Gravity Analysis Regge Ttbloch Assembly Neg Raw Cell Stencil Term Eq

The stencil identity

In numerical analysis, a stencil is a fixed pattern of neighboring points used to approximate a derivative or an integral. The declaration neg_rawCellStencilTerm_eq is a theorem in the Recognition Science framework's machine-checked library of formal theorems. It states a precise algebraic identity about one piece of a discrete gravity calculation: the negative of a raw stencil term equals a product of two cosine factors times a weight.

The identity is stated for a three-dimensional cubic lattice of side length N. The stencil term is built from a cell, two slots, and a momentum vector. The theorem says that the negative of this term is exactly equal to the product of the raw triple weight and the cosines of two phase angles. Each cosine is the phase at a cell midpoint plus a slot-dependent phase. The proof handles the periodic wrapping of the lattice by decomposing the phase into an integer number of turns and using cosine periodicity.

This identity is one step in a larger assembly. The library proves that the canonical finite Hamiltonian equals a Bloch fold of cosine evaluators, and that this equality holds for all sufficiently large N when the momentum is nonzero. The stencil identity is the local cell-level version of that global statement. It shows that the raw stencil term, which looks like a complicated sum over triples, is actually a product of two cosines at the cell level.

In Recognition Science, this is part of the framework's treatment of gravity as a discrete recognition process. The framework models spacetime as a ledger, a discrete record of events, and derives physical structure from the cost of recognition. This stencil identity is a technical lemma in that program, connecting the raw discretization to a cleaner cosine form that the Bloch fold can handle.

What the theorem does not claim is equally important. It does not claim that the stencil term approximates any continuum quantity. It is an exact algebraic identity for the discrete object, with no error term and no limit taken. The theorem also does not claim that the cosine product is numerically smaller or larger than the original term; it is an equality, not an inequality. The identity holds for a fixed N and a fixed momentum vector, under the condition that the momentum is non-aliased in at least one coordinate. It does not apply to aliased momenta, and it says nothing about what happens as N goes to infinity.

/-- One signed raw stencil term is a cell-independent raw triple weight
times the two phase-shifted cell cosines. -/
theorem neg_rawCellStencilTerm_eq (N : ℕ) [NeZero N]
    (E : Fin 3 → Fin 3 → ℝ) (m : Fin 3 → ℤ)
    (cell : Vertex N N N) (t f g : Fin 6) :
    -rawCellStencilTerm N E m (cell, t) f g =
      rawTripleWeight E (t, f, g) *
        Real.cos (BlochCellSum.theta N m cell + slotPhase N m t f) *
        Real.cos (BlochCellSum.theta N m cell + slotPhase N m t g) := by
  unfold rawCellStencilTerm rawTripleWeight
  unfold ReggeTTLocalSymbolExistence.planeWaveTetVelocity
  rw [slotDispClass_grounded N cell t f, slotDispClass_grounded N cell t g]
  rw [cos_localEdge_eq_cell_slot N m cell t f,
    cos_localEdge_eq_cell_slot N m cell t g]
  unfold ReggeTTBlochInterfaceAudit.rawJacobianCoefficient
  ring

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

What this page does not claim

The theorem does not claim any approximation or error bound for a continuum limit. The identity is not an inequality and does not compare magnitudes. The theorem does not apply to aliased momenta and says nothing about the infinite-N limit.

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: