Foundation Ordered Logic Realization

Ordered realization

In mathematics, a realization is a concrete model of an abstract structure. Recognition Science asks what happens when the structure is logic itself, and the model is built from a ledger, a discrete record of events with a forced cost. The simplest nontrivial ledger assigns a cost to comparing two natural numbers: equal numbers cost 0, unequal numbers cost 1. This is the equality cost, written natCost, and it is the seed of the ordered realization.

The ordered realization takes this cost and builds a full model of logic from it. The framework's library, a machine-checked collection of formal theorems, proves three things about this model. First, the cost is symmetric: comparing m to n costs the same as comparing n to m. Second, the model interprets arithmetic faithfully, meaning that distinct natural numbers stay distinct and zero is never confused with a successor. Third, the order on the model's numbers matches the usual order on natural numbers: a is at most b exactly when the model says so.

The key theorem, ordered_faithful, establishes that this realization is a faithful arithmetic interpretation. It proves that the map from the model's numbers to actual natural numbers is injective, and that zero does not collapse with any successor. This matters because it shows that a ledger with only equality and inequality as its cost structure already carries enough information to reconstruct the natural numbers and their order. The arithmetic is not added on top; it is recovered from the ledger itself.

A further result, ordered_arithmetic_invariant, shows that this recovery is not an accident of the chosen model. For any realization of logic, the arithmetic it produces is equivalent to the arithmetic from the ordered natural-number realization. In plain terms: every model of logic in the framework contains the same natural numbers, regardless of how its ledger is set up. The ordered realization is therefore not one example among many; it is the canonical one, and the framework proves that arithmetic is invariant across all realizations.

What this establishes in plain language is that the framework's starting point, a ledger with forced costs, is enough to generate the standard natural numbers with their order. The module is a bridge: it shows that the abstract machinery of Recognition Science does not lose touch with ordinary arithmetic. A reader who knows Peano arithmetic can recognize it here, recovered from a cost function that only distinguishes equality from inequality.

/-- The ordered natural-number realization. -/
def natOrderedRealization : LogicRealization where
  Carrier := Nat
  Cost := Nat
  zeroCost := inferInstance
  compare := natCost
  zero := 0
  step := Nat.succ
  Orbit := ArithmeticFromLogic.LogicNat
  orbitZero := ArithmeticFromLogic.LogicNat.zero
  orbitStep := ArithmeticFromLogic.LogicNat.succ
  interpret := ArithmeticFromLogic.LogicNat.toNat
  interpret_zero := ArithmeticFromLogic.LogicNat.toNat_zero
  interpret_step := by
    intro n
    exact ArithmeticFromLogic.LogicNat.toNat_succ n
  orbit_no_confusion := by
    intro n h
    exact ArithmeticFromLogic.LogicNat.zero_ne_succ n h
  orbit_step_injective := ArithmeticFromLogic.LogicNat.succ_injective
  orbit_induction := by
    intro P h0 hs n
    exact ArithmeticFromLogic.LogicNat.induction (motive := P) h0 hs n
  orbitEquivLogicNat := Equiv.refl ArithmeticFromLogic.LogicNat
  orbitEquiv_zero := rfl
  orbitEquiv_step := by intro n; rfl
  identity := natCost_self
  nonContradiction := natCost_symm
  excludedMiddle := True
  composition := True
  actionInvariant := True
  nontrivial := by
    refine ⟨1, ?_⟩
    simp [natCost]

theorem natCost_symm (m n : Nat) : natCost m n = natCost n m := by
  by_cases h : m = n
  · subst h
    simp [natCost]
  · have h' : n ≠ m := by intro hnm; exact h hnm.symm
    simp [natCost, h, h']

/-- The ordered realization interprets arithmetic faithfully. -/
theorem ordered_faithful :
    LogicRealization.FaithfulArithmeticInterpretation natOrderedRealization where
  injective := by
    intro a b h
    exact (ArithmeticFromLogic.LogicNat.eq_iff_toNat_eq).mpr h
  zero_step_noncollapse := by
    intro n h
    have hnat := congrArg id h
    simp [natOrderedRealization] at hnat
    exact Nat.succ_ne_zero _ hnat.symm

/-- Order on the carrier matches the recovered Peano order. -/
theorem ordered_interpret_le_iff (a b : ArithmeticFromLogic.LogicNat) :
    ArithmeticFromLogic.LogicNat.toNat a ≤ ArithmeticFromLogic.LogicNat.toNat b ↔ a ≤ b := by
  exact (ArithmeticFromLogic.LogicNat.toNat_le a b).symm

/-- Ordered arithmetic is invariant with every realization. -/
noncomputable def ordered_arithmetic_invariant (R : LogicRealization.{0, 0}) :
    (UniversalForcing.arithmeticOf natOrderedRealization).peano.carrier
      ≃ (UniversalForcing.arithmeticOf R).peano.carrier :=
  ArithmeticOf.equivOfInitial
    (UniversalForcing.arithmeticOf natOrderedRealization)
    (UniversalForcing.arithmeticOf R)

What this page does not claim

This module does not derive the golden ratio or any specific constant from the forcing chain. The ordered realization does not prove that all realizations are isomorphic, only that their arithmetic carriers are equivalent. No claim is made here about the physical interpretation of the ledger; this is purely a formal construction.

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