Foundation Closed Observable Framework Comparison Symm

Reciprocal comparison

In mathematics, a comparison is a way of putting two things side by side and asking how they differ. The Recognition Science framework formalizes this with a function recognition, a discrete record of events, that assigns a real number to each state of a system. The declaration comparison_symm proves a simple fact about this function: if the recognition values of two states differ, then they differ in either order. Formally, if r(s₁) ≠ r(s₂), then r(s₂) ≠ r(s₁). This is an instance of the symmetry of inequality, and the proof is a one-line application of the standard Ne.symm lemma.

The theorem lives in the ClosedObservableFramework structure, which models a system that is closed (no external input), has positive-valued observables, and conserves a charge. The framework's larger project is to show that a closed observable framework canonically carries a zero-parameter comparison ledger, a record of comparisons with no free parameters. The symmetry theorem is one of several small results that support this reconstruction. Its companion comparison_irrefl proves that a state cannot differ from itself, and unit_normalization_forced shows that comparing a state to itself forces the cost function J to vanish at 1.

The deeper significance is that this symmetry, together with other forced properties, leads to the framework's central result: any cost function satisfying five plain conditions must equal J(x) = (x + 1/x)/2 - 1. The symmetry of comparison is one of those conditions. The framework's library, a machine-checked collection of formal theorems, proves that this symmetry is forced by closure, not assumed as an axiom. The declaration reciprocal_symmetry_forced states this explicitly: if J satisfies the swap condition, then J(x) = J(x⁻¹) for all positive x.

What comparison_symm does not claim is more modest than the surrounding framework. It does not by itself prove the uniqueness of J, nor does it establish the full ledger reconstruction. Those results require additional hypotheses: continuity, strict convexity, calibration, and a sufficiency condition. The symmetry theorem is a necessary ingredient, not a sufficient one. It is a small, exact fact that the framework builds upon, not the whole edifice.

The practical upshot is that the framework's claim about the forced nature of comparison rests on a series of small, verifiable steps. comparison_symm is one such step: it shows that the most basic property of comparison, its symmetry, is not an arbitrary choice but a consequence of the framework's definition of a closed observable system. This is the kind of foundation on which the larger claims about the cost function and the golden ratio are built.

theorem comparison_symm (F : ClosedObservableFramework) (s₁ s₂ : F.S) :
    F.r s₁ ≠ F.r s₂ → F.r s₂ ≠ F.r s₁ := Ne.symm

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

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

What this page does not claim

The symmetry theorem alone does not prove the uniqueness of the cost function J. The theorem does not establish the full ledger reconstruction without additional regularity hypotheses. The theorem does not claim anything about the physical interpretation of the recognition values.

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: