Foundation Hamiltonian Emergence Operator U Unitary

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 the inner product, and therefore total probability. The Recognition Science framework derives this structure from its own starting point, a discrete record of recognition events called the ledger. The framework's library of machine-checked formal theorems proves that, on its finite-dimensional state space, the evolution family is a genuine unitary one-parameter group.

The central object is the evolution family U(t) = exp(t * (-i H)), where H is a Hermitian matrix (a self-adjoint operator, the quantum Hamiltonian) and i is the imaginary unit. The framework proves three properties of this family. First, U(0) is the identity, and U(s)U(t) = U(s+t), so the family forms a group under composition. Second, every U(t) is unitary, meaning its conjugate transpose times itself equals the identity. Third, the discrete evolution step already used in the framework is exactly the first-order truncation of this exponential, U(1) ≈ 1 + (-i H).

These results are proved in the machine-checked library for any finite-dimensional Hamiltonian, with no unproved axioms. The framework's key theorem, U_unitary, states the unitarity condition directly. This is the operator-level content of the claim that quantum mechanics is the high-frequency limit of recognition dynamics, now established as a theorem rather than a placeholder.

In Recognition Science, this is a conditional theorem. The Stone-generator structure (Hermitian generator, unitary group, first-order truncation) is a kernel theorem. What remains conditional is the identification that the full nonlinear recognition operator equals this linear step to third order in the deviation. That rests on a proved scalar bound plus a modeling choice, and the exact operator-level error bound and the calibration of the tick remain named residuals.

/-- Unitarity: `(U ev t)^H * U ev t = 1` and `U ev t * (U ev t)^H = 1`. -/
theorem U_unitary (ev : DiscreteEvolution N) (t : ℝ) :
    (U ev t)ᴴ * U ev t = 1 ∧ U ev t * (U ev t)ᴴ = 1 := by
  refine ⟨?_, ?_⟩
  · rw [U_conjTranspose, U_add, neg_add_cancel, U_zero]
  · rw [U_conjTranspose, U_add, add_neg_cancel, U_zero]

/-- One-parameter group law: `U ev s * U ev t = U ev (s + t)`. -/
theorem U_add (ev : DiscreteEvolution N) (s t : ℝ) :
    U ev s * U ev t = U ev (s + t) := by
  have hcomm : Commute ((s : ℂ) • gen ev) ((t : ℂ) • gen ev) :=
    ((Commute.refl (gen ev)).smul_left (s : ℂ)).smul_right (t : ℂ)
  unfold U
  rw [← Matrix.exp_add_of_commute ℂ _ _ hcomm]
  congr 1
  rw [← add_smul, ← Complex.ofReal_add]

/-- Identity at `t = 0`: `U ev 0 = 1`. -/
theorem U_zero (ev : DiscreteEvolution N) : U ev 0 = 1 := by
  unfold U
  rw [Complex.ofReal_zero, zero_smul, exp_zero]

/-- 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 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 equals this linear step to all orders. The calibration of the tick is derived from the framework's constants. This establishes quantum mechanics as a complete description of recognition dynamics.

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: