Encyclopedia Gravity Gravity Seven Gaps Exact Shell Gauge Preflight Labeled Z Eq Orbit Weighted Class

ARTICLE 5 claims 4 theorems 1 model

Gravity Seven Gaps Exact Shell Gauge Preflight Labeled Z Eq Orbit Weighted Class

A machine-checked theorem shows that a sum over every labeled triangulation equals a sum over classes of equivalent ones, with each class weighted by its symmetry count.

Verify this page

The labeled sum as a class sum

In discrete gravity, one often sums a quantity over every possible labeled triangulation of a space. This is the labeled path sum, written Z. The theorem labeledZ_eq_orbitWeighted_classSum states a useful equality: if the quantity being summed assigns the same value to any two triangulations that differ only by relabeling, then the sum over all labeled triangulations equals a sum over equivalence classes of triangulations. Each class is weighted by the number of labeled triangulations in it, times a mass factor, times the value of the quantity on a representative of the class.

The mass factor is the heart of the result. It is defined as the number of labeled triangulations in a class divided by the number of pairs consisting of a labeled triangulation and a relabeling witness connecting it to a fixed representative. This ratio, called the gauge orbit mass, turns out to equal 1 divided by the number of symmetries of the representative. The theorem proves this equality using a standard orbit-stabilizer argument: the relabelings between two equivalent triangulations form a torsor over the automorphism group, so their count equals the group size.

The theorem also proves that this mass is the unique one satisfying a natural counting property: the mass of a class times the pair count equals the orbit size. This pins down the measure uniquely. The path-sum corollary then follows: for a relabeling-invariant weight, the labeled sum decomposes into a class sum with these orbit-weighted coefficients.

In Recognition Science, this result is part of a preflight check for a gauge theory of discrete gravity. It derives the standard symmetry-factor measure from a counting principle, rather than postulating it. The counting principle itself, that each labeled copy and witness pair carries equal weight, is a model choice. It is not derived from the ledger cost function; a separate flag in the library records that this derivation remains open.

The practical consequence is a tool for computation: instead of summing over all labeled triangulations, one can sum over classes, with the orbit size providing the correct weighting. This is a common technique in physics, and the theorem provides a machine-checked foundation for it in this framework.

THEOREM labeledZ_eq_orbitWeighted_classSum · IndisputableMonolith/Gravity/SevenGaps/ExactShellGaugePreflight.lean
labeledZ_eq_orbitWeighted_classSum · IndisputableMonolith/Gravity/SevenGaps/ExactShellGaugePreflight.lean:321 
/-- **THEOREM (diagnostic fragment).**  For a relabeling-invariant weight,
the labeled path sum with the `1/|Aut|` measure equals the class sum
weighted by orbit size times the COUNTING-DERIVED mass:
`Z = Σ_c orbitCard c * gaugeOrbitMass c * w(rep c)`.
The measure in `Z` is now carried entirely by counting data. -/
theorem labeledZ_eq_orbitWeighted_classSum (B : ℕ) (w : BoundedComplex B → ℂ)
    (hinv : ∀ K K', Equivalent K K' → w K = w K') :
    Z B w = ∑ c : TriangulationClass B,
      (orbitCardClass c : ℂ) * (gaugeOrbitMass c : ℂ) * w (Quotient.out c) := by
  classical
  unfold Z
  rw [← Fintype.sum_fiberwise
    (fun K : BoundedComplex B => Quotient.mk (relabelSetoid B) K)
    (fun K : BoundedComplex B => (mu K : ℂ) * w K)]
  refine Finset.sum_congr rfl fun c _ => ?_
  have hc : Quotient.mk (relabelSetoid B) (Quotient.out c) = c := Quotient.out_eq c
  have hmem : ∀ K : {K : BoundedComplex B // Quotient.mk (relabelSetoid B) K = c},
      Equivalent (Quotient.out c) K.val := fun K =>
    Quotient.exact (hc.trans K.property.symm)
  have hmass : gaugeOrbitMass c = mu (Quotient.out c) := by
    conv_lhs => rw [← hc]
    exact gaugeOrbitMass_eq_mu (Quotient.out c)
  have e : {K : BoundedComplex B // Quotient.mk (relabelSetoid B) K = c}
      ≃ {K' : BoundedComplex B // Equivalent (Quotient.out c) K'} :=
    Equiv.subtypeEquivRight fun K =>
      ⟨fun hK => Quotient.exact (hc.trans hK.symm),
       fun hE => by
        have h1 : Quotient.mk (relabelSetoid B) (Quotient.out c)
            = Quotient.mk (relabelSetoid B) K := Quotient.sound hE
        exact h1.symm.trans hc⟩
  have hcard : Fintype.card {K : BoundedComplex B // Quotient.mk (relabelSetoid B) K = c}
      = orbitCardClass c := by
    rw [Fintype.card_eq_nat_card, Nat.card_congr e]
    conv_rhs => rw [← hc]
    rfl
  calc ∑ K : {K : BoundedComplex B // Quotient.mk (relabelSetoid B) K = c},
        (mu K.val : ℂ) * w K.val
      = ∑ _K : {K : BoundedComplex B // Quotient.mk (relabelSetoid B) K = c},
          (mu (Quotient.out c) : ℂ) * w (Quotient.out c) :=
        Finset.sum_congr rfl fun K _ =>
          (summand_class_constant B w hinv (hmem K)).symm
    _ = (Fintype.card {K : BoundedComplex B // Quotient.mk (relabelSetoid B) K = c} : ℂ) *
          ((mu (Quotient.out c) : ℂ) * w (Quotient.out c)) := by
        rw [Finset.sum_const, Finset.card_univ, nsmul_eq_mul]
    _ = (orbitCardClass c : ℂ) * (gaugeOrbitMass c : ℂ) * w (Quotient.out c) := by
        rw [hcard, hmass, mul_assoc]
THEOREM gaugeOrbitMass · IndisputableMonolith/Gravity/SevenGaps/ExactShellGaugePreflight.lean
gaugeOrbitMass · IndisputableMonolith/Gravity/SevenGaps/ExactShellGaugePreflight.lean:265 
/-- **The gauge-counting mass of a class**: labeled copies per unit of
gauge volume.  DEFINITION mentions only the two counting quantities
(`orbitCardClass`, `pairCountClass`); no `mu`, no `Aut`.  This is the
explicit counting principle: uniform gauge density on labeled
representatives. -/
noncomputable def gaugeOrbitMass (c : TriangulationClass B) : ℝ :=
  (orbitCardClass c : ℝ) / (pairCountClass c : ℝ)
THEOREM gaugeOrbitMass_eq_mu · IndisputableMonolith/Gravity/SevenGaps/ExactShellGaugePreflight.lean
gaugeOrbitMass_eq_mu · IndisputableMonolith/Gravity/SevenGaps/ExactShellGaugePreflight.lean:273 
/-- **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 gaugeCountingMass_unique · IndisputableMonolith/Gravity/SevenGaps/ExactShellGaugePreflight.lean
gaugeCountingMass_unique · IndisputableMonolith/Gravity/SevenGaps/ExactShellGaugePreflight.lean:298 
/-- **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
MODEL status_counting_principle_open · IndisputableMonolith/Gravity/SevenGaps/ExactShellGaugePreflight.lean
status_counting_principle_open · IndisputableMonolith/Gravity/SevenGaps/ExactShellGaugePreflight.lean:396 
/-- 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 is not derived from the ledger cost function; it remains a model premise. The theorem does not compute the numerical value of any path sum; it only establishes an equality between two forms of the sum. The result does not imply that the gauge orbit mass is the only possible measure, only the unique one satisfying the stated counting property.

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:

MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND