Foundation Primitive Recognition Calculus Certified Analytic Protocols Values Co

The countable registry

A countable set is one you can put in a list, even an infinite list, so that every member appears at some finite position. The rational numbers are countable; the real numbers are not. The declaration values_countable proves that a certain carefully built collection of real numbers is countable. The collection starts with a registry, which is just a rule that assigns a constant or a unary operation to each natural number. From that registry, the framework builds expressions: finite trees that combine rational numbers, registered constants, negation, addition, subtraction, and registered unary operations. Evaluating such an expression produces a real number.

The theorem states that the set of all real numbers obtainable this way is countable, for any registry whatsoever. The proof is short and structural: expressions are finite trees over countable labels, so there are only countably many expressions, and each evaluates to one value. This fact matters because it blocks a subtle kind of smuggling. If someone claimed the framework's analytic content reached every real number, that claim would fail immediately: the framework's values form a countable set, and the continuum is not countable. The declaration also guarantees that every value in the set has a protocol witness, meaning each number is genuinely produced by some expression, not merely asserted to exist.

In Recognition Science, this result anchors the ledger: the discrete record of events that the framework studies. The ledger can hold only countably many distinct values, which keeps the framework's analytic content tied to finite, checkable expressions instead of an uncountable continuum. The companion theorem transcendental_protocol_closure packages this countability together with the facts that rational literals evaluate correctly and that addition, negation, and subtraction behave as expected under evaluation.

The declaration does not claim that the registry itself is finite, nor that the set of values is closed under any operation beyond those explicitly built into the expression grammar. It does not claim that every real number appears, which would contradict countability. It also does not claim that the registry's constants or operations are computable in any practical sense; the evaluation is noncomputable in the formal library, meaning it is defined abstractly rather than as an algorithm. What it establishes is precise and limited: the values generated by any countable registry form a countable set, and each value is witnessed by a protocol.

/-- Registry values are countable because expressions are finite trees over
countable labels. This is the countability fact that blocks continuum smuggling. -/
theorem values_countable (R : Registry) : (values R).Countable :=
  Set.countable_range (value R)

/-- Registry values are countable because expressions are finite trees over
countable labels. This is the countability fact that blocks continuum smuggling. -/
theorem values_countable (R : Registry) : (values R).Countable :=
  Set.countable_range (value R)

/-- Every registry value has a protocol witness, by construction. -/
theorem every_value_has_protocol (R : Registry) (x : ℝ) (hx : x ∈ values R) :
    ∃ p : Protocol, p.value = x := by
  rcases hx with ⟨e, rfl⟩
  exact ⟨eval R e, rfl⟩

/-- **Transcendental protocol closure.** Any countably indexed registry of certified
analytic constants and protocol transformers generates only countably many real
values, and every value is witnessed by a Delta-real protocol. The continuum is not
the carrier of analytic content; a certified countable protocol registry is. -/
theorem transcendental_protocol_closure (R : Registry) :
    (values R).Countable
      ∧ (∀ x : ℝ, x ∈ values R → ∃ p : Protocol, p.value = x)
      ∧ (∀ q : ℚ, value R (.rat q) = (q : ℝ))
      ∧ (∀ a b : Expr, value R (.add a b) = value R a + value R b)
      ∧ (∀ a : Expr, value R (.neg a) = - value R a)
      ∧ (∀ a b : Expr, value R (.sub a b) = value R a - value R b) :=
  ⟨values_countable R, every_value_has_protocol R, value_rat R, value_add R,
    value_neg R, value_sub R⟩

What this page does not claim

The registry itself is finite, or that its values are closed under arbitrary operations. Every real number appears in the generated set, which would contradict the countability theorem. The registry's constants or operations are computable in a practical algorithmic sense.

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