Foundation Maximal Forcing Rscost Universe Tightening L0 Lcost Effective

The tightening that does real work

A cost function is a rule that assigns a number to an event, meant to represent the price of recognizing that event. The Recognition Science framework studies such functions under a discrete record of events, its ledger. The central question is whether the cost is forced by logic alone or remains a free choice. The declaration tightening_L0_Lcost_effective answers that question for two specific classes of candidate costs.

The loose class, called L0, contains every continuous cost function on the positive real numbers. Continuity is a mild smoothness condition: small changes in the input produce small changes in the output. Over this broad class, the claim that the cost equals the canonical function J is independent. Independence means both outcomes are possible: the canonical J itself is continuous and satisfies the claim, but so does the constant-zero function, which assigns zero to every input and therefore does not equal J. Without further restrictions, the cost is not forced.

The tight class, called Lcost, adds five gate conditions that the framework's Law of Logic imposes on any recognition cost: reciprocal symmetry, normalization to zero at unity, a composition law for combining costs, calibration, and continuity. These are not arbitrary; they are the conditions under which a published uniqueness theorem applies. The declaration shows that over Lcost, the claim "F equals J" is forced. Every admissible cost function in this class must equal the canonical J on the positive reals. The proof wraps the existing uniqueness theorem with no new axioms.

The effective part is the contrast. The same claim is independent over L0 but forced over Lcost. This proves the tightening is legitimate, not cosmetic. The five gate conditions do real classificatory work: they convert a free claim into a forced one. Without this contrast, the forcing result could be dismissed as a relabeling artifact. The declaration establishes that the gates, not the labels, are what force J.

/-- Over the loose class `L0`, "equals J" is independent: `Jcost` is a continuous
candidate cost that satisfies it, and the constant-zero function is a continuous
candidate cost that does not. -/
theorem isJ_independent_over_L0 : Independent L0.admissible isJClaim := by
  refine ⟨Cost.Jcost, (fun _ => (0 : ℝ)), ?_, ?_, ?_, ?_⟩
  · show ContinuousOn Cost.Jcost (Set.Ioi 0)
    exact IndisputableMonolith.CostUniqueness.Jcost_continuous_pos
  · show ContinuousOn (fun _ => (0 : ℝ)) (Set.Ioi 0)
    exact continuousOn_const
  · intro x _; rfl
  · intro h
    have h2 := h 2 (by norm_num)
    simp only [Cost.Jcost] at h2
    norm_num at h2

/-- **Phase 2.1.** Over the gate class, "equals `J`" is forced. This wraps the
published uniqueness theorem `law_of_logic_forces_jcost` with no new content and
no new axioms: the `AczelSmoothnessPackage` instance comes from `Cost.AczelProof`.
-/
theorem forced_isJ : Forced Lcost.admissible isJClaim := by
  intro F hF x hx
  obtain ⟨hRecip, hNorm, hComp, hCalib, hCont⟩ := hF
  exact law_of_logic_forces_jcost F hRecip hNorm hComp hCalib hCont x hx

/-- **The tightening is legitimate, not cheap.** `isJClaim` is independent over
`L0` but forced over `Lcost`. The gate conditions do real classificatory work:
they convert a free claim into a forced one. This is the per-step legitimacy
evidence the Phase 5 ladder requires for the `L0 → Lcost` rung. -/
theorem tightening_L0_Lcost_effective :
    Independent L0.admissible isJClaim ∧ Forced Lcost.admissible isJClaim :=
  ⟨isJ_independent_over_L0, forced_isJ⟩

What this page does not claim

The declaration does not prove that the five gate conditions are necessary for forcing J. It does not claim that the constant-zero function is a physically meaningful cost, only that it is continuous. It does not derive any specific value for J or any physical constant.

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/Foundation/MaximalForcing/RSCostUniverse.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: