ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ENNReal.trichotomy₂
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 
Arguments: {p q : ℝ≥0∞} (hpq : p ≤ q)
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
-- ENNReal.dichotomy
protected theorem dichotomy (p : ℝ≥0∞) [Fact (1 ≤ p)] : p = ∞ ∨ 1 ≤ p.toReal 
Arguments: (p : ℝ≥0∞) [Fact (1 ≤ p)]
Goal: p = ⊤ ∨ 1 ≤ p.toReal
-- ENNReal.toReal_pos_iff_ne_top
theorem toReal_pos_iff_ne_top (p : ℝ≥0∞) [Fact (1 ≤ p)] : 0 < p.toReal ↔ p ≠ ∞ 
Arguments: (p : ℝ≥0∞) [Fact (1 ≤ p)]
Goal: 0 < p.toReal ↔ p ≠ ⊤
-- ENNReal.toNNReal_inv
theorem toNNReal_inv (a : ℝ≥0∞) : a⁻¹.toNNReal = a.toNNReal⁻¹ 
Arguments: (a : ℝ≥0∞)
Goal: a⁻¹.toNNReal = a.toNNReal⁻¹
-- ENNReal.toNNReal_div
theorem toNNReal_div (a b : ℝ≥0∞) : (a / b).toNNReal = a.toNNReal / b.toNNReal 
Arguments: (a b : ℝ≥0∞)
Goal: (a / b).toNNReal = a.toNNReal / b.toNNReal
-- ENNReal.toReal_inv
theorem toReal_inv (a : ℝ≥0∞) : a⁻¹.toReal = a.toReal⁻¹ 
Arguments: (a : ℝ≥0∞)
Goal: a⁻¹.toReal = a.toReal⁻¹
-- ENNReal.toReal_div
theorem toReal_div (a b : ℝ≥0∞) : (a / b).toReal = a.toReal / b.toReal 
Arguments: (a b : ℝ≥0∞)
Goal: (a / b).toReal = a.toReal / b.toReal
-- ENNReal.ofReal_prod_of_nonneg
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) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ} (hf : ∀ i ∈ s, 0 ≤ f i)
Goal: ENNReal.ofReal (∏ i ∈ s, f i) = ∏ i ∈ s, ENNReal.ofReal (f i)
-- ENNReal.toNNReal_iInf
theorem toNNReal_iInf (hf : ∀ i, f i ≠ ∞) : (iInf f).toNNReal = ⨅ i, (f i).toNNReal 
Arguments: {ι : Sort u_1} {f : ι → ℝ≥0∞} (hf : ∀ (i : ι), f i ≠ ⊤)
Goal: (iInf f).toNNReal = ⨅ i, (f i).toNNReal
-- ENNReal.toNNReal_sInf
theorem toNNReal_sInf (s : Set ℝ≥0∞) (hs : ∀ r ∈ s, r ≠ ∞) :
    (sInf s).toNNReal = sInf (ENNReal.toNNReal '' s) 
Arguments: (s : Set ℝ≥0∞) (hs : ∀ r ∈ s, r ≠ ⊤)
Goal: (sInf s).toNNReal = sInf (ENNReal.toNNReal '' s)
-- ENNReal.toNNReal_iSup
theorem toNNReal_iSup (hf : ∀ i, f i ≠ ∞) : (iSup f).toNNReal = ⨆ i, (f i).toNNReal 
Arguments: {ι : Sort u_1} {f : ι → ℝ≥0∞} (hf : ∀ (i : ι), f i ≠ ⊤)
Goal: (iSup f).toNNReal = ⨆ i, (f i).toNNReal
-- ENNReal.toNNReal_sSup
theorem toNNReal_sSup (s : Set ℝ≥0∞) (hs : ∀ r ∈ s, r ≠ ∞) :
    (sSup s).toNNReal = sSup (ENNReal.toNNReal '' s) 
Arguments: (s : Set ℝ≥0∞) (hs : ∀ r ∈ s, r ≠ ⊤)
Goal: (sSup s).toNNReal = sSup (ENNReal.toNNReal '' s)
-- ENNReal.toReal_iInf
theorem toReal_iInf (hf : ∀ i, f i ≠ ∞) : (iInf f).toReal = ⨅ i, (f i).toReal 
Arguments: {ι : Sort u_1} {f : ι → ℝ≥0∞} (hf : ∀ (i : ι), f i ≠ ⊤)
Goal: (iInf f).toReal = ⨅ i, (f i).toReal
-- ENNReal.toReal_sInf
theorem toReal_sInf (s : Set ℝ≥0∞) (hf : ∀ r ∈ s, r ≠ ∞) :
    (sInf s).toReal = sInf (ENNReal.toReal '' s) 
Arguments: (s : Set ℝ≥0∞) (hf : ∀ r ∈ s, r ≠ ⊤)
Goal: (sInf s).toReal = sInf (ENNReal.toReal '' s)
-- ENNReal.toReal_iSup
theorem toReal_iSup (hf : ∀ i, f i ≠ ∞) : (iSup f).toReal = ⨆ i, (f i).toReal 
Arguments: {ι : Sort u_1} {f : ι → ℝ≥0∞} (hf : ∀ (i : ι), f i ≠ ⊤)
Goal: (iSup f).toReal = ⨆ i, (f i).toReal
-- ENNReal.toReal_sSup
theorem toReal_sSup (s : Set ℝ≥0∞) (hf : ∀ r ∈ s, r ≠ ∞) :
    (sSup s).toReal = sSup (ENNReal.toReal '' s) 
Arguments: (s : Set ℝ≥0∞) (hf : ∀ r ∈ s, r ≠ ⊤)
Goal: (sSup s).toReal = sSup (ENNReal.toReal '' s)
-- ENNReal.iInf_add
theorem iInf_add : iInf f + a = ⨅ i, f i + a 
Arguments: {ι : Sort u_1} {f : ι → ℝ≥0∞} {a : ℝ≥0∞}
Goal: iInf f + a = ⨅ i, f i + a
-- ENNReal.iSup_sub
theorem iSup_sub : (⨆ i, f i) - a = ⨆ i, f i - a 
Arguments: {ι : Sort u_1} {f : ι → ℝ≥0∞} {a : ℝ≥0∞}
Goal: (⨆ i, f i) - a = ⨆ i, f i - a
-- ENNReal.sub_iInf
theorem sub_iInf : (a - ⨅ i, f i) = ⨆ i, a - f i 
Arguments: {ι : Sort u_1} {f : ι → ℝ≥0∞} {a : ℝ≥0∞}
Goal: a - ⨅ i, f i = ⨆ i, a - f i
-- ENNReal.sInf_add
theorem sInf_add {s : Set ℝ≥0∞} : sInf s + a = ⨅ b ∈ s, b + a 
Arguments: {a : ℝ≥0∞} {s : Set ℝ≥0∞}
Goal: sInf s + a = ⨅ b ∈ s, b + a
-- ENNReal.add_iInf
theorem add_iInf {a : ℝ≥0∞} : a + iInf f = ⨅ b, a + f b 
Arguments: {ι : Sort u_1} {f : ι → ℝ≥0∞} {a : ℝ≥0∞}
Goal: a + iInf f = ⨅ b, a + f b
-- ENNReal.iInf_add_iInf
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 
Arguments: {ι : Sort u_1} {f g : ι → ℝ≥0∞} (h : ∀ (i j : ι), ∃ k, f k + g k ≤ f i + g j)
Goal: iInf f + iInf g = ⨅ a, f a + g a
-- ENNReal.iInf_sum
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 
Arguments: {ι : Sort u_1} {α : Type u_2} {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)
Goal: ⨅ i, ∑ a ∈ s, f i a = ∑ a ∈ s, ⨅ i, f i a
-- ENNReal.iInf_mul_of_ne
theorem iInf_mul_of_ne {ι} {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h0 : x ≠ 0) (h : x ≠ ∞) :
    iInf f * x = ⨅ i, f i * x 
Arguments: {ι : Sort u_2} {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h0 : x ≠ 0) (h : x ≠ ⊤)
Goal: iInf f * x = ⨅ i, f i * x
-- ENNReal.iInf_mul
theorem iInf_mul {ι} [Nonempty ι] {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h : x ≠ ∞) :
    iInf f * x = ⨅ i, f i * x 
Arguments: {ι : Sort u_2} [Nonempty ι] {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h : x ≠ ⊤)
Goal: iInf f * x = ⨅ i, f i * x
-- ENNReal.mul_iInf
theorem mul_iInf {ι} [Nonempty ι] {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h : x ≠ ∞) :
    x * iInf f = ⨅ i, x * f i 
Arguments: {ι : Sort u_2} [Nonempty ι] {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h : x ≠ ⊤)
Goal: x * iInf f = ⨅ i, x * f i
-- ENNReal.mul_iInf_of_ne
theorem mul_iInf_of_ne {ι} {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h0 : x ≠ 0) (h : x ≠ ∞) :
    x * iInf f = ⨅ i, x * f i 
Arguments: {ι : Sort u_2} {f : ι → ℝ≥0∞} {x : ℝ≥0∞} (h0 : x ≠ 0) (h : x ≠ ⊤)
Goal: x * iInf f = ⨅ i, x * f i
-- ENNReal.iSup_eq_zero
@[simp]
theorem iSup_eq_zero {ι : Sort*} {f : ι → ℝ≥0∞} : ⨆ i, f i = 0 ↔ ∀ i, f i = 0 
Arguments: {ι : Sort u_1} {f : ι → ℝ≥0∞}
Goal: ⨆ i, f i = 0 ↔ ∀ (i : ι), f i = 0
-- ENNReal.iSup_zero_eq_zero
@[simp]
theorem iSup_zero_eq_zero {ι : Sort*} : ⨆ _ : ι, (0 : ℝ≥0∞) = 0 
Arguments: {ι : Sort u_1}
Goal: ⨆ x, 0 = 0
-- ENNReal.sup_eq_zero
theorem sup_eq_zero {a b : ℝ≥0∞} : a ⊔ b = 0 ↔ a = 0 ∧ b = 0 
Arguments: {a b : ℝ≥0∞}
Goal: a ⊔ b = 0 ↔ a = 0 ∧ b = 0
-- ENNReal.iSup_natCast
theorem iSup_natCast : ⨆ n : ℕ, (n : ℝ≥0∞) = ∞ 
Goal: ⨆ n, ↑n = ⊤
-- Nat.coprime_list_prod_left_iff
theorem coprime_list_prod_left_iff {l : List ℕ} {k : ℕ} :
    Coprime l.prod k ↔ ∀ n ∈ l, Coprime n k 
Arguments: {l : List ℕ} {k : ℕ}
Goal: l.prod.Coprime k ↔ ∀ n ∈ l, n.Coprime k
-- Nat.coprime_list_prod_right_iff
theorem coprime_list_prod_right_iff {k : ℕ} {l : List ℕ} :
    Coprime k l.prod ↔ ∀ n ∈ l, Coprime k n 
Arguments: {k : ℕ} {l : List ℕ}
Goal: k.Coprime l.prod ↔ ∀ n ∈ l, k.Coprime n
-- Nat.coprime_multiset_prod_left_iff
theorem coprime_multiset_prod_left_iff {m : Multiset ℕ} {k : ℕ} :
    Coprime m.prod k ↔ ∀ n ∈ m, Coprime n k 
Arguments: {m : Multiset ℕ} {k : ℕ}
Goal: m.prod.Coprime k ↔ ∀ n ∈ m, n.Coprime k
-- Nat.coprime_multiset_prod_right_iff
theorem coprime_multiset_prod_right_iff {k : ℕ} {m : Multiset ℕ} :
    Coprime k m.prod ↔ ∀ n ∈ m, Coprime k n 
Arguments: {k : ℕ} {m : Multiset ℕ}
Goal: k.Coprime m.prod ↔ ∀ n ∈ m, k.Coprime n
-- Nat.coprime_prod_left_iff
theorem coprime_prod_left_iff {t : Finset ι} {s : ι → ℕ} {x : ℕ} :
    Coprime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, Coprime (s i) x 
Arguments: {ι : Type u_1} {t : Finset ι} {s : ι → ℕ} {x : ℕ}
Goal: (∏ i ∈ t, s i).Coprime x ↔ ∀ i ∈ t, (s i).Coprime x
-- Nat.coprime_prod_right_iff
theorem coprime_prod_right_iff {x : ℕ} {t : Finset ι} {s : ι → ℕ} :
    Coprime x (∏ i ∈ t, s i) ↔ ∀ i ∈ t, Coprime x (s i) 
Arguments: {ι : Type u_1} {x : ℕ} {t : Finset ι} {s : ι → ℕ}
Goal: x.Coprime (∏ i ∈ t, s i) ↔ ∀ i ∈ t, x.Coprime (s i)
-- Nat.coprime_fintype_prod_left_iff
theorem coprime_fintype_prod_left_iff [Fintype ι] {s : ι → ℕ} {x : ℕ} :
    Coprime (∏ i, s i) x ↔ ∀ i, Coprime (s i) x 
Arguments: {ι : Type u_1} [Fintype ι] {s : ι → ℕ} {x : ℕ}
Goal: (∏ i : ι, s i).Coprime x ↔ ∀ (i : ι), (s i).Coprime x
-- Nat.coprime_fintype_prod_right_iff
theorem coprime_fintype_prod_right_iff [Fintype ι] {x : ℕ} {s : ι → ℕ} :
    Coprime x (∏ i, s i) ↔ ∀ i, Coprime x (s i) 
Arguments: {ι : Type u_1} [Fintype ι] {x : ℕ} {s : ι → ℕ}
Goal: x.Coprime (∏ i : ι, s i) ↔ ∀ (i : ι), x.Coprime (s i)
-- Nat.Prime.dvd_choose_add
theorem dvd_choose_add (hp : Prime p) (hap : a < p) (hbp : b < p) (h : p ≤ a + b) :
    p ∣ choose (a + b) a 
Arguments: {p a b : ℕ} (hp : Nat.Prime p) (hap : a < p) (hbp : b < p) (h : p ≤ a + b)
Goal: p ∣ (a + b).choose a
-- Nat.Prime.dvd_choose
lemma dvd_choose (hp : Prime p) (ha : a < p) (hab : b - a < p) (h : p ≤ b) : p ∣ choose b a 
Arguments: {p a b : ℕ} (hp : Nat.Prime p) (ha : a < p) (hab : b - a < p) (h : p ≤ b)
Goal: p ∣ b.choose a
-- Nat.Prime.dvd_choose_self
lemma dvd_choose_self (hp : Prime p) (hk : k ≠ 0) (hkp : k < p) : p ∣ choose p k 
Arguments: {p k : ℕ} (hp : Nat.Prime p) (hk : k ≠ 0) (hkp : k < p)
Goal: p ∣ p.choose k
-- ENNReal.mul_lt_mul
@[mono, gcongr]
theorem mul_lt_mul (ac : a < c) (bd : b < d) : a * b < c * d 
Arguments: {a b c d : ℝ≥0∞} (ac : a < c) (bd : b < d)
Goal: a * b < c * d
-- ENNReal.mul_left_mono
theorem mul_left_mono : Monotone (a * ·) 
Arguments: {a : ℝ≥0∞}
Goal: Monotone fun x => a * x
-- ENNReal.mul_right_mono
theorem mul_right_mono : Monotone (· * a) 
Arguments: {a : ℝ≥0∞}
Goal: Monotone fun x => x * a
-- ENNReal.pow_strictMono
theorem pow_strictMono : ∀ {n : ℕ}, n ≠ 0 → StrictMono fun x : ℝ≥0∞ => x ^ n
  
Arguments: {n : ℕ}
Goal: n ≠ 0 → StrictMono fun x => x ^ n
-- ENNReal.pow_lt_pow_left
@[gcongr] protected theorem pow_lt_pow_left (h : a < b) {n : ℕ} (hn : n ≠ 0) :
    a ^ n < b ^ n 
Arguments: {a b : ℝ≥0∞} (h : a < b) {n : ℕ} (hn : n ≠ 0)
Goal: a ^ n < b ^ n
-- ENNReal.max_mul
theorem max_mul : max a b * c = max (a * c) (b * c) 
Arguments: {a b c : ℝ≥0∞}
Goal: max a b * c = max (a * c) (b * c)
-- ENNReal.mul_max
theorem mul_max : a * max b c = max (a * b) (a * c) 
Arguments: {a b c : ℝ≥0∞}
Goal: a * max b c = max (a * b) (a * c)
-- ENNReal.mul_left_strictMono
theorem mul_left_strictMono (h0 : a ≠ 0) (hinf : a ≠ ∞) : StrictMono (a * ·) 
Arguments: {a : ℝ≥0∞} (h0 : a ≠ 0) (hinf : a ≠ ⊤)
Goal: StrictMono fun x => a * x
-- ENNReal.mul_lt_mul_left'
@[gcongr] protected theorem mul_lt_mul_left' (h0 : a ≠ 0) (hinf : a ≠ ⊤) (bc : b < c) :
    a * b < a * c 
Arguments: {a b c : ℝ≥0∞} (h0 : a ≠ 0) (hinf : a ≠ ⊤) (bc : b < c)
Goal: a * b < a * c
-- ENNReal.mul_lt_mul_right'
@[gcongr] protected theorem mul_lt_mul_right' (h0 : a ≠ 0) (hinf : a ≠ ⊤) (bc : b < c) :
    b * a < c * a 
Arguments: {a b c : ℝ≥0∞} (h0 : a ≠ 0) (hinf : a ≠ ⊤) (bc : b < c)
Goal: b * a < c * a
-- ENNReal.mul_eq_mul_left
theorem mul_eq_mul_left (h0 : a ≠ 0) (hinf : a ≠ ∞) : a * b = a * c ↔ b = c 
Arguments: {a b c : ℝ≥0∞} (h0 : a ≠ 0) (hinf : a ≠ ⊤)
Goal: a * b = a * c ↔ b = c
-- ENNReal.mul_eq_mul_right
theorem mul_eq_mul_right : c ≠ 0 → c ≠ ∞ → (a * c = b * c ↔ a = b) 
Arguments: {a b c : ℝ≥0∞}
Goal: c ≠ 0 → c ≠ ⊤ → (a * c = b * c ↔ a = b)
-- ENNReal.mul_le_mul_left
theorem mul_le_mul_left (h0 : a ≠ 0) (hinf : a ≠ ∞) : a * b ≤ a * c ↔ b ≤ c 
Arguments: {a b c : ℝ≥0∞} (h0 : a ≠ 0) (hinf : a ≠ ⊤)
Goal: a * b ≤ a * c ↔ b ≤ c
-- ENNReal.mul_le_mul_right
theorem mul_le_mul_right : c ≠ 0 → c ≠ ∞ → (a * c ≤ b * c ↔ a ≤ b) 
Arguments: {a b c : ℝ≥0∞}
Goal: c ≠ 0 → c ≠ ⊤ → (a * c ≤ b * c ↔ a ≤ b)
-- ENNReal.mul_lt_mul_left
theorem mul_lt_mul_left (h0 : a ≠ 0) (hinf : a ≠ ∞) : a * b < a * c ↔ b < c 
Arguments: {a b c : ℝ≥0∞} (h0 : a ≠ 0) (hinf : a ≠ ⊤)
Goal: a * b < a * c ↔ b < c
-- ENNReal.mul_lt_mul_right
theorem mul_lt_mul_right : c ≠ 0 → c ≠ ∞ → (a * c < b * c ↔ a < b) 
Arguments: {a b c : ℝ≥0∞}
Goal: c ≠ 0 → c ≠ ⊤ → (a * c < b * c ↔ a < b)
-- ENNReal.pow_pos
protected theorem pow_pos : 0 < a → ∀ n : ℕ, 0 < a ^ n 
Arguments: {a : ℝ≥0∞}
Goal: 0 < a → ∀ (n : ℕ), 0 < a ^ n
-- ENNReal.pow_ne_zero
protected theorem pow_ne_zero : a ≠ 0 → ∀ n : ℕ, a ^ n ≠ 0 
Arguments: {a : ℝ≥0∞}
Goal: a ≠ 0 → ∀ (n : ℕ), a ^ n ≠ 0
-- ENNReal.not_lt_zero
theorem not_lt_zero : ¬a < 0 
Arguments: {a : ℝ≥0∞}
Goal: ¬a < 0
-- ENNReal.le_of_add_le_add_left
protected theorem le_of_add_le_add_left : a ≠ ∞ → a + b ≤ a + c → b ≤ c 
Arguments: {a b c : ℝ≥0∞}
Goal: a ≠ ⊤ → a + b ≤ a + c → b ≤ c
-- ENNReal.le_of_add_le_add_right
protected theorem le_of_add_le_add_right : a ≠ ∞ → b + a ≤ c + a → b ≤ c 
Arguments: {a b c : ℝ≥0∞}
Goal: a ≠ ⊤ → b + a ≤ c + a → b ≤ c
-- ENNReal.add_lt_add_left
@[gcongr] protected theorem add_lt_add_left : a ≠ ∞ → b < c → a + b < a + c 
Arguments: {a b c : ℝ≥0∞}
Goal: a ≠ ⊤ → b < c → a + b < a + c
-- ENNReal.add_lt_add_right
@[gcongr] protected theorem add_lt_add_right : a ≠ ∞ → b < c → b + a < c + a 
Arguments: {a b c : ℝ≥0∞}
Goal: a ≠ ⊤ → b < c → b + a < c + a
-- ENNReal.add_le_add_iff_left
protected theorem add_le_add_iff_left : a ≠ ∞ → (a + b ≤ a + c ↔ b ≤ c) 
Arguments: {a b c : ℝ≥0∞}
Goal: a ≠ ⊤ → (a + b ≤ a + c ↔ b ≤ c)
-- ENNReal.add_le_add_iff_right
protected theorem add_le_add_iff_right : a ≠ ∞ → (b + a ≤ c + a ↔ b ≤ c) 
Arguments: {a b c : ℝ≥0∞}
Goal: a ≠ ⊤ → (b + a ≤ c + a ↔ b ≤ c)
-- ENNReal.add_lt_add_iff_left
protected theorem add_lt_add_iff_left : a ≠ ∞ → (a + b < a + c ↔ b < c) 
Arguments: {a b c : ℝ≥0∞}
Goal: a ≠ ⊤ → (a + b < a + c ↔ b < c)
-- ENNReal.add_lt_add_iff_right
protected theorem add_lt_add_iff_right : a ≠ ∞ → (b + a < c + a ↔ b < c) 
Arguments: {a b c : ℝ≥0∞}
Goal: a ≠ ⊤ → (b + a < c + a ↔ b < c)
-- ENNReal.add_lt_add_of_le_of_lt
protected theorem add_lt_add_of_le_of_lt : a ≠ ∞ → a ≤ b → c < d → a + c < b + d 
Arguments: {a b c d : ℝ≥0∞}
Goal: a ≠ ⊤ → a ≤ b → c < d → a + c < b + d
-- ENNReal.add_lt_add_of_lt_of_le
protected theorem add_lt_add_of_lt_of_le : c ≠ ∞ → a < b → c ≤ d → a + c < b + d 
Arguments: {a b c d : ℝ≥0∞}
Goal: c ≠ ⊤ → a < b → c ≤ d → a + c < b + d
-- ENNReal.lt_add_right
theorem lt_add_right (ha : a ≠ ∞) (hb : b ≠ 0) : a < a + b 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤) (hb : b ≠ 0)
Goal: a < a + b
-- ENNReal.add_eq_top
@[simp] theorem add_eq_top : a + b = ∞ ↔ a = ∞ ∨ b = ∞ 
Arguments: {a b : ℝ≥0∞}
Goal: a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤
-- ENNReal.add_lt_top
@[simp] theorem add_lt_top : a + b < ∞ ↔ a < ∞ ∧ b < ∞ 
Arguments: {a b : ℝ≥0∞}
Goal: a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤
-- ENNReal.toNNReal_add
theorem toNNReal_add {r₁ r₂ : ℝ≥0∞} (h₁ : r₁ ≠ ∞) (h₂ : r₂ ≠ ∞) :
    (r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal 
Arguments: {r₁ r₂ : ℝ≥0∞} (h₁ : r₁ ≠ ⊤) (h₂ : r₂ ≠ ⊤)
Goal: (r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal
-- ENNReal.not_lt_top
theorem not_lt_top {x : ℝ≥0∞} : ¬x < ∞ ↔ x = ∞ 
Arguments: {x : ℝ≥0∞}
Goal: ¬x < ⊤ ↔ x = ⊤
-- ENNReal.add_ne_top
theorem add_ne_top : a + b ≠ ∞ ↔ a ≠ ∞ ∧ b ≠ ∞ 
Arguments: {a b : ℝ≥0∞}
Goal: a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤
-- ENNReal.mul_top'
theorem mul_top' : a * ∞ = if a = 0 then 0 else ∞ 
Arguments: {a : ℝ≥0∞}
Goal: a * ⊤ = if a = 0 then 0 else ⊤
-- ENNReal.mul_top
@[simp] theorem mul_top (h : a ≠ 0) : a * ∞ = ∞ 
Arguments: {a : ℝ≥0∞} (h : a ≠ 0)
Goal: a * ⊤ = ⊤
-- ENNReal.top_mul'
theorem top_mul' : ∞ * a = if a = 0 then 0 else ∞ 
Arguments: {a : ℝ≥0∞}
Goal: ⊤ * a = if a = 0 then 0 else ⊤
-- ENNReal.top_mul
@[simp] theorem top_mul (h : a ≠ 0) : ∞ * a = ∞ 
Arguments: {a : ℝ≥0∞} (h : a ≠ 0)
Goal: ⊤ * a = ⊤
-- ENNReal.top_mul_top
theorem top_mul_top : ∞ * ∞ = ∞ 
Goal: ⊤ * ⊤ = ⊤
-- ENNReal.top_pow
theorem top_pow {n : ℕ} (n_pos : 0 < n) : (∞ : ℝ≥0∞) ^ n = ∞ 
Arguments: {n : ℕ} (n_pos : 0 < n)
Goal: ⊤ ^ n = ⊤
-- ENNReal.mul_eq_top
theorem mul_eq_top : a * b = ∞ ↔ a ≠ 0 ∧ b = ∞ ∨ a = ∞ ∧ b ≠ 0 
Arguments: {a b : ℝ≥0∞}
Goal: a * b = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0
-- ENNReal.mul_lt_top
theorem mul_lt_top : a ≠ ∞ → b ≠ ∞ → a * b < ∞ 
Arguments: {a b : ℝ≥0∞}
Goal: a ≠ ⊤ → b ≠ ⊤ → a * b < ⊤
-- ENNReal.mul_ne_top
theorem mul_ne_top : a ≠ ∞ → b ≠ ∞ → a * b ≠ ∞ 
Arguments: {a b : ℝ≥0∞}
Goal: a ≠ ⊤ → b ≠ ⊤ → a * b ≠ ⊤
-- ENNReal.lt_top_of_mul_ne_top_left
theorem lt_top_of_mul_ne_top_left (h : a * b ≠ ∞) (hb : b ≠ 0) : a < ∞ 
Arguments: {a b : ℝ≥0∞} (h : a * b ≠ ⊤) (hb : b ≠ 0)
Goal: a < ⊤
-- ENNReal.lt_top_of_mul_ne_top_right
theorem lt_top_of_mul_ne_top_right (h : a * b ≠ ∞) (ha : a ≠ 0) : b < ∞ 
Arguments: {a b : ℝ≥0∞} (h : a * b ≠ ⊤) (ha : a ≠ 0)
Goal: b < ⊤
-- ENNReal.mul_lt_top_iff
theorem mul_lt_top_iff {a b : ℝ≥0∞} : a * b < ∞ ↔ a < ∞ ∧ b < ∞ ∨ a = 0 ∨ b = 0 
Arguments: {a b : ℝ≥0∞}
Goal: a * b < ⊤ ↔ a < ⊤ ∧ b < ⊤ ∨ a = 0 ∨ b = 0
-- ENNReal.mul_self_lt_top_iff
theorem mul_self_lt_top_iff {a : ℝ≥0∞} : a * a < ⊤ ↔ a < ⊤ 
Arguments: {a : ℝ≥0∞}
Goal: a * a < ⊤ ↔ a < ⊤
-- ENNReal.mul_pos_iff
theorem mul_pos_iff : 0 < a * b ↔ 0 < a ∧ 0 < b 
Arguments: {a b : ℝ≥0∞}
Goal: 0 < a * b ↔ 0 < a ∧ 0 < b
-- ENNReal.mul_pos
theorem mul_pos (ha : a ≠ 0) (hb : b ≠ 0) : 0 < a * b 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: 0 < a * b
-- ENNReal.pow_eq_top_iff
@[simp] theorem pow_eq_top_iff {n : ℕ} : a ^ n = ∞ ↔ a = ∞ ∧ n ≠ 0 
Arguments: {a : ℝ≥0∞} {n : ℕ}
Goal: a ^ n = ⊤ ↔ a = ⊤ ∧ n ≠ 0
-- ENNReal.pow_eq_top
theorem pow_eq_top (n : ℕ) (h : a ^ n = ∞) : a = ∞ 
Arguments: {a : ℝ≥0∞} (n : ℕ) (h : a ^ n = ⊤)
Goal: a = ⊤
-- ENNReal.pow_ne_top
theorem pow_ne_top (h : a ≠ ∞) {n : ℕ} : a ^ n ≠ ∞ 
Arguments: {a : ℝ≥0∞} (h : a ≠ ⊤) {n : ℕ}
Goal: a ^ n ≠ ⊤
-- ENNReal.pow_lt_top
theorem pow_lt_top : a < ∞ → ∀ n : ℕ, a ^ n < ∞ 
Arguments: {a : ℝ≥0∞}
Goal: a < ⊤ → ∀ (n : ℕ), a ^ n < ⊤
-- ENNReal.coe_finset_sum
@[simp, norm_cast]
theorem coe_finset_sum {s : Finset α} {f : α → ℝ≥0} : ↑(∑ a ∈ s, f a) = ∑ a ∈ s, (f a : ℝ≥0∞) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0}
Goal: ↑(∑ a ∈ s, f a) = ∑ a ∈ s, ↑(f a)
-- ENNReal.coe_finset_prod
@[simp, norm_cast]
theorem coe_finset_prod {s : Finset α} {f : α → ℝ≥0} : ↑(∏ a ∈ s, f a) = ∏ a ∈ s, (f a : ℝ≥0∞) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0}
Goal: ↑(∏ a ∈ s, f a) = ∏ a ∈ s, ↑(f a)
-- ENNReal.add_lt_add
@[gcongr] theorem add_lt_add (ac : a < c) (bd : b < d) : a + b < c + d 
Arguments: {a b c d : ℝ≥0∞} (ac : a < c) (bd : b < d)
Goal: a + b < c + d
-- ENNReal.addLECancellable_iff_ne
theorem addLECancellable_iff_ne {a : ℝ≥0∞} : AddLECancellable a ↔ a ≠ ∞ 
Arguments: {a : ℝ≥0∞}
Goal: AddLECancellable a ↔ a ≠ ⊤
-- ENNReal.cancel_of_ne
theorem cancel_of_ne {a : ℝ≥0∞} (h : a ≠ ∞) : AddLECancellable a 
Arguments: {a : ℝ≥0∞} (h : a ≠ ⊤)
Goal: AddLECancellable a
-- ENNReal.cancel_of_lt
theorem cancel_of_lt {a : ℝ≥0∞} (h : a < ∞) : AddLECancellable a 
Arguments: {a : ℝ≥0∞} (h : a < ⊤)
Goal: AddLECancellable a
-- ENNReal.cancel_of_lt'
theorem cancel_of_lt' {a b : ℝ≥0∞} (h : a < b) : AddLECancellable a 
Arguments: {a b : ℝ≥0∞} (h : a < b)
Goal: AddLECancellable a
-- ENNReal.cancel_coe
theorem cancel_coe {a : ℝ≥0} : AddLECancellable (a : ℝ≥0∞) 
Arguments: {a : ℝ≥0}
Goal: AddLECancellable ↑a
-- ENNReal.add_right_inj
theorem add_right_inj (h : a ≠ ∞) : a + b = a + c ↔ b = c 
Arguments: {a b c : ℝ≥0∞} (h : a ≠ ⊤)
Goal: a + b = a + c ↔ b = c
-- ENNReal.add_left_inj
theorem add_left_inj (h : a ≠ ∞) : b + a = c + a ↔ b = c 
Arguments: {a b c : ℝ≥0∞} (h : a ≠ ⊤)
Goal: b + a = c + a ↔ b = c
-- ENNReal.sub_eq_sInf
theorem sub_eq_sInf {a b : ℝ≥0∞} : a - b = sInf { d | a ≤ d + b } 
Arguments: {a b : ℝ≥0∞}
Goal: a - b = sInf {d | a ≤ d + b}
-- ENNReal.coe_sub
@[simp] theorem coe_sub : (↑(r - p) : ℝ≥0∞) = ↑r - ↑p 
Arguments: {r p : ℝ≥0}
Goal: ↑(r - p) = ↑r - ↑p
-- ENNReal.top_sub_coe
@[simp] theorem top_sub_coe : ∞ - ↑r = ∞ 
Arguments: {r : ℝ≥0}
Goal: ⊤ - ↑r = ⊤
-- ENNReal.sub_top
theorem sub_top : a - ∞ = 0 
Arguments: {a : ℝ≥0∞}
Goal: a - ⊤ = 0
-- ENNReal.sub_eq_top_iff
@[simp] theorem sub_eq_top_iff : a - b = ∞ ↔ a = ∞ ∧ b ≠ ∞ 
Arguments: {a b : ℝ≥0∞}
Goal: a - b = ⊤ ↔ a = ⊤ ∧ b ≠ ⊤
-- ENNReal.sub_ne_top
theorem sub_ne_top (ha : a ≠ ∞) : a - b ≠ ∞ 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤)
Goal: a - b ≠ ⊤
-- ENNReal.natCast_sub
@[simp, norm_cast]
theorem natCast_sub (m n : ℕ) : ↑(m - n) = (m - n : ℝ≥0∞) 
Arguments: (m n : ℕ)
Goal: ↑(m - n) = ↑m - ↑n
-- ENNReal.sub_eq_of_eq_add
protected theorem sub_eq_of_eq_add (hb : b ≠ ∞) : a = c + b → a - b = c 
Arguments: {a b c : ℝ≥0∞} (hb : b ≠ ⊤)
Goal: a = c + b → a - b = c
-- ENNReal.eq_sub_of_add_eq
protected theorem eq_sub_of_add_eq (hc : c ≠ ∞) : a + c = b → a = b - c 
Arguments: {a b c : ℝ≥0∞} (hc : c ≠ ⊤)
Goal: a + c = b → a = b - c
-- ENNReal.sub_eq_of_eq_add_rev
protected theorem sub_eq_of_eq_add_rev (hb : b ≠ ∞) : a = b + c → a - b = c 
Arguments: {a b c : ℝ≥0∞} (hb : b ≠ ⊤)
Goal: a = b + c → a - b = c
-- ENNReal.sub_eq_of_add_eq
theorem sub_eq_of_add_eq (hb : b ≠ ∞) (hc : a + b = c) : c - b = a 
Arguments: {a b c : ℝ≥0∞} (hb : b ≠ ⊤) (hc : a + b = c)
Goal: c - b = a
-- ENNReal.add_sub_cancel_left
@[simp]
protected theorem add_sub_cancel_left (ha : a ≠ ∞) : a + b - a = b 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤)
Goal: a + b - a = b
-- ENNReal.add_sub_cancel_right
@[simp]
protected theorem add_sub_cancel_right (hb : b ≠ ∞) : a + b - b = a 
Arguments: {a b : ℝ≥0∞} (hb : b ≠ ⊤)
Goal: a + b - b = a
-- ENNReal.lt_add_of_sub_lt_left
protected theorem lt_add_of_sub_lt_left (h : a ≠ ∞ ∨ b ≠ ∞) : a - b < c → a < b + c 
Arguments: {a b c : ℝ≥0∞} (h : a ≠ ⊤ ∨ b ≠ ⊤)
Goal: a - b < c → a < b + c
-- ENNReal.lt_add_of_sub_lt_right
protected theorem lt_add_of_sub_lt_right (h : a ≠ ∞ ∨ c ≠ ∞) : a - c < b → a < b + c 
Arguments: {a b c : ℝ≥0∞} (h : a ≠ ⊤ ∨ c ≠ ⊤)
Goal: a - c < b → a < b + c
-- ENNReal.le_sub_of_add_le_left
theorem le_sub_of_add_le_left (ha : a ≠ ∞) : a + b ≤ c → b ≤ c - a 
Arguments: {a b c : ℝ≥0∞} (ha : a ≠ ⊤)
Goal: a + b ≤ c → b ≤ c - a
-- ENNReal.le_sub_of_add_le_right
theorem le_sub_of_add_le_right (hb : b ≠ ∞) : a + b ≤ c → a ≤ c - b 
Arguments: {a b c : ℝ≥0∞} (hb : b ≠ ⊤)
Goal: a + b ≤ c → a ≤ c - b
-- ENNReal.sub_lt_of_lt_add
protected theorem sub_lt_of_lt_add (hac : c ≤ a) (h : a < b + c) : a - c < b 
Arguments: {a b c : ℝ≥0∞} (hac : c ≤ a) (h : a < b + c)
Goal: a - c < b
-- ENNReal.sub_lt_iff_lt_right
protected theorem sub_lt_iff_lt_right (hb : b ≠ ∞) (hab : b ≤ a) : a - b < c ↔ a < c + b 
Arguments: {a b c : ℝ≥0∞} (hb : b ≠ ⊤) (hab : b ≤ a)
Goal: a - b < c ↔ a < c + b
-- ENNReal.sub_lt_self
protected theorem sub_lt_self (ha : a ≠ ∞) (ha₀ : a ≠ 0) (hb : b ≠ 0) : a - b < a 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤) (ha₀ : a ≠ 0) (hb : b ≠ 0)
Goal: a - b < a
-- ENNReal.sub_lt_self_iff
protected theorem sub_lt_self_iff (ha : a ≠ ∞) : a - b < a ↔ 0 < a ∧ 0 < b 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ ⊤)
Goal: a - b < a ↔ 0 < a ∧ 0 < b
-- ENNReal.sub_lt_of_sub_lt
theorem sub_lt_of_sub_lt (h₂ : c ≤ a) (h₃ : a ≠ ∞ ∨ b ≠ ∞) (h₁ : a - b < c) : a - c < b 
Arguments: {a b c : ℝ≥0∞} (h₂ : c ≤ a) (h₃ : a ≠ ⊤ ∨ b ≠ ⊤) (h₁ : a - b < c)
Goal: a - c < b
-- ENNReal.sub_sub_cancel
theorem sub_sub_cancel (h : a ≠ ∞) (h2 : b ≤ a) : a - (a - b) = b 
Arguments: {a b : ℝ≥0∞} (h : a ≠ ⊤) (h2 : b ≤ a)
Goal: a - (a - b) = b
-- ENNReal.sub_right_inj
theorem sub_right_inj {a b c : ℝ≥0∞} (ha : a ≠ ∞) (hb : b ≤ a) (hc : c ≤ a) :
    a - b = a - c ↔ b = c 
Arguments: {a b c : ℝ≥0∞} (ha : a ≠ ⊤) (hb : b ≤ a) (hc : c ≤ a)
Goal: a - b = a - c ↔ b = c
-- ENNReal.sub_mul
theorem sub_mul (h : 0 < b → b < a → c ≠ ∞) : (a - b) * c = a * c - b * c 
Arguments: {a b c : ℝ≥0∞} (h : 0 < b → b < a → c ≠ ⊤)
Goal: (a - b) * c = a * c - b * c
-- ENNReal.mul_sub
theorem mul_sub (h : 0 < c → c < b → a ≠ ∞) : a * (b - c) = a * b - a * c 
Arguments: {a b c : ℝ≥0∞} (h : 0 < c → c < b → a ≠ ⊤)
Goal: a * (b - c) = a * b - a * c
-- ENNReal.sub_le_sub_iff_left
theorem sub_le_sub_iff_left (h : c ≤ a) (h' : a ≠ ∞) :
    (a - b ≤ a - c) ↔ c ≤ b 
Arguments: {a b c : ℝ≥0∞} (h : c ≤ a) (h' : a ≠ ⊤)
Goal: a - b ≤ a - c ↔ c ≤ b
-- ENNReal.prod_lt_top
theorem prod_lt_top {s : Finset α} {f : α → ℝ≥0∞} (h : ∀ a ∈ s, f a ≠ ∞) : ∏ a ∈ s, f a < ∞ 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0∞} (h : ∀ a ∈ s, f a ≠ ⊤)
Goal: ∏ a ∈ s, f a < ⊤
-- ENNReal.sum_lt_top
theorem sum_lt_top {s : Finset α} {f : α → ℝ≥0∞} (h : ∀ a ∈ s, f a ≠ ∞) : ∑ a ∈ s, f a < ∞ 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0∞} (h : ∀ a ∈ s, f a ≠ ⊤)
Goal: ∑ a ∈ s, f a < ⊤
-- ENNReal.sum_lt_top_iff
theorem sum_lt_top_iff {s : Finset α} {f : α → ℝ≥0∞} : ∑ a ∈ s, f a < ∞ ↔ ∀ a ∈ s, f a < ∞ 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0∞}
Goal: ∑ a ∈ s, f a < ⊤ ↔ ∀ a ∈ s, f a < ⊤