ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ENNReal.some_eq_coe
@[simp] theorem some_eq_coe (a : ℝ≥0) : (Option.some a : ℝ≥0∞) = (↑a : ℝ≥0∞) 
Arguments: (a : ℝ≥0)
Goal: some a = ↑a
-- ENNReal.some_eq_coe'
@[simp] theorem some_eq_coe' (a : ℝ≥0) : (WithTop.some a : ℝ≥0∞) = (↑a : ℝ≥0∞) 
Arguments: (a : ℝ≥0)
Goal: ↑a = ↑a
-- ENNReal.coe_injective
lemma coe_injective : Injective ((↑) : ℝ≥0 → ℝ≥0∞) 
Goal: Function.Injective ENNReal.ofNNReal
-- ENNReal.coe_inj
@[simp, norm_cast] lemma coe_inj : (p : ℝ≥0∞) = q ↔ p = q 
Arguments: {p q : ℝ≥0}
Goal: ↑p = ↑q ↔ p = q
-- ENNReal.coe_ne_coe
lemma coe_ne_coe : (p : ℝ≥0∞) ≠ q ↔ p ≠ q 
Arguments: {p q : ℝ≥0}
Goal: ↑p ≠ ↑q ↔ p ≠ q
-- ENNReal.range_coe'
theorem range_coe' : range ofNNReal = Iio ∞ 
Goal: Set.range ENNReal.ofNNReal = Set.Iio ⊤
-- ENNReal.range_coe
theorem range_coe : range ofNNReal = {∞}ᶜ 
Goal: Set.range ENNReal.ofNNReal = {⊤}ᶜ
-- ENNReal.toNNReal_coe
@[simp, norm_cast]
theorem toNNReal_coe : (r : ℝ≥0∞).toNNReal = r 
Arguments: {r : ℝ≥0}
Goal: (↑r).toNNReal = r
-- ENNReal.coe_toNNReal
@[simp]
theorem coe_toNNReal : ∀ {a : ℝ≥0∞}, a ≠ ∞ → ↑a.toNNReal = a
  
Arguments: {a : ℝ≥0∞}
Goal: a ≠ ⊤ → ↑a.toNNReal = a
-- ENNReal.ofReal_toReal
@[simp]
theorem ofReal_toReal {a : ℝ≥0∞} (h : a ≠ ∞) : ENNReal.ofReal a.toReal = a 
Arguments: {a : ℝ≥0∞} (h : a ≠ ⊤)
Goal: ENNReal.ofReal a.toReal = a
-- ENNReal.toReal_ofReal
@[simp]
theorem toReal_ofReal {r : ℝ} (h : 0 ≤ r) : (ENNReal.ofReal r).toReal = r 
Arguments: {r : ℝ} (h : 0 ≤ r)
Goal: (ENNReal.ofReal r).toReal = r
-- ENNReal.toReal_ofReal'
theorem toReal_ofReal' {r : ℝ} : (ENNReal.ofReal r).toReal = max r 0 
Arguments: {r : ℝ}
Goal: (ENNReal.ofReal r).toReal = max r 0
-- ENNReal.coe_toNNReal_le_self
theorem coe_toNNReal_le_self : ∀ {a : ℝ≥0∞}, ↑a.toNNReal ≤ a
  
Arguments: {a : ℝ≥0∞}
Goal: ↑a.toNNReal ≤ a
-- ENNReal.coe_nnreal_eq
theorem coe_nnreal_eq (r : ℝ≥0) : (r : ℝ≥0∞) = ENNReal.ofReal r 
Arguments: (r : ℝ≥0)
Goal: ↑r = ENNReal.ofReal ↑r
-- ENNReal.ofReal_eq_coe_nnreal
theorem ofReal_eq_coe_nnreal {x : ℝ} (h : 0 ≤ x) :
    ENNReal.ofReal x = ofNNReal ⟨x, h⟩ 
Arguments: {x : ℝ} (h : 0 ≤ x)
Goal: ENNReal.ofReal x = ↑⟨x, h⟩
-- ENNReal.ofReal_coe_nnreal
@[simp] theorem ofReal_coe_nnreal : ENNReal.ofReal p = p 
Arguments: {p : ℝ≥0}
Goal: ENNReal.ofReal ↑p = ↑p
-- ENNReal.coe_zero
@[simp, norm_cast] theorem coe_zero : ↑(0 : ℝ≥0) = (0 : ℝ≥0∞) 
Goal: ↑0 = 0
-- ENNReal.coe_one
@[simp, norm_cast] theorem coe_one : ↑(1 : ℝ≥0) = (1 : ℝ≥0∞) 
Goal: ↑1 = 1
-- ENNReal.toReal_nonneg
@[simp] theorem toReal_nonneg {a : ℝ≥0∞} : 0 ≤ a.toReal 
Arguments: {a : ℝ≥0∞}
Goal: 0 ≤ a.toReal
-- ENNReal.top_toNNReal
@[simp] theorem top_toNNReal : ∞.toNNReal = 0 
Goal: ⊤.toNNReal = 0
-- ENNReal.top_toReal
@[simp] theorem top_toReal : ∞.toReal = 0 
Goal: ⊤.toReal = 0
-- ENNReal.one_toReal
@[simp] theorem one_toReal : (1 : ℝ≥0∞).toReal = 1 
Goal: ENNReal.toReal 1 = 1
-- ENNReal.one_toNNReal
@[simp] theorem one_toNNReal : (1 : ℝ≥0∞).toNNReal = 1 
Goal: ENNReal.toNNReal 1 = 1
-- ENNReal.coe_toReal
@[simp] theorem coe_toReal (r : ℝ≥0) : (r : ℝ≥0∞).toReal = r 
Arguments: (r : ℝ≥0)
Goal: (↑r).toReal = ↑r
-- ENNReal.zero_toNNReal
@[simp] theorem zero_toNNReal : (0 : ℝ≥0∞).toNNReal = 0 
Goal: ENNReal.toNNReal 0 = 0
-- ENNReal.zero_toReal
@[simp] theorem zero_toReal : (0 : ℝ≥0∞).toReal = 0 
Goal: ENNReal.toReal 0 = 0
-- ENNReal.ofReal_zero
@[simp] theorem ofReal_zero : ENNReal.ofReal (0 : ℝ) = 0 
Goal: ENNReal.ofReal 0 = 0
-- ENNReal.ofReal_one
@[simp] theorem ofReal_one : ENNReal.ofReal (1 : ℝ) = (1 : ℝ≥0∞) 
Goal: ENNReal.ofReal 1 = 1
-- ENNReal.ofReal_toReal_le
theorem ofReal_toReal_le {a : ℝ≥0∞} : ENNReal.ofReal a.toReal ≤ a 
Arguments: {a : ℝ≥0∞}
Goal: ENNReal.ofReal a.toReal ≤ a
-- ENNReal.forall_ennreal
theorem forall_ennreal {p : ℝ≥0∞ → Prop} : (∀ a, p a) ↔ (∀ r : ℝ≥0, p r) ∧ p ∞ 
Arguments: {p : ℝ≥0∞ → Prop}
Goal: (∀ (a : ℝ≥0∞), p a) ↔ (∀ (r : ℝ≥0), p ↑r) ∧ p ⊤
-- ENNReal.forall_ne_top
theorem forall_ne_top {p : ℝ≥0∞ → Prop} : (∀ a, a ≠ ∞ → p a) ↔ ∀ r : ℝ≥0, p r 
Arguments: {p : ℝ≥0∞ → Prop}
Goal: (∀ (a : ℝ≥0∞), a ≠ ⊤ → p a) ↔ ∀ (r : ℝ≥0), p ↑r
-- ENNReal.exists_ne_top
theorem exists_ne_top {p : ℝ≥0∞ → Prop} : (∃ a ≠ ∞, p a) ↔ ∃ r : ℝ≥0, p r 
Arguments: {p : ℝ≥0∞ → Prop}
Goal: (∃ a, a ≠ ⊤ ∧ p a) ↔ ∃ r, p ↑r
-- ENNReal.toNNReal_eq_zero_iff
theorem toNNReal_eq_zero_iff (x : ℝ≥0∞) : x.toNNReal = 0 ↔ x = 0 ∨ x = ∞ 
Arguments: (x : ℝ≥0∞)
Goal: x.toNNReal = 0 ↔ x = 0 ∨ x = ⊤
-- ENNReal.toReal_eq_zero_iff
theorem toReal_eq_zero_iff (x : ℝ≥0∞) : x.toReal = 0 ↔ x = 0 ∨ x = ∞ 
Arguments: (x : ℝ≥0∞)
Goal: x.toReal = 0 ↔ x = 0 ∨ x = ⊤
-- ENNReal.toNNReal_ne_zero
theorem toNNReal_ne_zero : a.toNNReal ≠ 0 ↔ a ≠ 0 ∧ a ≠ ∞ 
Arguments: {a : ℝ≥0∞}
Goal: a.toNNReal ≠ 0 ↔ a ≠ 0 ∧ a ≠ ⊤
-- ENNReal.toReal_ne_zero
theorem toReal_ne_zero : a.toReal ≠ 0 ↔ a ≠ 0 ∧ a ≠ ∞ 
Arguments: {a : ℝ≥0∞}
Goal: a.toReal ≠ 0 ↔ a ≠ 0 ∧ a ≠ ⊤
-- ENNReal.toNNReal_eq_one_iff
theorem toNNReal_eq_one_iff (x : ℝ≥0∞) : x.toNNReal = 1 ↔ x = 1 
Arguments: (x : ℝ≥0∞)
Goal: x.toNNReal = 1 ↔ x = 1
-- ENNReal.toReal_eq_one_iff
theorem toReal_eq_one_iff (x : ℝ≥0∞) : x.toReal = 1 ↔ x = 1 
Arguments: (x : ℝ≥0∞)
Goal: x.toReal = 1 ↔ x = 1
-- ENNReal.toNNReal_ne_one
theorem toNNReal_ne_one : a.toNNReal ≠ 1 ↔ a ≠ 1 
Arguments: {a : ℝ≥0∞}
Goal: a.toNNReal ≠ 1 ↔ a ≠ 1
-- ENNReal.toReal_ne_one
theorem toReal_ne_one : a.toReal ≠ 1 ↔ a ≠ 1 
Arguments: {a : ℝ≥0∞}
Goal: a.toReal ≠ 1 ↔ a ≠ 1
-- ENNReal.coe_ne_top
@[simp] theorem coe_ne_top : (r : ℝ≥0∞) ≠ ∞ 
Arguments: {r : ℝ≥0}
Goal: ↑r ≠ ⊤
-- ENNReal.top_ne_coe
@[simp] theorem top_ne_coe : ∞ ≠ (r : ℝ≥0∞) 
Arguments: {r : ℝ≥0}
Goal: ⊤ ≠ ↑r
-- ENNReal.coe_lt_top
@[simp] theorem coe_lt_top : (r : ℝ≥0∞) < ∞ 
Arguments: {r : ℝ≥0}
Goal: ↑r < ⊤
-- ENNReal.ofReal_ne_top
@[simp] theorem ofReal_ne_top {r : ℝ} : ENNReal.ofReal r ≠ ∞ 
Arguments: {r : ℝ}
Goal: ENNReal.ofReal r ≠ ⊤
-- ENNReal.ofReal_lt_top
@[simp] theorem ofReal_lt_top {r : ℝ} : ENNReal.ofReal r < ∞ 
Arguments: {r : ℝ}
Goal: ENNReal.ofReal r < ⊤
-- ENNReal.top_ne_ofReal
@[simp] theorem top_ne_ofReal {r : ℝ} : ∞ ≠ ENNReal.ofReal r 
Arguments: {r : ℝ}
Goal: ⊤ ≠ ENNReal.ofReal r
-- ENNReal.ofReal_toReal_eq_iff
@[simp]
theorem ofReal_toReal_eq_iff : ENNReal.ofReal a.toReal = a ↔ a ≠ ⊤ 
Arguments: {a : ℝ≥0∞}
Goal: ENNReal.ofReal a.toReal = a ↔ a ≠ ⊤
-- ENNReal.toReal_ofReal_eq_iff
@[simp]
theorem toReal_ofReal_eq_iff {a : ℝ} : (ENNReal.ofReal a).toReal = a ↔ 0 ≤ a 
Arguments: {a : ℝ}
Goal: (ENNReal.ofReal a).toReal = a ↔ 0 ≤ a
-- ENNReal.zero_ne_top
@[simp] theorem zero_ne_top : 0 ≠ ∞ 
Goal: 0 ≠ ⊤
-- ENNReal.top_ne_zero
@[simp] theorem top_ne_zero : ∞ ≠ 0 
Goal: ⊤ ≠ 0
-- ENNReal.one_ne_top
@[simp] theorem one_ne_top : 1 ≠ ∞ 
Goal: 1 ≠ ⊤
-- ENNReal.top_ne_one
@[simp] theorem top_ne_one : ∞ ≠ 1 
Goal: ⊤ ≠ 1
-- ENNReal.zero_lt_top
@[simp] theorem zero_lt_top : 0 < ∞ 
Goal: 0 < ⊤
-- ENNReal.coe_le_coe
@[simp, norm_cast] theorem coe_le_coe : (↑r : ℝ≥0∞) ≤ ↑q ↔ r ≤ q 
Arguments: {r q : ℝ≥0}
Goal: ↑r ≤ ↑q ↔ r ≤ q
-- ENNReal.coe_lt_coe
@[simp, norm_cast] theorem coe_lt_coe : (↑r : ℝ≥0∞) < ↑q ↔ r < q 
Arguments: {r q : ℝ≥0}
Goal: ↑r < ↑q ↔ r < q
-- ENNReal.coe_mono
theorem coe_mono : Monotone ofNNReal 
Goal: Monotone ENNReal.ofNNReal
-- ENNReal.coe_strictMono
theorem coe_strictMono : StrictMono ofNNReal 
Goal: StrictMono ENNReal.ofNNReal
-- ENNReal.coe_eq_zero
@[simp, norm_cast] theorem coe_eq_zero : (↑r : ℝ≥0∞) = 0 ↔ r = 0 
Arguments: {r : ℝ≥0}
Goal: ↑r = 0 ↔ r = 0
-- ENNReal.zero_eq_coe
@[simp, norm_cast] theorem zero_eq_coe : 0 = (↑r : ℝ≥0∞) ↔ 0 = r 
Arguments: {r : ℝ≥0}
Goal: 0 = ↑r ↔ 0 = r
-- ENNReal.coe_eq_one
@[simp, norm_cast] theorem coe_eq_one : (↑r : ℝ≥0∞) = 1 ↔ r = 1 
Arguments: {r : ℝ≥0}
Goal: ↑r = 1 ↔ r = 1
-- ENNReal.one_eq_coe
@[simp, norm_cast] theorem one_eq_coe : 1 = (↑r : ℝ≥0∞) ↔ 1 = r 
Arguments: {r : ℝ≥0}
Goal: 1 = ↑r ↔ 1 = r
-- ENNReal.coe_pos
@[simp, norm_cast] theorem coe_pos : 0 < (r : ℝ≥0∞) ↔ 0 < r 
Arguments: {r : ℝ≥0}
Goal: 0 < ↑r ↔ 0 < r
-- ENNReal.coe_ne_zero
theorem coe_ne_zero : (r : ℝ≥0∞) ≠ 0 ↔ r ≠ 0 
Arguments: {r : ℝ≥0}
Goal: ↑r ≠ 0 ↔ r ≠ 0
-- ENNReal.coe_ne_one
lemma coe_ne_one : (r : ℝ≥0∞) ≠ 1 ↔ r ≠ 1 
Arguments: {r : ℝ≥0}
Goal: ↑r ≠ 1 ↔ r ≠ 1
-- ENNReal.coe_add
@[simp, norm_cast] lemma coe_add (x y : ℝ≥0) : (↑(x + y) : ℝ≥0∞) = x + y 
Arguments: (x y : ℝ≥0)
Goal: ↑(x + y) = ↑x + ↑y
-- ENNReal.coe_mul
@[simp, norm_cast] lemma coe_mul (x y : ℝ≥0) : (↑(x * y) : ℝ≥0∞) = x * y 
Arguments: (x y : ℝ≥0)
Goal: ↑(x * y) = ↑x * ↑y
-- ENNReal.coe_nsmul
@[norm_cast] lemma coe_nsmul (n : ℕ) (x : ℝ≥0) : (↑(n • x) : ℝ≥0∞) = n • x 
Arguments: (n : ℕ) (x : ℝ≥0)
Goal: ↑(n • x) = n • ↑x
-- ENNReal.coe_pow
@[simp, norm_cast] lemma coe_pow (x : ℝ≥0) (n : ℕ) : (↑(x ^ n) : ℝ≥0∞) = x ^ n 
Arguments: (x : ℝ≥0) (n : ℕ)
Goal: ↑(x ^ n) = ↑x ^ n
-- ENNReal.coe_ofNat
@[simp, norm_cast]
theorem coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n) : ℝ≥0) : ℝ≥0∞) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- ENNReal.coe_two
theorem coe_two : ((2 : ℝ≥0) : ℝ≥0∞) = 2 
Goal: ↑2 = 2
-- ENNReal.toNNReal_eq_toNNReal_iff
theorem toNNReal_eq_toNNReal_iff (x y : ℝ≥0∞) :
    x.toNNReal = y.toNNReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0 
Arguments: (x y : ℝ≥0∞)
Goal: x.toNNReal = y.toNNReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0
-- ENNReal.toReal_eq_toReal_iff
theorem toReal_eq_toReal_iff (x y : ℝ≥0∞) :
    x.toReal = y.toReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0 
Arguments: (x y : ℝ≥0∞)
Goal: x.toReal = y.toReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0
-- ENNReal.toNNReal_eq_toNNReal_iff'
theorem toNNReal_eq_toNNReal_iff' {x y : ℝ≥0∞} (hx : x ≠ ⊤) (hy : y ≠ ⊤) :
    x.toNNReal = y.toNNReal ↔ x = y 
Arguments: {x y : ℝ≥0∞} (hx : x ≠ ⊤) (hy : y ≠ ⊤)
Goal: x.toNNReal = y.toNNReal ↔ x = y
-- ENNReal.toReal_eq_toReal_iff'
theorem toReal_eq_toReal_iff' {x y : ℝ≥0∞} (hx : x ≠ ⊤) (hy : y ≠ ⊤) :
    x.toReal = y.toReal ↔ x = y 
Arguments: {x y : ℝ≥0∞} (hx : x ≠ ⊤) (hy : y ≠ ⊤)
Goal: x.toReal = y.toReal ↔ x = y
-- ENNReal.one_lt_two
theorem one_lt_two : (1 : ℝ≥0∞) < 2 
Goal: 1 < 2
-- ENNReal.two_ne_top
@[simp] theorem two_ne_top : (2 : ℝ≥0∞) ≠ ∞ 
Goal: 2 ≠ ⊤
-- ENNReal.two_lt_top
@[simp] theorem two_lt_top : (2 : ℝ≥0∞) < ∞ 
Goal: 2 < ⊤
-- ENNReal.cinfi_ne_top
theorem cinfi_ne_top [InfSet α] (f : ℝ≥0∞ → α) : ⨅ x : { x // x ≠ ∞ }, f x = ⨅ x : ℝ≥0, f x 
Arguments: {α : Type u_1} [InfSet α] (f : ℝ≥0∞ → α)
Goal: ⨅ x, f ↑x = ⨅ x, f ↑x
-- ENNReal.iInf_ne_top
theorem iInf_ne_top [CompleteLattice α] (f : ℝ≥0∞ → α) :
    ⨅ (x) (_ : x ≠ ∞), f x = ⨅ x : ℝ≥0, f x 
Arguments: {α : Type u_1} [CompleteLattice α] (f : ℝ≥0∞ → α)
Goal: ⨅ x, ⨅ (_ : x ≠ ⊤), f x = ⨅ x, f ↑x
-- ENNReal.csupr_ne_top
theorem csupr_ne_top [SupSet α] (f : ℝ≥0∞ → α) : ⨆ x : { x // x ≠ ∞ }, f x = ⨆ x : ℝ≥0, f x 
Arguments: {α : Type u_1} [SupSet α] (f : ℝ≥0∞ → α)
Goal: ⨆ x, f ↑x = ⨆ x, f ↑x
-- ENNReal.iSup_ne_top
theorem iSup_ne_top [CompleteLattice α] (f : ℝ≥0∞ → α) :
    ⨆ (x) (_ : x ≠ ∞), f x = ⨆ x : ℝ≥0, f x 
Arguments: {α : Type u_1} [CompleteLattice α] (f : ℝ≥0∞ → α)
Goal: ⨆ x, ⨆ (_ : x ≠ ⊤), f x = ⨆ x, f ↑x
-- ENNReal.iInf_ennreal
theorem iInf_ennreal {α : Type*} [CompleteLattice α] {f : ℝ≥0∞ → α} :
    ⨅ n, f n = (⨅ n : ℝ≥0, f n) ⊓ f ∞ 
Arguments: {α : Type u_2} [CompleteLattice α] {f : ℝ≥0∞ → α}
Goal: ⨅ n, f n = (⨅ n, f ↑n) ⊓ f ⊤
-- ENNReal.iSup_ennreal
theorem iSup_ennreal {α : Type*} [CompleteLattice α] {f : ℝ≥0∞ → α} :
    ⨆ n, f n = (⨆ n : ℝ≥0, f n) ⊔ f ∞ 
Arguments: {α : Type u_2} [CompleteLattice α] {f : ℝ≥0∞ → α}
Goal: ⨆ n, f n = (⨆ n, f ↑n) ⊔ f ⊤
-- ENNReal.coe_ofNNRealHom
@[simp] theorem coe_ofNNRealHom : ⇑ofNNRealHom = some 
Goal: ⇑ENNReal.ofNNRealHom = some
-- ENNReal.coe_indicator
@[simp, norm_cast]
theorem coe_indicator {α} (s : Set α) (f : α → ℝ≥0) (a : α) :
    ((s.indicator f a : ℝ≥0) : ℝ≥0∞) = s.indicator (fun x => ↑(f x)) a 
Arguments: {α : Type u_2} (s : Set α) (f : α → ℝ≥0) (a : α)
Goal: ↑(s.indicator f a) = s.indicator (fun x => ↑(f x)) a
-- ENNReal.bot_eq_zero
theorem bot_eq_zero : (⊥ : ℝ≥0∞) = 0 
Goal: ⊥ = 0
-- ENNReal.not_top_le_coe
theorem not_top_le_coe : ¬∞ ≤ ↑r 
Arguments: {r : ℝ≥0}
Goal: ¬⊤ ≤ ↑r
-- ENNReal.one_le_coe_iff
@[simp, norm_cast]
theorem one_le_coe_iff : (1 : ℝ≥0∞) ≤ ↑r ↔ 1 ≤ r 
Arguments: {r : ℝ≥0}
Goal: 1 ≤ ↑r ↔ 1 ≤ r
-- ENNReal.coe_le_one_iff
@[simp, norm_cast]
theorem coe_le_one_iff : ↑r ≤ (1 : ℝ≥0∞) ↔ r ≤ 1 
Arguments: {r : ℝ≥0}
Goal: ↑r ≤ 1 ↔ r ≤ 1
-- ENNReal.coe_lt_one_iff
@[simp, norm_cast]
theorem coe_lt_one_iff : (↑p : ℝ≥0∞) < 1 ↔ p < 1 
Arguments: {p : ℝ≥0}
Goal: ↑p < 1 ↔ p < 1
-- ENNReal.one_lt_coe_iff
@[simp, norm_cast]
theorem one_lt_coe_iff : 1 < (↑p : ℝ≥0∞) ↔ 1 < p 
Arguments: {p : ℝ≥0}
Goal: 1 < ↑p ↔ 1 < p
-- ENNReal.coe_natCast
@[simp, norm_cast]
theorem coe_natCast (n : ℕ) : ((n : ℝ≥0) : ℝ≥0∞) = n 
Arguments: (n : ℕ)
Goal: ↑↑n = ↑n
-- ENNReal.ofReal_natCast
@[simp, norm_cast] lemma ofReal_natCast (n : ℕ) : ENNReal.ofReal n = n 
Arguments: (n : ℕ)
Goal: ENNReal.ofReal ↑n = ↑n
-- ENNReal.ofReal_ofNat
@[simp] theorem ofReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    ENNReal.ofReal (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: ENNReal.ofReal (OfNat.ofNat n) = OfNat.ofNat n
-- ENNReal.natCast_ne_top
@[simp] theorem natCast_ne_top (n : ℕ) : (n : ℝ≥0∞) ≠ ∞ 
Arguments: (n : ℕ)
Goal: ↑n ≠ ⊤
-- ENNReal.top_ne_natCast
@[simp] theorem top_ne_natCast (n : ℕ) : ∞ ≠ n 
Arguments: (n : ℕ)
Goal: ⊤ ≠ ↑n
-- ENNReal.one_lt_top
@[simp] theorem one_lt_top : 1 < ∞ 
Goal: 1 < ⊤
-- ENNReal.toNNReal_nat
@[simp, norm_cast]
theorem toNNReal_nat (n : ℕ) : (n : ℝ≥0∞).toNNReal = n 
Arguments: (n : ℕ)
Goal: (↑n).toNNReal = ↑n
-- ENNReal.toReal_nat
@[simp, norm_cast]
theorem toReal_nat (n : ℕ) : (n : ℝ≥0∞).toReal = n 
Arguments: (n : ℕ)
Goal: (↑n).toReal = ↑n
-- ENNReal.toReal_ofNat
@[simp] theorem toReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    ENNReal.toReal (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).toReal = OfNat.ofNat n
-- ENNReal.le_coe_iff
theorem le_coe_iff : a ≤ ↑r ↔ ∃ p : ℝ≥0, a = p ∧ p ≤ r 
Arguments: {a : ℝ≥0∞} {r : ℝ≥0}
Goal: a ≤ ↑r ↔ ∃ p, a = ↑p ∧ p ≤ r
-- ENNReal.coe_le_iff
theorem coe_le_iff : ↑r ≤ a ↔ ∀ p : ℝ≥0, a = p → r ≤ p 
Arguments: {a : ℝ≥0∞} {r : ℝ≥0}
Goal: ↑r ≤ a ↔ ∀ (p : ℝ≥0), a = ↑p → r ≤ p
-- ENNReal.lt_iff_exists_coe
theorem lt_iff_exists_coe : a < b ↔ ∃ p : ℝ≥0, a = p ∧ ↑p < b 
Arguments: {a b : ℝ≥0∞}
Goal: a < b ↔ ∃ p, a = ↑p ∧ ↑p < b
-- ENNReal.toReal_le_coe_of_le_coe
theorem toReal_le_coe_of_le_coe {a : ℝ≥0∞} {b : ℝ≥0} (h : a ≤ b) : a.toReal ≤ b 
Arguments: {a : ℝ≥0∞} {b : ℝ≥0} (h : a ≤ ↑b)
Goal: a.toReal ≤ ↑b
-- ENNReal.coe_finset_sup
@[simp, norm_cast]
theorem coe_finset_sup {s : Finset α} {f : α → ℝ≥0} : ↑(s.sup f) = s.sup fun x => (f x : ℝ≥0∞) 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℝ≥0}
Goal: ↑(s.sup f) = s.sup fun x => ↑(f x)
-- ENNReal.max_eq_zero_iff
@[simp] theorem max_eq_zero_iff : max a b = 0 ↔ a = 0 ∧ b = 0 
Arguments: {a b : ℝ≥0∞}
Goal: max a b = 0 ↔ a = 0 ∧ b = 0
-- ENNReal.max_zero_left
theorem max_zero_left : max 0 a = a 
Arguments: {a : ℝ≥0∞}
Goal: max 0 a = a
-- ENNReal.max_zero_right
theorem max_zero_right : max a 0 = a 
Arguments: {a : ℝ≥0∞}
Goal: max a 0 = a
-- ENNReal.sup_eq_max
@[simp] theorem sup_eq_max : a ⊔ b = max a b 
Arguments: {a b : ℝ≥0∞}
Goal: a ⊔ b = max a b
-- ENNReal.lt_iff_exists_rat_btwn
theorem lt_iff_exists_rat_btwn :
    a < b ↔ ∃ q : ℚ, 0 ≤ q ∧ a < Real.toNNReal q ∧ (Real.toNNReal q : ℝ≥0∞) < b 
Arguments: {a b : ℝ≥0∞}
Goal: a < b ↔ ∃ q, 0 ≤ q ∧ a < ↑(↑q).toNNReal ∧ ↑(↑q).toNNReal < b
-- ENNReal.lt_iff_exists_real_btwn
theorem lt_iff_exists_real_btwn :
    a < b ↔ ∃ r : ℝ, 0 ≤ r ∧ a < ENNReal.ofReal r ∧ (ENNReal.ofReal r : ℝ≥0∞) < b 
Arguments: {a b : ℝ≥0∞}
Goal: a < b ↔ ∃ r, 0 ≤ r ∧ a < ENNReal.ofReal r ∧ ENNReal.ofReal r < b
-- ENNReal.lt_iff_exists_nnreal_btwn
theorem lt_iff_exists_nnreal_btwn : a < b ↔ ∃ r : ℝ≥0, a < r ∧ (r : ℝ≥0∞) < b 
Arguments: {a b : ℝ≥0∞}
Goal: a < b ↔ ∃ r, a < ↑r ∧ ↑r < b
-- ENNReal.lt_iff_exists_add_pos_lt
theorem lt_iff_exists_add_pos_lt : a < b ↔ ∃ r : ℝ≥0, 0 < r ∧ a + r < b 
Arguments: {a b : ℝ≥0∞}
Goal: a < b ↔ ∃ r, 0 < r ∧ a + ↑r < b
-- ENNReal.le_of_forall_pos_le_add
theorem le_of_forall_pos_le_add (h : ∀ ε : ℝ≥0, 0 < ε → b < ∞ → a ≤ b + ε) : a ≤ b 
Arguments: {a b : ℝ≥0∞} (h : ∀ (ε : ℝ≥0), 0 < ε → b < ⊤ → a ≤ b + ↑ε)
Goal: a ≤ b
-- ENNReal.natCast_lt_coe
theorem natCast_lt_coe {n : ℕ} : n < (r : ℝ≥0∞) ↔ n < r 
Arguments: {r : ℝ≥0} {n : ℕ}
Goal: ↑n < ↑r ↔ ↑n < r
-- ENNReal.coe_lt_natCast
theorem coe_lt_natCast {n : ℕ} : (r : ℝ≥0∞) < n ↔ r < n 
Arguments: {r : ℝ≥0} {n : ℕ}
Goal: ↑r < ↑n ↔ r < ↑n
-- ENNReal.exists_nat_gt
protected theorem exists_nat_gt {r : ℝ≥0∞} (h : r ≠ ∞) : ∃ n : ℕ, r < n 
Arguments: {r : ℝ≥0∞} (h : r ≠ ⊤)
Goal: ∃ n, r < ↑n
-- ENNReal.iUnion_Iio_coe_nat
@[simp]
theorem iUnion_Iio_coe_nat : ⋃ n : ℕ, Iio (n : ℝ≥0∞) = {∞}ᶜ 
Goal: ⋃ n, Set.Iio ↑n = {⊤}ᶜ
-- ENNReal.iUnion_Iic_coe_nat
@[simp]
theorem iUnion_Iic_coe_nat : ⋃ n : ℕ, Iic (n : ℝ≥0∞) = {∞}ᶜ 
Goal: ⋃ n, Set.Iic ↑n = {⊤}ᶜ
-- ENNReal.iUnion_Ioc_coe_nat
@[simp]
theorem iUnion_Ioc_coe_nat : ⋃ n : ℕ, Ioc a n = Ioi a \ {∞} 
Arguments: {a : ℝ≥0∞}
Goal: ⋃ n, Set.Ioc a ↑n = Set.Ioi a \ {⊤}
-- ENNReal.iUnion_Ioo_coe_nat
@[simp]
theorem iUnion_Ioo_coe_nat : ⋃ n : ℕ, Ioo a n = Ioi a \ {∞} 
Arguments: {a : ℝ≥0∞}
Goal: ⋃ n, Set.Ioo a ↑n = Set.Ioi a \ {⊤}
-- ENNReal.iUnion_Icc_coe_nat
@[simp]
theorem iUnion_Icc_coe_nat : ⋃ n : ℕ, Icc a n = Ici a \ {∞} 
Arguments: {a : ℝ≥0∞}
Goal: ⋃ n, Set.Icc a ↑n = Set.Ici a \ {⊤}
-- ENNReal.iUnion_Ico_coe_nat
@[simp]
theorem iUnion_Ico_coe_nat : ⋃ n : ℕ, Ico a n = Ici a \ {∞} 
Arguments: {a : ℝ≥0∞}
Goal: ⋃ n, Set.Ico a ↑n = Set.Ici a \ {⊤}
-- ENNReal.iInter_Ici_coe_nat
@[simp]
theorem iInter_Ici_coe_nat : ⋂ n : ℕ, Ici (n : ℝ≥0∞) = {∞} 
Goal: ⋂ n, Set.Ici ↑n = {⊤}
-- ENNReal.iInter_Ioi_coe_nat
@[simp]
theorem iInter_Ioi_coe_nat : ⋂ n : ℕ, Ioi (n : ℝ≥0∞) = {∞} 
Goal: ⋂ n, Set.Ioi ↑n = {⊤}
-- ENNReal.coe_min
@[simp, norm_cast]
theorem coe_min (r p : ℝ≥0) : ((min r p : ℝ≥0) : ℝ≥0∞) = min (r : ℝ≥0∞) p 
Arguments: (r p : ℝ≥0)
Goal: ↑(min r p) = min ↑r ↑p
-- ENNReal.coe_max
@[simp, norm_cast]
theorem coe_max (r p : ℝ≥0) : ((max r p : ℝ≥0) : ℝ≥0∞) = max (r : ℝ≥0∞) p 
Arguments: (r p : ℝ≥0)
Goal: ↑(max r p) = max ↑r ↑p
-- ENNReal.le_of_top_imp_top_of_toNNReal_le
theorem le_of_top_imp_top_of_toNNReal_le {a b : ℝ≥0∞} (h : a = ⊤ → b = ⊤)
    (h_nnreal : a ≠ ⊤ → b ≠ ⊤ → a.toNNReal ≤ b.toNNReal) : a ≤ b 
Arguments: {a b : ℝ≥0∞} (h : a = ⊤ → b = ⊤) (h_nnreal : a ≠ ⊤ → b ≠ ⊤ → a.toNNReal ≤ b.toNNReal)
Goal: a ≤ b
-- ENNReal.abs_toReal
@[simp]
theorem abs_toReal {x : ℝ≥0∞} : |x.toReal| = x.toReal 
Arguments: {x : ℝ≥0∞}
Goal: |x.toReal| = x.toReal
-- ENNReal.coe_sSup
theorem coe_sSup {s : Set ℝ≥0} : BddAbove s → (↑(sSup s) : ℝ≥0∞) = ⨆ a ∈ s, ↑a 
Arguments: {s : Set ℝ≥0}
Goal: BddAbove s → ↑(sSup s) = ⨆ a ∈ s, ↑a
-- ENNReal.coe_sInf
theorem coe_sInf {s : Set ℝ≥0} (hs : s.Nonempty) : (↑(sInf s) : ℝ≥0∞) = ⨅ a ∈ s, ↑a 
Arguments: {s : Set ℝ≥0} (hs : s.Nonempty)
Goal: ↑(sInf s) = ⨅ a ∈ s, ↑a
-- ENNReal.coe_iSup
theorem coe_iSup {ι : Sort*} {f : ι → ℝ≥0} (hf : BddAbove (range f)) :
    (↑(iSup f) : ℝ≥0∞) = ⨆ a, ↑(f a) 
Arguments: {ι : Sort u_3} {f : ι → ℝ≥0} (hf : BddAbove (Set.range f))
Goal: ↑(iSup f) = ⨆ a, ↑(f a)
-- ENNReal.coe_iInf
@[norm_cast]
theorem coe_iInf {ι : Sort*} [Nonempty ι] (f : ι → ℝ≥0) : (↑(iInf f) : ℝ≥0∞) = ⨅ a, ↑(f a) 
Arguments: {ι : Sort u_3} [Nonempty ι] (f : ι → ℝ≥0)
Goal: ↑(iInf f) = ⨅ a, ↑(f a)
-- ENNReal.coe_mem_upperBounds
theorem coe_mem_upperBounds {s : Set ℝ≥0} :
    ↑r ∈ upperBounds (ofNNReal '' s) ↔ r ∈ upperBounds s 
Arguments: {r : ℝ≥0} {s : Set ℝ≥0}
Goal: ↑r ∈ upperBounds (ENNReal.ofNNReal '' s) ↔ r ∈ upperBounds s
-- ENNReal.iSup_coe_eq_top
lemma iSup_coe_eq_top : ⨆ i, (f i : ℝ≥0∞) = ⊤ ↔ ¬ BddAbove (range f) 
Arguments: {ι : Sort u_2} {f : ι → ℝ≥0}
Goal: ⨆ i, ↑(f i) = ⊤ ↔ ¬BddAbove (Set.range f)
-- ENNReal.iSup_coe_lt_top
lemma iSup_coe_lt_top : ⨆ i, (f i : ℝ≥0∞) < ⊤ ↔ BddAbove (range f) 
Arguments: {ι : Sort u_2} {f : ι → ℝ≥0}
Goal: ⨆ i, ↑(f i) < ⊤ ↔ BddAbove (Set.range f)
-- ENNReal.iInf_coe_eq_top
lemma iInf_coe_eq_top : ⨅ i, (f i : ℝ≥0∞) = ⊤ ↔ IsEmpty ι 
Arguments: {ι : Sort u_2} {f : ι → ℝ≥0}
Goal: ⨅ i, ↑(f i) = ⊤ ↔ IsEmpty ι
-- ENNReal.iInf_coe_lt_top
lemma iInf_coe_lt_top : ⨅ i, (f i : ℝ≥0∞) < ⊤ ↔ Nonempty ι 
Arguments: {ι : Sort u_2} {f : ι → ℝ≥0}
Goal: ⨅ i, ↑(f i) < ⊤ ↔ Nonempty ι
-- Set.OrdConnected.preimage_coe_nnreal_ennreal
theorem preimage_coe_nnreal_ennreal (h : u.OrdConnected) : ((↑) ⁻¹' u : Set ℝ≥0).OrdConnected 
Arguments: {u : Set ℝ≥0∞} (h : u.OrdConnected)
Goal: (ENNReal.ofNNReal ⁻¹' u).OrdConnected
-- Set.OrdConnected.image_coe_nnreal_ennreal
theorem image_coe_nnreal_ennreal (h : t.OrdConnected) : ((↑) '' t : Set ℝ≥0∞).OrdConnected 
Arguments: {t : Set ℝ≥0} (h : t.OrdConnected)
Goal: (ENNReal.ofNNReal '' t).OrdConnected
-- Set.OrdConnected.preimage_ennreal_ofReal
theorem preimage_ennreal_ofReal (h : u.OrdConnected) : (ENNReal.ofReal ⁻¹' u).OrdConnected 
Arguments: {u : Set ℝ≥0∞} (h : u.OrdConnected)
Goal: (ENNReal.ofReal ⁻¹' u).OrdConnected
-- Set.OrdConnected.image_ennreal_ofReal
theorem image_ennreal_ofReal (h : s.OrdConnected) : (ENNReal.ofReal '' s).OrdConnected 
Arguments: {s : Set ℝ} (h : s.OrdConnected)
Goal: (ENNReal.ofReal '' s).OrdConnected
-- Nat.maxPowDiv.go_succ
theorem go_succ {k p n : ℕ} : go (k+1) p n = go k p n + 1 
Arguments: {k p n : ℕ}
Goal: Nat.maxPowDiv.go (k + 1) p n = Nat.maxPowDiv.go k p n + 1
-- Nat.maxPowDiv.zero_base
@[simp]
theorem zero_base {n : ℕ} : maxPowDiv 0 n = 0 
Arguments: {n : ℕ}
Goal: Nat.maxPowDiv 0 n = 0
-- Nat.maxPowDiv.zero
@[simp]
theorem zero {p : ℕ} : maxPowDiv p 0 = 0 
Arguments: {p : ℕ}
Goal: p.maxPowDiv 0 = 0
-- Nat.maxPowDiv.base_mul_eq_succ
theorem base_mul_eq_succ {p n : ℕ} (hp : 1 < p) (hn : 0 < n) :
    p.maxPowDiv (p*n) = p.maxPowDiv n + 1 
Arguments: {p n : ℕ} (hp : 1 < p) (hn : 0 < n)
Goal: p.maxPowDiv (p * n) = p.maxPowDiv n + 1
-- Nat.maxPowDiv.base_pow_mul
theorem base_pow_mul {p n exp : ℕ} (hp : 1 < p) (hn : 0 < n) :
    p.maxPowDiv (p ^ exp * n) = p.maxPowDiv n + exp 
Arguments: {p n exp : ℕ} (hp : 1 < p) (hn : 0 < n)
Goal: p.maxPowDiv (p ^ exp * n) = p.maxPowDiv n + exp
-- Nat.maxPowDiv.pow_dvd
theorem pow_dvd (p n : ℕ) : p ^ (p.maxPowDiv n) ∣ n 
Arguments: (p n : ℕ)
Goal: p ^ p.maxPowDiv n ∣ n
-- Nat.maxPowDiv.le_of_dvd
theorem le_of_dvd {p n pow : ℕ} (hp : 1 < p) (hn : 0 < n) (h : p ^ pow ∣ n) :
    pow ≤ p.maxPowDiv n 
Arguments: {p n pow : ℕ} (hp : 1 < p) (hn : 0 < n) (h : p ^ pow ∣ n)
Goal: pow ≤ p.maxPowDiv n
-- Nat.find_spec
protected theorem find_spec : p (Nat.find H) 
Arguments: {p : ℕ → Prop} [DecidablePred p] (H : ∃ n, p n)
Goal: p (Nat.find H)
-- Nat.find_min
protected theorem find_min : ∀ {m : ℕ}, m < Nat.find H → ¬p m 
Arguments: {p : ℕ → Prop} [DecidablePred p] (H : ∃ n, p n) {m : ℕ}
Goal: m < Nat.find H → ¬p m
-- Nat.find_min'
protected theorem find_min' {m : ℕ} (h : p m) : Nat.find H ≤ m 
Arguments: {p : ℕ → Prop} [DecidablePred p] (H : ∃ n, p n) {m : ℕ} (h : p m)
Goal: Nat.find H ≤ m
-- Nat.find_eq_iff
lemma find_eq_iff (h : ∃ n : ℕ, p n) : Nat.find h = m ↔ p m ∧ ∀ n < m, ¬ p n 
Arguments: {m : ℕ} {p : ℕ → Prop} [DecidablePred p] (h : ∃ n, p n)
Goal: Nat.find h = m ↔ p m ∧ ∀ (n : ℕ), n < m → ¬p n
-- Nat.find_lt_iff
@[simp] lemma find_lt_iff (h : ∃ n : ℕ, p n) (n : ℕ) : Nat.find h < n ↔ ∃ m < n, p m 
Arguments: {p : ℕ → Prop} [DecidablePred p] (h : ∃ n, p n) (n : ℕ)
Goal: Nat.find h < n ↔ ∃ m, m < n ∧ p m
-- Nat.find_le_iff
@[simp] lemma find_le_iff (h : ∃ n : ℕ, p n) (n : ℕ) : Nat.find h ≤ n ↔ ∃ m ≤ n, p m 
Arguments: {p : ℕ → Prop} [DecidablePred p] (h : ∃ n, p n) (n : ℕ)
Goal: Nat.find h ≤ n ↔ ∃ m, m ≤ n ∧ p m
-- Nat.le_find_iff
@[simp] lemma le_find_iff (h : ∃ n : ℕ, p n) (n : ℕ) : n ≤ Nat.find h ↔ ∀ m < n, ¬ p m 
Arguments: {p : ℕ → Prop} [DecidablePred p] (h : ∃ n, p n) (n : ℕ)
Goal: n ≤ Nat.find h ↔ ∀ (m : ℕ), m < n → ¬p m
-- Nat.lt_find_iff
@[simp] lemma lt_find_iff (h : ∃ n : ℕ, p n) (n : ℕ) : n < Nat.find h ↔ ∀ m ≤ n, ¬ p m 
Arguments: {p : ℕ → Prop} [DecidablePred p] (h : ∃ n, p n) (n : ℕ)
Goal: n < Nat.find h ↔ ∀ (m : ℕ), m ≤ n → ¬p m
-- Nat.find_eq_zero
@[simp] lemma find_eq_zero (h : ∃ n : ℕ, p n) : Nat.find h = 0 ↔ p 0 
Arguments: {p : ℕ → Prop} [DecidablePred p] (h : ∃ n, p n)
Goal: Nat.find h = 0 ↔ p 0
-- Nat.find_mono
lemma find_mono (h : ∀ n, q n → p n) {hp : ∃ n, p n} {hq : ∃ n, q n} : Nat.find hp ≤ Nat.find hq 
Arguments: {p q : ℕ → Prop} [DecidablePred p] [DecidablePred q] (h : ∀ (n : ℕ), q n → p n) {hp : ∃ n, p n} {hq : ∃ n, q n}
Goal: Nat.find hp ≤ Nat.find hq