Foundation Ledger Composition To Jcost Ledger Composition Forces Jcost

The composition law as a ledger fact

The Recognition Science framework begins with a ledger, a discrete record of recognition events. The central question is what it costs to recognize one event given another. The framework's answer is a single function, J(x) = (x + 1/x)/2 - 1, which measures the cost of recognizing a ratio x between two events. The theorem ledgerComposition_forces_jcost establishes that this function is not chosen but forced: if a cost function satisfies five plain conditions, and if its two-point combination follows a ledger-posting rule, then it must equal J.

The key step is the composition law. For any two positive numbers x and y, the cost function must satisfy F(x·y) + F(x/y) = 2F(x)F(y) + 2F(x) + 2F(y). This is not an arbitrary assumption. The theorem shows this law is exactly the statement that the cost's two-point combination equals a specific combiner, rclCombiner(u,v) = 2uv + 2u + 2v, evaluated at the two costs. The composition law is thus a ledger fact: it says the cost composes through a particular binary operation, and that operation is the one the ledger forces.

The proof works in two stages. First, a directional ledger theorem already forces any primitive ledger-posting combiner with per-slice directional regularity to equal rclCombiner. Second, if a cost composes through such a combiner, then it satisfies the composition law. Feeding that law into the earlier law_of_logic_forces_jcost theorem, together with the reciprocal, normalized, calibrated, and continuity conditions, yields F = J on all positive numbers. The previously assumed composition-law hypothesis is replaced by a ledger-side statement: the cost composes through a ledger-posting combiner. The combiner-is-RCL half is now a theorem, not an assumption.

The construction is non-vacuous. The function J itself composes through rclCombiner, so J is a genuine fixed point of the entire ledger-composition setup. The certificate theorem records that every field of the closure is proved: the composition law is the RCL combiner law, ledger composition forces the composition law, ledger composition plus the other conditions forces J, and J composes consistently. The result is unconditional, with zero axioms beyond the standard three and zero sorry fields.

What the theorem does not claim is equally important. It does not say that every cost function satisfying the five conditions must compose through a ledger-posting combiner; that composability is the one remaining input, isolated as the bare factorization assumption. It does not derive the value of any physical constant. It does not prove the Riemann Hypothesis, and it does not claim that the framework's axioms are the only possible starting point. The theorem is a structural result about what the ledger forces, not a claim about the empirical world.

/-- **Ledger composition forces `J`.**  If the recognition cost `F` is
reciprocal, normalized, calibrated, and continuous on the positive ray, and it
composes through a combiner `P` that satisfies primitive ledger posting with
per-slice directional regularity, then `F = J` on positives.

This is the genuine discharge of the Phase 3 "Apply `law_of_logic_forces_jcost`"
item: the previously-assumed `SatisfiesCompositionLaw F` hypothesis is replaced
by the ledger-side pair (cost composes through `P`) ∧ (`P` is a ledger-posting
combiner), and the "combiner = RCL" half is a theorem, not an assumption. -/
theorem ledgerComposition_forces_jcost
    (F : ℝ → ℝ) (P : ℝ → ℝ → ℝ)
    (hRecip : IsReciprocalCost F)
    (hNorm : IsNormalized F)
    (hCalib : IsCalibrated F)
    (hCont : ContinuousOn F (Set.Ioi 0))
    (hP : PrimitiveLedgerPostingSemantics P)
    (hdir : ∀ u, Monotone (fun v => P u v) ∨ Antitone (fun v => P u v))
    (hCompose : CostComposesThrough F P) :
    ∀ x : ℝ, 0 < x → F x = Cost.Jcost x := by
  have hComp : SatisfiesCompositionLaw F :=
    satisfiesCompositionLaw_of_ledgerComposes F P hP hdir hCompose
  exact law_of_logic_forces_jcost F hRecip hNorm hComp hCalib hCont

/-- **The composition law is the RCL combiner law on costs.**  `F` satisfies the
recognition composition law iff its symmetric two-point combination
`F (x·y) + F (x/y)` equals `rclCombiner (F x) (F y)`.  This is a pure
rearrangement: `rclCombiner u v = 2uv + 2u + 2v` is the composition-law RHS with
`u = F x`, `v = F y`. -/
theorem satisfiesCompositionLaw_iff_rclCombiner (F : ℝ → ℝ) :
    SatisfiesCompositionLaw F ↔
      ∀ x y : ℝ, 0 < x → 0 < y →
        F (x * y) + F (x / y) = rclCombiner (F x) (F y) := by
  unfold SatisfiesCompositionLaw rclCombiner
  constructor
  · intro h x y hx hy; rw [h x y hx hy]
  · intro h x y hx hy; rw [h x y hx hy]

/-- **`J` composes through the RCL combiner.**  The recognition cost
`J(x) = ½(x + x⁻¹) − 1` satisfies `J (x·y) + J (x/y) = rclCombiner (J x) (J y)`
for positive `x, y`.  This shows the ledger-composition setup is non-vacuous:
`J` is a fixed point of the composition law it forces. -/
theorem jcost_composesThrough_rclCombiner :
    CostComposesThrough Cost.Jcost rclCombiner := by
  intro x y hx hy
  have hx0 : x ≠ 0 := ne_of_gt hx
  have hy0 : y ≠ 0 := ne_of_gt hy
  unfold Cost.Jcost rclCombiner
  field_simp
  ring

/-- The ledger-composition certificate holds. -/
theorem ledgerCompositionCertificate : LedgerCompositionCertificate where
  composition_law_is_rcl := satisfiesCompositionLaw_iff_rclCombiner
  ledger_composes_forces_composition_law :=
    satisfiesCompositionLaw_of_ledgerComposes
  ledger_composition_forces_jcost := ledgerComposition_forces_jcost
  jcost_composes := jcost_composesThrough_rclCombiner

What this page does not claim

The theorem does not prove that every cost function satisfying the five conditions must compose through a ledger-posting combiner. The theorem does not derive any physical constant or empirical value. The theorem does not prove the Riemann Hypothesis. The theorem does not claim the framework's axioms are the only possible starting point.

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