Foundation Hamiltonian Emergence Operator Step Eq First Order

The first-order step

In quantum mechanics, time evolution is generated by a Hamiltonian operator. For a finite-dimensional system, this evolution is a family of unitary matrices, one for each time, that compose as a group. The Recognition Science framework's machine-checked library of formal theorems proves that its discrete recognition step, the rule that advances a small deviation by one tick, is exactly the first-order truncation of such a unitary evolution.

The recognition register, a discrete record of possible states, is finite-dimensional, so the framework needs no infinite-dimensional Stone theorem. Its library proves that the complexified Hamiltonian is Hermitian, meaning it is self-adjoint, and that the generator, which is negative imaginary times the Hamiltonian, is skew-Hermitian. The exponential of this generator defines a one-parameter group of unitary matrices: the identity at time zero, composition of evolutions at successive times, and unitarity at every time.

The central theorem, step_eq_firstOrder, states that the discrete step equals the first-order Taylor expansion of the exponential: step ψ = (1 + gen) ψ. This is the Euler approximation of the exact unitary evolution. The theorem is proved for every small-deviation Hamiltonian on the register, with no unproved axioms in the library's kernel.

In Recognition Science, this establishes the operator-level content of the claim that quantum mechanics is the high-frequency limit of recognition dynamics. The linear step is not an ad hoc rule; it is the first-order piece of a genuine unitary group generated by a self-adjoint Hamiltonian. The full nonlinear evolution, however, is not proved to equal this linearization beyond first order. That identification rests on a proved scalar bound plus a modeling choice, and the exact exponential bound and the calibration of the tick remain named residuals.

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

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

What this page does not claim

The full nonlinear R-hat action is proved to equal the linear step beyond first order. The exact exponential Taylor bound for the operator is proved. The calibration of the tick 8 tau_0 / hbar is derived in this module.

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: