Foundation Universal Forcing Natural Number Object Interpret Eq Parity

The parity map

A natural-number object is a categorical way to say what counting is, without presupposing the usual number system. It is a triple (N, z, s) where z is a starting point and s is a successor map, such that for any target set X with a point x and a function f, there is exactly one map h from N to X with h z = x and h (s n) = f (h n). This is the Lawvere characterization, named after F. William Lawvere, who isolated it in the 1960s. It captures primitive recursion: the unique h is the recursive definition generated by the data (x, f).

The machine-checked library of formal theorems proves that the framework's natural numbers, called LogicNat, form such an object, and that every realization of the framework's logic carries the same one. The sharpest test is the discrete Boolean realization, whose carrier has only two elements, false and true. Its interpretation map sends every LogicNat to a Boolean value. The theorem interpret_eq_parity states that this map is exactly the parity map: it sends a number to true exactly when the number is odd, and false when it is even. In symbols, the interpretation of n equals Nat.bodd (LogicNat.toNat n), where bodd is the parity function. The proof runs by induction on n, using the fact that one step of the Boolean realization is Boolean negation, which flips parity.

What the theorem establishes is that the iteration count survives even when the carrier image collapses to two values. The map is not injective: infinitely many numbers land on each Boolean. But the iteration object itself, LogicNat, never collapses. It remains the full natural-number object, canonically equivalent to the natural-number object of any other realization, including the continuous positive-ratio one. The Boolean collapse is therefore a collapse of the carrier set, not of the counting structure. The framework's answer to the critic who says it smuggled in iteration-counting is that the iteration object is the natural-number object in the Lawvere sense, and it is the same in every realization.

In Recognition Science, this is the natural-number-object level of the Universal Forcing statement: every Law-of-Logic realization carries the same NNO. The theorem does not claim that the Boolean realization's carrier is the natural numbers, nor that the interpretation map is injective. It does not claim that parity is the only information preserved. It claims exactly that the interpretation equals the parity map, and that the iteration object remains the full LogicNat. The collapse is real, but it is a collapse of the set of values, not of the ability to count.

/-- The Boolean strict-realization interpretation is the parity map.

This is the formal statement that the iteration count survives even when
the orbit-as-set collapses to `{false, true}`. -/
theorem interpret_eq_parity (n : LogicNat) :
    StrictLogicRealization.interpret strictBooleanRealization n =
      Nat.bodd (LogicNat.toNat n) := by
  induction n with
  | identity => rfl
  | step n ih =>
      show xorBool true (StrictLogicRealization.interpret strictBooleanRealization n) =
        Nat.bodd (Nat.succ (LogicNat.toNat n))
      rw [xorBool_true, ih, Nat.bodd_succ]

/-- Despite the carrier collapse, the iteration object is itself a
natural-number object — the same one as in the continuous positive-ratio
realization. -/
def boolean_freeOrbit_isNNO :
    IsNaturalNumberObject
      (N := StrictLogicRealization.FreeOrbit strictBooleanRealization)
      LogicNat.identity LogicNat.step :=
  logicNat_isNNO

/-- The forced arithmetic of every realization is canonically equivalent to
`LogicNat`. This is the Universal Forcing statement at the natural-number
object level: every Law-of-Logic realization carries the same NNO. -/
noncomputable def realizationOrbit_equiv_logicNat (R : LogicRealization.{0, 0}) :
    R.Orbit ≃ LogicNat :=
  IsNaturalNumberObject.equiv (realizationOrbit_isNNO R) logicNat_isNNO

/-- Even though the carrier image collapses, the iteration object is the
full `LogicNat`. Concretely: the interpretation map is not injective. -/
theorem interpret_collapses :
    ¬ Function.Injective
      (StrictLogicRealization.interpret strictBooleanRealization) := by
  intro hinj
  have h0 :
      StrictLogicRealization.interpret strictBooleanRealization LogicNat.identity =
        Nat.bodd 0 := interpret_eq_parity _
  have h2 :
      StrictLogicRealization.interpret strictBooleanRealization
        (LogicNat.step (LogicNat.step LogicNat.identity)) =
          Nat.bodd 2 := interpret_eq_parity _
  have hbodd : (Nat.bodd 0 : Bool) = Nat.bodd 2 := by decide
  have hboth :
      StrictLogicRealization.interpret strictBooleanRealization LogicNat.identity =
        StrictLogicRealization.interpret strictBooleanRealization
          (LogicNat.step (LogicNat.step LogicNat.identity)) := by
    rw [h0, h2, hbodd]
  have hne : LogicNat.identity ≠ LogicNat.step (LogicNat.step LogicNat.identity) :=
    LogicNat.zero_ne_succ _
  exact hne (hinj hboth)

What this page does not claim

The Boolean realization's carrier is the natural numbers. The interpretation map is injective or preserves any structure beyond parity. Parity is the only information preserved by the collapse.

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/UniversalForcing/NaturalNumberObject.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: