Cost Gauge Orbit Classification Sign Gauge Sees Orientation Only

What the sign gauge sees

A cost function, in the Recognition Science framework, assigns a number to each ratio of two quantities, a number that represents the price reality pays to recognize that ratio as a distinct event. The framework's library, a machine-checked collection of formal theorems, proves that under the full structural axioms this cost must take one of two forms. The theorem named signGauge_sees_orientation_only characterizes the degenerate member of that family.

In plain terms, the theorem states that the sign gauge cost function returns exactly two values: zero for every positive ratio, and minus two for every negative ratio. It sees only the orientation, the sign, of the ratio, and is blind to its magnitude. The formal statement in the library is a theorem about the function signGaugeNativeCost, and it is proved by a direct case split on the sign of the input ratio. This is the simplest possible non-constant cost rule consistent with the framework's axioms.

The broader classification result, GaugeOrbitIsSignedPowerFamily_of_sixExponentials, proves that any cost function satisfying the structural hypotheses is either this sign gauge or a member of the signed power family, where the cost of a positive ratio x is J(x^k) for some integer k. The sign gauge is the case where the exponent is effectively zero, collapsing all positive ratios to a single cost. The theorem charges_at_two_iff_not_signGauge draws the boundary: a cost function charges a nonzero cost at the ratio 2 if and only if it is not the sign gauge.

What the theorem does not claim is equally important. It does not say that the sign gauge is the cost function that nature uses; that would be a physical claim the framework does not make. It does not assert that the sign gauge is the unique solution to the axioms, only that it is one member of the classified family. And it says nothing about what happens at the ratio zero, where the framework's axioms force the cost to be minus one, a value the sign gauge theorem does not address.

/-- What the degenerate member actually is. It charges the full reversal penalty at every
negative ratio and nothing at every positive one: a cost that records orientation and never
magnitude. So the nondegeneracy hypothesis is not "assume cost is not free"; it is "assume
cost sees how far apart the two sides are". -/
theorem signGauge_sees_orientation_only (q : RatioOrbit) :
    (0 < q.toRat → (signGaugeNativeCost q).toRat = 0) ∧
      (q.toRat < 0 → (signGaugeNativeCost q).toRat = -2) := by
  refine ⟨fun hq => ?_, fun hq => ?_⟩
  · rw [signGaugeNativeCost_toRat, signGaugeCostDisplay, if_pos hq]
  · rw [signGaugeNativeCost_toRat, signGaugeCostDisplay, if_neg (not_lt.mpr hq.le),
      if_neg (ne_of_lt hq)]

/-- **The anchor-free gauge classification, on one named import.** Every inhabitant of the
anchor-free structural cost ledger is the sign cost or the sign-extended power cost of a
nonnegative integer exponent. The only hypothesis is the six exponentials input; the Erdős
step is now the theorem `Cost.MonotonePower.exists_exponent`.

Two things this does NOT say. It does not say the exponent is odd: both parities are
inhabited, by construction in `GaugeOrbitFromRealCharacter`. And it does not select `J`:
selection is leastness, which lives in `Cost.UnitFromMinimality`. -/
theorem GaugeOrbitIsSignedPowerFamily_of_sixExponentials
    (hsix : SixExponentialsTraceInput) : GaugeOrbitIsSignedPowerFamily := by
  intro G hG
  have hS := realCharacterFactorizationHypotheses_of_structural hG
  by_cases htwo : rationalTrace G 2 = 2
  · exact Or.inl (degenerate_is_signGauge hS htwo)
  · obtain ⟨k, hk1, hk⟩ := exists_nat_exponent hsix hS htwo
    exact Or.inr ⟨k - 1, nontrivial_is_signedPower hS htwo hk1 hk⟩

/-- **Nondegeneracy is exactly the exclusion of the sign cost**, with no reference to
exponents and no appeal to the classification. -/
theorem charges_at_two_iff_not_signGauge (hS : SansAnchorHypotheses F) :
    (F two).toRat ≠ 0 ↔
      ¬ ∀ q : RatioOrbit, RatioOrbit.crossEq (F q) (signGaugeNativeCost q) := by
  constructor
  · intro hne hall
    have h := crossDisp (hall two)
    rw [signGaugeNativeCost_toRat, two_toRat, signGaugeCostDisplay,
      if_pos (by norm_num : (0 : ℚ) < 2)] at h
    exact hne h
  · intro hnot hzero
    exact hnot (degenerate_is_signGauge hS ((vanishes_at_two_iff_trace_two hS).mp hzero))

What this page does not claim

The sign gauge is the cost function that nature uses. The sign gauge is the unique solution to the framework's axioms. The sign gauge theorem says anything about the cost at ratio zero.

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/Cost/GaugeOrbitClassification.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: