Foundation Primitive Recognition Calculus Orbit Arithmetic Mul Succ Eq

Multiplication by one more step

In ordinary arithmetic, multiplying a number by the next whole number is the same as adding the original number one more time. For example, 3 times 4 is 12, and 3 times 3 plus 3 is also 12. The rule a * (b+1) = a * b + a is so familiar that it is easy to miss what it is: a complete description of how multiplication steps forward one unit at a time.

The Recognition Science framework builds its own version of the counting numbers, called orbit positions, a discrete record of distinct states along a recognition cycle. In this setting, the declaration mul_succ_eq states the same stepping rule: multiplying an orbit position a by the successor of b (the next position after b) equals multiplying a by b and then adding a. The framework proves this as a theorem, not merely a convention, because it follows from its own definition of multiplication as nested repetition: multiplying by a successor repeats the earlier product one more time.

This single rule anchors the whole arithmetic of orbit positions. From it, the framework derives that multiplication is commutative (a * b = b * a), that multiplying by zero gives zero, and that the product of two nonzero positions is never zero. The rule also guarantees that the framework's arithmetic agrees with ordinary counting: translating an orbit product to the usual natural numbers yields exactly the familiar product. The step rule is the load-bearing wall; the other properties are the rooms built against it.

What the rule does not do is say anything about what the successor of a number is, or what addition itself means. Those are defined separately, before multiplication is even introduced. The theorem also does not claim that orbit positions are the same objects as ordinary natural numbers; it only shows that the two systems behave identically under multiplication. It is a bridge between a framework-internal structure and the arithmetic everyone already knows, not a claim that the framework has invented a new kind of number.

theorem mul_succ_eq (a b : DistinctionNat) :
    a * succ b = a * b + a := rfl

theorem mul_comm (a b : DistinctionNat) :
    a * b = b * a := by
  induction a with
  | zero =>
      rw [zero_mul_eq, mul_zero_eq]
  | succ n ih =>
      rw [succ_mul_eq, mul_succ_eq, ih]

/-- K4.7. The verifier display of orbit multiplication matches Lean Nat. -/
theorem toNat_mul (a b : DistinctionNat) :
    (a * b).toNat = a.toNat * b.toNat := by
  induction b with
  | zero =>
      show (a * zero).toNat = a.toNat * zero.toNat
      rw [mul_zero_eq, toNat_zero]
      omega
  | succ n ih =>
      show (a * n + a).toNat = a.toNat * (succ n).toNat
      rw [toNat_add, toNat_succ, ih, Nat.mul_succ]

What this page does not claim

The theorem does not define what the successor of a number is. The theorem does not claim orbit positions are the same objects as ordinary natural numbers. The theorem does not establish any property of addition, which is defined separately.

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