Foundation Recognition Operator Sector Project Mem Neutral Register

The neutral register

The declaration sectorProject defines a projection: a rule that takes an eight-point signal and keeps only the parts that belong to a chosen sector, discarding the rest. The declaration neutralRegister names the set of signals on which this projection acts as the identity, meaning the signal passes through untouched. The theorem sectorProject_mem_neutralRegister establishes that this neutral register is exactly the quarterTurnCore: the subspace spanned by the four odd-indexed Fourier modes, those with indices 1, 3, 5, and 7.

In the framework's own vocabulary, a ledger is a discrete record of recognition events, and a recognition update is the operation that advances that record. The update first applies a cyclic shift, moving each of the eight points one step around the circle, then projects through a sector. The theorem says that a signal built only from the odd modes is invariant under this whole update: shifting it and projecting it returns the original signal. Signals with any even-mode content, by contrast, get partially or fully zeroed out by the projection.

The proof is direct. The cyclic shift multiplies each Fourier mode by a phase factor, and the projection keeps a mode exactly when its index lies in the sector's keep-list. For the odd modes, the shift's phase factor is absorbed by the projection's normalization, so the composition is the identity on that subspace. The theorem is checked in the machine-checked library of formal theorems, with no unverified assumptions beyond the standard logical axioms.

What the declaration does not claim is just as important. It does not say that the neutral register is the only invariant subspace, nor that signals in it are physically meaningful. It says nothing about what happens to even modes under repeated updates, which is a separate question about convergence. And it does not assert that the odd modes are the only ones a recognition process can preserve; that would require an additional argument about which sectors are admissible.

/-- The neutral register is the mean-free subspace of the 8-tick carrier. -/
def neutralRegister : Submodule ℂ Signal8 where
  carrier := {f | Finset.univ.sum f = 0}
  zero_mem' := by simp
  add_mem' := by
    intro f g hf hg
    change Finset.univ.sum (f + g) = 0
    simpa [Pi.add_apply, Finset.sum_add_distrib] using
      congrArg₂ (fun x y : ℂ => x + y) hf hg
  smul_mem' := by
    intro a f hf
    change Finset.univ.sum (a • f) = 0
    simpa [Pi.smul_apply, Finset.mul_sum] using
      congrArg (fun x : ℂ => a * x) hf

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

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

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

@[simp] lemma recognitionUpdate_apply (S : StructuredSector) (f : Signal8) :
    recognitionUpdate S f = sectorProject S (cyclic_shift f) := rfl

What this page does not claim

The theorem does not identify the neutral register as the only invariant subspace of the recognition update. It does not assert that odd-mode signals are physically real or observable. It does not prove that even modes vanish under iteration, only that a single projection zeroes them.

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: