File: Mathlib/Data/ENNReal/Operations.lean

full_name: ENNReal.mul_lt_mul
code: @[mono, gcongr]
theorem mul_lt_mul (ac : a < c) (bd : b < d) : a * b < c * d 
goal: a * b < c * d

full_name: ENNReal.mul_left_mono
code: theorem mul_left_mono : Monotone (a * ·) 
goal: Monotone fun x => a * x

full_name: ENNReal.mul_right_mono
code: theorem mul_right_mono : Monotone (· * a) 
goal: Monotone fun x => x * a

full_name: ENNReal.pow_strictMono
code: theorem pow_strictMono : ∀ {n : ℕ}, n ≠ 0 → StrictMono fun x : ℝ≥0∞ => x ^ n
  
goal: n ≠ 0 → StrictMono fun x => x ^ n

full_name: ENNReal.pow_lt_pow_left
code: @[gcongr] protected theorem pow_lt_pow_left (h : a < b) {n : ℕ} (hn : n ≠ 0) :
    a ^ n < b ^ n 
goal: a ^ n < b ^ n

full_name: ENNReal.max_mul
code: theorem max_mul : max a b * c = max (a * c) (b * c) 
goal: max a b * c = max (a * c) (b * c)

full_name: ENNReal.mul_max
code: theorem mul_max : a * max b c = max (a * b) (a * c) 
goal: a * max b c = max (a * b) (a * c)

full_name: ENNReal.mul_left_strictMono
code: theorem mul_left_strictMono (h0 : a ≠ 0) (hinf : a ≠ ∞) : StrictMono (a * ·) 
goal: StrictMono fun x => a * x

full_name: ENNReal.mul_lt_mul_left'
code: @[gcongr] protected theorem mul_lt_mul_left' (h0 : a ≠ 0) (hinf : a ≠ ⊤) (bc : b < c) :
    a * b < a * c 
goal: a * b < a * c

full_name: ENNReal.mul_lt_mul_right'
code: @[gcongr] protected theorem mul_lt_mul_right' (h0 : a ≠ 0) (hinf : a ≠ ⊤) (bc : b < c) :
    b * a < c * a 
goal: b * a < c * a

full_name: ENNReal.mul_eq_mul_left
code: theorem mul_eq_mul_left (h0 : a ≠ 0) (hinf : a ≠ ∞) : a * b = a * c ↔ b = c 
goal: a * b = a * c ↔ b = c

full_name: ENNReal.mul_eq_mul_right
code: theorem mul_eq_mul_right : c ≠ 0 → c ≠ ∞ → (a * c = b * c ↔ a = b) 
goal: c ≠ 0 → c ≠ ⊤ → (a * c = b * c ↔ a = b)

full_name: ENNReal.mul_le_mul_left
code: theorem mul_le_mul_left (h0 : a ≠ 0) (hinf : a ≠ ∞) : a * b ≤ a * c ↔ b ≤ c 
goal: a * b ≤ a * c ↔ b ≤ c

full_name: ENNReal.mul_le_mul_right
code: theorem mul_le_mul_right : c ≠ 0 → c ≠ ∞ → (a * c ≤ b * c ↔ a ≤ b) 
goal: c ≠ 0 → c ≠ ⊤ → (a * c ≤ b * c ↔ a ≤ b)

full_name: ENNReal.mul_lt_mul_left
code: theorem mul_lt_mul_left (h0 : a ≠ 0) (hinf : a ≠ ∞) : a * b < a * c ↔ b < c 
goal: a * b < a * c ↔ b < c

full_name: ENNReal.mul_lt_mul_right
code: theorem mul_lt_mul_right : c ≠ 0 → c ≠ ∞ → (a * c < b * c ↔ a < b) 
goal: c ≠ 0 → c ≠ ⊤ → (a * c < b * c ↔ a < b)

full_name: ENNReal.pow_pos
code: protected theorem pow_pos : 0 < a → ∀ n : ℕ, 0 < a ^ n 
goal: 0 < a → ∀ (n : ℕ), 0 < a ^ n

full_name: ENNReal.pow_ne_zero
code: protected theorem pow_ne_zero : a ≠ 0 → ∀ n : ℕ, a ^ n ≠ 0 
goal: a ≠ 0 → ∀ (n : ℕ), a ^ n ≠ 0

full_name: ENNReal.not_lt_zero
code: theorem not_lt_zero : ¬a < 0 
goal: ¬a < 0

full_name: ENNReal.le_of_add_le_add_left
code: protected theorem le_of_add_le_add_left : a ≠ ∞ → a + b ≤ a + c → b ≤ c 
goal: a ≠ ⊤ → a + b ≤ a + c → b ≤ c

full_name: ENNReal.le_of_add_le_add_right
code: protected theorem le_of_add_le_add_right : a ≠ ∞ → b + a ≤ c + a → b ≤ c 
goal: a ≠ ⊤ → b + a ≤ c + a → b ≤ c

full_name: ENNReal.add_lt_add_left
code: @[gcongr] protected theorem add_lt_add_left : a ≠ ∞ → b < c → a + b < a + c 
goal: a ≠ ⊤ → b < c → a + b < a + c

full_name: ENNReal.add_lt_add_right
code: @[gcongr] protected theorem add_lt_add_right : a ≠ ∞ → b < c → b + a < c + a 
goal: a ≠ ⊤ → b < c → b + a < c + a

full_name: ENNReal.add_le_add_iff_left
code: protected theorem add_le_add_iff_left : a ≠ ∞ → (a + b ≤ a + c ↔ b ≤ c) 
goal: a ≠ ⊤ → (a + b ≤ a + c ↔ b ≤ c)

full_name: ENNReal.add_le_add_iff_right
code: protected theorem add_le_add_iff_right : a ≠ ∞ → (b + a ≤ c + a ↔ b ≤ c) 
goal: a ≠ ⊤ → (b + a ≤ c + a ↔ b ≤ c)

full_name: ENNReal.add_lt_add_iff_left
code: protected theorem add_lt_add_iff_left : a ≠ ∞ → (a + b < a + c ↔ b < c) 
goal: a ≠ ⊤ → (a + b < a + c ↔ b < c)

full_name: ENNReal.add_lt_add_iff_right
code: protected theorem add_lt_add_iff_right : a ≠ ∞ → (b + a < c + a ↔ b < c) 
goal: a ≠ ⊤ → (b + a < c + a ↔ b < c)

full_name: ENNReal.add_lt_add_of_le_of_lt
code: protected theorem add_lt_add_of_le_of_lt : a ≠ ∞ → a ≤ b → c < d → a + c < b + d 
goal: a ≠ ⊤ → a ≤ b → c < d → a + c < b + d

full_name: ENNReal.add_lt_add_of_lt_of_le
code: protected theorem add_lt_add_of_lt_of_le : c ≠ ∞ → a < b → c ≤ d → a + c < b + d 
goal: c ≠ ⊤ → a < b → c ≤ d → a + c < b + d

full_name: ENNReal.contravariantClass_add_lt
code: instance contravariantClass_add_lt : ContravariantClass ℝ≥0∞ ℝ≥0∞ (· + ·) (· < ·) 
goal: ContravariantClass ℝ≥0∞ ℝ≥0∞ (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: ENNReal.lt_add_right
code: theorem lt_add_right (ha : a ≠ ∞) (hb : b ≠ 0) : a < a + b 
goal: a < a + b

full_name: ENNReal.add_eq_top
code: @[simp] theorem add_eq_top : a + b = ∞ ↔ a = ∞ ∨ b = ∞ 
goal: a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤

full_name: ENNReal.add_lt_top
code: @[simp] theorem add_lt_top : a + b < ∞ ↔ a < ∞ ∧ b < ∞ 
goal: a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤

full_name: ENNReal.toNNReal_add
code: theorem toNNReal_add {r₁ r₂ : ℝ≥0∞} (h₁ : r₁ ≠ ∞) (h₂ : r₂ ≠ ∞) :
    (r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal 
goal: (r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal

full_name: ENNReal.not_lt_top
code: theorem not_lt_top {x : ℝ≥0∞} : ¬x < ∞ ↔ x = ∞ 
goal: ¬x < ⊤ ↔ x = ⊤

full_name: ENNReal.add_ne_top
code: theorem add_ne_top : a + b ≠ ∞ ↔ a ≠ ∞ ∧ b ≠ ∞ 
goal: a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤

full_name: ENNReal.mul_top'
code: theorem mul_top' : a * ∞ = if a = 0 then 0 else ∞ 
goal: a * ⊤ = if a = 0 then 0 else ⊤

full_name: ENNReal.mul_top
code: @[simp] theorem mul_top (h : a ≠ 0) : a * ∞ = ∞ 
goal: a * ⊤ = ⊤

full_name: ENNReal.top_mul'
code: theorem top_mul' : ∞ * a = if a = 0 then 0 else ∞ 
goal: ⊤ * a = if a = 0 then 0 else ⊤

full_name: ENNReal.top_mul
code: @[simp] theorem top_mul (h : a ≠ 0) : ∞ * a = ∞ 
goal: ⊤ * a = ⊤

full_name: ENNReal.top_mul_top
code: theorem top_mul_top : ∞ * ∞ = ∞ 
goal: ⊤ * ⊤ = ⊤

full_name: ENNReal.top_pow
code: theorem top_pow {n : ℕ} (n_pos : 0 < n) : (∞ : ℝ≥0∞) ^ n = ∞ 
goal: ⊤ ^ n = ⊤

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

full_name: ENNReal.mul_lt_top
code: theorem mul_lt_top : a ≠ ∞ → b ≠ ∞ → a * b < ∞ 
goal: a ≠ ⊤ → b ≠ ⊤ → a * b < ⊤

full_name: ENNReal.mul_ne_top
code: theorem mul_ne_top : a ≠ ∞ → b ≠ ∞ → a * b ≠ ∞ 
goal: a ≠ ⊤ → b ≠ ⊤ → a * b ≠ ⊤

full_name: ENNReal.lt_top_of_mul_ne_top_left
code: theorem lt_top_of_mul_ne_top_left (h : a * b ≠ ∞) (hb : b ≠ 0) : a < ∞ 
goal: a < ⊤

full_name: ENNReal.lt_top_of_mul_ne_top_right
code: theorem lt_top_of_mul_ne_top_right (h : a * b ≠ ∞) (ha : a ≠ 0) : b < ∞ 
goal: b < ⊤

full_name: ENNReal.mul_lt_top_iff
code: theorem mul_lt_top_iff {a b : ℝ≥0∞} : a * b < ∞ ↔ a < ∞ ∧ b < ∞ ∨ a = 0 ∨ b = 0 
goal: a * b < ⊤ ↔ a < ⊤ ∧ b < ⊤ ∨ a = 0 ∨ b = 0

full_name: ENNReal.mul_self_lt_top_iff
code: theorem mul_self_lt_top_iff {a : ℝ≥0∞} : a * a < ⊤ ↔ a < ⊤ 
goal: a * a < ⊤ ↔ a < ⊤

full_name: ENNReal.mul_pos_iff
code: theorem mul_pos_iff : 0 < a * b ↔ 0 < a ∧ 0 < b 
goal: 0 < a * b ↔ 0 < a ∧ 0 < b

full_name: ENNReal.mul_pos
code: theorem mul_pos (ha : a ≠ 0) (hb : b ≠ 0) : 0 < a * b 
goal: 0 < a * b

full_name: ENNReal.pow_eq_top_iff
code: @[simp] theorem pow_eq_top_iff {n : ℕ} : a ^ n = ∞ ↔ a = ∞ ∧ n ≠ 0 
goal: a ^ n = ⊤ ↔ a = ⊤ ∧ n ≠ 0

full_name: ENNReal.pow_eq_top
code: theorem pow_eq_top (n : ℕ) (h : a ^ n = ∞) : a = ∞ 
goal: a = ⊤

full_name: ENNReal.pow_ne_top
code: theorem pow_ne_top (h : a ≠ ∞) {n : ℕ} : a ^ n ≠ ∞ 
goal: a ^ n ≠ ⊤

full_name: ENNReal.pow_lt_top
code: theorem pow_lt_top : a < ∞ → ∀ n : ℕ, a ^ n < ∞ 
goal: a < ⊤ → ∀ (n : ℕ), a ^ n < ⊤

full_name: ENNReal.coe_finset_sum
code: @[simp, norm_cast]
theorem coe_finset_sum {s : Finset α} {f : α → ℝ≥0} : ↑(∑ a ∈ s, f a) = ∑ a ∈ s, (f a : ℝ≥0∞) 
goal: ↑(∑ a ∈ s, f a) = ∑ a ∈ s, ↑(f a)

full_name: ENNReal.coe_finset_prod
code: @[simp, norm_cast]
theorem coe_finset_prod {s : Finset α} {f : α → ℝ≥0} : ↑(∏ a ∈ s, f a) = ∏ a ∈ s, (f a : ℝ≥0∞) 
goal: ↑(∏ a ∈ s, f a) = ∏ a ∈ s, ↑(f a)

full_name: ENNReal.add_lt_add
code: @[gcongr] theorem add_lt_add (ac : a < c) (bd : b < d) : a + b < c + d 
goal: a + b < c + d

full_name: ENNReal.addLECancellable_iff_ne
code: /-- An element `a` is `AddLECancellable` if `a + b ≤ a + c` implies `b ≤ c` for all `b` and `c`.
  This is true in `ℝ≥0∞` for all elements except `∞`. -/
theorem addLECancellable_iff_ne {a : ℝ≥0∞} : AddLECancellable a ↔ a ≠ ∞ 
goal: AddLECancellable a ↔ a ≠ ⊤

full_name: ENNReal.cancel_of_ne
code: /-- This lemma has an abbreviated name because it is used frequently. -/
theorem cancel_of_ne {a : ℝ≥0∞} (h : a ≠ ∞) : AddLECancellable a 
goal: AddLECancellable a

full_name: ENNReal.cancel_of_lt
code: /-- This lemma has an abbreviated name because it is used frequently. -/
theorem cancel_of_lt {a : ℝ≥0∞} (h : a < ∞) : AddLECancellable a 
goal: AddLECancellable a

full_name: ENNReal.cancel_of_lt'
code: /-- This lemma has an abbreviated name because it is used frequently. -/
theorem cancel_of_lt' {a b : ℝ≥0∞} (h : a < b) : AddLECancellable a 
goal: AddLECancellable a

full_name: ENNReal.cancel_coe
code: /-- This lemma has an abbreviated name because it is used frequently. -/
theorem cancel_coe {a : ℝ≥0} : AddLECancellable (a : ℝ≥0∞) 
goal: AddLECancellable ↑a

full_name: ENNReal.add_right_inj
code: theorem add_right_inj (h : a ≠ ∞) : a + b = a + c ↔ b = c 
goal: a + b = a + c ↔ b = c

full_name: ENNReal.add_left_inj
code: theorem add_left_inj (h : a ≠ ∞) : b + a = c + a ↔ b = c 
goal: b + a = c + a ↔ b = c

full_name: ENNReal.sub_eq_sInf
code: theorem sub_eq_sInf {a b : ℝ≥0∞} : a - b = sInf { d | a ≤ d + b } 
goal: a - b = sInf {d | a ≤ d + b}

full_name: ENNReal.coe_sub
code: /-- This is a special case of `WithTop.coe_sub` in the `ENNReal` namespace -/
@[simp] theorem coe_sub : (↑(r - p) : ℝ≥0∞) = ↑r - ↑p 
goal: ↑(r - p) = ↑r - ↑p

full_name: ENNReal.top_sub_coe
code: /-- This is a special case of `WithTop.top_sub_coe` in the `ENNReal` namespace -/
@[simp] theorem top_sub_coe : ∞ - ↑r = ∞ 
goal: ⊤ - ↑r = ⊤

full_name: ENNReal.sub_top
code: /-- This is a special case of `WithTop.sub_top` in the `ENNReal` namespace -/
theorem sub_top : a - ∞ = 0 
goal: a - ⊤ = 0

full_name: ENNReal.sub_eq_top_iff
code: @[simp] theorem sub_eq_top_iff : a - b = ∞ ↔ a = ∞ ∧ b ≠ ∞ 
goal: a - b = ⊤ ↔ a = ⊤ ∧ b ≠ ⊤

full_name: ENNReal.sub_ne_top
code: theorem sub_ne_top (ha : a ≠ ∞) : a - b ≠ ∞ 
goal: a - b ≠ ⊤

full_name: ENNReal.natCast_sub
code: @[simp, norm_cast]
theorem natCast_sub (m n : ℕ) : ↑(m - n) = (m - n : ℝ≥0∞) 
goal: ↑(m - n) = ↑m - ↑n

full_name: ENNReal.sub_eq_of_eq_add
code: protected theorem sub_eq_of_eq_add (hb : b ≠ ∞) : a = c + b → a - b = c 
goal: a = c + b → a - b = c

full_name: ENNReal.eq_sub_of_add_eq
code: protected theorem eq_sub_of_add_eq (hc : c ≠ ∞) : a + c = b → a = b - c 
goal: a + c = b → a = b - c

full_name: ENNReal.sub_eq_of_eq_add_rev
code: protected theorem sub_eq_of_eq_add_rev (hb : b ≠ ∞) : a = b + c → a - b = c 
goal: a = b + c → a - b = c

full_name: ENNReal.sub_eq_of_add_eq
code: theorem sub_eq_of_add_eq (hb : b ≠ ∞) (hc : a + b = c) : c - b = a 
goal: c - b = a

full_name: ENNReal.add_sub_cancel_left
code: @[simp]
protected theorem add_sub_cancel_left (ha : a ≠ ∞) : a + b - a = b 
goal: a + b - a = b

full_name: ENNReal.add_sub_cancel_right
code: @[simp]
protected theorem add_sub_cancel_right (hb : b ≠ ∞) : a + b - b = a 
goal: a + b - b = a

full_name: ENNReal.lt_add_of_sub_lt_left
code: protected theorem lt_add_of_sub_lt_left (h : a ≠ ∞ ∨ b ≠ ∞) : a - b < c → a < b + c 
goal: a - b < c → a < b + c

full_name: ENNReal.lt_add_of_sub_lt_right
code: protected theorem lt_add_of_sub_lt_right (h : a ≠ ∞ ∨ c ≠ ∞) : a - c < b → a < b + c 
goal: a - c < b → a < b + c

full_name: ENNReal.le_sub_of_add_le_left
code: theorem le_sub_of_add_le_left (ha : a ≠ ∞) : a + b ≤ c → b ≤ c - a 
goal: a + b ≤ c → b ≤ c - a

full_name: ENNReal.le_sub_of_add_le_right
code: theorem le_sub_of_add_le_right (hb : b ≠ ∞) : a + b ≤ c → a ≤ c - b 
goal: a + b ≤ c → a ≤ c - b

full_name: ENNReal.sub_lt_of_lt_add
code: protected theorem sub_lt_of_lt_add (hac : c ≤ a) (h : a < b + c) : a - c < b 
goal: a - c < b

full_name: ENNReal.sub_lt_iff_lt_right
code: protected theorem sub_lt_iff_lt_right (hb : b ≠ ∞) (hab : b ≤ a) : a - b < c ↔ a < c + b 
goal: a - b < c ↔ a < c + b

full_name: ENNReal.sub_lt_self
code: protected theorem sub_lt_self (ha : a ≠ ∞) (ha₀ : a ≠ 0) (hb : b ≠ 0) : a - b < a 
goal: a - b < a

full_name: ENNReal.sub_lt_self_iff
code: protected theorem sub_lt_self_iff (ha : a ≠ ∞) : a - b < a ↔ 0 < a ∧ 0 < b 
goal: a - b < a ↔ 0 < a ∧ 0 < b

full_name: ENNReal.sub_lt_of_sub_lt
code: theorem sub_lt_of_sub_lt (h₂ : c ≤ a) (h₃ : a ≠ ∞ ∨ b ≠ ∞) (h₁ : a - b < c) : a - c < b 
goal: a - c < b

full_name: ENNReal.sub_sub_cancel
code: theorem sub_sub_cancel (h : a ≠ ∞) (h2 : b ≤ a) : a - (a - b) = b 
goal: a - (a - b) = b

full_name: ENNReal.sub_right_inj
code: theorem sub_right_inj {a b c : ℝ≥0∞} (ha : a ≠ ∞) (hb : b ≤ a) (hc : c ≤ a) :
    a - b = a - c ↔ b = c 
goal: a - b = a - c ↔ b = c

full_name: ENNReal.sub_mul
code: theorem sub_mul (h : 0 < b → b < a → c ≠ ∞) : (a - b) * c = a * c - b * c 
goal: (a - b) * c = a * c - b * c

full_name: ENNReal.mul_sub
code: theorem mul_sub (h : 0 < c → c < b → a ≠ ∞) : a * (b - c) = a * b - a * c 
goal: a * (b - c) = a * b - a * c

full_name: ENNReal.sub_le_sub_iff_left
code: theorem sub_le_sub_iff_left (h : c ≤ a) (h' : a ≠ ∞) :
    (a - b ≤ a - c) ↔ c ≤ b 
goal: a - b ≤ a - c ↔ c ≤ b

full_name: ENNReal.prod_lt_top
code: /-- A product of finite numbers is still finite -/
theorem prod_lt_top {s : Finset α} {f : α → ℝ≥0∞} (h : ∀ a ∈ s, f a ≠ ∞) : ∏ a ∈ s, f a < ∞ 
goal: ∏ a ∈ s, f a < ⊤

full_name: ENNReal.sum_lt_top
code: /-- A sum of finite numbers is still finite -/
theorem sum_lt_top {s : Finset α} {f : α → ℝ≥0∞} (h : ∀ a ∈ s, f a ≠ ∞) : ∑ a ∈ s, f a < ∞ 
goal: ∑ a ∈ s, f a < ⊤

full_name: ENNReal.sum_lt_top_iff
code: /-- A sum of finite numbers is still finite -/
theorem sum_lt_top_iff {s : Finset α} {f : α → ℝ≥0∞} : ∑ a ∈ s, f a < ∞ ↔ ∀ a ∈ s, f a < ∞ 
goal: ∑ a ∈ s, f a < ⊤ ↔ ∀ a ∈ s, f a < ⊤

full_name: ENNReal.sum_eq_top_iff
code: /-- A sum of numbers is infinite iff one of them is infinite -/
theorem sum_eq_top_iff {s : Finset α} {f : α → ℝ≥0∞} : ∑ x ∈ s, f x = ∞ ↔ ∃ a ∈ s, f a = ∞ 
goal: ∑ x ∈ s, f x = ⊤ ↔ ∃ a ∈ s, f a = ⊤

full_name: ENNReal.lt_top_of_sum_ne_top
code: theorem lt_top_of_sum_ne_top {s : Finset α} {f : α → ℝ≥0∞} (h : ∑ x ∈ s, f x ≠ ∞) {a : α}
    (ha : a ∈ s) : f a < ∞ 
goal: f a < ⊤

full_name: ENNReal.toNNReal_sum
code: /-- Seeing `ℝ≥0∞` as `ℝ≥0` does not change their sum, unless one of the `ℝ≥0∞` is
infinity -/
theorem toNNReal_sum {s : Finset α} {f : α → ℝ≥0∞} (hf : ∀ a ∈ s, f a ≠ ∞) :
    ENNReal.toNNReal (∑ a ∈ s, f a) = ∑ a ∈ s, ENNReal.toNNReal (f a) 
goal: (∑ a ∈ s, f a).toNNReal = ∑ a ∈ s, (f a).toNNReal

full_name: ENNReal.toReal_sum
code: /-- seeing `ℝ≥0∞` as `Real` does not change their sum, unless one of the `ℝ≥0∞` is infinity -/
theorem toReal_sum {s : Finset α} {f : α → ℝ≥0∞} (hf : ∀ a ∈ s, f a ≠ ∞) :
    ENNReal.toReal (∑ a ∈ s, f a) = ∑ a ∈ s, ENNReal.toReal (f a) 
goal: (∑ a ∈ s, f a).toReal = ∑ a ∈ s, (f a).toReal

full_name: ENNReal.ofReal_sum_of_nonneg
code: theorem ofReal_sum_of_nonneg {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.sum_lt_sum_of_nonempty
code: theorem sum_lt_sum_of_nonempty {s : Finset α} (hs : s.Nonempty) {f g : α → ℝ≥0∞}
    (Hlt : ∀ i ∈ s, f i < g i) : ∑ i ∈ s, f i < ∑ i ∈ s, g i 
goal: ∑ i ∈ s, f i < ∑ i ∈ s, g i

full_name: ENNReal.exists_le_of_sum_le
code: theorem exists_le_of_sum_le {s : Finset α} (hs : s.Nonempty) {f g : α → ℝ≥0∞}
    (Hle : ∑ i ∈ s, f i ≤ ∑ i ∈ s, g i) : ∃ i ∈ s, f i ≤ g i 
goal: ∃ i ∈ s, f i ≤ g i

full_name: ENNReal.Ico_eq_Iio
code: protected theorem Ico_eq_Iio : Ico 0 y = Iio y 
goal: Set.Ico 0 y = Set.Iio y

full_name: ENNReal.mem_Iio_self_add
code: theorem mem_Iio_self_add : x ≠ ∞ → ε ≠ 0 → x ∈ Iio (x + ε) 
goal: x ≠ ⊤ → ε ≠ 0 → x ∈ Set.Iio (x + ε)

full_name: ENNReal.mem_Ioo_self_sub_add
code: theorem mem_Ioo_self_sub_add : x ≠ ∞ → x ≠ 0 → ε₁ ≠ 0 → ε₂ ≠ 0 → x ∈ Ioo (x - ε₁) (x + ε₂) 
goal: x ≠ ⊤ → x ≠ 0 → ε₁ ≠ 0 → ε₂ ≠ 0 → x ∈ Set.Ioo (x - ε₁) (x + ε₂)

full_name: ENNReal.instMulActionNNReal
code: /-- A `MulAction` over `ℝ≥0∞` restricts to a `MulAction` over `ℝ≥0`. -/
noncomputable instance {M : Type*} [MulAction ℝ≥0∞ M] : MulAction ℝ≥0 M 
goal: MulAction ℝ≥0 M

full_name: ENNReal.smul_def
code: theorem smul_def {M : Type*} [MulAction ℝ≥0∞ M] (c : ℝ≥0) (x : M) : c • x = (c : ℝ≥0∞) • x 
goal: c • x = ↑c • x

full_name: ENNReal.instIsScalarTowerNNReal
code: instance {M N : Type*} [MulAction ℝ≥0∞ M] [MulAction ℝ≥0∞ N] [SMul M N] [IsScalarTower ℝ≥0∞ M N] :
    IsScalarTower ℝ≥0 M N 
goal: IsScalarTower ℝ≥0 M N

full_name: ENNReal.smulCommClass_left
code: instance smulCommClass_left {M N : Type*} [MulAction ℝ≥0∞ N] [SMul M N] [SMulCommClass ℝ≥0∞ M N] :
    SMulCommClass ℝ≥0 M N 
goal: SMulCommClass ℝ≥0 M N

full_name: ENNReal.smulCommClass_right
code: instance smulCommClass_right {M N : Type*} [MulAction ℝ≥0∞ N] [SMul M N] [SMulCommClass M ℝ≥0∞ N] :
    SMulCommClass M ℝ≥0 N 
goal: SMulCommClass M ℝ≥0 N

full_name: ENNReal.instDistribMulActionNNReal
code: /-- A `DistribMulAction` over `ℝ≥0∞` restricts to a `DistribMulAction` over `ℝ≥0`. -/
noncomputable instance {M : Type*} [AddMonoid M] [DistribMulAction ℝ≥0∞ M] :
    DistribMulAction ℝ≥0 M 
goal: DistribMulAction ℝ≥0 M

full_name: ENNReal.instModuleNNReal
code: /-- A `Module` over `ℝ≥0∞` restricts to a `Module` over `ℝ≥0`. -/
noncomputable instance {M : Type*} [AddCommMonoid M] [Module ℝ≥0∞ M] : Module ℝ≥0 M 
goal: Module ℝ≥0 M

full_name: ENNReal.instAlgebraNNReal
code: /-- An `Algebra` over `ℝ≥0∞` restricts to an `Algebra` over `ℝ≥0`. -/
noncomputable instance {A : Type*} [Semiring A] [Algebra ℝ≥0∞ A] : Algebra ℝ≥0 A 
goal: Algebra ℝ≥0 A

full_name: ENNReal.coe_smul
code: theorem coe_smul {R} (r : R) (s : ℝ≥0) [SMul R ℝ≥0] [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0 ℝ≥0]
    [IsScalarTower R ℝ≥0 ℝ≥0∞] : (↑(r • s) : ℝ≥0∞) = (r : R) • (s : ℝ≥0∞) 
goal: ↑(r • s) = r • ↑s

full_name: ENNReal.smul_top
code: theorem smul_top {R} [Zero R] [SMulWithZero R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞]
    [NoZeroSMulDivisors R ℝ≥0∞] [DecidableEq R] (c : R) :
    c • ∞ = if c = 0 then 0 else ∞ 
goal: c • ⊤ = if c = 0 then 0 else ⊤