Foundation Recognition Operator Shift Four Eq Neg On Quarter Turn Core

The quarter-turn sign flip

In the Recognition Science framework, a ledger (a discrete record of events) is represented as a vector of eight complex numbers, called a Signal8. The framework's central operator, the recognition operator (the map that advances a ledger state by one recognition event), applies a cyclic shift to this vector, moving each entry one position forward and wrapping the last entry to the front. A theorem in the framework's machine-checked library of formal theorems proves that applying this cyclic shift four times to any signal lying in a specific subspace, called the quarter-turn core, yields the negative of the original signal.

The quarter-turn core is the subspace spanned by the four odd-indexed Fourier modes of the eight-point discrete Fourier transform. These are the modes with indices 1, 3, 5, and 7, the ones that oscillate with odd frequencies. The theorem, named shift_four_eq_neg_on_quarterTurnCore, states that for any signal f in this core, the fourth iterate of the cyclic shift equals -f. In plain terms, four applications of the shift produce a sign flip: every component of the vector is multiplied by -1, while the pattern of the signal remains otherwise unchanged.

This result is a purely algebraic fact about the cyclic group of order eight acting on a four-dimensional complex subspace. It holds because the fourth power of the eighth root of unity, omega8, is -1, so shifting an odd-frequency mode four times multiplies it by -1. The theorem is proved in the Lean 4 proof assistant, with the declaration audited to the kernel's standard axioms and no framework-specific axioms. It is a theorem about the discrete structure of the framework's signal space, not a claim about physical space or time.

What the theorem does not claim is equally precise. It does not assert that four recognition events in the physical world produce a sign flip; the framework's bridge from recognition events to physical space and time is a separate, open question. It does not claim that the shift operator itself is the recognition operator; the recognition operator also includes a projection onto a structured sector after the shift. And it does not claim that the sign flip applies to all signals, only to those in the quarter-turn core. The theorem is a structural fact about the framework's discrete signal space, and its physical interpretation, if any, remains a target for future work.

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

/-- 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 DFT mode is an eigenvector of each iterate of the shift. -/
lemma cyclicShiftIter_mode (n : ℕ) (k : Fin 8) :
    cyclicShiftIter n (dft8_mode k) = (omega8 ^ k.val) ^ n • dft8_mode k := by
  induction n with
  | zero =>
      ext t
      simp [cyclicShiftIter]
  | succ n ih =>
      calc
        cyclicShiftIter (n + 1) (dft8_mode k)
            = cyclic_shift (cyclicShiftIter n (dft8_mode k)) := rfl
        _ = cyclic_shift ((omega8 ^ k.val) ^ n • dft8_mode k) := by rw [ih]
        _ = (omega8 ^ k.val) ^ n • cyclic_shift (dft8_mode k) := by
              ext t
              simp [cyclic_shift]
        _ = (omega8 ^ k.val) ^ n • ((omega8 ^ k.val) • dft8_mode k) := by
              rw [dft8_shift_eigenvector]
        _ = (omega8 ^ k.val) ^ (n + 1) • dft8_mode k := by
              ext t
              simp [pow_succ, mul_assoc]

What this page does not claim

The theorem does not claim that four recognition events in the physical world produce a sign flip. The theorem does not claim that the shift operator alone is the recognition operator, which also includes a sector projection. The theorem does not claim that the sign flip applies to all signals, only to those in the quarter-turn core.

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: