Gravity Analysis Regge Ttbloch Assembly Eventually Canonical Finite H Eq Raw Cos

The finite-cell equality

The declaration eventually_canonicalFiniteH_eq_rawCosineBlochFold is a theorem in the framework's machine-checked library of formal theorems. It states that for any nonzero integer wave vector m, and for all sufficiently large grid sizes N, the canonical finite Hamiltonian H equals a simpler expression called the raw cosine Bloch fold. The equality holds for every side length N beyond a threshold that depends on m, and the proof is fully checked by the kernel, with no gaps.

The raw cosine Bloch fold is built from a cosine evaluator that reads a bucket's integer phase key directly, without any quadratic moment evaluator. The theorem shows that the canonical finite H, which is defined through a cell stencil and a triple sum over edges, collapses to this cosine fold exactly. The proof uses a phase decomposition that handles periodic wrapping by an explicit integer-turn count, and cosine periodicity then absorbs the wrap terms.

The theorem requires that the wave vector m be nonzero in at least one coordinate. It does not require the stronger condition that the doubled frequency be non-aliased in every coordinate; the eventual statement only needs some coordinate where m_i is nonzero. The proof obtains the non-aliasing condition for all sufficiently large N from a separate lemma, so the eventual form is clean: for every nonzero m, the equality holds for all large enough grids.

What the theorem does not claim is that the equality holds for every grid size. For small N, aliasing can occur, and the statement makes no assertion there. It also does not claim that the raw cosine fold is the unique or preferred way to evaluate the canonical H; it only establishes equality under the stated conditions. The theorem does not assert anything about the physical meaning of H or about gravity itself; it is a formal identity between two finite sums.

The practical consequence is that a complicated triple sum over edges can be replaced by a simpler bucket-based cosine fold, for large enough grids. This is a computational simplification that holds exactly, not approximately. It gives a cleaner handle on the finite-cell assembly stage, and it does so without importing any spike or continuum-certificate module, as the module docstring notes.

/-- For every fixed nonzero integer mode, the canonical finite assembly
identity holds at every sufficiently large side length.  The explicit
`NeZero N` argument only supplies the existing finite-torus definitions. -/
theorem eventually_canonicalFiniteH_eq_rawCosineBlochFold
    (E : Fin 3 → Fin 3 → ℝ) (m : Fin 3 → ℤ)
    (hm : ∃ i : Fin 3, m i ≠ 0) :
    ∀ᶠ N : ℕ in Filter.atTop, ∀ hN : NeZero N,
      @canonicalFiniteH N hN E m =
        reggeTTBlochFold rawCosineSupport (@rawCosineEvaluator N hN m)
          (rawBucketAmplitude E) := by
  filter_upwards [BlochCellSum.eventually_nonaliased m hm] with N halias
  intro hN
  letI : NeZero N := hN
  exact canonicalFiniteH_eq_rawCosineBlochFold N E m halias

/-- Cosine phase evaluator on a raw bucket.  This definition is direct from
the integer phase key and does not mention `rawPhaseQuadratic`. -/
def rawCosineEvaluator (N : ℕ) [NeZero N] (m : Fin 3 → ℤ)
    (b : Bucket) : ℝ :=
  Real.cos
    (∑ i : Fin 3,
      commensurateMomentum N m i * (((b.phase i : ℤ) : ℝ) / 2))

/-- For every fixed nonzero integer mode, the canonical finite assembly
identity holds at every sufficiently large side length.  The explicit
`NeZero N` argument only supplies the existing finite-torus definitions. -/
theorem eventually_canonicalFiniteH_eq_rawCosineBlochFold
    (E : Fin 3 → Fin 3 → ℝ) (m : Fin 3 → ℤ)
    (hm : ∃ i : Fin 3, m i ≠ 0) :
    ∀ᶠ N : ℕ in Filter.atTop, ∀ hN : NeZero N,
      @canonicalFiniteH N hN E m =
        reggeTTBlochFold rawCosineSupport (@rawCosineEvaluator N hN m)
          (rawBucketAmplitude E) := by
  filter_upwards [BlochCellSum.eventually_nonaliased m hm] with N halias
  intro hN
  letI : NeZero N := hN
  exact canonicalFiniteH_eq_rawCosineBlochFold N E m halias

/-- For every fixed nonzero integer mode, the canonical finite assembly
identity holds at every sufficiently large side length.  The explicit
`NeZero N` argument only supplies the existing finite-torus definitions. -/
theorem eventually_canonicalFiniteH_eq_rawCosineBlochFold
    (E : Fin 3 → Fin 3 → ℝ) (m : Fin 3 → ℤ)
    (hm : ∃ i : Fin 3, m i ≠ 0) :
    ∀ᶠ N : ℕ in Filter.atTop, ∀ hN : NeZero N,
      @canonicalFiniteH N hN E m =
        reggeTTBlochFold rawCosineSupport (@rawCosineEvaluator N hN m)
          (rawBucketAmplitude E) := by
  filter_upwards [BlochCellSum.eventually_nonaliased m hm] with N halias
  intro hN
  letI : NeZero N := hN
  exact canonicalFiniteH_eq_rawCosineBlochFold N E m halias

What this page does not claim

The equality holds for all grid sizes, including small ones where aliasing occurs. The raw cosine fold is the unique or preferred evaluation method for the canonical Hamiltonian. The theorem assigns any physical meaning to the Hamiltonian or connects it to gravity. The proof uses any spike or continuum-certificate 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/Gravity/Analysis/ReggeTTBlochAssembly.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: