Foundation Pair Kernel Tick Locality

What the tick schedule cannot force

In Recognition Science, a ledger is a discrete record of events, and an atomic tick is its smallest time step: exactly one site posts at each tick. A natural guess is that this one-post-per-tick rule forces a kind of locality, so that a recognition event only couples sites that are adjacent in the posting order. The module PairKernelTickLocality closes that question with a negative result: the atomic tick schedule does not force any spatial range cutoff. The temporal rule and the spatial coupling graph are independent.

The decisive fact is that the atomic tick condition is satisfied by every posting sequence. If you choose any function that assigns a site to each tick, that function trivially has exactly one post per tick. The formal library proves this with a definition that turns any sequence into a valid atomic tick instance. Because the condition is so weak, it places no constraint on which pairs of sites carry nonzero weight in the coupling graph. A schedule could post site 0 at tick 0 and site n-1 at every later tick; the first two consecutive posts are then index-maximally separated, so tick adjacency is not index adjacency.

The module builds a null test to make the point concrete. For any fixed radius R, it constructs a carrier with R+2 sites that admits a valid atomic tick instance, while its all-to-all mean-field weight graph fails to be finite-range at radius R. This is a decoy: a system that satisfies the temporal rule yet couples every site to every other site. The theorem atomicTick_finiteRange_provenance_closed_negative bundles all three facts at once: a valid atomic tick exists, the mean-field graph is not finite-range, and consecutive posts can be maximally separated. The route from the tick schedule to a locality theorem is closed.

In Recognition Science, the locality cutoff must come from the spatial recognition relation, not from the temporal primitive. The framework's structure carries a relation R that defines which sites are neighbors, and a local coupling graph called bandWeight already satisfies the finite-range property at radius 1. The open work is deriving that the recognition relation itself is finite-neighborhood. The module does not claim locality is impossible; it claims the tick schedule is the wrong place to look for it.

/-- Any posting sequence `s : ℕ → Fin n` is a valid `AtomicTick` schedule on `tickCarrier n`.
    `unique_post` holds for *every* `s`, so atomic-tick validity carries no adjacency/range content. -/
def scheduleAtomicTick {n : ℕ} (s : ℕ → Fin n) : AtomicTick (tickCarrier n) where
  postedAt := fun t u => u = s t
  unique_post := by
    intro t
    refine ⟨s t, rfl, ?_⟩
    intro u hu
    exact hu

/-- **Null test / decoy.** For every radius `R`, a carrier of size `R + 2` carries a valid
    `AtomicTick` instance while its all-to-all mean-field weight graph fails `FiniteRange R`.
    Atomic-tick validity does not make the weight graph finite-range. -/
theorem atomicTick_does_not_force_finiteRange (R : ℕ) :
    ∃ n : ℕ, Nonempty (AtomicTick (tickCarrier n)) ∧ ¬ FiniteRange (meanFieldWeight n) R := by
  refine ⟨R + 2, ⟨scheduleAtomicTick (fun _ => ⟨0, by omega⟩)⟩, ?_⟩
  exact meanFieldWeight_not_finiteRange R (R + 2) (le_refl _)

/-- The first two (tick-adjacent) posts of `maxSeparatedSchedule` are index-maximally separated:
    `cellDist (s 0) (s 1) = n − 1`. Tick-adjacency is not index-adjacency. -/
theorem maxSeparatedSchedule_consecutive_maximally_separated (n : ℕ) (hn : 2 ≤ n) :
    cellDist (maxSeparatedSchedule n hn 0) (maxSeparatedSchedule n hn 1) = n - 1 := by
  have h0 := maxSeparatedSchedule_val_zero n hn
  have h1 := maxSeparatedSchedule_val_one n hn
  unfold cellDist Nat.dist
  rw [h0, h1]
  omega

/-- **L0 provenance verdict (bundle).** At carrier size `n = R + 2` all three facts hold at once:
    (1) a valid `AtomicTick` instance exists, (2) the all-to-all mean-field weight graph fails
    `FiniteRange R` (the null test), and (3) a valid `AtomicTick` schedule posts index-maximally
    separated sites at consecutive ticks (`cellDist (s 0) (s 1) = n − 1 = R + 1`). Together:
    atomic-tick posting adjacency does not force `FiniteRange`; the route to a THEOREM-grade `L0`
    via the tick schedule is CLOSED NEGATIVE. `L0` stays HYPOTHESIS, its provenance the spatial
    coupling geometry (`M.R` / lattice adjacency), not the temporal tick primitive. -/
theorem atomicTick_finiteRange_provenance_closed_negative (R : ℕ) :
    Nonempty (AtomicTick (tickCarrier (R + 2))) ∧
      ¬ FiniteRange (meanFieldWeight (R + 2)) R ∧
      cellDist (maxSeparatedSchedule (R + 2) (by omega) 0)
          (maxSeparatedSchedule (R + 2) (by omega) 1) = R + 1 := by
  refine ⟨⟨scheduleAtomicTick (maxSeparatedSchedule (R + 2) (by omega))⟩,
    meanFieldWeight_not_finiteRange R (R + 2) (le_refl _), ?_⟩
  have h := maxSeparatedSchedule_consecutive_maximally_separated (R + 2) (by omega)
  simpa using h

What this page does not claim

This module does not claim that locality is impossible in Recognition Science. This module does not claim that the mean-field weight graph is the only possible coupling. This module does not derive any specific range cutoff from the recognition relation R.

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