Foundation Arithmetic Of Extracted Peano Surface

The extracted arithmetic surface

Peano arithmetic is the standard axiomatic description of the natural numbers: a starting point called zero, a successor operation that steps to the next number, and three laws saying that zero is not a successor, that the successor function never repeats itself, and that any property holding at zero and preserved by each step holds for every number. These three laws are the backbone of counting, induction, and recursion. In classical mathematics, they are taken as axioms for a structure called the natural numbers.

The Recognition Science framework asks what arithmetic looks like when it is not assumed but forced. Its library of machine-checked theorems defines a ledger, a discrete record of events, and shows that the framework's basic logical structure generates a sequence of positions: a starting point and a step map. The declaration extracted_peanoSurface proves that this generated sequence satisfies all three Peano laws. The zero is not a successor, the step map is injective, and induction holds. This means the framework's internal counting structure is not merely similar to the natural numbers; it is a Peano algebra in the precise mathematical sense.

The proof is not a loose analogy. The theorem is checked by a machine, and it relies on three properties of the framework's logical realization: that the zero is distinct from every stepped position, that the step map is injective, and that induction holds on the generated orbit. These are exactly the three Peano laws, and the declaration assembles them into the PeanoSurface structure. The result is that any realization of the framework's logic carries arithmetic with the same behavior as the natural numbers, including the unique recursive definitions that flow from induction.

In Recognition Science, this theorem is the bridge from the framework's abstract logic to concrete arithmetic. It shows that the natural numbers are not an extra assumption but a consequence of the framework's basic structure. The theorem also establishes that this arithmetic is canonical: any two such generated structures are uniquely isomorphic, meaning there is exactly one structure up to unique isomorphism. This is the mechanism the framework calls Universal Forcing, the idea that the framework's logic determines its mathematics.

The theorem does not claim that the framework's arithmetic is the only possible arithmetic, nor that it settles which physical objects satisfy the framework's conditions. It proves a conditional statement: if a logical realization exists with the three orbit properties, then its arithmetic is Peano. The theorem does not construct such a realization from nothing, and it does not identify the framework's counting with any specific physical counting process. Those questions remain open, and the theorem's power is precisely that it reduces the existence of arithmetic to the existence of a logical realization.

/-- Peano surface for the extracted arithmetic of any realization. -/
theorem extracted_peanoSurface (R : LogicRealization) :
    PeanoSurface (extracted R) where
  zero_ne_step := R.orbit_no_confusion
  step_injective := R.orbit_step_injective
  induction := R.orbit_induction

/-- Peano surface for the extracted arithmetic of any realization. -/
theorem extracted_peanoSurface (R : LogicRealization) :
    PeanoSurface (extracted R) where
  zero_ne_step := R.orbit_no_confusion
  step_injective := R.orbit_step_injective
  induction := R.orbit_induction

/-- 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 theorem does not construct a logical realization from nothing. The theorem does not identify the framework's counting with any specific physical counting process. The theorem does not prove that the framework's arithmetic is the only possible 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: