Gravity Analysis Regge Bloch Fold4 D

A discrete gravity probe

Regge calculus is a way to study gravity without a smooth spacetime fabric. Instead of a continuous manifold, space is built from flat triangular pieces, like a geodesic dome. The name comes from Tullio Regge, who introduced the idea in 1961. In this framework, gravity is encoded in the lengths of the edges and the angles where pieces meet, and the Einstein equations become algebraic conditions on those lengths.

The module ReggeBlochFold4D applies a standard tool from solid-state physics, the Bloch wave, to this discrete geometry. A Bloch wave is a plane wave modulated by a periodic function, used to describe electrons in a crystal lattice. Here the lattice is the discrete spacetime, and the wave is a probe with a finite momentum. The module computes a specific quantity, the fold, which is a sum over all the triangular hinges in one cell of the lattice, weighted by phase factors that depend on the wave's momentum.

The central result is a set of machine-checked theorems about this fold. The framework's library, a machine-checked collection of formal theorems, proves that the fold is bilinear in the metric perturbation, that it vanishes at zero momentum for certain components, and that at a special wave vector it takes exact integer values. Specifically, at the wave vector (π/2, π/2, π/2, 0), the contribution from one class of terms sums to -3, and the contribution from a gauge-like term sums to -4 + 4√2. These are not approximations; they are exact identities.

What does this establish? It shows that the discrete model behaves in a controlled, predictable way under a finite-momentum probe. The exact integer outcomes are a sign of internal consistency, a check that the complicated sums over 72 slots and 240 orientations do not hide errors. The module explicitly does not claim to have derived the continuum Einstein-Hilbert action, nor does it prove that this discrete model converges to general relativity in the continuum limit. Those remain open targets.

The practical consequence is a rigorous test bed. Future work can use this fold as a building block to compare the discrete model against the known continuum physics of gravity, one step at a time. The exact results here provide a clean, checkable baseline for that comparison.

/-- Honest transported finite-momentum `(1,1)` Bloch fold (72 instances). -/
def blochFold11 (H : Mat4) (m : Fin 4 → ℝ) : ℝ :=
  ∑ s : Fin 24, ∑ t : Fin 10, transportedSlotTerm H m s t

/-- Certificate sum for axis TT at `m⋆`: `-3`. -/
theorem sum_axisStarContrib :
    (∑ s : Fin 24, ∑ t : Fin 10, axisStarContrib s t) = (-3 : ℝ) := by
  unfold axisStarContrib
  set a : ℝ := -Real.sqrt 2 / 8
  set b : ℝ := -1 / 4 + Real.sqrt 2 / 8
  have hterm : ∀ s t,
      (if axisStarKind s t = 1 then a
        else if axisStarKind s t = 2 then b else (0 : ℝ)) =
        a * (if axisStarKind s t = 1 then (1 : ℝ) else 0) +
          b * (if axisStarKind s t = 2 then (1 : ℝ) else 0) := by
    intro s t
    have hk : axisStarKind s t ≤ 2 := by
      unfold axisStarKind; split_ifs <;> simp
    match h : axisStarKind s t with
    | 0 => simp
    | 1 => simp
    | 2 => simp
    | n + 3 => omega
  simp_rw [hterm, Finset.sum_add_distrib, ← Finset.mul_sum]
  have hc1 :
      (∑ s : Fin 24, ∑ t : Fin 10,
          if axisStarKind s t = 1 then (1 : ℝ) else 0) = 12 := by
    simpa [Nat.cast_sum] using
      congrArg (fun n : ℕ => (n : ℝ)) axisStarKind_count1
  have hc2 :
      (∑ s : Fin 24, ∑ t : Fin 10,
          if axisStarKind s t = 2 then (1 : ℝ) else 0) = 12 := by
    simpa [Nat.cast_sum] using
      congrArg (fun n : ℕ => (n : ℝ)) axisStarKind_count2
  rw [hc1, hc2]
  -- a*12 + b*12 = -3
  unfold a b
  ring

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

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

What this page does not claim

The module does not prove convergence to general relativity. The module does not evaluate the mass-squared Taylor coefficient against the continuum symbol. The module does not establish any physical prediction about gravity in our universe.

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: