Foundation Arithmetic Of Is Initial

The initial arithmetic object

In mathematics, a Peano algebra is a minimal counting structure: a collection of objects with a distinguished zero element and a step function that moves from one object to the next. The classical example is the natural numbers, where zero is the starting point and the step function adds one. The Recognition Science declaration IsInitial establishes that, given any such structure, there is exactly one way to map it into any other counting structure while preserving zero and the step operation. This property, called initiality, is what makes the natural numbers the canonical example of counting.

The framework's library proves this initiality in a specific way. It defines a structure called a PeanoObject, which packages a type with a zero and a step map. The declaration IsInitial then asserts that for any two maps from this object to another PeanoObject that both preserve zero and the step function, the two maps must be identical. This uniqueness is proved by induction: the base case forces the image of zero, and the step case forces the image of every successor. The result is that the counting structure is unique up to unique isomorphism, meaning any two such structures are essentially the same, just with different labels.

In Recognition Science, this initiality is the mechanism behind what the framework calls Universal Forcing. The framework models a ledger, a discrete record of events, as a LogicRealization that supplies identity and step data. From that data, the framework constructs a PeanoObject and proves it is initial. This means the arithmetic that emerges from any such realization is forced to be the same as the natural numbers. The declaration IsInitial is what guarantees this: once a realization provides a zero and a step, the resulting counting structure cannot be anything other than the initial one.

The framework also shows that this initial object satisfies the full Peano surface: zero is not the step of any element, the step function is injective, and induction holds. These properties are proved for both the canonical natural numbers and for the arithmetic extracted from any realization. The practical consequence is that arithmetic is not an arbitrary choice but a forced outcome of having a starting point and a way to move forward.

What IsInitial does not claim is that the framework discovers a new kind of arithmetic. It claims that any sufficiently rich structure with a zero and a step must contain the natural numbers as its counting backbone. The declaration does not assert that the natural numbers are the only possible type, nor does it say that every PeanoObject is initial. It says that the initial one is unique, and that uniqueness is what makes counting universal.

/-- Initiality of a Peano algebra. This is data, so it lives in `Type`. -/
structure IsInitial (A : PeanoObject) where
  lift : ∀ B : PeanoObject, Hom A B
  uniq : ∀ (B : PeanoObject) (f g : Hom A B), f.toFun = g.toFun

/-- `LogicNat` is initial among Peano objects. -/
def logicNat_initial : PeanoObject.IsInitial logicNatPeano where
  lift := logicNatLift
  uniq := by
    intro B f g
    rw [logicNatLift_unique_fun B f, logicNatLift_unique_fun B g]

/-- The Peano object extracted from a realization's own orbit. -/
def realizationPeano (R : LogicRealization) : PeanoObject where
  carrier := R.Orbit
  zero := R.orbitZero
  step := R.orbitStep

/-- The Peano surface for the canonical arithmetic object. -/
theorem canonical_peanoSurface (R : LogicRealization) :
    PeanoSurface (canonical R) where
  zero_ne_step := by
    intro x h
    cases h
  step_injective := by
    intro a b h
    exact LogicNat.succ_injective h
  induction := by
    intro P h0 hstep n
    exact LogicNat.induction (motive := P) h0 hstep n

What this page does not claim

IsInitial does not claim that every PeanoObject is initial, only that the initial one is unique. The declaration does not assert that the natural numbers are the only possible type in the framework. This does not claim that the framework's arithmetic differs from classical natural number arithmetic.

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: