Foundation Primitive Recognition Calculus Integer Order Recip Num Not Balanced O

The reciprocal sign rule

The declaration recip_num_not_balanced_ofOrbit_den_iff_negativeFlag_of_not_balanced_zero is a theorem in the machine-checked library of formal theorems that Recognition Science uses. It concerns reciprocals, the operation that maps a number to one divided by itself, within a discrete number system called the signed-orbit surface. The theorem states a precise relationship between the sign of a number's denominator and the sign of its reciprocal's numerator, under the condition that the original number's numerator is not balanced with zero, meaning it is not zero itself.

In plain terms, the theorem says: if you take a number whose numerator is not zero, then the numerator of its reciprocal has a negative sign exactly when the denominator of the original number has a negative sign. In symbols, the reciprocal of a number with a negative denominator has a negative numerator. This is a formal statement about how the sign of a number's parts behaves under the reciprocal operation.

The theorem is part of a larger body of work in the framework's library on the order properties of the signed-orbit surface. It builds on earlier results about how signs and comparisons behave under reciprocals, such as the theorem that the absolute value of the reciprocal's numerator equals the absolute value of the original denominator. The new theorem extends this by relating the signs of the numerator and denominator, not just their magnitudes.

This result is a formal theorem, proved in the framework's library, not a hypothesis or a measurement. It is a statement about the internal structure of the framework's number system, not about the physical world directly. The theorem does not claim anything about the physical meaning of these signs or about how this number system relates to ordinary arithmetic or to any physical quantity.

theorem recip_num_balanced_zero_iff (a : RatioOrbit) :
    SignedOrbit.balanced (RatioOrbit.recip a).num SignedOrbit.zero ↔
      SignedOrbit.balanced a.num SignedOrbit.zero := by
  by_cases hzero : SignedOrbit.balanced a.num SignedOrbit.zero
  · unfold RatioOrbit.recip
    simp [hzero, RatioOrbit.zero, SignedOrbit.balanced_refl]
  · rw [RatioOrbit.recip_eq_recipNonzero_of_not_balanced_zero a hzero]
    constructor
    · intro hrec
      exfalso
      exact RatioOrbit.recipNonzero_num_not_balanced_zero a hzero hrec
    · intro ha
      exfalso
      exact hzero ha

theorem recip_num_balanced_zero_iff (a : RatioOrbit) :
    SignedOrbit.balanced (RatioOrbit.recip a).num SignedOrbit.zero ↔
      SignedOrbit.balanced a.num SignedOrbit.zero := by
  by_cases hzero : SignedOrbit.balanced a.num SignedOrbit.zero
  · unfold RatioOrbit.recip
    simp [hzero, RatioOrbit.zero, SignedOrbit.balanced_refl]
  · rw [RatioOrbit.recip_eq_recipNonzero_of_not_balanced_zero a hzero]
    constructor
    · intro hrec
      exfalso
      exact RatioOrbit.recipNonzero_num_not_balanced_zero a hzero hrec
    · intro ha
      exfalso
      exact hzero ha

theorem recipNonzero_num_abs_eq_den (a : RatioOrbit)
    (h : ¬ SignedOrbit.balanced a.num SignedOrbit.zero) :
    (RatioOrbit.recipNonzero a h).num.abs = a.den := by
  by_cases hnonneg : a.num.nonnegFlag = true
  · rw [RatioOrbit.recipNonzero_num_eq_of_nonnegFlag (a := a) (h := h) hnonneg,
      SignedOrbit.abs_ofOrbit]
  · have hneg : a.num.negativeFlag = true := by
      rw [SignedOrbit.negativeFlag_eq_true_iff_nonnegFlag_eq_false]
      cases hflag : a.num.nonnegFlag with
      | false => rfl
      | true =>
          exfalso
          exact hnonneg hflag
    rw [RatioOrbit.recipNonzero_num_eq_of_negativeFlag (a := a) (h := h) hneg,
      SignedOrbit.abs_negate_ofOrbit]

What this page does not claim

This theorem does not claim anything about the physical interpretation of these signs or about how this number system relates to ordinary arithmetic. This theorem does not claim that the reciprocal operation is defined for all numbers, only for those whose numerator is not balanced with zero. This theorem does not claim that a negative denominator always yields a negative reciprocal numerator; it only states the equivalence under the given condition.

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