Foundation Primitive Recognition Calculus Prcfoundations Parsed

Three foundations, one core

Set theory, type theory, and category theory are usually taught as rival foundations for mathematics, each with its own axioms and its own picture of what a mathematical object is. The module foundation primitive recognition calculus, a discrete record of how a system tells its basic objects apart, takes a different view. It parses each of the three into a common interface and then shows, in the framework's machine-checked library of formal theorems, that all three reach the same core.

That core is called the δ core. The framework models a foundation as a system that must distinguish two primitive kinds of object from each other. A foundation is degenerate if it cannot make that distinction at all. The module shows that set theory, type theory, and category theory all fall on the non-degenerate side: each one has a working way to tell its two primitives apart.

The arguments are not about vague family resemblances. For each foundation, the module names the specific mechanism that does the distinguishing. Set theory uses extensionality: two sets are equal exactly when they have the same members. Type theory uses canonicity: every term of the two-element type is either false or true. Category theory uses subobject classification: a special object classifies the subobjects of any object. Each mechanism is shown to yield the δ distinction in the framework's formal system.

The set-theory leg goes further. A finite version of set theory, the hereditarily finite sets, already embeds the δ core, but it cannot model infinity. The module lifts that caveat by showing that full ZFC, with the axiom of infinity modelled by an ω that contains the empty set and is closed under successor, also realizes the δ core. The framework's claim is not limited to toy foundations.

What this establishes in plain language is a structural claim about the three standard foundations: they are not three different worlds but three different routes to the same basic machinery. The framework models that machinery as the δ core, and the machine-checked library shows each route arrives. For a reader, the consequence is that the choice of foundation does not change what the framework's core forces downstream. The same recognition calculus runs underneath set theory, type theory, and category theory alike.

/-- **The three named foundations each realize the δ core.** Set theory, type
theory, and category theory, parsed into the `FormalSystem` interface via their own
distinction mechanisms, each admit a PRC embedding. -/
theorem three_foundations_realize_delta :
    Nonempty (PRCEmbeddingInto SetTheoryParse.hfSystem)
      ∧ Nonempty (PRCEmbeddingInto TypeTheoryParse.ttSystem)
      ∧ Nonempty (PRCEmbeddingInto CategoryTheoryParse.toposSystem) :=
  ⟨SetTheoryParse.hfSystem_embeds_delta,
    TypeTheoryParse.ttSystem_embeds_delta,
    CategoryTheoryParse.toposSystem_embeds_delta⟩

/-- The three named foundations all fall on the δ side of the distinction
dichotomy: none is degenerate. -/
theorem three_foundations_not_degenerate :
    ¬ DistinctionDichotomy.Degenerate SetTheoryParse.hfSystem
      ∧ ¬ DistinctionDichotomy.Degenerate TypeTheoryParse.ttSystem
      ∧ ¬ DistinctionDichotomy.Degenerate CategoryTheoryParse.toposSystem :=
  ⟨SetTheoryParse.hfSystem_not_degenerate,
    TypeTheoryParse.ttSystem_not_degenerate,
    CategoryTheoryParse.toposSystem_not_degenerate⟩

/-- **The substantive distinction mechanism of each foundation is proved.** Set
theory's extensionality, type theory's canonicity, category theory's subobject
classification, each is the foundation's own way of telling its two primitives
apart, and each yields the δ distinction. -/
theorem three_foundations_own_distinction :
    (∀ m n : ℕ, m = n ↔ ∀ i, (SetTheoryParse.Mem i m ↔ SetTheoryParse.Mem i n))
      ∧ (∀ b : TypeTheoryParse.Two, b = false ∨ b = true)
      ∧ CategoryTheoryParse.subobjectClassification (fun _ => True) = True :=
  ⟨SetTheoryParse.ext_iff, TypeTheoryParse.canonicity,
    CategoryTheoryParse.classifies_top⟩

/-- **The set-theory leg, at full strength.** Beyond the finite (HF) parse, full ZFC
over Mathlib's `ZFSet`, with the axiom of infinity modelled (ω containing ∅ and
closed under successor), realizes the δ core. The HF caveat ("infinity not
modelled") is lifted. -/
theorem set_theory_with_infinity_realizes_delta :
    ((∅ : FullZFCParse.ZF) ∈ ZFSet.omega
        ∧ ∀ n, n ∈ ZFSet.omega → insert n n ∈ ZFSet.omega)
      ∧ Nonempty (PRCEmbeddingInto FullZFCParse.zfSystem) :=
  ⟨FullZFCParse.infinity_modeled, FullZFCParse.zfSystem_embeds_delta⟩

What this page does not claim

This module does not prove that the three foundations are identical, only that each embeds the same δ core. The axiom of infinity is modelled for full ZFC, but the module does not show how infinity behaves in the type-theory or category-theory parses.

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/PrimitiveRecognitionCalculus/PRCFoundationsParsed.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: