Foundation Ledger Composition To Jcost Satisfies Composition Law Iff Rcl Combine

The composition law's meaning

The recognition cost cost, a function that assigns a price to each recognition event, obeys a composition law: the cost of two events combined in a symmetric way equals a fixed expression built from the two individual costs. The declaration satisfiesCompositionLaw_iff_rclCombiner proves that this law is exactly the statement that the symmetric combination F(x·y) + F(x/y) equals 2·F(x)·F(y) + 2·F(x) + 2·F(y) for all positive x and y. This is a pure rearrangement, with no hidden assumption: the right-hand side is simply the definition of the RCL combiner applied to the two costs.

The force of this equivalence is that the composition law is not an independent analytic input. It is the same claim as saying the cost composes through the RCL combiner, a specific two-argument function. The framework's library proves that any cost satisfying this composition law, together with three other conditions (reciprocal symmetry, normalization, calibration, and continuity), must equal the unique function J(x) = (x + 1/x)/2 − 1. The declaration therefore pins down the exact algebraic content of the composition law, making it a concrete, checkable identity rather than a vague requirement.

What the declaration does not claim is that the composition law alone forces J. The equivalence only restates the law in terms of the RCL combiner; it does not, by itself, derive J. The full derivation requires the other conditions and a separate theorem about ledger posting. The declaration also does not claim that every cost function satisfies the composition law, only that if one does, it must have this specific algebraic form. It is a structural identity, not an existence claim.

/-- **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]

/-- **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]

/-- **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

What this page does not claim

The composition law alone forces the cost function J. Every cost function satisfies the composition law. The declaration provides the full derivation of J from the ledger postulates.

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: