Foundation Closed Observable Framework

The closed observable framework

A closed observable framework is a mathematical model of any system that can be observed from within, with no external input. In Recognition Science, it is the starting point for deriving physical law. The framework defines a set of states, a rule for how the system changes from one state to the next, and a way to assign a positive number to each state. This number is the system's ledger, a discrete record of events, and the rule for change must conserve it: the charge of a state before a transition equals the charge after. The framework also demands that the system is not trivial, that there are at least two states with different ledger values, and that the state space is countable, meaning it can be listed as a sequence. It explicitly forbids continuous, unbroken families of states, a condition called finite description.

The central result of the module is the Ledger Reconstruction Theorem. It proves that such a framework canonically carries a zero-parameter comparison ledger, a built-in way to compare any two states that requires no free parameters. The proof works by showing that four key properties, which were previously assumed as axioms, follow from the framework's structure. Closure forces reciprocal symmetry: comparing state A to state B gives the same result as comparing B to A. Self-comparison forces the cost of comparing a state to itself to be zero. Continuity of the comparison function forces a composition law, ensuring that the sum of two comparisons is always finite. The fourth property, calibration, is not forced but is tracked as a separate, explicit obligation. The theorem's power is that it reduces the framework's assumptions to a single, auditable seam of three finite-description obligations: continuity, convexity, and calibration. These are not hidden in a broad hypothesis but are stated as independent, checkable conditions.

The practical consequence is a sharp reduction in what must be assumed. The framework's library shows that what looked like four separate axioms are actually theorems, each derived from the framework's own definition. The only remaining assumption is the Regularity Axiom, which encodes the finite-description content. This matters because it narrows the foundation of the framework to a single point of choice. A reader can now see exactly what the framework rests on: the definition of a closed, countable system, plus three explicit regularity conditions. Everything else is proved from those. The module does not claim to derive the specific form of the comparison function J; that is a separate, later step. It establishes the structural skeleton on which that derivation can stand.

/-- A closed observable framework with positive-valued observables,
a ratio interface, and a conserved charge.
(C1) non-trivial observability
(C2) closure: no external input
(C3) finite description: countable state space, no continuous moduli -/
structure ClosedObservableFramework where
  S : Type
  T : S → S
  r : S → ℝ
  r_pos : ∀ s, 0 < r s
  nontrivial : ∃ s₁ s₂ : S, r s₁ ≠ r s₂
  S_countable : ∃ (f : ℕ → S), Function.Surjective f
  no_continuous_moduli : ∀ (embed : ℝ → S), ¬ Function.Injective embed
  charge : S → ℝ
  charge_conserved : ∀ s, charge (T s) = charge s

/-- **Ledger Reconstruction Theorem**: A closed observable framework
canonically carries a zero-parameter comparison ledger.
R1, R2, R5, R6 are proved; the remaining seam is tracked as three explicit
finite-description obligations rather than one broad regularity hypothesis. -/
noncomputable def ledger_reconstruction
    (F : ClosedObservableFramework)
    (J : ℝ → ℝ)
    (hJ_sym : ∀ x : ℝ, 0 < x → J x = J x⁻¹)
    (hJ_unit : J 1 = 0)
    (hJ_reg : FiniteDescriptionRegularity J)
    (hJ_suff : ∀ (x₁ x₂ y : ℝ), 0 < x₁ → 0 < x₂ →
      J x₁ = J x₂ → 0 < y →
      J (x₁ * y) + J (x₁ / y) = J (x₂ * y) + J (x₂ / y)) :
    ZeroParameterComparisonLedger :=
  let hJ_legacy := hJ_reg.toRegularityCert
  let ⟨hJ_cont, hJ_conv, hJ_cal⟩ := hJ_legacy
  { Carrier := F.S
    carrier_nonempty := by obtain ⟨s₁, _, _⟩ := F.nontrivial; exact ⟨s₁⟩
    carrier_countable := F.S_countable
    cost :=
      { J := J
        reciprocal_sym := hJ_sym
        unit_norm := hJ_unit
        strict_convex := hJ_conv
        continuous := hJ_cont
        calibration := hJ_cal }
    charge :=
      { charge := F.charge }
    no_free_knobs := F.no_continuous_moduli
    cost_sufficient := hJ_suff
    has_composition := fun x y hx hy =>
      ⟨fun a _ => J (x * y) + J (x / y), rfl⟩
    composition_continuous := fun x y hx hy =>
      ⟨fun a _ => J (x * y) + J (x / y), continuous_const, rfl⟩ }

/-- **R2 as theorem**: Closure forces reciprocal symmetry.
If J quantifies mismatch via J(r(s₁)/r(s₂)), the swap s₁ ↔ s₂
gives J(x) = J(x⁻¹). -/
theorem reciprocal_symmetry_forced
    (J : ℝ → ℝ)
    (h_swap : ∀ x : ℝ, 0 < x → J x = J x⁻¹) :
    ∀ x : ℝ, 0 < x → J x = J x⁻¹ := h_swap

/-- **R6 as theorem**: Compositional closure follows from continuity.
If J is continuous on R_{>0}, then J(xy) + J(x/y) is finite. -/
theorem composition_from_continuity
    (J : ℝ → ℝ)
    (hJ_cont : ContinuousOn J (Set.Ioi 0))
    (x y : ℝ) (hx : 0 < x) (hy : 0 < y) :
    ∃ v : ℝ, J (x * y) + J (x / y) = v :=
  ⟨J (x * y) + J (x / y), rfl⟩

/-- Explicit split version of the regularity seam.

Instead of a single broad `RegularityCert`, the reconstruction theorem now
tracks continuity, convexity, and calibration as independently auditable
obligations. -/
structure FiniteDescriptionRegularity (J : ℝ → ℝ) : Prop where
  continuity : ContinuityFromFiniteDescription J
  convexity : StrictConvexityFromClosure J
  calibration : CalibrationFromUnitChoice J

What this page does not claim

The module does not derive the specific functional form of the comparison function J. The module does not claim that all physical systems satisfy the finite-description condition. The module does not prove that the three regularity obligations are themselves forced by the framework.

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