Foundation Hamiltonian Emergence Operator U Mem Unitary Group

The unitary evolution family

In quantum mechanics, the evolution of a closed system over time is described by a unitary operator: a linear map that preserves inner products, and therefore total probability. The operator U(t) = exp(-iHt), built from a self-adjoint Hamiltonian H, is the standard example. A key structural fact, Stone's theorem, says that any strongly continuous one-parameter group of unitary operators has this exponential form. The classical statement is infinite-dimensional; on a finite-dimensional complex vector space, the same conclusion follows from elementary matrix analysis.

Recognition Science works with a finite-dimensional register of states, the 8-tick recognition cycle represented as C^N. The framework's ledger, a discrete record of recognition events, gives rise to a small-deviation Hamiltonian, a real symmetric matrix. The declaration U_mem_unitaryGroup proves that the evolution family built from this Hamiltonian, U(t) = exp(t * (-iH)), is unitary for every real time t: it satisfies U(t)^H U(t) = 1 and U(t) U(t)^H = 1, and therefore lies in the unitary group of C^N. This is the operator-level content of the framework's claim that quantum mechanics is the high-frequency limit of recognition dynamics, now as a finite-dimensional theorem rather than a placeholder.

The proof is short and rests on two facts. First, the complexified Hamiltonian Hc is Hermitian because the original real matrix is symmetric. Second, the generator gen = -iHc is skew-Hermitian, which is the defining property of the generator of a unitary one-parameter group. From these, the theorem U_add shows the group law U(s)U(t) = U(s+t), and U_unitary gives the two unitarity equations. The discrete evolution step already defined in the framework, step ψ = ψ - iHcψ, is exactly the first-order truncation (1 + gen)ψ of the exponential U(1) = exp(gen).

What remains conditional is not the unitary structure itself, but the identification of the full nonlinear recognition operator R-hat with this linear step to third order in the deviation. That rests on the proved scalar bound that the cost function is approximately quadratic near equilibrium, plus the modeling choice that R-hat linearizes to step. The exact operator-level Taylor bound and the calibration of the tick, Δ = 8τ₀/ħ, remain named residuals. The theorem is therefore a conditional theorem: the Stone-generator structure is proved, while the physical bridge from the nonlinear ledger to the linear evolution is not.

For the reader, the consequence is concrete: the framework's small-deviation dynamics has the same mathematical skeleton as textbook quantum mechanics, including the preservation of probability, without importing an infinite-dimensional Stone theorem. The finite-dimensional setting makes the argument elementary, and the machine-checked library of formal theorems confirms it with no unproved assumptions.

/-- The evolution lies in the unitary group of `C^N`. -/
theorem U_mem_unitaryGroup (ev : DiscreteEvolution N) (t : ℝ) :
    U ev t ∈ Matrix.unitaryGroup (Fin N) ℂ := by
  rw [Matrix.mem_unitaryGroup_iff, Matrix.star_eq_conjTranspose]
  exact (U_unitary ev t).2

/-- The complexified Hamiltonian is Hermitian: a real symmetric matrix is self-adjoint over `C`. -/
theorem Hc_isHermitian (ev : DiscreteEvolution N) : (Hc ev).IsHermitian := by
  show (Hc ev)ᴴ = Hc ev
  ext i j
  simp only [Matrix.conjTranspose_apply, Hc, Matrix.of_apply, Complex.star_def,
    Complex.conj_ofReal]
  norm_cast
  exact ev.symmetric j i

/-- The generator is skew-Hermitian: `(gen)^H = -gen`. This is the defining property of the generator
of a unitary one-parameter group. -/
theorem gen_skewHermitian (ev : DiscreteEvolution N) :
    (gen ev)ᴴ = -(gen ev) := by
  have hH : (Hc ev)ᴴ = Hc ev := (Hc_isHermitian ev).eq
  unfold gen
  rw [Matrix.conjTranspose_smul, hH]
  have hstar : star (-Complex.I) = Complex.I := by
    rw [star_neg, Complex.star_def, Complex.conj_I, neg_neg]
  rw [hstar, neg_smul, neg_neg]

/-- The discrete evolution step of `HamiltonianEmergence` is exactly the first-order truncation
`(1 + gen ev) *v psi` of the exact unitary evolution `U ev 1 = exp(gen ev)`. This ties the existing
linear step to the operator exponential: `step` is the Euler / first-order approximation of the genuine
unitary recognition tick. -/
theorem step_eq_firstOrder (ev : DiscreteEvolution N) (ψ : DeviationHilbert N) :
    ev.step ψ = (1 + gen ev) *ᵥ ψ := by
  funext i
  rw [Matrix.add_mulVec, Matrix.one_mulVec, Pi.add_apply]
  have hg : (gen ev *ᵥ ψ) i
      = ∑ j, (-Complex.I) * ((ev.hamiltonian i j : ℂ) * ψ j) := by
    simp only [Matrix.mulVec, dotProduct, gen, Matrix.smul_apply, Hc, Matrix.of_apply,
      smul_eq_mul]
    exact Finset.sum_congr rfl (fun j _ => by ring)
  rw [hg, ← Finset.mul_sum]
  show ψ i - Complex.I * (∑ j, (ev.hamiltonian i j : ℂ) * ψ j)
      = ψ i + (-Complex.I) * ∑ j, (ev.hamiltonian i j : ℂ) * ψ j
  ring

What this page does not claim

The full nonlinear recognition operator R-hat is not proved to equal the linear step; that identification remains conditional. The tick calibration Δ = 8τ₀/ħ is not derived in this module; it is a named residual. The theorem does not prove that the framework's ledger produces quantum mechanics in general; it proves the unitary structure of the small-deviation evolution only.

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