Foundation Arithmetic Of Realization Lift Unique Fun

The unique lift

Peano arithmetic is the classical formalization of counting: a starting point called zero, a successor operation that moves from one number to the next, and the principle that if a property holds at zero and is preserved by each successor step, it holds for every natural number. This structure was named for Giuseppe Peano, who published it in 1889, and it underlies the arithmetic that appears in almost all of mathematics. The key fact about Peano arithmetic is its universality: any structure that has a zero and a successor operation, and obeys the same induction principle, is essentially the same as the natural numbers.

The declaration realizationLift_unique_fun in the framework's machine-checked library of formal theorems establishes exactly this universality for a specific kind of structure. It says that if you have a realization, which is a discrete record of events that provides a zero and a successor operation, and you have any other Peano structure B, then there is exactly one way to map the realization's counting sequence into B while preserving zero and successor. The word "unique" is the whole point: there is no choice in how this mapping works. Once the realization provides its zero and its step, the arithmetic that follows is forced, not optional.

This uniqueness is what the framework calls initiality. An initial object in a category is one that has exactly one morphism to every other object; here, the realization's counting structure is initial among all Peano structures. The theorem realizationLift_unique_fun proves that any structure-preserving map from the realization's counting sequence to another Peano object must equal the specific map that the framework constructs, called the realization lift. The proof proceeds by induction: the zero case is fixed by the requirement to preserve zero, and each successor step is fixed by the requirement to preserve the step operation.

What this does not claim is equally important. The theorem does not say that the realization's counting structure is the only Peano structure that exists; it says only that any other Peano structure receives a unique map from it. It does not claim that the realization itself is unique, only that once a realization is given, its arithmetic is unique. And it does not claim anything about which realizations exist or what events they record. The theorem is about the relationship between a given realization and the arithmetic it generates, not about the content of any particular realization.

In the framework's broader picture, this uniqueness is the mechanism behind what it calls Universal Forcing. Because the arithmetic object is initial, any two initial objects are isomorphic in exactly one way, and this forces the structure of the natural numbers to appear regardless of the details of the realization. The practical consequence is that the framework's arithmetic is not an arbitrary choice: it is the unique arithmetic that any valid realization must generate.

private theorem realizationLift_unique_fun (R : LogicRealization) (B : PeanoObject)
    (f : PeanoObject.Hom (realizationPeano R) B) :
    f.toFun = (realizationLift R B).toFun := by
  funext n
  have hlogic :
      (f.toFun ∘ R.orbitEquivLogicNat.symm) =
        (logicNatLift B).toFun := by
    exact logicNatLift_unique_fun B
      { toFun := f.toFun ∘ R.orbitEquivLogicNat.symm
        map_zero := by
          simp [Function.comp_def]
          have hz := f.map_zero
          have hsymm0 : R.orbitEquivLogicNat.symm LogicNat.zero = R.orbitZero := by
            apply R.orbitEquivLogicNat.injective
            simp [R.orbitEquiv_zero]
          change f.toFun (R.orbitEquivLogicNat.symm LogicNat.zero) = B.zero
          rw [hsymm0]
          exact hz
        map_step := by
          intro k
          simp [Function.comp_def]
          change f.toFun (R.orbitEquivLogicNat.symm (LogicNat.succ k)) =
            B.step (f.toFun (R.orbitEquivLogicNat.symm k))
          have hstep_symm :
              R.orbitEquivLogicNat.symm (LogicNat.succ k) =
                R.orbitStep (R.orbitEquivLogicNat.symm k) := by
            apply R.orbitEquivLogicNat.injective
            rw [R.orbitEquiv_step]
            simp
          rw [hstep_symm]
          simpa [realizationPeano] using f.map_step (R.orbitEquivLogicNat.symm k) }
  have hn : R.orbitEquivLogicNat.symm (R.orbitEquivLogicNat n) = n := by simp
  calc
    f.toFun n = (f.toFun ∘ R.orbitEquivLogicNat.symm) (R.orbitEquivLogicNat n) := by
      simp [Function.comp_def, hn]
    _ = (logicNatLift B).toFun (R.orbitEquivLogicNat n) := by rw [hlogic]
    _ = (realizationLift R B).toFun n := rfl

private theorem logicNatLift_unique_fun (B : PeanoObject)
    (f : PeanoObject.Hom logicNatPeano B) :
    f.toFun = (logicNatLift B).toFun := by
  funext n
  induction n with
  | identity =>
      exact f.map_zero
  | step n ih =>
      calc
        f.toFun (LogicNat.step n) = B.step (f.toFun n) := f.map_step n
        _ = B.step ((logicNatLift B).toFun n) := by rw [ih]
        _ = (logicNatLift B).toFun (LogicNat.step n) := rfl

What this page does not claim

The theorem does not claim that the realization's counting structure is the only Peano structure that exists. It does not claim that the realization itself is unique, only that once a realization is given, its arithmetic is unique. It does not claim anything about which realizations exist or what events they record.

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