Foundation Primitive Recognition Calculus Prctype Theory Parse Tt System

The smallest possible system

Martin-Löf type theory, the formal system that underpins modern proof assistants, begins with a deceptively simple object: a type with exactly two elements, usually called Bool (for boolean) with values false and true. The Recognition Science framework formalizes this as ttSystem, a concrete instance of its more general ledger concept, a discrete record of events. The declaration establishes three facts: the type has exactly two inhabitants (canonicity), those two inhabitants are distinct (no-confusion), and this minimal structure is expressive enough to embed the framework's foundational δ core.

The first property, canonicity, states that every closed term of the type is either false or true. In plain terms, there are no hidden or exotic values beyond the two obvious ones. The second property, no-confusion, asserts that false is not equal to true; they are genuinely different objects. These two properties together give the type its fundamental role: it provides a binary distinction that the rest of the formal system can build upon. The framework proves both properties as theorems, not assumptions, using the type theory's own rules of construction and recursion.

The third and most substantial claim is ttSystem_expressive: the two-element type is expressive enough to realize the δ core, the framework's minimal recognition structure. This is shown by constructing an embedding from the δ core into ttSystem, which means every behavior of the core can be represented within this simple type-theoretic setting. From this embedding, the framework derives that ttSystem is not degenerate, meaning it does not collapse into a trivial system where all expressions are equivalent. The key theorem type_theory_realizes_delta packages all three results together: canonicity, no-confusion, and the embedding.

In Recognition Science, this declaration acts as a bridge. It shows that the framework's primitive recognition calculus, built on the idea of a ledger with distinct tokens, is compatible with the standard foundations of formal mathematics. The framework models type theory itself as a recognition system, where the two boolean values serve as the fundamental tokens and expressions are ordered by their derivation length. This is a modeling choice, not a claim about how mathematicians actually think; it is a way of viewing an existing formal system through the framework's lens.

What ttSystem does not claim is equally important. It does not assert that all of mathematics reduces to two values, nor that Martin-Löf type theory is the only foundation. It does not claim to have discovered new facts about type theory; the canonicity and no-confusion properties are well-known classical results. The declaration's contribution is structural: it shows how an existing formal system fits into the framework's recognition-based architecture, providing a concrete example of how the δ core can be realized. This is a proof of compatibility, not a proof of uniqueness or superiority.

/-- **The faithful parse, packaged.** Type theory's two-element type satisfies
canonicity (exactly two closed terms) and no-confusion (they are distinct), and the
foundation realizes the δ core. -/
theorem type_theory_realizes_delta :
    (∀ b : Two, b = false ∨ b = true)
      ∧ ((false : Two) ≠ true)
      ∧ Nonempty (PRCEmbeddingInto ttSystem) :=
  ⟨canonicity, no_confusion, ttSystem_embeds_delta⟩

/-- **Canonicity.** Every closed term of `𝟚` is one of the two canonical
constructors. The type has exactly two inhabitants. -/
theorem canonicity (b : Two) : b = false ∨ b = true := by
  cases b
  · exact Or.inl rfl
  · exact Or.inr rfl

/-- **No-confusion / constructor disjointness.** The two canonical terms are
distinct: this is the recursor's verdict, the type theory's own distinction. -/
theorem no_confusion : (false : Two) ≠ true := by decide

/-- **MLTT contains the δ core.** -/
theorem ttSystem_embeds_delta : Nonempty (PRCEmbeddingInto ttSystem) :=
  FormalSystemEmbeddingTarget_proved ttSystem ttSystem_expressive

/-- MLTT parsed into the `FormalSystem` interface. Tokens are closed terms of `𝟚`;
the discrimination relation is term inequality; the endpoints are the two canonical
constructors; the expression order is the derivation-length order. -/
def ttSystem : FormalSystem where
  Token := Two
  Expr := ℕ
  distinguishes := fun a b => a ≠ b
  exprExtends := fun m n => m ≤ n
  endpointToken := fun e =>
    match e.side with
    | Side.left => false
    | Side.right => true
  traceExpr := Trace.length
  traceExpr_extends := fun h => InevitabilityInstances.length_le_of_extends h

What this page does not claim

All of mathematics reduces to two values. Martin-Löf type theory is the only valid foundation for mathematics. The declaration discovers new facts about type theory beyond known classical results.

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