Gravity Analysis Regge Ttbloch Assembly

A finite-cell assembly stage

In numerical physics, a Regge calculation breaks spacetime into discrete chunks, or cells, and computes how geometry bends across their edges. This assembly stage, Regge TT finite Bloch assembly, is a stage in that pipeline. It takes a grid of cells and a wave vector, a momentum-like quantity, and shows that the full gravitational response of the grid equals a much simpler sum. The simpler sum is built from cosine functions evaluated at points defined by integer phase keys, one per cell bucket. The result is a proof, checked by a machine, that the two ways of computing agree exactly.

The core theorem, canonicalFiniteH_eq_rawCosineBlochFold, states that for any side length N and any commensurate wave vector whose doubled frequency is not aliased in one coordinate, the normalized canonical finite value equals the raw bucket-fiber Bloch fold. In plain words: the complicated stencil, the pattern of how a cell's neighbors influence it, can be rewritten as a fold, a structured reduction, over cosine values. The proof handles periodic wrapping, the way a grid edge connects back to the opposite edge, through an explicit integer-turn phase decomposition and cosine periodicity. No spike or continuum-certificate module is imported, meaning this is a self-contained finite-cell statement.

The assembly stage also proves eventually_canonicalFiniteH_eq_rawCosineBlochFold, which extends the equality to all sufficiently large grids. For any wave vector with at least one nonzero component, the equality holds for all N beyond some threshold. This is the practical payoff: as the grid refines, the cosine-based form remains valid, and the calculation can be performed with a known, stable structure. The cosine evaluator is defined directly from a bucket's integer phase key, independently of any quadratic moment evaluator, which keeps the assembly stage clean and modular.

In Recognition Science, this assembly stage is part of the C-DAG1 finite-cell assembly stage, a step in the framework's gravity analysis pipeline. The framework models physical structure from a discrete ledger of recognition events, and this assembly stage contributes a verified computational bridge: it shows that a finite-cell gravitational calculation can be expressed in a canonical cosine form. The proof is a theorem in the framework's machine-checked library, meaning its correctness does not depend on hand-waving or approximation. What this changes for a reader: the finite-cell gravity calculation is not an ad hoc numerical recipe but a formally grounded construction, with a clean decomposition that can be trusted and reused.

/-- CANONICAL FINITE ASSEMBLY: the actual reduced finite second variation
equals the raw bucket cosine fold under the same non-aliasing condition. -/
theorem canonicalFiniteH_eq_rawCosineBlochFold (N : ℕ) [NeZero N]
    (E : Fin 3 → Fin 3 → ℝ) (m : Fin 3 → ℤ)
    (halias : ∃ i : Fin 3, ¬ (N : ℤ) ∣ 2 * m i) :
    canonicalFiniteH N E m =
      reggeTTBlochFold rawCosineSupport (rawCosineEvaluator N m)
        (rawBucketAmplitude E) := by
  rw [a2_reduced_eq_rawCellStencil,
    rawCellStencil_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

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

/-- CANONICAL FINITE ASSEMBLY: the actual reduced finite second variation
equals the raw bucket cosine fold under the same non-aliasing condition. -/
theorem canonicalFiniteH_eq_rawCosineBlochFold (N : ℕ) [NeZero N]
    (E : Fin 3 → Fin 3 → ℝ) (m : Fin 3 → ℤ)
    (halias : ∃ i : Fin 3, ¬ (N : ℤ) ∣ 2 * m i) :
    canonicalFiniteH N E m =
      reggeTTBlochFold rawCosineSupport (rawCosineEvaluator N m)
        (rawBucketAmplitude E) := by
  rw [a2_reduced_eq_rawCellStencil,
    rawCellStencil_eq_rawCosineBlochFold N E m halias]

What this page does not claim

This assembly stage does not prove that the Regge calculation converges to a continuum gravity theory. It does not establish any physical prediction about gravity itself. The non-aliasing condition is a technical requirement, not a physical assumption.

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: