Encyclopedia Foundation Foundation Primitive Recognition Calculus Grow Signed Orbit Nonneg Flag Mul Of O

ARTICLE 2 claims 2 theorems

Foundation Primitive Recognition Calculus Grow Signed Orbit Nonneg Flag Mul Of O

A machine-checked theorem shows that multiplying a signed orbit by any nonzero distinction leaves its sign unchanged, a structural fact with a narrow scope.

Verify this page

A stability property of orbits

A signed orbit is an object in the framework's primitive recognition calculus that carries a sign, like a direction or a charge. The theorem in question states that when such an orbit is multiplied on the right by any nonzero distinction, its nonnegFlag, the marker that says whether the orbit is nonnegative, stays exactly the same. In plainer terms: multiplying by a nonzero element does not flip the sign or destroy the orbit's basic character.

The declaration is a theorem in the framework's machine-checked library of formal theorems, meaning its proof has been verified by a computer. It is a structural fact about how multiplication interacts with the sign flag in this calculus. The theorem is conditional: it requires the distinction d to be nonzero, and it applies specifically to right multiplication by an orbit built from a distinction via the ofOrbit construction.

What this theorem does not claim is broader significance. It does not say that all multiplications preserve signs, nor that the sign flag is invariant under every operation. It does not assert anything about left multiplication, about zero distinctions, or about the physical interpretation of orbits. It is a narrow algebraic lemma, not a statement about the universe or about recognition costs.

The value of the theorem is architectural. It establishes a clean, checkable property that later constructions can rely on: a nonzero right factor cannot alter the nonnegativity flag. This is the kind of small, precise fact that lets a larger formal system be built without hidden assumptions. It is a building block, not a headline result.

THEOREM nonnegFlag_mul_ofOrbit_right_of_ne_zero_cf · IndisputableMonolith/Foundation/PrimitiveRecognitionCalculus/Grow/SignedOrbitNonnegFlagMulOfOrbitRightOfNeZeroChoiceFree.lean
nonnegFlag_mul_ofOrbit_right_of_ne_zero_cf · IndisputableMonolith/Foundation/PrimitiveRecognitionCalculus/Grow/SignedOrbitNonnegFlagMulOfOrbitRightOfNeZeroChoiceFree.lean:12 
theorem nonnegFlag_mul_ofOrbit_right_of_ne_zero_cf
    (z : SignedOrbit) (d : DistinctionNat) (hd : d ≠ DistinctionNat.zero) :
    (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).nonnegFlag = z.nonnegFlag := by
  have hd' : d.toNat ≠ 0 := by
    intro h
    apply hd
    rw [← DistinctionNat.ofNat_toNat d, h, DistinctionNat.ofNat_zero]
  have hdpos : 0 < d.toNat := by omega
  have hpos : (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).pos.toNat = z.pos.toNat * d.toNat := by
    show (z.pos * (SignedOrbit.ofOrbit d).pos + z.neg * (SignedOrbit.ofOrbit d).neg).toNat = _
    have hp : (SignedOrbit.ofOrbit d).pos = d := rfl
    have hn : (SignedOrbit.ofOrbit d).neg = DistinctionNat.zero := rfl
    rw [hp, hn, DistinctionNat.toNat_add, DistinctionNat.toNat_mul, DistinctionNat.toNat_mul,
      DistinctionNat.toNat_zero]
    omega
  have hneg : (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).neg.toNat = z.neg.toNat * d.toNat := by
    show (z.pos * (SignedOrbit.ofOrbit d).neg + z.neg * (SignedOrbit.ofOrbit d).pos).toNat = _
    have hp : (SignedOrbit.ofOrbit d).pos = d := rfl
    have hn : (SignedOrbit.ofOrbit d).neg = DistinctionNat.zero := rfl
    rw [hp, hn, DistinctionNat.toNat_add, DistinctionNat.toNat_mul, DistinctionNat.toNat_mul,
      DistinctionNat.toNat_zero]
    omega
  have key : DistinctionNat.leq (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).neg
      (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).pos = true ↔
      DistinctionNat.leq z.neg z.pos = true := by
    rw [leq_eq_true_iff_cf, leq_eq_true_iff_cf, hpos, hneg]
    constructor
    · intro h
      exact Nat.le_of_mul_le_mul_right h hdpos
    · intro h
      exact Nat.mul_le_mul_right _ h
  show DistinctionNat.leq (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).neg
      (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).pos =
      DistinctionNat.leq z.neg z.pos
  cases hb : DistinctionNat.leq z.neg z.pos with
    | true => exact key.mpr hb
    | false =>
      cases hb2 : DistinctionNat.leq (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).neg
          (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).pos with
        | true =>
          rw [key.mp hb2] at hb
          exact absurd hb (by decide)
        | false => rfl
THEOREM nonnegFlag_mul_ofOrbit_right_of_ne_zero_cf · IndisputableMonolith/Foundation/PrimitiveRecognitionCalculus/Grow/SignedOrbitNonnegFlagMulOfOrbitRightOfNeZeroChoiceFree.lean
nonnegFlag_mul_ofOrbit_right_of_ne_zero_cf · IndisputableMonolith/Foundation/PrimitiveRecognitionCalculus/Grow/SignedOrbitNonnegFlagMulOfOrbitRightOfNeZeroChoiceFree.lean:12 
theorem nonnegFlag_mul_ofOrbit_right_of_ne_zero_cf
    (z : SignedOrbit) (d : DistinctionNat) (hd : d ≠ DistinctionNat.zero) :
    (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).nonnegFlag = z.nonnegFlag := by
  have hd' : d.toNat ≠ 0 := by
    intro h
    apply hd
    rw [← DistinctionNat.ofNat_toNat d, h, DistinctionNat.ofNat_zero]
  have hdpos : 0 < d.toNat := by omega
  have hpos : (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).pos.toNat = z.pos.toNat * d.toNat := by
    show (z.pos * (SignedOrbit.ofOrbit d).pos + z.neg * (SignedOrbit.ofOrbit d).neg).toNat = _
    have hp : (SignedOrbit.ofOrbit d).pos = d := rfl
    have hn : (SignedOrbit.ofOrbit d).neg = DistinctionNat.zero := rfl
    rw [hp, hn, DistinctionNat.toNat_add, DistinctionNat.toNat_mul, DistinctionNat.toNat_mul,
      DistinctionNat.toNat_zero]
    omega
  have hneg : (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).neg.toNat = z.neg.toNat * d.toNat := by
    show (z.pos * (SignedOrbit.ofOrbit d).neg + z.neg * (SignedOrbit.ofOrbit d).pos).toNat = _
    have hp : (SignedOrbit.ofOrbit d).pos = d := rfl
    have hn : (SignedOrbit.ofOrbit d).neg = DistinctionNat.zero := rfl
    rw [hp, hn, DistinctionNat.toNat_add, DistinctionNat.toNat_mul, DistinctionNat.toNat_mul,
      DistinctionNat.toNat_zero]
    omega
  have key : DistinctionNat.leq (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).neg
      (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).pos = true ↔
      DistinctionNat.leq z.neg z.pos = true := by
    rw [leq_eq_true_iff_cf, leq_eq_true_iff_cf, hpos, hneg]
    constructor
    · intro h
      exact Nat.le_of_mul_le_mul_right h hdpos
    · intro h
      exact Nat.mul_le_mul_right _ h
  show DistinctionNat.leq (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).neg
      (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).pos =
      DistinctionNat.leq z.neg z.pos
  cases hb : DistinctionNat.leq z.neg z.pos with
    | true => exact key.mpr hb
    | false =>
      cases hb2 : DistinctionNat.leq (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).neg
          (SignedOrbit.mul z (SignedOrbit.ofOrbit d)).pos with
        | true =>
          rw [key.mp hb2] at hb
          exact absurd hb (by decide)
        | false => rfl

What this page does not claim

The theorem does not claim sign invariance under left multiplication. The theorem does not claim anything about multiplication by zero distinctions. The theorem does not assert any physical meaning for orbits or their signs.

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

MACHINE LAYER · GROUNDED CLAIM TABLE · CLICK TO EXPAND