Foundation Arithmetic From Logic Pow Le Pow Iff Of One Lt

A monotone comparison rule

The declaration pow_le_pow_iff_of_one_lt is a theorem about ordered powers. In ordinary mathematics, it states that for a base b greater than 1, the inequality b^m ≤ b^n holds exactly when m ≤ n. The direction from right to left is familiar: raising a number above 1 to a larger exponent gives a larger result. The converse, that a larger power forces a larger exponent, is the monotonicity property that makes the comparison reversible.

Within Recognition Science, the theorem lives in the ledger, a discrete record of events that the framework uses as its starting point. The framework builds natural numbers from a generator, a positive real number not equal to 1, by repeated multiplication. The theorem applies to that construction: for any generator γ with γ > 1, the statement γ^m ≤ γ^n is equivalent to m ≤ n for the framework's natural numbers. The proof is machine-checked in the framework's library of formal theorems, meaning no step is left to informal reasoning.

The theorem does not claim that the framework's natural numbers are the only possible numbers, nor that the generator γ must be the golden ratio. It applies to any generator satisfying the positivity condition. It also does not assert that the framework's ordering is the usual ordering on real numbers; the comparison is internal to the framework's own structure. The theorem is a structural fact about how the framework's arithmetic behaves, not a claim about the physical world.

What the theorem establishes is a bridge between the framework's abstract construction and ordinary arithmetic intuition. It shows that the framework's natural numbers, built from a generator and a step operation, respect the same monotonicity rule that governs familiar powers. That consistency is what makes the framework's arithmetic usable: when the framework says one expression is smaller than another, the statement behaves as expected.

theorem toNat_le (a b : LogicNat) : a ≤ b ↔ toNat a ≤ toNat b := by
  constructor
  · rintro ⟨k, hk⟩
    have := congrArg toNat hk
    rw [toNat_add] at this
    omega
  · intro h
    refine ⟨fromNat (toNat b - toNat a), ?_⟩
    have hroundtrip : ∀ n : LogicNat, fromNat (toNat n) = n := fromNat_toNat
    -- toNat (a + fromNat (toNat b - toNat a)) = toNat a + (toNat b - toNat a) = toNat b
    have hadd : toNat (a + fromNat (toNat b - toNat a)) = toNat b := by
      rw [toNat_add, toNat_fromNat]
      omega
    -- Apply equivNat injectivity
    have : a + fromNat (toNat b - toNat a) = b := by
      have h1 := congrArg fromNat hadd
      rw [hroundtrip, hroundtrip] at h1
      exact h1
    exact this

/-- A non-trivial generator: any positive real other than the
identity. The Law of Logic guarantees existence via the
`non_trivial` field of `SatisfiesLawsOfLogic`. -/
structure Generator where
  value      : ℝ
  pos        : 0 < value
  nontrivial : value ≠ 1

theorem toNat_le (a b : LogicNat) : a ≤ b ↔ toNat a ≤ toNat b := by
  constructor
  · rintro ⟨k, hk⟩
    have := congrArg toNat hk
    rw [toNat_add] at this
    omega
  · intro h
    refine ⟨fromNat (toNat b - toNat a), ?_⟩
    have hroundtrip : ∀ n : LogicNat, fromNat (toNat n) = n := fromNat_toNat
    -- toNat (a + fromNat (toNat b - toNat a)) = toNat a + (toNat b - toNat a) = toNat b
    have hadd : toNat (a + fromNat (toNat b - toNat a)) = toNat b := by
      rw [toNat_add, toNat_fromNat]
      omega
    -- Apply equivNat injectivity
    have : a + fromNat (toNat b - toNat a) = b := by
      have h1 := congrArg fromNat hadd
      rw [hroundtrip, hroundtrip] at h1
      exact h1
    exact this

What this page does not claim

The theorem does not claim that the framework's natural numbers are the only possible numbers. It does not assert that the generator must be the golden ratio. It does not claim the framework's ordering is the usual ordering on real numbers.

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