Foundation Ledger Composition To Jcost

The composition law

In Recognition Science, a ledger is a discrete record of recognition events. The framework asks how the cost of recognizing two events together relates to the cost of recognizing each alone. The answer is a composition law, and the law is not chosen freely. For a cost function F, the law states that the symmetric combination F(x·y) + F(x/y) equals 2F(x)F(y) + 2F(x) + 2F(y). This is the exact equation that the framework's central theorem needs.

The key insight is that this composition law is not an independent assumption. It is precisely the statement that the cost composes through a specific combiner, called the RCL combiner, which takes two costs u and v and returns 2uv + 2u + 2v. The equivalence is proved as a theorem: a cost satisfies the composition law if and only if its two-point combination equals the RCL combiner evaluated at the two costs. This is a pure rearrangement of the equation, but it reframes the law as a property of how costs combine, not as a separate axiom.

The ledger postings, the primitive operations that record recognition events, have a directional regularity property. It is proved that any combiner satisfying this ledger-posting semantics and directional regularity must equal the RCL combiner. Therefore, if a cost composes through any such combiner, it automatically satisfies the composition law. This replaces a previously assumed hypothesis with a derived theorem: the combiner is forced by the ledger, not given as an input.

With this in place, the endpoint is reached. If a cost function F is reciprocal, normalized, calibrated, and continuous on the positive ray, and it composes through a ledger-posting combiner with directional regularity, then F equals J, where J(x) = ½(x + x⁻¹) − 1. This is the framework's unique cost function, now derived from ledger composition rather than assumed. It is also proved that J itself composes through the RCL combiner, so the construction is not empty: J is a genuine fixed point of the entire setup.

The certificate records that every field is a proved theorem. The practical consequence is that the composition law, once a hypothesis in the framework's main forcing theorem, is now a consequence of ledger structure. The framework's central result, that any cost satisfying five plain conditions must equal J, stands on a fully derived composition law with no gaps.

/-- **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 posting + directional regularity force the cost's composition
law.**  If `F` composes through a combiner `P`, and `P` is a primitive
ledger-posting combiner with per-slice directional regularity, then `P` is
forced to be `rclCombiner` (Phase 3), so `F` satisfies the recognition
composition law. -/
theorem satisfiesCompositionLaw_of_ledgerComposes (F : ℝ → ℝ) (P : ℝ → ℝ → ℝ)
    (hP : PrimitiveLedgerPostingSemantics P)
    (hdir : ∀ u, Monotone (fun v => P u v) ∨ Antitone (fun v => P u v))
    (hCompose : CostComposesThrough F P) :
    SatisfiesCompositionLaw F := by
  have hPrcl : ∀ u v, P u v = rclCombiner u v :=
    primitiveLedgerPosting_directional_forces_rcl P hP hdir
  apply satisfiesCompositionLaw_of_composesThrough_rcl
  intro x y hx hy
  rw [hCompose x y hx hy, hPrcl]

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

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

What this page does not claim

The module does not prove that every cost function composes through some combiner; composability remains an input. The module does not derive the reciprocal, normalized, calibrated, or continuity conditions; they are hypotheses. The module does not establish the physical interpretation of the ledger postings.

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: