File: Mathlib/Tactic/Positivity/Basic.lean

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.ite_pos
code: private lemma ite_pos [LT α] (ha : 0 < a) (hb : 0 < b) : 0 < ite p a b 
goal: 0 < if p then a else b

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.ite_nonneg
code: private lemma ite_nonneg [LE α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ ite p a b 
goal: 0 ≤ if p then a else b

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.ite_nonneg_of_pos_of_nonneg
code: private lemma ite_nonneg_of_pos_of_nonneg [Preorder α] (ha : 0 < a) (hb : 0 ≤ b) : 0 ≤ ite p a b 
goal: 0 ≤ if p then a else b

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.ite_nonneg_of_nonneg_of_pos
code: private lemma ite_nonneg_of_nonneg_of_pos [Preorder α] (ha : 0 ≤ a) (hb : 0 < b) : 0 ≤ ite p a b 
goal: 0 ≤ if p then a else b

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.ite_ne_zero
code: private lemma ite_ne_zero (ha : a ≠ 0) (hb : b ≠ 0) : ite p a b ≠ 0 
goal: (if p then a else b) ≠ 0

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.ite_ne_zero_of_pos_of_ne_zero
code: private lemma ite_ne_zero_of_pos_of_ne_zero [Preorder α] (ha : 0 < a) (hb : b ≠ 0) :
    ite p a b ≠ 0 
goal: (if p then a else b) ≠ 0

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.ite_ne_zero_of_ne_zero_of_pos
code: private lemma ite_ne_zero_of_ne_zero_of_pos [Preorder α] (ha : a ≠ 0) (hb : 0 < b) :
    ite p a b ≠ 0 
goal: (if p then a else b) ≠ 0

full_name: Mathlib.Meta.Positivity.evalIte
code: /-- The `positivity` extension which identifies expressions of the form `ite p a b`,
such that `positivity` successfully recognises both `a` and `b`. -/
@[positivity ite _ _ _] def evalIte : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.le_min_of_lt_of_le
code: private lemma le_min_of_lt_of_le (ha : a < b) (hb : a ≤ c) : a ≤ min b c 
goal: a ≤ min b c

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.le_min_of_le_of_lt
code: private lemma le_min_of_le_of_lt (ha : a ≤ b) (hb : a < c) : a ≤ min b c 
goal: a ≤ min b c

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.min_ne
code: private lemma min_ne (ha : a ≠ c) (hb : b ≠ c) : min a b ≠ c 
goal: min a b ≠ c

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.min_ne_of_ne_of_lt
code: private lemma min_ne_of_ne_of_lt (ha : a ≠ c) (hb : c < b) : min a b ≠ c 
goal: min a b ≠ c

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.min_ne_of_lt_of_ne
code: private lemma min_ne_of_lt_of_ne (ha : c < a) (hb : b ≠ c) : min a b ≠ c 
goal: min a b ≠ c

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.max_ne
code: private lemma max_ne (ha : a ≠ c) (hb : b ≠ c) : max a b ≠ c 
goal: max a b ≠ c

full_name: Mathlib.Meta.Positivity.evalMin
code: /-- The `positivity` extension which identifies expressions of the form `min a b`,
such that `positivity` successfully recognises both `a` and `b`. -/
@[positivity min _ _] def evalMin : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalMax
code: /-- Extension for the `max` operator. The `max` of two numbers is nonnegative if at least one
is nonnegative, strictly positive if at least one is positive, and nonzero if both are nonzero. -/
@[positivity max _ _] def evalMax : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalAdd
code: /-- The `positivity` extension which identifies expressions of the form `a + b`,
such that `positivity` successfully recognises both `a` and `b`. -/
@[positivity _ + _] def evalAdd : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.mul_nonneg_of_pos_of_nonneg
code: private theorem mul_nonneg_of_pos_of_nonneg [OrderedSemiring α] {a b : α}
    (ha : 0 < a) (hb : 0 ≤ b) : 0 ≤ a * b 
goal: 0 ≤ a * b

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.mul_nonneg_of_nonneg_of_pos
code: private theorem mul_nonneg_of_nonneg_of_pos [OrderedSemiring α] {a b : α}
    (ha : 0 ≤ a) (hb : 0 < b) : 0 ≤ a * b 
goal: 0 ≤ a * b

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.mul_ne_zero_of_ne_zero_of_pos
code: private theorem mul_ne_zero_of_ne_zero_of_pos [OrderedSemiring α] [NoZeroDivisors α]
    {a b : α} (ha : a ≠ 0) (hb : 0 < b) : a * b ≠ 0 
goal: a * b ≠ 0

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.mul_ne_zero_of_pos_of_ne_zero
code: private theorem mul_ne_zero_of_pos_of_ne_zero [OrderedSemiring α] [NoZeroDivisors α]
    {a b : α} (ha : 0 < a) (hb : b ≠ 0) : a * b ≠ 0 
goal: a * b ≠ 0

full_name: Mathlib.Meta.Positivity.evalMul
code: /-- The `positivity` extension which identifies expressions of the form `a * b`,
such that `positivity` successfully recognises both `a` and `b`. -/
@[positivity _ * _] def evalMul : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.int_div_self_pos
code: private lemma int_div_self_pos {a : ℤ} (ha : 0 < a) : 0 < a / a 
goal: 0 < a / a

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.int_div_nonneg_of_pos_of_nonneg
code: private lemma int_div_nonneg_of_pos_of_nonneg {a b : ℤ} (ha : 0 < a) (hb : 0 ≤ b) : 0 ≤ a / b 
goal: 0 ≤ a / b

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.int_div_nonneg_of_nonneg_of_pos
code: private lemma int_div_nonneg_of_nonneg_of_pos {a b : ℤ} (ha : 0 ≤ a) (hb : 0 < b) : 0 ≤ a / b 
goal: 0 ≤ a / b

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.int_div_nonneg_of_pos_of_pos
code: private lemma int_div_nonneg_of_pos_of_pos {a b : ℤ} (ha : 0 < a) (hb : 0 < b) : 0 ≤ a / b 
goal: 0 ≤ a / b

full_name: Mathlib.Meta.Positivity.evalIntDiv
code: /-- The `positivity` extension which identifies expressions of the form `a / b`,
where `a` and `b` are integers. -/
@[positivity (_ : ℤ) / (_ : ℤ)] def evalIntDiv : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.pow_zero_pos
code: private theorem pow_zero_pos [OrderedSemiring α] [Nontrivial α] (a : α) : 0 < a ^ 0 
goal: 0 < a ^ 0

full_name: Mathlib.Meta.Positivity.evalPowZeroNat
code: /-- The `positivity` extension which identifies expressions of the form `a ^ (0:ℕ)`.
This extension is run in addition to the general `a ^ b` extension (they are overlapping). -/
@[positivity _ ^ (0:ℕ)]
def evalPowZeroNat : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalPow
code: /-- The `positivity` extension which identifies expressions of the form `a ^ (b : ℕ)`,
such that `positivity` successfully recognises both `a` and `b`. -/
@[positivity _ ^ (_ : ℕ)]
def evalPow : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.abs_pos_of_ne_zero
code: private theorem abs_pos_of_ne_zero {α : Type*} [AddGroup α] [LinearOrder α]
    [CovariantClass α α (·+·) (·≤·)] {a : α} : a ≠ 0 → 0 < |a| 
goal: a ≠ 0 → 0 < |a|

full_name: Mathlib.Meta.Positivity.evalAbs
code: /-- The `positivity` extension which identifies expressions of the form `|a|`. -/
@[positivity |_|]
def evalAbs : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: _private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.int_natAbs_pos
code: private theorem int_natAbs_pos {n : ℤ} (hn : 0 < n) : 0 < n.natAbs 
goal: 0 < n.natAbs

full_name: Mathlib.Meta.Positivity.evalNatAbs
code: /-- Extension for the `positivity` tactic: `Int.natAbs` is positive when its input is.
Since the output type of `Int.natAbs` is `ℕ`, the nonnegative case is handled by the default
`positivity` tactic.
-/
@[positivity Int.natAbs _]
def evalNatAbs : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalNatCast
code: /-- Extension for the `positivity` tactic: `Nat.cast` is always non-negative,
and positive when its input is. -/
@[positivity Nat.cast _]
def evalNatCast : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalIntCast
code: /-- Extension for the `positivity` tactic: `Int.cast` is positive (resp. non-negative)
if its input is. -/
@[positivity Int.cast _]
def evalIntCast : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalNatSucc
code: /-- Extension for `Nat.succ`. -/
@[positivity Nat.succ _]
def evalNatSucc : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalPNatVal
code: /-- Extension for `PNat.val`. -/
@[positivity PNat.val _]
def evalPNatVal : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalFactorial
code: /-- Extension for `Nat.factorial`. -/
@[positivity Nat.factorial _]
def evalFactorial : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalAscFactorial
code: /-- Extension for `Nat.ascFactorial`. -/
@[positivity Nat.ascFactorial _ _]
def evalAscFactorial : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalNNRatNum
code: /-- The `positivity` extension which identifies expressions of the form `NNRat.num q`,
such that `positivity` successfully recognises `q`. -/
@[positivity NNRat.num _]
def evalNNRatNum : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalNNRatDen
code: /-- The `positivity` extension which identifies expressions of the form `Rat.den a`. -/
@[positivity NNRat.den _]
def evalNNRatDen : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalRatNum
code: /-- The `positivity` extension which identifies expressions of the form `Rat.num a`,
such that `positivity` successfully recognises `a`. -/
@[positivity Rat.num _]
def evalRatNum : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalRatDen
code: /-- The `positivity` extension which identifies expressions of the form `Rat.den a`. -/
@[positivity Rat.den _]
def evalRatDen : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalPosPart
code: /-- Extension for `posPart`. `a⁺` is always nonegative, and positive if `a` is. -/
@[positivity _⁺]
def evalPosPart : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalNegPart
code: /-- Extension for `negPart`. `a⁻` is always nonegative. -/
@[positivity _⁻]
def evalNegPart : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt