Foundation Recognition Operator Quarter Turn Core Le Neutral Register

The quarter-turn core

In the Recognition Science framework, a ledger, a discrete record of events, is represented as an eight-component complex signal. The framework's library, a machine-checked collection of formal theorems, studies how such signals evolve under a cyclic shift, a step that moves each component one position forward. The quarter-turn core is the span of the four odd-indexed Fourier modes of this eight-point signal. In plainer terms, it is the subspace generated by the signal's four highest-frequency patterns, the ones that oscillate most rapidly across the eight positions.

The declaration quarterTurnCore_le_neutralRegister establishes a containment: every signal in the quarter-turn core also belongs to the neutral register, the subspace defined as the set of admissible ledger states. The library proves this as a theorem, and the same containment is what makes the neutral register a meaningful target for the recognition update. The update rule first applies the cyclic shift, then projects the result onto a chosen sector. The theorem sectorProject_eq_id_on_quarterTurnCore shows that for any sector, this projection leaves signals in the quarter-turn core unchanged. So the containment means that the high-frequency patterns are exactly the ones that survive the update untouched; they are the stable, neutral states of the ledger.

The quarter-turn name comes from the shift behavior. The library proves that shifting a signal in the core four times produces its negation, shift_four_eq_neg_on_quarterTurnCore. A fourth of a full eight-step cycle reverses the signal, and a full cycle of eight shifts returns it to itself. This is the discrete analogue of a rotation by 90 degrees in a two-dimensional plane, where four quarter-turns give a full rotation. The framework models this as the fundamental period of recognition: eight ticks, with the quarter-turn core as the set of states that oscillate with the shortest period.

What the declaration does not claim is just as important. It does not say that the neutral register equals the quarter-turn core; it only says the core is contained in the register. The register may contain other, lower-frequency states. It does not claim that every admissible ledger state is stable under the update; only the core's states are provably left unchanged by the projection. And it says nothing about what happens outside the core, where the projection can and does alter the signal. The theorem is a structural fact about one subspace, not a description of the full dynamics.

In Recognition Science, this containment is one of the load-bearing pieces that connects the discrete ledger picture to the framework's eight-tick cycle. It identifies the states that carry the purest oscillatory behavior and shows they are exactly the ones the framework treats as neutral. The practical consequence is that the framework can reason about stability and periodicity in a finite, machine-checked setting, without needing to track the full eight-dimensional space.

/-- The quarter-turn core is the span of the odd DFT modes. -/
def quarterTurnCore : Submodule ℂ Signal8 :=
  Submodule.span ℂ {m | ∃ k : Fin 8, Odd k.val ∧ m = dft8_mode k}

/-- Admissibility on the analytic carrier: membership in the neutral register
(mean-free / DC-free). The retired ledger meaning was σ-balance
(`net_skew = 0` / vanishing reciprocity skew). That meaning cannot be stated
for real here: `LedgerState` is `Signal8`, and the bond/skew readouts above
are constant stubs. Neutral-register membership is the only non-trivial
balance predicate this carrier supports. -/
def admissible (s : LedgerState) : Prop := s ∈ neutralRegister

/-- Four shifts act as `-I` on the quarter-turn core. This is the concrete
`P^4 = -I` statement used in the paper. -/
theorem shift_four_eq_neg_on_quarterTurnCore {f : Signal8} (hf : f ∈ quarterTurnCore) :
    cyclicShiftIter 4 f = -f := by
  refine Submodule.span_induction ?_ ?_ ?_ ?_ hf
  · intro m hm
    rcases hm with ⟨k, hkodd, rfl⟩
    rw [cyclicShiftIter_mode, odd_mode_fourth_eigenvalue k hkodd]
    ext t
    simp
  · ext t
    simp [cyclicShiftIter, cyclic_shift]
  · intro x y hx hy hpx hpy
    calc
      cyclicShiftIter 4 (x + y) = cyclicShiftIter 4 x + cyclicShiftIter 4 y := cyclicShiftIter_add 4 x y
      _ = -x + -y := by rw [hpx, hpy]
      _ = (-1 : ℂ) • x + (-1 : ℂ) • y := by simp
      _ = (-1 : ℂ) • (x + y) := by rw [smul_add]
      _ = -(x + y) := by
            ext t
            simp [smul_eq_mul]
  · intro a x hx hpx
    calc
      cyclicShiftIter 4 (a • x) = a • cyclicShiftIter 4 x := cyclicShiftIter_smul 4 a x
      _ = a • (-x) := by rw [hpx]
      _ = -(a • x) := by simp

/-- Every structured-sector projector fixes the quarter-turn core pointwise. -/
theorem sectorProject_eq_id_on_quarterTurnCore (S : StructuredSector) :
    ∀ {f : Signal8}, f ∈ quarterTurnCore → sectorProject S f = f := by
  intro f hf
  refine Submodule.span_induction ?_ ?_ ?_ ?_ hf
  · intro m hm
    rcases hm with ⟨k, hkodd, rfl⟩
    have hk : k ∈ S.keepModes := S.odd_modes_included hkodd
    simpa [sectorProject_mode, hk] using sectorProject_mode S k
  · exact map_zero (sectorProject S)
  · intro x y hx hy hpx hpy
    calc
      sectorProject S (x + y) = sectorProject S x + sectorProject S y := by
        exact map_add (sectorProject S) x y
      _ = x + y := by rw [hpx, hpy]
  · intro a x hx hpx
    calc
      sectorProject S (a • x) = a • sectorProject S x := by
        exact map_smul (sectorProject S) a x
      _ = a • x := by rw [hpx]

What this page does not claim

The neutral register equals the quarter-turn core; the theorem only proves containment. The recognition update leaves every admissible ledger state unchanged; only core states are provably stable. The quarter-turn core is the only subspace with this stability property under the update.

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