Foundation Universal Forcing Strict Realization Universal Forcing

The strict forcing result

The natural numbers, 0, 1, 2, 3, and so on, are usually introduced as a special set of objects with a special operation called addition. The Recognition Science result called universal forcing shows that this arithmetic is not special at all. It is forced. Any structure that provides the bare minimum of data: a way to compare two things, a way to combine two things into one, a distinguished identity element, and a generator that is not the identity, must contain a copy of the natural numbers inside it. The theorem is not about a particular example. It is about every possible structure that satisfies these few conditions.

The proof works by building the natural numbers out of the structure's own operations. Start with the identity element, call it one. Then apply the generator once to get the next element, apply it again to get the next, and so on. This process, primitive recursion over the generator and composition operation, produces an infinite sequence that behaves exactly like the natural numbers. The earlier version of the theorem allowed a structure to carry an internal orbit, a ready-made sequence, as part of its data. The strict version removes that escape hatch. A strict realization supplies only the native comparison, composition, identity, invariance, and non-triviality data. The free orbit is then derived uniformly as LogicNat, the framework's name for the natural numbers built this way.

The central declaration, universal_forcing, takes two strict realizations, R and S, and produces an equivalence between their arithmetics. The equivalence is not an accident or a construction choice. It is a theorem that the arithmetic of R and the arithmetic of S are canonically the same, both equivalent to LogicNat. Every strict realization has forced arithmetic canonically equivalent to LogicNat. This means the natural numbers are not one structure among many. They are the unique arithmetic that any structure with these basic laws must contain.

In Recognition Science, this result is a load-bearing step. The framework derives physical constants and structures from the cost of recognition events, and the natural numbers are the first piece of mathematics that the framework does not assume. It gets them for free from the laws of comparison and combination. The strict version matters because it shows the result does not depend on a hidden assumption. The arithmetic is not supplied by the user of the framework. It is extracted from the native data alone.

The result establishes a uniqueness claim. It does not establish that any particular physical system is a strict realization. It does not say what the generator or the composition operation are in any concrete case. It says only that if a structure has these basic features, then it contains the natural numbers, and that this arithmetic is the same in every such structure. The framework's later steps, the ones that derive the golden ratio, the eight-tick cycle, and three spatial dimensions, build on this foundation, but they are separate results with their own conditions.

/-- Universal forcing for strict realizations. -/
noncomputable def universal_forcing (R S : StrictLogicRealization) :
    (arith R).peano.carrier ≃ (arith S).peano.carrier :=
  ArithmeticOf.equivOfInitial (arith R) (arith S)

/-- Every strict realization has forced arithmetic canonically equivalent to
`LogicNat`. -/
def arith_equiv_logicNat (R : StrictLogicRealization) :
    (arith R).peano.carrier ≃ LogicNat :=
  (toLightweight R).orbitEquivLogicNat

/-- Convert a strict realization to the existing lightweight interface.
The orbit fields are all derived from `LogicNat`, not supplied by the caller. -/
def toLightweight (R : StrictLogicRealization) : LogicRealization where
  Carrier := R.Carrier
  Cost := R.Cost
  zeroCost := R.zeroCost
  compare := R.compare
  zero := R.one
  step := fun x => R.compose R.generator x
  Orbit := FreeOrbit R
  orbitZero := LogicNat.zero
  orbitStep := LogicNat.succ
  interpret := interpret R
  interpret_zero := rfl
  interpret_step := by intro n; rfl
  orbit_no_confusion := by
    intro n h
    exact LogicNat.zero_ne_succ n h
  orbit_step_injective := LogicNat.succ_injective
  orbit_induction := by
    intro P h0 hs n
    exact LogicNat.induction (motive := P) h0 hs n
  orbitEquivLogicNat := Equiv.refl LogicNat
  orbitEquiv_zero := rfl
  orbitEquiv_step := by intro n; rfl
  identity := R.identity_law
  nonContradiction := R.non_contradiction_law
  excludedMiddle := R.excluded_middle_law
  composition := R.composition_law
  actionInvariant := R.invariance_law
  nontrivial := ⟨R.generator, R.nontrivial_law⟩

What this page does not claim

The result does not identify any particular physical system as a strict realization. The theorem does not derive the golden ratio, the eight-tick cycle, or three spatial dimensions; those are separate results built on this foundation. The declaration does not prove that the natural numbers are the only arithmetic possible, only that any structure with the stated laws must contain them.

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