Gravity Seven Gaps Exact Shell Gauge Preflight

The gauge preflight

In discrete gravity, the path sum over triangulations of spacetime is weighted by a symmetry factor: each complex K contributes with weight 1 divided by the size of its automorphism group, |Aut K|. This factor corrects for overcounting when the same geometry appears many times under relabeling. The module called ExactShellGaugePreflight asks whether this factor can be derived rather than assumed. It proves that it can, from a counting principle about labeled complexes and their relabelings.

The counting starts with two quantities defined without ever mentioning the symmetry factor. For a complex K, gaugeOrbitCard K counts how many labeled complexes are equivalent to K, meaning how many distinct labelings present the same geometry. The second quantity, pairCount K, counts pairs (K', r) where K' is one of those equivalent complexes and r is a concrete relabeling witness from K to K'. This is the gauge volume of the orbit. The module proves a torsor result: for equivalent K and K', the relabeling witnesses form a torsor over the automorphism group, so their number equals |Aut K|. Consequently pairCount K factorizes as gaugeOrbitCard K times |Aut K|.

The derivation then defines the gauge orbit mass of a class as labeled copies divided by gauge volume: gaugeOrbitMass c = orbitCardClass c / pairCountClass c. The key result, gaugeOrbitMass_eq_mu, shows this counting-defined mass equals the postulated mu K = 1/|Aut K|. A uniqueness result, gaugeCountingMass_unique, proves that any class mass satisfying the counting property must equal this one. The counting principle pins the measure uniquely. A corollary rewrites the labeled path sum as a sum over equivalence classes, each weighted by orbit size times gauge mass times the weight of a representative.

In Recognition Science, the framework's machine-checked library of formal results establishes this derivation with zero new axioms. The status flags in the module confirm that the torsor property, the measure derivation, and the uniqueness are all proved. One flag stays false on purpose: the counting principle itself, the choice that each (copy, witness) pair carries equal weight, is a MODEL premise, not a result. The module identifies this premise and proves that the ledger cost function cannot supply it. The derivation shows what follows from the counting principle, but the principle remains a named assumption.

What this establishes in plain language is a clean separation. The standard symmetry factor 1/|Aut| is not a separate postulate in this framework; it follows from a single counting principle about uniform gauge density on labeled representatives. The counting principle is the only input, and it is flagged as such. The module does not claim to derive the counting principle from the ledger or from anything deeper. That question remains open, and the flag records it honestly.

/-- **THEOREM (torsor).**  Fixing one witness `r0 : Relabel K K'`, the map
`a ↦ a.trans r0` is a bijection `Aut K ≃ Relabel K K'`: the witnesses
between equivalent complexes are a torsor over the automorphism group. -/
def torsorEquiv {K K' : BoundedComplex B} (r0 : Relabel K K') :
    Aut K ≃ Relabel K K' where
  toFun a := a.trans r0
  invFun r := r.trans r0.symm
  left_inv a := by
    apply Relabel.ext <;>
      · apply Equiv.ext
        intro x
        simp only [Relabel.trans_vEquiv, Relabel.trans_eEquiv, Relabel.trans_tEquiv,
          Relabel.symm_vEquiv, Relabel.symm_eEquiv, Relabel.symm_tEquiv,
          Equiv.trans_apply, Equiv.symm_apply_apply]
  right_inv r := by
    apply Relabel.ext <;>
      · apply Equiv.ext
        intro x
        simp only [Relabel.trans_vEquiv, Relabel.trans_eEquiv, Relabel.trans_tEquiv,
          Relabel.symm_vEquiv, Relabel.symm_eEquiv, Relabel.symm_tEquiv,
          Equiv.trans_apply, Equiv.apply_symm_apply]

/-- **THEOREM (orbit-stabilizer, cardinal form).**  For equivalent
complexes, the witness count equals the automorphism count. -/
theorem relabelingCount_eq_autCard {K K' : BoundedComplex B}
    (h : Equivalent K K') : relabelingCount K K' = Nat.card (Aut K) := by
  obtain ⟨r0⟩ := h
  unfold relabelingCount
  exact (Nat.card_congr (torsorEquiv r0)).symm

/-- **THEOREM (pair-count factorization).**  The gauge volume of the orbit
is the orbit size times the automorphism count: every fiber of the
projection `(K', r) ↦ K'` is a torsor over `Aut K`. -/
theorem pairCount_eq_orbitCard_mul_autCard (K : BoundedComplex B) :
    pairCount K = gaugeOrbitCard K * Nat.card (Aut K) := by
  have e : (Σ K' : {K' : BoundedComplex B // Equivalent K K'}, Relabel K K'.val)
      ≃ {K' : BoundedComplex B // Equivalent K K'} × Aut K :=
    Equiv.sigmaEquivProdOfEquiv fun K' =>
      (torsorEquiv (Classical.choice K'.property)).symm
  unfold pairCount gaugeOrbitCard
  rw [Nat.card_congr e, Nat.card_prod]

/-- **THEOREM (the derivation).**  The counting-defined class mass equals
the postulated symmetry-factor measure: GIVEN the pair-counting principle,
`1/|Aut|` follows from orbit-stabilizer (`pairCount = orbitCard * |Aut|`)
rather than being written into the definition. -/
theorem gaugeOrbitMass_eq_mu (K : BoundedComplex B) :
    gaugeOrbitMass (Quotient.mk (relabelSetoid B) K) = mu K := by
  have ho : (gaugeOrbitCard K : ℝ) ≠ 0 := by
    exact_mod_cast (gaugeOrbitCard_pos K).ne'
  unfold gaugeOrbitMass mu
  rw [orbitCardClass_mk, pairCountClass_mk, pairCount_eq_orbitCard_mul_autCard,
    Nat.cast_mul, div_mul_eq_div_div, div_self ho]

/-- **THEOREM (uniqueness).**  Any class-mass assignment satisfying the
normalized gauge-divided counting property (`ν c * pairCount c =
orbitCard c` for every class) equals `gaugeOrbitMass`.  Given the counting
principle (the explicit MODEL premise of this module), the measure is
unique; combined with `gaugeOrbitMass_eq_mu`, it is forced to be
`1/|Aut|`. -/
theorem gaugeCountingMass_unique (ν : TriangulationClass B → ℝ)
    (hν : ∀ c, ν c * (pairCountClass c : ℝ) = (orbitCardClass c : ℝ))
    (c : TriangulationClass B) : ν c = gaugeOrbitMass c := by
  have hp : (pairCountClass c : ℝ) ≠ 0 := by
    exact_mod_cast (pairCountClass_pos c).ne'
  unfold gaugeOrbitMass
  rw [eq_div_iff hp]
  exact hν c

/-- OPEN (retracted 2026-07-26): the counting principle remains this
module's named premise and is not derived from the ledger. -/
theorem status_counting_principle_open :
    gaugePreflightStatus.counting_principle_derived_from_ledger = false := rfl

What this page does not claim

The counting principle itself is not derived from the ledger or any deeper principle. The module does not compute any numerical value for a path sum. The module does not claim that the ledger cost function implies label indifference.

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/SevenGaps/ExactShellGaugePreflight.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: