Encyclopedia Foundation Foundation Universal Forcing Modular Realization Modular Arithmetic Invariant
ARTICLE 3 claims 2 theorems 1 model
Foundation Universal Forcing Modular Realization Modular Arithmetic Invariant
A machine-checked library shows that counting on a clock face carries the same arithmetic as any other recognition ledger, a uniqueness result with a precise boundary.
The modular realization
Modular arithmetic is the mathematics of clocks and calendars: after reaching a fixed size, the count wraps around. On a clock with twelve hours, eleven plus two is one, because twelve becomes zero. The Recognition Science framework builds a discrete record of events, called a ledger, and asks what arithmetic such a record forces. The declaration modular_arithmetic_invariant states that a ledger whose events wrap around modulo any number greater than one carries the same arithmetic as any other ledger in the framework.
The result is a theorem in the framework's machine-checked library of formal theorems. The proof constructs a specific ledger on the cyclic carrier ZMod n, where equality costs zero and inequality costs one. It then shows this modular ledger is initial: every other ledger in the framework has a unique structure-preserving map to it. Because the modular ledger is initial, the arithmetic it defines is universal, meaning any ledger's arithmetic agrees with it. The declaration modular_arithmetic_invariant packages this uniqueness as an equivalence between the arithmetic of the modular ledger and the arithmetic of any other ledger.
The classical counterpart is the fact that the natural numbers are initial among Peano systems. Any structure satisfying the Peano axioms is isomorphic to the natural numbers. The framework's theorem generalizes this: within its own definition of a ledger, the modular realization is initial, so its arithmetic is forced. The declaration does not claim that modular arithmetic is the only arithmetic, nor that the framework's ledger definition matches every mathematical structure. It claims only that within the framework, any ledger's arithmetic is equivalent to the modular one.
The theorem's scope is narrow but precise. It requires the modulus n to be greater than one, so the trivial one-element carrier is excluded. It does not say anything about what happens when equality cost is not binary, nor does it address ledgers with additional structure beyond the framework's definition. The declaration is a definition in the library, and the equivalence it states is a theorem about that definition.
THEOREM modular_arithmetic_invariant · IndisputableMonolith/Foundation/UniversalForcing/ModularRealization.lean
/-- Modular realization carries the universal forced arithmetic. -/
noncomputable def modular_arithmetic_invariant (n : ℕ) [Fact (1 < n)]
(R : LogicRealization.{0, 0}) :
(arithmeticOf (modularRealization n)).peano.carrier
≃ (arithmeticOf R).peano.carrier :=
ArithmeticOf.equivOfInitial (arithmeticOf (modularRealization n)) (arithmeticOf R)
MODEL zmodCost · IndisputableMonolith/Foundation/UniversalForcing/ModularRealization.lean
/-- Equality cost on a cyclic carrier. -/
def zmodCost {n : ℕ} (a b : ZMod n) : Nat :=
if a = b then 0 else 1
THEOREM modular_arithmetic_invariant · IndisputableMonolith/Foundation/UniversalForcing/ModularRealization.lean
/-- Modular realization carries the universal forced arithmetic. -/
noncomputable def modular_arithmetic_invariant (n : ℕ) [Fact (1 < n)]
(R : LogicRealization.{0, 0}) :
(arithmeticOf (modularRealization n)).peano.carrier
≃ (arithmeticOf R).peano.carrier :=
ArithmeticOf.equivOfInitial (arithmeticOf (modularRealization n)) (arithmeticOf R)
What this page does not claim
The declaration does not claim that modular arithmetic is the only arithmetic possible. The result does not cover the trivial one-element carrier where n equals one. The theorem does not address ledgers with additional structure beyond the framework's definition.
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/ModularRealization.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:
- What exactly does the framework's definition of a ledger include?
- How does the modular realization relate to the eight-tick recognition cycle?
- Does the initiality property extend to ledgers with non-binary cost functions?
MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND
THEOREM modular_arithmetic_invariant · IndisputableMonolith/Foundation/UniversalForcing/ModularRealization.lean
/-- Modular realization carries the universal forced arithmetic. -/ noncomputable def modular_arithmetic_invariant (n : ℕ) [Fact (1 < n)] (R : LogicRealization.{0, 0}) : (arithmeticOf (modularRealization n)).peano.carrier ≃ (arithmeticOf R).peano.carrier := ArithmeticOf.equivOfInitial (arithmeticOf (modularRealization n)) (arithmeticOf R)The declaration modular_arithmetic_invariant states that a ledger whose events wrap around modulo any number greater than one carries the same arithmetic as any other ledger in the framework. modular_arithmetic_invariant · IndisputableMonolith/Foundation/UniversalForcing/ModularRealization.leanMODEL zmodCost · IndisputableMonolith/Foundation/UniversalForcing/ModularRealization.lean
/-- Equality cost on a cyclic carrier. -/ def zmodCost {n : ℕ} (a b : ZMod n) : Nat := if a = b then 0 else 1The proof constructs a specific ledger on the cyclic carrier ZMod n, where equality costs zero and inequality costs one. zmodCost · IndisputableMonolith/Foundation/UniversalForcing/ModularRealization.leanTHEOREM modular_arithmetic_invariant · IndisputableMonolith/Foundation/UniversalForcing/ModularRealization.lean
/-- Modular realization carries the universal forced arithmetic. -/ noncomputable def modular_arithmetic_invariant (n : ℕ) [Fact (1 < n)] (R : LogicRealization.{0, 0}) : (arithmeticOf (modularRealization n)).peano.carrier ≃ (arithmeticOf R).peano.carrier := ArithmeticOf.equivOfInitial (arithmeticOf (modularRealization n)) (arithmeticOf R)Because the modular ledger is initial, the arithmetic it defines is universal, meaning any ledger's arithmetic agrees with it. modular_arithmetic_invariant · IndisputableMonolith/Foundation/UniversalForcing/ModularRealization.lean