Foundation Arithmetic Of Peano Object

The initial arithmetic object

A Peano object is the skeleton of arithmetic: a collection of things with one distinguished starting element and a function that moves from any element to a next one. The classical example is the natural numbers with zero and the successor function. The structure itself makes no further demands. Nothing says the elements are numbers, nothing says the step is reversible, and nothing says the collection is finite or infinite. It is simply the shape that counting requires.

The classical theory of such structures goes back to Giuseppe Peano's 1889 axioms. The key property is initiality: among all Peano objects, the natural numbers are the one from which every other can be reached in exactly one way. A map that preserves the starting point and the step function is a homomorphism; the natural numbers admit a unique homomorphism into any Peano object. This is what makes recursive definition possible. To define a function on the natural numbers, one specifies its value at zero and its rule for moving from n to n+1, and the uniqueness guarantee supplies the rest.

In Recognition Science, the framework's library of machine-checked formal theorems defines PeanoObject as a type with a zero element and a step map. The framework then proves that any realization of its logic yields such an object, and that this object is initial: for every Peano object B, there is a unique structure-preserving map from the realization's natural numbers to B. The proof is by induction on the natural numbers, with the identity case handled by preservation of zero and the step case by preservation of the step map.

The framework's arithmetic object is therefore not an arbitrary choice. It is the initial Peano algebra generated by the identity and step data of a logic realization. Initial objects are unique up to unique isomorphism, so any two realizations produce arithmetic that is the same in the only sense that matters: there is exactly one way to translate between them. The framework calls this mechanism Universal Forcing: the structure of counting is forced, not selected.

What the declaration does not claim is equally important. PeanoObject does not assert that the natural numbers exist in any metaphysical sense. It does not claim that the step function is injective or that zero is not a successor; those are properties that must be proved separately, and the framework does prove them for its canonical and extracted realizations. The declaration also does not say that arithmetic is the only structure the logic supports. It says only that if a realization supplies identity and step data, then arithmetic follows uniquely.

/-- A Peano algebra: a type with a zero element and a step map. -/
structure PeanoObject where
  carrier : Type u
  zero : carrier
  step : carrier → carrier

/-- The extracted realization orbit is initial. -/
def realization_initial (R : LogicRealization) :
    PeanoObject.IsInitial (realizationPeano R) where
  lift := realizationLift R
  uniq := by
    intro B f g
    rw [realizationLift_unique_fun R B f, realizationLift_unique_fun R B g]

/-- The natural equivalence between two initial Peano objects. -/
noncomputable def equivOfInitial {R S : LogicRealization}
    (A : ArithmeticOf R) (B : ArithmeticOf S) : A.peano.carrier ≃ B.peano.carrier where
  toFun := (A.initial.lift B.peano).toFun
  invFun := (B.initial.lift A.peano).toFun
  left_inv := by
    intro x
    have hcomp :
        (PeanoObject.Hom.comp (B.initial.lift A.peano) (A.initial.lift B.peano)).toFun =
          (PeanoObject.Hom.id A.peano).toFun :=
      A.initial.uniq A.peano
        (PeanoObject.Hom.comp (B.initial.lift A.peano) (A.initial.lift B.peano))
        (PeanoObject.Hom.id A.peano)
    exact congrFun hcomp x
  right_inv := by
    intro y
    have hcomp :
        (PeanoObject.Hom.comp (A.initial.lift B.peano) (B.initial.lift A.peano)).toFun =
          (PeanoObject.Hom.id B.peano).toFun :=
      B.initial.uniq B.peano
        (PeanoObject.Hom.comp (A.initial.lift B.peano) (B.initial.lift A.peano))
        (PeanoObject.Hom.id B.peano)
    exact congrFun hcomp y

What this page does not claim

The declaration does not assert that the natural numbers exist in any metaphysical sense. The declaration does not claim that the step function is injective or that zero is not a successor; those are separate theorems. The declaration does not say that arithmetic is the only structure the logic supports.

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: