Foundation Pair Kernel Bounded Coupling Box Weight Finite Range On Export V1

What the export proves

In the Recognition Science framework, a ledger is a discrete record of events, and the framework's core objects are graphs whose edges carry weights. A natural question is whether those weights are local: does a pair of sites interact only when they are close together, or can distant sites influence each other directly? The declaration boxWeight_finiteRangeOn_export_v1 answers that question for one specific, committed geometry.

The setting is a three-dimensional lattice, a cubic grid of points indexed by triples of natural numbers. The boxWeight rule assigns a nonzero weight to a pair of sites exactly when their distance in the grid, measured by the Manhattan metric (the sum of absolute coordinate differences), is at most 1. That means only nearest neighbors interact. The theorem proves this formally: for any lattice size L, the weight rule is finite-range with respect to that metric and radius 1. In plain terms, the proof establishes that the boxWeight rule is strictly local on the three-dimensional lattice it was designed for.

The proof is not a free-standing result. It relies on two ingredients that are also proved in the same module. First, the recognition relation for the lattice, which declares which pairs are allowed to interact, is bounded: it only relates sites within distance 1. Second, the boxWeight rule is supported on that relation: every nonzero weight sits on a pair that the relation allows. From those two facts, the export theorem derives the finite-range conclusion. The proof is machine-checked, meaning a computer program verified every logical step, with no gaps and no unproven assumptions beyond the standard axioms of the underlying type theory.

What the declaration does not claim is just as important. It does not prove that finite-range behavior is forced by the bare recognition structure of the framework. In fact, a separate theorem in the same module shows the opposite: there exist valid recognition structures with atomic ticks whose weights are not bounded and not finite-range. The boxWeight result holds only because the three-dimensional lattice geometry was deliberately committed to, not because it was derived from deeper principles. The framework names this remaining step ProductionLatticeCouplingObligation: forcing or committing that production weights are supported on a metric-bounded relation equivalent to this lattice geometry. Until that premise is established, the global finite-range property in one dimension remains an open hypothesis.

The practical consequence is a clear boundary. Within the committed three-dimensional lattice model, the framework has a theorem-grade guarantee that boxWeight is local. Outside that model, the general question of whether recognition forces locality is not settled. This export gives the framework a solid local foundation for the three-dimensional case while honestly marking the broader claim as unfinished business.

/-- **D=3 inhabitant of the metric export.** Under the committed lattice
geometry, nonzero box weights force `FiniteRangeOn` at radius 1. -/
theorem boxWeight_finiteRangeOn_export_v1 (L : ℕ) :
    BoundedRecognitionRelationOn
        (lattice3RecognitionRelation L) (encodedDist3 L) 1 ∧
      RelationSupportsWeightOn (lattice3RecognitionRelation L) (boxWeight L) ∧
        FiniteRangeOn (boxWeight L) (encodedDist3 L) 1 :=
  ⟨lattice3RecognitionRelation_bounded L,
    boxWeight_supported_on_lattice3 L,
    finiteRangeOn_export_v1
      (lattice3RecognitionRelation_bounded L)
      (boxWeight_supported_on_lattice3 L)⟩

theorem lattice3RecognitionRelation_bounded (L : ℕ) :
    BoundedRecognitionRelationOn
      (lattice3RecognitionRelation L) (encodedDist3 L) 1 := by
  intro i j hR
  exact hR

theorem boxWeight_supported_on_lattice3 (L : ℕ) :
    RelationSupportsWeightOn (lattice3RecognitionRelation L) (boxWeight L) := by
  intro i j hne
  dsimp [lattice3RecognitionRelation, encodedDist3]
  change (if dist3 ((enc3 L).symm i) ((enc3 L).symm j) ≤ 1 then (1 : ℝ) else 0) ≠ 0 at hne
  split_ifs at hne with hle
  · exact hle
  · exact (hne rfl).elim

/-- **THEOREM (closed negative).** Bare `RecognitionStructure` (via
`tickCarrier`, whose `R` is all-true) plus a valid `AtomicTick` coexist with
mean-field weights that fail both `BoundedRecognitionRelation` and
`FiniteRange`. This is the Lean form of the season-1 obstruction. -/
theorem recognitionStructure_atomicTick_do_not_force_boundedCoupling
    (radius : ℕ) :
    ∃ n : ℕ,
      Nonempty (AtomicTick (tickCarrier n)) ∧
        ¬ BoundedRecognitionRelation (tickCarrier n).R radius ∧
          RelationSupportsWeight (tickCarrier n).R (meanFieldWeight n) ∧
            ¬ FiniteRange (meanFieldWeight n) radius := by
  refine ⟨radius + 2, ⟨scheduleAtomicTick (fun _ => ⟨0, by omega⟩)⟩, ?_,
    meanFieldWeight_supported_on_unconstrained (radius + 2),
    meanFieldWeight_not_finiteRange radius (radius + 2) (le_refl _)⟩
  intro hB
  have hi : (0 : ℕ) < radius + 2 := Nat.succ_pos _
  have hj : radius + 1 < radius + 2 := Nat.lt_succ_self _
  have hle :
      cellDist (⟨0, hi⟩ : Fin (radius + 2)) ⟨radius + 1, hj⟩ ≤ radius :=
    hB ⟨0, hi⟩ ⟨radius + 1, hj⟩ trivial
  have hdist :
      cellDist (⟨0, hi⟩ : Fin (radius + 2)) ⟨radius + 1, hj⟩ = radius + 1 := by
    simp only [cellDist, Nat.dist]
    omega
  omega

What this page does not claim

The theorem does not prove that finite-range behavior is forced by the bare recognition structure. The theorem does not establish the global FiniteRange property in one dimension. The theorem does not identify the boxWeight rule with any specific physical interaction.

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/PairKernelBoundedCoupling.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: