Foundation Pair Kernel Operational Locality S4

Operational locality in the framework

In Recognition Science, the ledger, a discrete record of recognition events, evolves by postings, single changes to its entries. The framework's central cost function, J, assigns a price to every possible transition between ledger states. A foundational theorem, proved in the machine-checked library of formal theorems, states that a transition of minimum J cost is always a posting that flips exactly one bit in the ledger's parity pattern. This is the one-bit motion principle: the cheapest legal step is always a single, local change.

The module called foundation pair kernel operational locality s4 takes this one-bit principle and transports it into a translated three-dimensional unit cell. It defines a dependency relation between cells: one cell depends on another if a minimum-J posting in the first cell can produce a change in the second. The key theorem, tiledJMinimalDependency3_operationally_local, proves that this dependency relation is operational, meaning it is defined by realizable minimum-J posting transitions, not by an arbitrary range cutoff or a generator support assumption. In plain terms, the framework proves that the only dependencies that can actually occur are those between cells that are adjacent in the translated grid, at distance one.

The module also records exact countermodels for weaker candidate routes. It shows that balanced conservation, shift-invariant J-cost, an eight-tick D=3 identity, and a valid atomic tick can all coexist with an all-pairs dependency relation, where every cell depends on every other cell. These conditions, on their own, do not force locality. The countermodels are precise: they exhibit explicit ledger states and cost functions satisfying the weaker axioms while violating operational locality. This sharpens the result: locality is not a consequence of conservation or symmetry alone, but specifically of the minimum-J posting semantics.

What this establishes, in the framework's own terms, is that spatial locality in three dimensions is not assumed but derived from the cost structure. The dependency relation that the framework uses to build space is the one that minimum-J postings actually generate. The module proves that this relation is finite-range, meaning each cell depends only on cells within a bounded distance, and that separated cells have disjoint dependency sets. This is the bridge from the one-bit motion principle to a three-dimensional spatial structure with local interactions.

For a reader outside the framework, the significance is that the framework offers a proof, not a postulate, for why physical interactions are local. The classical assumption that forces act only between nearby objects is here a theorem about the cost of recognition. The module does not claim to derive all of physics; it establishes one precise structural fact: in the framework's ledger semantics, operational locality is forced by the minimum-J posting rule, and weaker conditions do not suffice.

/-- The committed J-cost theorem turns a minimum-J transition into exactly
one bit of parity motion. -/
theorem jMinimalPostingStep_oneBitDiff
    {A B : LedgerState 3}
    (h : JMinimalPostingStep A B) :
    OneBitDiff (parity 3 A) (parity 3 B) := by
  have hpost : PostingStep A B :=
    minJlogCost_monotoneStep_implies_postingStep
      h.1 h.2.1 h.2.2
  exact postingStep_oneBitDiff hpost

/-- **S4 locality theorem.** The operational dependency induced by minimum-J
posting in translated D=3 cells satisfies `LocalOperationalDependency3`
at radius one. The theorem is exact on the account-axis MODEL identification;
production selection of that identification remains the physical hard fork. -/
theorem tiledJMinimalDependency3_operationally_local
    {L : ℕ} (hL : 2 ≤ L) :
    LocalOperationalDependency3 L 1 (TiledJMinimalDependency3 hL) := by
  intro i j hij
  rcases hij with ⟨origin, A, B, hstep, rfl, rfl⟩
  have hdist :
      dist3
        (patternAtCell hL origin (parity 3 A))
        (patternAtCell hL origin (parity 3 B)) = 1 := by
    rw [patternAtCell_dist3]
    exact oneBitDiff_patternDist3
      (jMinimalPostingStep_oneBitDiff hstep)
  simpa only [encodedDist3, Equiv.symm_apply_apply] using hdist.le

/-- Atomicity, balanced conservation, shift-invariant J-cost, period eight,
D=3, and a nontrivial distinction all coexist with an all-pairs dependency.
Thus none of those scalar or temporal declarations chooses spatial locality. -/
theorem committed_candidate_routes_admit_allPairs :
    Nonempty (AtomicTick (tickCarrier 8)) ∧
      Conserves (globalBalancedLedger 8) ∧
      ShiftInvariant (meanFieldLedgerCost 8) ∧
      EightTickFromDimension 3 = eight_tick ∧
      (∃ a b : Fin (2 * 2 * 2), a ≠ b) ∧
      ¬ LocalOperationalDependency3 2 1
        (allPairsDependency :
          Fin (2 * 2 * 2) → Fin (2 * 2 * 2) → Prop) := by
  refine ⟨⟨globalAtomicTick (fun _ => 0)⟩,
    globalBalancedLedger_conserves 8,
    meanFieldLedgerCost_shift_invariant 8,
    rfl, ?_, allPairsDependency_not_local3 2 (by omega)⟩
  exact ⟨0, 1, by decide⟩

/-- Consumer-changing export: any generator whose nonzero weights are
realizable minimum-J translated-cell dependencies is finite-range at one
D=3 lattice step. -/
theorem tiledJMinimalGenerator_finiteRangeOn
    {L : ℕ} (hL : 2 ≤ L)
    (G : WeightedLedgerGraph (L * L * L))
    (hSupport :
      ∀ i j, G.weight i j ≠ 0 →
        TiledJMinimalDependency3 hL i j) :
    FiniteRangeOn G (encodedDist3 L) 1 :=
  finiteRangeOn_export_v1
    (tiledJMinimalDependency3_operationally_local hL)
    hSupport

What this page does not claim

This module does not derive the fine-structure constant or any specific coupling constant. It does not prove that all physically realizable dependencies in the framework are local, only those generated by minimum-J postings. It does not claim that balanced conservation or shift-invariance alone imply locality; the countermodels show the opposite.

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