Foundation Primitive Recognition Calculus Prcinevitability Instances Named Found

Four foundations, one primitive distinction

A formal system, in the Recognition Science framework, is a discrete record of events: a set of tokens, a way to build expressions from them, and a rule for when one expression extends another. The framework's recognition cost, the forced price of telling two tokens apart, is what its theorems study. The declaration named_foundations_embed_delta, proved in the framework's machine-checked library of formal theorems, shows that four standard foundations each contain the same primitive two-token core, the δ core.

The four foundations are logic, arithmetic, set theory, and type theory. Logic contributes the two Boolean values, true and false. Arithmetic contributes the natural numbers 0 and 1. Set theory contributes the empty set and the singleton set. Type theory contributes the two-element type whose two closed terms are distinct. In each case, the foundation exposes two distinguishable primitives, and the theorem shows that any such pair can be embedded into the δ core. The theorem is a single conjunction: each of the four systems admits a PRC embedding, a structure-preserving translation into the primitive recognition calculus.

The proof is short and uniform. A single construction, ofTwoDistinct, takes any type with two distinct elements and builds a formal system from it. The construction then proves that the system is expressive, meaning it distinguishes the two endpoint tokens, and that expressiveness suffices for the embedding. The four instances are the Boolean pair false and true, the Peano pair 0 and 1, the set-theoretic pair of the empty set and the universal set on a one-point domain, and the type-theoretic pair of the two injections into a sum type. Each instance is a concrete witness, not a schematic placeholder.

What the theorem does not claim is as important as what it proves. It does not show that these four foundations are equivalent, nor that one reduces to another. It does not provide a full faithful parse of any foundation into the recognition calculus; the docstring explicitly notes that such a corpus task remains open. The theorem shows only that the primitive distinction, the ability to tell two things apart, appears in each foundation. It is a structural observation about a shared core, not a reduction of mathematics to a single system.

The consequence is that the δ core is not an artifact of one foundation's notation. Whether a foundation starts with truth values, numbers, sets, or types, it must draw the same first line: this token is not that token. The theorem makes that line precise and machine-checked, and it names the four witnesses that demonstrate its generality.

/-- **Item 4, widened.** Four structurally different foundations, the logical
two-valued carrier, the arithmetic `0 ≠ 1`, the set-theoretic `∅ ≠ {∅}`, and the
type-theoretic `𝟚`, each realize the δ core. The primitive distinction is not an
artifact of one foundation's notation; it appears wherever two primitives can be
told apart. -/
theorem named_foundations_embed_delta :
    Nonempty (PRCEmbeddingInto boolLogicSystem)
      ∧ Nonempty (PRCEmbeddingInto peanoSystem)
      ∧ Nonempty (PRCEmbeddingInto setFoundationSystem)
      ∧ Nonempty (PRCEmbeddingInto typeTheorySystem) :=
  ⟨boolLogicSystem_embeds_delta, peanoSystem_embeds_delta,
    setFoundationSystem_embeds_delta, typeTheorySystem_embeds_delta⟩

/-- A formal system built from any type with two distinct primitives. Tokens are
the type's elements, expressions are finite-trace lengths, and expression
extension is the length order. -/
def ofTwoDistinct {α : Type} (a₀ a₁ : α) (_hne : a₀ ≠ a₁) : FormalSystem where
  Token := α
  Expr := Nat
  distinguishes := fun x y => x ≠ y
  exprExtends := fun m n => m ≤ n
  endpointToken := fun e => if e.side = Side.left then a₀ else a₁
  traceExpr := Trace.length
  traceExpr_extends := fun h => length_le_of_extends h

/-- **Item 4 (generic).** Any foundation exposing two distinguishable primitives
realizes the δ core. -/
theorem two_distinct_realizes_delta {α : Type} (a₀ a₁ : α) (hne : a₀ ≠ a₁) :
    Nonempty (PRCEmbeddingInto (ofTwoDistinct a₀ a₁ hne)) :=
  FormalSystemEmbeddingTarget_proved _ (ofTwoDistinct_expressive a₀ a₁ hne)

What this page does not claim

The theorem does not prove that logic, arithmetic, set theory, and type theory are equivalent foundations. The theorem does not reduce any of the four foundations to the recognition calculus in full. The theorem does not claim that the δ core is the only primitive structure in these foundations.

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