Foundation Arithmetic From Logic Embed Strict Mono Of One Lt

The embedding theorem

The natural numbers are the counting numbers: 0, 1, 2, 3, and so on. A standard way to build them is to start with 0 and then repeatedly add 1. The Recognition Science framework constructs its own version of the natural numbers, called the logic natural numbers, from two basic ingredients: an identity element and a single step operation. The identity element represents 0, and the step operation represents adding 1. This structure mirrors the orbit of a positive number γ under repeated multiplication, {1, γ, γ², γ³, ...}, as the smallest set closed under multiplication by γ and containing 1.

The theorem embed_strictMono_of_one_lt establishes that this embedding is strictly monotone: if one logic natural number is less than another, then their images under the embedding into the real numbers are also in the same order. In plainer terms, the step operation preserves the order of the counting numbers. The embedding sends the identity element to 1, and each step multiplies by the generator γ. Because γ is greater than 1, taking a step always moves to a larger real number. The theorem guarantees that the logic natural numbers, when mapped into the reals, keep their order intact and never collapse two different numbers into the same value.

This result is part of a larger project in Recognition Science: deriving arithmetic from the structure of a comparison operator. The framework starts with a cost function that measures the cost of recognition, and from that cost function it derives a generator γ, a positive number not equal to 1. The logic natural numbers are then built from this generator. The theorem that the embedding is strictly monotone is a technical step in showing that the logic natural numbers behave like the usual natural numbers. It ensures that the order relation on the logic natural numbers matches the order of their real-number counterparts.

The theorem does not claim that the logic natural numbers are the same as the usual natural numbers, nor does it claim that the embedding is onto the positive reals. It only establishes order preservation. It also does not claim that the generator γ is the golden ratio, nor that the natural numbers themselves are derived from the cost function. The construction of the logic natural numbers is a definitional choice, while the monotonicity theorem is a proved result about that choice.

What this means for the framework is that the step operation, the most basic building block of arithmetic, is order-preserving. This is a necessary condition for the logic natural numbers to serve as a foundation for counting and ordering. The theorem gives confidence that the constructed numbers behave in the expected way, at least in terms of order.

/-- **Embedding injectivity**: distinct natural numbers map to distinct
points in the orbit. This closes the bridge from the abstract `LogicNat`
to the concrete orbit `{1, γ, γ², ...}` in ℝ₊. -/
theorem embed_injective (γ : Generator) : Function.Injective (embed γ) := by
  intro a b hab
  -- Translate to powers.
  rw [embed_eq_pow, embed_eq_pow] at hab
  -- Take logs.
  have hpos_a : 0 < γ.value ^ (LogicNat.toNat a) := pow_pos γ.pos _
  have hpos_b : 0 < γ.value ^ (LogicNat.toNat b) := pow_pos γ.pos _
  have hlog : Real.log (γ.value ^ (LogicNat.toNat a))
              = Real.log (γ.value ^ (LogicNat.toNat b)) := by
    exact congrArg Real.log hab
  rw [Real.log_pow, Real.log_pow] at hlog
  -- Cancel the non-zero log γ.value.
  have hne := log_generator_ne_zero γ
  have hcast : ((LogicNat.toNat a : ℝ)) = ((LogicNat.toNat b : ℝ)) := by
    have := mul_right_cancel₀ hne hlog
    exact this
  have h_nat : LogicNat.toNat a = LogicNat.toNat b := by exact_mod_cast hcast
  -- Lift back to LogicNat via the equivalence.
  have := congrArg LogicNat.fromNat h_nat
  rw [LogicNat.fromNat_toNat, LogicNat.fromNat_toNat] at this
  exact this

/-- The orbit embedding: `LogicNat` into the positive reals. -/
def embed (γ : Generator) : LogicNat → ℝ
  | .identity => 1
  | .step n   => γ.value * embed γ n

/-- The natural numbers as forced by the Law of Logic.

`identity` represents the zero-cost element (the multiplicative
identity in the orbit). `step` represents one more iteration of the
generator. The two-constructor structure mirrors the orbit
{1, γ, γ², γ³, ...} as the smallest subset of ℝ₊ closed under
multiplication by γ and containing 1. -/
inductive LogicNat : Type
  | identity : LogicNat
  | step     : LogicNat → LogicNat
  deriving DecidableEq, Repr

What this page does not claim

The logic natural numbers are identical to the usual natural numbers. The embedding maps onto all positive real numbers. The generator γ is the golden ratio. The natural numbers themselves are derived from the cost function J.

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: