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

full_name: Left.neg_nonpos_iff
code: /-- Uses `left` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
theorem Left.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a 
goal: -a ≤ 0 ↔ 0 ≤ a

full_name: Left.inv_le_one_iff
code: /-- Uses `left` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
theorem Left.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a 
goal: a⁻¹ ≤ 1 ↔ 1 ≤ a

full_name: Left.one_le_inv_iff
code: /-- Uses `left` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
theorem Left.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 
goal: 1 ≤ a⁻¹ ↔ a ≤ 1

full_name: Left.nonneg_neg_iff
code: /-- Uses `left` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
theorem Left.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 
goal: 0 ≤ -a ↔ a ≤ 0

full_name: le_inv_mul_iff_mul_le
code: @[to_additive (attr := simp)]
theorem le_inv_mul_iff_mul_le : b ≤ a⁻¹ * c ↔ a * b ≤ c 
goal: b ≤ a⁻¹ * c ↔ a * b ≤ c

full_name: le_neg_add_iff_add_le
code: @[to_additive (attr := simp)]
theorem le_inv_mul_iff_mul_le : b ≤ a⁻¹ * c ↔ a * b ≤ c 
goal: b ≤ -a + c ↔ a + b ≤ c

full_name: neg_add_le_iff_le_add
code: @[to_additive (attr := simp)]
theorem inv_mul_le_iff_le_mul : b⁻¹ * a ≤ c ↔ a ≤ b * c 
goal: -b + a ≤ c ↔ a ≤ b + c

full_name: inv_mul_le_iff_le_mul
code: @[to_additive (attr := simp)]
theorem inv_mul_le_iff_le_mul : b⁻¹ * a ≤ c ↔ a ≤ b * c 
goal: b⁻¹ * a ≤ c ↔ a ≤ b * c

full_name: inv_le_iff_one_le_mul'
code: @[to_additive neg_le_iff_add_nonneg']
theorem inv_le_iff_one_le_mul' : a⁻¹ ≤ b ↔ 1 ≤ a * b 
goal: a⁻¹ ≤ b ↔ 1 ≤ a * b

full_name: neg_le_iff_add_nonneg'
code: @[to_additive neg_le_iff_add_nonneg']
theorem inv_le_iff_one_le_mul' : a⁻¹ ≤ b ↔ 1 ≤ a * b 
goal: -a ≤ b ↔ 0 ≤ a + b

full_name: le_inv_iff_mul_le_one_left
code: @[to_additive]
theorem le_inv_iff_mul_le_one_left : a ≤ b⁻¹ ↔ b * a ≤ 1 
goal: a ≤ b⁻¹ ↔ b * a ≤ 1

full_name: le_neg_iff_add_nonpos_left
code: @[to_additive]
theorem le_inv_iff_mul_le_one_left : a ≤ b⁻¹ ↔ b * a ≤ 1 
goal: a ≤ -b ↔ b + a ≤ 0

full_name: le_neg_add_iff_le
code: @[to_additive]
theorem le_inv_mul_iff_le : 1 ≤ b⁻¹ * a ↔ b ≤ a 
goal: 0 ≤ -b + a ↔ b ≤ a

full_name: le_inv_mul_iff_le
code: @[to_additive]
theorem le_inv_mul_iff_le : 1 ≤ b⁻¹ * a ↔ b ≤ a 
goal: 1 ≤ b⁻¹ * a ↔ b ≤ a

full_name: inv_mul_le_one_iff
code: @[to_additive]
theorem inv_mul_le_one_iff : a⁻¹ * b ≤ 1 ↔ b ≤ a 
goal: a⁻¹ * b ≤ 1 ↔ b ≤ a

full_name: neg_add_nonpos_iff
code: @[to_additive]
theorem inv_mul_le_one_iff : a⁻¹ * b ≤ 1 ↔ b ≤ a 
goal: -a + b ≤ 0 ↔ b ≤ a

full_name: Left.one_lt_inv_iff
code: /-- Uses `left` co(ntra)variant. -/
@[to_additive (attr := simp) Left.neg_pos_iff "Uses `left` co(ntra)variant."]
theorem Left.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 
goal: 1 < a⁻¹ ↔ a < 1

full_name: Left.neg_pos_iff
code: /-- Uses `left` co(ntra)variant. -/
@[to_additive (attr := simp) Left.neg_pos_iff "Uses `left` co(ntra)variant."]
theorem Left.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 
goal: 0 < -a ↔ a < 0

full_name: Left.inv_lt_one_iff
code: /-- Uses `left` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
theorem Left.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a 
goal: a⁻¹ < 1 ↔ 1 < a

full_name: Left.neg_neg_iff
code: /-- Uses `left` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
theorem Left.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a 
goal: -a < 0 ↔ 0 < a

full_name: lt_neg_add_iff_add_lt
code: @[to_additive (attr := simp)]
theorem lt_inv_mul_iff_mul_lt : b < a⁻¹ * c ↔ a * b < c 
goal: b < -a + c ↔ a + b < c

full_name: lt_inv_mul_iff_mul_lt
code: @[to_additive (attr := simp)]
theorem lt_inv_mul_iff_mul_lt : b < a⁻¹ * c ↔ a * b < c 
goal: b < a⁻¹ * c ↔ a * b < c

full_name: inv_mul_lt_iff_lt_mul
code: @[to_additive (attr := simp)]
theorem inv_mul_lt_iff_lt_mul : b⁻¹ * a < c ↔ a < b * c 
goal: b⁻¹ * a < c ↔ a < b * c

full_name: neg_add_lt_iff_lt_add
code: @[to_additive (attr := simp)]
theorem inv_mul_lt_iff_lt_mul : b⁻¹ * a < c ↔ a < b * c 
goal: -b + a < c ↔ a < b + c

full_name: neg_lt_iff_pos_add'
code: @[to_additive]
theorem inv_lt_iff_one_lt_mul' : a⁻¹ < b ↔ 1 < a * b 
goal: -a < b ↔ 0 < a + b

full_name: inv_lt_iff_one_lt_mul'
code: @[to_additive]
theorem inv_lt_iff_one_lt_mul' : a⁻¹ < b ↔ 1 < a * b 
goal: a⁻¹ < b ↔ 1 < a * b

full_name: lt_inv_iff_mul_lt_one'
code: @[to_additive]
theorem lt_inv_iff_mul_lt_one' : a < b⁻¹ ↔ b * a < 1 
goal: a < b⁻¹ ↔ b * a < 1

full_name: lt_neg_iff_add_neg'
code: @[to_additive]
theorem lt_inv_iff_mul_lt_one' : a < b⁻¹ ↔ b * a < 1 
goal: a < -b ↔ b + a < 0

full_name: lt_neg_add_iff_lt
code: @[to_additive]
theorem lt_inv_mul_iff_lt : 1 < b⁻¹ * a ↔ b < a 
goal: 0 < -b + a ↔ b < a

full_name: lt_inv_mul_iff_lt
code: @[to_additive]
theorem lt_inv_mul_iff_lt : 1 < b⁻¹ * a ↔ b < a 
goal: 1 < b⁻¹ * a ↔ b < a

full_name: inv_mul_lt_one_iff
code: @[to_additive]
theorem inv_mul_lt_one_iff : a⁻¹ * b < 1 ↔ b < a 
goal: a⁻¹ * b < 1 ↔ b < a

full_name: neg_add_neg_iff
code: @[to_additive]
theorem inv_mul_lt_one_iff : a⁻¹ * b < 1 ↔ b < a 
goal: -a + b < 0 ↔ b < a

full_name: Right.neg_nonpos_iff
code: /-- Uses `right` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
theorem Right.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a 
goal: -a ≤ 0 ↔ 0 ≤ a

full_name: Right.inv_le_one_iff
code: /-- Uses `right` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
theorem Right.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a 
goal: a⁻¹ ≤ 1 ↔ 1 ≤ a

full_name: Right.one_le_inv_iff
code: /-- Uses `right` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
theorem Right.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 
goal: 1 ≤ a⁻¹ ↔ a ≤ 1

full_name: Right.nonneg_neg_iff
code: /-- Uses `right` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
theorem Right.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 
goal: 0 ≤ -a ↔ a ≤ 0

full_name: inv_le_iff_one_le_mul
code: @[to_additive neg_le_iff_add_nonneg]
theorem inv_le_iff_one_le_mul : a⁻¹ ≤ b ↔ 1 ≤ b * a 
goal: a⁻¹ ≤ b ↔ 1 ≤ b * a

full_name: neg_le_iff_add_nonneg
code: @[to_additive neg_le_iff_add_nonneg]
theorem inv_le_iff_one_le_mul : a⁻¹ ≤ b ↔ 1 ≤ b * a 
goal: -a ≤ b ↔ 0 ≤ b + a

full_name: le_neg_iff_add_nonpos_right
code: @[to_additive]
theorem le_inv_iff_mul_le_one_right : a ≤ b⁻¹ ↔ a * b ≤ 1 
goal: a ≤ -b ↔ a + b ≤ 0

full_name: le_inv_iff_mul_le_one_right
code: @[to_additive]
theorem le_inv_iff_mul_le_one_right : a ≤ b⁻¹ ↔ a * b ≤ 1 
goal: a ≤ b⁻¹ ↔ a * b ≤ 1

full_name: add_neg_le_iff_le_add
code: @[to_additive (attr := simp)]
theorem mul_inv_le_iff_le_mul : a * b⁻¹ ≤ c ↔ a ≤ c * b 
goal: a + -b ≤ c ↔ a ≤ c + b

full_name: mul_inv_le_iff_le_mul
code: @[to_additive (attr := simp)]
theorem mul_inv_le_iff_le_mul : a * b⁻¹ ≤ c ↔ a ≤ c * b 
goal: a * b⁻¹ ≤ c ↔ a ≤ c * b

full_name: le_add_neg_iff_add_le
code: @[to_additive (attr := simp)]
theorem le_mul_inv_iff_mul_le : c ≤ a * b⁻¹ ↔ c * b ≤ a 
goal: c ≤ a + -b ↔ c + b ≤ a

full_name: le_mul_inv_iff_mul_le
code: @[to_additive (attr := simp)]
theorem le_mul_inv_iff_mul_le : c ≤ a * b⁻¹ ↔ c * b ≤ a 
goal: c ≤ a * b⁻¹ ↔ c * b ≤ a

full_name: add_neg_nonpos_iff_le
code: @[to_additive]
theorem mul_inv_le_one_iff_le : a * b⁻¹ ≤ 1 ↔ a ≤ b 
goal: a + -b ≤ 0 ↔ a ≤ b

full_name: mul_inv_le_one_iff_le
code: @[to_additive]
theorem mul_inv_le_one_iff_le : a * b⁻¹ ≤ 1 ↔ a ≤ b 
goal: a * b⁻¹ ≤ 1 ↔ a ≤ b

full_name: le_add_neg_iff_le
code: @[to_additive]
theorem le_mul_inv_iff_le : 1 ≤ a * b⁻¹ ↔ b ≤ a 
goal: 0 ≤ a + -b ↔ b ≤ a

full_name: le_mul_inv_iff_le
code: @[to_additive]
theorem le_mul_inv_iff_le : 1 ≤ a * b⁻¹ ↔ b ≤ a 
goal: 1 ≤ a * b⁻¹ ↔ b ≤ a

full_name: mul_inv_le_one_iff
code: @[to_additive]
theorem mul_inv_le_one_iff : b * a⁻¹ ≤ 1 ↔ b ≤ a 
goal: b * a⁻¹ ≤ 1 ↔ b ≤ a

full_name: add_neg_nonpos_iff
code: @[to_additive]
theorem mul_inv_le_one_iff : b * a⁻¹ ≤ 1 ↔ b ≤ a 
goal: b + -a ≤ 0 ↔ b ≤ a

full_name: Right.neg_neg_iff
code: /-- Uses `right` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
theorem Right.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a 
goal: -a < 0 ↔ 0 < a

full_name: Right.inv_lt_one_iff
code: /-- Uses `right` co(ntra)variant. -/
@[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
theorem Right.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a 
goal: a⁻¹ < 1 ↔ 1 < a

full_name: Right.neg_pos_iff
code: /-- Uses `right` co(ntra)variant. -/
@[to_additive (attr := simp) Right.neg_pos_iff "Uses `right` co(ntra)variant."]
theorem Right.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 
goal: 0 < -a ↔ a < 0

full_name: Right.one_lt_inv_iff
code: /-- Uses `right` co(ntra)variant. -/
@[to_additive (attr := simp) Right.neg_pos_iff "Uses `right` co(ntra)variant."]
theorem Right.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 
goal: 1 < a⁻¹ ↔ a < 1

full_name: neg_lt_iff_pos_add
code: @[to_additive]
theorem inv_lt_iff_one_lt_mul : a⁻¹ < b ↔ 1 < b * a 
goal: -a < b ↔ 0 < b + a

full_name: inv_lt_iff_one_lt_mul
code: @[to_additive]
theorem inv_lt_iff_one_lt_mul : a⁻¹ < b ↔ 1 < b * a 
goal: a⁻¹ < b ↔ 1 < b * a

full_name: lt_inv_iff_mul_lt_one
code: @[to_additive]
theorem lt_inv_iff_mul_lt_one : a < b⁻¹ ↔ a * b < 1 
goal: a < b⁻¹ ↔ a * b < 1

full_name: lt_neg_iff_add_neg
code: @[to_additive]
theorem lt_inv_iff_mul_lt_one : a < b⁻¹ ↔ a * b < 1 
goal: a < -b ↔ a + b < 0

full_name: add_neg_lt_iff_lt_add
code: @[to_additive (attr := simp)]
theorem mul_inv_lt_iff_lt_mul : a * b⁻¹ < c ↔ a < c * b 
goal: a + -b < c ↔ a < c + b

full_name: mul_inv_lt_iff_lt_mul
code: @[to_additive (attr := simp)]
theorem mul_inv_lt_iff_lt_mul : a * b⁻¹ < c ↔ a < c * b 
goal: a * b⁻¹ < c ↔ a < c * b

full_name: lt_add_neg_iff_add_lt
code: @[to_additive (attr := simp)]
theorem lt_mul_inv_iff_mul_lt : c < a * b⁻¹ ↔ c * b < a 
goal: c < a + -b ↔ c + b < a

full_name: lt_mul_inv_iff_mul_lt
code: @[to_additive (attr := simp)]
theorem lt_mul_inv_iff_mul_lt : c < a * b⁻¹ ↔ c * b < a 
goal: c < a * b⁻¹ ↔ c * b < a

full_name: neg_add_neg_iff_lt
code: @[to_additive]
theorem inv_mul_lt_one_iff_lt : a * b⁻¹ < 1 ↔ a < b 
goal: a + -b < 0 ↔ a < b

full_name: inv_mul_lt_one_iff_lt
code: @[to_additive]
theorem inv_mul_lt_one_iff_lt : a * b⁻¹ < 1 ↔ a < b 
goal: a * b⁻¹ < 1 ↔ a < b

full_name: lt_add_neg_iff_lt
code: @[to_additive]
theorem lt_mul_inv_iff_lt : 1 < a * b⁻¹ ↔ b < a 
goal: 0 < a + -b ↔ b < a

full_name: lt_mul_inv_iff_lt
code: @[to_additive]
theorem lt_mul_inv_iff_lt : 1 < a * b⁻¹ ↔ b < a 
goal: 1 < a * b⁻¹ ↔ b < a

full_name: mul_inv_lt_one_iff
code: @[to_additive]
theorem mul_inv_lt_one_iff : b * a⁻¹ < 1 ↔ b < a 
goal: b * a⁻¹ < 1 ↔ b < a

full_name: add_neg_neg_iff
code: @[to_additive]
theorem mul_inv_lt_one_iff : b * a⁻¹ < 1 ↔ b < a 
goal: b + -a < 0 ↔ b < a

full_name: inv_le_inv_iff
code: @[to_additive (attr := simp)]
theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a 
goal: a⁻¹ ≤ b⁻¹ ↔ b ≤ a

full_name: neg_le_neg_iff
code: @[to_additive (attr := simp)]
theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a 
goal: -a ≤ -b ↔ b ≤ a

full_name: mul_inv_le_inv_mul_iff
code: @[to_additive]
theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b 
goal: a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b

full_name: add_neg_le_neg_add_iff
code: @[to_additive]
theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b 
goal: a + -b ≤ -d + c ↔ d + a ≤ c + b

full_name: div_le_self_iff
code: @[to_additive (attr := simp)]
theorem div_le_self_iff (a : α) {b : α} : a / b ≤ a ↔ 1 ≤ b 
goal: a / b ≤ a ↔ 1 ≤ b

full_name: sub_le_self_iff
code: @[to_additive (attr := simp)]
theorem div_le_self_iff (a : α) {b : α} : a / b ≤ a ↔ 1 ≤ b 
goal: a - b ≤ a ↔ 0 ≤ b

full_name: le_div_self_iff
code: @[to_additive (attr := simp)]
theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 
goal: a ≤ a / b ↔ b ≤ 1

full_name: le_sub_self_iff
code: @[to_additive (attr := simp)]
theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 
goal: a ≤ a - b ↔ b ≤ 0

full_name: neg_lt_neg_iff
code: @[to_additive (attr := simp)]
theorem inv_lt_inv_iff : a⁻¹ < b⁻¹ ↔ b < a 
goal: -a < -b ↔ b < a

full_name: inv_lt_inv_iff
code: @[to_additive (attr := simp)]
theorem inv_lt_inv_iff : a⁻¹ < b⁻¹ ↔ b < a 
goal: a⁻¹ < b⁻¹ ↔ b < a

full_name: inv_lt'
code: @[to_additive neg_lt]
theorem inv_lt' : a⁻¹ < b ↔ b⁻¹ < a 
goal: a⁻¹ < b ↔ b⁻¹ < a

full_name: neg_lt
code: @[to_additive neg_lt]
theorem inv_lt' : a⁻¹ < b ↔ b⁻¹ < a 
goal: -a < b ↔ -b < a

full_name: lt_neg
code: @[to_additive lt_neg]
theorem lt_inv' : a < b⁻¹ ↔ b < a⁻¹ 
goal: a < -b ↔ b < -a

full_name: lt_inv'
code: @[to_additive lt_neg]
theorem lt_inv' : a < b⁻¹ ↔ b < a⁻¹ 
goal: a < b⁻¹ ↔ b < a⁻¹

full_name: mul_inv_lt_inv_mul_iff
code: @[to_additive]
theorem mul_inv_lt_inv_mul_iff : a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b 
goal: a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b

full_name: add_neg_lt_neg_add_iff
code: @[to_additive]
theorem mul_inv_lt_inv_mul_iff : a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b 
goal: a + -b < -d + c ↔ d + a < c + b

full_name: sub_lt_self_iff
code: @[to_additive (attr := simp)]
theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b 
goal: a - b < a ↔ 0 < b

full_name: div_lt_self_iff
code: @[to_additive (attr := simp)]
theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b 
goal: a / b < a ↔ 1 < b

full_name: Left.neg_le_self
code: @[to_additive]
theorem Left.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a 
goal: -a ≤ a

full_name: Left.inv_le_self
code: @[to_additive]
theorem Left.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a 
goal: a⁻¹ ≤ a

full_name: Left.self_le_inv
code: @[to_additive]
theorem Left.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ 
goal: a ≤ a⁻¹

full_name: Left.self_le_neg
code: @[to_additive]
theorem Left.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ 
goal: a ≤ -a

full_name: Left.neg_lt_self
code: @[to_additive]
theorem Left.inv_lt_self (h : 1 < a) : a⁻¹ < a 
goal: -a < a

full_name: Left.inv_lt_self
code: @[to_additive]
theorem Left.inv_lt_self (h : 1 < a) : a⁻¹ < a 
goal: a⁻¹ < a

full_name: Left.self_lt_neg
code: @[to_additive]
theorem Left.self_lt_inv (h : a < 1) : a < a⁻¹ 
goal: a < -a

full_name: Left.self_lt_inv
code: @[to_additive]
theorem Left.self_lt_inv (h : a < 1) : a < a⁻¹ 
goal: a < a⁻¹

full_name: Right.neg_le_self
code: @[to_additive]
theorem Right.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a 
goal: -a ≤ a

full_name: Right.inv_le_self
code: @[to_additive]
theorem Right.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a 
goal: a⁻¹ ≤ a

full_name: Right.self_le_inv
code: @[to_additive]
theorem Right.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ 
goal: a ≤ a⁻¹

full_name: Right.self_le_neg
code: @[to_additive]
theorem Right.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ 
goal: a ≤ -a

full_name: Right.inv_lt_self
code: @[to_additive]
theorem Right.inv_lt_self (h : 1 < a) : a⁻¹ < a 
goal: a⁻¹ < a

full_name: Right.neg_lt_self
code: @[to_additive]
theorem Right.inv_lt_self (h : 1 < a) : a⁻¹ < a 
goal: -a < a

full_name: Right.self_lt_inv
code: @[to_additive]
theorem Right.self_lt_inv (h : a < 1) : a < a⁻¹ 
goal: a < a⁻¹

full_name: Right.self_lt_neg
code: @[to_additive]
theorem Right.self_lt_inv (h : a < 1) : a < a⁻¹ 
goal: a < -a

full_name: inv_mul_le_iff_le_mul'
code: @[to_additive]
theorem inv_mul_le_iff_le_mul' : c⁻¹ * a ≤ b ↔ a ≤ b * c 
goal: c⁻¹ * a ≤ b ↔ a ≤ b * c

full_name: neg_add_le_iff_le_add'
code: @[to_additive]
theorem inv_mul_le_iff_le_mul' : c⁻¹ * a ≤ b ↔ a ≤ b * c 
goal: -c + a ≤ b ↔ a ≤ b + c

full_name: mul_inv_le_iff_le_mul'
code: @[to_additive]
theorem mul_inv_le_iff_le_mul' : a * b⁻¹ ≤ c ↔ a ≤ b * c 
goal: a * b⁻¹ ≤ c ↔ a ≤ b * c

full_name: add_neg_le_iff_le_add'
code: @[to_additive]
theorem mul_inv_le_iff_le_mul' : a * b⁻¹ ≤ c ↔ a ≤ b * c 
goal: a + -b ≤ c ↔ a ≤ b + c

full_name: mul_inv_le_mul_inv_iff'
code: @[to_additive add_neg_le_add_neg_iff]
theorem mul_inv_le_mul_inv_iff' : a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b 
goal: a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b

full_name: add_neg_le_add_neg_iff
code: @[to_additive add_neg_le_add_neg_iff]
theorem mul_inv_le_mul_inv_iff' : a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b 
goal: a + -b ≤ c + -d ↔ a + d ≤ c + b

full_name: inv_mul_lt_iff_lt_mul'
code: @[to_additive]
theorem inv_mul_lt_iff_lt_mul' : c⁻¹ * a < b ↔ a < b * c 
goal: c⁻¹ * a < b ↔ a < b * c

full_name: neg_add_lt_iff_lt_add'
code: @[to_additive]
theorem inv_mul_lt_iff_lt_mul' : c⁻¹ * a < b ↔ a < b * c 
goal: -c + a < b ↔ a < b + c

full_name: add_neg_lt_iff_le_add'
code: @[to_additive]
theorem mul_inv_lt_iff_le_mul' : a * b⁻¹ < c ↔ a < b * c 
goal: a + -b < c ↔ a < b + c

full_name: mul_inv_lt_iff_le_mul'
code: @[to_additive]
theorem mul_inv_lt_iff_le_mul' : a * b⁻¹ < c ↔ a < b * c 
goal: a * b⁻¹ < c ↔ a < b * c

full_name: add_neg_lt_add_neg_iff
code: @[to_additive add_neg_lt_add_neg_iff]
theorem mul_inv_lt_mul_inv_iff' : a * b⁻¹ < c * d⁻¹ ↔ a * d < c * b 
goal: a + -b < c + -d ↔ a + d < c + b

full_name: mul_inv_lt_mul_inv_iff'
code: @[to_additive add_neg_lt_add_neg_iff]
theorem mul_inv_lt_mul_inv_iff' : a * b⁻¹ < c * d⁻¹ ↔ a * d < c * b 
goal: a * b⁻¹ < c * d⁻¹ ↔ a * d < c * b

full_name: sub_le_sub_iff_right
code: @[to_additive]
theorem div_le_div_iff_right (c : α) : a / c ≤ b / c ↔ a ≤ b 
goal: a - c ≤ b - c ↔ a ≤ b

full_name: div_le_div_iff_right
code: @[to_additive]
theorem div_le_div_iff_right (c : α) : a / c ≤ b / c ↔ a ≤ b 
goal: a / c ≤ b / c ↔ a ≤ b

full_name: sub_le_sub_right
code: @[to_additive (attr := gcongr) sub_le_sub_right]
theorem div_le_div_right' (h : a ≤ b) (c : α) : a / c ≤ b / c 
goal: a - c ≤ b - c

full_name: div_le_div_right'
code: @[to_additive (attr := gcongr) sub_le_sub_right]
theorem div_le_div_right' (h : a ≤ b) (c : α) : a / c ≤ b / c 
goal: a / c ≤ b / c

full_name: sub_nonneg
code: @[to_additive (attr := simp) sub_nonneg]
theorem one_le_div' : 1 ≤ a / b ↔ b ≤ a 
goal: 0 ≤ a - b ↔ b ≤ a

full_name: one_le_div'
code: @[to_additive (attr := simp) sub_nonneg]
theorem one_le_div' : 1 ≤ a / b ↔ b ≤ a 
goal: 1 ≤ a / b ↔ b ≤ a

full_name: div_le_one'
code: @[to_additive sub_nonpos]
theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b 
goal: a / b ≤ 1 ↔ a ≤ b

full_name: sub_nonpos
code: @[to_additive sub_nonpos]
theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b 
goal: a - b ≤ 0 ↔ a ≤ b

full_name: le_div_iff_mul_le
code: @[to_additive]
theorem le_div_iff_mul_le : a ≤ c / b ↔ a * b ≤ c 
goal: a ≤ c / b ↔ a * b ≤ c

full_name: le_sub_iff_add_le
code: @[to_additive]
theorem le_div_iff_mul_le : a ≤ c / b ↔ a * b ≤ c 
goal: a ≤ c - b ↔ a + b ≤ c

full_name: div_le_iff_le_mul
code: @[to_additive]
theorem div_le_iff_le_mul : a / c ≤ b ↔ a ≤ b * c 
goal: a / c ≤ b ↔ a ≤ b * c

full_name: sub_le_iff_le_add
code: @[to_additive]
theorem div_le_iff_le_mul : a / c ≤ b ↔ a ≤ b * c 
goal: a - c ≤ b ↔ a ≤ b + c

full_name: AddGroup.toOrderedSub
code: instance (priority := 100) AddGroup.toOrderedSub {α : Type*} [AddGroup α] [LE α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] : OrderedSub α 
goal: OrderedSub α

full_name: div_le_div_iff_left
code: @[to_additive]
theorem div_le_div_iff_left (a : α) : a / b ≤ a / c ↔ c ≤ b 
goal: a / b ≤ a / c ↔ c ≤ b

full_name: sub_le_sub_iff_left
code: @[to_additive]
theorem div_le_div_iff_left (a : α) : a / b ≤ a / c ↔ c ≤ b 
goal: a - b ≤ a - c ↔ c ≤ b

full_name: sub_le_sub_left
code: @[to_additive (attr := gcongr) sub_le_sub_left]
theorem div_le_div_left' (h : a ≤ b) (c : α) : c / b ≤ c / a 
goal: c - b ≤ c - a

full_name: div_le_div_left'
code: @[to_additive (attr := gcongr) sub_le_sub_left]
theorem div_le_div_left' (h : a ≤ b) (c : α) : c / b ≤ c / a 
goal: c / b ≤ c / a

full_name: sub_le_sub_iff
code: @[to_additive sub_le_sub_iff]
theorem div_le_div_iff' : a / b ≤ c / d ↔ a * d ≤ c * b 
goal: a - b ≤ c - d ↔ a + d ≤ c + b

full_name: div_le_div_iff'
code: @[to_additive sub_le_sub_iff]
theorem div_le_div_iff' : a / b ≤ c / d ↔ a * d ≤ c * b 
goal: a / b ≤ c / d ↔ a * d ≤ c * b

full_name: le_div_iff_mul_le'
code: @[to_additive]
theorem le_div_iff_mul_le' : b ≤ c / a ↔ a * b ≤ c 
goal: b ≤ c / a ↔ a * b ≤ c

full_name: le_sub_iff_add_le'
code: @[to_additive]
theorem le_div_iff_mul_le' : b ≤ c / a ↔ a * b ≤ c 
goal: b ≤ c - a ↔ a + b ≤ c

full_name: div_le_iff_le_mul'
code: @[to_additive]
theorem div_le_iff_le_mul' : a / b ≤ c ↔ a ≤ b * c 
goal: a / b ≤ c ↔ a ≤ b * c

full_name: sub_le_iff_le_add'
code: @[to_additive]
theorem div_le_iff_le_mul' : a / b ≤ c ↔ a ≤ b * c 
goal: a - b ≤ c ↔ a ≤ b + c

full_name: inv_le_div_iff_le_mul
code: @[to_additive (attr := simp)]
theorem inv_le_div_iff_le_mul : b⁻¹ ≤ a / c ↔ c ≤ a * b 
goal: b⁻¹ ≤ a / c ↔ c ≤ a * b

full_name: neg_le_sub_iff_le_add
code: @[to_additive (attr := simp)]
theorem inv_le_div_iff_le_mul : b⁻¹ ≤ a / c ↔ c ≤ a * b 
goal: -b ≤ a - c ↔ c ≤ a + b

full_name: inv_le_div_iff_le_mul'
code: @[to_additive]
theorem inv_le_div_iff_le_mul' : a⁻¹ ≤ b / c ↔ c ≤ a * b 
goal: a⁻¹ ≤ b / c ↔ c ≤ a * b

full_name: neg_le_sub_iff_le_add'
code: @[to_additive]
theorem inv_le_div_iff_le_mul' : a⁻¹ ≤ b / c ↔ c ≤ a * b 
goal: -a ≤ b - c ↔ c ≤ a + b

full_name: sub_le_comm
code: @[to_additive]
theorem div_le_comm : a / b ≤ c ↔ a / c ≤ b 
goal: a - b ≤ c ↔ a - c ≤ b

full_name: div_le_comm
code: @[to_additive]
theorem div_le_comm : a / b ≤ c ↔ a / c ≤ b 
goal: a / b ≤ c ↔ a / c ≤ b

full_name: le_sub_comm
code: @[to_additive]
theorem le_div_comm : a ≤ b / c ↔ c ≤ b / a 
goal: a ≤ b - c ↔ c ≤ b - a

full_name: le_div_comm
code: @[to_additive]
theorem le_div_comm : a ≤ b / c ↔ c ≤ b / a 
goal: a ≤ b / c ↔ c ≤ b / a

full_name: div_le_div''
code: @[to_additive (attr := gcongr) sub_le_sub]
theorem div_le_div'' (hab : a ≤ b) (hcd : c ≤ d) : a / d ≤ b / c 
goal: a / d ≤ b / c

full_name: sub_le_sub
code: @[to_additive (attr := gcongr) sub_le_sub]
theorem div_le_div'' (hab : a ≤ b) (hcd : c ≤ d) : a / d ≤ b / c 
goal: a - d ≤ b - c

full_name: sub_lt_sub_iff_right
code: @[to_additive (attr := simp)]
theorem div_lt_div_iff_right (c : α) : a / c < b / c ↔ a < b 
goal: a - c < b - c ↔ a < b

full_name: div_lt_div_iff_right
code: @[to_additive (attr := simp)]
theorem div_lt_div_iff_right (c : α) : a / c < b / c ↔ a < b 
goal: a / c < b / c ↔ a < b

full_name: div_lt_div_right'
code: @[to_additive (attr := gcongr) sub_lt_sub_right]
theorem div_lt_div_right' (h : a < b) (c : α) : a / c < b / c 
goal: a / c < b / c

full_name: sub_lt_sub_right
code: @[to_additive (attr := gcongr) sub_lt_sub_right]
theorem div_lt_div_right' (h : a < b) (c : α) : a / c < b / c 
goal: a - c < b - c

full_name: one_lt_div'
code: @[to_additive (attr := simp) sub_pos]
theorem one_lt_div' : 1 < a / b ↔ b < a 
goal: 1 < a / b ↔ b < a

full_name: sub_pos
code: @[to_additive (attr := simp) sub_pos]
theorem one_lt_div' : 1 < a / b ↔ b < a 
goal: 0 < a - b ↔ b < a

full_name: sub_neg
code: @[to_additive (attr := simp) sub_neg "For `a - -b = a + b`, see `sub_neg_eq_add`."]
theorem div_lt_one' : a / b < 1 ↔ a < b 
goal: a - b < 0 ↔ a < b

full_name: div_lt_one'
code: @[to_additive (attr := simp) sub_neg "For `a - -b = a + b`, see `sub_neg_eq_add`."]
theorem div_lt_one' : a / b < 1 ↔ a < b 
goal: a / b < 1 ↔ a < b

full_name: lt_sub_iff_add_lt
code: @[to_additive]
theorem lt_div_iff_mul_lt : a < c / b ↔ a * b < c 
goal: a < c - b ↔ a + b < c

full_name: lt_div_iff_mul_lt
code: @[to_additive]
theorem lt_div_iff_mul_lt : a < c / b ↔ a * b < c 
goal: a < c / b ↔ a * b < c

full_name: div_lt_iff_lt_mul
code: @[to_additive]
theorem div_lt_iff_lt_mul : a / c < b ↔ a < b * c 
goal: a / c < b ↔ a < b * c

full_name: sub_lt_iff_lt_add
code: @[to_additive]
theorem div_lt_iff_lt_mul : a / c < b ↔ a < b * c 
goal: a - c < b ↔ a < b + c

full_name: div_lt_div_iff_left
code: @[to_additive (attr := simp)]
theorem div_lt_div_iff_left (a : α) : a / b < a / c ↔ c < b 
goal: a / b < a / c ↔ c < b

full_name: sub_lt_sub_iff_left
code: @[to_additive (attr := simp)]
theorem div_lt_div_iff_left (a : α) : a / b < a / c ↔ c < b 
goal: a - b < a - c ↔ c < b

full_name: inv_lt_div_iff_lt_mul
code: @[to_additive (attr := simp)]
theorem inv_lt_div_iff_lt_mul : a⁻¹ < b / c ↔ c < a * b 
goal: a⁻¹ < b / c ↔ c < a * b

full_name: neg_lt_sub_iff_lt_add
code: @[to_additive (attr := simp)]
theorem inv_lt_div_iff_lt_mul : a⁻¹ < b / c ↔ c < a * b 
goal: -a < b - c ↔ c < a + b

full_name: sub_lt_sub_left
code: @[to_additive (attr := gcongr) sub_lt_sub_left]
theorem div_lt_div_left' (h : a < b) (c : α) : c / b < c / a 
goal: c - b < c - a

full_name: div_lt_div_left'
code: @[to_additive (attr := gcongr) sub_lt_sub_left]
theorem div_lt_div_left' (h : a < b) (c : α) : c / b < c / a 
goal: c / b < c / a

full_name: sub_lt_sub_iff
code: @[to_additive sub_lt_sub_iff]
theorem div_lt_div_iff' : a / b < c / d ↔ a * d < c * b 
goal: a - b < c - d ↔ a + d < c + b

full_name: div_lt_div_iff'
code: @[to_additive sub_lt_sub_iff]
theorem div_lt_div_iff' : a / b < c / d ↔ a * d < c * b 
goal: a / b < c / d ↔ a * d < c * b

full_name: lt_div_iff_mul_lt'
code: @[to_additive]
theorem lt_div_iff_mul_lt' : b < c / a ↔ a * b < c 
goal: b < c / a ↔ a * b < c

full_name: lt_sub_iff_add_lt'
code: @[to_additive]
theorem lt_div_iff_mul_lt' : b < c / a ↔ a * b < c 
goal: b < c - a ↔ a + b < c

full_name: sub_lt_iff_lt_add'
code: @[to_additive]
theorem div_lt_iff_lt_mul' : a / b < c ↔ a < b * c 
goal: a - b < c ↔ a < b + c

full_name: div_lt_iff_lt_mul'
code: @[to_additive]
theorem div_lt_iff_lt_mul' : a / b < c ↔ a < b * c 
goal: a / b < c ↔ a < b * c

full_name: neg_lt_sub_iff_lt_add'
code: @[to_additive]
theorem inv_lt_div_iff_lt_mul' : b⁻¹ < a / c ↔ c < a * b 
goal: -b < a - c ↔ c < a + b

full_name: inv_lt_div_iff_lt_mul'
code: @[to_additive]
theorem inv_lt_div_iff_lt_mul' : b⁻¹ < a / c ↔ c < a * b 
goal: b⁻¹ < a / c ↔ c < a * b

full_name: sub_lt_comm
code: @[to_additive]
theorem div_lt_comm : a / b < c ↔ a / c < b 
goal: a - b < c ↔ a - c < b

full_name: div_lt_comm
code: @[to_additive]
theorem div_lt_comm : a / b < c ↔ a / c < b 
goal: a / b < c ↔ a / c < b

full_name: lt_div_comm
code: @[to_additive]
theorem lt_div_comm : a < b / c ↔ c < b / a 
goal: a < b / c ↔ c < b / a

full_name: lt_sub_comm
code: @[to_additive]
theorem lt_div_comm : a < b / c ↔ c < b / a 
goal: a < b - c ↔ c < b - a

full_name: sub_lt_sub
code: @[to_additive (attr := gcongr) sub_lt_sub]
theorem div_lt_div'' (hab : a < b) (hcd : c < d) : a / d < b / c 
goal: a - d < b - c

full_name: div_lt_div''
code: @[to_additive (attr := gcongr) sub_lt_sub]
theorem div_lt_div'' (hab : a < b) (hcd : c < d) : a / d < b / c 
goal: a / d < b / c

full_name: lt_or_lt_of_div_lt_div
code: @[to_additive] lemma lt_or_lt_of_div_lt_div : a / d < b / c → a < b ∨ c < d 
goal: a / d < b / c → a < b ∨ c < d

full_name: lt_or_lt_of_sub_lt_sub
code: @[to_additive] lemma lt_or_lt_of_div_lt_div : a / d < b / c → a < b ∨ c < d 
goal: a - d < b - c → a < b ∨ c < d

full_name: cmp_sub_zero
code: @[to_additive (attr := simp) cmp_sub_zero]
theorem cmp_div_one' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (a b : α) :
    cmp (a / b) 1 = cmp a b 
goal: cmp (a - b) 0 = cmp a b

full_name: cmp_div_one'
code: @[to_additive (attr := simp) cmp_sub_zero]
theorem cmp_div_one' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (a b : α) :
    cmp (a / b) 1 = cmp a b 
goal: cmp (a / b) 1 = cmp a b

full_name: le_of_forall_pos_lt_add
code: @[to_additive]
theorem le_of_forall_one_lt_lt_mul (h : ∀ ε : α, 1 < ε → a < b * ε) : a ≤ b 
goal: a ≤ b

full_name: le_of_forall_one_lt_lt_mul
code: @[to_additive]
theorem le_of_forall_one_lt_lt_mul (h : ∀ ε : α, 1 < ε → a < b * ε) : a ≤ b 
goal: a ≤ b

full_name: le_iff_forall_pos_lt_add
code: @[to_additive]
theorem le_iff_forall_one_lt_lt_mul : a ≤ b ↔ ∀ ε, 1 < ε → a < b * ε 
goal: a ≤ b ↔ ∀ (ε : α), 0 < ε → a < b + ε

full_name: le_iff_forall_one_lt_lt_mul
code: @[to_additive]
theorem le_iff_forall_one_lt_lt_mul : a ≤ b ↔ ∀ ε, 1 < ε → a < b * ε 
goal: a ≤ b ↔ ∀ (ε : α), 1 < ε → a < b * ε

full_name: sub_le_neg_add_iff
code: @[to_additive]
theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
    a / b ≤ a⁻¹ * b ↔ a ≤ b 
goal: a - b ≤ -a + b ↔ a ≤ b

full_name: div_le_inv_mul_iff
code: @[to_additive]
theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
    a / b ≤ a⁻¹ * b ↔ a ≤ b 
goal: a / b ≤ a⁻¹ * b ↔ a ≤ b

full_name: div_le_div_flip
code: @[to_additive]
theorem div_le_div_flip {α : Type*} [CommGroup α] [LinearOrder α]
    [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} : a / b ≤ b / a ↔ a ≤ b 
goal: a / b ≤ b / a ↔ a ≤ b

full_name: sub_le_sub_flip
code: @[to_additive]
theorem div_le_div_flip {α : Type*} [CommGroup α] [LinearOrder α]
    [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} : a / b ≤ b / a ↔ a ≤ b 
goal: a - b ≤ b - a ↔ a ≤ b

full_name: Monotone.inv
code: @[to_additive]
theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ 
goal: Antitone fun x => (f x)⁻¹

full_name: Monotone.neg
code: @[to_additive]
theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ 
goal: Antitone fun x => -f x

full_name: Antitone.inv
code: @[to_additive]
theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ 
goal: Monotone fun x => (f x)⁻¹

full_name: Antitone.neg
code: @[to_additive]
theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ 
goal: Monotone fun x => -f x

full_name: MonotoneOn.neg
code: @[to_additive]
theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹) s 
goal: AntitoneOn (fun x => -f x) s

full_name: MonotoneOn.inv
code: @[to_additive]
theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹) s 
goal: AntitoneOn (fun x => (f x)⁻¹) s

full_name: AntitoneOn.inv
code: @[to_additive]
theorem AntitoneOn.inv (hf : AntitoneOn f s) : MonotoneOn (fun x => (f x)⁻¹) s 
goal: MonotoneOn (fun x => (f x)⁻¹) s

full_name: AntitoneOn.neg
code: @[to_additive]
theorem AntitoneOn.inv (hf : AntitoneOn f s) : MonotoneOn (fun x => (f x)⁻¹) s 
goal: MonotoneOn (fun x => -f x) s

full_name: StrictMono.inv
code: @[to_additive]
theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ 
goal: StrictAnti fun x => (f x)⁻¹

full_name: StrictMono.neg
code: @[to_additive]
theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ 
goal: StrictAnti fun x => -f x

full_name: StrictAnti.neg
code: @[to_additive]
theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ 
goal: StrictMono fun x => -f x

full_name: StrictAnti.inv
code: @[to_additive]
theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ 
goal: StrictMono fun x => (f x)⁻¹

full_name: StrictMonoOn.neg
code: @[to_additive]
theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)⁻¹) s 
goal: StrictAntiOn (fun x => -f x) s

full_name: StrictMonoOn.inv
code: @[to_additive]
theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)⁻¹) s 
goal: StrictAntiOn (fun x => (f x)⁻¹) s

full_name: StrictAntiOn.inv
code: @[to_additive]
theorem StrictAntiOn.inv (hf : StrictAntiOn f s) : StrictMonoOn (fun x => (f x)⁻¹) s 
goal: StrictMonoOn (fun x => (f x)⁻¹) s

full_name: StrictAntiOn.neg
code: @[to_additive]
theorem StrictAntiOn.inv (hf : StrictAntiOn f s) : StrictMonoOn (fun x => (f x)⁻¹) s 
goal: StrictMonoOn (fun x => -f x) s