Cost Gauge Orbit From Real Character Sign Gauge Native Cost Character Not Odd Po

A sign-only cost

A cost function assigns a number to every ratio, and in the Recognition Science framework these costs live on a discrete orbit of ratios rather than on a continuum. The framework's library, a machine-checked collection of formal theorems, defines one particular cost called signGaugeNativeCost, which is as simple as a cost can be: it returns 0 for a positive ratio, -1 for zero, and -2 for a negative ratio. It reads only the sign, nothing else.

The declaration signGaugeNativeCost_character_not_oddPower proves that this sign-only cost is not a member of the odd-power family. The odd-power family consists of costs of the form x times |x| raised to an odd exponent, written as x * |x|^(2k+1). The theorem states that for every natural number k, the sign cost evaluated at the ratio 2 is not equal to 2^(2k+1). Since the two disagree at a single point, they cannot be the same function. The proof is a direct computation: the sign cost at 2 returns 0, while every odd power of 2 is positive.

This negative result has a positive consequence. The framework's library also proves that every structural cost, one satisfying the basic hypotheses of the framework, has a real-character factorization. The sign cost satisfies those hypotheses, so it has such a factorization. The theorem then shows that the sign cost's character, the component that carries its multiplicative structure, has exponent zero. That exponent zero is what makes the sign cost distinct from every odd-power cost, whose character has a positive exponent. The sign cost is therefore its own irreducible member of the cost family, not a special case of a power law.

What the declaration does not claim is just as important. It does not say that the sign cost is the only cost outside the odd-power family, nor does it say that the sign cost is the unique cost with a character exponent of zero. It proves only that the sign cost is not an odd-power cost. The broader classification of all possible costs remains open, and the sign cost is a concrete example of a cost that the odd-power family cannot capture.

/-- The extracted sign character is not any positive odd-integer power,
already at the anchor. -/
theorem signGaugeNativeCost_character_not_oddPower (k : ℕ) :
    IndisputableMonolith.Cost.RealCharacterFactorization.realCharacterCandidate
        signGaugeNativeCost
        (IndisputableMonolith.Cost.RealCharacterFactorization.natOrbit 2) ≠
      (2 : ℝ) ^ (2 * k + 1) := by
  rw [signGaugeNativeCost_realCharacterCandidate,
    IndisputableMonolith.Cost.RealCharacterFactorization.natOrbit_toRat]
  have hsign :
      IndisputableMonolith.Cost.RealCharacterFactorization.rationalSignCharacter
        (((2 : ℕ) : ℚ)) = 1 := by
    norm_num
      [IndisputableMonolith.Cost.RealCharacterFactorization.rationalSignCharacter]
  rw [hsign]
  exact ne_of_lt (one_lt_pow₀ (by norm_num) (by omega))

/-- The cost generated by the sign character. -/
def signGaugeNativeCost (q : RatioOrbit) : RatioOrbit :=
  if 0 < q.toRat then RatioOrbit.zero
  else if q.toRat = 0 then ratioOrbitOfRat (-1)
  else ratioOrbitOfRat (-2)

/-- The structural ledger fields imply the light hypothesis pack used by the
real-character factorization theorem. -/
theorem realCharacterFactorizationHypotheses_of_structural
    {F : RatioOrbit → RatioOrbit}
    (hF : PRCStructuralNativeCostHypothesesSansAnchor F) :
    IndisputableMonolith.Cost.RealCharacterFactorization.SansAnchorHypotheses F where
  base_sans_two :=
    { reciprocal := hF.base_sans_two.reciprocal
      normalized_invariant := hF.base_sans_two.normalized_invariant
      canonical_rcl := hF.base_sans_two.canonical_rcl
      unit_zero := hF.base_sans_two.unit_zero }
  sign_reversing := fun q r hr => hF.sign_reversing q r hr
  monotone := by
    intro a b ha hb hab
    exact hF.monotone a b ha hb hab
  zero_calibrated := hF.zero_calibrated

/-- The extracted character has exponent zero. -/
theorem signGaugeNativeCost_characterExponent_zero :
    IndisputableMonolith.Cost.RealCharacterFactorization.exponentOfCharacter
      (IndisputableMonolith.Cost.RealCharacterFactorization.realCharacterCandidate
        signGaugeNativeCost) = 0 := by
  rw [IndisputableMonolith.Cost.RealCharacterFactorization.exponentOfCharacter,
    signGaugeNativeCost_realCharacterCandidate,
    IndisputableMonolith.Cost.RealCharacterFactorization.natOrbit_toRat]
  have hsign :
      IndisputableMonolith.Cost.RealCharacterFactorization.rationalSignCharacter
        (((2 : ℕ) : ℚ)) = 1 := by
    norm_num
      [IndisputableMonolith.Cost.RealCharacterFactorization.rationalSignCharacter]
  rw [hsign]
  norm_num

What this page does not claim

The declaration does not claim the sign cost is the only cost outside the odd-power family. The declaration does not claim the sign cost is the unique cost with a character exponent of zero. The declaration does not claim a full classification of all possible costs.

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