Foundation Primitive Recognition Calculus Prcfull Zfcparse Distinguishes Iff Ne

Distinguishing by set difference

In the Recognition Science framework, a ledger is a discrete record of events, and its most basic operation is telling two tokens apart. The theorem distinguishes_iff_ne, proved in the framework's machine-checked library of formal theorems, makes this precise for a specific system built on Zermelo-Fraenkel set theory with choice (ZFC). It states that two tokens are distinguished exactly when the sets they represent are not equal. In symbols: zfSystem.distinguishes a b holds if and only if zfWitness a ≠ zfWitness b.

The declaration is not an isolated curiosity. It is the core of a faithful parse of full ZFC into the framework's formal system. The tokens are the booleans false and true, mapped to the empty set ∅ and the singleton {∅}, the von Neumann numerals 0 and 1. The theorem proves that this mapping is injective: distinct tokens name distinct sets. The distinction is genuinely extensional, meaning the sets differ in their members, not merely in their names. The empty set has no members; the singleton has exactly one member, namely the empty set itself. This is the real set-theoretic difference, not a token accident.

The theorem also establishes that this system realizes the framework's δ core, a minimal structure for recognition. It proves the system is expressive, meaning it can distinguish its two endpoints, and that it embeds the δ core. It further shows the system is not degenerate, a technical condition meaning it does not collapse all tokens into one. The proof of distinguishes_iff_ne itself is short, relying on the standard extensionality axiom of ZF set theory: two sets are equal if and only if they have exactly the same members. The theorem is a formal consequence of this axiom, applied to the specific sets ∅ and {∅}.

What this does not claim is broader. It does not claim that the framework's entire recognition calculus is equivalent to ZFC, nor that ZFC is the only possible foundation. It does not claim that the mapping from tokens to sets is surjective, only injective. It does not claim that the framework proves the consistency of ZFC, a separate and much deeper question. The theorem is a precise, limited bridge: it shows that a minimal recognition system can be faithfully embedded in full ZFC, and that the distinction relation in that system is exactly set-theoretic inequality. This is a foundational step, not a complete foundation.

The practical consequence is that the framework's primitive recognition operation, distinguishing two tokens, can be grounded in a standard, well-understood mathematical universe. When the framework says two things are different, it can mean, in this model, that the sets they name are different in the ordinary set-theoretic sense. This gives the framework's most basic concept a solid, checkable meaning, and it opens the door to building more complex structures on top of this foundation, such as the axiom of infinity, which the same file shows is modeled by the von Neumann ω.

/-- The discrimination relation IS inequality of the represented ZF sets: two tokens
are distinguished exactly when the sets they name differ in some member. So the
parse discriminates by real set difference, not by token accident. -/
theorem distinguishes_iff_ne (a b : Bool) :
    zfSystem.distinguishes a b ↔ zfWitness a ≠ zfWitness b := by
  show (∃ z : ZF, ¬ (z ∈ zfWitness a ↔ z ∈ zfWitness b)) ↔ zfWitness a ≠ zfWitness b
  rw [ne_eq, ZFSet.ext_iff, not_forall]

/-- The token-to-set map is injective: distinct tokens name distinct ZF sets. -/
theorem zfWitness_injective : Function.Injective zfWitness := by
  intro a b h
  cases a <;> cases b <;> simp only [zfWitness] at h <;>
    first
      | rfl
      | exact absurd h empty_ne_singleton
      | exact absurd h.symm empty_ne_singleton

/-- **The faithful parse, packaged.** Full ZFC (Mathlib's `ZFSet`): (i) satisfies
extensionality, (ii) has ∅ ≠ {∅} as sets, (iii) discriminates by genuine ZF
extensional difference, (iv) models the axiom of infinity (ω with ∅ and successor
closure), and (v) realizes the δ core. -/
theorem full_zfc_realizes_delta :
    (∀ a b : ZF, a = b ↔ ∀ z, z ∈ a ↔ z ∈ b)
      ∧ ((∅ : ZF) ≠ ({∅} : ZF))
      ∧ (∀ a b : Bool, zfSystem.distinguishes a b ↔ zfWitness a ≠ zfWitness b)
      ∧ ((∅ : ZF) ∈ ZFSet.omega ∧ ∀ n, n ∈ ZFSet.omega → insert n n ∈ ZFSet.omega)
      ∧ Nonempty (PRCEmbeddingInto zfSystem) :=
  ⟨fun _ _ => ZFSet.ext_iff, empty_ne_singleton, distinguishes_iff_ne,
    infinity_modeled, zfSystem_embeds_delta⟩

What this page does not claim

The theorem does not prove that the framework's entire calculus is equivalent to ZFC. The theorem does not claim the token-to-set mapping is surjective. The theorem does not prove the consistency of ZFC.

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