Cost Gauge Orbit Classification Strict Somewhere Iff Charges At Two

The classification theorem

In the Recognition Science framework, a ledger (a discrete record of recognition events) assigns a cost to every ratio of quantities. The framework's central theorem forces the cost to be J(x) = (x + 1/x)/2 - 1, but that theorem assumes a strong condition: the cost must vanish at unity. The declaration strict_somewhere_iff_charges_at_two drops that assumption and asks a simpler question: when does a cost function show any variation at all?

The answer, proved in the machine-checked library of formal theorems, is a clean dichotomy. If a cost function F is strictly increasing somewhere (there exist positive ratios a < b with F(a) < F(b)), then F(2) is nonzero. Conversely, if F(2) is nonzero, then F is strictly increasing somewhere. The theorem states this as an iff: (∃ a b, 0 < a ≤ b ∧ F a < F b) ↔ F 2 ≠ 0. The number 2 is not arbitrary; it is the smallest integer greater than 1, and the cost at 2 acts as a detector for whether the function is nontrivial.

The proof splits into two cases. If F(2) = 0, the function is flat: it assigns cost zero to every positive ratio. This is the sign gauge, which sees only the sign of a ratio, not its magnitude. If F(2) ≠ 0, the function is not flat, and the theorem shows it must be strictly increasing somewhere. The proof uses the trace order: for values above 1, the map v ↦ v + v⁻¹ is strictly increasing, so an inequality between traces becomes an inequality between the values themselves.

What the theorem does not claim is equally important. It does not say that a nonzero cost at 2 forces the specific J form; that requires the full set of five axioms. It does not say that the cost is strictly increasing everywhere, only somewhere. And it does not identify which ratios a and b witness the strict increase; the theorem is an existence statement, not a construction. The classification is a dichotomy between flat and non-flat, with the non-flat case opening the door to the signed power family of costs, but not to the unique J itself.

/-- **Nondegeneracy is the strict form of the ledger's monotonicity.** Charging anything at
orbit two is equivalent to the cost order being strict at some pair of positive ratios. The
ledger assumes monotonicity non-strictly (`PRCNativeCostMonotone` is `≤ → ≤`), and the only
inhabitant that keeps it flat is the sign cost. -/
theorem strict_somewhere_iff_charges_at_two (hS : SansAnchorHypotheses F) :
    (∃ a b : RatioOrbit, 0 < a.toRat ∧ 0 < b.toRat ∧ a.toRat ≤ b.toRat ∧
        (F a).toRat < (F b).toRat)
      ↔ (F two).toRat ≠ 0 := by
  constructor
  · rintro ⟨a, b, ha, hb, -, hlt⟩ hzero
    have hflat := (vanishes_at_two_iff_flat hS).mp hzero
    rw [hflat a ha, hflat b hb] at hlt
    exact absurd hlt (lt_irrefl 0)
  · intro hne
    refine ⟨RatioOrbit.one, two, ?_, ?_, ?_, ?_⟩
    · rw [RatioOrbit.one_toRat]; norm_num
    · rw [two_toRat]; norm_num
    · rw [RatioOrbit.one_toRat, two_toRat]; norm_num
    · rw [hS.base_sans_two.unit_zero, RatioOrbit.zero_toRat]
      exact charges_positively_at_two hS hne

/-- **Nondegeneracy is the strict form of the ledger's monotonicity.** Charging anything at
orbit two is equivalent to the cost order being strict at some pair of positive ratios. The
ledger assumes monotonicity non-strictly (`PRCNativeCostMonotone` is `≤ → ≤`), and the only
inhabitant that keeps it flat is the sign cost. -/
theorem strict_somewhere_iff_charges_at_two (hS : SansAnchorHypotheses F) :
    (∃ a b : RatioOrbit, 0 < a.toRat ∧ 0 < b.toRat ∧ a.toRat ≤ b.toRat ∧
        (F a).toRat < (F b).toRat)
      ↔ (F two).toRat ≠ 0 := by
  constructor
  · rintro ⟨a, b, ha, hb, -, hlt⟩ hzero
    have hflat := (vanishes_at_two_iff_flat hS).mp hzero
    rw [hflat a ha, hflat b hb] at hlt
    exact absurd hlt (lt_irrefl 0)
  · intro hne
    refine ⟨RatioOrbit.one, two, ?_, ?_, ?_, ?_⟩
    · rw [RatioOrbit.one_toRat]; norm_num
    · rw [two_toRat]; norm_num
    · rw [RatioOrbit.one_toRat, two_toRat]; norm_num
    · rw [hS.base_sans_two.unit_zero, RatioOrbit.zero_toRat]
      exact charges_positively_at_two hS hne

/-- **Charging nothing at one point is charging nothing anywhere.** An inhabitant that is
free at orbit two is free at every positive ratio, however far apart its sides are. -/
theorem vanishes_at_two_iff_flat (hS : SansAnchorHypotheses F) :
    (F two).toRat = 0 ↔ ∀ q : RatioOrbit, 0 < q.toRat → (F q).toRat = 0 := by
  constructor
  · intro h q hq
    have hd := cost_display hS q
    rw [rationalTrace_pos_eq_two_of_two_eq_two hS ((vanishes_at_two_iff_trace_two hS).mp h) hq]
      at hd
    have hz : ((F q).toRat : ℝ) = 0 := by rw [hd]; norm_num
    exact_mod_cast hz
  · intro h
    exact h two (by rw [two_toRat]; norm_num)

What this page does not claim

The theorem does not force the specific J(x) = (x + 1/x)/2 - 1 form; that requires the full set of five axioms. The theorem does not say the cost is strictly increasing everywhere, only somewhere. The theorem does not construct the ratios a and b that witness the strict increase.

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: