Foundation Pair Kernel Tick Locality Max Separated Schedule Val Zero

The temporal tick and spatial coupling

In the Recognition Science framework, a recognition event is a discrete record of one site in a system posting a signal at one moment, called a tick. The framework's ledger, a discrete record of such events, is built from these ticks. The question at hand is whether the simple rule that exactly one site posts per tick, called an atomic tick, can by itself force a limit on which pairs of sites can be coupled, a property known as finite range. The declaration maxSeparatedSchedule_val_zero is a small but decisive piece of the answer: it proves that a schedule can post site 0 at tick 0, and then post the site with the largest possible index at every later tick.

This theorem, proved in the machine-checked library of formal theorems, is part of a larger negative result. The framework shows that the atomic-tick rule is satisfied by every possible posting sequence, so it places no constraint on which pairs of sites carry nonzero weight in the coupling graph. The maxSeparatedSchedule construction makes this concrete: its first two posts, which are adjacent in time, are separated in index by the maximum possible distance n - 1 on a carrier of n sites. The theorem maxSeparatedSchedule_val_zero simply states that the first post is site 0, and its companion maxSeparatedSchedule_val_one states that the second post is site n - 1. Together they show that tick-adjacency does not imply index-adjacency.

The consequence is that the locality cutoff, the property that only nearby sites couple, cannot be derived from the temporal schedule. It must come from the spatial geometry of the recognition relation itself, the structure that defines which sites are neighbors. The framework's library proves that a local coupling graph called bandWeight does satisfy finite range, so the concept is coherent. But the atomic-tick primitive alone cannot force a system into that local case rather than the all-to-all mean-field case. The claim that atomic ticks force finite range is therefore closed as a negative result, and the provenance of locality remains an open hypothesis tied to the spatial relation, not the tick order.

theorem maxSeparatedSchedule_val_zero (n : ℕ) (hn : 2 ≤ n) :
    (maxSeparatedSchedule n hn 0).val = 0 := by
  simp [maxSeparatedSchedule]

/-- **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

The theorem does not claim that finite range is false or impossible; it only shows atomic ticks do not force it. The theorem does not claim that no schedule can be index-local; it shows the atomic-tick rule does not require it. The theorem does not claim anything about the physical origin of the recognition relation's geometry.

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: