Foundation Pair Kernel Atomic Tick Countermodels Lattice3 Generator Finite Range

The local generator theorem

In the Recognition Science framework, a ledger (a discrete record of recognition events) is built from local updates: at each tick, one site posts a recognition. The declaration lattice3Generator_finiteRangeOn is a proved theorem about a specific generator on a three-dimensional lattice. It states that the generator's weights, the numbers that determine how strongly one site influences another, are zero beyond a fixed radius. In plain terms, the theorem proves that the generator's direct influence is local: each site only talks to its immediate neighbors, not to the whole lattice.

The theorem is not a free-standing assumption. It is derived from two more basic ingredients. The first is an operational premise, LocalOperationalDependency3, which says that a site's dependency on other sites is bounded in the encoded three-dimensional metric. The second is a structural fact about the generator itself: its weights only use declared dependencies. The proof combines these to show that the weights satisfy the finite-range condition. The key formula is that the dependency radius is one, so the generator's weights vanish beyond a distance of one in the lattice metric.

This result is part of a larger effort to build a physical theory from recognition events. The framework's library, a machine-checked collection of formal theorems, uses this locality result as an export: it feeds into a metric property called FiniteRangeOn. The theorem itself is narrow. It does not claim that the generator's influence on the rest of the system is local. It only constrains the direct weights. Long-range effects, such as the response of the Green function, are deliberately left unconstrained by this result.

The theorem also comes with a countermodel. The framework shows that the current AtomicTick interface, which only says one site posts per tick, admits both a bounded local relation and an unbounded all-pairs relation with the same schedule. This means the interface alone cannot enforce locality. The new premise, LocalOperationalDependency3, is what selects the local behavior. The theorem lattice3Generator_finiteRangeOn is the payoff: given that premise and the generator's declared dependencies, the finite-range property follows.

What the theorem does not claim is just as important as what it proves. It does not prove that the three-dimensional geometry is forced by physics; that remains a target. It does not place any locality bound on the Green response or on long-distance influence. And it does not derive the fine-structure constant or any other coupling. The theorem is a clean, local statement about weights, and it earns its place by being exactly that.

/-- **Consumer-changing export.** Operational locality plus declared weight
support feeds the S2 metric export and proves `FiniteRangeOn` for the local
generator weights. No range predicate is placed on a Green response. -/
theorem lattice3Generator_finiteRangeOn (L : ℕ) :
    FiniteRangeOn
      (lattice3Generator L).graph (encodedDist3 L) 1 :=
  finiteRangeOn_export_v1
    (lattice3Generator_operationally_local L)
    (lattice3Generator L).weight_uses_dependency

/-- **Consumer-changing export.** Operational locality plus declared weight
support feeds the S2 metric export and proves `FiniteRangeOn` for the local
generator weights. No range predicate is placed on a Green response. -/
theorem lattice3Generator_finiteRangeOn (L : ℕ) :
    FiniteRangeOn
      (lattice3Generator L).graph (encodedDist3 L) 1 :=
  finiteRangeOn_export_v1
    (lattice3Generator_operationally_local L)
    (lattice3Generator L).weight_uses_dependency

/-- **Explicit local/global countermodels.** At every proposed radius, the
same constant posting schedule is valid for both a bounded local relation and
an unbounded all-pairs relation. Current `AtomicTick` therefore cannot select
generator locality. -/
theorem atomicTick_admits_local_and_global_dependency_models (radius : ℕ) :
    ∃ n : ℕ,
      Nonempty (AtomicTick (localRecognitionStructure n radius)) ∧
        BoundedRecognitionRelation
          (localRecognitionStructure n radius).R radius ∧
        Nonempty (AtomicTick (tickCarrier n)) ∧
        ¬ BoundedRecognitionRelation (tickCarrier n).R radius := by
  let n := radius + 2
  let s : ℕ → Fin n := fun _ => ⟨0, by simp [n]⟩
  refine ⟨n, ⟨localAtomicTick s⟩,
    localRecognitionStructure_bounded n radius, ⟨globalAtomicTick s⟩, ?_⟩
  intro hB
  have hi : (0 : ℕ) < n := by simp [n]
  have hj : radius + 1 < n := by simp [n]
  have hle :
      cellDist (⟨0, hi⟩ : Fin n) ⟨radius + 1, hj⟩ ≤ radius :=
    hB ⟨0, hi⟩ ⟨radius + 1, hj⟩ trivial
  have hdist :
      cellDist (⟨0, hi⟩ : Fin n) ⟨radius + 1, hj⟩ = radius + 1 := by
    simp only [cellDist, Nat.dist]
    omega
  omega

/-- On any nontrivial D=3 box, the all-pairs dependency is not radius-one
operational locality. This is the exclusion witness for the new premise. -/
theorem allPairsDependency_not_local3 (L : ℕ) (hL : 2 ≤ L) :
    ¬ LocalOperationalDependency3 L 1
      (allPairsDependency :
        Fin (L * L * L) → Fin (L * L * L) → Prop) := by
  intro hlocal
  let o : Site3 L :=
    ((⟨0, by omega⟩, ⟨0, by omega⟩), ⟨0, by omega⟩)
  let e : Site3 L :=
    ((⟨1, by omega⟩, ⟨1, by omega⟩), ⟨0, by omega⟩)
  have hle : encodedDist3 L (enc3 L o) (enc3 L e) ≤ 1 :=
    hlocal (enc3 L o) (enc3 L e) trivial
  have hdist : encodedDist3 L (enc3 L o) (enc3 L e) = 2 := by
    simp only [encodedDist3, Equiv.symm_apply_apply, dist3, o, e]
    unfold Nat.dist
    omega
  omega

What this page does not claim

The theorem does not prove that three-dimensional geometry is forced by physics. The theorem does not place any locality bound on the Green response or long-distance influence. The theorem does not derive the fine-structure constant or any other coupling constant.

Verify this page

Every tagged claim above names its theorem. To check one yourself rather than trust this page, elaborate the source module with Lean 4 and audit its axiom basis:

$ lake env lean IndisputableMonolith/Foundation/PairKernelAtomicTickCountermodels.lean
expected axiom basis: [propext, Classical.choice, Quot.sound] (the Lean kernel's standard three; no RS-specific axioms)

A page whose claims cannot be reproduced this way does not ship. In production, every anchor links to the exact declaration in the public source release, and this block carries the build receipt for the page itself.

Derived articles

This page is generated by a question-recursion engine: the questions its answers raise become the next pages. The current agenda, with open targets marked red: