Foundation Modular Logic Realization

A finite clock for logic

Modular arithmetic is the mathematics of clocks and calendars: you count up to a fixed number, then wrap around to zero. The number 7 o'clock plus 8 hours is 3 o'clock, not 15 o'clock, because the clock has modulus 12. In Recognition Science, the ledger, a discrete record of events that the framework uses to track recognition costs, can be built on this same wrapping idea. The module called Modular Logic Realization constructs a specific, finite version of that ledger and proves it behaves exactly like the infinite one for all practical purposes.

The construction starts with a simple cost function on a finite set of values. If two values are equal, the cost is 0; otherwise, it is 1. This is the discrete version of a distance: identical things cost nothing to recognize, different things cost one unit. The module then defines a successor operation, the act of moving to the next value, which wraps around at the end of the finite set. The core object is a realization: a concrete model of the framework's logic where the internal counting numbers are interpreted as positions on this finite cycle.

The key theorem is that this finite, periodic interpretation is indistinguishable from the standard infinite one. The module proves that the arithmetic extracted from the finite realization is equivalent to the arithmetic of any other realization. In plain terms, the framework's universal forcing, the principle that recognition costs are forced by the logic itself, does not require a full, faithful copy of the natural numbers inside every model. A simple repeating pattern is enough to carry the same logical content.

This matters because it shows the framework's foundations are more flexible than they might appear. The infinite counting numbers are not a hidden assumption smuggled into the system; they are one possible realization among many. The finite clock is a second, simpler one. This result, verified in the framework's machine-checked library of formal theorems, strengthens the claim that the framework's core logic is genuinely universal, not accidentally tied to one particular infinite structure.

/-- Finite cyclic Law-of-Logic realization with periodic interpretation. -/
def modularRealization (k : ℕ) : LogicRealization where
  Carrier := Fin (modulus k)
  Cost := Nat
  zeroCost := inferInstance
  compare := finCost
  zero := ⟨0, modulus_pos k⟩
  step := cycStep k
  Orbit := ArithmeticFromLogic.LogicNat
  orbitZero := ArithmeticFromLogic.LogicNat.zero
  orbitStep := ArithmeticFromLogic.LogicNat.succ
  interpret := modularInterpret k
  interpret_zero := modularInterpret_zero k
  interpret_step := modularInterpret_step k
  orbit_no_confusion := by
    intro n h
    exact ArithmeticFromLogic.LogicNat.zero_ne_succ n h
  orbit_step_injective := ArithmeticFromLogic.LogicNat.succ_injective
  orbit_induction := by
    intro P h0 hs n
    exact ArithmeticFromLogic.LogicNat.induction (motive := P) h0 hs n
  orbitEquivLogicNat := Equiv.refl ArithmeticFromLogic.LogicNat
  orbitEquiv_zero := rfl
  orbitEquiv_step := by intro n; rfl
  identity := finCost_self
  nonContradiction := finCost_symm
  excludedMiddle := True
  composition := True
  actionInvariant := True
  nontrivial := by
    refine ⟨⟨1, one_lt_modulus k⟩, ?_⟩
    simp [finCost]

/-- The modular interpretation is periodic on the carrier. -/
theorem modular_interpret_periodic (k : ℕ) (n : ArithmeticFromLogic.LogicNat) :
    modularInterpret k
        (ArithmeticFromLogic.LogicNat.fromNat
          (ArithmeticFromLogic.LogicNat.toNat n + modulus k))
      = modularInterpret k n := by
  apply Fin.ext
  simp [modularInterpret, ArithmeticFromLogic.LogicNat.toNat_fromNat]

/-- Modular realization has invariant extracted arithmetic. -/
noncomputable def modular_arithmetic_invariant (k : ℕ) (R : LogicRealization.{0, 0}) :
    (UniversalForcing.arithmeticOf (modularRealization k)).peano.carrier
      ≃ (UniversalForcing.arithmeticOf R).peano.carrier :=
  ArithmeticOf.equivOfInitial
    (UniversalForcing.arithmeticOf (modularRealization k))
    (UniversalForcing.arithmeticOf R)

What this page does not claim

This module does not prove that the finite realization is the only possible one. It does not claim that the framework's logic is identical to modular arithmetic, only that it can be faithfully modeled by it. The equivalence of arithmetic is proven, but the physical interpretation of this finite carrier is not addressed here.

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