Foundation Primitive Recognition Calculus Delta Real Calibration Discrete Does N

The residual freedom

The Recognition Science framework models recognition events as entries in a discrete ledger, a record of distinct happenings. Its central cost function, which assigns a price to each act of recognition, comes in a family parameterized by a positive real number c. The declaration discrete_does_not_force_unit establishes that this discrete ledger alone cannot distinguish between different values of c: for any two positive units c and d, there exists a rescaling that makes the cost functions identical on all discrete inputs. The freedom is exactly a one-real torsor, meaning the choice of unit is a single real parameter that remains completely unconstrained by any finite or discrete observation.

The theorem is precise about what it proves. It states two things: first, that distinct units give distinct cost functions (the family is faithful), and second, that for any two positive units, one can always find a positive scaling factor that maps one cost function onto the other. This is the formal content of the residual freedom. The theorem is a result about the discrete carrier alone; it does not involve any continuum measurement or normalization. It is a proved theorem in the framework's machine-checked library of formal theorems, with the Lean declaration discrete_does_not_force_unit in the module DeltaRealCalibration.lean.

What the declaration does not claim is that the unit is unfixable in principle. It only says the discrete structure cannot fix it. The framework's companion result, unit_forced_by_one_act, shows that a single continuum datum, the normalization of the one-act curvature to 1, forces c = 1. The discrete freedom and the continuum fix are complementary: the discrete ledger leaves the unit free, and exactly one continuum act removes that freedom. The honest conditional is that calibration is not discrete-forced, and the one continuum datum is named rather than hidden.

This matters because it identifies where the framework's constants come from. The unit c is not a free parameter smuggled in through the discrete laws; it is a genuine degree of freedom that the discrete structure cannot see. The framework's claim is that this freedom is closed by a minimal second-order recognition interface, not by the discrete ledger itself. The declaration therefore sharpens the framework's epistemology: it tells you precisely what the discrete theory can and cannot determine, and it points to the continuum interface as the place where the unit is actually fixed.

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

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

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

What this page does not claim

The declaration does not claim that the unit cannot be fixed by any means; it only says the discrete structure cannot fix it. The declaration does not claim that the discrete cost functions are identical for all inputs; they are distinct but related by a rescaling. The declaration does not claim that a continuum measurement is unnecessary; the companion theorem shows exactly one is needed.

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: