Foundation Primitive Recognition Calculus Real Boundedness Modulus

The boundedness modulus

The real boundedness modulus is a specific small number, one eighth, chosen inside the Recognition Science framework as a threshold. The framework works with a ledger, a discrete record of recognition events, where each entry is a rational number and the cost of moving between two entries measures how far apart they are. The modulus says: if the cost between two ledger entries is less than one eighth, then the ordinary difference between those entries, squared, is less than one. That is a boundedness guarantee, a way to know that small cost really does mean small distance.

The number one eighth is not arbitrary. The framework's library, a machine-checked collection of formal theorems, proves that this threshold is positive and that it has exactly the needed property. The proof runs through the cost function's definition: the cost between entries is built from a rational display increment, and the theorem shows that when that increment stays below one eighth, the square of the underlying rational difference stays below one. This is the kind of local control a construction of real numbers needs, because it prevents wild jumps between entries that are supposed to be close.

In Recognition Science, this modulus is one piece of a larger construction. The framework models real numbers as equivalence classes of Cauchy sequences of ledger entries, sequences where costs between later terms shrink toward zero. The boundedness modulus supplies the first step: it proves that any such Cauchy ledger is eventually contained in a symmetric rational interval, meaning the entries do not run off to infinity. That eventual boundedness is a proved theorem, and it is recorded as a certificate, a structured collection of the facts the construction relies on.

The certificate also names what remains open. Multiplication of these real numbers needs a separate continuity condition, a bound on how costs behave under products, and that condition is a target, not yet proved. The boundedness modulus closes the addition and distance side of the construction; the multiplication side waits on that further step. What the modulus changes is concrete: it turns a vague hope that small cost means small distance into a checked, quantitative guarantee, and it clears one named obstacle on the path from discrete ledger to continuous real line.

theorem PRCBoundednessDelta_toRat :
    PRCBoundednessDelta.toRat = (1 / 8 : ℚ) := by
  unfold PRCBoundednessDelta
  simp [PRCRat.toRat_mul, PRCRat.toRat_recip]
  norm_num

/-- Small PRC J-cost distance at the fixed threshold forces the ordinary
rational display increment to have square below one. -/
theorem PRCJCostDistance_sq_diff_lt_one_of_lt_boundedness_delta
    {a b : PRCRat}
    (hsmall : PRCRat.lt (PRCJCostDistance a b) PRCBoundednessDelta) :
    (a.toRat - b.toRat) * (a.toRat - b.toRat) < 1 := by
  rw [PRCRat.lt_iff_toRat_lt] at hsmall
  rw [PRCJCostDistance_toRat, PRCJCostDistanceRatDisplay_as_increment,
    PRCBoundednessDelta_toRat] at hsmall
  exact PRCJCostDistanceIncrementDisplay_sq_lt_one hsmall

/-- A J-cost Cauchy ledger is eventually contained in a PRC symmetric rational
interval. -/
theorem PRCCauchySeqEventuallyBoundedTarget_proved :
    PRCCauchySeqEventuallyBoundedTarget := by
  intro u
  rcases u.cauchy PRCBoundednessDelta PRCBoundednessDelta_positive with
    ⟨N, hN⟩
  let anchor : PRCRat := u.term N
  let two : PRCRat := (1 : PRCRat) + (1 : PRCRat)
  let B : PRCRat := anchor * anchor + two
  have hB_pos : PRCRat.positive B := by
    rw [PRCRat.positive_iff_toRat_pos]
    have hsq : (0 : ℚ) ≤ anchor.toRat * anchor.toRat :=
      mul_self_nonneg anchor.toRat
    simp [B, two]
    nlinarith
  refine ⟨B, hB_pos, N, ?_⟩
  intro n hn
  have hdist : PRCRat.lt (PRCJCostDistance (u.term n) anchor) PRCBoundednessDelta := by
    simpa [anchor] using hN n N hn (Nat.le_refl N)
  have hsquare :
      ((u.term n).toRat - anchor.toRat) *
          ((u.term n).toRat - anchor.toRat) < 1 :=
    PRCJCostDistance_sq_diff_lt_one_of_lt_boundedness_delta hdist
  let x : ℚ := (u.term n).toRat
  let q : ℚ := anchor.toRat
  have hsquare_xq : (x - q) * (x - q) < 1 := by
    simpa [x, q] using hsquare
  have hdiff_lt_one : x - q < 1 := by
    nlinarith [mul_self_nonneg ((x - q) - 1)]
  have hdiff_gt_neg_one : -1 < x - q := by
    nlinarith [mul_self_nonneg ((x - q) + 1)]
  constructor
  · rw [PRCRat.lt_iff_toRat_lt]
    simp [B, two, anchor]
    nlinarith [mul_self_nonneg (2 * q + 1)]
  · rw [PRCRat.lt_iff_toRat_lt]
    simp [B, two, anchor]
    nlinarith [mul_self_nonneg (2 * q - 1)]

What this page does not claim

The modulus does not prove multiplication of the constructed real numbers is closed or well-defined. The modulus does not establish that the cost function itself is bounded, only that small cost forces small rational difference. The certificate does not show the real number construction is complete; it names one remaining target.

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/PrimitiveRecognitionCalculus/RealBoundednessModulus.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: