Foundation Complex Structure Forcing Dft Basis Is Tick Eigenvector

The tick shift and its eigenvectors

The discrete Fourier transform (DFT) is a standard tool that breaks a periodic signal into a sum of pure frequency components. For a signal with eight equally spaced samples, the eight basis vectors of the DFT are the sequences of eighth roots of unity, complex numbers of the form e^(2πik/8). Each basis vector is a pure oscillation at one of eight frequencies, and the DFT simply expresses any signal as a weighted sum of these oscillations.

The Recognition Science framework models reality as a ledger, a discrete record of recognition events, and its eight-tick cycle is a fundamental period. The framework defines an operator called the tick shift, which moves a signal one step forward in time. After eight shifts, any signal returns to itself, because the cycle has eight positions. The framework's library of machine-checked theorems proves that each of the eight DFT basis vectors is an eigenvector of this shift operator: shifting a pure oscillation by one tick multiplies it by a single complex number, its eigenvalue. This is the declaration dftBasis_is_tick_eigenvector.

The content of this theorem is a standard fact about the DFT and cyclic shifts. The new content is that the framework's own axioms force this structure. The framework's cost function, which assigns a price to each recognition event, is proved to depend only on the magnitude of a signal's components, not on their phase. This phase invariance is what makes the complex numbers the natural arena: the cost cannot distinguish a signal from a version of it with all phases rotated. The framework proves that the shift operator cannot be diagonalized using only real numbers, because one of its eigenvalues is the imaginary unit i, which has no real square root. The extension to complex numbers is therefore forced by the framework's own postulates, not chosen for convenience.

In Recognition Science, this result closes a gap between the cost axioms and the complex Hilbert-space structure needed for genuine unitarity. The DFT basis provides the coordinate system in which the tick shift is diagonal, and the framework proves that this basis preserves the inner product, meaning it is a unitary transformation. The framework's library shows that the total cost of a signal is invariant under changing the phases of its components, which is consistent with the shift operator being unitary. This is a structural result: it says that the framework's account of time evolution is naturally expressed in the language of complex numbers and Fourier analysis.

What this theorem does not claim is that the framework derives the DFT from first principles in the sense of inventing it. The DFT is a classical mathematical object with a well-known definition. The framework's contribution is to show that its own axioms force the use of complex numbers and that the DFT basis is the correct coordinate system for its tick shift. The theorem also does not claim that the framework's cost function is the only possible one, or that the framework's axioms are the only way to arrive at the DFT. It is a statement about the internal consistency of the framework, not about the uniqueness of the DFT as a mathematical object.

/-- The local DFT vectors are tick eigenvectors over `ℂ`. -/
theorem dftBasis_is_tick_eigenvector (k : Fin 8) :
    shift (dftBasis k) = eigenvalue k • dftBasis k := by
  funext j
  simp only [shift, dftBasis, eigenvalue, nextIdx, Pi.smul_apply, smul_eq_mul]
  have hzk : (ζ ^ k.val) ^ 8 = 1 := by
    rw [← pow_mul, mul_comm, pow_mul, ζ_pow_8, one_pow]
  calc
    ζ ^ (k.val * ((j.val + 1) % 8))
        = (ζ ^ k.val) ^ ((j.val + 1) % 8) := by rw [← pow_mul]
    _ = (ζ ^ k.val) ^ ((j.val + 1) % 8 + 8 * ((j.val + 1) / 8)) := by
      rw [pow_add, pow_mul, hzk, one_pow, mul_one]
    _ = (ζ ^ k.val) ^ (j.val + 1) := by rw [Nat.mod_add_div]
    _ = ζ ^ (k.val * (j.val + 1)) := by rw [← pow_mul]
    _ = ζ ^ (k.val * j.val + k.val) := by rw [Nat.mul_succ]
    _ = ζ ^ k.val * ζ ^ (k.val * j.val) := by
      rw [pow_add]
      ring

/-- **THEOREM (Complexification is Forced)**:
    The shift operator T on Signal8 has eigenvalue i (at k=2).
    Since i is not real (no real x satisfies x² + 1 = 0), the eigenspace
    decomposition of T REQUIRES ℂ. Working over ℝ alone, T can only
    be block-diagonalized into 2×2 rotation matrices — it cannot
    be fully diagonalized.

    This is the core theorem: the 8-tick forces ℂ. -/
theorem complexification_forced :
    (∃ k : Fin 8, eigenvalue k = Complex.I) ∧
    (∀ x : ℝ, x ^ 2 + 1 ≠ 0) := by
  exact ⟨⟨⟨2, by norm_num⟩, eigenvalue_2_is_I⟩, x2_plus_1_no_real_root⟩

/-- No real basis of the 8-register consists entirely of one-dimensional tick eigenstates. -/
theorem no_real_tick_eigenbasis :
    ¬ (∃ (b : Module.Basis (Fin 8) ℝ RealSignal8) (mu : Fin 8 → ℝ),
        ∀ k, realShift (b k) = mu k • b k) := by
  classical
  rintro ⟨b, mu, hb⟩
  let W : Submodule ℝ RealSignal8 :=
    { carrier := {v | v (2 : Fin 8) = v 0}
      zero_mem' := rfl
      add_mem' := by
        intro x y hx hy
        have hx' : x (2 : Fin 8) = x 0 := hx
        have hy' : y (2 : Fin 8) = y 0 := hy
        show x (2 : Fin 8) + y (2 : Fin 8) = x 0 + y 0
        rw [hx', hy']
      smul_mem' := by
        intro c x hx
        have hx' : x (2 : Fin 8) = x 0 := hx
        show c • x (2 : Fin 8) = c • x 0
        rw [hx'] }
  have hbW : Set.range (fun k => b k) ⊆ W := by
    rintro v ⟨k, rfl⟩
    have hper := realShift_eigenvector_two_periodic (mu k) (b k) (b.ne_zero k) (hb k) 0
    simpa [W, nextIdx] using hper
  have hspan_le : Submodule.span ℝ (Set.range fun k => b k) ≤ W :=
    Submodule.span_le.mpr hbW
  have htop_le : (⊤ : Submodule ℝ RealSignal8) ≤ W := by
    simpa [Module.Basis.span_eq] using hspan_le
  have hWtop : W = ⊤ := le_antisymm le_top htop_le
  let e0 : RealSignal8 := Pi.single (0 : Fin 8) (1 : ℝ)
  have he0_mem : e0 ∈ W := by
    rw [hWtop]
    trivial
  have he0_not_mem : e0 ∉ W := by
    intro he
    have h20 : (2 : Fin 8) ≠ 0 := by decide
    simpa [W, e0, h20] using he
  exact he0_not_mem he0_mem

/-- **THEOREM (Phase Invariance of J-Cost)**:
    J(‖z‖) = J(‖z·e^{iθ}‖) for any phase θ.
    The cost functional depends ONLY on the modulus, not the phase.
    This is the root cause of the Born rule: P = |ψ|² is the unique
    probability function that respects cost-phase invariance. -/
theorem jcost_phase_invariant (z : ℂ) (θ : ℝ) :
    JcostC z = JcostC (z * Complex.exp (↑θ * Complex.I)) := by
  simp only [JcostC]
  congr 1
  rw [norm_mul]
  have : ‖Complex.exp (↑θ * Complex.I)‖ = 1 := by
    rw [Complex.norm_exp_ofReal_mul_I]
  rw [this, mul_one]

/-- **THEOREM (Mode Cost is Phase-Invariant)**:
    Rotating each mode by an independent phase does not change
    the total cost. This means the cost landscape has a U(1)⁸
    gauge symmetry in the mode basis.

    Combined with the norm constraint, this forces the dynamics
    to be unitary: any cost-preserving, norm-preserving linear
    map on ℂ⁸ is unitary. -/
theorem mode_cost_phase_invariant (f : Signal8) (phases : Fin 8 → ℝ) :
    totalModeCost f =
    totalModeCost (fun k => f k * Complex.exp (↑(phases k) * Complex.I)) := by
  simp only [totalModeCost]
  congr 1; ext k; congr 1
  rw [norm_mul, Complex.norm_exp_ofReal_mul_I, mul_one]

/-- **COROLLARY**: The DFT-8 preserves the norm: ‖F(f)‖² = ‖f‖². -/
theorem dft8_preserves_norm (f : Signal8) :
    inner8 (dft8 f) (dft8 f) = inner8 f f :=
  dft8_preserves_inner f f

What this page does not claim

The framework does not claim to derive the discrete Fourier transform from its axioms; the DFT is a classical mathematical object. The theorem does not claim that the framework's cost function is the only possible cost function satisfying its axioms. The theorem does not claim that the framework's axioms are the only way to arrive at the complex Hilbert-space structure.

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