Foundation Universal Forcing Strict Categorical Mathlib Categorical Mathlib Cert

The natural-number certificate

The declaration categoricalMathlibCert_holds is a formal certificate inside the framework's machine-checked library of formal theorems. It proves that the framework's own counting numbers, called LogicNat, satisfy the same defining property that category theory uses to recognize the natural numbers 0, 1, 2, 3, and so on. That property is the natural number object, or NNO: a structure with a starting point and a successor step such that any other structure with a starting point and a step has exactly one structure-preserving map from it.

The certificate establishes three things in precise logical language. First, LogicNat has a primitive recursion principle: given any starting value and any step function, there is a unique way to define a function on all of LogicNat. Second, that recursion principle is equivalent in content to the standard recursion on the usual natural numbers once the two are transported along an isomorphism. Third, the two structural equations that the NNO universal property requires hold exactly: the recursor sends the zero element to the base value, and it sends a successor to the step applied to the recursor of the predecessor. These are the commuting-square equations of the NNO definition, checked by the kernel without any gaps or extra axioms.

The certificate is a bridge, not a new discovery. It connects the framework's internal counting numbers to the standard category-theoretic account of natural numbers as they appear in Mathlib, the large formal library of mathematics. The declaration collects the existence and uniqueness theorems into one structure and proves that structure is inhabited. The status line is 0 sorry and 0 axiom, meaning the proof uses only the ambient type theory's standard postulates and no framework-specific assumptions.

What the certificate does not claim matters as much as what it proves. It does not claim that the framework's counting numbers are the only possible natural numbers, nor does it claim that the framework has constructed a full category-theoretic model with all the machinery of limits and colimits. It does not invoke Mathlib's heavy categorical apparatus for initial objects; it proves the two structural identities directly. The certificate establishes that LogicNat has the algebraic content of a natural number object in the category of types, nothing more. It is a clean, narrow, verified statement of equivalence between two ways of describing the same counting structure.

/-- The NNO universal property on `LogicNat` in `Type`: existence. -/
theorem nno_universal_existence {α : Type*} (base : α) (step : α → α) :
    ∃ (f : LogicNat → α),
      f LogicNat.zero = base ∧
      ∀ n, f (LogicNat.succ n) = step (f n) :=
  ⟨recursor base step, recursor_zero base step, recursor_succ base step⟩

/-- The NNO universal property on `LogicNat` in `Type`: uniqueness. -/
theorem nno_universal_uniqueness {α : Type*} (base : α) (step : α → α)
    (f g : LogicNat → α)
    (hf_zero : f LogicNat.zero = base)
    (hf_succ : ∀ n, f (LogicNat.succ n) = step (f n))
    (hg_zero : g LogicNat.zero = base)
    (hg_succ : ∀ n, g (LogicNat.succ n) = step (g n)) :
    f = g := by
  funext n
  induction n with
  | identity =>
      rw [show LogicNat.identity = LogicNat.zero from rfl, hf_zero, hg_zero]
  | step k ih =>
      rw [show LogicNat.step k = LogicNat.succ k from rfl, hf_succ k, hg_succ k, ih]

theorem recursor_zero {α : Type*} (base : α) (step : α → α) :
    recursor base step LogicNat.zero = base := rfl

theorem recursor_succ {α : Type*} (base : α) (step : α → α) (n : LogicNat) :
    recursor base step (LogicNat.succ n) = step (recursor base step n) := rfl

theorem categoricalMathlibCert_holds : CategoricalMathlibCert :=
{ recursor_zero_eq := @recursor_zero
  recursor_succ_eq := @recursor_succ
  universal_existence := @nno_universal_existence
  universal_uniqueness := @nno_universal_uniqueness }

What this page does not claim

The certificate does not construct a full category-theoretic model with limits and colimits. The certificate does not claim that LogicNat is the only possible natural number object in all categories. The certificate does not use Mathlib's heavy categorical machinery for initial objects.

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/UniversalForcing/Strict/CategoricalMathlib.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: