Encyclopedia Gravity Gravity Analysis Regge Tthinge Aware Zero Mode Hinge Cancels Recorded Residual

ARTICLE 4 claims 4 theorems

Gravity Analysis Regge Tthinge Aware Zero Mode Hinge Cancels Recorded Residual

A machine-checked proof shows a certain flat deformation of a lattice gravity model costs no energy, settling a question about how the model behaves at its simplest level.

Verify this page

The vanishing mode

Regge calculus is a way of doing general relativity on a lattice: instead of a smooth spacetime, you have a grid of flat tetrahedra, and the geometry is encoded in the edge lengths. A natural question is whether you can deform the lattice, changing those edge lengths, without changing the total energy. Such a deformation is called a zero mode. The declaration hinge_cancels_recorded_residual is a theorem in the framework's machine-checked library of formal theorems, and it establishes that, for a specific class of deformations, the answer is yes: the assembled energy cost vanishes exactly.

The proof works by splitting the energy cost into two pieces. One piece, the hinge block, comes from the angles between tetrahedra. The other, the stencil-only residual, comes from the rest of the lattice stencil. A numerical diagnostic had found that each piece alone contributes a nonzero value, specifically -π(√2 + 4)/8. The theorem shows that when you assemble the full energy cost, these two pieces cancel each other out with a relative minus sign, leaving zero. This is not a numerical approximation; it is an exact identity, checked by the machine.

The result is stronger than the question that motivated it. The original question asked whether the assembled block vanishes for a special class of deformations called transverse-traceless (TT) polarizations, which are the ones relevant to gravitational waves. The theorem proves the block vanishes for every polarization matrix, TT or not. Constant metric perturbations are exact flat directions of the lattice. The TT case is then a special case, and a separate theorem confirms that the cancellation happens on the concrete TT example the diagnostic reported.

What the theorem does not do is re-prove the full decomposition of the energy into hinge and Hessian parts for all possible deformations. That split is only checked at the recorded witness point. The proof also inherits two extra axioms from an earlier step in the chain, beyond the standard three, though these are inherited disclosures rather than new assumptions. The headline, however, stands: for constant metric perturbations, the energy cost is identically zero.

THEOREM ttWitness_isTT · IndisputableMonolith/Gravity/Analysis/ReggeTTHingeAwareZeroMode.lean
ttWitness_isTT · IndisputableMonolith/Gravity/Analysis/ReggeTTHingeAwareZeroMode.lean:146 
/-- The reported witness IS a TT polarization for `k = e_z`: symmetric,
traceless, transverse, Frobenius-normalized.  This grounds the phrase
"the reported TT witness" of the recorded residual. -/
theorem ttWitness_isTT :
    IsTTPolarization ttWitnessWaveVector ttWitnessPolarization := by
  refine ⟨?_, ?_, ?_, ?_⟩
  · intro i j
    fin_cases i <;> fin_cases j <;> simp only [ttWitnessPolarization]
  · simp only [Fin.sum_univ_three, ttWitnessPolarization]
    ring
  · intro j
    fin_cases j <;>
      · simp only [Fin.sum_univ_three, ttWitnessPolarization,
          ttWitnessWaveVector]
        push_cast
        ring
  · simp only [Fin.sum_univ_three, ttWitnessPolarization]
    linear_combination 2 * inv_sqrt2_mul_self
THEOREM zeroMomentum_symbol_is_zero · IndisputableMonolith/Gravity/Analysis/ReggeTTHingeAwareZeroMode.lean
zeroMomentum_symbol_is_zero · IndisputableMonolith/Gravity/Analysis/ReggeTTHingeAwareZeroMode.lean:478 
/-- **ZERO-MODE SYMBOL COROLLARY (THEOREM): the fixed-`N` TT Bloch symbol
of the TRUE nonlinear Regge action at ZERO wave vector exists and equals
`0`, for every `N` and every polarization matrix.**  This is the lattice
flat zero mode as a statement about the actual second variation, through
the Gate A1 existence chain and the Gate A2 reduction.  AXIOM
DISCLOSURE: this corollary (alone in this file) rides the certified
flat-deficit chain and therefore inherits `Lean.ofReduceBool` /
`Lean.trustCompiler` in addition to the standard trio. -/
theorem zeroMomentum_symbol_is_zero (N : ℕ) [NeZero N]
    (E : Fin 3 → Fin 3 → ℝ) :
    TTBlochSymbolIs N E (fun _ => (0 : ℤ)) 0 := by
  have h := ReggeTTFlatSecondVariation.planeWave_TTBlochSymbolIs_reduced
    N E (fun _ => (0 : ℤ))
  have hval : canonicalFiniteH N E (fun _ => (0 : ℤ)) =
      (2 / (N : ℝ) ^ (3 : ℕ)) *
        (-∑ τ : PeriodicTet N N N, ∑ f : Fin 6,
          ReggeTTFlatSecondVariation.flatSlotSqrtDeriv N E
              (commensurateMomentum N (fun _ => (0 : ℤ))) τ f *
            ReggeTTFlatSecondVariation.flatSlotAngleDeriv N E
              (commensurateMomentum N (fun _ => (0 : ℤ))) τ f) := rfl
  rw [← hval, canonicalFiniteH_zeroMomentum_eq_zero N E] at h
  exact h
THEOREM rawCellStencil_zeroMomentum · IndisputableMonolith/Gravity/Analysis/ReggeTTHingeAwareZeroMode.lean
rawCellStencil_zeroMomentum · IndisputableMonolith/Gravity/Analysis/ReggeTTHingeAwareZeroMode.lean:405 
/-- The `k = 0` raw cell stencil is `2` times the per-cell assembled
constant block: the cell sum contributes exactly `N ^ 3` identical
copies, and the `2 / N ^ 3` normalization leaves the factor `2`. -/
theorem rawCellStencil_zeroMomentum (N : ℕ) [NeZero N]
    (E : Fin 3 → Fin 3 → ℝ) :
    rawCellStencil N E (fun _ => (0 : ℤ)) = 2 * assembledConstantBlock E := by
  unfold rawCellStencil
  have hterm : ∀ (τ : PeriodicTet N N N) (f g : Fin 6),
      rawCellStencilTerm N E (fun _ => (0 : ℤ)) τ f g =
        rawJacobianCoefficient f g *
          polEdgeCoeff E (slotDispClass τ.2 f) *
          polEdgeCoeff E (slotDispClass τ.2 g) := by
    intro τ f g
    unfold rawCellStencilTerm rawJacobianCoefficient
    rw [commensurateMomentum_zero N,
      planeWaveTetVelocity_zeroMomentum N E τ f,
      planeWaveTetVelocity_zeroMomentum N E τ g]
    ring
  have hsum : (∑ τ : PeriodicTet N N N, ∑ f : Fin 6, ∑ g : Fin 6,
      rawCellStencilTerm N E (fun _ => (0 : ℤ)) τ f g) =
      (N : ℝ) ^ (3 : ℕ) *
        ∑ t : Fin 6, ∑ f : Fin 6, ∑ g : Fin 6,
          rawJacobianCoefficient f g *
            polEdgeCoeff E (slotDispClass t f) *
            polEdgeCoeff E (slotDispClass t g) := by
    calc
      (∑ τ : PeriodicTet N N N, ∑ f : Fin 6, ∑ g : Fin 6,
          rawCellStencilTerm N E (fun _ => (0 : ℤ)) τ f g)
          = ∑ cell : Vertex N N N, ∑ t : Fin 6, ∑ f : Fin 6, ∑ g : Fin 6,
              rawJacobianCoefficient f g *
                polEdgeCoeff E (slotDispClass t f) *
                polEdgeCoeff E (slotDispClass t g) := by
            rw [Fintype.sum_prod_type]
            refine Finset.sum_congr rfl fun cell _ => ?_
            refine Finset.sum_congr rfl fun t _ => ?_
            refine Finset.sum_congr rfl fun f _ => ?_
            refine Finset.sum_congr rfl fun g _ => ?_
            exact hterm (cell, t) f g
      _ = (Fintype.card (Vertex N N N) : ℝ) *
            ∑ t : Fin 6, ∑ f : Fin 6, ∑ g : Fin 6,
              rawJacobianCoefficient f g *
                polEdgeCoeff E (slotDispClass t f) *
                polEdgeCoeff E (slotDispClass t g) := by
            rw [Finset.sum_const, nsmul_eq_mul, Finset.card_univ]
      _ = (N : ℝ) ^ (3 : ℕ) *
            ∑ t : Fin 6, ∑ f : Fin 6, ∑ g : Fin 6,
              rawJacobianCoefficient f g *
                polEdgeCoeff E (slotDispClass t f) *
                polEdgeCoeff E (slotDispClass t g) := by
            congr 1
            rw [show Fintype.card (Vertex N N N) = N * (N * N) by
              simp [Fintype.card_prod]]
            push_cast
            ring
  rw [hsum]
  unfold assembledConstantBlock
  have hN : ((N : ℝ)) ^ (3 : ℕ) ≠ 0 := by
    have hcast : (N : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (Nat.pos_of_neZero N).ne'
    positivity
  have hkey : ∀ (A S : ℝ), A ≠ 0 → (2 / A) * -(A * S) = 2 * -S := by
    intro A S hA
    field_simp
  exact hkey _ _ hN
THEOREM commensurateMomentum_zero · IndisputableMonolith/Gravity/Analysis/ReggeTTHingeAwareZeroMode.lean
commensurateMomentum_zero · IndisputableMonolith/Gravity/Analysis/ReggeTTHingeAwareZeroMode.lean:385 
/-- Zero integer wave vector gives the zero commensurate momentum. -/
theorem commensurateMomentum_zero (N : ℕ) [NeZero N] :
    commensurateMomentum N (fun _ => (0 : ℤ)) = fun _ => (0 : ℝ) := by
  funext i
  simp [commensurateMomentum]

What this page does not claim

The full Hessian decomposition is not re-proved in the machine-checked library. The theorem does not claim the cancellation holds for all deformations, only for constant metric perturbations. The proof does not introduce new axioms; it inherits two extra ones from a prior step.

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/ReggeTTHingeAwareZeroMode.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:

MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND