File: Mathlib/Data/ENNReal/Real.lean

full_name: ENNReal.toReal_add
code: theorem toReal_add (ha : a ≠ ∞) (hb : b ≠ ∞) : (a + b).toReal = a.toReal + b.toReal 
goal: (a + b).toReal = a.toReal + b.toReal

full_name: ENNReal.toReal_sub_of_le
code: theorem toReal_sub_of_le {a b : ℝ≥0∞} (h : b ≤ a) (ha : a ≠ ∞) :
    (a - b).toReal = a.toReal - b.toReal 
goal: (a - b).toReal = a.toReal - b.toReal

full_name: ENNReal.le_toReal_sub
code: theorem le_toReal_sub {a b : ℝ≥0∞} (hb : b ≠ ∞) : a.toReal - b.toReal ≤ (a - b).toReal 
goal: a.toReal - b.toReal ≤ (a - b).toReal

full_name: ENNReal.toReal_add_le
code: theorem toReal_add_le : (a + b).toReal ≤ a.toReal + b.toReal 
goal: (a + b).toReal ≤ a.toReal + b.toReal

full_name: ENNReal.ofReal_add
code: theorem ofReal_add {p q : ℝ} (hp : 0 ≤ p) (hq : 0 ≤ q) :
    ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q 
goal: ENNReal.ofReal (p + q) = ENNReal.ofReal p + ENNReal.ofReal q

full_name: ENNReal.ofReal_add_le
code: theorem ofReal_add_le {p q : ℝ} : ENNReal.ofReal (p + q) ≤ ENNReal.ofReal p + ENNReal.ofReal q 
goal: ENNReal.ofReal (p + q) ≤ ENNReal.ofReal p + ENNReal.ofReal q

full_name: ENNReal.toReal_le_toReal
code: @[simp]
theorem toReal_le_toReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toReal ≤ b.toReal ↔ a ≤ b 
goal: a.toReal ≤ b.toReal ↔ a ≤ b

full_name: ENNReal.toReal_mono
code: @[gcongr]
theorem toReal_mono (hb : b ≠ ∞) (h : a ≤ b) : a.toReal ≤ b.toReal 
goal: a.toReal ≤ b.toReal

full_name: ENNReal.toReal_mono'
code: theorem toReal_mono' (h : a ≤ b) (ht : b = ∞ → a = ∞) : a.toReal ≤ b.toReal 
goal: a.toReal ≤ b.toReal

full_name: ENNReal.toReal_lt_toReal
code: @[simp]
theorem toReal_lt_toReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toReal < b.toReal ↔ a < b 
goal: a.toReal < b.toReal ↔ a < b

full_name: ENNReal.toReal_strict_mono
code: @[gcongr]
theorem toReal_strict_mono (hb : b ≠ ∞) (h : a < b) : a.toReal < b.toReal 
goal: a.toReal < b.toReal

full_name: ENNReal.toNNReal_mono
code: @[gcongr]
theorem toNNReal_mono (hb : b ≠ ∞) (h : a ≤ b) : a.toNNReal ≤ b.toNNReal 
goal: a.toNNReal ≤ b.toNNReal

full_name: ENNReal.le_toNNReal_of_coe_le
code: theorem le_toNNReal_of_coe_le (h : p ≤ a) (ha : a ≠ ∞) : p ≤ a.toNNReal 
goal: p ≤ a.toNNReal

full_name: ENNReal.toReal_le_add'
code: /-- If `a ≤ b + c` and `a = ∞` whenever `b = ∞` or `c = ∞`, then
`ENNReal.toReal a ≤ ENNReal.toReal b + ENNReal.toReal c`. This lemma is useful to transfer
triangle-like inequalities from `ENNReal`s to `Real`s. -/
theorem toReal_le_add' (hle : a ≤ b + c) (hb : b = ∞ → a = ∞) (hc : c = ∞ → a = ∞) :
    a.toReal ≤ b.toReal + c.toReal 
goal: a.toReal ≤ b.toReal + c.toReal

full_name: ENNReal.toReal_le_add
code: /-- If `a ≤ b + c`, `b ≠ ∞`, and `c ≠ ∞`, then
`ENNReal.toReal a ≤ ENNReal.toReal b + ENNReal.toReal c`. This lemma is useful to transfer
triangle-like inequalities from `ENNReal`s to `Real`s. -/
theorem toReal_le_add (hle : a ≤ b + c) (hb : b ≠ ∞) (hc : c ≠ ∞) :
    a.toReal ≤ b.toReal + c.toReal 
goal: a.toReal ≤ b.toReal + c.toReal

full_name: ENNReal.toNNReal_le_toNNReal
code: @[simp]
theorem toNNReal_le_toNNReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toNNReal ≤ b.toNNReal ↔ a ≤ b 
goal: a.toNNReal ≤ b.toNNReal ↔ a ≤ b

full_name: ENNReal.toNNReal_strict_mono
code: @[gcongr]
theorem toNNReal_strict_mono (hb : b ≠ ∞) (h : a < b) : a.toNNReal < b.toNNReal 
goal: a.toNNReal < b.toNNReal

full_name: ENNReal.toNNReal_lt_toNNReal
code: @[simp]
theorem toNNReal_lt_toNNReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toNNReal < b.toNNReal ↔ a < b 
goal: a.toNNReal < b.toNNReal ↔ a < b

full_name: ENNReal.toNNReal_lt_of_lt_coe
code: theorem toNNReal_lt_of_lt_coe (h : a < p) : a.toNNReal < p 
goal: a.toNNReal < p

full_name: ENNReal.toReal_max
code: theorem toReal_max (hr : a ≠ ∞) (hp : b ≠ ∞) :
    ENNReal.toReal (max a b) = max (ENNReal.toReal a) (ENNReal.toReal b) 
goal: (max a b).toReal = max a.toReal b.toReal

full_name: ENNReal.toReal_min
code: theorem toReal_min {a b : ℝ≥0∞} (hr : a ≠ ∞) (hp : b ≠ ∞) :
    ENNReal.toReal (min a b) = min (ENNReal.toReal a) (ENNReal.toReal b) 
goal: (min a b).toReal = min a.toReal b.toReal

full_name: ENNReal.toReal_sup
code: theorem toReal_sup {a b : ℝ≥0∞} : a ≠ ∞ → b ≠ ∞ → (a ⊔ b).toReal = a.toReal ⊔ b.toReal 
goal: a ≠ ⊤ → b ≠ ⊤ → (a ⊔ b).toReal = a.toReal ⊔ b.toReal

full_name: ENNReal.toReal_inf
code: theorem toReal_inf {a b : ℝ≥0∞} : a ≠ ∞ → b ≠ ∞ → (a ⊓ b).toReal = a.toReal ⊓ b.toReal 
goal: a ≠ ⊤ → b ≠ ⊤ → (a ⊓ b).toReal = a.toReal ⊓ b.toReal

full_name: ENNReal.toNNReal_pos_iff
code: theorem toNNReal_pos_iff : 0 < a.toNNReal ↔ 0 < a ∧ a < ∞ 
goal: 0 < a.toNNReal ↔ 0 < a ∧ a < ⊤

full_name: ENNReal.toNNReal_pos
code: theorem toNNReal_pos {a : ℝ≥0∞} (ha₀ : a ≠ 0) (ha_top : a ≠ ∞) : 0 < a.toNNReal 
goal: 0 < a.toNNReal

full_name: ENNReal.toReal_pos_iff
code: theorem toReal_pos_iff : 0 < a.toReal ↔ 0 < a ∧ a < ∞ 
goal: 0 < a.toReal ↔ 0 < a ∧ a < ⊤

full_name: ENNReal.toReal_pos
code: theorem toReal_pos {a : ℝ≥0∞} (ha₀ : a ≠ 0) (ha_top : a ≠ ∞) : 0 < a.toReal 
goal: 0 < a.toReal

full_name: ENNReal.ofReal_le_ofReal
code: @[gcongr]
theorem ofReal_le_ofReal {p q : ℝ} (h : p ≤ q) : ENNReal.ofReal p ≤ ENNReal.ofReal q 
goal: ENNReal.ofReal p ≤ ENNReal.ofReal q

full_name: ENNReal.ofReal_le_of_le_toReal
code: theorem ofReal_le_of_le_toReal {a : ℝ} {b : ℝ≥0∞} (h : a ≤ ENNReal.toReal b) :
    ENNReal.ofReal a ≤ b 
goal: ENNReal.ofReal a ≤ b

full_name: ENNReal.ofReal_le_ofReal_iff
code: @[simp]
theorem ofReal_le_ofReal_iff {p q : ℝ} (h : 0 ≤ q) :
    ENNReal.ofReal p ≤ ENNReal.ofReal q ↔ p ≤ q 
goal: ENNReal.ofReal p ≤ ENNReal.ofReal q ↔ p ≤ q

full_name: ENNReal.ofReal_le_ofReal_iff'
code: lemma ofReal_le_ofReal_iff' {p q : ℝ} : ENNReal.ofReal p ≤ .ofReal q ↔ p ≤ q ∨ p ≤ 0 
goal: ENNReal.ofReal p ≤ ENNReal.ofReal q ↔ p ≤ q ∨ p ≤ 0

full_name: ENNReal.ofReal_lt_ofReal_iff'
code: lemma ofReal_lt_ofReal_iff' {p q : ℝ} : ENNReal.ofReal p < .ofReal q ↔ p < q ∧ 0 < q 
goal: ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q ∧ 0 < q

full_name: ENNReal.ofReal_eq_ofReal_iff
code: @[simp]
theorem ofReal_eq_ofReal_iff {p q : ℝ} (hp : 0 ≤ p) (hq : 0 ≤ q) :
    ENNReal.ofReal p = ENNReal.ofReal q ↔ p = q 
goal: ENNReal.ofReal p = ENNReal.ofReal q ↔ p = q

full_name: ENNReal.ofReal_lt_ofReal_iff
code: @[simp]
theorem ofReal_lt_ofReal_iff {p q : ℝ} (h : 0 < q) :
    ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q 
goal: ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q

full_name: ENNReal.ofReal_lt_ofReal_iff_of_nonneg
code: theorem ofReal_lt_ofReal_iff_of_nonneg {p q : ℝ} (hp : 0 ≤ p) :
    ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q 
goal: ENNReal.ofReal p < ENNReal.ofReal q ↔ p < q

full_name: ENNReal.ofReal_pos
code: @[simp]
theorem ofReal_pos {p : ℝ} : 0 < ENNReal.ofReal p ↔ 0 < p 
goal: 0 < ENNReal.ofReal p ↔ 0 < p

full_name: ENNReal.ofReal_eq_zero
code: @[simp]
theorem ofReal_eq_zero {p : ℝ} : ENNReal.ofReal p = 0 ↔ p ≤ 0 
goal: ENNReal.ofReal p = 0 ↔ p ≤ 0

full_name: ENNReal.zero_eq_ofReal
code: @[simp]
theorem zero_eq_ofReal {p : ℝ} : 0 = ENNReal.ofReal p ↔ p ≤ 0 
goal: 0 = ENNReal.ofReal p ↔ p ≤ 0

full_name: ENNReal.ofReal_lt_natCast
code: @[simp]
lemma ofReal_lt_natCast {p : ℝ} {n : ℕ} (hn : n ≠ 0) : ENNReal.ofReal p < n ↔ p < n 
goal: ENNReal.ofReal p < ↑n ↔ p < ↑n

full_name: ENNReal.ofReal_lt_one
code: @[simp]
lemma ofReal_lt_one {p : ℝ} : ENNReal.ofReal p < 1 ↔ p < 1 
goal: ENNReal.ofReal p < 1 ↔ p < 1

full_name: ENNReal.ofReal_lt_ofNat
code: @[simp]
lemma ofReal_lt_ofNat {p : ℝ} {n : ℕ} [n.AtLeastTwo] :
    ENNReal.ofReal p < no_index (OfNat.ofNat n) ↔ p < OfNat.ofNat n 
goal: ENNReal.ofReal p < OfNat.ofNat n ↔ p < OfNat.ofNat n

full_name: ENNReal.natCast_le_ofReal
code: @[simp]
lemma natCast_le_ofReal {n : ℕ} {p : ℝ} (hn : n ≠ 0) : n ≤ ENNReal.ofReal p ↔ n ≤ p 
goal: ↑n ≤ ENNReal.ofReal p ↔ ↑n ≤ p

full_name: ENNReal.one_le_ofReal
code: @[simp]
lemma one_le_ofReal {p : ℝ} : 1 ≤ ENNReal.ofReal p ↔ 1 ≤ p 
goal: 1 ≤ ENNReal.ofReal p ↔ 1 ≤ p

full_name: ENNReal.ofNat_le_ofReal
code: @[simp]
lemma ofNat_le_ofReal {n : ℕ} [n.AtLeastTwo] {p : ℝ} :
    no_index (OfNat.ofNat n) ≤ ENNReal.ofReal p ↔ OfNat.ofNat n ≤ p 
goal: OfNat.ofNat n ≤ ENNReal.ofReal p ↔ OfNat.ofNat n ≤ p

full_name: ENNReal.ofReal_le_natCast
code: @[simp]
lemma ofReal_le_natCast {r : ℝ} {n : ℕ} : ENNReal.ofReal r ≤ n ↔ r ≤ n 
goal: ENNReal.ofReal r ≤ ↑n ↔ r ≤ ↑n

full_name: ENNReal.ofReal_le_one
code: @[simp]
lemma ofReal_le_one {r : ℝ} : ENNReal.ofReal r ≤ 1 ↔ r ≤ 1 
goal: ENNReal.ofReal r ≤ 1 ↔ r ≤ 1

full_name: ENNReal.ofReal_le_ofNat
code: @[simp]
lemma ofReal_le_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    ENNReal.ofReal r ≤ no_index (OfNat.ofNat n) ↔ r ≤ OfNat.ofNat n 
goal: ENNReal.ofReal r ≤ OfNat.ofNat n ↔ r ≤ OfNat.ofNat n

full_name: ENNReal.natCast_lt_ofReal
code: @[simp]
lemma natCast_lt_ofReal {n : ℕ} {r : ℝ} : n < ENNReal.ofReal r ↔ n < r 
goal: ↑n < ENNReal.ofReal r ↔ ↑n < r

full_name: ENNReal.one_lt_ofReal
code: @[simp]
lemma one_lt_ofReal {r : ℝ} : 1 < ENNReal.ofReal r ↔ 1 < r 
goal: 1 < ENNReal.ofReal r ↔ 1 < r

full_name: ENNReal.ofNat_lt_ofReal
code: @[simp]
lemma ofNat_lt_ofReal {n : ℕ} [n.AtLeastTwo] {r : ℝ} :
    no_index (OfNat.ofNat n) < ENNReal.ofReal r ↔ OfNat.ofNat n < r 
goal: OfNat.ofNat n < ENNReal.ofReal r ↔ OfNat.ofNat n < r

full_name: ENNReal.ofReal_eq_natCast
code: @[simp]
lemma ofReal_eq_natCast {r : ℝ} {n : ℕ} (h : n ≠ 0) : ENNReal.ofReal r = n ↔ r = n 
goal: ENNReal.ofReal r = ↑n ↔ r = ↑n

full_name: ENNReal.ofReal_eq_one
code: @[simp]
lemma ofReal_eq_one {r : ℝ} : ENNReal.ofReal r = 1 ↔ r = 1 
goal: ENNReal.ofReal r = 1 ↔ r = 1

full_name: ENNReal.ofReal_eq_ofNat
code: @[simp]
lemma ofReal_eq_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    ENNReal.ofReal r = no_index (OfNat.ofNat n) ↔ r = OfNat.ofNat n 
goal: ENNReal.ofReal r = OfNat.ofNat n ↔ r = OfNat.ofNat n

full_name: ENNReal.ofReal_sub
code: theorem ofReal_sub (p : ℝ) {q : ℝ} (hq : 0 ≤ q) :
    ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q 
goal: ENNReal.ofReal (p - q) = ENNReal.ofReal p - ENNReal.ofReal q

full_name: ENNReal.ofReal_le_iff_le_toReal
code: theorem ofReal_le_iff_le_toReal {a : ℝ} {b : ℝ≥0∞} (hb : b ≠ ∞) :
    ENNReal.ofReal a ≤ b ↔ a ≤ ENNReal.toReal b 
goal: ENNReal.ofReal a ≤ b ↔ a ≤ b.toReal

full_name: ENNReal.ofReal_lt_iff_lt_toReal
code: theorem ofReal_lt_iff_lt_toReal {a : ℝ} {b : ℝ≥0∞} (ha : 0 ≤ a) (hb : b ≠ ∞) :
    ENNReal.ofReal a < b ↔ a < ENNReal.toReal b 
goal: ENNReal.ofReal a < b ↔ a < b.toReal

full_name: ENNReal.ofReal_lt_coe_iff
code: theorem ofReal_lt_coe_iff {a : ℝ} {b : ℝ≥0} (ha : 0 ≤ a) : ENNReal.ofReal a < b ↔ a < b 
goal: ENNReal.ofReal a < ↑b ↔ a < ↑b

full_name: ENNReal.le_ofReal_iff_toReal_le
code: theorem le_ofReal_iff_toReal_le {a : ℝ≥0∞} {b : ℝ} (ha : a ≠ ∞) (hb : 0 ≤ b) :
    a ≤ ENNReal.ofReal b ↔ ENNReal.toReal a ≤ b 
goal: a ≤ ENNReal.ofReal b ↔ a.toReal ≤ b

full_name: ENNReal.toReal_le_of_le_ofReal
code: theorem toReal_le_of_le_ofReal {a : ℝ≥0∞} {b : ℝ} (hb : 0 ≤ b) (h : a ≤ ENNReal.ofReal b) :
    ENNReal.toReal a ≤ b 
goal: a.toReal ≤ b

full_name: ENNReal.lt_ofReal_iff_toReal_lt
code: theorem lt_ofReal_iff_toReal_lt {a : ℝ≥0∞} {b : ℝ} (ha : a ≠ ∞) :
    a < ENNReal.ofReal b ↔ ENNReal.toReal a < b 
goal: a < ENNReal.ofReal b ↔ a.toReal < b

full_name: ENNReal.toReal_lt_of_lt_ofReal
code: theorem toReal_lt_of_lt_ofReal {b : ℝ} (h : a < ENNReal.ofReal b) : ENNReal.toReal a < b 
goal: a.toReal < b

full_name: ENNReal.ofReal_mul
code: theorem ofReal_mul {p q : ℝ} (hp : 0 ≤ p) :
    ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q 
goal: ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q

full_name: ENNReal.ofReal_mul'
code: theorem ofReal_mul' {p q : ℝ} (hq : 0 ≤ q) :
    ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q 
goal: ENNReal.ofReal (p * q) = ENNReal.ofReal p * ENNReal.ofReal q

full_name: ENNReal.ofReal_pow
code: theorem ofReal_pow {p : ℝ} (hp : 0 ≤ p) (n : ℕ) :
    ENNReal.ofReal (p ^ n) = ENNReal.ofReal p ^ n 
goal: ENNReal.ofReal (p ^ n) = ENNReal.ofReal p ^ n

full_name: ENNReal.ofReal_nsmul
code: theorem ofReal_nsmul {x : ℝ} {n : ℕ} : ENNReal.ofReal (n • x) = n • ENNReal.ofReal x 
goal: ENNReal.ofReal (n • x) = n • ENNReal.ofReal x

full_name: ENNReal.ofReal_inv_of_pos
code: theorem ofReal_inv_of_pos {x : ℝ} (hx : 0 < x) : ENNReal.ofReal x⁻¹ = (ENNReal.ofReal x)⁻¹ 
goal: ENNReal.ofReal x⁻¹ = (ENNReal.ofReal x)⁻¹

full_name: ENNReal.ofReal_div_of_pos
code: theorem ofReal_div_of_pos {x y : ℝ} (hy : 0 < y) :
    ENNReal.ofReal (x / y) = ENNReal.ofReal x / ENNReal.ofReal y 
goal: ENNReal.ofReal (x / y) = ENNReal.ofReal x / ENNReal.ofReal y

full_name: ENNReal.toNNReal_mul
code: @[simp]
theorem toNNReal_mul {a b : ℝ≥0∞} : (a * b).toNNReal = a.toNNReal * b.toNNReal 
goal: (a * b).toNNReal = a.toNNReal * b.toNNReal

full_name: ENNReal.toNNReal_mul_top
code: theorem toNNReal_mul_top (a : ℝ≥0∞) : ENNReal.toNNReal (a * ∞) = 0 
goal: (a * ⊤).toNNReal = 0

full_name: ENNReal.toNNReal_top_mul
code: theorem toNNReal_top_mul (a : ℝ≥0∞) : ENNReal.toNNReal (∞ * a) = 0 
goal: (⊤ * a).toNNReal = 0

full_name: ENNReal.smul_toNNReal
code: @[simp]
theorem smul_toNNReal (a : ℝ≥0) (b : ℝ≥0∞) : (a • b).toNNReal = a * b.toNNReal 
goal: (a • b).toNNReal = a * b.toNNReal

full_name: ENNReal.toNNRealHom
code: /-- `ENNReal.toNNReal` as a `MonoidHom`. -/
def toNNRealHom : ℝ≥0∞ →* ℝ≥0 
goal: ℝ≥0∞ →* ℝ≥0

full_name: ENNReal.toNNReal_pow
code: @[simp]
theorem toNNReal_pow (a : ℝ≥0∞) (n : ℕ) : (a ^ n).toNNReal = a.toNNReal ^ n 
goal: (a ^ n).toNNReal = a.toNNReal ^ n

full_name: ENNReal.toNNReal_prod
code: @[simp]
theorem toNNReal_prod {ι : Type*} {s : Finset ι} {f : ι → ℝ≥0∞} :
    (∏ i ∈ s, f i).toNNReal = ∏ i ∈ s, (f i).toNNReal 
goal: (∏ i ∈ s, f i).toNNReal = ∏ i ∈ s, (f i).toNNReal

full_name: ENNReal.toRealHom
code: /-- `ENNReal.toReal` as a `MonoidHom`. -/
def toRealHom : ℝ≥0∞ →* ℝ 
goal: ℝ≥0∞ →* ℝ

full_name: ENNReal.toReal_mul
code: @[simp]
theorem toReal_mul : (a * b).toReal = a.toReal * b.toReal 
goal: (a * b).toReal = a.toReal * b.toReal

full_name: ENNReal.toReal_nsmul
code: theorem toReal_nsmul (a : ℝ≥0∞) (n : ℕ) : (n • a).toReal = n • a.toReal 
goal: (n • a).toReal = n • a.toReal

full_name: ENNReal.toReal_pow
code: @[simp]
theorem toReal_pow (a : ℝ≥0∞) (n : ℕ) : (a ^ n).toReal = a.toReal ^ n 
goal: (a ^ n).toReal = a.toReal ^ n

full_name: ENNReal.toReal_prod
code: @[simp]
theorem toReal_prod {ι : Type*} {s : Finset ι} {f : ι → ℝ≥0∞} :
    (∏ i ∈ s, f i).toReal = ∏ i ∈ s, (f i).toReal 
goal: (∏ i ∈ s, f i).toReal = ∏ i ∈ s, (f i).toReal

full_name: ENNReal.toReal_ofReal_mul
code: theorem toReal_ofReal_mul (c : ℝ) (a : ℝ≥0∞) (h : 0 ≤ c) :
    ENNReal.toReal (ENNReal.ofReal c * a) = c * ENNReal.toReal a 
goal: (ENNReal.ofReal c * a).toReal = c * a.toReal

full_name: ENNReal.toReal_mul_top
code: theorem toReal_mul_top (a : ℝ≥0∞) : ENNReal.toReal (a * ∞) = 0 
goal: (a * ⊤).toReal = 0

full_name: ENNReal.toReal_top_mul
code: theorem toReal_top_mul (a : ℝ≥0∞) : ENNReal.toReal (∞ * a) = 0 
goal: (⊤ * a).toReal = 0

full_name: ENNReal.toReal_eq_toReal
code: theorem toReal_eq_toReal (ha : a ≠ ∞) (hb : b ≠ ∞) : a.toReal = b.toReal ↔ a = b 
goal: a.toReal = b.toReal ↔ a = b

full_name: ENNReal.toReal_smul
code: theorem toReal_smul (r : ℝ≥0) (s : ℝ≥0∞) : (r • s).toReal = r • s.toReal 
goal: (r • s).toReal = r • s.toReal

full_name: ENNReal.trichotomy
code: protected theorem trichotomy (p : ℝ≥0∞) : p = 0 ∨ p = ∞ ∨ 0 < p.toReal 
goal: p = 0 ∨ p = ⊤ ∨ 0 < p.toReal

full_name: ENNReal.trichotomy₂
code: protected theorem trichotomy₂ {p q : ℝ≥0∞} (hpq : p ≤ q) :
    p = 0 ∧ q = 0 ∨
      p = 0 ∧ q = ∞ ∨
        p = 0 ∧ 0 < q.toReal ∨
          p = ∞ ∧ q = ∞ ∨
            0 < p.toReal ∧ q = ∞ ∨ 0 < p.toReal ∧ 0 < q.toReal ∧ p.toReal ≤ q.toReal 
goal: p = 0 ∧ q = 0 ∨
  p = 0 ∧ q = ⊤ ∨
    p = 0 ∧ 0 < q.toReal ∨ p = ⊤ ∧ q = ⊤ ∨ 0 < p.toReal ∧ q = ⊤ ∨ 0 < p.toReal ∧ 0 < q.toReal ∧ p.toReal ≤ q.toReal

full_name: ENNReal.dichotomy
code: protected theorem dichotomy (p : ℝ≥0∞) [Fact (1 ≤ p)] : p = ∞ ∨ 1 ≤ p.toReal 
goal: p = ⊤ ∨ 1 ≤ p.toReal

full_name: ENNReal.toReal_pos_iff_ne_top
code: theorem toReal_pos_iff_ne_top (p : ℝ≥0∞) [Fact (1 ≤ p)] : 0 < p.toReal ↔ p ≠ ∞ 
goal: 0 < p.toReal ↔ p ≠ ⊤

full_name: ENNReal.toNNReal_inv
code: theorem toNNReal_inv (a : ℝ≥0∞) : a⁻¹.toNNReal = a.toNNReal⁻¹ 
goal: a⁻¹.toNNReal = a.toNNReal⁻¹

full_name: ENNReal.toNNReal_div
code: theorem toNNReal_div (a b : ℝ≥0∞) : (a / b).toNNReal = a.toNNReal / b.toNNReal 
goal: (a / b).toNNReal = a.toNNReal / b.toNNReal

full_name: ENNReal.toReal_inv
code: theorem toReal_inv (a : ℝ≥0∞) : a⁻¹.toReal = a.toReal⁻¹ 
goal: a⁻¹.toReal = a.toReal⁻¹

full_name: ENNReal.toReal_div
code: theorem toReal_div (a b : ℝ≥0∞) : (a / b).toReal = a.toReal / b.toReal 
goal: (a / b).toReal = a.toReal / b.toReal

full_name: ENNReal.ofReal_prod_of_nonneg
code: theorem ofReal_prod_of_nonneg {α : Type*} {s : Finset α} {f : α → ℝ} (hf : ∀ i, i ∈ s → 0 ≤ f i) :
    ENNReal.ofReal (∏ i ∈ s, f i) = ∏ i ∈ s, ENNReal.ofReal (f i) 
goal: ENNReal.ofReal (∏ i ∈ s, f i) = ∏ i ∈ s, ENNReal.ofReal (f i)

full_name: ENNReal.toNNReal_iInf
code: theorem toNNReal_iInf (hf : ∀ i, f i ≠ ∞) : (iInf f).toNNReal = ⨅ i, (f i).toNNReal 
goal: (iInf f).toNNReal = ⨅ i, (f i).toNNReal

full_name: ENNReal.toNNReal_sInf
code: theorem toNNReal_sInf (s : Set ℝ≥0∞) (hs : ∀ r ∈ s, r ≠ ∞) :
    (sInf s).toNNReal = sInf (ENNReal.toNNReal '' s) 
goal: (sInf s).toNNReal = sInf (ENNReal.toNNReal '' s)

full_name: ENNReal.toNNReal_iSup
code: theorem toNNReal_iSup (hf : ∀ i, f i ≠ ∞) : (iSup f).toNNReal = ⨆ i, (f i).toNNReal 
goal: (iSup f).toNNReal = ⨆ i, (f i).toNNReal

full_name: ENNReal.toNNReal_sSup
code: theorem toNNReal_sSup (s : Set ℝ≥0∞) (hs : ∀ r ∈ s, r ≠ ∞) :
    (sSup s).toNNReal = sSup (ENNReal.toNNReal '' s) 
goal: (sSup s).toNNReal = sSup (ENNReal.toNNReal '' s)

full_name: ENNReal.toReal_iInf
code: theorem toReal_iInf (hf : ∀ i, f i ≠ ∞) : (iInf f).toReal = ⨅ i, (f i).toReal 
goal: (iInf f).toReal = ⨅ i, (f i).toReal

full_name: ENNReal.toReal_sInf
code: theorem toReal_sInf (s : Set ℝ≥0∞) (hf : ∀ r ∈ s, r ≠ ∞) :
    (sInf s).toReal = sInf (ENNReal.toReal '' s) 
goal: (sInf s).toReal = sInf (ENNReal.toReal '' s)

full_name: ENNReal.toReal_iSup
code: theorem toReal_iSup (hf : ∀ i, f i ≠ ∞) : (iSup f).toReal = ⨆ i, (f i).toReal 
goal: (iSup f).toReal = ⨆ i, (f i).toReal

full_name: ENNReal.toReal_sSup
code: theorem toReal_sSup (s : Set ℝ≥0∞) (hf : ∀ r ∈ s, r ≠ ∞) :
    (sSup s).toReal = sSup (ENNReal.toReal '' s) 
goal: (sSup s).toReal = sSup (ENNReal.toReal '' s)

full_name: ENNReal.iInf_add
code: theorem iInf_add : iInf f + a = ⨅ i, f i + a 
goal: iInf f + a = ⨅ i, f i + a

full_name: ENNReal.iSup_sub
code: theorem iSup_sub : (⨆ i, f i) - a = ⨆ i, f i - a 
goal: (⨆ i, f i) - a = ⨆ i, f i - a

full_name: ENNReal.sub_iInf
code: theorem sub_iInf : (a - ⨅ i, f i) = ⨆ i, a - f i 
goal: a - ⨅ i, f i = ⨆ i, a - f i

full_name: ENNReal.sInf_add
code: theorem sInf_add {s : Set ℝ≥0∞} : sInf s + a = ⨅ b ∈ s, b + a 
goal: sInf s + a = ⨅ b ∈ s, b + a

full_name: ENNReal.add_iInf
code: theorem add_iInf {a : ℝ≥0∞} : a + iInf f = ⨅ b, a + f b 
goal: a + iInf f = ⨅ b, a + f b

full_name: ENNReal.iInf_add_iInf
code: theorem iInf_add_iInf (h : ∀ i j, ∃ k, f k + g k ≤ f i + g j) : iInf f + iInf g = ⨅ a, f a + g a 
goal: iInf f + iInf g = ⨅ a, f a + g a

full_name: ENNReal.iInf_sum
code: theorem iInf_sum {α : Type*} {f : ι → α → ℝ≥0∞} {s : Finset α} [Nonempty ι]
    (h : ∀ (t : Finset α) (i j : ι), ∃ k, ∀ a ∈ t, f k a ≤ f i a ∧ f k a ≤ f j a) :
    ⨅ i, ∑ a ∈ s, f i a = ∑ a ∈ s, ⨅ i, f i a 
goal: ⨅ i, ∑ a ∈ s, f i a = ∑ a ∈ s, ⨅ i, f i a

full_name: ENNReal.iInf_mul_of_ne
code: /-- If `x ≠ 0` and `x ≠ ∞`, then right multiplication by `x` maps infimum to infimum.
See also `ENNReal.iInf_mul` that assumes `[Nonempty ι]` but does not require `x ≠ 0`. -/
theorem iInf_mul_of_ne {ι} {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h0 : x ≠ 0) (h : x ≠ ∞) :
    iInf f * x = ⨅ i, f i * x 
goal: iInf f * x = ⨅ i, f i * x

full_name: ENNReal.iInf_mul
code: /-- If `x ≠ ∞`, then right multiplication by `x` maps infimum over a nonempty type to infimum. See
also `ENNReal.iInf_mul_of_ne` that assumes `x ≠ 0` but does not require `[Nonempty ι]`. -/
theorem iInf_mul {ι} [Nonempty ι] {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h : x ≠ ∞) :
    iInf f * x = ⨅ i, f i * x 
goal: iInf f * x = ⨅ i, f i * x

full_name: ENNReal.mul_iInf
code: /-- If `x ≠ ∞`, then left multiplication by `x` maps infimum over a nonempty type to infimum. See
also `ENNReal.mul_iInf_of_ne` that assumes `x ≠ 0` but does not require `[Nonempty ι]`. -/
theorem mul_iInf {ι} [Nonempty ι] {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h : x ≠ ∞) :
    x * iInf f = ⨅ i, x * f i 
goal: x * iInf f = ⨅ i, x * f i

full_name: ENNReal.mul_iInf_of_ne
code: /-- If `x ≠ 0` and `x ≠ ∞`, then left multiplication by `x` maps infimum to infimum.
See also `ENNReal.mul_iInf` that assumes `[Nonempty ι]` but does not require `x ≠ 0`. -/
theorem mul_iInf_of_ne {ι} {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h0 : x ≠ 0) (h : x ≠ ∞) :
    x * iInf f = ⨅ i, x * f i 
goal: x * iInf f = ⨅ i, x * f i

full_name: ENNReal.iSup_eq_zero
code: @[simp]
theorem iSup_eq_zero {ι : Sort*} {f : ι → ℝ≥0∞} : ⨆ i, f i = 0 ↔ ∀ i, f i = 0 
goal: ⨆ i, f i = 0 ↔ ∀ (i : ι), f i = 0

full_name: ENNReal.iSup_zero_eq_zero
code: @[simp]
theorem iSup_zero_eq_zero {ι : Sort*} : ⨆ _ : ι, (0 : ℝ≥0∞) = 0 
goal: ⨆ x, 0 = 0

full_name: ENNReal.sup_eq_zero
code: theorem sup_eq_zero {a b : ℝ≥0∞} : a ⊔ b = 0 ↔ a = 0 ∧ b = 0 
goal: a ⊔ b = 0 ↔ a = 0 ∧ b = 0

full_name: ENNReal.iSup_natCast
code: theorem iSup_natCast : ⨆ n : ℕ, (n : ℝ≥0∞) = ∞ 
goal: ⨆ n, ↑n = ⊤

full_name: Mathlib.Meta.Positivity.evalENNRealOfReal
code: /-- Extension for the `positivity` tactic: `ENNReal.ofReal`. -/
@[positivity ENNReal.ofReal _]
def evalENNRealOfReal : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt