Foundation Hamiltonian Emergence Operator U Conj Transpose

Time reversal in the evolution family

In linear algebra, a matrix conjugate transpose (written M^H) is formed by transposing the matrix and taking the complex conjugate of each entry. The declaration U_conjTranspose proves a specific identity about a family of matrices U(t) that describe how a small deviation from equilibrium evolves over a continuous time parameter t. The identity states that the conjugate transpose of the evolution at time t equals the evolution at time -t: U(t)^H = U(-t).

This is a time-reversal symmetry. If you take the state of a system and run it backward by an amount t, you get the same result as applying the conjugate transpose of the forward evolution operator. For a physicist, this is the hallmark of a unitary process, one that preserves total probability or norm. The theorem is proved in the framework's machine-checked library of formal theorems, using the fact that the generator of the evolution is skew-Hermitian, meaning its conjugate transpose is its own negative.

In Recognition Science, the framework models a discrete ledger of recognition events. Near equilibrium, the cost of recognition is a quadratic form, and the framework constructs a finite-dimensional Hamiltonian matrix H from the small-deviation data. The evolution family is defined as the matrix exponential U(t) = exp(t · (-iH)), where i is the imaginary unit. The identity U(t)^H = U(-t) is one of several properties that together certify that this family forms a genuine unitary one-parameter group: it starts at the identity, composes additively, and every member is unitary.

The framework's library proves this identity as a theorem, along with the related facts that the Hamiltonian is Hermitian and the evolution is unitary. The discrete recognition step, which updates a state by a small linear correction, is shown to be exactly the first-order truncation of this exponential evolution. This connects the discrete ledger to the continuous unitary picture.

What the declaration does not claim is that the full nonlinear recognition operator equals this linear evolution. The identification of the complete dynamics with the linear step to third order in the deviation, and the calibration of the time step t = 8τ₀/ħ, remain named residuals. The theorem establishes the linear operator structure, not the full nonlinear equivalence.

/-- The adjoint of the evolution is the time-reversed evolution: `(U ev t)^H = U ev (-t)`. -/
theorem U_conjTranspose (ev : DiscreteEvolution N) (t : ℝ) :
    (U ev t)ᴴ = U ev (-t) := by
  have hexp : ((t : ℂ) • gen ev)ᴴ = ((-t : ℝ) : ℂ) • gen ev := by
    rw [Matrix.conjTranspose_smul, gen_skewHermitian]
    simp [Complex.star_def, Complex.conj_ofReal, smul_neg, neg_smul, Complex.ofReal_neg]
  unfold U
  rw [← Matrix.exp_conjTranspose, hexp]

/-- The Stone generator certificate holds for every discrete-evolution Hamiltonian. -/
theorem stoneGeneratorCert (ev : DiscreteEvolution N) :
    StoneGeneratorCert N ev where
  hamiltonian_hermitian := Hc_isHermitian ev
  generator_skewHermitian := gen_skewHermitian ev
  evolution_id := U_zero ev
  one_parameter_group := U_add ev
  evolution_unitary := U_unitary ev
  evolution_mem_unitary := U_mem_unitaryGroup ev
  discrete_step_is_first_order := step_eq_firstOrder ev

/-- 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 the linear evolution to third order in the deviation. The time step t = 8τ₀/ħ is derived within this theorem. The evolution family applies to an infinite-dimensional state space.

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: