Foundation Hamiltonian Emergence Operator Hc Is Hermitian

The self-adjoint generator

In quantum mechanics, the operator that generates time evolution must be Hermitian: it must equal its own conjugate transpose. This property guarantees that probabilities are conserved and that energy values are real. The declaration Hc_isHermitian proves that a specific matrix, built from the small-deviation Hamiltonian of a discrete evolution, has exactly this property. The matrix is the complexification of a real symmetric matrix, and the theorem shows that complexifying a real symmetric matrix always yields a Hermitian matrix.

The proof is a direct calculation. For any indices i and j, the conjugate transpose of the complexified matrix at (i, j) equals the original matrix at (i, j), because the original real matrix is symmetric and conjugation of a real number does nothing. The theorem is stated for any discrete evolution on a finite-dimensional space, so it holds universally within the framework.

This Hermiticity result is the first link in a chain. From it, the framework derives that the generator gen = -i * Hc is skew-Hermitian, that the evolution family U(t) = exp(t * gen) forms a one-parameter group, and that every U(t) is unitary. The discrete step used in the framework's dynamics is then shown to be exactly the first-order truncation of this exponential evolution. Together, these results form a finite-dimensional Stone generator certificate, establishing that the recognition dynamics has the structure of quantum mechanics at the operator level.

In Recognition Science, this is the operator-level content of the claim that quantum mechanics is the high-frequency limit of recognition dynamics. The framework models the recognition register as a finite-dimensional complex space, so the evolution is a matrix exponential, not an infinite-dimensional operator. The certificate proves that the small-deviation evolution is a genuine unitary one-parameter group generated by a self-adjoint operator, matching the mathematical structure of Schrödinger evolution.

The theorem does not claim that the full nonlinear recognition operator R-hat equals this linear evolution. That identification remains conditional, resting on a proved scalar bound and a modeling choice. The exact operator-level error bound for the exponential Taylor series and the calibration of the time step remain named residuals. The Hermiticity theorem itself is unconditional within the framework, but the bridge from the linearized step to the full nonlinear dynamics is not yet a theorem.

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

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

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

/-- 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 equals the linear evolution step. The operator-level error bound for the exponential Taylor series is proved. The calibration of the time step 8 tau_0 / hbar is derived.

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: