Foundation Universal Forcing Forced Semiring Map Preserves Mul

The forced arithmetic

The natural numbers are the counting numbers: 0, 1, 2, 3, and so on, built one step at a time. A ledger here means a discrete record of events, and the framework's recognition process, the act of distinguishing one event from another, forces a structure that behaves exactly like these numbers. The theorem map_preserves_mul states that any function from this structure to itself that sends zero to zero and commutes with the step function (so that the image of a successor is the successor of the image) must also preserve multiplication: h(a * b) = h(a) * h(b).

This is not a property of one special map. The proof is a single induction on the second argument, because multiplication itself is defined by repeated addition. The same two assumptions, fixing zero and commuting with the step, already force the map to preserve addition. Multiplication then follows automatically. The result is a semiring isomorphism, meaning the map is a bijection that respects 0, 1, addition, and multiplication. The framework's library of machine-checked formal theorems records this as a proved theorem, not a definitional choice.

In Recognition Science, this theorem is part of a larger claim: distinction forces the arithmetic. The canonical map between any two strict realizations of the ledger is the unique zero/step-preserving map, and it preserves the full arithmetic structure. The capstone result states that this forced carrier is isomorphic to the natural numbers as a (0, 1, +, ×) structure. The arithmetic is not posited; it is derived from the act of distinguishing events.

One honest note is recorded in the same file. On the strict path, every realization uses the same free orbit for its carrier, so the canonical map between two realizations is literally the identity function. This does not trivialize the theory. The general preservation lemmas apply to any zero/step map, and the cross-carrier canonicity is the substantive content. The identity observation is simply a fact about this particular presentation.

What the theorem does not claim is broader. It does not say that any map preserving multiplication must fix zero or commute with the step. It does not claim that the natural numbers are the only possible arithmetic, only that this structure is what distinction forces. It also does not assert that the ledger itself is the natural numbers; the ledger is the discrete record, and the arithmetic is what recognition imposes on it.

/-- A map fixing zero and commuting with `succ` (hence, by the previous lemma,
preserving `+`) preserves multiplication. Multiplication recurses on its second
argument via addition. -/
theorem map_preserves_mul (h : LogicNat → LogicNat)
    (h0 : h LogicNat.zero = LogicNat.zero)
    (hs : ∀ n, h (LogicNat.succ n) = LogicNat.succ (h n)) :
    ∀ a b : LogicNat, h (a * b) = h a * h b := by
  have hadd := map_preserves_add h h0 hs
  intro a b
  induction b with
  | identity =>
      show h (a * LogicNat.zero) = h a * h LogicNat.zero
      rw [mul_zero, h0, mul_zero]
  | step b ih =>
      show h (a * LogicNat.succ b) = h a * h (LogicNat.succ b)
      rw [mul_succ, hadd, ih, hs, mul_succ]

/-- A map fixing zero and commuting with `succ` preserves addition. Addition
recurses on its second argument, so the proof is a single induction. -/
theorem map_preserves_add (h : LogicNat → LogicNat)
    (h0 : h LogicNat.zero = LogicNat.zero)
    (hs : ∀ n, h (LogicNat.succ n) = LogicNat.succ (h n)) :
    ∀ a b : LogicNat, h (a + b) = h a + h b := by
  intro a b
  induction b with
  | identity =>
      show h (a + LogicNat.zero) = h a + h LogicNat.zero
      rw [add_zero, h0, add_zero]
  | step b ih =>
      show h (a + LogicNat.succ b) = h a + h (LogicNat.succ b)
      rw [add_succ, hs, ih, hs, add_succ]

/-- **Uniqueness as a semiring map.** Any function preserving zero and step
equals the forcing map, so in particular the forcing map is the unique semiring
homomorphism — it is determined, not chosen. (Restated from canonicity for the
`LogicNat` presentation.) -/
theorem forcingFn_unique (R S : UniversalForcing.Strict.StrictLogicRealization.{0,0})
    (f : LogicNat → LogicNat)
    (h0 : f LogicNat.zero = LogicNat.zero)
    (hs : ∀ n, f (LogicNat.succ n) = LogicNat.succ (f n)) :
    f = forcingFn R S :=
  UniversalForcing.Strict.StrictLogicRealization.universal_forcing_unique R S f h0 hs

/-- The forced arithmetic is `ℕ`. -/
noncomputable def forcedArithmeticIsNat : ForcedArithmeticIsNat where
  toEquiv := LogicNat.equivNat
  map_zero := LogicNat.toNat_zero
  map_one := toNat_one
  map_add := LogicNat.toNat_add
  map_mul := LogicNat.toNat_mul

What this page does not claim

The theorem does not claim that any multiplication-preserving map must fix zero or commute with the step. The theorem does not claim the natural numbers are the only possible arithmetic, only that this structure is what distinction forces. The theorem does not claim the ledger itself is the natural numbers; the ledger is the discrete record, and the arithmetic is what recognition imposes on it.

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