Gravity Seven Gaps Measure Substrate Blocker

The missing rule for counting

The ledger, a discrete record of events, needs a way to assign a mass to each class of equivalent triangulations. The framework's gravity program reaches a fork: several plausible rules for this mass all satisfy basic requirements like relabeling invariance and normalization. The module MeasureSubstrateBlocker settles which rule is forced, and it does so by proving that the basic requirements alone are not enough.

The classical setting is counting objects up to symmetry. If two triangulations differ only by a relabeling of their parts, they are equivalent. A mass function assigns a real number to each equivalence class. The naive rule assigns mass 1 to every class. A more refined rule assigns each class a mass of 1 divided by the size of its automorphism group, the number of ways the object can be relabeled onto itself. The refined rule is the one that appears throughout mathematics when symmetries matter, for example in Burnside's lemma.

The module proves an exact equivalence: a mass function satisfies the principle of normalized gauge counting if and only if it assigns 1 divided by the automorphism group size to every class. The principle states that the mass of a class, multiplied by the number of labeled copies with relabeling witnesses, equals the total number of labeled copies. The forward direction is a derivation from the orbit-stabilizer theorem. The reverse direction shows that no hidden weaker condition is lurking in the statement.

The proof then shows the naive uniform rule fails. On a two-point class, the required mass is 1/2, but the uniform rule assigns 1. This failure is not a defect of the uniform rule alone; it proves that the refined principle is genuinely discriminating. The basic invariance axioms admit the uniform rule as a live decoy, and only the stronger principle eliminates it.

In Recognition Science, this result is a certified blocker. It identifies the exact extra premise that the gravity program still needs: a derivation of normalized gauge counting from richer ledger structure. The module proves that this premise is not a restatement of the invariance axioms, and it does not claim to supply that derivation. The blocker is precise, and the path forward is clear.

/-- **Exact blocker theorem.** Normalized gauge counting is equivalent to
assigning `1 / |Aut K|` to every represented bounded complex. The forward
direction is the orbit-stabilizer derivation. The reverse direction shows
that no weaker unnamed condition is hidden in the counting statement. -/
theorem gaugeCountingPrinciple_iff_mu_on_representatives {B : ℕ}
    (ν : TriangulationClass B → ℝ) :
    GaugeCountingPrinciple ν ↔
      ∀ K : BoundedComplex B,
        ν (Quotient.mk (relabelSetoid B) K) = mu K := by
  rw [gaugeCountingPrinciple_iff_eq_gaugeOrbitMass]
  constructor
  · intro hν K
    rw [hν]
    exact gaugeOrbitMass_eq_mu K
  · intro hν
    funext c
    refine Quotient.inductionOn c ?_
    intro K
    exact (hν K).trans (gaugeOrbitMass_eq_mu K).symm

/-- The quotient-uniform decoy fails normalized gauge counting on the
two-point class, where the required mass is `1/2`. This proves that the
extra principle is discriminating and does not restate class invariance. -/
theorem uniformClassMass_not_gaugeCounting (B : ℕ) (hB : 2 ≤ B) :
    ¬ GaugeCountingPrinciple
      (uniformClassMass : TriangulationClass B → ℝ) := by
  intro h
  have hmu :=
    (gaugeCountingPrinciple_iff_mu_on_representatives
      (uniformClassMass : TriangulationClass B → ℝ)).mp h
      (MeasureInvarianceNoGo.twoPointComplex B hB)
  unfold uniformClassMass at hmu
  rw [MeasureInvarianceNoGo.mu_twoPointComplex B hB] at hmu
  norm_num at hmu

/-- **Certified blocker package.** Gauge counting exists and selects
`1/|Aut|`; the quotient-uniform decoy fails it. What remains is precisely a
ledger theorem supplying `GaugeCountingPrinciple`, not more invariance. -/
theorem substrate_measure_blocker_certificate (B : ℕ) (hB : 2 ≤ B) :
    GaugeCountingPrinciple
        (gaugeOrbitMass : TriangulationClass B → ℝ) ∧
      (∀ ν : TriangulationClass B → ℝ,
        GaugeCountingPrinciple ν ↔
          ∀ K : BoundedComplex B,
            ν (Quotient.mk (relabelSetoid B) K) = mu K) ∧
      ¬ GaugeCountingPrinciple
        (uniformClassMass : TriangulationClass B → ℝ) :=
  ⟨gaugeOrbitMass_satisfies,
    gaugeCountingPrinciple_iff_mu_on_representatives,
    uniformClassMass_not_gaugeCounting B hB⟩

What this page does not claim

The module does not derive normalized gauge counting from ledger structure. The module does not claim the uniform rule is the only alternative that fails. The module does not provide a physical interpretation of the mass function.

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