Foundation Primitive Recognition Calculus Grow Signed Orbit Le Mul Right Iff Of Nonneg Flag Of Not Balanced Zero Choice Free

The right-multiplication lemma

A signed orbit is a finite sequence of +1 and -1 steps, like a walk that only moves left or right by one unit. The framework's recognition calculus, its discrete record of events, uses these orbits to encode growth patterns. A ledger, the discrete record of recognition events, tracks how such orbits combine. The classical question is simple: when does multiplying one orbit by another preserve the order of two orbits? The module answers it for a specific, clean case.

The main theorem, le_mul_right_iff_of_nonnegFlag_of_not_balanced_zero_cf, states: if an orbit a has a nonnegative flag (its steps never go negative) and is not balanced around zero (it does not return to the origin), then for any orbits z and w, the inequality z·a ≤ w·a holds if and only if z ≤ w. In plainer terms, multiplying by such an orbit is order-preserving: it does not flip or collapse the comparison between two other orbits. The proof rests on a helper lemma, cross_le_iff, which handles the arithmetic of weighted sums.

The condition matters. If the multiplier were balanced, meaning it returns to zero, the order could fail. The nonnegative flag rules out negative steps, and the not-balanced condition rules out the degenerate case where the orbit cancels itself out. Together they guarantee that the multiplication behaves like a positive scaling, not a reflection or a projection. The theorem is choice-free, meaning the proof does not rely on the axiom of choice; it is a constructive, direct derivation.

What this establishes in the framework is a structural fact about the recognition calculus: certain orbits act as order-preserving operators. This is a building block for larger results about growth and comparison in the ledger. The practical consequence is that when you have a nonnegative, unbalanced orbit, you can safely multiply both sides of an inequality without changing its truth, a tool that simplifies later proofs in the calculus.

theorem le_mul_right_iff_of_nonnegFlag_of_not_balanced_zero_cf :
    ∀ (a z w : SignedOrbit), a.nonnegFlag = true →
    ¬ a.balanced SignedOrbit.zero →
    ((z.mul a).le (w.mul a) ↔ z.le w) := by
  intro a z w hanonneg ha
  have han : a.neg.toNat ≤ a.pos.toNat := by
    have h := hanonneg
    unfold SignedOrbit.nonnegFlag at h
    rwa [leq_eq_true_iff_cf] at h
  have hlt : a.neg.toNat < a.pos.toNat := by
    rcases Nat.lt_or_ge a.neg.toNat a.pos.toNat with h | h
    · exact h
    · exfalso; apply ha
      rw [SignedOrbit.balanced_iff_toNat_eq]
      rw [show SignedOrbit.zero.neg.toNat = 0 from rfl,
          show SignedOrbit.zero.pos.toNat = 0 from rfl]
      omega
  rw [le_iff_toNat_cf, le_iff_toNat_cf]
  have eqL : (w.mul a).neg.toNat + (z.mul a).pos.toNat =
      a.neg.toNat * (w.pos.toNat + z.neg.toNat) + a.pos.toNat * (w.neg.toNat + z.pos.toNat) := by
    simp only [SignedOrbit.mul_pos, SignedOrbit.mul_neg,
              DistinctionNat.toNat_add, DistinctionNat.toNat_mul]
    ring
  have eqR : (w.mul a).pos.toNat + (z.mul a).neg.toNat =
      a.pos.toNat * (w.pos.toNat + z.neg.toNat) + a.neg.toNat * (w.neg.toNat + z.pos.toNat) := by
    simp only [SignedOrbit.mul_pos, SignedOrbit.mul_neg,
              DistinctionNat.toNat_add, DistinctionNat.toNat_mul]
    ring
  rw [eqL, eqR]
  exact cross_le_iff (w.neg.toNat + z.pos.toNat) (w.pos.toNat + z.neg.toNat)
      a.pos.toNat a.neg.toNat hlt

theorem cross_le_iff (A B p n : Nat) (hnp : n < p) :
    (n * B + p * A ≤ p * B + n * A ↔ A ≤ B) := by
  obtain ⟨c, hc⟩ := Nat.exists_eq_add_of_lt hnp
  subst hc
  have e1 : (n + c + 1) * A = n * A + (c + 1) * A := by ring
  have e2 : (n + c + 1) * B = n * B + (c + 1) * B := by ring
  rw [e1, e2]
  constructor
  · intro h
    have h2 : (c + 1) * A ≤ (c + 1) * B := by omega
    exact Nat.le_of_mul_le_mul_left h2 (Nat.succ_pos c)
  · intro h
    have h2 : (c + 1) * A ≤ (c + 1) * B := Nat.mul_le_mul (Nat.le_refl _) h
    omega

What this page does not claim

This module does not prove that all orbits preserve order, only those with a nonnegative flag and not balanced around zero. The lemma does not establish any property of the golden ratio or the forcing chain; it is a standalone structural result. The nonnegative flag condition is not shown to be necessary for order preservation, only sufficient in this theorem.

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/Grow/SignedOrbitLeMulRightIffOfNonnegFlagOfNotBalancedZeroChoiceFree.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: