Foundation Universal Forcing Forced Integers Forced Difference Fixed Iff

The fixed difference

In ordinary arithmetic, the only number equal to its own negative is zero. The Recognition Science framework, which derives structure from the idea that reality keeps a ledger, a discrete record of recognition events, meets the same fact in its own terms. The declaration forced_difference_fixed_iff proves the additive analogue: a difference of two forced numbers equals its own negative precisely when the two numbers are identical. If the counts differ, the difference cannot be its own negation; if they agree, the difference is zero and the equality holds trivially.

The framework models forced numbers as iteration counts, so each forced number is a natural number. The declaration embeds these counts into the integers by their iteration count, preserving zero, one, addition, and multiplication. A difference of two such counts is therefore an integer, and the theorem shows that the negation involution fixes such a difference exactly on the diagonal, the set of pairs where the two counts agree. This mirrors the framework's ratio layer, where the reciprocal involution fixes a ratio exactly on the unit, the set where the two counts agree. The two layers, integers and ratios, carry the same comparison geometry: an involution that swaps two counts, fixed precisely where the counts agree.

The theorem is part of a larger certificate in the framework's machine-checked library of formal theorems. That certificate shows that the forced arithmetic embeds in the integers, that every integer is a difference of two forced numbers, and that the negation involution fixes a difference precisely on the diagonal. The certificate establishes that distinction forces the full additive group of integers, not a proper sub-collection. This is the additive mirror of the ratio layer's comparison geometry, and it is proved in the framework's library without additional axioms beyond the standard three.

What the theorem does not claim is equally important. It does not claim that the framework derives the integers from nothing; it assumes the ambient type theory supplies the natural numbers. It does not claim that every integer is itself a forced number; rather, every integer is a difference of two forced numbers. It does not claim that the framework's comparison geometry extends beyond the additive and multiplicative layers it names. The theorem is a precise statement about the framework's own constructions, not a claim about conventional arithmetic.

/-- **The additive analogue of the reciprocal fixed-point law.** The negation
involution fixes a forced difference exactly on the diagonal `a = b` — just as the
reciprocal involution fixes a forced ratio exactly on the unit `a = b`. The two
forced layers, integers and ratios, carry the same comparison geometry: an
involution that swaps two counts, fixed precisely where the counts agree. -/
theorem forced_difference_fixed_iff (a b : LogicNat) :
    (toInt a - toInt b = -(toInt a - toInt b)) ↔ a = b := by
  rw [forced_difference_neg_swap]
  constructor
  · intro h
    have hz : toInt a - toInt b = 0 := by omega
    exact (forced_difference_zero_iff a b).mp hz
  · intro h; subst h; ring

/-- Embed a forced number into the integers by its iteration count. -/
def toInt (n : LogicNat) : ℤ := (LogicNat.toNat n : ℤ)

/-- **Certificate.** The forced arithmetic embeds in `ℤ` preserving `0, 1, +, ×`;
its differences are exactly `ℤ`; and the negation involution fixes a difference
precisely on the diagonal. The integer layer the δ paper names is forced,
canonical, and carries the additive mirror of the ratio layer's comparison
geometry. -/
structure ForcedIntegersCert where
  embed : LogicNat → ℤ
  embed_zero : embed LogicNat.zero = 0
  embed_one : embed 1 = 1
  embed_add : ∀ a b, embed (a + b) = embed a + embed b
  embed_mul : ∀ a b, embed (a * b) = embed a * embed b
  embed_injective : Function.Injective embed
  differences_surject : ∀ z : ℤ, ∃ a b : LogicNat, z = embed a - embed b
  negation_diagonal : ∀ a b : LogicNat,
      (toInt a - toInt b = -(toInt a - toInt b)) ↔ a = b

/-- The forced-integers certificate holds. -/
def forcedIntegersCert_holds : ForcedIntegersCert where
  embed := toInt
  embed_zero := toInt_zero
  embed_one := toInt_one
  embed_add := toInt_add
  embed_mul := toInt_mul
  embed_injective := toInt_injective
  differences_surject := integers_surject
  negation_diagonal := forced_difference_fixed_iff

What this page does not claim

The framework derives the natural numbers from nothing; it assumes the ambient type theory supplies them. Every integer is itself a forced number; only every integer is a difference of two forced numbers. The theorem applies to conventional arithmetic outside the framework's own constructions.

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