File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

full_name: add_one_le_two_mul
code: theorem add_one_le_two_mul [LE α] [Semiring α] [CovariantClass α α (· + ·) (· ≤ ·)] {a : α}
    (a1 : 1 ≤ a) : a + 1 ≤ 2 * a 
goal: a + 1 ≤ 2 * a

full_name: pow_nonneg
code: @[simp]
theorem pow_nonneg [ZeroLEOneClass α] [PosMulMono α]
    (H : 0 ≤ a) : ∀ n : ℕ, 0 ≤ a ^ n
  
goal: 0 ≤ a ^ n

full_name: pow_le_pow_of_le_one
code: lemma pow_le_pow_of_le_one [ZeroLEOneClass α] [PosMulMono α] [MulPosMono α]
    (ha₀ : 0 ≤ a) (ha₁ : a ≤ 1) : ∀ {m n : ℕ}, m ≤ n → a ^ n ≤ a ^ m
  
goal: m ≤ n → a ^ n ≤ a ^ m

full_name: pow_le_of_le_one
code: lemma pow_le_of_le_one [ZeroLEOneClass α] [PosMulMono α] [MulPosMono α]
    (h₀ : 0 ≤ a) (h₁ : a ≤ 1) {n : ℕ} (hn : n ≠ 0) : a ^ n ≤ a 
goal: a ^ n ≤ a

full_name: sq_le
code: lemma sq_le [ZeroLEOneClass α] [PosMulMono α] [MulPosMono α]
    (h₀ : 0 ≤ a) (h₁ : a ≤ 1) : a ^ 2 ≤ a 
goal: a ^ 2 ≤ a

full_name: add_le_mul_two_add
code: theorem add_le_mul_two_add [ZeroLEOneClass α] [MulPosMono α] [CovariantClass α α (· + ·) (· ≤ ·)]
    (a2 : 2 ≤ a) (b0 : 0 ≤ b) : a + (2 + b) ≤ a * (2 + b) 
goal: a + (2 + b) ≤ a * (2 + b)

full_name: one_le_mul_of_one_le_of_one_le
code: theorem one_le_mul_of_one_le_of_one_le [ZeroLEOneClass α] [PosMulMono α]
    (ha : 1 ≤ a) (hb : 1 ≤ b) : (1 : α) ≤ a * b 
goal: 1 ≤ a * b

full_name: monotone_mul_left_of_nonneg
code: theorem monotone_mul_left_of_nonneg [PosMulMono α]
    (ha : 0 ≤ a) : Monotone fun x => a * x 
goal: Monotone fun x => a * x

full_name: monotone_mul_right_of_nonneg
code: theorem monotone_mul_right_of_nonneg [MulPosMono α]
    (ha : 0 ≤ a) : Monotone fun x => x * a 
goal: Monotone fun x => x * a

full_name: Monotone.mul_const
code: theorem Monotone.mul_const [MulPosMono α]
    (hf : Monotone f) (ha : 0 ≤ a) : Monotone fun x => f x * a 
goal: Monotone fun x => f x * a

full_name: Monotone.const_mul
code: theorem Monotone.const_mul [PosMulMono α]
    (hf : Monotone f) (ha : 0 ≤ a) : Monotone fun x => a * f x 
goal: Monotone fun x => a * f x

full_name: Antitone.mul_const
code: theorem Antitone.mul_const [MulPosMono α]
    (hf : Antitone f) (ha : 0 ≤ a) : Antitone fun x => f x * a 
goal: Antitone fun x => f x * a

full_name: Antitone.const_mul
code: theorem Antitone.const_mul [PosMulMono α]
    (hf : Antitone f) (ha : 0 ≤ a) : Antitone fun x => a * f x 
goal: Antitone fun x => a * f x

full_name: Monotone.mul
code: theorem Monotone.mul [PosMulMono α] [MulPosMono α]
    (hf : Monotone f) (hg : Monotone g) (hf₀ : ∀ x, 0 ≤ f x) (hg₀ : ∀ x, 0 ≤ g x) :
    Monotone (f * g) 
goal: Monotone (f * g)

full_name: mul_le_one
code: theorem mul_le_one [ZeroLEOneClass α] [PosMulMono α] [MulPosMono α]
    (ha : a ≤ 1) (hb' : 0 ≤ b) (hb : b ≤ 1) : a * b ≤ 1 
goal: a * b ≤ 1

full_name: one_lt_mul_of_le_of_lt
code: theorem one_lt_mul_of_le_of_lt [ZeroLEOneClass α] [MulPosMono α]
    (ha : 1 ≤ a) (hb : 1 < b) : 1 < a * b 
goal: 1 < a * b

full_name: one_lt_mul_of_lt_of_le
code: theorem one_lt_mul_of_lt_of_le [ZeroLEOneClass α] [PosMulMono α]
    (ha : 1 < a) (hb : 1 ≤ b) : 1 < a * b 
goal: 1 < a * b

full_name: mul_lt_one_of_nonneg_of_lt_one_left
code: theorem mul_lt_one_of_nonneg_of_lt_one_left [PosMulMono α]
    (ha₀ : 0 ≤ a) (ha : a < 1) (hb : b ≤ 1) : a * b < 1 
goal: a * b < 1

full_name: mul_lt_one_of_nonneg_of_lt_one_right
code: theorem mul_lt_one_of_nonneg_of_lt_one_right [MulPosMono α]
    (ha : a ≤ 1) (hb₀ : 0 ≤ b) (hb : b < 1) : a * b < 1 
goal: a * b < 1

full_name: mul_le_mul_of_nonpos_left
code: theorem mul_le_mul_of_nonpos_left [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (h : b ≤ a) (hc : c ≤ 0) : c * a ≤ c * b 
goal: c * a ≤ c * b

full_name: mul_le_mul_of_nonpos_right
code: theorem mul_le_mul_of_nonpos_right [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (h : b ≤ a) (hc : c ≤ 0) : a * c ≤ b * c 
goal: a * c ≤ b * c

full_name: mul_nonneg_of_nonpos_of_nonpos
code: theorem mul_nonneg_of_nonpos_of_nonpos [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (ha : a ≤ 0) (hb : b ≤ 0) : 0 ≤ a * b 
goal: 0 ≤ a * b

full_name: mul_le_mul_of_nonneg_of_nonpos
code: theorem mul_le_mul_of_nonneg_of_nonpos [ExistsAddOfLE α] [MulPosMono α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hca : c ≤ a) (hbd : b ≤ d) (hc : 0 ≤ c) (hb : b ≤ 0) : a * b ≤ c * d 
goal: a * b ≤ c * d

full_name: mul_le_mul_of_nonneg_of_nonpos'
code: theorem mul_le_mul_of_nonneg_of_nonpos' [ExistsAddOfLE α] [PosMulMono α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hca : c ≤ a) (hbd : b ≤ d) (ha : 0 ≤ a) (hd : d ≤ 0) : a * b ≤ c * d 
goal: a * b ≤ c * d

full_name: mul_le_mul_of_nonpos_of_nonneg
code: theorem mul_le_mul_of_nonpos_of_nonneg [ExistsAddOfLE α] [MulPosMono α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hac : a ≤ c) (hdb : d ≤ b) (hc : c ≤ 0) (hb : 0 ≤ b) : a * b ≤ c * d 
goal: a * b ≤ c * d

full_name: mul_le_mul_of_nonpos_of_nonneg'
code: theorem mul_le_mul_of_nonpos_of_nonneg' [ExistsAddOfLE α] [PosMulMono α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hca : c ≤ a) (hbd : b ≤ d) (ha : 0 ≤ a) (hd : d ≤ 0) : a * b ≤ c * d 
goal: a * b ≤ c * d

full_name: mul_le_mul_of_nonpos_of_nonpos
code: theorem mul_le_mul_of_nonpos_of_nonpos [ExistsAddOfLE α] [MulPosMono α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hca : c ≤ a) (hdb : d ≤ b) (hc : c ≤ 0) (hb : b ≤ 0) : a * b ≤ c * d 
goal: a * b ≤ c * d

full_name: mul_le_mul_of_nonpos_of_nonpos'
code: theorem mul_le_mul_of_nonpos_of_nonpos' [ExistsAddOfLE α] [PosMulMono α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hca : c ≤ a) (hdb : d ≤ b) (ha : a ≤ 0) (hd : d ≤ 0) : a * b ≤ c * d 
goal: a * b ≤ c * d

full_name: le_mul_of_le_one_left
code: /-- Variant of `mul_le_of_le_one_left` for `b` non-positive instead of non-negative.  -/
theorem le_mul_of_le_one_left [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hb : b ≤ 0) (h : a ≤ 1) : b ≤ a * b 
goal: b ≤ a * b

full_name: mul_le_of_one_le_left
code: /-- Variant of `le_mul_of_one_le_left` for `b` non-positive instead of non-negative. -/
theorem mul_le_of_one_le_left [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hb : b ≤ 0) (h : 1 ≤ a) : a * b ≤ b 
goal: a * b ≤ b

full_name: le_mul_of_le_one_right
code: /-- Variant of `mul_le_of_le_one_right` for `a` non-positive instead of non-negative. -/
theorem le_mul_of_le_one_right [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (ha : a ≤ 0) (h : b ≤ 1) : a ≤ a * b 
goal: a ≤ a * b

full_name: mul_le_of_one_le_right
code: /-- Variant of `le_mul_of_one_le_right` for `a` non-positive instead of non-negative. -/
theorem mul_le_of_one_le_right [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (ha : a ≤ 0) (h : 1 ≤ b) : a * b ≤ a 
goal: a * b ≤ a

full_name: antitone_mul_left
code: theorem antitone_mul_left [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    {a : α} (ha : a ≤ 0) : Antitone (a * ·) 
goal: Antitone fun x => a * x

full_name: antitone_mul_right
code: theorem antitone_mul_right [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    {a : α} (ha : a ≤ 0) : Antitone fun x => x * a 
goal: Antitone fun x => x * a

full_name: Monotone.const_mul_of_nonpos
code: theorem Monotone.const_mul_of_nonpos [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hf : Monotone f) (ha : a ≤ 0) : Antitone fun x => a * f x 
goal: Antitone fun x => a * f x

full_name: Monotone.mul_const_of_nonpos
code: theorem Monotone.mul_const_of_nonpos [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hf : Monotone f) (ha : a ≤ 0) : Antitone fun x => f x * a 
goal: Antitone fun x => f x * a

full_name: Antitone.const_mul_of_nonpos
code: theorem Antitone.const_mul_of_nonpos [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hf : Antitone f) (ha : a ≤ 0) : Monotone fun x => a * f x 
goal: Monotone fun x => a * f x

full_name: Antitone.mul_const_of_nonpos
code: theorem Antitone.mul_const_of_nonpos [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hf : Antitone f) (ha : a ≤ 0) : Monotone fun x => f x * a 
goal: Monotone fun x => f x * a

full_name: Antitone.mul_monotone
code: theorem Antitone.mul_monotone [ExistsAddOfLE α] [PosMulMono α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hf : Antitone f) (hg : Monotone g) (hf₀ : ∀ x, f x ≤ 0)
    (hg₀ : ∀ x, 0 ≤ g x) : Antitone (f * g) 
goal: Antitone (f * g)

full_name: Monotone.mul_antitone
code: theorem Monotone.mul_antitone [ExistsAddOfLE α] [PosMulMono α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hf : Monotone f) (hg : Antitone g) (hf₀ : ∀ x, 0 ≤ f x)
    (hg₀ : ∀ x, g x ≤ 0) : Antitone (f * g) 
goal: Antitone (f * g)

full_name: Antitone.mul
code: theorem Antitone.mul [ExistsAddOfLE α] [PosMulMono α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hf : Antitone f) (hg : Antitone g) (hf₀ : ∀ x, f x ≤ 0) (hg₀ : ∀ x, g x ≤ 0) :
    Monotone (f * g) 
goal: Monotone (f * g)

full_name: le_iff_exists_nonneg_add
code: lemma le_iff_exists_nonneg_add
    [ExistsAddOfLE α] [ContravariantClass α α (· + ·) (· ≤ ·)] [CovariantClass α α (· + ·) (· ≤ ·)]
    (a b : α) : a ≤ b ↔ ∃ c ≥ 0, b = a + c 
goal: a ≤ b ↔ ∃ c, c ≥ 0 ∧ b = a + c

full_name: pow_pos
code: @[simp]
theorem pow_pos [ZeroLEOneClass α] [PosMulStrictMono α]
    (H : 0 < a) : ∀ n : ℕ, 0 < a ^ n
  
goal: 0 < a ^ n

full_name: mul_self_lt_mul_self
code: theorem mul_self_lt_mul_self [PosMulStrictMono α] [MulPosMono α]
    (h1 : 0 ≤ a) (h2 : a < b) : a * a < b * b 
goal: a * a < b * b

full_name: strictMonoOn_mul_self
code: theorem strictMonoOn_mul_self [PosMulStrictMono α] [MulPosMono α] :
    StrictMonoOn (fun x : α => x * x) { x | 0 ≤ x } 
goal: StrictMonoOn (fun x => x * x) {x | 0 ≤ x}

full_name: Decidable.mul_lt_mul''
code: protected theorem Decidable.mul_lt_mul'' [PosMulMono α] [PosMulStrictMono α] [MulPosStrictMono α]
    [@DecidableRel α (· ≤ ·)] (h1 : a < c) (h2 : b < d)
    (h3 : 0 ≤ a) (h4 : 0 ≤ b) : a * b < c * d 
goal: a * b < c * d

full_name: lt_mul_left
code: theorem lt_mul_left [MulPosStrictMono α]
    (hn : 0 < a) (hm : 1 < b) : a < b * a 
goal: a < b * a

full_name: lt_mul_right
code: theorem lt_mul_right [PosMulStrictMono α]
    (hn : 0 < a) (hm : 1 < b) : a < a * b 
goal: a < a * b

full_name: lt_mul_self
code: theorem lt_mul_self [ZeroLEOneClass α] [MulPosStrictMono α]
    (hn : 1 < a) : a < a * a 
goal: a < a * a

full_name: strictMono_mul_left_of_pos
code: theorem strictMono_mul_left_of_pos [PosMulStrictMono α]
    (ha : 0 < a) : StrictMono fun x => a * x 
goal: StrictMono fun x => a * x

full_name: strictMono_mul_right_of_pos
code: theorem strictMono_mul_right_of_pos [MulPosStrictMono α]
    (ha : 0 < a) : StrictMono fun x => x * a 
goal: StrictMono fun x => x * a

full_name: StrictMono.mul_const
code: theorem StrictMono.mul_const [MulPosStrictMono α]
    (hf : StrictMono f) (ha : 0 < a) : StrictMono fun x => f x * a 
goal: StrictMono fun x => f x * a

full_name: StrictMono.const_mul
code: theorem StrictMono.const_mul [PosMulStrictMono α]
    (hf : StrictMono f) (ha : 0 < a) : StrictMono fun x => a * f x 
goal: StrictMono fun x => a * f x

full_name: StrictAnti.mul_const
code: theorem StrictAnti.mul_const [MulPosStrictMono α]
    (hf : StrictAnti f) (ha : 0 < a) : StrictAnti fun x => f x * a 
goal: StrictAnti fun x => f x * a

full_name: StrictAnti.const_mul
code: theorem StrictAnti.const_mul [PosMulStrictMono α]
    (hf : StrictAnti f) (ha : 0 < a) : StrictAnti fun x => a * f x 
goal: StrictAnti fun x => a * f x

full_name: StrictMono.mul_monotone
code: theorem StrictMono.mul_monotone [PosMulMono α] [MulPosStrictMono α]
    (hf : StrictMono f) (hg : Monotone g) (hf₀ : ∀ x, 0 ≤ f x)
    (hg₀ : ∀ x, 0 < g x) : StrictMono (f * g) 
goal: StrictMono (f * g)

full_name: Monotone.mul_strictMono
code: theorem Monotone.mul_strictMono [PosMulStrictMono α] [MulPosMono α]
    (hf : Monotone f) (hg : StrictMono g) (hf₀ : ∀ x, 0 < f x)
    (hg₀ : ∀ x, 0 ≤ g x) : StrictMono (f * g) 
goal: StrictMono (f * g)

full_name: StrictMono.mul
code: theorem StrictMono.mul [PosMulStrictMono α] [MulPosStrictMono α]
    (hf : StrictMono f) (hg : StrictMono g) (hf₀ : ∀ x, 0 ≤ f x)
    (hg₀ : ∀ x, 0 ≤ g x) : StrictMono (f * g) 
goal: StrictMono (f * g)

full_name: lt_two_mul_self
code: theorem lt_two_mul_self [ZeroLEOneClass α] [MulPosStrictMono α] [NeZero (R := α) 1]
    [CovariantClass α α (· + ·) (· < ·)] (ha : 0 < a) : a < 2 * a 
goal: a < 2 * a

full_name: mul_lt_mul_of_neg_left
code: theorem mul_lt_mul_of_neg_left [ExistsAddOfLE α] [PosMulStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (h : b < a) (hc : c < 0) : c * a < c * b 
goal: c * a < c * b

full_name: mul_lt_mul_of_neg_right
code: theorem mul_lt_mul_of_neg_right [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (h : b < a) (hc : c < 0) : a * c < b * c 
goal: a * c < b * c

full_name: mul_pos_of_neg_of_neg
code: theorem mul_pos_of_neg_of_neg [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    {a b : α} (ha : a < 0) (hb : b < 0) : 0 < a * b 
goal: 0 < a * b

full_name: lt_mul_of_lt_one_left
code: /-- Variant of `mul_lt_of_lt_one_left` for `b` negative instead of positive. -/
theorem lt_mul_of_lt_one_left [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (hb : b < 0) (h : a < 1) : b < a * b 
goal: b < a * b

full_name: mul_lt_of_one_lt_left
code: /-- Variant of `lt_mul_of_one_lt_left` for `b` negative instead of positive. -/
theorem mul_lt_of_one_lt_left [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (hb : b < 0) (h : 1 < a) : a * b < b 
goal: a * b < b

full_name: lt_mul_of_lt_one_right
code: /-- Variant of `mul_lt_of_lt_one_right` for `a` negative instead of positive. -/
theorem lt_mul_of_lt_one_right [ExistsAddOfLE α] [PosMulStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (ha : a < 0) (h : b < 1) : a < a * b 
goal: a < a * b

full_name: mul_lt_of_one_lt_right
code: /-- Variant of `lt_mul_of_lt_one_right` for `a` negative instead of positive. -/
theorem mul_lt_of_one_lt_right [ExistsAddOfLE α] [PosMulStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (ha : a < 0) (h : 1 < b) : a * b < a 
goal: a * b < a

full_name: strictAnti_mul_left
code: theorem strictAnti_mul_left [ExistsAddOfLE α] [PosMulStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    {a : α} (ha : a < 0) : StrictAnti (a * ·) 
goal: StrictAnti fun x => a * x

full_name: strictAnti_mul_right
code: theorem strictAnti_mul_right [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    {a : α} (ha : a < 0) : StrictAnti fun x => x * a 
goal: StrictAnti fun x => x * a

full_name: StrictMono.const_mul_of_neg
code: theorem StrictMono.const_mul_of_neg [ExistsAddOfLE α] [PosMulStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (hf : StrictMono f) (ha : a < 0) : StrictAnti fun x => a * f x 
goal: StrictAnti fun x => a * f x

full_name: StrictMono.mul_const_of_neg
code: theorem StrictMono.mul_const_of_neg [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (hf : StrictMono f) (ha : a < 0) : StrictAnti fun x => f x * a 
goal: StrictAnti fun x => f x * a

full_name: StrictAnti.const_mul_of_neg
code: theorem StrictAnti.const_mul_of_neg [ExistsAddOfLE α] [PosMulStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (hf : StrictAnti f) (ha : a < 0) : StrictMono fun x => a * f x 
goal: StrictMono fun x => a * f x

full_name: StrictAnti.mul_const_of_neg
code: theorem StrictAnti.mul_const_of_neg [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    (hf : StrictAnti f) (ha : a < 0) : StrictMono fun x => f x * a 
goal: StrictMono fun x => f x * a

full_name: mul_add_mul_le_mul_add_mul
code: /-- Binary **rearrangement inequality**. -/
lemma mul_add_mul_le_mul_add_mul [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)]
    (hab : a ≤ b) (hcd : c ≤ d) : a * d + b * c ≤ a * c + b * d 
goal: a * d + b * c ≤ a * c + b * d

full_name: mul_add_mul_le_mul_add_mul'
code: /-- Binary **rearrangement inequality**. -/
lemma mul_add_mul_le_mul_add_mul' [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)]
    (hba : b ≤ a) (hdc : d ≤ c) : a * d + b * c ≤ a * c + b * d 
goal: a * d + b * c ≤ a * c + b * d

full_name: mul_add_mul_lt_mul_add_mul
code: /-- Binary strict **rearrangement inequality**. -/
lemma mul_add_mul_lt_mul_add_mul [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· < ·)] [ContravariantClass α α (· + ·) (· < ·)]
    (hab : a < b) (hcd : c < d) : a * d + b * c < a * c + b * d 
goal: a * d + b * c < a * c + b * d

full_name: mul_add_mul_lt_mul_add_mul'
code: /-- Binary **rearrangement inequality**. -/
lemma mul_add_mul_lt_mul_add_mul' [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· < ·)] [ContravariantClass α α (· + ·) (· < ·)]
    (hba : b < a) (hdc : d < c) : a * d + b * c < a * c + b * d 
goal: a * d + b * c < a * c + b * d

full_name: nonneg_and_nonneg_or_nonpos_and_nonpos_of_mul_nonneg
code: theorem nonneg_and_nonneg_or_nonpos_and_nonpos_of_mul_nonneg
    [MulPosStrictMono α] [PosMulStrictMono α]
    (hab : 0 ≤ a * b) : 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0 
goal: 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0

full_name: nonneg_of_mul_nonneg_left
code: theorem nonneg_of_mul_nonneg_left [MulPosStrictMono α]
    (h : 0 ≤ a * b) (hb : 0 < b) : 0 ≤ a 
goal: 0 ≤ a

full_name: nonneg_of_mul_nonneg_right
code: theorem nonneg_of_mul_nonneg_right [PosMulStrictMono α]
    (h : 0 ≤ a * b) (ha : 0 < a) : 0 ≤ b 
goal: 0 ≤ b

full_name: nonpos_of_mul_nonpos_left
code: theorem nonpos_of_mul_nonpos_left [PosMulStrictMono α]
    (h : a * b ≤ 0) (hb : 0 < b) : a ≤ 0 
goal: a ≤ 0

full_name: nonpos_of_mul_nonpos_right
code: theorem nonpos_of_mul_nonpos_right [PosMulStrictMono α]
    (h : a * b ≤ 0) (ha : 0 < a) : b ≤ 0 
goal: b ≤ 0

full_name: mul_nonneg_iff_of_pos_left
code: @[simp]
theorem mul_nonneg_iff_of_pos_left [PosMulStrictMono α]
    (h : 0 < c) : 0 ≤ c * b ↔ 0 ≤ b 
goal: 0 ≤ c * b ↔ 0 ≤ b

full_name: mul_nonneg_iff_of_pos_right
code: @[simp]
theorem mul_nonneg_iff_of_pos_right [MulPosStrictMono α]
    (h : 0 < c) : 0 ≤ b * c ↔ 0 ≤ b 
goal: 0 ≤ b * c ↔ 0 ≤ b

full_name: add_le_mul_of_left_le_right
code: theorem add_le_mul_of_left_le_right [ZeroLEOneClass α] [NeZero (R := α) 1]
    [MulPosStrictMono α] [CovariantClass α α (· + ·) (· ≤ ·)]
    (a2 : 2 ≤ a) (ab : a ≤ b) : a + b ≤ a * b 
goal: a + b ≤ a * b

full_name: add_le_mul_of_right_le_left
code: theorem add_le_mul_of_right_le_left [ZeroLEOneClass α] [NeZero (R := α) 1]
    [CovariantClass α α (· + ·) (· ≤ ·)] [PosMulStrictMono α]
    (b2 : 2 ≤ b) (ba : b ≤ a) : a + b ≤ a * b 
goal: a + b ≤ a * b

full_name: add_le_mul
code: theorem add_le_mul [ZeroLEOneClass α] [NeZero (R := α) 1]
    [MulPosStrictMono α] [PosMulStrictMono α] [CovariantClass α α (· + ·) (· ≤ ·)]
    (a2 : 2 ≤ a) (b2 : 2 ≤ b) : a + b ≤ a * b 
goal: a + b ≤ a * b

full_name: add_le_mul'
code: theorem add_le_mul' [ZeroLEOneClass α] [NeZero (R := α) 1]
    [MulPosStrictMono α] [PosMulStrictMono α] [CovariantClass α α (· + ·) (· ≤ ·)]
    (a2 : 2 ≤ a) (b2 : 2 ≤ b) : a + b ≤ b * a 
goal: a + b ≤ b * a

full_name: mul_nonneg_iff_right_nonneg_of_pos
code: theorem mul_nonneg_iff_right_nonneg_of_pos [PosMulStrictMono α]
    (ha : 0 < a) : 0 ≤ a * b ↔ 0 ≤ b 
goal: 0 ≤ a * b ↔ 0 ≤ b

full_name: mul_nonneg_iff_left_nonneg_of_pos
code: theorem mul_nonneg_iff_left_nonneg_of_pos [PosMulStrictMono α] [MulPosStrictMono α]
    (hb : 0 < b) : 0 ≤ a * b ↔ 0 ≤ a 
goal: 0 ≤ a * b ↔ 0 ≤ a

full_name: nonpos_of_mul_nonneg_left
code: theorem nonpos_of_mul_nonneg_left [PosMulStrictMono α]
    (h : 0 ≤ a * b) (hb : b < 0) : a ≤ 0 
goal: a ≤ 0

full_name: nonpos_of_mul_nonneg_right
code: theorem nonpos_of_mul_nonneg_right [MulPosStrictMono α]
    (h : 0 ≤ a * b) (ha : a < 0) : b ≤ 0 
goal: b ≤ 0

full_name: Units.inv_pos
code: @[simp]
theorem Units.inv_pos
    [ZeroLEOneClass α] [NeZero (R := α) 1] [PosMulStrictMono α]
    {u : αˣ} : (0 : α) < ↑u⁻¹ ↔ (0 : α) < u 
goal: 0 < ↑u⁻¹ ↔ 0 < ↑u

full_name: Units.inv_neg
code: @[simp]
theorem Units.inv_neg
    [ZeroLEOneClass α] [NeZero (R := α) 1] [MulPosMono α] [PosMulMono α]
    {u : αˣ} : ↑u⁻¹ < (0 : α) ↔ ↑u < (0 : α) 
goal: ↑u⁻¹ < 0 ↔ ↑u < 0

full_name: cmp_mul_pos_left
code: theorem cmp_mul_pos_left [PosMulStrictMono α]
    (ha : 0 < a) (b c : α) : cmp (a * b) (a * c) = cmp b c 
goal: cmp (a * b) (a * c) = cmp b c

full_name: cmp_mul_pos_right
code: theorem cmp_mul_pos_right [MulPosStrictMono α]
    (ha : 0 < a) (b c : α) : cmp (b * a) (c * a) = cmp b c 
goal: cmp (b * a) (c * a) = cmp b c

full_name: mul_max_of_nonneg
code: theorem mul_max_of_nonneg [PosMulMono α]
    (b c : α) (ha : 0 ≤ a) : a * max b c = max (a * b) (a * c) 
goal: a * max b c = max (a * b) (a * c)

full_name: mul_min_of_nonneg
code: theorem mul_min_of_nonneg [PosMulMono α]
    (b c : α) (ha : 0 ≤ a) : a * min b c = min (a * b) (a * c) 
goal: a * min b c = min (a * b) (a * c)

full_name: max_mul_of_nonneg
code: theorem max_mul_of_nonneg [MulPosMono α]
    (a b : α) (hc : 0 ≤ c) : max a b * c = max (a * c) (b * c) 
goal: max a b * c = max (a * c) (b * c)

full_name: min_mul_of_nonneg
code: theorem min_mul_of_nonneg [MulPosMono α]
    (a b : α) (hc : 0 ≤ c) : min a b * c = min (a * c) (b * c) 
goal: min a b * c = min (a * c) (b * c)

full_name: le_of_mul_le_of_one_le
code: theorem le_of_mul_le_of_one_le
    [ZeroLEOneClass α] [NeZero (R := α) 1] [MulPosStrictMono α] [PosMulMono α]
    {a b c : α} (h : a * c ≤ b) (hb : 0 ≤ b) (hc : 1 ≤ c) : a ≤ b 
goal: a ≤ b

full_name: nonneg_le_nonneg_of_sq_le_sq
code: theorem nonneg_le_nonneg_of_sq_le_sq [PosMulStrictMono α] [MulPosMono α]
    {a b : α} (hb : 0 ≤ b) (h : a * a ≤ b * b) : a ≤ b 
goal: a ≤ b

full_name: mul_self_le_mul_self_iff
code: theorem mul_self_le_mul_self_iff [PosMulStrictMono α] [MulPosMono α]
    {a b : α} (h1 : 0 ≤ a) (h2 : 0 ≤ b) : a ≤ b ↔ a * a ≤ b * b 
goal: a ≤ b ↔ a * a ≤ b * b

full_name: mul_self_lt_mul_self_iff
code: theorem mul_self_lt_mul_self_iff [PosMulStrictMono α] [MulPosMono α]
    {a b : α} (h1 : 0 ≤ a) (h2 : 0 ≤ b) : a < b ↔ a * a < b * b 
goal: a < b ↔ a * a < b * b

full_name: mul_self_inj
code: theorem mul_self_inj [PosMulStrictMono α] [MulPosMono α]
    {a b : α} (h1 : 0 ≤ a) (h2 : 0 ≤ b) : a * a = b * b ↔ a = b 
goal: a * a = b * b ↔ a = b

full_name: sign_cases_of_C_mul_pow_nonneg
code: lemma sign_cases_of_C_mul_pow_nonneg [PosMulStrictMono α]
    (h : ∀ n, 0 ≤ a * b ^ n) : a = 0 ∨ 0 < a ∧ 0 ≤ b 
goal: a = 0 ∨ 0 < a ∧ 0 ≤ b

full_name: mul_pos_iff
code: theorem mul_pos_iff [ExistsAddOfLE α] [PosMulStrictMono α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· < ·)] [ContravariantClass α α (· + ·) (· < ·)] :
    0 < a * b ↔ 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0 
goal: 0 < a * b ↔ 0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0

full_name: mul_nonneg_iff
code: theorem mul_nonneg_iff [ExistsAddOfLE α] [MulPosStrictMono α] [PosMulStrictMono α]
    [ContravariantClass α α (· + ·) (· ≤ ·)] [CovariantClass α α (· + ·) (· ≤ ·)]:
    0 ≤ a * b ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0 
goal: 0 ≤ a * b ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0

full_name: mul_nonneg_of_three
code: /-- Out of three elements of a `LinearOrderedRing`, two must have the same sign. -/
theorem mul_nonneg_of_three [ExistsAddOfLE α] [MulPosStrictMono α] [PosMulStrictMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)]
    (a b c : α) : 0 ≤ a * b ∨ 0 ≤ b * c ∨ 0 ≤ c * a 
goal: 0 ≤ a * b ∨ 0 ≤ b * c ∨ 0 ≤ c * a

full_name: mul_nonneg_iff_pos_imp_nonneg
code: lemma mul_nonneg_iff_pos_imp_nonneg [ExistsAddOfLE α] [PosMulStrictMono α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)] :
    0 ≤ a * b ↔ (0 < a → 0 ≤ b) ∧ (0 < b → 0 ≤ a) 
goal: 0 ≤ a * b ↔ (0 < a → 0 ≤ b) ∧ (0 < b → 0 ≤ a)

full_name: mul_le_mul_left_of_neg
code: @[simp]
theorem mul_le_mul_left_of_neg [ExistsAddOfLE α] [PosMulStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    {a b c : α} (h : c < 0) : c * a ≤ c * b ↔ b ≤ a 
goal: c * a ≤ c * b ↔ b ≤ a

full_name: mul_le_mul_right_of_neg
code: @[simp]
theorem mul_le_mul_right_of_neg [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    {a b c : α} (h : c < 0) : a * c ≤ b * c ↔ b ≤ a 
goal: a * c ≤ b * c ↔ b ≤ a

full_name: mul_lt_mul_left_of_neg
code: @[simp]
theorem mul_lt_mul_left_of_neg [ExistsAddOfLE α] [PosMulStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    {a b c : α} (h : c < 0) : c * a < c * b ↔ b < a 
goal: c * a < c * b ↔ b < a

full_name: mul_lt_mul_right_of_neg
code: @[simp]
theorem mul_lt_mul_right_of_neg [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    {a b c : α} (h : c < 0) : a * c < b * c ↔ b < a 
goal: a * c < b * c ↔ b < a

full_name: lt_of_mul_lt_mul_of_nonpos_left
code: theorem lt_of_mul_lt_mul_of_nonpos_left [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (h : c * a < c * b) (hc : c ≤ 0) : b < a 
goal: b < a

full_name: lt_of_mul_lt_mul_of_nonpos_right
code: theorem lt_of_mul_lt_mul_of_nonpos_right [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (h : a * c < b * c) (hc : c ≤ 0) : b < a 
goal: b < a

full_name: cmp_mul_neg_left
code: theorem cmp_mul_neg_left [ExistsAddOfLE α] [PosMulStrictMono α]
    [ContravariantClass α α (swap (· + ·)) (· < ·)] [CovariantClass α α (swap (· + ·)) (· < ·)]
    {a : α} (ha : a < 0) (b c : α) : cmp (a * b) (a * c) = cmp c b 
goal: cmp (a * b) (a * c) = cmp c b

full_name: cmp_mul_neg_right
code: theorem cmp_mul_neg_right [ExistsAddOfLE α] [MulPosStrictMono α]
    [ContravariantClass α α (swap (· + ·)) (· < ·)] [CovariantClass α α (swap (· + ·)) (· < ·)]
    {a : α} (ha : a < 0) (b c : α) : cmp (b * a) (c * a) = cmp c b 
goal: cmp (b * a) (c * a) = cmp c b

full_name: mul_self_pos
code: @[simp]
theorem mul_self_pos [ExistsAddOfLE α] [PosMulStrictMono α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· < ·)] [ContravariantClass α α (· + ·) (· < ·)]
    {a : α} : 0 < a * a ↔ a ≠ 0 
goal: 0 < a * a ↔ a ≠ 0

full_name: nonneg_of_mul_nonpos_left
code: theorem nonneg_of_mul_nonpos_left [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    {a b : α} (h : a * b ≤ 0) (hb : b < 0) : 0 ≤ a 
goal: 0 ≤ a

full_name: nonneg_of_mul_nonpos_right
code: theorem nonneg_of_mul_nonpos_right [ExistsAddOfLE α] [MulPosStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    {a b : α} (h : a * b ≤ 0) (ha : a < 0) : 0 ≤ b 
goal: 0 ≤ b

full_name: pos_of_mul_neg_left
code: theorem pos_of_mul_neg_left [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    {a b : α} (h : a * b < 0) (hb : b ≤ 0) : 0 < a 
goal: 0 < a

full_name: pos_of_mul_neg_right
code: theorem pos_of_mul_neg_right [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    {a b : α} (h : a * b < 0) (ha : a ≤ 0) : 0 < b 
goal: 0 < b

full_name: neg_iff_pos_of_mul_neg
code: theorem neg_iff_pos_of_mul_neg [ExistsAddOfLE α] [PosMulMono α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hab : a * b < 0) : a < 0 ↔ 0 < b 
goal: a < 0 ↔ 0 < b

full_name: pos_iff_neg_of_mul_neg
code: theorem pos_iff_neg_of_mul_neg [ExistsAddOfLE α] [PosMulMono α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (hab : a * b < 0) : 0 < a ↔ b < 0 
goal: 0 < a ↔ b < 0

full_name: sq_nonneg
code: lemma sq_nonneg [IsRightCancelAdd α]
    [ZeroLEOneClass α] [ExistsAddOfLE α] [PosMulMono α] [CovariantClass α α (· + ·) (· < ·)]
    (a : α) : 0 ≤ a ^ 2 
goal: 0 ≤ a ^ 2

full_name: mul_self_nonneg
code: lemma mul_self_nonneg [IsRightCancelAdd α]
    [ZeroLEOneClass α] [ExistsAddOfLE α] [PosMulMono α] [CovariantClass α α (· + ·) (· < ·)]
    (a : α) : 0 ≤ a * a 
goal: 0 ≤ a * a

full_name: mul_self_add_mul_self_eq_zero
code: /-- The sum of two squares is zero iff both elements are zero. -/
lemma mul_self_add_mul_self_eq_zero [IsRightCancelAdd α] [NoZeroDivisors α]
    [ZeroLEOneClass α] [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [CovariantClass α α (· + ·) (· < ·)] :
    a * a + b * b = 0 ↔ a = 0 ∧ b = 0 
goal: a * a + b * b = 0 ↔ a = 0 ∧ b = 0

full_name: eq_zero_of_mul_self_add_mul_self_eq_zero
code: lemma eq_zero_of_mul_self_add_mul_self_eq_zero [IsRightCancelAdd α] [NoZeroDivisors α]
    [ZeroLEOneClass α] [ExistsAddOfLE α] [PosMulMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [CovariantClass α α (· + ·) (· < ·)]
    (h : a * a + b * b = 0) : a = 0 
goal: a = 0

full_name: max_mul_mul_le_max_mul_max
code: lemma max_mul_mul_le_max_mul_max [PosMulMono α] [MulPosMono α] (b c : α) (ha : 0 ≤ a) (hd : 0 ≤ d) :
    max (a * b) (d * c) ≤ max a c * max d b 
goal: max (a * b) (d * c) ≤ max a c * max d b

full_name: two_mul_le_add_sq
code: /-- Binary **arithmetic mean-geometric mean inequality** (aka AM-GM inequality) for linearly ordered
commutative semirings. -/
lemma two_mul_le_add_sq [ExistsAddOfLE α] [MulPosStrictMono α]
    [ContravariantClass α α (· + ·) (· ≤ ·)] [CovariantClass α α (· + ·) (· ≤ ·)]
    (a b : α) : 2 * a * b ≤ a ^ 2 + b ^ 2 
goal: 2 * a * b ≤ a ^ 2 + b ^ 2

full_name: mul_neg_iff
code: lemma mul_neg_iff [PosMulStrictMono α] [MulPosStrictMono α]
    [ContravariantClass α α (· + ·) (· < ·)] [CovariantClass α α (· + ·) (· < ·)] :
    a * b < 0 ↔ 0 < a ∧ b < 0 ∨ a < 0 ∧ 0 < b 
goal: a * b < 0 ↔ 0 < a ∧ b < 0 ∨ a < 0 ∧ 0 < b

full_name: mul_nonpos_iff
code: lemma mul_nonpos_iff [MulPosStrictMono α] [PosMulStrictMono α]
    [ContravariantClass α α (· + ·) (· ≤ ·)] [CovariantClass α α (· + ·) (· ≤ ·)] :
    a * b ≤ 0 ↔ 0 ≤ a ∧ b ≤ 0 ∨ a ≤ 0 ∧ 0 ≤ b 
goal: a * b ≤ 0 ↔ 0 ≤ a ∧ b ≤ 0 ∨ a ≤ 0 ∧ 0 ≤ b

full_name: mul_nonneg_iff_neg_imp_nonpos
code: lemma mul_nonneg_iff_neg_imp_nonpos [PosMulStrictMono α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)] :
    0 ≤ a * b ↔ (a < 0 → b ≤ 0) ∧ (b < 0 → a ≤ 0) 
goal: 0 ≤ a * b ↔ (a < 0 → b ≤ 0) ∧ (b < 0 → a ≤ 0)

full_name: mul_nonpos_iff_pos_imp_nonpos
code: lemma mul_nonpos_iff_pos_imp_nonpos [PosMulStrictMono α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)] :
    a * b ≤ 0 ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a) 
goal: a * b ≤ 0 ↔ (0 < a → b ≤ 0) ∧ (b < 0 → 0 ≤ a)

full_name: mul_nonpos_iff_neg_imp_nonneg
code: lemma mul_nonpos_iff_neg_imp_nonneg [PosMulStrictMono α] [MulPosStrictMono α]
    [CovariantClass α α (· + ·) (· ≤ ·)] [ContravariantClass α α (· + ·) (· ≤ ·)] :
    a * b ≤ 0 ↔ (a < 0 → 0 ≤ b) ∧ (0 < b → a ≤ 0) 
goal: a * b ≤ 0 ↔ (a < 0 → 0 ≤ b) ∧ (0 < b → a ≤ 0)

full_name: neg_one_lt_zero
code: lemma neg_one_lt_zero
    [ZeroLEOneClass α] [NeZero (R := α) 1] [CovariantClass α α (· + ·) (· < ·)] :
    -1 < (0 : α) 
goal: -1 < 0

full_name: sub_one_lt
code: lemma sub_one_lt [ZeroLEOneClass α] [NeZero (R := α) 1]
    [CovariantClass α α (· + ·) (· < ·)]
    (a : α) : a - 1 < a 
goal: a - 1 < a

full_name: mul_self_le_mul_self_of_le_of_neg_le
code: lemma mul_self_le_mul_self_of_le_of_neg_le
    [MulPosMono α] [PosMulMono α] [CovariantClass α α (· + ·) (· ≤ ·)]
    (h₁ : a ≤ b) (h₂ : -a ≤ b) : a * a ≤ b * b 
goal: a * a ≤ b * b