Cost Functional Equation Strict Law Of Logic Forces Jcost Of Log Calibration

The strict cost equation

A cost is a number that measures how hard one act of recognition is, where recognition means the event of matching a new observation to a stored pattern. The central question is whether the form of that cost is forced or optional. The answer, proved in a machine-checked library of formal theorems, is that any cost function satisfying a small set of plain conditions must equal J(x) = (x + 1/x)/2 - 1. The strict variant of the theorem, law_of_logic_forces_jcost_of_log_calibration, shows that two of the original five conditions already do all the work.

The two conditions are a composition law and a limit-form calibration. The composition law says that the cost of recognizing a compound object is determined by the costs of recognizing its parts in a specific algebraic way. The calibration condition says that near the point where recognition costs nothing, the cost behaves in a controlled, smooth manner. Together they force the unique form J(x). The theorem states this for every positive x: if a cost function satisfies both conditions, then F x = J x for all x greater than zero.

The proof route matters because it removes an earlier assumption. The original version of the theorem required the cost function to be continuous on the positive real line. The strict variant replaces that explicit continuity premise with the limit-form calibration, which supplies the needed smoothness through a different path. The other three original conditions, reciprocal symmetry, normalization, and ordinary calibration, turn out to be consequences of the two that remain. They are kept in the statement only so that existing code that calls the theorem keeps working.

This is not a claim about the physical world. It is a statement about a mathematical structure: given the composition law and the calibration condition, the cost function has no freedom. The theorem does not say that real recognition processes must obey those conditions, nor does it say anything about what the constant 1 in the denominator represents physically. It establishes a conditional fact, and the condition is a pair of equations.

The practical consequence is that any system, physical or abstract, whose recognition costs obey the two conditions is locked into the same functional form. That form has a minimum at x = 1, where the cost is zero, and it grows symmetrically as x moves away from 1 in either direction. The strict theorem narrows the path to that conclusion, and it gives future work a cleaner foundation to build on.

/-- Limit-form log calibration supplies the continuity needed by the Aczél
d'Alembert route, so the explicit `ContinuousOn F (Set.Ioi 0)` premise can be
removed from this T5 variant.

Only `hComp` and `hLogCalib` are used: the other three premises are consequences
of that pair. They are retained so existing callers keep type-checking. -/
theorem law_of_logic_forces_jcost_of_log_calibration (F : ℝ → ℝ)
    [AczelSmoothnessPackage]
    (_hRecip : IsReciprocalCost F)
    (_hNorm : IsNormalized F)
    (hComp : SatisfiesCompositionLaw F)
    (_hCalib : IsCalibrated F)
    (hLogCalib : IsCalibratedLimit F) :
    ∀ x : ℝ, 0 < x → F x = Cost.Jcost x :=
  composition_logCurvature_forces_jcost F hComp hLogCalib

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

/-- Limit-form log calibration supplies the continuity needed by the Aczél
d'Alembert route, so the explicit `ContinuousOn F (Set.Ioi 0)` premise can be
removed from this T5 variant.

Only `hComp` and `hLogCalib` are used: the other three premises are consequences
of that pair. They are retained so existing callers keep type-checking. -/
theorem law_of_logic_forces_jcost_of_log_calibration (F : ℝ → ℝ)
    [AczelSmoothnessPackage]
    (_hRecip : IsReciprocalCost F)
    (_hNorm : IsNormalized F)
    (hComp : SatisfiesCompositionLaw F)
    (_hCalib : IsCalibrated F)
    (hLogCalib : IsCalibratedLimit F) :
    ∀ x : ℝ, 0 < x → F x = Cost.Jcost x :=
  composition_logCurvature_forces_jcost F hComp hLogCalib

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

This theorem does not claim that real recognition processes must obey the two conditions. It does not assign any physical meaning to the constant 1 in the denominator. It does not say the cost function is unique without the two premises.

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: