File: Mathlib/Data/ENNReal/Inv.lean

full_name: ENNReal.div_eq_inv_mul
code: protected theorem div_eq_inv_mul : a / b = b⁻¹ * a 
goal: a / b = b⁻¹ * a

full_name: ENNReal.inv_zero
code: @[simp] theorem inv_zero : (0 : ℝ≥0∞)⁻¹ = ∞ 
goal: 0⁻¹ = ⊤

full_name: ENNReal.inv_top
code: @[simp] theorem inv_top : ∞⁻¹ = 0 
goal: ⊤⁻¹ = 0

full_name: ENNReal.coe_inv_le
code: theorem coe_inv_le : (↑r⁻¹ : ℝ≥0∞) ≤ (↑r)⁻¹ 
goal: ↑r⁻¹ ≤ (↑r)⁻¹

full_name: ENNReal.coe_inv
code: @[simp, norm_cast]
theorem coe_inv (hr : r ≠ 0) : (↑r⁻¹ : ℝ≥0∞) = (↑r)⁻¹ 
goal: ↑r⁻¹ = (↑r)⁻¹

full_name: ENNReal.coe_inv_two
code: @[norm_cast]
theorem coe_inv_two : ((2⁻¹ : ℝ≥0) : ℝ≥0∞) = 2⁻¹ 
goal: ↑2⁻¹ = 2⁻¹

full_name: ENNReal.coe_div
code: @[simp, norm_cast]
theorem coe_div (hr : r ≠ 0) : (↑(p / r) : ℝ≥0∞) = p / r 
goal: ↑(p / r) = ↑p / ↑r

full_name: ENNReal.coe_div_le
code: lemma coe_div_le : ↑(p / r) ≤ (p / r : ℝ≥0∞) 
goal: ↑(p / r) ≤ ↑p / ↑r

full_name: ENNReal.div_zero
code: theorem div_zero (h : a ≠ 0) : a / 0 = ∞ 
goal: a / 0 = ⊤

full_name: ENNReal.instDivInvOneMonoid
code: instance : DivInvOneMonoid ℝ≥0∞ 
goal: DivInvOneMonoid ENNReal

full_name: ENNReal.inv_pow
code: protected theorem inv_pow : ∀ {a : ℝ≥0∞} {n : ℕ}, (a ^ n)⁻¹ = a⁻¹ ^ n
  
goal: (a ^ n)⁻¹ = a⁻¹ ^ n

full_name: ENNReal.mul_inv_cancel
code: protected theorem mul_inv_cancel (h0 : a ≠ 0) (ht : a ≠ ∞) : a * a⁻¹ = 1 
goal: a * a⁻¹ = 1

full_name: ENNReal.inv_mul_cancel
code: protected theorem inv_mul_cancel (h0 : a ≠ 0) (ht : a ≠ ∞) : a⁻¹ * a = 1 
goal: a⁻¹ * a = 1

full_name: ENNReal.div_mul_cancel
code: protected theorem div_mul_cancel (h0 : a ≠ 0) (hI : a ≠ ∞) : b / a * a = b 
goal: b / a * a = b

full_name: ENNReal.mul_div_cancel'
code: protected theorem mul_div_cancel' (h0 : a ≠ 0) (hI : a ≠ ∞) : a * (b / a) = b 
goal: a * (b / a) = b

full_name: ENNReal.mul_comm_div
code: protected theorem mul_comm_div : a / b * c = a * (c / b) 
goal: a / b * c = a * (c / b)

full_name: ENNReal.mul_div_right_comm
code: protected theorem mul_div_right_comm : a * b / c = a / c * b 
goal: a * b / c = a / c * b

full_name: ENNReal.instInvolutiveInv
code: instance : InvolutiveInv ℝ≥0∞ 
goal: InvolutiveInv ENNReal

full_name: ENNReal.inv_eq_one
code: @[simp] protected lemma inv_eq_one : a⁻¹ = 1 ↔ a = 1 
goal: a⁻¹ = 1 ↔ a = 1

full_name: ENNReal.inv_eq_top
code: @[simp] theorem inv_eq_top : a⁻¹ = ∞ ↔ a = 0 
goal: a⁻¹ = ⊤ ↔ a = 0

full_name: ENNReal.inv_ne_top
code: theorem inv_ne_top : a⁻¹ ≠ ∞ ↔ a ≠ 0 
goal: a⁻¹ ≠ ⊤ ↔ a ≠ 0

full_name: ENNReal.inv_lt_top
code: @[simp]
theorem inv_lt_top {x : ℝ≥0∞} : x⁻¹ < ∞ ↔ 0 < x 
goal: x⁻¹ < ⊤ ↔ 0 < x

full_name: ENNReal.div_lt_top
code: theorem div_lt_top {x y : ℝ≥0∞} (h1 : x ≠ ∞) (h2 : y ≠ 0) : x / y < ∞ 
goal: x / y < ⊤

full_name: ENNReal.inv_eq_zero
code: @[simp]
protected theorem inv_eq_zero : a⁻¹ = 0 ↔ a = ∞ 
goal: a⁻¹ = 0 ↔ a = ⊤

full_name: ENNReal.inv_ne_zero
code: protected theorem inv_ne_zero : a⁻¹ ≠ 0 ↔ a ≠ ∞ 
goal: a⁻¹ ≠ 0 ↔ a ≠ ⊤

full_name: ENNReal.div_pos
code: protected theorem div_pos (ha : a ≠ 0) (hb : b ≠ ∞) : 0 < a / b 
goal: 0 < a / b

full_name: ENNReal.inv_mul_le_iff
code: protected theorem inv_mul_le_iff {x y z : ℝ≥0∞} (h1 : x ≠ 0) (h2 : x ≠ ∞) :
    x⁻¹ * y ≤ z ↔ y ≤ x * z 
goal: x⁻¹ * y ≤ z ↔ y ≤ x * z

full_name: ENNReal.mul_inv_le_iff
code: protected theorem mul_inv_le_iff {x y z : ℝ≥0∞} (h1 : y ≠ 0) (h2 : y ≠ ∞) :
    x * y⁻¹ ≤ z ↔ x ≤ z * y 
goal: x * y⁻¹ ≤ z ↔ x ≤ z * y

full_name: ENNReal.div_le_iff
code: protected theorem div_le_iff {x y z : ℝ≥0∞} (h1 : y ≠ 0) (h2 : y ≠ ∞) :
    x / y ≤ z ↔ x ≤ z * y 
goal: x / y ≤ z ↔ x ≤ z * y

full_name: ENNReal.div_le_iff'
code: protected theorem div_le_iff' {x y z : ℝ≥0∞} (h1 : y ≠ 0) (h2 : y ≠ ∞) :
    x / y ≤ z ↔ x ≤ y * z 
goal: x / y ≤ z ↔ x ≤ y * z

full_name: ENNReal.mul_inv
code: protected theorem mul_inv {a b : ℝ≥0∞} (ha : a ≠ 0 ∨ b ≠ ∞) (hb : a ≠ ∞ ∨ b ≠ 0) :
    (a * b)⁻¹ = a⁻¹ * b⁻¹ 
goal: (a * b)⁻¹ = a⁻¹ * b⁻¹

full_name: ENNReal.mul_div_mul_left
code: protected theorem mul_div_mul_left (a b : ℝ≥0∞) (hc : c ≠ 0) (hc' : c ≠ ⊤) :
    c * a / (c * b) = a / b 
goal: c * a / (c * b) = a / b

full_name: ENNReal.mul_div_mul_right
code: protected theorem mul_div_mul_right (a b : ℝ≥0∞) (hc : c ≠ 0) (hc' : c ≠ ⊤) :
    a * c / (b * c) = a / b 
goal: a * c / (b * c) = a / b

full_name: ENNReal.sub_div
code: protected theorem sub_div (h : 0 < b → b < a → c ≠ 0) : (a - b) / c = a / c - b / c 
goal: (a - b) / c = a / c - b / c

full_name: ENNReal.inv_pos
code: @[simp]
protected theorem inv_pos : 0 < a⁻¹ ↔ a ≠ ∞ 
goal: 0 < a⁻¹ ↔ a ≠ ⊤

full_name: ENNReal.inv_strictAnti
code: theorem inv_strictAnti : StrictAnti (Inv.inv : ℝ≥0∞ → ℝ≥0∞) 
goal: StrictAnti Inv.inv

full_name: ENNReal.inv_lt_inv
code: @[simp]
protected theorem inv_lt_inv : a⁻¹ < b⁻¹ ↔ b < a 
goal: a⁻¹ < b⁻¹ ↔ b < a

full_name: ENNReal.inv_lt_iff_inv_lt
code: theorem inv_lt_iff_inv_lt : a⁻¹ < b ↔ b⁻¹ < a 
goal: a⁻¹ < b ↔ b⁻¹ < a

full_name: ENNReal.lt_inv_iff_lt_inv
code: theorem lt_inv_iff_lt_inv : a < b⁻¹ ↔ b < a⁻¹ 
goal: a < b⁻¹ ↔ b < a⁻¹

full_name: ENNReal.inv_le_inv
code: @[simp]
protected theorem inv_le_inv : a⁻¹ ≤ b⁻¹ ↔ b ≤ a 
goal: a⁻¹ ≤ b⁻¹ ↔ b ≤ a

full_name: ENNReal.inv_le_iff_inv_le
code: theorem inv_le_iff_inv_le : a⁻¹ ≤ b ↔ b⁻¹ ≤ a 
goal: a⁻¹ ≤ b ↔ b⁻¹ ≤ a

full_name: ENNReal.le_inv_iff_le_inv
code: theorem le_inv_iff_le_inv : a ≤ b⁻¹ ↔ b ≤ a⁻¹ 
goal: a ≤ b⁻¹ ↔ b ≤ a⁻¹

full_name: ENNReal.inv_le_inv'
code: @[gcongr] protected theorem inv_le_inv' (h : a ≤ b) : b⁻¹ ≤ a⁻¹ 
goal: b⁻¹ ≤ a⁻¹

full_name: ENNReal.inv_lt_inv'
code: @[gcongr] protected theorem inv_lt_inv' (h : a < b) : b⁻¹ < a⁻¹ 
goal: b⁻¹ < a⁻¹

full_name: ENNReal.inv_le_one
code: @[simp]
protected theorem inv_le_one : a⁻¹ ≤ 1 ↔ 1 ≤ a 
goal: a⁻¹ ≤ 1 ↔ 1 ≤ a

full_name: ENNReal.one_le_inv
code: protected theorem one_le_inv : 1 ≤ a⁻¹ ↔ a ≤ 1 
goal: 1 ≤ a⁻¹ ↔ a ≤ 1

full_name: ENNReal.inv_lt_one
code: @[simp]
protected theorem inv_lt_one : a⁻¹ < 1 ↔ 1 < a 
goal: a⁻¹ < 1 ↔ 1 < a

full_name: ENNReal.one_lt_inv
code: @[simp]
protected theorem one_lt_inv : 1 < a⁻¹ ↔ a < 1 
goal: 1 < a⁻¹ ↔ a < 1

full_name: OrderIso.invENNReal_apply
code: /-- The inverse map `fun x ↦ x⁻¹` is an order isomorphism between `ℝ≥0∞` and its `OrderDual` -/
@[simps! apply]
def _root_.OrderIso.invENNReal : ℝ≥0∞ ≃o ℝ≥0∞ᵒᵈ 
goal: ∀ (a : ENNReal), OrderIso.invENNReal a = (OrderDual.toDual a)⁻¹

full_name: OrderIso.invENNReal
code: /-- The inverse map `fun x ↦ x⁻¹` is an order isomorphism between `ℝ≥0∞` and its `OrderDual` -/
@[simps! apply]
def _root_.OrderIso.invENNReal : ℝ≥0∞ ≃o ℝ≥0∞ᵒᵈ 
goal: ENNReal ≃o ENNRealᵒᵈ

full_name: OrderIso.invENNReal_symm_apply
code: @[simp]
theorem _root_.OrderIso.invENNReal_symm_apply (a : ℝ≥0∞ᵒᵈ) :
    OrderIso.invENNReal.symm a = (OrderDual.ofDual a)⁻¹ 
goal: OrderIso.invENNReal.symm a = (OrderDual.ofDual a)⁻¹

full_name: ENNReal.div_top
code: @[simp] theorem div_top : a / ∞ = 0 
goal: a / ⊤ = 0

full_name: ENNReal.top_div
code: theorem top_div : ∞ / a = if a = ∞ then 0 else ∞ 
goal: ⊤ / a = if a = ⊤ then 0 else ⊤

full_name: ENNReal.top_div_of_ne_top
code: theorem top_div_of_ne_top (h : a ≠ ∞) : ∞ / a = ∞ 
goal: ⊤ / a = ⊤

full_name: ENNReal.top_div_coe
code: @[simp] theorem top_div_coe : ∞ / p = ∞ 
goal: ⊤ / ↑p = ⊤

full_name: ENNReal.top_div_of_lt_top
code: theorem top_div_of_lt_top (h : a < ∞) : ∞ / a = ∞ 
goal: ⊤ / a = ⊤

full_name: ENNReal.zero_div
code: @[simp] protected theorem zero_div : 0 / a = 0 
goal: 0 / a = 0

full_name: ENNReal.div_eq_top
code: theorem div_eq_top : a / b = ∞ ↔ a ≠ 0 ∧ b = 0 ∨ a = ∞ ∧ b ≠ ∞ 
goal: a / b = ⊤ ↔ a ≠ 0 ∧ b = 0 ∨ a = ⊤ ∧ b ≠ ⊤

full_name: ENNReal.le_div_iff_mul_le
code: protected theorem le_div_iff_mul_le (h0 : b ≠ 0 ∨ c ≠ 0) (ht : b ≠ ∞ ∨ c ≠ ∞) :
    a ≤ c / b ↔ a * b ≤ c 
goal: a ≤ c / b ↔ a * b ≤ c

full_name: ENNReal.div_le_iff_le_mul
code: protected theorem div_le_iff_le_mul (hb0 : b ≠ 0 ∨ c ≠ ∞) (hbt : b ≠ ∞ ∨ c ≠ 0) :
    a / b ≤ c ↔ a ≤ c * b 
goal: a / b ≤ c ↔ a ≤ c * b

full_name: ENNReal.lt_div_iff_mul_lt
code: protected theorem lt_div_iff_mul_lt (hb0 : b ≠ 0 ∨ c ≠ ∞) (hbt : b ≠ ∞ ∨ c ≠ 0) :
    c < a / b ↔ c * b < a 
goal: c < a / b ↔ c * b < a

full_name: ENNReal.div_le_of_le_mul
code: theorem div_le_of_le_mul (h : a ≤ b * c) : a / c ≤ b 
goal: a / c ≤ b

full_name: ENNReal.div_le_of_le_mul'
code: theorem div_le_of_le_mul' (h : a ≤ b * c) : a / b ≤ c 
goal: a / b ≤ c

full_name: ENNReal.div_self_le_one
code: @[simp] protected theorem div_self_le_one : a / a ≤ 1 
goal: a / a ≤ 1

full_name: ENNReal.mul_inv_le_one
code: @[simp] protected lemma mul_inv_le_one (a : ℝ≥0∞) : a * a⁻¹ ≤ 1 
goal: a * a⁻¹ ≤ 1

full_name: ENNReal.inv_mul_le_one
code: @[simp] protected lemma inv_mul_le_one (a : ℝ≥0∞) : a⁻¹ * a ≤ 1 
goal: a⁻¹ * a ≤ 1

full_name: ENNReal.mul_inv_ne_top
code: @[simp] lemma mul_inv_ne_top (a : ℝ≥0∞) : a * a⁻¹ ≠ ⊤ 
goal: a * a⁻¹ ≠ ⊤

full_name: ENNReal.inv_mul_ne_top
code: @[simp] lemma inv_mul_ne_top (a : ℝ≥0∞) : a⁻¹ * a ≠ ⊤ 
goal: a⁻¹ * a ≠ ⊤

full_name: ENNReal.mul_le_of_le_div
code: theorem mul_le_of_le_div (h : a ≤ b / c) : a * c ≤ b 
goal: a * c ≤ b

full_name: ENNReal.mul_le_of_le_div'
code: theorem mul_le_of_le_div' (h : a ≤ b / c) : c * a ≤ b 
goal: c * a ≤ b

full_name: ENNReal.div_lt_iff
code: protected theorem div_lt_iff (h0 : b ≠ 0 ∨ c ≠ 0) (ht : b ≠ ∞ ∨ c ≠ ∞) : c / b < a ↔ c < a * b 
goal: c / b < a ↔ c < a * b

full_name: ENNReal.mul_lt_of_lt_div
code: theorem mul_lt_of_lt_div (h : a < b / c) : a * c < b 
goal: a * c < b

full_name: ENNReal.mul_lt_of_lt_div'
code: theorem mul_lt_of_lt_div' (h : a < b / c) : c * a < b 
goal: c * a < b

full_name: ENNReal.div_lt_of_lt_mul
code: theorem div_lt_of_lt_mul (h : a < b * c) : a / c < b 
goal: a / c < b

full_name: ENNReal.div_lt_of_lt_mul'
code: theorem div_lt_of_lt_mul' (h : a < b * c) : a / b < c 
goal: a / b < c

full_name: ENNReal.inv_le_iff_le_mul
code: theorem inv_le_iff_le_mul (h₁ : b = ∞ → a ≠ 0) (h₂ : a = ∞ → b ≠ 0) : a⁻¹ ≤ b ↔ 1 ≤ a * b 
goal: a⁻¹ ≤ b ↔ 1 ≤ a * b

full_name: ENNReal.le_inv_iff_mul_le
code: @[simp 900]
theorem le_inv_iff_mul_le : a ≤ b⁻¹ ↔ a * b ≤ 1 
goal: a ≤ b⁻¹ ↔ a * b ≤ 1

full_name: ENNReal.div_le_div
code: @[gcongr] protected theorem div_le_div (hab : a ≤ b) (hdc : d ≤ c) : a / c ≤ b / d 
goal: a / c ≤ b / d

full_name: ENNReal.div_le_div_left
code: @[gcongr] protected theorem div_le_div_left (h : a ≤ b) (c : ℝ≥0∞) : c / b ≤ c / a 
goal: c / b ≤ c / a

full_name: ENNReal.div_le_div_right
code: @[gcongr] protected theorem div_le_div_right (h : a ≤ b) (c : ℝ≥0∞) : a / c ≤ b / c 
goal: a / c ≤ b / c

full_name: ENNReal.eq_inv_of_mul_eq_one_left
code: protected theorem eq_inv_of_mul_eq_one_left (h : a * b = 1) : a = b⁻¹ 
goal: a = b⁻¹

full_name: ENNReal.mul_le_iff_le_inv
code: theorem mul_le_iff_le_inv {a b r : ℝ≥0∞} (hr₀ : r ≠ 0) (hr₁ : r ≠ ∞) : r * a ≤ b ↔ a ≤ r⁻¹ * b 
goal: r * a ≤ b ↔ a ≤ r⁻¹ * b

full_name: ENNReal.instPosSMulStrictMonoNNReal
code: instance : PosSMulStrictMono ℝ≥0 ℝ≥0∞ 
goal: PosSMulStrictMono ℝ≥0 ENNReal

full_name: ENNReal.instSMulPosMonoNNReal
code: instance : SMulPosMono ℝ≥0 ℝ≥0∞ 
goal: SMulPosMono ℝ≥0 ENNReal

full_name: ENNReal.le_of_forall_nnreal_lt
code: theorem le_of_forall_nnreal_lt {x y : ℝ≥0∞} (h : ∀ r : ℝ≥0, ↑r < x → ↑r ≤ y) : x ≤ y 
goal: x ≤ y

full_name: ENNReal.le_of_forall_pos_nnreal_lt
code: theorem le_of_forall_pos_nnreal_lt {x y : ℝ≥0∞} (h : ∀ r : ℝ≥0, 0 < r → ↑r < x → ↑r ≤ y) : x ≤ y 
goal: x ≤ y

full_name: ENNReal.eq_top_of_forall_nnreal_le
code: theorem eq_top_of_forall_nnreal_le {x : ℝ≥0∞} (h : ∀ r : ℝ≥0, ↑r ≤ x) : x = ∞ 
goal: x = ⊤

full_name: ENNReal.add_div
code: protected theorem add_div : (a + b) / c = a / c + b / c 
goal: (a + b) / c = a / c + b / c

full_name: ENNReal.div_add_div_same
code: protected theorem div_add_div_same {a b c : ℝ≥0∞} : a / c + b / c = (a + b) / c 
goal: a / c + b / c = (a + b) / c

full_name: ENNReal.div_self
code: protected theorem div_self (h0 : a ≠ 0) (hI : a ≠ ∞) : a / a = 1 
goal: a / a = 1

full_name: ENNReal.mul_div_le
code: theorem mul_div_le : a * (b / a) ≤ b 
goal: a * (b / a) ≤ b

full_name: ENNReal.eq_div_iff
code: theorem eq_div_iff (ha : a ≠ 0) (ha' : a ≠ ∞) : b = c / a ↔ a * b = c 
goal: b = c / a ↔ a * b = c

full_name: ENNReal.div_eq_div_iff
code: protected theorem div_eq_div_iff (ha : a ≠ 0) (ha' : a ≠ ∞) (hb : b ≠ 0) (hb' : b ≠ ∞) :
    c / b = d / a ↔ a * c = b * d 
goal: c / b = d / a ↔ a * c = b * d

full_name: ENNReal.div_eq_one_iff
code: theorem div_eq_one_iff {a b : ℝ≥0∞} (hb₀ : b ≠ 0) (hb₁ : b ≠ ∞) : a / b = 1 ↔ a = b 
goal: a / b = 1 ↔ a = b

full_name: ENNReal.inv_two_add_inv_two
code: theorem inv_two_add_inv_two : (2 : ℝ≥0∞)⁻¹ + 2⁻¹ = 1 
goal: 2⁻¹ + 2⁻¹ = 1

full_name: ENNReal.inv_three_add_inv_three
code: theorem inv_three_add_inv_three : (3 : ℝ≥0∞)⁻¹ + 3⁻¹ + 3⁻¹ = 1 
goal: 3⁻¹ + 3⁻¹ + 3⁻¹ = 1

full_name: ENNReal.add_halves
code: @[simp]
protected theorem add_halves (a : ℝ≥0∞) : a / 2 + a / 2 = a 
goal: a / 2 + a / 2 = a

full_name: ENNReal.add_thirds
code: @[simp]
theorem add_thirds (a : ℝ≥0∞) : a / 3 + a / 3 + a / 3 = a 
goal: a / 3 + a / 3 + a / 3 = a

full_name: ENNReal.div_eq_zero_iff
code: @[simp] theorem div_eq_zero_iff : a / b = 0 ↔ a = 0 ∨ b = ∞ 
goal: a / b = 0 ↔ a = 0 ∨ b = ⊤

full_name: ENNReal.div_pos_iff
code: @[simp] theorem div_pos_iff : 0 < a / b ↔ a ≠ 0 ∧ b ≠ ∞ 
goal: 0 < a / b ↔ a ≠ 0 ∧ b ≠ ⊤

full_name: ENNReal.div_ne_zero
code: protected lemma div_ne_zero : a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ ⊤ 
goal: a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ ⊤

full_name: ENNReal.half_pos
code: protected theorem half_pos (h : a ≠ 0) : 0 < a / 2 
goal: 0 < a / 2

full_name: ENNReal.one_half_lt_one
code: protected theorem one_half_lt_one : (2⁻¹ : ℝ≥0∞) < 1 
goal: 2⁻¹ < 1

full_name: ENNReal.half_lt_self
code: protected theorem half_lt_self (hz : a ≠ 0) (ht : a ≠ ∞) : a / 2 < a 
goal: a / 2 < a

full_name: ENNReal.half_le_self
code: protected theorem half_le_self : a / 2 ≤ a 
goal: a / 2 ≤ a

full_name: ENNReal.sub_half
code: theorem sub_half (h : a ≠ ∞) : a - a / 2 = a / 2 
goal: a - a / 2 = a / 2

full_name: ENNReal.one_sub_inv_two
code: @[simp]
theorem one_sub_inv_two : (1 : ℝ≥0∞) - 2⁻¹ = 2⁻¹ 
goal: 1 - 2⁻¹ = 2⁻¹

full_name: ENNReal.orderIsoIicOneBirational
code: /-- The birational order isomorphism between `ℝ≥0∞` and the unit interval `Set.Iic (1 : ℝ≥0∞)`. -/
@[simps! apply_coe]
def orderIsoIicOneBirational : ℝ≥0∞ ≃o Iic (1 : ℝ≥0∞) 
goal: ENNReal ≃o ↑(Set.Iic 1)

full_name: ENNReal.orderIsoIicOneBirational_apply_coe
code: /-- The birational order isomorphism between `ℝ≥0∞` and the unit interval `Set.Iic (1 : ℝ≥0∞)`. -/
@[simps! apply_coe]
def orderIsoIicOneBirational : ℝ≥0∞ ≃o Iic (1 : ℝ≥0∞) 
goal: ↑(ENNReal.orderIsoIicOneBirational x) = (x⁻¹ + 1)⁻¹

full_name: ENNReal.orderIsoIicOneBirational_symm_apply
code: @[simp]
theorem orderIsoIicOneBirational_symm_apply (x : Iic (1 : ℝ≥0∞)) :
    orderIsoIicOneBirational.symm x = (x.1⁻¹ - 1)⁻¹ 
goal: ENNReal.orderIsoIicOneBirational.symm x = ((↑x)⁻¹ - 1)⁻¹

full_name: ENNReal.orderIsoIicCoe
code: /-- Order isomorphism between an initial interval in `ℝ≥0∞` and an initial interval in `ℝ≥0`. -/
@[simps! apply_coe]
def orderIsoIicCoe (a : ℝ≥0) : Iic (a : ℝ≥0∞) ≃o Iic a 
goal: ↑(Set.Iic ↑a) ≃o ↑(Set.Iic a)

full_name: ENNReal.orderIsoIicCoe_apply_coe
code: /-- Order isomorphism between an initial interval in `ℝ≥0∞` and an initial interval in `ℝ≥0`. -/
@[simps! apply_coe]
def orderIsoIicCoe (a : ℝ≥0) : Iic (a : ℝ≥0∞) ≃o Iic a 
goal: ∀ (a_1 : ↑(Set.Iic ↑a)), ↑((ENNReal.orderIsoIicCoe a) a_1) = (↑a_1).toNNReal

full_name: ENNReal.orderIsoIicCoe_symm_apply_coe
code: @[simp]
theorem orderIsoIicCoe_symm_apply_coe (a : ℝ≥0) (b : Iic a) :
    ((orderIsoIicCoe a).symm b : ℝ≥0∞) = b 
goal: ↑((ENNReal.orderIsoIicCoe a).symm b) = ↑↑b

full_name: ENNReal.orderIsoUnitIntervalBirational
code: /-- An order isomorphism between the extended nonnegative real numbers and the unit interval. -/
def orderIsoUnitIntervalBirational : ℝ≥0∞ ≃o Icc (0 : ℝ) 1 
goal: ENNReal ≃o ↑(Set.Icc 0 1)

full_name: ENNReal.orderIsoUnitIntervalBirational_apply_coe
code: @[simp]
theorem orderIsoUnitIntervalBirational_apply_coe (x : ℝ≥0∞) :
    (orderIsoUnitIntervalBirational x : ℝ) = (x⁻¹ + 1)⁻¹.toReal 
goal: ↑(ENNReal.orderIsoUnitIntervalBirational x) = (x⁻¹ + 1)⁻¹.toReal

full_name: ENNReal.exists_inv_nat_lt
code: theorem exists_inv_nat_lt {a : ℝ≥0∞} (h : a ≠ 0) : ∃ n : ℕ, (n : ℝ≥0∞)⁻¹ < a 
goal: ∃ n, (↑n)⁻¹ < a

full_name: ENNReal.exists_nat_pos_mul_gt
code: theorem exists_nat_pos_mul_gt (ha : a ≠ 0) (hb : b ≠ ∞) : ∃ n > 0, b < (n : ℕ) * a 
goal: ∃ n > 0, b < ↑n * a

full_name: ENNReal.exists_nat_mul_gt
code: theorem exists_nat_mul_gt (ha : a ≠ 0) (hb : b ≠ ∞) : ∃ n : ℕ, b < n * a 
goal: ∃ n, b < ↑n * a

full_name: ENNReal.exists_nat_pos_inv_mul_lt
code: theorem exists_nat_pos_inv_mul_lt (ha : a ≠ ∞) (hb : b ≠ 0) :
    ∃ n > 0, ((n : ℕ) : ℝ≥0∞)⁻¹ * a < b 
goal: ∃ n > 0, (↑n)⁻¹ * a < b

full_name: ENNReal.exists_nnreal_pos_mul_lt
code: theorem exists_nnreal_pos_mul_lt (ha : a ≠ ∞) (hb : b ≠ 0) : ∃ n > 0, ↑(n : ℝ≥0) * a < b 
goal: ∃ n > 0, ↑n * a < b

full_name: ENNReal.exists_inv_two_pow_lt
code: theorem exists_inv_two_pow_lt (ha : a ≠ 0) : ∃ n : ℕ, 2⁻¹ ^ n < a 
goal: ∃ n, 2⁻¹ ^ n < a

full_name: ENNReal.coe_zpow
code: @[simp, norm_cast]
theorem coe_zpow (hr : r ≠ 0) (n : ℤ) : (↑(r ^ n) : ℝ≥0∞) = (r : ℝ≥0∞) ^ n 
goal: ↑(r ^ n) = ↑r ^ n

full_name: ENNReal.zpow_pos
code: theorem zpow_pos (ha : a ≠ 0) (h'a : a ≠ ∞) (n : ℤ) : 0 < a ^ n 
goal: 0 < a ^ n

full_name: ENNReal.zpow_lt_top
code: theorem zpow_lt_top (ha : a ≠ 0) (h'a : a ≠ ∞) (n : ℤ) : a ^ n < ∞ 
goal: a ^ n < ⊤

full_name: ENNReal.exists_mem_Ico_zpow
code: theorem exists_mem_Ico_zpow {x y : ℝ≥0∞} (hx : x ≠ 0) (h'x : x ≠ ∞) (hy : 1 < y) (h'y : y ≠ ⊤) :
    ∃ n : ℤ, x ∈ Ico (y ^ n) (y ^ (n + 1)) 
goal: ∃ n, x ∈ Set.Ico (y ^ n) (y ^ (n + 1))

full_name: ENNReal.exists_mem_Ioc_zpow
code: theorem exists_mem_Ioc_zpow {x y : ℝ≥0∞} (hx : x ≠ 0) (h'x : x ≠ ∞) (hy : 1 < y) (h'y : y ≠ ⊤) :
    ∃ n : ℤ, x ∈ Ioc (y ^ n) (y ^ (n + 1)) 
goal: ∃ n, x ∈ Set.Ioc (y ^ n) (y ^ (n + 1))

full_name: ENNReal.Ioo_zero_top_eq_iUnion_Ico_zpow
code: theorem Ioo_zero_top_eq_iUnion_Ico_zpow {y : ℝ≥0∞} (hy : 1 < y) (h'y : y ≠ ⊤) :
    Ioo (0 : ℝ≥0∞) (∞ : ℝ≥0∞) = ⋃ n : ℤ, Ico (y ^ n) (y ^ (n + 1)) 
goal: Set.Ioo 0 ⊤ = ⋃ n, Set.Ico (y ^ n) (y ^ (n + 1))

full_name: ENNReal.zpow_le_of_le
code: @[gcongr]
theorem zpow_le_of_le {x : ℝ≥0∞} (hx : 1 ≤ x) {a b : ℤ} (h : a ≤ b) : x ^ a ≤ x ^ b 
goal: x ^ a ≤ x ^ b

full_name: ENNReal.monotone_zpow
code: theorem monotone_zpow {x : ℝ≥0∞} (hx : 1 ≤ x) : Monotone ((x ^ ·) : ℤ → ℝ≥0∞) 
goal: Monotone fun x_1 => x ^ x_1

full_name: ENNReal.zpow_add
code: protected theorem zpow_add {x : ℝ≥0∞} (hx : x ≠ 0) (h'x : x ≠ ∞) (m n : ℤ) :
    x ^ (m + n) = x ^ m * x ^ n 
goal: x ^ (m + n) = x ^ m * x ^ n