File: Mathlib/Algebra/Order/Field/Basic.lean

full_name: OrderIso.mulLeft₀
code: /-- `Equiv.mulLeft₀` as an order_iso. -/
@[simps! (config := { simpRhs := true })]
def OrderIso.mulLeft₀ (a : α) (ha : 0 < a) : α ≃o α 
goal: α ≃o α

full_name: OrderIso.mulLeft₀_apply
code: /-- `Equiv.mulLeft₀` as an order_iso. -/
@[simps! (config := { simpRhs := true })]
def OrderIso.mulLeft₀ (a : α) (ha : 0 < a) : α ≃o α 
goal: (OrderIso.mulLeft₀ a ha) x = a * x

full_name: OrderIso.mulLeft₀_symm_apply
code: /-- `Equiv.mulLeft₀` as an order_iso. -/
@[simps! (config := { simpRhs := true })]
def OrderIso.mulLeft₀ (a : α) (ha : 0 < a) : α ≃o α 
goal: (RelIso.symm (OrderIso.mulLeft₀ a ha)) x = a⁻¹ * x

full_name: OrderIso.mulRight₀_symm_apply
code: /-- `Equiv.mulRight₀` as an order_iso. -/
@[simps! (config := { simpRhs := true })]
def OrderIso.mulRight₀ (a : α) (ha : 0 < a) : α ≃o α 
goal: (RelIso.symm (OrderIso.mulRight₀ a ha)) x = x * a⁻¹

full_name: OrderIso.mulRight₀
code: /-- `Equiv.mulRight₀` as an order_iso. -/
@[simps! (config := { simpRhs := true })]
def OrderIso.mulRight₀ (a : α) (ha : 0 < a) : α ≃o α 
goal: α ≃o α

full_name: OrderIso.mulRight₀_apply
code: /-- `Equiv.mulRight₀` as an order_iso. -/
@[simps! (config := { simpRhs := true })]
def OrderIso.mulRight₀ (a : α) (ha : 0 < a) : α ≃o α 
goal: (OrderIso.mulRight₀ a ha) x = x * a

full_name: le_div_iff
code: theorem le_div_iff (hc : 0 < c) : a ≤ b / c ↔ a * c ≤ b 
goal: a ≤ b / c ↔ a * c ≤ b

full_name: le_div_iff'
code: theorem le_div_iff' (hc : 0 < c) : a ≤ b / c ↔ c * a ≤ b 
goal: a ≤ b / c ↔ c * a ≤ b

full_name: div_le_iff
code: theorem div_le_iff (hb : 0 < b) : a / b ≤ c ↔ a ≤ c * b 
goal: a / b ≤ c ↔ a ≤ c * b

full_name: div_le_iff'
code: theorem div_le_iff' (hb : 0 < b) : a / b ≤ c ↔ a ≤ b * c 
goal: a / b ≤ c ↔ a ≤ b * c

full_name: div_le_comm₀
code: lemma div_le_comm₀ (hb : 0 < b) (hc : 0 < c) : a / b ≤ c ↔ a / c ≤ b 
goal: a / b ≤ c ↔ a / c ≤ b

full_name: lt_div_iff
code: theorem lt_div_iff (hc : 0 < c) : a < b / c ↔ a * c < b 
goal: a < b / c ↔ a * c < b

full_name: lt_div_iff'
code: theorem lt_div_iff' (hc : 0 < c) : a < b / c ↔ c * a < b 
goal: a < b / c ↔ c * a < b

full_name: div_lt_iff
code: theorem div_lt_iff (hc : 0 < c) : b / c < a ↔ b < a * c 
goal: b / c < a ↔ b < a * c

full_name: div_lt_iff'
code: theorem div_lt_iff' (hc : 0 < c) : b / c < a ↔ b < c * a 
goal: b / c < a ↔ b < c * a

full_name: div_lt_comm₀
code: lemma div_lt_comm₀ (hb : 0 < b) (hc : 0 < c) : a / b < c ↔ a / c < b 
goal: a / b < c ↔ a / c < b

full_name: inv_mul_le_iff
code: theorem inv_mul_le_iff (h : 0 < b) : b⁻¹ * a ≤ c ↔ a ≤ b * c 
goal: b⁻¹ * a ≤ c ↔ a ≤ b * c

full_name: inv_mul_le_iff'
code: theorem inv_mul_le_iff' (h : 0 < b) : b⁻¹ * a ≤ c ↔ a ≤ c * b 
goal: b⁻¹ * a ≤ c ↔ a ≤ c * b

full_name: mul_inv_le_iff
code: theorem mul_inv_le_iff (h : 0 < b) : a * b⁻¹ ≤ c ↔ a ≤ b * c 
goal: a * b⁻¹ ≤ c ↔ a ≤ b * c

full_name: mul_inv_le_iff'
code: theorem mul_inv_le_iff' (h : 0 < b) : a * b⁻¹ ≤ c ↔ a ≤ c * b 
goal: a * b⁻¹ ≤ c ↔ a ≤ c * b

full_name: div_self_le_one
code: theorem div_self_le_one (a : α) : a / a ≤ 1 
goal: a / a ≤ 1

full_name: inv_mul_lt_iff
code: theorem inv_mul_lt_iff (h : 0 < b) : b⁻¹ * a < c ↔ a < b * c 
goal: b⁻¹ * a < c ↔ a < b * c

full_name: inv_mul_lt_iff'
code: theorem inv_mul_lt_iff' (h : 0 < b) : b⁻¹ * a < c ↔ a < c * b 
goal: b⁻¹ * a < c ↔ a < c * b

full_name: mul_inv_lt_iff
code: theorem mul_inv_lt_iff (h : 0 < b) : a * b⁻¹ < c ↔ a < b * c 
goal: a * b⁻¹ < c ↔ a < b * c

full_name: mul_inv_lt_iff'
code: theorem mul_inv_lt_iff' (h : 0 < b) : a * b⁻¹ < c ↔ a < c * b 
goal: a * b⁻¹ < c ↔ a < c * b

full_name: inv_pos_le_iff_one_le_mul
code: theorem inv_pos_le_iff_one_le_mul (ha : 0 < a) : a⁻¹ ≤ b ↔ 1 ≤ b * a 
goal: a⁻¹ ≤ b ↔ 1 ≤ b * a

full_name: inv_pos_le_iff_one_le_mul'
code: theorem inv_pos_le_iff_one_le_mul' (ha : 0 < a) : a⁻¹ ≤ b ↔ 1 ≤ a * b 
goal: a⁻¹ ≤ b ↔ 1 ≤ a * b

full_name: inv_pos_lt_iff_one_lt_mul
code: theorem inv_pos_lt_iff_one_lt_mul (ha : 0 < a) : a⁻¹ < b ↔ 1 < b * a 
goal: a⁻¹ < b ↔ 1 < b * a

full_name: inv_pos_lt_iff_one_lt_mul'
code: theorem inv_pos_lt_iff_one_lt_mul' (ha : 0 < a) : a⁻¹ < b ↔ 1 < a * b 
goal: a⁻¹ < b ↔ 1 < a * b

full_name: div_le_of_nonneg_of_le_mul
code: /-- One direction of `div_le_iff` where `b` is allowed to be `0` (but `c` must be nonnegative) -/
theorem div_le_of_nonneg_of_le_mul (hb : 0 ≤ b) (hc : 0 ≤ c) (h : a ≤ c * b) : a / b ≤ c 
goal: a / b ≤ c

full_name: mul_le_of_nonneg_of_le_div
code: /-- One direction of `div_le_iff` where `c` is allowed to be `0` (but `b` must be nonnegative) -/
lemma mul_le_of_nonneg_of_le_div (hb : 0 ≤ b) (hc : 0 ≤ c) (h : a ≤ b / c) : a * c ≤ b 
goal: a * c ≤ b

full_name: div_le_one_of_le
code: theorem div_le_one_of_le (h : a ≤ b) (hb : 0 ≤ b) : a / b ≤ 1 
goal: a / b ≤ 1

full_name: mul_inv_le_one_of_le
code: lemma mul_inv_le_one_of_le (h : a ≤ b) (hb : 0 ≤ b) : a * b⁻¹ ≤ 1 
goal: a * b⁻¹ ≤ 1

full_name: inv_mul_le_one_of_le
code: lemma inv_mul_le_one_of_le (h : a ≤ b) (hb : 0 ≤ b) : b⁻¹ * a ≤ 1 
goal: b⁻¹ * a ≤ 1

full_name: inv_le_inv_of_le
code: @[gcongr]
theorem inv_le_inv_of_le (ha : 0 < a) (h : a ≤ b) : b⁻¹ ≤ a⁻¹ 
goal: b⁻¹ ≤ a⁻¹

full_name: inv_le_inv
code: /-- See `inv_le_inv_of_le` for the implication from right-to-left with one fewer assumption. -/
theorem inv_le_inv (ha : 0 < a) (hb : 0 < b) : a⁻¹ ≤ b⁻¹ ↔ b ≤ a 
goal: a⁻¹ ≤ b⁻¹ ↔ b ≤ a

full_name: inv_le
code: /-- In a linear ordered field, for positive `a` and `b` we have `a⁻¹ ≤ b ↔ b⁻¹ ≤ a`.
See also `inv_le_of_inv_le` for a one-sided implication with one fewer assumption. -/
theorem inv_le (ha : 0 < a) (hb : 0 < b) : a⁻¹ ≤ b ↔ b⁻¹ ≤ a 
goal: a⁻¹ ≤ b ↔ b⁻¹ ≤ a

full_name: inv_le_of_inv_le
code: theorem inv_le_of_inv_le (ha : 0 < a) (h : a⁻¹ ≤ b) : b⁻¹ ≤ a 
goal: b⁻¹ ≤ a

full_name: le_inv
code: theorem le_inv (ha : 0 < a) (hb : 0 < b) : a ≤ b⁻¹ ↔ b ≤ a⁻¹ 
goal: a ≤ b⁻¹ ↔ b ≤ a⁻¹

full_name: inv_lt_inv
code: /-- See `inv_lt_inv_of_lt` for the implication from right-to-left with one fewer assumption. -/
theorem inv_lt_inv (ha : 0 < a) (hb : 0 < b) : a⁻¹ < b⁻¹ ↔ b < a 
goal: a⁻¹ < b⁻¹ ↔ b < a

full_name: inv_lt_inv_of_lt
code: @[gcongr]
theorem inv_lt_inv_of_lt (hb : 0 < b) (h : b < a) : a⁻¹ < b⁻¹ 
goal: a⁻¹ < b⁻¹

full_name: inv_lt
code: /-- In a linear ordered field, for positive `a` and `b` we have `a⁻¹ < b ↔ b⁻¹ < a`.
See also `inv_lt_of_inv_lt` for a one-sided implication with one fewer assumption. -/
theorem inv_lt (ha : 0 < a) (hb : 0 < b) : a⁻¹ < b ↔ b⁻¹ < a 
goal: a⁻¹ < b ↔ b⁻¹ < a

full_name: inv_lt_of_inv_lt
code: theorem inv_lt_of_inv_lt (ha : 0 < a) (h : a⁻¹ < b) : b⁻¹ < a 
goal: b⁻¹ < a

full_name: lt_inv
code: theorem lt_inv (ha : 0 < a) (hb : 0 < b) : a < b⁻¹ ↔ b < a⁻¹ 
goal: a < b⁻¹ ↔ b < a⁻¹

full_name: inv_lt_one
code: theorem inv_lt_one (ha : 1 < a) : a⁻¹ < 1 
goal: a⁻¹ < 1

full_name: one_lt_inv
code: theorem one_lt_inv (h₁ : 0 < a) (h₂ : a < 1) : 1 < a⁻¹ 
goal: 1 < a⁻¹

full_name: inv_le_one
code: theorem inv_le_one (ha : 1 ≤ a) : a⁻¹ ≤ 1 
goal: a⁻¹ ≤ 1

full_name: one_le_inv
code: theorem one_le_inv (h₁ : 0 < a) (h₂ : a ≤ 1) : 1 ≤ a⁻¹ 
goal: 1 ≤ a⁻¹

full_name: inv_lt_one_iff_of_pos
code: theorem inv_lt_one_iff_of_pos (h₀ : 0 < a) : a⁻¹ < 1 ↔ 1 < a 
goal: a⁻¹ < 1 ↔ 1 < a

full_name: inv_lt_one_iff
code: theorem inv_lt_one_iff : a⁻¹ < 1 ↔ a ≤ 0 ∨ 1 < a 
goal: a⁻¹ < 1 ↔ a ≤ 0 ∨ 1 < a

full_name: one_lt_inv_iff
code: theorem one_lt_inv_iff : 1 < a⁻¹ ↔ 0 < a ∧ a < 1 
goal: 1 < a⁻¹ ↔ 0 < a ∧ a < 1

full_name: inv_le_one_iff
code: theorem inv_le_one_iff : a⁻¹ ≤ 1 ↔ a ≤ 0 ∨ 1 ≤ a 
goal: a⁻¹ ≤ 1 ↔ a ≤ 0 ∨ 1 ≤ a

full_name: one_le_inv_iff
code: theorem one_le_inv_iff : 1 ≤ a⁻¹ ↔ 0 < a ∧ a ≤ 1 
goal: 1 ≤ a⁻¹ ↔ 0 < a ∧ a ≤ 1

full_name: div_le_div_of_nonneg_right
code: @[mono, gcongr]
lemma div_le_div_of_nonneg_right (hab : a ≤ b) (hc : 0 ≤ c) : a / c ≤ b / c 
goal: a / c ≤ b / c

full_name: div_lt_div_of_pos_right
code: @[gcongr]
lemma div_lt_div_of_pos_right (h : a < b) (hc : 0 < c) : a / c < b / c 
goal: a / c < b / c

full_name: div_le_div_of_nonneg_left
code: @[gcongr]
lemma div_le_div_of_nonneg_left (ha : 0 ≤ a) (hc : 0 < c) (h : c ≤ b) : a / b ≤ a / c 
goal: a / b ≤ a / c

full_name: div_lt_div_of_pos_left
code: @[gcongr]
lemma div_lt_div_of_pos_left (ha : 0 < a) (hc : 0 < c) (h : c < b) : a / b < a / c 
goal: a / b < a / c

full_name: div_le_div_of_le
code: @[deprecated div_le_div_of_nonneg_right (since := "2024-02-16")]
lemma div_le_div_of_le (hc : 0 ≤ c) (hab : a ≤ b) : a / c ≤ b / c 
goal: a / c ≤ b / c

full_name: div_le_div_right
code: theorem div_le_div_right (hc : 0 < c) : a / c ≤ b / c ↔ a ≤ b 
goal: a / c ≤ b / c ↔ a ≤ b

full_name: div_lt_div_right
code: theorem div_lt_div_right (hc : 0 < c) : a / c < b / c ↔ a < b 
goal: a / c < b / c ↔ a < b

full_name: div_lt_div_left
code: theorem div_lt_div_left (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : a / b < a / c ↔ c < b 
goal: a / b < a / c ↔ c < b

full_name: div_le_div_left
code: theorem div_le_div_left (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : a / b ≤ a / c ↔ c ≤ b 
goal: a / b ≤ a / c ↔ c ≤ b

full_name: div_lt_div_iff
code: theorem div_lt_div_iff (b0 : 0 < b) (d0 : 0 < d) : a / b < c / d ↔ a * d < c * b 
goal: a / b < c / d ↔ a * d < c * b

full_name: div_le_div_iff
code: theorem div_le_div_iff (b0 : 0 < b) (d0 : 0 < d) : a / b ≤ c / d ↔ a * d ≤ c * b 
goal: a / b ≤ c / d ↔ a * d ≤ c * b

full_name: div_le_div
code: @[mono, gcongr]
theorem div_le_div (hc : 0 ≤ c) (hac : a ≤ c) (hd : 0 < d) (hbd : d ≤ b) : a / b ≤ c / d 
goal: a / b ≤ c / d

full_name: div_lt_div
code: @[gcongr]
theorem div_lt_div (hac : a < c) (hbd : d ≤ b) (c0 : 0 ≤ c) (d0 : 0 < d) : a / b < c / d 
goal: a / b < c / d

full_name: div_lt_div'
code: theorem div_lt_div' (hac : a ≤ c) (hbd : d < b) (c0 : 0 < c) (d0 : 0 < d) : a / b < c / d 
goal: a / b < c / d

full_name: div_le_self
code: theorem div_le_self (ha : 0 ≤ a) (hb : 1 ≤ b) : a / b ≤ a 
goal: a / b ≤ a

full_name: div_lt_self
code: theorem div_lt_self (ha : 0 < a) (hb : 1 < b) : a / b < a 
goal: a / b < a

full_name: le_div_self
code: theorem le_div_self (ha : 0 ≤ a) (hb₀ : 0 < b) (hb₁ : b ≤ 1) : a ≤ a / b 
goal: a ≤ a / b

full_name: one_le_div
code: theorem one_le_div (hb : 0 < b) : 1 ≤ a / b ↔ b ≤ a 
goal: 1 ≤ a / b ↔ b ≤ a

full_name: div_le_one
code: theorem div_le_one (hb : 0 < b) : a / b ≤ 1 ↔ a ≤ b 
goal: a / b ≤ 1 ↔ a ≤ b

full_name: one_lt_div
code: theorem one_lt_div (hb : 0 < b) : 1 < a / b ↔ b < a 
goal: 1 < a / b ↔ b < a

full_name: div_lt_one
code: theorem div_lt_one (hb : 0 < b) : a / b < 1 ↔ a < b 
goal: a / b < 1 ↔ a < b

full_name: one_div_le
code: theorem one_div_le (ha : 0 < a) (hb : 0 < b) : 1 / a ≤ b ↔ 1 / b ≤ a 
goal: 1 / a ≤ b ↔ 1 / b ≤ a

full_name: one_div_lt
code: theorem one_div_lt (ha : 0 < a) (hb : 0 < b) : 1 / a < b ↔ 1 / b < a 
goal: 1 / a < b ↔ 1 / b < a

full_name: le_one_div
code: theorem le_one_div (ha : 0 < a) (hb : 0 < b) : a ≤ 1 / b ↔ b ≤ 1 / a 
goal: a ≤ 1 / b ↔ b ≤ 1 / a

full_name: lt_one_div
code: theorem lt_one_div (ha : 0 < a) (hb : 0 < b) : a < 1 / b ↔ b < 1 / a 
goal: a < 1 / b ↔ b < 1 / a

full_name: one_div_le_one_div_of_le
code: theorem one_div_le_one_div_of_le (ha : 0 < a) (h : a ≤ b) : 1 / b ≤ 1 / a 
goal: 1 / b ≤ 1 / a

full_name: one_div_lt_one_div_of_lt
code: theorem one_div_lt_one_div_of_lt (ha : 0 < a) (h : a < b) : 1 / b < 1 / a 
goal: 1 / b < 1 / a

full_name: le_of_one_div_le_one_div
code: theorem le_of_one_div_le_one_div (ha : 0 < a) (h : 1 / a ≤ 1 / b) : b ≤ a 
goal: b ≤ a

full_name: lt_of_one_div_lt_one_div
code: theorem lt_of_one_div_lt_one_div (ha : 0 < a) (h : 1 / a < 1 / b) : b < a 
goal: b < a

full_name: one_div_le_one_div
code: /-- For the single implications with fewer assumptions, see `one_div_le_one_div_of_le` and
  `le_of_one_div_le_one_div` -/
theorem one_div_le_one_div (ha : 0 < a) (hb : 0 < b) : 1 / a ≤ 1 / b ↔ b ≤ a 
goal: 1 / a ≤ 1 / b ↔ b ≤ a

full_name: one_div_lt_one_div
code: /-- For the single implications with fewer assumptions, see `one_div_lt_one_div_of_lt` and
  `lt_of_one_div_lt_one_div` -/
theorem one_div_lt_one_div (ha : 0 < a) (hb : 0 < b) : 1 / a < 1 / b ↔ b < a 
goal: 1 / a < 1 / b ↔ b < a

full_name: one_lt_one_div
code: theorem one_lt_one_div (h1 : 0 < a) (h2 : a < 1) : 1 < 1 / a 
goal: 1 < 1 / a

full_name: one_le_one_div
code: theorem one_le_one_div (h1 : 0 < a) (h2 : a ≤ 1) : 1 ≤ 1 / a 
goal: 1 ≤ 1 / a

full_name: half_pos
code: theorem half_pos (h : 0 < a) : 0 < a / 2 
goal: 0 < a / 2

full_name: one_half_pos
code: theorem one_half_pos : (0 : α) < 1 / 2 
goal: 0 < 1 / 2

full_name: half_le_self_iff
code: @[simp]
theorem half_le_self_iff : a / 2 ≤ a ↔ 0 ≤ a 
goal: a / 2 ≤ a ↔ 0 ≤ a

full_name: half_lt_self_iff
code: @[simp]
theorem half_lt_self_iff : a / 2 < a ↔ 0 < a 
goal: a / 2 < a ↔ 0 < a

full_name: one_half_lt_one
code: theorem one_half_lt_one : (1 / 2 : α) < 1 
goal: 1 / 2 < 1

full_name: two_inv_lt_one
code: theorem two_inv_lt_one : (2⁻¹ : α) < 1 
goal: 2⁻¹ < 1

full_name: left_lt_add_div_two
code: theorem left_lt_add_div_two : a < (a + b) / 2 ↔ a < b 
goal: a < (a + b) / 2 ↔ a < b

full_name: add_div_two_lt_right
code: theorem add_div_two_lt_right : (a + b) / 2 < b ↔ a < b 
goal: (a + b) / 2 < b ↔ a < b

full_name: add_thirds
code: theorem add_thirds (a : α) : a / 3 + a / 3 + a / 3 = a 
goal: a / 3 + a / 3 + a / 3 = a

full_name: div_pos_iff_of_pos_left
code: @[simp] lemma div_pos_iff_of_pos_left (ha : 0 < a) : 0 < a / b ↔ 0 < b 
goal: 0 < a / b ↔ 0 < b

full_name: div_pos_iff_of_pos_right
code: @[simp] lemma div_pos_iff_of_pos_right (hb : 0 < b) : 0 < a / b ↔ 0 < a 
goal: 0 < a / b ↔ 0 < a

full_name: mul_le_mul_of_mul_div_le
code: theorem mul_le_mul_of_mul_div_le (h : a * (b / c) ≤ d) (hc : 0 < c) : b * a ≤ d * c 
goal: b * a ≤ d * c

full_name: div_mul_le_div_mul_of_div_le_div
code: theorem div_mul_le_div_mul_of_div_le_div (h : a / b ≤ c / d) (he : 0 ≤ e) :
    a / (b * e) ≤ c / (d * e) 
goal: a / (b * e) ≤ c / (d * e)

full_name: exists_pos_mul_lt
code: theorem exists_pos_mul_lt {a : α} (h : 0 < a) (b : α) : ∃ c : α, 0 < c ∧ b * c < a 
goal: ∃ c, 0 < c ∧ b * c < a

full_name: exists_pos_lt_mul
code: theorem exists_pos_lt_mul {a : α} (h : 0 < a) (b : α) : ∃ c : α, 0 < c ∧ b < c * a 
goal: ∃ c, 0 < c ∧ b < c * a

full_name: monotone_div_right_of_nonneg
code: lemma monotone_div_right_of_nonneg (ha : 0 ≤ a) : Monotone (· / a) 
goal: Monotone fun x => x / a

full_name: strictMono_div_right_of_pos
code: lemma strictMono_div_right_of_pos (ha : 0 < a) : StrictMono (· / a) 
goal: StrictMono fun x => x / a

full_name: Monotone.div_const
code: theorem Monotone.div_const {β : Type*} [Preorder β] {f : β → α} (hf : Monotone f) {c : α}
    (hc : 0 ≤ c) : Monotone fun x => f x / c 
goal: Monotone fun x => f x / c

full_name: StrictMono.div_const
code: theorem StrictMono.div_const {β : Type*} [Preorder β] {f : β → α} (hf : StrictMono f) {c : α}
    (hc : 0 < c) : StrictMono fun x => f x / c 
goal: StrictMono fun x => f x / c

full_name: LinearOrderedSemiField.toDenselyOrdered
code: instance (priority := 100) LinearOrderedSemiField.toDenselyOrdered : DenselyOrdered α 
goal: DenselyOrdered α

full_name: min_div_div_right
code: theorem min_div_div_right {c : α} (hc : 0 ≤ c) (a b : α) : min (a / c) (b / c) = min a b / c 
goal: min (a / c) (b / c) = min a b / c

full_name: max_div_div_right
code: theorem max_div_div_right {c : α} (hc : 0 ≤ c) (a b : α) : max (a / c) (b / c) = max a b / c 
goal: max (a / c) (b / c) = max a b / c

full_name: one_div_strictAntiOn
code: theorem one_div_strictAntiOn : StrictAntiOn (fun x : α => 1 / x) (Set.Ioi 0) 
goal: StrictAntiOn (fun x => 1 / x) (Set.Ioi 0)

full_name: one_div_pow_le_one_div_pow_of_le
code: theorem one_div_pow_le_one_div_pow_of_le (a1 : 1 ≤ a) {m n : ℕ} (mn : m ≤ n) :
    1 / a ^ n ≤ 1 / a ^ m 
goal: 1 / a ^ n ≤ 1 / a ^ m

full_name: one_div_pow_lt_one_div_pow_of_lt
code: theorem one_div_pow_lt_one_div_pow_of_lt (a1 : 1 < a) {m n : ℕ} (mn : m < n) :
    1 / a ^ n < 1 / a ^ m 
goal: 1 / a ^ n < 1 / a ^ m

full_name: one_div_pow_anti
code: theorem one_div_pow_anti (a1 : 1 ≤ a) : Antitone fun n : ℕ => 1 / a ^ n 
goal: Antitone fun n => 1 / a ^ n

full_name: one_div_pow_strictAnti
code: theorem one_div_pow_strictAnti (a1 : 1 < a) : StrictAnti fun n : ℕ => 1 / a ^ n 
goal: StrictAnti fun n => 1 / a ^ n

full_name: inv_strictAntiOn
code: theorem inv_strictAntiOn : StrictAntiOn (fun x : α => x⁻¹) (Set.Ioi 0) 
goal: StrictAntiOn (fun x => x⁻¹) (Set.Ioi 0)

full_name: inv_pow_le_inv_pow_of_le
code: theorem inv_pow_le_inv_pow_of_le (a1 : 1 ≤ a) {m n : ℕ} (mn : m ≤ n) : (a ^ n)⁻¹ ≤ (a ^ m)⁻¹ 
goal: (a ^ n)⁻¹ ≤ (a ^ m)⁻¹

full_name: inv_pow_lt_inv_pow_of_lt
code: theorem inv_pow_lt_inv_pow_of_lt (a1 : 1 < a) {m n : ℕ} (mn : m < n) : (a ^ n)⁻¹ < (a ^ m)⁻¹ 
goal: (a ^ n)⁻¹ < (a ^ m)⁻¹

full_name: inv_pow_anti
code: theorem inv_pow_anti (a1 : 1 ≤ a) : Antitone fun n : ℕ => (a ^ n)⁻¹ 
goal: Antitone fun n => (a ^ n)⁻¹

full_name: inv_pow_strictAnti
code: theorem inv_pow_strictAnti (a1 : 1 < a) : StrictAnti fun n : ℕ => (a ^ n)⁻¹ 
goal: StrictAnti fun n => (a ^ n)⁻¹

full_name: IsGLB.mul_left
code: theorem IsGLB.mul_left {s : Set α} (ha : 0 ≤ a) (hs : IsGLB s b) :
    IsGLB ((fun b => a * b) '' s) (a * b) 
goal: IsGLB ((fun b => a * b) '' s) (a * b)

full_name: IsGLB.mul_right
code: theorem IsGLB.mul_right {s : Set α} (ha : 0 ≤ a) (hs : IsGLB s b) :
    IsGLB ((fun b => b * a) '' s) (b * a) 
goal: IsGLB ((fun b => b * a) '' s) (b * a)

full_name: div_pos_iff
code: theorem div_pos_iff : 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: div_neg_iff
code: theorem div_neg_iff : 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: div_nonneg_iff
code: theorem div_nonneg_iff : 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: div_nonpos_iff
code: theorem div_nonpos_iff : 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: div_nonneg_of_nonpos
code: theorem div_nonneg_of_nonpos (ha : a ≤ 0) (hb : b ≤ 0) : 0 ≤ a / b 
goal: 0 ≤ a / b

full_name: div_pos_of_neg_of_neg
code: theorem div_pos_of_neg_of_neg (ha : a < 0) (hb : b < 0) : 0 < a / b 
goal: 0 < a / b

full_name: div_neg_of_neg_of_pos
code: theorem div_neg_of_neg_of_pos (ha : a < 0) (hb : 0 < b) : a / b < 0 
goal: a / b < 0

full_name: div_neg_of_pos_of_neg
code: theorem div_neg_of_pos_of_neg (ha : 0 < a) (hb : b < 0) : a / b < 0 
goal: a / b < 0

full_name: div_le_iff_of_neg
code: theorem div_le_iff_of_neg (hc : c < 0) : b / c ≤ a ↔ a * c ≤ b 
goal: b / c ≤ a ↔ a * c ≤ b

full_name: div_le_iff_of_neg'
code: theorem div_le_iff_of_neg' (hc : c < 0) : b / c ≤ a ↔ c * a ≤ b 
goal: b / c ≤ a ↔ c * a ≤ b

full_name: le_div_iff_of_neg
code: theorem le_div_iff_of_neg (hc : c < 0) : a ≤ b / c ↔ b ≤ a * c 
goal: a ≤ b / c ↔ b ≤ a * c

full_name: le_div_iff_of_neg'
code: theorem le_div_iff_of_neg' (hc : c < 0) : a ≤ b / c ↔ b ≤ c * a 
goal: a ≤ b / c ↔ b ≤ c * a

full_name: div_lt_iff_of_neg
code: theorem div_lt_iff_of_neg (hc : c < 0) : b / c < a ↔ a * c < b 
goal: b / c < a ↔ a * c < b

full_name: div_lt_iff_of_neg'
code: theorem div_lt_iff_of_neg' (hc : c < 0) : b / c < a ↔ c * a < b 
goal: b / c < a ↔ c * a < b

full_name: lt_div_iff_of_neg
code: theorem lt_div_iff_of_neg (hc : c < 0) : a < b / c ↔ b < a * c 
goal: a < b / c ↔ b < a * c

full_name: lt_div_iff_of_neg'
code: theorem lt_div_iff_of_neg' (hc : c < 0) : a < b / c ↔ b < c * a 
goal: a < b / c ↔ b < c * a

full_name: div_le_one_of_ge
code: theorem div_le_one_of_ge (h : b ≤ a) (hb : b ≤ 0) : a / b ≤ 1 
goal: a / b ≤ 1

full_name: inv_le_inv_of_neg
code: theorem inv_le_inv_of_neg (ha : a < 0) (hb : b < 0) : a⁻¹ ≤ b⁻¹ ↔ b ≤ a 
goal: a⁻¹ ≤ b⁻¹ ↔ b ≤ a

full_name: inv_le_of_neg
code: theorem inv_le_of_neg (ha : a < 0) (hb : b < 0) : a⁻¹ ≤ b ↔ b⁻¹ ≤ a 
goal: a⁻¹ ≤ b ↔ b⁻¹ ≤ a

full_name: le_inv_of_neg
code: theorem le_inv_of_neg (ha : a < 0) (hb : b < 0) : a ≤ b⁻¹ ↔ b ≤ a⁻¹ 
goal: a ≤ b⁻¹ ↔ b ≤ a⁻¹

full_name: inv_lt_inv_of_neg
code: theorem inv_lt_inv_of_neg (ha : a < 0) (hb : b < 0) : a⁻¹ < b⁻¹ ↔ b < a 
goal: a⁻¹ < b⁻¹ ↔ b < a

full_name: inv_lt_of_neg
code: theorem inv_lt_of_neg (ha : a < 0) (hb : b < 0) : a⁻¹ < b ↔ b⁻¹ < a 
goal: a⁻¹ < b ↔ b⁻¹ < a

full_name: lt_inv_of_neg
code: theorem lt_inv_of_neg (ha : a < 0) (hb : b < 0) : a < b⁻¹ ↔ b < a⁻¹ 
goal: a < b⁻¹ ↔ b < a⁻¹

full_name: sub_inv_antitoneOn_Ioi
code: theorem sub_inv_antitoneOn_Ioi :
    AntitoneOn (fun x ↦ (x-c)⁻¹) (Set.Ioi c) 
goal: AntitoneOn (fun x => (x - c)⁻¹) (Set.Ioi c)

full_name: sub_inv_antitoneOn_Iio
code: theorem sub_inv_antitoneOn_Iio :
    AntitoneOn (fun x ↦ (x-c)⁻¹) (Set.Iio c) 
goal: AntitoneOn (fun x => (x - c)⁻¹) (Set.Iio c)

full_name: sub_inv_antitoneOn_Icc_right
code: theorem sub_inv_antitoneOn_Icc_right (ha : c < a) :
    AntitoneOn (fun x ↦ (x-c)⁻¹) (Set.Icc a b) 
goal: AntitoneOn (fun x => (x - c)⁻¹) (Set.Icc a b)

full_name: sub_inv_antitoneOn_Icc_left
code: theorem sub_inv_antitoneOn_Icc_left (ha : b < c) :
    AntitoneOn (fun x ↦ (x-c)⁻¹) (Set.Icc a b) 
goal: AntitoneOn (fun x => (x - c)⁻¹) (Set.Icc a b)

full_name: inv_antitoneOn_Ioi
code: theorem inv_antitoneOn_Ioi :
    AntitoneOn (fun x : α ↦ x⁻¹) (Set.Ioi 0) 
goal: AntitoneOn (fun x => x⁻¹) (Set.Ioi 0)

full_name: inv_antitoneOn_Iio
code: theorem inv_antitoneOn_Iio :
    AntitoneOn (fun x : α ↦ x⁻¹) (Set.Iio 0) 
goal: AntitoneOn (fun x => x⁻¹) (Set.Iio 0)

full_name: inv_antitoneOn_Icc_right
code: theorem inv_antitoneOn_Icc_right (ha : 0 < a) :
    AntitoneOn (fun x : α ↦ x⁻¹) (Set.Icc a b) 
goal: AntitoneOn (fun x => x⁻¹) (Set.Icc a b)

full_name: inv_antitoneOn_Icc_left
code: theorem inv_antitoneOn_Icc_left (hb : b < 0) :
    AntitoneOn (fun x : α ↦ x⁻¹) (Set.Icc a b) 
goal: AntitoneOn (fun x => x⁻¹) (Set.Icc a b)

full_name: div_le_div_of_nonpos_of_le
code: theorem div_le_div_of_nonpos_of_le (hc : c ≤ 0) (h : b ≤ a) : a / c ≤ b / c 
goal: a / c ≤ b / c

full_name: div_lt_div_of_neg_of_lt
code: theorem div_lt_div_of_neg_of_lt (hc : c < 0) (h : b < a) : a / c < b / c 
goal: a / c < b / c

full_name: div_le_div_right_of_neg
code: theorem div_le_div_right_of_neg (hc : c < 0) : a / c ≤ b / c ↔ b ≤ a 
goal: a / c ≤ b / c ↔ b ≤ a

full_name: div_lt_div_right_of_neg
code: theorem div_lt_div_right_of_neg (hc : c < 0) : a / c < b / c ↔ b < a 
goal: a / c < b / c ↔ b < a

full_name: one_le_div_of_neg
code: theorem one_le_div_of_neg (hb : b < 0) : 1 ≤ a / b ↔ a ≤ b 
goal: 1 ≤ a / b ↔ a ≤ b

full_name: div_le_one_of_neg
code: theorem div_le_one_of_neg (hb : b < 0) : a / b ≤ 1 ↔ b ≤ a 
goal: a / b ≤ 1 ↔ b ≤ a

full_name: one_lt_div_of_neg
code: theorem one_lt_div_of_neg (hb : b < 0) : 1 < a / b ↔ a < b 
goal: 1 < a / b ↔ a < b

full_name: div_lt_one_of_neg
code: theorem div_lt_one_of_neg (hb : b < 0) : a / b < 1 ↔ b < a 
goal: a / b < 1 ↔ b < a

full_name: one_div_le_of_neg
code: theorem one_div_le_of_neg (ha : a < 0) (hb : b < 0) : 1 / a ≤ b ↔ 1 / b ≤ a 
goal: 1 / a ≤ b ↔ 1 / b ≤ a

full_name: one_div_lt_of_neg
code: theorem one_div_lt_of_neg (ha : a < 0) (hb : b < 0) : 1 / a < b ↔ 1 / b < a 
goal: 1 / a < b ↔ 1 / b < a

full_name: le_one_div_of_neg
code: theorem le_one_div_of_neg (ha : a < 0) (hb : b < 0) : a ≤ 1 / b ↔ b ≤ 1 / a 
goal: a ≤ 1 / b ↔ b ≤ 1 / a

full_name: lt_one_div_of_neg
code: theorem lt_one_div_of_neg (ha : a < 0) (hb : b < 0) : a < 1 / b ↔ b < 1 / a 
goal: a < 1 / b ↔ b < 1 / a

full_name: one_lt_div_iff
code: theorem one_lt_div_iff : 1 < a / b ↔ 0 < b ∧ b < a ∨ b < 0 ∧ a < b 
goal: 1 < a / b ↔ 0 < b ∧ b < a ∨ b < 0 ∧ a < b

full_name: one_le_div_iff
code: theorem one_le_div_iff : 1 ≤ a / b ↔ 0 < b ∧ b ≤ a ∨ b < 0 ∧ a ≤ b 
goal: 1 ≤ a / b ↔ 0 < b ∧ b ≤ a ∨ b < 0 ∧ a ≤ b

full_name: div_lt_one_iff
code: theorem div_lt_one_iff : a / b < 1 ↔ 0 < b ∧ a < b ∨ b = 0 ∨ b < 0 ∧ b < a 
goal: a / b < 1 ↔ 0 < b ∧ a < b ∨ b = 0 ∨ b < 0 ∧ b < a

full_name: div_le_one_iff
code: theorem div_le_one_iff : a / b ≤ 1 ↔ 0 < b ∧ a ≤ b ∨ b = 0 ∨ b < 0 ∧ b ≤ a 
goal: a / b ≤ 1 ↔ 0 < b ∧ a ≤ b ∨ b = 0 ∨ b < 0 ∧ b ≤ a

full_name: one_div_le_one_div_of_neg_of_le
code: theorem one_div_le_one_div_of_neg_of_le (hb : b < 0) (h : a ≤ b) : 1 / b ≤ 1 / a 
goal: 1 / b ≤ 1 / a

full_name: one_div_lt_one_div_of_neg_of_lt
code: theorem one_div_lt_one_div_of_neg_of_lt (hb : b < 0) (h : a < b) : 1 / b < 1 / a 
goal: 1 / b < 1 / a

full_name: le_of_neg_of_one_div_le_one_div
code: theorem le_of_neg_of_one_div_le_one_div (hb : b < 0) (h : 1 / a ≤ 1 / b) : b ≤ a 
goal: b ≤ a

full_name: lt_of_neg_of_one_div_lt_one_div
code: theorem lt_of_neg_of_one_div_lt_one_div (hb : b < 0) (h : 1 / a < 1 / b) : b < a 
goal: b < a

full_name: one_div_le_one_div_of_neg
code: /-- For the single implications with fewer assumptions, see `one_div_lt_one_div_of_neg_of_lt` and
  `lt_of_one_div_lt_one_div` -/
theorem one_div_le_one_div_of_neg (ha : a < 0) (hb : b < 0) : 1 / a ≤ 1 / b ↔ b ≤ a 
goal: 1 / a ≤ 1 / b ↔ b ≤ a

full_name: one_div_lt_one_div_of_neg
code: /-- For the single implications with fewer assumptions, see `one_div_lt_one_div_of_lt` and
  `lt_of_one_div_lt_one_div` -/
theorem one_div_lt_one_div_of_neg (ha : a < 0) (hb : b < 0) : 1 / a < 1 / b ↔ b < a 
goal: 1 / a < 1 / b ↔ b < a

full_name: one_div_lt_neg_one
code: theorem one_div_lt_neg_one (h1 : a < 0) (h2 : -1 < a) : 1 / a < -1 
goal: 1 / a < -1

full_name: one_div_le_neg_one
code: theorem one_div_le_neg_one (h1 : a < 0) (h2 : -1 ≤ a) : 1 / a ≤ -1 
goal: 1 / a ≤ -1

full_name: sub_self_div_two
code: theorem sub_self_div_two (a : α) : a - a / 2 = a / 2 
goal: a - a / 2 = a / 2

full_name: div_two_sub_self
code: theorem div_two_sub_self (a : α) : a / 2 - a = -(a / 2) 
goal: a / 2 - a = -(a / 2)

full_name: add_sub_div_two_lt
code: theorem add_sub_div_two_lt (h : a < b) : a + (b - a) / 2 < b 
goal: a + (b - a) / 2 < b

full_name: sub_one_div_inv_le_two
code: /-- An inequality involving `2`. -/
theorem sub_one_div_inv_le_two (a2 : 2 ≤ a) : (1 - 1 / a)⁻¹ ≤ 2 
goal: (1 - 1 / a)⁻¹ ≤ 2

full_name: IsLUB.mul_left
code: theorem IsLUB.mul_left {s : Set α} (ha : 0 ≤ a) (hs : IsLUB s b) :
    IsLUB ((fun b => a * b) '' s) (a * b) 
goal: IsLUB ((fun b => a * b) '' s) (a * b)

full_name: IsLUB.mul_right
code: theorem IsLUB.mul_right {s : Set α} (ha : 0 ≤ a) (hs : IsLUB s b) :
    IsLUB ((fun b => b * a) '' s) (b * a) 
goal: IsLUB ((fun b => b * a) '' s) (b * a)

full_name: mul_sub_mul_div_mul_neg_iff
code: theorem mul_sub_mul_div_mul_neg_iff (hc : c ≠ 0) (hd : d ≠ 0) :
    (a * d - b * c) / (c * d) < 0 ↔ a / c < b / d 
goal: (a * d - b * c) / (c * d) < 0 ↔ a / c < b / d

full_name: mul_sub_mul_div_mul_nonpos_iff
code: theorem mul_sub_mul_div_mul_nonpos_iff (hc : c ≠ 0) (hd : d ≠ 0) :
    (a * d - b * c) / (c * d) ≤ 0 ↔ a / c ≤ b / d 
goal: (a * d - b * c) / (c * d) ≤ 0 ↔ a / c ≤ b / d

full_name: exists_add_lt_and_pos_of_lt
code: theorem exists_add_lt_and_pos_of_lt (h : b < a) : ∃ c, b + c < a ∧ 0 < c 
goal: ∃ c, b + c < a ∧ 0 < c

full_name: le_of_forall_sub_le
code: theorem le_of_forall_sub_le (h : ∀ ε > 0, b - ε ≤ a) : b ≤ a 
goal: b ≤ a

full_name: mul_self_inj_of_nonneg
code: theorem mul_self_inj_of_nonneg (a0 : 0 ≤ a) (b0 : 0 ≤ b) : a * a = b * b ↔ a = b 
goal: a * a = b * b ↔ a = b

full_name: min_div_div_right_of_nonpos
code: theorem min_div_div_right_of_nonpos (hc : c ≤ 0) (a b : α) : min (a / c) (b / c) = max a b / c 
goal: min (a / c) (b / c) = max a b / c

full_name: max_div_div_right_of_nonpos
code: theorem max_div_div_right_of_nonpos (hc : c ≤ 0) (a b : α) : max (a / c) (b / c) = min a b / c 
goal: max (a / c) (b / c) = min a b / c

full_name: abs_inv
code: theorem abs_inv (a : α) : |a⁻¹| = |a|⁻¹ 
goal: |a⁻¹| = |a|⁻¹

full_name: abs_div
code: theorem abs_div (a b : α) : |a / b| = |a| / |b| 
goal: |a / b| = |a| / |b|

full_name: abs_one_div
code: theorem abs_one_div (a : α) : |1 / a| = 1 / |a| 
goal: |1 / a| = 1 / |a|

full_name: _private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.div_nonneg_of_pos_of_nonneg
code: private lemma div_nonneg_of_pos_of_nonneg (ha : 0 < a) (hb : 0 ≤ b) : 0 ≤ a / b 
goal: 0 ≤ a / b

full_name: _private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.div_nonneg_of_nonneg_of_pos
code: private lemma div_nonneg_of_nonneg_of_pos (ha : 0 ≤ a) (hb : 0 < b) : 0 ≤ a / b 
goal: 0 ≤ a / b

full_name: _private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.div_ne_zero_of_pos_of_ne_zero
code: private lemma div_ne_zero_of_pos_of_ne_zero (ha : 0 < a) (hb : b ≠ 0) : a / b ≠ 0 
goal: a / b ≠ 0

full_name: _private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.div_ne_zero_of_ne_zero_of_pos
code: private lemma div_ne_zero_of_ne_zero_of_pos (ha : a ≠ 0) (hb : 0 < b) : a / b ≠ 0 
goal: a / b ≠ 0

full_name: _private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.zpow_zero_pos
code: private lemma zpow_zero_pos (a : α) : 0 < a ^ (0 : ℤ) 
goal: 0 < a ^ 0

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

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

full_name: Mathlib.Meta.Positivity.evalPowZeroInt
code: /-- The `positivity` extension which identifies expressions of the form `a ^ (0:ℤ)`. -/
@[positivity _ ^ (0 : ℤ), Pow.pow _ (0 : ℤ)]
def evalPowZeroInt : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt