Foundation Categorical Logic Realization Canonical Categorical Realization

The categorical bridge

In mathematics, a natural-number object is a way to encode counting inside a category: it supplies a starting point, a successor operation, and a guarantee that this structure is initial, meaning every other copy of the counting numbers receives a unique structure-preserving map from it. The Recognition Science framework builds its own natural-number object from logic alone, then provides a canonical categorical realization, a standard bridge that packages this logical construction into the language of category theory. The declaration canonicalCategoricalRealization is that bridge: it takes the Peano-style arithmetic derived from logic and presents it as a categorical natural-number object, without rebuilding the whole of category theory.

The construction works by defining a small interface with the essential categorical data: a type of objects, a type of morphisms, a terminal object, the natural-number object itself, and the zero and successor morphisms. The framework then shows that its logical natural-number object satisfies this interface. A key theorem, categorical_arithmetic_invariant, proves that the arithmetic obtained from this canonical realization is equivalent to the arithmetic obtained from any other realization in the framework. In plain terms: the counting structure does not depend on which formal path you take to build it. This is a coherence result, not a new mathematical discovery about numbers themselves.

The declaration does not claim that the framework has built a full category-theoretic foundation, nor that it has instantiated every categorical construction. The interface deliberately collapses the object type to a single object for this first bridge, and the docstring notes that future work could replace this with a genuine category instance. It also does not claim that this realization is unique in any deep sense; it is canonical in the sense of being the standard one supplied by the framework's logic, not in the sense of being the only possible one. The theorem about invariance is what carries the weight: whatever realization you choose, the arithmetic is the same.

What this changes for a reader is the assurance that the framework's arithmetic is stable across its own internal representations. If you are tracking how the framework derives structure from logic, this is the point where the categorical packaging is shown to be harmless: it adds vocabulary, not new content. The counting numbers remain the counting numbers, whether you meet them through the logical construction or through the categorical interface.

/-- The categorical realization from the canonical NNO, written directly to
avoid universe inference noise from the generic `ofNNO` wrapper. -/
def canonicalCategoricalRealization : LogicRealization.{0, 0} where
  Carrier := ArithmeticFromLogic.LogicNat
  Cost := Nat
  zeroCost := inferInstance
  compare := fun x y => if x = y then 0 else 1
  zero := ArithmeticFromLogic.LogicNat.zero
  step := ArithmeticFromLogic.LogicNat.succ
  Orbit := ArithmeticFromLogic.LogicNat
  orbitZero := ArithmeticFromLogic.LogicNat.zero
  orbitStep := ArithmeticFromLogic.LogicNat.succ
  interpret := fun n => n
  interpret_zero := rfl
  interpret_step := by intro n; rfl
  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 := by intro x; simp
  nonContradiction := by
    intro x y
    by_cases h : x = y
    · subst h; simp
    · have h' : y ≠ x := by intro hyx; exact h hyx.symm
      simp [h, h']
  excludedMiddle := True
  composition := True
  actionInvariant := True
  nontrivial := by
    refine ⟨ArithmeticFromLogic.LogicNat.succ ArithmeticFromLogic.LogicNat.zero, ?_⟩
    simp

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

/-- Explicit categorical interface for a natural-number object. This avoids
committing to Mathlib's full category-theory stack in this sprint while naming
the data that the full categorical realization must eventually instantiate. -/
structure CategoryNNOInterface where
  Obj : Type
  Hom : Obj → Obj → Type
  terminalOrZero : Obj
  nno : Obj
  zeroMorphism : Hom terminalOrZero nno
  succMorphism : Hom nno nno
  initiality : Prop

What this page does not claim

This does not claim that the framework has constructed a full category-theoretic foundation. This does not claim that the canonical realization is the unique possible one. This does not claim any new property of the natural numbers themselves.

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