Encyclopedia Gravity Gravity Analysis Regge Bloch Fold4 D Phased Class Dot Area Axis Of Masks 2 1

ARTICLE 4 claims 4 theorems

Gravity Analysis Regge Bloch Fold4 D Phased Class Dot Area Axis Of Masks 2 1

A machine-checked calculation shows that a discrete model of spacetime geometry, built from four-dimensional hinges, produces exact integer certificates for its own structure.

Verify this page

A discrete gravity ledger

The declaration phasedClassDot (a discrete record of how a geometric perturbation overlaps with a plane wave) belongs to a campaign that models gravity as a ledger of recognition events on a four-dimensional grid. The grid's basic objects are triangle hinges: triangular pieces of a tetrahedral cell, each with an orientation and a position. The framework's library, a machine-checked collection of formal theorems, proves that when these hinges are grouped into a specific orbit called type (1,1), there are exactly 72 oriented slots per cell.

For each slot, the calculation assigns a phase based on a wave vector, the momentum of a plane wave probing the geometry. At a special wave vector where three components are π/2 and the fourth is zero, every phase becomes a natural multiple of π/4. This means each slot's contribution to the fold, the total overlap of the perturbation with the wave, is exactly (N₁ + N₂·√2)/8 for decidable integers N₁ and N₂. The library proves these integers match precomputed tables for all 240 oriented slots, a geometric-to-certificate match that closes.

Two structural results emerge. First, the total fold for the axis-TT-plus perturbation at that wave vector is -3, and it is nonzero, so the result is not vacuous. Second, the total for a decoy gauge perturbation is -4 + 4√2, also nonzero, which shows that discrete gauge invariance at finite momentum holds only up to a finite-difference identity. The library also proves that difference masks of type (1,2) and (2,1) give identically zero contributions for every wave vector, meaning those area supports miss the axis-TT class loads entirely.

All theorems are kernel-checked with no axioms beyond the standard three, and the calculation does not evaluate the mass-squared Taylor coefficient against the Einstein-Hilbert continuum symbol. It does not prove that the discrete action converges to general relativity in four dimensions, and it does not flip any action-recovery gap. The result is a precise, self-contained statement about one orbit in a discrete geometry, not a claim about the continuum limit.

THEOREM t11_count_nat · IndisputableMonolith/Gravity/Analysis/ReggeBlochFold4D.lean
t11_count_nat · IndisputableMonolith/Gravity/Analysis/ReggeBlochFold4D.lean:130 
private lemma t11_count_nat :
    (∑ s : Fin 24, ∑ t : Fin 10, (if isT11 s t then (1 : ℕ) else 0)) =
      72 := by
  have h : (∑ s : Fin 24, ∑ t : Fin 10,
      (if hingeTypePop s t = (1, 1) then (1 : ℕ) else 0)) = 72 := by
    simpa [cellTriangleCount, triangleTypeNat] using cellTriangleCount_t11
  refine Eq.trans ?_ h
  refine Finset.sum_congr rfl fun s _ => Finset.sum_congr rfl fun t _ => ?_
  by_cases h' : isT11 s t
  · have hp : hingeTypePop s t = (1, 1) := (isT11_iff_pop s t).mp h'
    simp [h', hp]
  · have : hingeTypePop s t ≠ (1, 1) := fun happ =>
      h' ((isT11_iff_pop s t).mpr happ)
    simp [h', this]
THEOREM cos_quarterTurns · IndisputableMonolith/Gravity/Analysis/ReggeBlochFold4D.lean
cos_quarterTurns · IndisputableMonolith/Gravity/Analysis/ReggeBlochFold4D.lean:587 
/-- Exact table for `cos(k·π/4)`, valid for every natural `k`. -/
theorem cos_quarterTurns (k : ℕ) :
    Real.cos ((k : ℝ) * (Real.pi / 4)) =
      (cosC1 (k % 8) : ℝ) + (cosC2 (k % 8) : ℝ) * (Real.sqrt 2 / 2) := by
  have hmod : ((k % 8 : ℕ) : ℝ) + 8 * ((k / 8 : ℕ) : ℝ) = (k : ℝ) := by
    exact_mod_cast congrArg (fun n : ℕ => (n : ℝ)) (Nat.mod_add_div k 8)
  have hsplit : (k : ℝ) * (Real.pi / 4) =
      ((k % 8 : ℕ) : ℝ) * (Real.pi / 4) +
        ((k / 8 : ℕ) : ℝ) * (2 * Real.pi) := by
    rw [← hmod]; ring
  rw [hsplit,
    (Real.cos_periodic.nat_mul (k / 8)) (((k % 8 : ℕ) : ℝ) * (Real.pi / 4))]
  have h8 : k % 8 = 0 ∨ k % 8 = 1 ∨ k % 8 = 2 ∨ k % 8 = 3 ∨ k % 8 = 4 ∨
      k % 8 = 5 ∨ k % 8 = 6 ∨ k % 8 = 7 := by omega
  rcases h8 with h | h | h | h | h | h | h | h <;> rw [h]
  · norm_num [cosC1, cosC2, Real.cos_zero]
  · norm_num [cosC1, cosC2, Real.cos_pi_div_four]
  · rw [show ((2 : ℕ) : ℝ) * (Real.pi / 4) = Real.pi / 2 by push_cast; ring]
    norm_num [cosC1, cosC2, Real.cos_pi_div_two]
  · rw [show ((3 : ℕ) : ℝ) * (Real.pi / 4) = Real.pi - Real.pi / 4 by
      push_cast; ring]
    rw [Real.cos_pi_sub]
    norm_num [cosC1, cosC2, Real.cos_pi_div_four]
  · rw [show ((4 : ℕ) : ℝ) * (Real.pi / 4) = Real.pi by push_cast; ring]
    norm_num [cosC1, cosC2, Real.cos_pi]
  · rw [show ((5 : ℕ) : ℝ) * (Real.pi / 4) = Real.pi + Real.pi / 4 by
      push_cast; ring]
    rw [Real.cos_add]
    norm_num [cosC1, cosC2, Real.cos_pi, Real.sin_pi, Real.cos_pi_div_four]
  · rw [show ((6 : ℕ) : ℝ) * (Real.pi / 4) = Real.pi + Real.pi / 2 by
      push_cast; ring]
    rw [Real.cos_add]
    norm_num [cosC1, cosC2, Real.cos_pi, Real.sin_pi, Real.cos_pi_div_two]
  · rw [show ((7 : ℕ) : ℝ) * (Real.pi / 4) = 2 * Real.pi - Real.pi / 4 by
      push_cast; ring]
    rw [Real.cos_sub]
    norm_num [cosC1, cosC2, Real.cos_two_pi, Real.sin_two_pi,
      Real.cos_pi_div_four]
THEOREM blochFold11_axisTTPlus_waveStar_ne_zero · IndisputableMonolith/Gravity/Analysis/ReggeBlochFold4D.lean
blochFold11_axisTTPlus_waveStar_ne_zero · IndisputableMonolith/Gravity/Analysis/ReggeBlochFold4D.lean:827 
/-- Nonvacuity of the finite-momentum fold on axis TT. -/
theorem blochFold11_axisTTPlus_waveStar_ne_zero :
    blochFold11 axisTTPlus waveStar ≠ 0 := by
  rw [blochFold11_axisTTPlus_waveStar]; norm_num
THEOREM sum_gaugeStarContrib · IndisputableMonolith/Gravity/Analysis/ReggeBlochFold4D.lean
sum_gaugeStarContrib · IndisputableMonolith/Gravity/Analysis/ReggeBlochFold4D.lean:501 
/-- Certificate sum for decoy gauge at `m⋆`: `-4 + 4√2`. -/
theorem sum_gaugeStarContrib :
    (∑ s : Fin 24, ∑ t : Fin 10, gaugeStarContrib s t) =
      -4 + 4 * Real.sqrt 2 := by
  unfold gaugeStarContrib
  set c : ℝ := -1 + Real.sqrt 2
  have hterm : ∀ s t,
      (if gaugeStarKind s t = 1 then c else (0 : ℝ)) =
        c * (if gaugeStarKind s t = 1 then (1 : ℝ) else 0) := by
    intro s t; by_cases h : gaugeStarKind s t = 1 <;> simp [h]
  simp_rw [hterm, ← Finset.mul_sum]
  have hc :
      (∑ s : Fin 24, ∑ t : Fin 10,
          if gaugeStarKind s t = 1 then (1 : ℝ) else 0) = 4 := by
    simpa [Nat.cast_sum] using
      congrArg (fun n : ℕ => (n : ℝ)) gaugeStarKind_count1
  rw [hc]
  unfold c
  ring

What this page does not claim

The mass-squared Taylor coefficient is not compared to the Einstein-Hilbert continuum symbol. The discrete action is not proved to converge to general relativity in four dimensions. The result does not establish any property of the (1,2) or (2,1) orbit contributions, which vanish identically.

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