Encyclopedia Foundation Foundation Universal Forcing Canonical Forcing Forcing Map Iff
ARTICLE 3 claims 3 theorems
Foundation Universal Forcing Canonical Forcing Forcing Map Iff
A single theorem pins down the only structure-preserving bridge between any two forced arithmetics, leaving no room for representational choice.
The canonical forcing map
In mathematics, a Peano structure is a set with a distinguished starting point, usually called zero, and a successor operation that steps from one element to the next. The natural numbers are the standard example: zero, then its successor one, then two, and so on. A structure-preserving map between two such systems is a function that sends the first system's zero to the second system's zero and commutes with the successor operation, so that stepping first and then mapping gives the same result as mapping first and then stepping.
The Recognition Science framework builds its own arithmetic from a primitive notion of a ledger, a discrete record of events, and derives a cost function that forces a specific structure. Within this framework, the declaration forcing_map_iff establishes a complete characterization: a function between the carriers of two forced arithmetics is the canonical forcing map if and only if it preserves zero and the successor operation. This is an equivalence, not merely a one-way implication. The theorem proves that any function satisfying these two simple conditions must be the unique structure-preserving map, and conversely, that this unique map always satisfies the conditions.
The significance lies in what the theorem removes: representational freedom. When two forced arithmetics share a carrier universe, the framework proves there is exactly one structure morphism between them, determined entirely by the zero and step data. The forcing map is not one isomorphism among many; it is the only one. This canonicity result holds for any two realizations of the framework's logic, not just a single preferred example, and it extends to a certificate that packages existence, preservation, and uniqueness into a single structure.
What the theorem does not claim is equally important. It does not assert that the carrier universes themselves are identical, only that a unique map exists between them. It does not claim that any function preserving zero and step exists; it characterizes those that do as being the forcing map. The theorem is a statement about the uniqueness of a morphism given a shared carrier universe, not about the construction of that universe or about any physical property of the framework's constants. It leaves open how the carrier universe is chosen and what the forced arithmetic represents in physical terms.
THEOREM forcing_map_iff · IndisputableMonolith/Foundation/UniversalForcing/CanonicalForcing.lean
/-- Complete characterization (general realizations). -/
theorem forcing_map_iff
(A : ArithmeticOf.{u, v, w, w, w} R) (B : ArithmeticOf.{u', v', w, w, w} S)
(f : A.peano.carrier → B.peano.carrier) :
(f A.peano.zero = B.peano.zero ∧ ∀ x, f (A.peano.step x) = B.peano.step (f x))
↔ f = (equivOfInitial A B).toFun := by
constructor
· rintro ⟨hz, hs⟩
exact forcing_map_unique A B f hz hs
· rintro rfl
exact ⟨equivOfInitial_map_zero A B, equivOfInitial_map_step A B⟩
THEOREM forcing_map_unique · IndisputableMonolith/Foundation/UniversalForcing/CanonicalForcing.lean
/-- **General canonicity.** Any function preserving zero and step between two
forced arithmetics (sharing a carrier universe) *is* the forcing map. The map is
determined by the zero/step data alone — no representational freedom. -/
theorem forcing_map_unique
(A : ArithmeticOf.{u, v, w, w, w} R) (B : ArithmeticOf.{u', v', w, w, w} S)
(f : A.peano.carrier → B.peano.carrier)
(hz : f A.peano.zero = B.peano.zero)
(hs : ∀ x, f (A.peano.step x) = B.peano.step (f x)) :
f = (equivOfInitial A B).toFun := by
have h := A.initial.uniq B.peano
(⟨f, hz, hs⟩ : PeanoObject.Hom A.peano B.peano) (A.initial.lift B.peano)
simpa [equivOfInitial] using h
THEOREM universal_objective · IndisputableMonolith/Foundation/UniversalForcing/CanonicalForcing.lean
/-- **The Universal-Forcing objective at full generality.** For *any* two
Law-of-Logic realizations `R`, `S` (in arbitrary universes) and any forced
arithmetics `A` over `R`, `B` over `S` sharing a carrier universe, there is a
structure-preserving equivalence between the carriers that is *the unique*
zero/step-preserving map. This is the precise content of
`universal-forcing-program.mdc`'s "canonical equivalence of `ArithmeticOf R` and
`ArithmeticOf S` across admissible realizations": not bare existence of some
iso, but a canonical, determined morphism.
Unlike the strict-realization certificate below (where the carrier is concretely
`LogicNat` and the map is the identity), here `A.peano.carrier` and
`B.peano.carrier` may be genuinely different Peano objects, so the equivalence is
a nontrivial iso — yet still the only structure morphism between them. -/
theorem universal_objective
(A : ArithmeticOf.{u, v, w, w, w} R) (B : ArithmeticOf.{u', v', w, w, w} S) :
∃ e : A.peano.carrier ≃ B.peano.carrier,
e A.peano.zero = B.peano.zero
∧ (∀ x, e (A.peano.step x) = B.peano.step (e x))
∧ (∀ f : A.peano.carrier → B.peano.carrier,
f A.peano.zero = B.peano.zero →
(∀ x, f (A.peano.step x) = B.peano.step (f x)) →
f = e.toFun) :=
⟨equivOfInitial A B,
equivOfInitial_map_zero A B,
equivOfInitial_map_step A B,
fun f hz hs => forcing_map_unique A B f hz hs⟩
What this page does not claim
The theorem does not claim that the carrier universes of two realizations are identical. The theorem does not establish the existence of any zero and step preserving function; it only characterizes those that do exist. The theorem does not assign any physical meaning to the forced arithmetic or its elements.
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/CanonicalForcing.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:
- How does the framework construct the carrier universe for a given realization?
- What physical interpretation does the framework assign to the forced arithmetic's zero and successor operations?
- How does the canonicity of the forcing map relate to the derivation of physical constants in the framework?
- What distinguishes the strict realizations from the general realizations in the framework's proofs?
MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND
THEOREM forcing_map_iff · IndisputableMonolith/Foundation/UniversalForcing/CanonicalForcing.lean
/-- Complete characterization (general realizations). -/ theorem forcing_map_iff (A : ArithmeticOf.{u, v, w, w, w} R) (B : ArithmeticOf.{u', v', w, w, w} S) (f : A.peano.carrier → B.peano.carrier) : (f A.peano.zero = B.peano.zero ∧ ∀ x, f (A.peano.step x) = B.peano.step (f x)) ↔ f = (equivOfInitial A B).toFun := by constructor · rintro ⟨hz, hs⟩ exact forcing_map_unique A B f hz hs · rintro rfl exact ⟨equivOfInitial_map_zero A B, equivOfInitial_map_step A B⟩The theorem proves that any function satisfying these two simple conditions must be the unique structure-preserving map, and conversely, that this unique map always satisfies the conditions. forcing_map_iff · IndisputableMonolith/Foundation/UniversalForcing/CanonicalForcing.leanTHEOREM forcing_map_unique · IndisputableMonolith/Foundation/UniversalForcing/CanonicalForcing.lean
/-- **General canonicity.** Any function preserving zero and step between two forced arithmetics (sharing a carrier universe) *is* the forcing map. The map is determined by the zero/step data alone — no representational freedom. -/ theorem forcing_map_unique (A : ArithmeticOf.{u, v, w, w, w} R) (B : ArithmeticOf.{u', v', w, w, w} S) (f : A.peano.carrier → B.peano.carrier) (hz : f A.peano.zero = B.peano.zero) (hs : ∀ x, f (A.peano.step x) = B.peano.step (f x)) : f = (equivOfInitial A B).toFun := by have h := A.initial.uniq B.peano (⟨f, hz, hs⟩ : PeanoObject.Hom A.peano B.peano) (A.initial.lift B.peano) simpa [equivOfInitial] using hThe framework proves there is exactly one structure morphism between them, determined entirely by the zero and step data. forcing_map_unique · IndisputableMonolith/Foundation/UniversalForcing/CanonicalForcing.leanTHEOREM universal_objective · IndisputableMonolith/Foundation/UniversalForcing/CanonicalForcing.lean
/-- **The Universal-Forcing objective at full generality.** For *any* two Law-of-Logic realizations `R`, `S` (in arbitrary universes) and any forced arithmetics `A` over `R`, `B` over `S` sharing a carrier universe, there is a structure-preserving equivalence between the carriers that is *the unique* zero/step-preserving map. This is the precise content of `universal-forcing-program.mdc`'s "canonical equivalence of `ArithmeticOf R` and `ArithmeticOf S` across admissible realizations": not bare existence of some iso, but a canonical, determined morphism. Unlike the strict-realization certificate below (where the carrier is concretely `LogicNat` and the map is the identity), here `A.peano.carrier` and `B.peano.carrier` may be genuinely different Peano objects, so the equivalence is a nontrivial iso — yet still the only structure morphism between them. -/ theorem universal_objective (A : ArithmeticOf.{u, v, w, w, w} R) (B : ArithmeticOf.{u', v', w, w, w} S) : ∃ e : A.peano.carrier ≃ B.peano.carrier, e A.peano.zero = B.peano.zero ∧ (∀ x, e (A.peano.step x) = B.peano.step (e x)) ∧ (∀ f : A.peano.carrier → B.peano.carrier, f A.peano.zero = B.peano.zero → (∀ x, f (A.peano.step x) = B.peano.step (f x)) → f = e.toFun) := ⟨equivOfInitial A B, equivOfInitial_map_zero A B, equivOfInitial_map_step A B, fun f hz hs => forcing_map_unique A B f hz hs⟩This canonicity result holds for any two realizations of the framework's logic, not just a single preferred example. universal_objective · IndisputableMonolith/Foundation/UniversalForcing/CanonicalForcing.lean