File: Mathlib/Algebra/Order/Ring/Rat.lean

full_name: Rat.divInt_nonneg_iff_of_pos_right
code: @[simp] lemma divInt_nonneg_iff_of_pos_right {a b : ℤ} (hb : 0 < b) : 0 ≤ a /. b ↔ 0 ≤ a 
goal: 0 ≤ Rat.divInt a b ↔ 0 ≤ a

full_name: Rat.divInt_nonneg
code: @[simp] lemma divInt_nonneg {a b : ℤ} (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a /. b 
goal: 0 ≤ Rat.divInt a b

full_name: Rat.mkRat_nonneg
code: @[simp] lemma mkRat_nonneg {a : ℤ} (ha : 0 ≤ a) (b : ℕ) : 0 ≤ mkRat a b 
goal: 0 ≤ mkRat a b

full_name: Rat.ofScientific_nonneg
code: theorem ofScientific_nonneg (m : ℕ) (s : Bool) (e : ℕ) :
    0 ≤ Rat.ofScientific m s e 
goal: 0 ≤ Rat.ofScientific m s e

full_name: NNRatCast.toOfScientific
code: instance _root_.NNRatCast.toOfScientific {K} [NNRatCast K] : OfScientific K 
goal: OfScientific K

full_name: NNRat.cast_ofScientific
code: /-- Casting a scientific literal via `ℚ≥0` is the same as casting directly. -/
@[simp, norm_cast]
theorem _root_.NNRat.cast_ofScientific {K} [NNRatCast K] (m : ℕ) (s : Bool) (e : ℕ) :
    (OfScientific.ofScientific m s e : ℚ≥0) = (OfScientific.ofScientific m s e : K) 
goal: ↑(OfScientific.ofScientific m s e) = OfScientific.ofScientific m s e

full_name: Rat.add_nonneg
code: protected lemma add_nonneg : 0 ≤ a → 0 ≤ b → 0 ≤ a + b 
goal: 0 ≤ a → 0 ≤ b → 0 ≤ a + b

full_name: Rat.mul_nonneg
code: protected lemma mul_nonneg : 0 ≤ a → 0 ≤ b → 0 ≤ a * b 
goal: 0 ≤ a → 0 ≤ b → 0 ≤ a * b

full_name: Rat.le_iff_sub_nonneg
code: protected theorem le_iff_sub_nonneg (a b : ℚ) : a ≤ b ↔ 0 ≤ b - a 
goal: a ≤ b ↔ 0 ≤ b - a

full_name: Rat.divInt_le_divInt
code: protected lemma divInt_le_divInt {a b c d : ℤ} (b0 : 0 < b) (d0 : 0 < d) :
    a /. b ≤ c /. d ↔ a * d ≤ c * b 
goal: Rat.divInt a b ≤ Rat.divInt c d ↔ a * d ≤ c * b

full_name: Rat.le_total
code: protected lemma le_total : a ≤ b ∨ b ≤ a 
goal: a ≤ b ∨ b ≤ a

full_name: Rat.not_le
code: protected theorem not_le {a b : ℚ} : ¬a ≤ b ↔ b < a 
goal: ¬a ≤ b ↔ b < a

full_name: Rat.linearOrder
code: instance linearOrder : LinearOrder ℚ 
goal: LinearOrder ℚ

full_name: Rat.instDistribLattice
code: instance instDistribLattice : DistribLattice ℚ 
goal: DistribLattice ℚ

full_name: Rat.instLattice
code: instance instLattice        : Lattice ℚ        
goal: Lattice ℚ

full_name: Rat.instSemilatticeInf
code: instance instSemilatticeInf : SemilatticeInf ℚ 
goal: SemilatticeInf ℚ

full_name: Rat.instSemilatticeSup
code: instance instSemilatticeSup : SemilatticeSup ℚ 
goal: SemilatticeSup ℚ

full_name: Rat.instInf
code: instance instInf            : Inf ℚ            
goal: Inf ℚ

full_name: Rat.instSup
code: instance instSup            : Sup ℚ            
goal: Sup ℚ

full_name: Rat.instPartialOrder
code: instance instPartialOrder   : PartialOrder ℚ   
goal: PartialOrder ℚ

full_name: Rat.instPreorder
code: instance instPreorder       : Preorder ℚ       
goal: Preorder ℚ

full_name: Rat.le_def
code: protected lemma le_def : p ≤ q ↔ p.num * q.den ≤ q.num * p.den 
goal: p ≤ q ↔ p.num * ↑q.den ≤ q.num * ↑p.den

full_name: Rat.lt_def
code: protected lemma lt_def : p < q ↔ p.num * q.den < q.num * p.den 
goal: p < q ↔ p.num * ↑q.den < q.num * ↑p.den

full_name: Rat.add_le_add_left
code: protected theorem add_le_add_left {a b c : ℚ} : c + a ≤ c + b ↔ a ≤ b 
goal: c + a ≤ c + b ↔ a ≤ b

full_name: Rat.instLinearOrderedCommRing
code: instance instLinearOrderedCommRing : LinearOrderedCommRing ℚ 
goal: LinearOrderedCommRing ℚ

full_name: Rat.instLinearOrderedRing
code: instance : LinearOrderedRing ℚ 
goal: LinearOrderedRing ℚ

full_name: Rat.instOrderedRing
code: instance : OrderedRing ℚ 
goal: OrderedRing ℚ

full_name: Rat.instLinearOrderedSemiring
code: instance : LinearOrderedSemiring ℚ 
goal: LinearOrderedSemiring ℚ

full_name: Rat.instOrderedSemiring
code: instance : OrderedSemiring ℚ 
goal: OrderedSemiring ℚ

full_name: Rat.instLinearOrderedAddCommGroup
code: instance : LinearOrderedAddCommGroup ℚ 
goal: LinearOrderedAddCommGroup ℚ

full_name: Rat.instOrderedAddCommGroup
code: instance : OrderedAddCommGroup ℚ 
goal: OrderedAddCommGroup ℚ

full_name: Rat.instOrderedCancelAddCommMonoid
code: instance : OrderedCancelAddCommMonoid ℚ 
goal: OrderedCancelAddCommMonoid ℚ

full_name: Rat.instOrderedAddCommMonoid
code: instance : OrderedAddCommMonoid ℚ 
goal: OrderedAddCommMonoid ℚ

full_name: Rat.num_nonpos
code: @[simp] lemma num_nonpos {a : ℚ} : a.num ≤ 0 ↔ a ≤ 0 
goal: a.num ≤ 0 ↔ a ≤ 0

full_name: Rat.num_pos
code: @[simp] lemma num_pos {a : ℚ} : 0 < a.num ↔ 0 < a 
goal: 0 < a.num ↔ 0 < a

full_name: Rat.num_neg
code: @[simp] lemma num_neg {a : ℚ} : a.num < 0 ↔ a < 0 
goal: a.num < 0 ↔ a < 0

full_name: Rat.div_lt_div_iff_mul_lt_mul
code: theorem div_lt_div_iff_mul_lt_mul {a b c d : ℤ} (b_pos : 0 < b) (d_pos : 0 < d) :
    (a : ℚ) / b < c / d ↔ a * d < c * b 
goal: ↑a / ↑b < ↑c / ↑d ↔ a * d < c * b

full_name: Rat.lt_one_iff_num_lt_denom
code: theorem lt_one_iff_num_lt_denom {q : ℚ} : q < 1 ↔ q.num < q.den 
goal: q < 1 ↔ q.num < ↑q.den

full_name: Rat.abs_def
code: theorem abs_def (q : ℚ) : |q| = q.num.natAbs /. q.den 
goal: |q| = Rat.divInt ↑q.num.natAbs ↑q.den