Foundation Primitive Recognition Calculus Delta Real Calibration One Act Curvatu

The one-act curvature

In Recognition Science, the cost of a recognition event (the price a ledger pays for recording an event) is not a free parameter. The framework's central theorem forces a specific cost function, J(x) = (x + 1/x)/2 - 1, from five plain conditions. But there is a gap: the discrete laws that define the cost family do not, by themselves, pick out a unit of measurement. The declaration oneActCurvature_eq closes a piece of that gap by showing that a single continuum-level datum, the curvature of the cost curve at its origin, is enough to force the unit to be 1.

The declaration itself is a theorem about a specific definition. The one-act curvature is defined as the second derivative, at the point t = 0, of the function cosh(c * t) - 1, where c is the cost unit. The theorem oneActCurvature_eq states that this second derivative equals c squared. This is a direct computation from the definition, a fact that holds for any real number c. It is a purely mathematical statement about a chosen curve, not yet a claim about the physical world.

The power of this result appears when it is combined with a normalization condition. If we demand that the one-act curvature equals 1, and c is positive, then the theorem unit_forced_by_one_act shows that c must be 1. The single datum "one-act curvature equals 1" selects the canonical cost unit. This is the honest conditional: the discrete carrier does not force the unit, but one continuum-interface datum does. The declaration oneActCurvature_eq is the algebraic engine behind that forcing.

In Recognition Science, this is the calibration closure. The framework proves that the discrete laws leave a faithful one-real torsor, meaning distinct units give distinct costs and any unit can be rescaled to any other. The one-act curvature normalization removes exactly that one degree of freedom. The theorem calibration_gap_closed_by_normalized_interface packages this: any normalized interface forces the unit to be 1, and the condition is both necessary and sufficient. The unit is not derived from discrete recognition acts; it is fixed by the minimal second-order continuum interface.

What the declaration does not claim is equally important. It does not claim that the curvature datum is discrete-forced; the discrete laws alone leave the unit free. It does not claim that the value 1 for the unit is a prediction from nothing; it is a normalization choice, albeit one that is necessary and sufficient for a consistent interface. The declaration is a theorem about a definition, and the subsequent theorems are about what that definition can and cannot force. The framework is explicit that the calibration is not discrete-delta-forced, and the one continuum datum is named rather than hidden.

/-- The one-act log-curvature of the cost member with unit `c`: the second
derivative at the limit ratio `t = 0`. This is a continuum-interface quantity (it
is a second derivative), living in the `ℝδ` protocol layer, not in the discrete
rational carrier. -/
noncomputable def oneActCurvature (c : ℝ) : ℝ :=
  deriv (deriv (fun t => Real.cosh (c * t) - 1)) 0

/-- The one-act curvature is `c²`: the residual gauge parameter read as a
second derivative. -/
theorem oneActCurvature_eq (c : ℝ) : oneActCurvature c = c ^ 2 :=
  Calibration.logCurvature c

/-- **One continuum datum fixes the unit.** At the continuum interface, the single
normalization "one-act curvature equals 1" forces `c = 1`, i.e. selects the
canonical J. -/
theorem unit_forced_by_one_act {c : ℝ} (hc : 0 < c) :
    oneActCurvature c = 1 ↔ c = 1 := by
  unfold oneActCurvature
  exact Calibration.curvature_one_iff_J hc

/-- **The discrete carrier does not force the unit.** The cost family is faithful
(distinct units give distinct costs) and transitively rescaled, so the residual
freedom is a one-real torsor. Without the one-act normalization datum the unit is
genuinely free. -/
theorem discrete_does_not_force_unit :
    (∀ c d : ℝ, 0 < c → 0 < d →
        (fun t => Real.cosh (c * t) - 1) = (fun t => Real.cosh (d * t) - 1) → c = d)
      ∧ (∀ c d : ℝ, 0 < c → 0 < d →
          ∃ μ : ℝ, 0 < μ ∧
            (fun t => Real.cosh (c * (μ * t)) - 1) = (fun t => Real.cosh (d * t) - 1)) :=
  Calibration.cost_freedom_is_one_real_torsor

/-- **Calibration closure theorem.** The discrete laws leave a faithful one-real
torsor (`discrete_does_not_force_unit`), while the normalized one-act interface is
both sufficient and necessary for `c = 1`. Thus the cost-unit issue is fully
classified: it is not discrete-forced; it is closed exactly by the minimal
second-order recognition interface. -/
theorem calibration_gap_closed_by_normalized_interface :
    (∀ I : NormalizedOneActInterface, I.unit = 1)
      ∧ (∀ c : ℝ, 0 < c → (c = 1 ↔ oneActCurvature c = 1))
      ∧ (∃ I : NormalizedOneActInterface, I.unit = 1)
      ∧ (∀ c d : ℝ, 0 < c → 0 < d →
          (fun t => Real.cosh (c * t) - 1) = (fun t => Real.cosh (d * t) - 1) → c = d) :=
  ⟨normalized_interface_forces_J, fun _ hc => calibration_datum_necessary_and_sufficient hc,
    ⟨canonicalInterface, rfl⟩, fun _ _ hc hd h => Calibration.clog_inj hc hd h⟩

What this page does not claim

The one-act curvature is not derived from the discrete recognition laws; it is a continuum-interface datum. The value 1 for the unit is not a prediction from nothing; it is a necessary and sufficient normalization choice. The declaration does not claim that the cost function J itself is derived from the one-act curvature.

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/PrimitiveRecognitionCalculus/DeltaRealCalibration.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: