Cost Functional Equation Strict Composition Log Curvature Forces Jcost Unconditi

The two-premise cost theorem

The cost of recognition is the price reality pays to keep a ledger, a discrete record of events. The central question is whether that price has a unique form. The answer, proved in the framework's machine-checked library of formal theorems, is yes: any cost function that satisfies two plain conditions must equal J(x) = (x + 1/x)/2 - 1 for every positive x.

The first condition is the composition law, which says the cost of recognizing a combined event equals the sum of the costs of recognizing its parts, adjusted by their ratio. In symbols, F(xy) + F(x/y) = 2F(x)F(y) + 2F(x) + 2F(y). The second condition is unit log curvature, a limit-form calibration that replaces the usual continuity assumption: it says the second logarithmic derivative of the cost approaches a fixed value as x approaches 1. Together these two premises force the unique J form, with no further regularity assumptions and no extra hypotheses.

The theorem is stated unconditionally in the framework's library: it carries no hidden instance arguments and no premises beyond the composition law and unit log curvature. Earlier versions of the theorem required additional conditions such as reciprocity, normalization, and explicit continuity, but the library proved those are redundant. A historical note records that a prior statement of the log-calibration condition was vacuous, meaning it could never be satisfied; the condition is now punctured and carries a witness that it is satisfiable, so the theorem has content.

What the theorem does not claim is just as important. It does not say that the composition law alone forces J; without the log-curvature condition, other solutions exist. It does not say that the cost function is the only possible ledger rule, only that any rule meeting these two conditions must take this form. And it does not say that the cost function describes any particular physical system; that identification is a separate modeling step, not part of the theorem.

The payoff is that the framework's entire structure, from the golden ratio to the eight-tick cycle, rests on this single forced equation. Knowing that the cost is unique from two plain conditions means the later results are not chosen by hand; they follow from the same logic that fixes J.

/-- **The cost theorem on two premises, unconditionally.**

`composition_logCurvature_forces_jcost` is stated in `FunctionalEquation`, which
does not import the module that builds the `AczelSmoothnessPackage` instance, so
there it carries the package as an instance argument. This module does import it,
so here the theorem stands with no instance argument and no hypotheses beyond the
composition law and unit log curvature. Cite this one. -/
theorem composition_logCurvature_forces_jcost_unconditional (F : ℝ → ℝ)
    (hComp : SatisfiesCompositionLaw F)
    (hκ : HasLogCurvature (H F) 1) :
    ∀ x : ℝ, 0 < x → F x = Cost.Jcost x :=
  composition_logCurvature_forces_jcost F hComp hκ

/-- **The cost theorem on two premises, unconditionally.**

`composition_logCurvature_forces_jcost` is stated in `FunctionalEquation`, which
does not import the module that builds the `AczelSmoothnessPackage` instance, so
there it carries the package as an instance argument. This module does import it,
so here the theorem stands with no instance argument and no hypotheses beyond the
composition law and unit log curvature. Cite this one. -/
theorem composition_logCurvature_forces_jcost_unconditional (F : ℝ → ℝ)
    (hComp : SatisfiesCompositionLaw F)
    (hκ : HasLogCurvature (H F) 1) :
    ∀ x : ℝ, 0 < x → F x = Cost.Jcost x :=
  composition_logCurvature_forces_jcost F hComp hκ

/-- **The cost theorem on two premises, unconditionally.**

`composition_logCurvature_forces_jcost` is stated in `FunctionalEquation`, which
does not import the module that builds the `AczelSmoothnessPackage` instance, so
there it carries the package as an instance argument. This module does import it,
so here the theorem stands with no instance argument and no hypotheses beyond the
composition law and unit log curvature. Cite this one. -/
theorem composition_logCurvature_forces_jcost_unconditional (F : ℝ → ℝ)
    (hComp : SatisfiesCompositionLaw F)
    (hκ : HasLogCurvature (H F) 1) :
    ∀ x : ℝ, 0 < x → F x = Cost.Jcost x :=
  composition_logCurvature_forces_jcost F hComp hκ

What this page does not claim

The composition law alone forces J without the log-curvature condition. The theorem identifies which physical systems have this cost function. The theorem applies to costs defined on negative or zero inputs.

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