Gravity Seven Gaps Measure Substrate Blocker Gauge Counting Principle Iff Mu On

The gauge counting principle

A triangulation class is a set of geometric objects, built from triangles, that are considered the same shape because one can be relabeled into another. In Recognition Science, the framework's library of formal theorems studies how to assign a mass, a real number weight, to each such class. The gauge counting principle is a rule for doing this: it says the mass of a class, multiplied by the number of ways one object in the class can be relabeled into another, must equal the number of distinct labeled objects in the class. This is a precise, bookkeeping-style condition that connects the weight of a shape class to its internal symmetries.

The theorem gaugeCountingPrinciple_iff_mu_on_representatives states that this principle holds if and only if every class receives the mass 1 divided by the size of its automorphism group, the set of relabelings that map an object to itself. In plainer terms, the rule forces a specific, symmetry-based weighting: the more symmetric a shape is, the less mass its class gets. The theorem is an equivalence, meaning the principle and the 1 over automorphism size rule are exactly the same condition, with no hidden extra assumptions. The framework's library proves this in Lean, a machine-checked collection of formal theorems, with no gaps or unproved axioms.

The result has a sharp edge. A simpler-looking rule, assigning mass 1 to every class, also satisfies the weaker requirement of invariance under relabeling. The theorem shows this uniform rule fails the gauge counting principle, for instance on a class with two objects where the required mass is one half. This proves the principle is not just a restatement of invariance; it is a genuinely stronger condition that selects the symmetry-based weighting uniquely. The framework's library certifies this as a blocker: the principle cannot be derived from the weaker axioms alone, and it must be supplied by a richer structure, a ledger of discrete recognition events.

What the theorem does not claim is that the gauge counting principle itself is proved. The theorem is conditional: if the principle holds, then the mass formula follows, and vice versa. The principle remains a MODEL premise, a definitional choice about how mass should behave, not a derived consequence. The framework's library explicitly records this status. The theorem also does not claim that the uniform rule is the only alternative, nor does it say anything about which physical situations, if any, actually satisfy the gauge counting principle. Those questions remain open targets for further work within the framework.

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

/-- The exact extra principle used by the gauge-counting derivation: class
mass times gauge-witness volume equals labeled orbit size. -/
def GaugeCountingPrinciple {B : ℕ}
    (ν : TriangulationClass B → ℝ) : Prop :=
  ∀ c, ν c * (pairCountClass c : ℝ) = (orbitCardClass c : ℝ)

What this page does not claim

The gauge counting principle itself is not proved; it is a MODEL premise. The theorem does not say that the uniform rule is the only alternative that fails the principle. The theorem does not establish that any physical system actually satisfies the gauge counting principle.

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: