File: Mathlib/Topology/Instances/ENNReal.lean

full_name: ENNReal.instTopologicalSpace
code: /-- Topology on `ℝ≥0∞`.

Note: this is different from the `EMetricSpace` topology. The `EMetricSpace` topology has
`IsOpen {∞}`, while this topology doesn't have singleton elements. -/
instance : TopologicalSpace ℝ≥0∞ 
goal: TopologicalSpace ℝ≥0∞

full_name: ENNReal.instOrderTopology
code: instance : OrderTopology ℝ≥0∞ 
goal: OrderTopology ℝ≥0∞

full_name: ENNReal.instT2Space
code: instance : T2Space ℝ≥0∞ 
goal: T2Space ℝ≥0∞

full_name: ENNReal.instT5Space
code: instance : T5Space ℝ≥0∞ 
goal: T5Space ℝ≥0∞

full_name: ENNReal.instT4Space
code: instance : T4Space ℝ≥0∞ 
goal: T4Space ℝ≥0∞

full_name: ENNReal.instSecondCountableTopology
code: instance : SecondCountableTopology ℝ≥0∞ 
goal: SecondCountableTopology ℝ≥0∞

full_name: ENNReal.instMetrizableSpace
code: instance : MetrizableSpace ENNReal 
goal: TopologicalSpace.MetrizableSpace ℝ≥0∞

full_name: ENNReal.embedding_coe
code: theorem embedding_coe : Embedding ((↑) : ℝ≥0 → ℝ≥0∞) 
goal: Embedding ENNReal.ofNNReal

full_name: ENNReal.isOpen_ne_top
code: theorem isOpen_ne_top : IsOpen { a : ℝ≥0∞ | a ≠ ∞ } 
goal: IsOpen {a | a ≠ ⊤}

full_name: ENNReal.isOpen_Ico_zero
code: theorem isOpen_Ico_zero : IsOpen (Ico 0 b) 
goal: IsOpen (Set.Ico 0 b)

full_name: ENNReal.openEmbedding_coe
code: theorem openEmbedding_coe : OpenEmbedding ((↑) : ℝ≥0 → ℝ≥0∞) 
goal: OpenEmbedding ENNReal.ofNNReal

full_name: ENNReal.coe_range_mem_nhds
code: theorem coe_range_mem_nhds : range ((↑) : ℝ≥0 → ℝ≥0∞) ∈ 𝓝 (r : ℝ≥0∞) 
goal: Set.range ENNReal.ofNNReal ∈ 𝓝 ↑r

full_name: ENNReal.tendsto_coe
code: @[norm_cast]
theorem tendsto_coe {f : Filter α} {m : α → ℝ≥0} {a : ℝ≥0} :
    Tendsto (fun a => (m a : ℝ≥0∞)) f (𝓝 ↑a) ↔ Tendsto m f (𝓝 a) 
goal: Filter.Tendsto (fun a => ↑(m a)) f (𝓝 ↑a) ↔ Filter.Tendsto m f (𝓝 a)

full_name: ENNReal.continuous_coe
code: @[fun_prop]
theorem continuous_coe : Continuous ((↑) : ℝ≥0 → ℝ≥0∞) 
goal: Continuous ENNReal.ofNNReal

full_name: ENNReal.continuous_coe_iff
code: theorem continuous_coe_iff {α} [TopologicalSpace α] {f : α → ℝ≥0} :
    (Continuous fun a => (f a : ℝ≥0∞)) ↔ Continuous f 
goal: (Continuous fun a => ↑(f a)) ↔ Continuous f

full_name: ENNReal.nhds_coe
code: theorem nhds_coe {r : ℝ≥0} : 𝓝 (r : ℝ≥0∞) = (𝓝 r).map (↑) 
goal: 𝓝 ↑r = Filter.map ENNReal.ofNNReal (𝓝 r)

full_name: ENNReal.tendsto_nhds_coe_iff
code: theorem tendsto_nhds_coe_iff {α : Type*} {l : Filter α} {x : ℝ≥0} {f : ℝ≥0∞ → α} :
    Tendsto f (𝓝 ↑x) l ↔ Tendsto (f ∘ (↑) : ℝ≥0 → α) (𝓝 x) l 
goal: Filter.Tendsto f (𝓝 ↑x) l ↔ Filter.Tendsto (f ∘ ENNReal.ofNNReal) (𝓝 x) l

full_name: ENNReal.continuousAt_coe_iff
code: theorem continuousAt_coe_iff {α : Type*} [TopologicalSpace α] {x : ℝ≥0} {f : ℝ≥0∞ → α} :
    ContinuousAt f ↑x ↔ ContinuousAt (f ∘ (↑) : ℝ≥0 → α) x 
goal: ContinuousAt f ↑x ↔ ContinuousAt (f ∘ ENNReal.ofNNReal) x

full_name: ENNReal.nhds_coe_coe
code: theorem nhds_coe_coe {r p : ℝ≥0} :
    𝓝 ((r : ℝ≥0∞), (p : ℝ≥0∞)) = (𝓝 (r, p)).map fun p : ℝ≥0 × ℝ≥0 => (↑p.1, ↑p.2) 
goal: 𝓝 (↑r, ↑p) = Filter.map (fun p => (↑p.1, ↑p.2)) (𝓝 (r, p))

full_name: ENNReal.continuous_ofReal
code: theorem continuous_ofReal : Continuous ENNReal.ofReal 
goal: Continuous ENNReal.ofReal

full_name: ENNReal.tendsto_ofReal
code: theorem tendsto_ofReal {f : Filter α} {m : α → ℝ} {a : ℝ} (h : Tendsto m f (𝓝 a)) :
    Tendsto (fun a => ENNReal.ofReal (m a)) f (𝓝 (ENNReal.ofReal a)) 
goal: Filter.Tendsto (fun a => ENNReal.ofReal (m a)) f (𝓝 (ENNReal.ofReal a))

full_name: ENNReal.tendsto_toNNReal
code: theorem tendsto_toNNReal {a : ℝ≥0∞} (ha : a ≠ ∞) :
    Tendsto ENNReal.toNNReal (𝓝 a) (𝓝 a.toNNReal) 
goal: Filter.Tendsto ENNReal.toNNReal (𝓝 a) (𝓝 a.toNNReal)

full_name: ENNReal.eventuallyEq_of_toReal_eventuallyEq
code: theorem eventuallyEq_of_toReal_eventuallyEq {l : Filter α} {f g : α → ℝ≥0∞}
    (hfi : ∀ᶠ x in l, f x ≠ ∞) (hgi : ∀ᶠ x in l, g x ≠ ∞)
    (hfg : (fun x => (f x).toReal) =ᶠ[l] fun x => (g x).toReal) : f =ᶠ[l] g 
goal: f =ᶠ[l] g

full_name: ENNReal.continuousOn_toNNReal
code: theorem continuousOn_toNNReal : ContinuousOn ENNReal.toNNReal { a | a ≠ ∞ } 
goal: ContinuousOn ENNReal.toNNReal {a | a ≠ ⊤}

full_name: ENNReal.tendsto_toReal
code: theorem tendsto_toReal {a : ℝ≥0∞} (ha : a ≠ ∞) : Tendsto ENNReal.toReal (𝓝 a) (𝓝 a.toReal) 
goal: Filter.Tendsto ENNReal.toReal (𝓝 a) (𝓝 a.toReal)

full_name: ENNReal.continuousOn_toReal
code: lemma continuousOn_toReal : ContinuousOn ENNReal.toReal { a | a ≠ ∞ } 
goal: ContinuousOn ENNReal.toReal {a | a ≠ ⊤}

full_name: ENNReal.continuousAt_toReal
code: lemma continuousAt_toReal (hx : x ≠ ∞) : ContinuousAt ENNReal.toReal x 
goal: ContinuousAt ENNReal.toReal x

full_name: ENNReal.neTopHomeomorphNNReal
code: /-- The set of finite `ℝ≥0∞` numbers is homeomorphic to `ℝ≥0`. -/
def neTopHomeomorphNNReal : { a | a ≠ ∞ } ≃ₜ ℝ≥0 
goal: ↑{a | a ≠ ⊤} ≃ₜ ℝ≥0

full_name: ENNReal.ltTopHomeomorphNNReal
code: /-- The set of finite `ℝ≥0∞` numbers is homeomorphic to `ℝ≥0`. -/
def ltTopHomeomorphNNReal : { a | a < ∞ } ≃ₜ ℝ≥0 
goal: ↑{a | a < ⊤} ≃ₜ ℝ≥0

full_name: ENNReal.nhds_top
code: theorem nhds_top : 𝓝 ∞ = ⨅ (a) (_ : a ≠ ∞), 𝓟 (Ioi a) 
goal: 𝓝 ⊤ = ⨅ a, ⨅ (_ : a ≠ ⊤), 𝓟 (Set.Ioi a)

full_name: ENNReal.nhds_top'
code: theorem nhds_top' : 𝓝 ∞ = ⨅ r : ℝ≥0, 𝓟 (Ioi ↑r) 
goal: 𝓝 ⊤ = ⨅ r, 𝓟 (Set.Ioi ↑r)

full_name: ENNReal.nhds_top_basis
code: theorem nhds_top_basis : (𝓝 ∞).HasBasis (fun a => a < ∞) fun a => Ioi a 
goal: (𝓝 ⊤).HasBasis (fun a => a < ⊤) fun a => Set.Ioi a

full_name: ENNReal.tendsto_nhds_top_iff_nnreal
code: theorem tendsto_nhds_top_iff_nnreal {m : α → ℝ≥0∞} {f : Filter α} :
    Tendsto m f (𝓝 ∞) ↔ ∀ x : ℝ≥0, ∀ᶠ a in f, ↑x < m a 
goal: Filter.Tendsto m f (𝓝 ⊤) ↔ ∀ (x : ℝ≥0), ∀ᶠ (a : α) in f, ↑x < m a

full_name: ENNReal.tendsto_nhds_top_iff_nat
code: theorem tendsto_nhds_top_iff_nat {m : α → ℝ≥0∞} {f : Filter α} :
    Tendsto m f (𝓝 ∞) ↔ ∀ n : ℕ, ∀ᶠ a in f, ↑n < m a 
goal: Filter.Tendsto m f (𝓝 ⊤) ↔ ∀ (n : ℕ), ∀ᶠ (a : α) in f, ↑n < m a

full_name: ENNReal.tendsto_nhds_top
code: theorem tendsto_nhds_top {m : α → ℝ≥0∞} {f : Filter α} (h : ∀ n : ℕ, ∀ᶠ a in f, ↑n < m a) :
    Tendsto m f (𝓝 ∞) 
goal: Filter.Tendsto m f (𝓝 ⊤)

full_name: ENNReal.tendsto_nat_nhds_top
code: theorem tendsto_nat_nhds_top : Tendsto (fun n : ℕ => ↑n) atTop (𝓝 ∞) 
goal: Filter.Tendsto (fun n => ↑n) Filter.atTop (𝓝 ⊤)

full_name: ENNReal.tendsto_coe_nhds_top
code: @[simp, norm_cast]
theorem tendsto_coe_nhds_top {f : α → ℝ≥0} {l : Filter α} :
    Tendsto (fun x => (f x : ℝ≥0∞)) l (𝓝 ∞) ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => ↑(f x)) l (𝓝 ⊤) ↔ Filter.Tendsto f l Filter.atTop

full_name: ENNReal.tendsto_ofReal_nhds_top
code: @[simp]
theorem tendsto_ofReal_nhds_top {f : α → ℝ} {l : Filter α} :
    Tendsto (fun x ↦ ENNReal.ofReal (f x)) l (𝓝 ∞) ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => ENNReal.ofReal (f x)) l (𝓝 ⊤) ↔ Filter.Tendsto f l Filter.atTop

full_name: ENNReal.tendsto_ofReal_atTop
code: theorem tendsto_ofReal_atTop : Tendsto ENNReal.ofReal atTop (𝓝 ∞) 
goal: Filter.Tendsto ENNReal.ofReal Filter.atTop (𝓝 ⊤)

full_name: ENNReal.nhds_zero
code: theorem nhds_zero : 𝓝 (0 : ℝ≥0∞) = ⨅ (a) (_ : a ≠ 0), 𝓟 (Iio a) 
goal: 𝓝 0 = ⨅ a, ⨅ (_ : a ≠ 0), 𝓟 (Set.Iio a)

full_name: ENNReal.nhds_zero_basis
code: theorem nhds_zero_basis : (𝓝 (0 : ℝ≥0∞)).HasBasis (fun a : ℝ≥0∞ => 0 < a) fun a => Iio a 
goal: (𝓝 0).HasBasis (fun a => 0 < a) fun a => Set.Iio a

full_name: ENNReal.nhds_zero_basis_Iic
code: theorem nhds_zero_basis_Iic : (𝓝 (0 : ℝ≥0∞)).HasBasis (fun a : ℝ≥0∞ => 0 < a) Iic 
goal: (𝓝 0).HasBasis (fun a => 0 < a) Set.Iic

full_name: ENNReal.nhdsWithin_Ioi_coe_neBot
code: @[instance]
theorem nhdsWithin_Ioi_coe_neBot {r : ℝ≥0} : (𝓝[>] (r : ℝ≥0∞)).NeBot 
goal: (𝓝[>] ↑r).NeBot

full_name: ENNReal.nhdsWithin_Ioi_zero_neBot
code: @[instance]
theorem nhdsWithin_Ioi_zero_neBot : (𝓝[>] (0 : ℝ≥0∞)).NeBot 
goal: (𝓝[>] 0).NeBot

full_name: ENNReal.nhdsWithin_Ioi_one_neBot
code: @[instance]
theorem nhdsWithin_Ioi_one_neBot : (𝓝[>] (1 : ℝ≥0∞)).NeBot 
goal: (𝓝[>] 1).NeBot

full_name: ENNReal.nhdsWithin_Ioi_nat_neBot
code: @[instance]
theorem nhdsWithin_Ioi_nat_neBot (n : ℕ) : (𝓝[>] (n : ℝ≥0∞)).NeBot 
goal: (𝓝[>] ↑n).NeBot

full_name: ENNReal.nhdsWithin_Ioi_ofNat_nebot
code: @[instance]
theorem nhdsWithin_Ioi_ofNat_nebot (n : ℕ) [n.AtLeastTwo] :
    (𝓝[>] (OfNat.ofNat n : ℝ≥0∞)).NeBot 
goal: (𝓝[>] OfNat.ofNat n).NeBot

full_name: ENNReal.nhdsWithin_Iio_neBot
code: @[instance]
theorem nhdsWithin_Iio_neBot [NeZero x] : (𝓝[<] x).NeBot 
goal: (𝓝[<] x).NeBot

full_name: ENNReal.hasBasis_nhds_of_ne_top'
code: /-- Closed intervals `Set.Icc (x - ε) (x + ε)`, `ε ≠ 0`, form a basis of neighborhoods of an
extended nonnegative real number `x ≠ ∞`. We use `Set.Icc` instead of `Set.Ioo` because this way the
statement works for `x = 0`.
-/
theorem hasBasis_nhds_of_ne_top' (xt : x ≠ ∞) :
    (𝓝 x).HasBasis (· ≠ 0) (fun ε => Icc (x - ε) (x + ε)) 
goal: (𝓝 x).HasBasis (fun x => x ≠ 0) fun ε => Set.Icc (x - ε) (x + ε)

full_name: ENNReal.hasBasis_nhds_of_ne_top
code: theorem hasBasis_nhds_of_ne_top (xt : x ≠ ∞) :
    (𝓝 x).HasBasis (0 < ·) (fun ε => Icc (x - ε) (x + ε)) 
goal: (𝓝 x).HasBasis (fun x => 0 < x) fun ε => Set.Icc (x - ε) (x + ε)

full_name: ENNReal.Icc_mem_nhds
code: theorem Icc_mem_nhds (xt : x ≠ ∞) (ε0 : ε ≠ 0) : Icc (x - ε) (x + ε) ∈ 𝓝 x 
goal: Set.Icc (x - ε) (x + ε) ∈ 𝓝 x

full_name: ENNReal.nhds_of_ne_top
code: theorem nhds_of_ne_top (xt : x ≠ ∞) : 𝓝 x = ⨅ ε > 0, 𝓟 (Icc (x - ε) (x + ε)) 
goal: 𝓝 x = ⨅ ε, ⨅ (_ : ε > 0), 𝓟 (Set.Icc (x - ε) (x + ε))

full_name: ENNReal.biInf_le_nhds
code: theorem biInf_le_nhds : ∀ x : ℝ≥0∞, ⨅ ε > 0, 𝓟 (Icc (x - ε) (x + ε)) ≤ 𝓝 x
  
goal: ⨅ ε, ⨅ (_ : ε > 0), 𝓟 (Set.Icc (x - ε) (x + ε)) ≤ 𝓝 x

full_name: ENNReal.tendsto_nhds_of_Icc
code: protected theorem tendsto_nhds_of_Icc {f : Filter α} {u : α → ℝ≥0∞} {a : ℝ≥0∞}
    (h : ∀ ε > 0, ∀ᶠ x in f, u x ∈ Icc (a - ε) (a + ε)) : Tendsto u f (𝓝 a) 
goal: Filter.Tendsto u f (𝓝 a)

full_name: ENNReal.tendsto_nhds
code: /-- Characterization of neighborhoods for `ℝ≥0∞` numbers. See also `tendsto_order`
for a version with strict inequalities. -/
protected theorem tendsto_nhds {f : Filter α} {u : α → ℝ≥0∞} {a : ℝ≥0∞} (ha : a ≠ ∞) :
    Tendsto u f (𝓝 a) ↔ ∀ ε > 0, ∀ᶠ x in f, u x ∈ Icc (a - ε) (a + ε) 
goal: Filter.Tendsto u f (𝓝 a) ↔ ∀ ε > 0, ∀ᶠ (x : α) in f, u x ∈ Set.Icc (a - ε) (a + ε)

full_name: ENNReal.tendsto_nhds_zero
code: protected theorem tendsto_nhds_zero {f : Filter α} {u : α → ℝ≥0∞} :
    Tendsto u f (𝓝 0) ↔ ∀ ε > 0, ∀ᶠ x in f, u x ≤ ε 
goal: Filter.Tendsto u f (𝓝 0) ↔ ∀ ε > 0, ∀ᶠ (x : α) in f, u x ≤ ε

full_name: ENNReal.tendsto_atTop
code: protected theorem tendsto_atTop [Nonempty β] [SemilatticeSup β] {f : β → ℝ≥0∞} {a : ℝ≥0∞}
    (ha : a ≠ ∞) : Tendsto f atTop (𝓝 a) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, f n ∈ Icc (a - ε) (a + ε) 
goal: Filter.Tendsto f Filter.atTop (𝓝 a) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, f n ∈ Set.Icc (a - ε) (a + ε)

full_name: ENNReal.instContinuousAdd
code: instance : ContinuousAdd ℝ≥0∞ 
goal: ContinuousAdd ℝ≥0∞

full_name: ENNReal.tendsto_atTop_zero
code: protected theorem tendsto_atTop_zero [Nonempty β] [SemilatticeSup β] {f : β → ℝ≥0∞} :
    Tendsto f atTop (𝓝 0) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, f n ≤ ε 
goal: Filter.Tendsto f Filter.atTop (𝓝 0) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, f n ≤ ε

full_name: ENNReal.tendsto_sub
code: theorem tendsto_sub : ∀ {a b : ℝ≥0∞}, (a ≠ ∞ ∨ b ≠ ∞) →
    Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 - p.2) (𝓝 (a, b)) (𝓝 (a - b))
  
goal: a ≠ ⊤ ∨ b ≠ ⊤ → Filter.Tendsto (fun p => p.1 - p.2) (𝓝 (a, b)) (𝓝 (a - b))

full_name: ENNReal.Tendsto.sub
code: protected theorem Tendsto.sub {f : Filter α} {ma : α → ℝ≥0∞} {mb : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hma : Tendsto ma f (𝓝 a)) (hmb : Tendsto mb f (𝓝 b)) (h : a ≠ ∞ ∨ b ≠ ∞) :
    Tendsto (fun a => ma a - mb a) f (𝓝 (a - b)) 
goal: Filter.Tendsto (fun a => ma a - mb a) f (𝓝 (a - b))

full_name: ENNReal.tendsto_mul
code: protected theorem tendsto_mul (ha : a ≠ 0 ∨ b ≠ ∞) (hb : b ≠ 0 ∨ a ≠ ∞) :
    Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 * p.2) (𝓝 (a, b)) (𝓝 (a * b)) 
goal: Filter.Tendsto (fun p => p.1 * p.2) (𝓝 (a, b)) (𝓝 (a * b))

full_name: ENNReal.Tendsto.mul
code: protected theorem Tendsto.mul {f : Filter α} {ma : α → ℝ≥0∞} {mb : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hma : Tendsto ma f (𝓝 a)) (ha : a ≠ 0 ∨ b ≠ ∞) (hmb : Tendsto mb f (𝓝 b))
    (hb : b ≠ 0 ∨ a ≠ ∞) : Tendsto (fun a => ma a * mb a) f (𝓝 (a * b)) 
goal: Filter.Tendsto (fun a => ma a * mb a) f (𝓝 (a * b))

full_name: ContinuousOn.ennreal_mul
code: theorem _root_.ContinuousOn.ennreal_mul [TopologicalSpace α] {f g : α → ℝ≥0∞} {s : Set α}
    (hf : ContinuousOn f s) (hg : ContinuousOn g s) (h₁ : ∀ x ∈ s, f x ≠ 0 ∨ g x ≠ ∞)
    (h₂ : ∀ x ∈ s, g x ≠ 0 ∨ f x ≠ ∞) : ContinuousOn (fun x => f x * g x) s 
goal: ContinuousOn (fun x => f x * g x) s

full_name: Continuous.ennreal_mul
code: theorem _root_.Continuous.ennreal_mul [TopologicalSpace α] {f g : α → ℝ≥0∞} (hf : Continuous f)
    (hg : Continuous g) (h₁ : ∀ x, f x ≠ 0 ∨ g x ≠ ∞) (h₂ : ∀ x, g x ≠ 0 ∨ f x ≠ ∞) :
    Continuous fun x => f x * g x 
goal: Continuous fun x => f x * g x

full_name: ENNReal.Tendsto.const_mul
code: protected theorem Tendsto.const_mul {f : Filter α} {m : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hm : Tendsto m f (𝓝 b)) (hb : b ≠ 0 ∨ a ≠ ∞) : Tendsto (fun b => a * m b) f (𝓝 (a * b)) 
goal: Filter.Tendsto (fun b => a * m b) f (𝓝 (a * b))

full_name: ENNReal.Tendsto.mul_const
code: protected theorem Tendsto.mul_const {f : Filter α} {m : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hm : Tendsto m f (𝓝 a)) (ha : a ≠ 0 ∨ b ≠ ∞) : Tendsto (fun x => m x * b) f (𝓝 (a * b)) 
goal: Filter.Tendsto (fun x => m x * b) f (𝓝 (a * b))

full_name: ENNReal.tendsto_finset_prod_of_ne_top
code: theorem tendsto_finset_prod_of_ne_top {ι : Type*} {f : ι → α → ℝ≥0∞} {x : Filter α} {a : ι → ℝ≥0∞}
    (s : Finset ι) (h : ∀ i ∈ s, Tendsto (f i) x (𝓝 (a i))) (h' : ∀ i ∈ s, a i ≠ ∞) :
    Tendsto (fun b => ∏ c ∈ s, f c b) x (𝓝 (∏ c ∈ s, a c)) 
goal: Filter.Tendsto (fun b => ∏ c ∈ s, f c b) x (𝓝 (∏ c ∈ s, a c))

full_name: ENNReal.continuousAt_const_mul
code: protected theorem continuousAt_const_mul {a b : ℝ≥0∞} (h : a ≠ ∞ ∨ b ≠ 0) :
    ContinuousAt (a * ·) b 
goal: ContinuousAt (fun x => a * x) b

full_name: ENNReal.continuousAt_mul_const
code: protected theorem continuousAt_mul_const {a b : ℝ≥0∞} (h : a ≠ ∞ ∨ b ≠ 0) :
    ContinuousAt (fun x => x * a) b 
goal: ContinuousAt (fun x => x * a) b

full_name: ENNReal.continuous_const_mul
code: protected theorem continuous_const_mul {a : ℝ≥0∞} (ha : a ≠ ∞) : Continuous (a * ·) 
goal: Continuous fun x => a * x

full_name: ENNReal.continuous_mul_const
code: protected theorem continuous_mul_const {a : ℝ≥0∞} (ha : a ≠ ∞) : Continuous fun x => x * a 
goal: Continuous fun x => x * a

full_name: ENNReal.continuous_div_const
code: protected theorem continuous_div_const (c : ℝ≥0∞) (c_ne_zero : c ≠ 0) :
    Continuous fun x : ℝ≥0∞ => x / c 
goal: Continuous fun x => x / c

full_name: ENNReal.continuous_pow
code: @[continuity]
theorem continuous_pow (n : ℕ) : Continuous fun a : ℝ≥0∞ => a ^ n 
goal: Continuous fun a => a ^ n

full_name: ENNReal.continuousOn_sub
code: theorem continuousOn_sub :
    ContinuousOn (fun p : ℝ≥0∞ × ℝ≥0∞ => p.fst - p.snd) { p : ℝ≥0∞ × ℝ≥0∞ | p ≠ ⟨∞, ∞⟩ } 
goal: ContinuousOn (fun p => p.1 - p.2) {p | p ≠ (⊤, ⊤)}

full_name: ENNReal.continuous_sub_left
code: theorem continuous_sub_left {a : ℝ≥0∞} (a_ne_top : a ≠ ∞) : Continuous (a - ·) 
goal: Continuous fun x => a - x

full_name: ENNReal.continuous_nnreal_sub
code: theorem continuous_nnreal_sub {a : ℝ≥0} : Continuous fun x : ℝ≥0∞ => (a : ℝ≥0∞) - x 
goal: Continuous fun x => ↑a - x

full_name: ENNReal.continuousOn_sub_left
code: theorem continuousOn_sub_left (a : ℝ≥0∞) : ContinuousOn (a - ·) { x : ℝ≥0∞ | x ≠ ∞ } 
goal: ContinuousOn (fun x => a - x) {x | x ≠ ⊤}

full_name: ENNReal.continuous_sub_right
code: theorem continuous_sub_right (a : ℝ≥0∞) : Continuous fun x : ℝ≥0∞ => x - a 
goal: Continuous fun x => x - a

full_name: ENNReal.Tendsto.pow
code: protected theorem Tendsto.pow {f : Filter α} {m : α → ℝ≥0∞} {a : ℝ≥0∞} {n : ℕ}
    (hm : Tendsto m f (𝓝 a)) : Tendsto (fun x => m x ^ n) f (𝓝 (a ^ n)) 
goal: Filter.Tendsto (fun x => m x ^ n) f (𝓝 (a ^ n))

full_name: ENNReal.le_of_forall_lt_one_mul_le
code: theorem le_of_forall_lt_one_mul_le {x y : ℝ≥0∞} (h : ∀ a < 1, a * x ≤ y) : x ≤ y 
goal: x ≤ y

full_name: ENNReal.iInf_mul_left'
code: theorem iInf_mul_left' {ι} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} (h : a = ∞ → ⨅ i, f i = 0 → ∃ i, f i = 0)
    (h0 : a = 0 → Nonempty ι) : ⨅ i, a * f i = a * ⨅ i, f i 
goal: ⨅ i, a * f i = a * ⨅ i, f i

full_name: ENNReal.iInf_mul_left
code: theorem iInf_mul_left {ι} [Nonempty ι] {f : ι → ℝ≥0∞} {a : ℝ≥0∞}
    (h : a = ∞ → ⨅ i, f i = 0 → ∃ i, f i = 0) : ⨅ i, a * f i = a * ⨅ i, f i 
goal: ⨅ i, a * f i = a * ⨅ i, f i

full_name: ENNReal.iInf_mul_right'
code: theorem iInf_mul_right' {ι} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} (h : a = ∞ → ⨅ i, f i = 0 → ∃ i, f i = 0)
    (h0 : a = 0 → Nonempty ι) : ⨅ i, f i * a = (⨅ i, f i) * a 
goal: ⨅ i, f i * a = (⨅ i, f i) * a

full_name: ENNReal.iInf_mul_right
code: theorem iInf_mul_right {ι} [Nonempty ι] {f : ι → ℝ≥0∞} {a : ℝ≥0∞}
    (h : a = ∞ → ⨅ i, f i = 0 → ∃ i, f i = 0) : ⨅ i, f i * a = (⨅ i, f i) * a 
goal: ⨅ i, f i * a = (⨅ i, f i) * a

full_name: ENNReal.inv_map_iInf
code: theorem inv_map_iInf {ι : Sort*} {x : ι → ℝ≥0∞} : (iInf x)⁻¹ = ⨆ i, (x i)⁻¹ 
goal: (iInf x)⁻¹ = ⨆ i, (x i)⁻¹

full_name: ENNReal.inv_map_iSup
code: theorem inv_map_iSup {ι : Sort*} {x : ι → ℝ≥0∞} : (iSup x)⁻¹ = ⨅ i, (x i)⁻¹ 
goal: (iSup x)⁻¹ = ⨅ i, (x i)⁻¹

full_name: ENNReal.inv_limsup
code: theorem inv_limsup {ι : Sort _} {x : ι → ℝ≥0∞} {l : Filter ι} :
    (limsup x l)⁻¹ = liminf (fun i => (x i)⁻¹) l 
goal: (Filter.limsup x l)⁻¹ = Filter.liminf (fun i => (x i)⁻¹) l

full_name: ENNReal.inv_liminf
code: theorem inv_liminf {ι : Sort _} {x : ι → ℝ≥0∞} {l : Filter ι} :
    (liminf x l)⁻¹ = limsup (fun i => (x i)⁻¹) l 
goal: (Filter.liminf x l)⁻¹ = Filter.limsup (fun i => (x i)⁻¹) l

full_name: ENNReal.instContinuousInv
code: instance : ContinuousInv ℝ≥0∞ 
goal: ContinuousInv ℝ≥0∞

full_name: ENNReal.tendsto_inv_iff
code: @[simp] -- Porting note (#11215): TODO: generalize to `[InvolutiveInv _] [ContinuousInv _]`
protected theorem tendsto_inv_iff {f : Filter α} {m : α → ℝ≥0∞} {a : ℝ≥0∞} :
    Tendsto (fun x => (m x)⁻¹) f (𝓝 a⁻¹) ↔ Tendsto m f (𝓝 a) 
goal: Filter.Tendsto (fun x => (m x)⁻¹) f (𝓝 a⁻¹) ↔ Filter.Tendsto m f (𝓝 a)

full_name: ENNReal.Tendsto.div
code: protected theorem Tendsto.div {f : Filter α} {ma : α → ℝ≥0∞} {mb : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hma : Tendsto ma f (𝓝 a)) (ha : a ≠ 0 ∨ b ≠ 0) (hmb : Tendsto mb f (𝓝 b))
    (hb : b ≠ ∞ ∨ a ≠ ∞) : Tendsto (fun a => ma a / mb a) f (𝓝 (a / b)) 
goal: Filter.Tendsto (fun a => ma a / mb a) f (𝓝 (a / b))

full_name: ENNReal.Tendsto.const_div
code: protected theorem Tendsto.const_div {f : Filter α} {m : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hm : Tendsto m f (𝓝 b)) (hb : b ≠ ∞ ∨ a ≠ ∞) : Tendsto (fun b => a / m b) f (𝓝 (a / b)) 
goal: Filter.Tendsto (fun b => a / m b) f (𝓝 (a / b))

full_name: ENNReal.Tendsto.div_const
code: protected theorem Tendsto.div_const {f : Filter α} {m : α → ℝ≥0∞} {a b : ℝ≥0∞}
    (hm : Tendsto m f (𝓝 a)) (ha : a ≠ 0 ∨ b ≠ 0) : Tendsto (fun x => m x / b) f (𝓝 (a / b)) 
goal: Filter.Tendsto (fun x => m x / b) f (𝓝 (a / b))

full_name: ENNReal.tendsto_inv_nat_nhds_zero
code: protected theorem tendsto_inv_nat_nhds_zero : Tendsto (fun n : ℕ => (n : ℝ≥0∞)⁻¹) atTop (𝓝 0) 
goal: Filter.Tendsto (fun n => (↑n)⁻¹) Filter.atTop (𝓝 0)

full_name: ENNReal.iSup_add
code: theorem iSup_add {ι : Sort*} {s : ι → ℝ≥0∞} [Nonempty ι] : iSup s + a = ⨆ b, s b + a 
goal: iSup s + a = ⨆ b, s b + a

full_name: ENNReal.biSup_add'
code: theorem biSup_add' {ι : Sort*} {p : ι → Prop} (h : ∃ i, p i) {f : ι → ℝ≥0∞} :
    (⨆ (i) (_ : p i), f i) + a = ⨆ (i) (_ : p i), f i + a 
goal: (⨆ i, ⨆ (_ : p i), f i) + a = ⨆ i, ⨆ (_ : p i), f i + a

full_name: ENNReal.add_biSup'
code: theorem add_biSup' {ι : Sort*} {p : ι → Prop} (h : ∃ i, p i) {f : ι → ℝ≥0∞} :
    (a + ⨆ (i) (_ : p i), f i) = ⨆ (i) (_ : p i), a + f i 
goal: a + ⨆ i, ⨆ (_ : p i), f i = ⨆ i, ⨆ (_ : p i), a + f i

full_name: ENNReal.biSup_add
code: theorem biSup_add {ι} {s : Set ι} (hs : s.Nonempty) {f : ι → ℝ≥0∞} :
    (⨆ i ∈ s, f i) + a = ⨆ i ∈ s, f i + a 
goal: (⨆ i ∈ s, f i) + a = ⨆ i ∈ s, f i + a

full_name: ENNReal.add_biSup
code: theorem add_biSup {ι} {s : Set ι} (hs : s.Nonempty) {f : ι → ℝ≥0∞} :
    (a + ⨆ i ∈ s, f i) = ⨆ i ∈ s, a + f i 
goal: a + ⨆ i ∈ s, f i = ⨆ i ∈ s, a + f i

full_name: ENNReal.sSup_add
code: theorem sSup_add {s : Set ℝ≥0∞} (hs : s.Nonempty) : sSup s + a = ⨆ b ∈ s, b + a 
goal: sSup s + a = ⨆ b ∈ s, b + a

full_name: ENNReal.add_iSup
code: theorem add_iSup {ι : Sort*} {s : ι → ℝ≥0∞} [Nonempty ι] : a + iSup s = ⨆ b, a + s b 
goal: a + iSup s = ⨆ b, a + s b

full_name: ENNReal.iSup_add_iSup_le
code: theorem iSup_add_iSup_le {ι ι' : Sort*} [Nonempty ι] [Nonempty ι'] {f : ι → ℝ≥0∞} {g : ι' → ℝ≥0∞}
    {a : ℝ≥0∞} (h : ∀ i j, f i + g j ≤ a) : iSup f + iSup g ≤ a 
goal: iSup f + iSup g ≤ a

full_name: ENNReal.biSup_add_biSup_le'
code: theorem biSup_add_biSup_le' {ι ι'} {p : ι → Prop} {q : ι' → Prop} (hp : ∃ i, p i) (hq : ∃ j, q j)
    {f : ι → ℝ≥0∞} {g : ι' → ℝ≥0∞} {a : ℝ≥0∞} (h : ∀ i, p i → ∀ j, q j → f i + g j ≤ a) :
    ((⨆ (i) (_ : p i), f i) + ⨆ (j) (_ : q j), g j) ≤ a 
goal: (⨆ i, ⨆ (_ : p i), f i) + ⨆ j, ⨆ (_ : q j), g j ≤ a

full_name: ENNReal.biSup_add_biSup_le
code: theorem biSup_add_biSup_le {ι ι'} {s : Set ι} {t : Set ι'} (hs : s.Nonempty) (ht : t.Nonempty)
    {f : ι → ℝ≥0∞} {g : ι' → ℝ≥0∞} {a : ℝ≥0∞} (h : ∀ i ∈ s, ∀ j ∈ t, f i + g j ≤ a) :
    ((⨆ i ∈ s, f i) + ⨆ j ∈ t, g j) ≤ a 
goal: (⨆ i ∈ s, f i) + ⨆ j ∈ t, g j ≤ a

full_name: ENNReal.iSup_add_iSup
code: theorem iSup_add_iSup {ι : Sort*} {f g : ι → ℝ≥0∞} (h : ∀ i j, ∃ k, f i + g j ≤ f k + g k) :
    iSup f + iSup g = ⨆ a, f a + g a 
goal: iSup f + iSup g = ⨆ a, f a + g a

full_name: ENNReal.iSup_add_iSup_of_monotone
code: theorem iSup_add_iSup_of_monotone {ι : Type*} [Preorder ι] [IsDirected ι (· ≤ ·)]
    {f g : ι → ℝ≥0∞} (hf : Monotone f) (hg : Monotone g) : iSup f + iSup g = ⨆ a, f a + g a 
goal: iSup f + iSup g = ⨆ a, f a + g a

full_name: ENNReal.finsetSum_iSup
code: theorem finsetSum_iSup {α ι : Type*} {s : Finset α} {f : α → ι → ℝ≥0∞}
    (hf : ∀ i j, ∃ k, ∀ a, f a i ≤ f a k ∧ f a j ≤ f a k) :
    ∑ a ∈ s, ⨆ i, f a i = ⨆ i, ∑ a ∈ s, f a i 
goal: ∑ a ∈ s, ⨆ i, f a i = ⨆ i, ∑ a ∈ s, f a i

full_name: ENNReal.finsetSum_iSup_of_monotone
code: theorem finsetSum_iSup_of_monotone {α} {ι} [Preorder ι] [IsDirected ι (· ≤ ·)]
    {s : Finset α} {f : α → ι → ℝ≥0∞} (hf : ∀ a, Monotone (f a)) :
    (∑ a ∈ s, iSup (f a)) = ⨆ n, ∑ a ∈ s, f a n 
goal: ∑ a ∈ s, iSup (f a) = ⨆ n, ∑ a ∈ s, f a n

full_name: ENNReal.mul_iSup
code: theorem mul_iSup {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : a * iSup f = ⨆ i, a * f i 
goal: a * iSup f = ⨆ i, a * f i

full_name: ENNReal.mul_sSup
code: theorem mul_sSup {s : Set ℝ≥0∞} {a : ℝ≥0∞} : a * sSup s = ⨆ i ∈ s, a * i 
goal: a * sSup s = ⨆ i ∈ s, a * i

full_name: ENNReal.iSup_mul
code: theorem iSup_mul {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : iSup f * a = ⨆ i, f i * a 
goal: iSup f * a = ⨆ i, f i * a

full_name: ENNReal.smul_iSup
code: theorem smul_iSup {ι : Sort*} {R} [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞] (f : ι → ℝ≥0∞)
    (c : R) : (c • ⨆ i, f i) = ⨆ i, c • f i 
goal: c • ⨆ i, f i = ⨆ i, c • f i

full_name: ENNReal.smul_sSup
code: theorem smul_sSup {R} [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞] (s : Set ℝ≥0∞) (c : R) :
    c • sSup s = ⨆ i ∈ s, c • i 
goal: c • sSup s = ⨆ i ∈ s, c • i

full_name: ENNReal.iSup_div
code: theorem iSup_div {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : iSup f / a = ⨆ i, f i / a 
goal: iSup f / a = ⨆ i, f i / a

full_name: ENNReal.tendsto_coe_sub
code: protected theorem tendsto_coe_sub {b : ℝ≥0∞} :
    Tendsto (fun b : ℝ≥0∞ => ↑r - b) (𝓝 b) (𝓝 (↑r - b)) 
goal: Filter.Tendsto (fun b => ↑r - b) (𝓝 b) (𝓝 (↑r - b))

full_name: ENNReal.sub_iSup
code: theorem sub_iSup {ι : Sort*} [Nonempty ι] {b : ι → ℝ≥0∞} (hr : a < ∞) :
    (a - ⨆ i, b i) = ⨅ i, a - b i 
goal: a - ⨆ i, b i = ⨅ i, a - b i

full_name: ENNReal.exists_countable_dense_no_zero_top
code: theorem exists_countable_dense_no_zero_top :
    ∃ s : Set ℝ≥0∞, s.Countable ∧ Dense s ∧ 0 ∉ s ∧ ∞ ∉ s 
goal: ∃ s, s.Countable ∧ Dense s ∧ 0 ∉ s ∧ ⊤ ∉ s

full_name: ENNReal.exists_lt_add_of_lt_add
code: theorem exists_lt_add_of_lt_add {x y z : ℝ≥0∞} (h : x < y + z) (hy : y ≠ 0) (hz : z ≠ 0) :
    ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z' 
goal: ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

full_name: ENNReal.ofReal_cinfi
code: theorem ofReal_cinfi (f : α → ℝ) [Nonempty α] :
    ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i) 
goal: ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i)

full_name: ENNReal.exists_frequently_lt_of_liminf_ne_top
code: theorem exists_frequently_lt_of_liminf_ne_top {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, x n < R 
goal: ∃ R, ∃ᶠ (n : ι) in l, x n < R

full_name: ENNReal.exists_frequently_lt_of_liminf_ne_top'
code: theorem exists_frequently_lt_of_liminf_ne_top' {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, R < x n 
goal: ∃ R, ∃ᶠ (n : ι) in l, R < x n

full_name: ENNReal.exists_upcrossings_of_not_bounded_under
code: theorem exists_upcrossings_of_not_bounded_under {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hf : liminf (fun i => (Real.nnabs (x i) : ℝ≥0∞)) l ≠ ∞)
    (hbdd : ¬IsBoundedUnder (· ≤ ·) l fun i => |x i|) :
    ∃ a b : ℚ, a < b ∧ (∃ᶠ i in l, x i < a) ∧ ∃ᶠ i in l, ↑b < x i 
goal: ∃ a b, a < b ∧ (∃ᶠ (i : ι) in l, x i < ↑a) ∧ ∃ᶠ (i : ι) in l, ↑b < x i

full_name: ENNReal.hasSum_coe
code: @[norm_cast]
protected theorem hasSum_coe {f : α → ℝ≥0} {r : ℝ≥0} :
    HasSum (fun a => (f a : ℝ≥0∞)) ↑r ↔ HasSum f r 
goal: HasSum (fun a => ↑(f a)) ↑r ↔ HasSum f r

full_name: ENNReal.tsum_coe_eq
code: protected theorem tsum_coe_eq {f : α → ℝ≥0} (h : HasSum f r) : (∑' a, (f a : ℝ≥0∞)) = r 
goal: ∑' (a : α), ↑(f a) = ↑r

full_name: ENNReal.coe_tsum
code: protected theorem coe_tsum {f : α → ℝ≥0} : Summable f → ↑(tsum f) = ∑' a, (f a : ℝ≥0∞)
  
goal: Summable f → ↑(tsum f) = ∑' (a : α), ↑(f a)

full_name: ENNReal.hasSum
code: protected theorem hasSum : HasSum f (⨆ s : Finset α, ∑ a ∈ s, f a) 
goal: HasSum f (⨆ s, ∑ a ∈ s, f a)

full_name: ENNReal.summable
code: @[simp]
protected theorem summable : Summable f 
goal: Summable f

full_name: ENNReal.tsum_coe_ne_top_iff_summable
code: theorem tsum_coe_ne_top_iff_summable {f : β → ℝ≥0} : (∑' b, (f b : ℝ≥0∞)) ≠ ∞ ↔ Summable f 
goal: ∑' (b : β), ↑(f b) ≠ ⊤ ↔ Summable f

full_name: ENNReal.tsum_eq_iSup_sum
code: protected theorem tsum_eq_iSup_sum : ∑' a, f a = ⨆ s : Finset α, ∑ a ∈ s, f a 
goal: ∑' (a : α), f a = ⨆ s, ∑ a ∈ s, f a

full_name: ENNReal.tsum_eq_iSup_sum'
code: protected theorem tsum_eq_iSup_sum' {ι : Type*} (s : ι → Finset α) (hs : ∀ t, ∃ i, t ⊆ s i) :
    ∑' a, f a = ⨆ i, ∑ a ∈ s i, f a 
goal: ∑' (a : α), f a = ⨆ i, ∑ a ∈ s i, f a

full_name: ENNReal.tsum_sigma
code: protected theorem tsum_sigma {β : α → Type*} (f : ∀ a, β a → ℝ≥0∞) :
    ∑' p : Σa, β a, f p.1 p.2 = ∑' (a) (b), f a b 
goal: ∑' (p : (a : α) × β a), f p.fst p.snd = ∑' (a : α) (b : β a), f a b

full_name: ENNReal.tsum_sigma'
code: protected theorem tsum_sigma' {β : α → Type*} (f : (Σa, β a) → ℝ≥0∞) :
    ∑' p : Σa, β a, f p = ∑' (a) (b), f ⟨a, b⟩ 
goal: ∑' (p : (a : α) × β a), f p = ∑' (a : α) (b : β a), f ⟨a, b⟩

full_name: ENNReal.tsum_prod
code: protected theorem tsum_prod {f : α → β → ℝ≥0∞} : ∑' p : α × β, f p.1 p.2 = ∑' (a) (b), f a b 
goal: ∑' (p : α × β), f p.1 p.2 = ∑' (a : α) (b : β), f a b

full_name: ENNReal.tsum_prod'
code: protected theorem tsum_prod' {f : α × β → ℝ≥0∞} : ∑' p : α × β, f p = ∑' (a) (b), f (a, b) 
goal: ∑' (p : α × β), f p = ∑' (a : α) (b : β), f (a, b)

full_name: ENNReal.tsum_comm
code: protected theorem tsum_comm {f : α → β → ℝ≥0∞} : ∑' a, ∑' b, f a b = ∑' b, ∑' a, f a b 
goal: ∑' (a : α) (b : β), f a b = ∑' (b : β) (a : α), f a b

full_name: ENNReal.tsum_add
code: protected theorem tsum_add : ∑' a, (f a + g a) = ∑' a, f a + ∑' a, g a 
goal: ∑' (a : α), (f a + g a) = ∑' (a : α), f a + ∑' (a : α), g a

full_name: ENNReal.tsum_le_tsum
code: protected theorem tsum_le_tsum (h : ∀ a, f a ≤ g a) : ∑' a, f a ≤ ∑' a, g a 
goal: ∑' (a : α), f a ≤ ∑' (a : α), g a

full_name: GCongr.ennreal_tsum_le_tsum
code: @[gcongr]
protected theorem _root_.GCongr.ennreal_tsum_le_tsum (h : ∀ a, f a ≤ g a) : tsum f ≤ tsum g 
goal: tsum f ≤ tsum g

full_name: ENNReal.sum_le_tsum
code: protected theorem sum_le_tsum {f : α → ℝ≥0∞} (s : Finset α) : ∑ x ∈ s, f x ≤ ∑' x, f x 
goal: ∑ x ∈ s, f x ≤ ∑' (x : α), f x

full_name: ENNReal.tsum_eq_iSup_nat'
code: protected theorem tsum_eq_iSup_nat' {f : ℕ → ℝ≥0∞} {N : ℕ → ℕ} (hN : Tendsto N atTop atTop) :
    ∑' i : ℕ, f i = ⨆ i : ℕ, ∑ a ∈ Finset.range (N i), f a 
goal: ∑' (i : ℕ), f i = ⨆ i, ∑ a ∈ Finset.range (N i), f a

full_name: ENNReal.tsum_eq_iSup_nat
code: protected theorem tsum_eq_iSup_nat {f : ℕ → ℝ≥0∞} :
    ∑' i : ℕ, f i = ⨆ i : ℕ, ∑ a ∈ Finset.range i, f a 
goal: ∑' (i : ℕ), f i = ⨆ i, ∑ a ∈ Finset.range i, f a

full_name: ENNReal.tsum_eq_liminf_sum_nat
code: protected theorem tsum_eq_liminf_sum_nat {f : ℕ → ℝ≥0∞} :
    ∑' i, f i = liminf (fun n => ∑ i ∈ Finset.range n, f i) atTop 
goal: ∑' (i : ℕ), f i = Filter.liminf (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop

full_name: ENNReal.tsum_eq_limsup_sum_nat
code: protected theorem tsum_eq_limsup_sum_nat {f : ℕ → ℝ≥0∞} :
    ∑' i, f i = limsup (fun n => ∑ i ∈ Finset.range n, f i) atTop 
goal: ∑' (i : ℕ), f i = Filter.limsup (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop

full_name: ENNReal.le_tsum
code: protected theorem le_tsum (a : α) : f a ≤ ∑' a, f a 
goal: f a ≤ ∑' (a : α), f a

full_name: ENNReal.tsum_eq_zero
code: @[simp]
protected theorem tsum_eq_zero : ∑' i, f i = 0 ↔ ∀ i, f i = 0 
goal: ∑' (i : α), f i = 0 ↔ ∀ (i : α), f i = 0

full_name: ENNReal.tsum_eq_top_of_eq_top
code: protected theorem tsum_eq_top_of_eq_top : (∃ a, f a = ∞) → ∑' a, f a = ∞
  
goal: (∃ a, f a = ⊤) → ∑' (a : α), f a = ⊤

full_name: ENNReal.lt_top_of_tsum_ne_top
code: protected theorem lt_top_of_tsum_ne_top {a : α → ℝ≥0∞} (tsum_ne_top : ∑' i, a i ≠ ∞) (j : α) :
    a j < ∞ 
goal: a j < ⊤

full_name: ENNReal.tsum_top
code: @[simp]
protected theorem tsum_top [Nonempty α] : ∑' _ : α, ∞ = ∞ 
goal: ∑' (x : α), ⊤ = ⊤

full_name: ENNReal.tsum_const_eq_top_of_ne_zero
code: theorem tsum_const_eq_top_of_ne_zero {α : Type*} [Infinite α] {c : ℝ≥0∞} (hc : c ≠ 0) :
    ∑' _ : α, c = ∞ 
goal: ∑' (x : α), c = ⊤

full_name: ENNReal.ne_top_of_tsum_ne_top
code: protected theorem ne_top_of_tsum_ne_top (h : ∑' a, f a ≠ ∞) (a : α) : f a ≠ ∞ 
goal: f a ≠ ⊤

full_name: ENNReal.tsum_mul_left
code: protected theorem tsum_mul_left : ∑' i, a * f i = a * ∑' i, f i 
goal: ∑' (i : α), a * f i = a * ∑' (i : α), f i

full_name: ENNReal.tsum_mul_right
code: protected theorem tsum_mul_right : ∑' i, f i * a = (∑' i, f i) * a 
goal: ∑' (i : α), f i * a = (∑' (i : α), f i) * a

full_name: ENNReal.tsum_const_smul
code: protected theorem tsum_const_smul {R} [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞] (a : R) :
    ∑' i, a • f i = a • ∑' i, f i 
goal: ∑' (i : α), a • f i = a • ∑' (i : α), f i

full_name: ENNReal.tsum_iSup_eq
code: @[simp]
theorem tsum_iSup_eq {α : Type*} (a : α) {f : α → ℝ≥0∞} : (∑' b : α, ⨆ _ : a = b, f b) = f a 
goal: ∑' (b : α), ⨆ (_ : a = b), f b = f a

full_name: ENNReal.hasSum_iff_tendsto_nat
code: theorem hasSum_iff_tendsto_nat {f : ℕ → ℝ≥0∞} (r : ℝ≥0∞) :
    HasSum f r ↔ Tendsto (fun n : ℕ => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r) 
goal: HasSum f r ↔ Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop (𝓝 r)

full_name: ENNReal.tendsto_nat_tsum
code: theorem tendsto_nat_tsum (f : ℕ → ℝ≥0∞) :
    Tendsto (fun n : ℕ => ∑ i ∈ Finset.range n, f i) atTop (𝓝 (∑' n, f n)) 
goal: Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop (𝓝 (∑' (n : ℕ), f n))

full_name: ENNReal.toNNReal_apply_of_tsum_ne_top
code: theorem toNNReal_apply_of_tsum_ne_top {α : Type*} {f : α → ℝ≥0∞} (hf : ∑' i, f i ≠ ∞) (x : α) :
    (((ENNReal.toNNReal ∘ f) x : ℝ≥0) : ℝ≥0∞) = f x 
goal: ↑((ENNReal.toNNReal ∘ f) x) = f x

full_name: ENNReal.summable_toNNReal_of_tsum_ne_top
code: theorem summable_toNNReal_of_tsum_ne_top {α : Type*} {f : α → ℝ≥0∞} (hf : ∑' i, f i ≠ ∞) :
    Summable (ENNReal.toNNReal ∘ f) 
goal: Summable (ENNReal.toNNReal ∘ f)

full_name: ENNReal.tendsto_cofinite_zero_of_tsum_ne_top
code: theorem tendsto_cofinite_zero_of_tsum_ne_top {α} {f : α → ℝ≥0∞} (hf : ∑' x, f x ≠ ∞) :
    Tendsto f cofinite (𝓝 0) 
goal: Filter.Tendsto f Filter.cofinite (𝓝 0)

full_name: ENNReal.tendsto_atTop_zero_of_tsum_ne_top
code: theorem tendsto_atTop_zero_of_tsum_ne_top {f : ℕ → ℝ≥0∞} (hf : ∑' x, f x ≠ ∞) :
    Tendsto f atTop (𝓝 0) 
goal: Filter.Tendsto f Filter.atTop (𝓝 0)

full_name: ENNReal.tendsto_tsum_compl_atTop_zero
code: /-- The sum over the complement of a finset tends to `0` when the finset grows to cover the whole
space. This does not need a summability assumption, as otherwise all sums are zero. -/
theorem tendsto_tsum_compl_atTop_zero {α : Type*} {f : α → ℝ≥0∞} (hf : ∑' x, f x ≠ ∞) :
    Tendsto (fun s : Finset α => ∑' b : { x // x ∉ s }, f b) atTop (𝓝 0) 
goal: Filter.Tendsto (fun s => ∑' (b : { x // x ∉ s }), f ↑b) Filter.atTop (𝓝 0)

full_name: ENNReal.tsum_apply
code: protected theorem tsum_apply {ι α : Type*} {f : ι → α → ℝ≥0∞} {x : α} :
    (∑' i, f i) x = ∑' i, f i x 
goal: tsum (fun i => f i) x = ∑' (i : ι), f i x

full_name: ENNReal.tsum_sub
code: theorem tsum_sub {f : ℕ → ℝ≥0∞} {g : ℕ → ℝ≥0∞} (h₁ : ∑' i, g i ≠ ∞) (h₂ : g ≤ f) :
    ∑' i, (f i - g i) = ∑' i, f i - ∑' i, g i 
goal: ∑' (i : ℕ), (f i - g i) = ∑' (i : ℕ), f i - ∑' (i : ℕ), g i

full_name: ENNReal.tsum_comp_le_tsum_of_injective
code: theorem tsum_comp_le_tsum_of_injective {f : α → β} (hf : Injective f) (g : β → ℝ≥0∞) :
    ∑' x, g (f x) ≤ ∑' y, g y 
goal: ∑' (x : α), g (f x) ≤ ∑' (y : β), g y

full_name: ENNReal.tsum_le_tsum_comp_of_surjective
code: theorem tsum_le_tsum_comp_of_surjective {f : α → β} (hf : Surjective f) (g : β → ℝ≥0∞) :
    ∑' y, g y ≤ ∑' x, g (f x) 
goal: ∑' (y : β), g y ≤ ∑' (x : α), g (f x)

full_name: ENNReal.tsum_mono_subtype
code: theorem tsum_mono_subtype (f : α → ℝ≥0∞) {s t : Set α} (h : s ⊆ t) :
    ∑' x : s, f x ≤ ∑' x : t, f x 
goal: ∑' (x : ↑s), f ↑x ≤ ∑' (x : ↑t), f ↑x

full_name: ENNReal.tsum_iUnion_le_tsum
code: theorem tsum_iUnion_le_tsum {ι : Type*} (f : α → ℝ≥0∞) (t : ι → Set α) :
    ∑' x : ⋃ i, t i, f x ≤ ∑' i, ∑' x : t i, f x 
goal: ∑' (x : ↑(⋃ i, t i)), f ↑x ≤ ∑' (i : ι) (x : ↑(t i)), f ↑x

full_name: ENNReal.tsum_biUnion_le_tsum
code: theorem tsum_biUnion_le_tsum {ι : Type*} (f : α → ℝ≥0∞) (s : Set ι) (t : ι → Set α) :
    ∑' x : ⋃ i ∈ s , t i, f x ≤ ∑' i : s, ∑' x : t i, f x 
goal: ∑' (x : ↑(⋃ i ∈ s, t i)), f ↑x ≤ ∑' (i : ↑s) (x : ↑(t ↑i)), f ↑x

full_name: ENNReal.tsum_biUnion_le
code: theorem tsum_biUnion_le {ι : Type*} (f : α → ℝ≥0∞) (s : Finset ι) (t : ι → Set α) :
    ∑' x : ⋃ i ∈ s, t i, f x ≤ ∑ i ∈ s, ∑' x : t i, f x 
goal: ∑' (x : ↑(⋃ i ∈ s, t i)), f ↑x ≤ ∑ i ∈ s, ∑' (x : ↑(t i)), f ↑x

full_name: ENNReal.tsum_iUnion_le
code: theorem tsum_iUnion_le {ι : Type*} [Fintype ι] (f : α → ℝ≥0∞) (t : ι → Set α) :
    ∑' x : ⋃ i, t i, f x ≤ ∑ i, ∑' x : t i, f x 
goal: ∑' (x : ↑(⋃ i, t i)), f ↑x ≤ ∑ i : ι, ∑' (x : ↑(t i)), f ↑x

full_name: ENNReal.tsum_union_le
code: theorem tsum_union_le (f : α → ℝ≥0∞) (s t : Set α) :
    ∑' x : ↑(s ∪ t), f x ≤ ∑' x : s, f x + ∑' x : t, f x 
goal: ∑' (x : ↑(s ∪ t)), f ↑x ≤ ∑' (x : ↑s), f ↑x + ∑' (x : ↑t), f ↑x

full_name: ENNReal.tsum_eq_add_tsum_ite
code: theorem tsum_eq_add_tsum_ite {f : β → ℝ≥0∞} (b : β) :
    ∑' x, f x = f b + ∑' x, ite (x = b) 0 (f x) 
goal: ∑' (x : β), f x = f b + ∑' (x : β), if x = b then 0 else f x

full_name: ENNReal.tsum_add_one_eq_top
code: theorem tsum_add_one_eq_top {f : ℕ → ℝ≥0∞} (hf : ∑' n, f n = ∞) (hf0 : f 0 ≠ ∞) :
    ∑' n, f (n + 1) = ∞ 
goal: ∑' (n : ℕ), f (n + 1) = ⊤

full_name: ENNReal.finite_const_le_of_tsum_ne_top
code: /-- A sum of extended nonnegative reals which is finite can have only finitely many terms
above any positive threshold. -/
theorem finite_const_le_of_tsum_ne_top {ι : Type*} {a : ι → ℝ≥0∞} (tsum_ne_top : ∑' i, a i ≠ ∞)
    {ε : ℝ≥0∞} (ε_ne_zero : ε ≠ 0) : { i : ι | ε ≤ a i }.Finite 
goal: {i | ε ≤ a i}.Finite

full_name: ENNReal.finset_card_const_le_le_of_tsum_le
code: /-- Markov's inequality for `Finset.card` and `tsum` in `ℝ≥0∞`. -/
theorem finset_card_const_le_le_of_tsum_le {ι : Type*} {a : ι → ℝ≥0∞} {c : ℝ≥0∞} (c_ne_top : c ≠ ∞)
    (tsum_le_c : ∑' i, a i ≤ c) {ε : ℝ≥0∞} (ε_ne_zero : ε ≠ 0) :
    ∃ hf : { i : ι | ε ≤ a i }.Finite, ↑hf.toFinset.card ≤ c / ε 
goal: ∃ (hf : {i | ε ≤ a i}.Finite), ↑hf.toFinset.card ≤ c / ε

full_name: ENNReal.tsum_fiberwise
code: theorem tsum_fiberwise (f : β → ℝ≥0∞) (g : β → γ) :
    ∑' x, ∑' b : g ⁻¹' {x}, f b = ∑' i, f i 
goal: ∑' (x : γ) (b : ↑(g ⁻¹' {x})), f ↑b = ∑' (i : β), f i

full_name: ENNReal.tendsto_toReal_iff
code: theorem tendsto_toReal_iff {ι} {fi : Filter ι} {f : ι → ℝ≥0∞} (hf : ∀ i, f i ≠ ∞) {x : ℝ≥0∞}
    (hx : x ≠ ∞) : Tendsto (fun n => (f n).toReal) fi (𝓝 x.toReal) ↔ Tendsto f fi (𝓝 x) 
goal: Filter.Tendsto (fun n => (f n).toReal) fi (𝓝 x.toReal) ↔ Filter.Tendsto f fi (𝓝 x)

full_name: ENNReal.tsum_coe_ne_top_iff_summable_coe
code: theorem tsum_coe_ne_top_iff_summable_coe {f : α → ℝ≥0} :
    (∑' a, (f a : ℝ≥0∞)) ≠ ∞ ↔ Summable fun a => (f a : ℝ) 
goal: ∑' (a : α), ↑(f a) ≠ ⊤ ↔ Summable fun a => ↑(f a)

full_name: ENNReal.tsum_coe_eq_top_iff_not_summable_coe
code: theorem tsum_coe_eq_top_iff_not_summable_coe {f : α → ℝ≥0} :
    (∑' a, (f a : ℝ≥0∞)) = ∞ ↔ ¬Summable fun a => (f a : ℝ) 
goal: ∑' (a : α), ↑(f a) = ⊤ ↔ ¬Summable fun a => ↑(f a)

full_name: ENNReal.hasSum_toReal
code: theorem hasSum_toReal {f : α → ℝ≥0∞} (hsum : ∑' x, f x ≠ ∞) :
    HasSum (fun x => (f x).toReal) (∑' x, (f x).toReal) 
goal: HasSum (fun x => (f x).toReal) (∑' (x : α), (f x).toReal)

full_name: ENNReal.summable_toReal
code: theorem summable_toReal {f : α → ℝ≥0∞} (hsum : ∑' x, f x ≠ ∞) : Summable fun x => (f x).toReal 
goal: Summable fun x => (f x).toReal

full_name: NNReal.tsum_eq_toNNReal_tsum
code: theorem tsum_eq_toNNReal_tsum {f : β → ℝ≥0} : ∑' b, f b = (∑' b, (f b : ℝ≥0∞)).toNNReal 
goal: ∑' (b : β), f b = (∑' (b : β), ↑(f b)).toNNReal

full_name: NNReal.exists_le_hasSum_of_le
code: /-- Comparison test of convergence of `ℝ≥0`-valued series. -/
theorem exists_le_hasSum_of_le {f g : β → ℝ≥0} {r : ℝ≥0} (hgf : ∀ b, g b ≤ f b) (hfr : HasSum f r) :
    ∃ p ≤ r, HasSum g p 
goal: ∃ p ≤ r, HasSum g p

full_name: NNReal.summable_of_le
code: /-- Comparison test of convergence of `ℝ≥0`-valued series. -/
theorem summable_of_le {f g : β → ℝ≥0} (hgf : ∀ b, g b ≤ f b) : Summable f → Summable g
  
goal: Summable f → Summable g

full_name: Summable.countable_support_nnreal
code: /-- Summable non-negative functions have countable support -/
theorem _root_.Summable.countable_support_nnreal (f : α → ℝ≥0) (h : Summable f) :
    f.support.Countable 
goal: (Function.support f).Countable

full_name: NNReal.hasSum_iff_tendsto_nat
code: /-- A series of non-negative real numbers converges to `r` in the sense of `HasSum` if and only if
the sequence of partial sum converges to `r`. -/
theorem hasSum_iff_tendsto_nat {f : ℕ → ℝ≥0} {r : ℝ≥0} :
    HasSum f r ↔ Tendsto (fun n : ℕ => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r) 
goal: HasSum f r ↔ Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop (𝓝 r)

full_name: NNReal.not_summable_iff_tendsto_nat_atTop
code: theorem not_summable_iff_tendsto_nat_atTop {f : ℕ → ℝ≥0} :
    ¬Summable f ↔ Tendsto (fun n : ℕ => ∑ i ∈ Finset.range n, f i) atTop atTop 
goal: ¬Summable f ↔ Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop Filter.atTop

full_name: NNReal.summable_iff_not_tendsto_nat_atTop
code: theorem summable_iff_not_tendsto_nat_atTop {f : ℕ → ℝ≥0} :
    Summable f ↔ ¬Tendsto (fun n : ℕ => ∑ i ∈ Finset.range n, f i) atTop atTop 
goal: Summable f ↔ ¬Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop Filter.atTop

full_name: NNReal.summable_of_sum_range_le
code: theorem summable_of_sum_range_le {f : ℕ → ℝ≥0} {c : ℝ≥0}
    (h : ∀ n, ∑ i ∈ Finset.range n, f i ≤ c) : Summable f 
goal: Summable f

full_name: NNReal.tsum_le_of_sum_range_le
code: theorem tsum_le_of_sum_range_le {f : ℕ → ℝ≥0} {c : ℝ≥0}
    (h : ∀ n, ∑ i ∈ Finset.range n, f i ≤ c) : ∑' n, f n ≤ c 
goal: ∑' (n : ℕ), f n ≤ c

full_name: NNReal.tsum_comp_le_tsum_of_inj
code: theorem tsum_comp_le_tsum_of_inj {β : Type*} {f : α → ℝ≥0} (hf : Summable f) {i : β → α}
    (hi : Function.Injective i) : (∑' x, f (i x)) ≤ ∑' x, f x 
goal: ∑' (x : β), f (i x) ≤ ∑' (x : α), f x

full_name: NNReal.summable_sigma
code: theorem summable_sigma {β : α → Type*} {f : (Σ x, β x) → ℝ≥0} :
    Summable f ↔ (∀ x, Summable fun y => f ⟨x, y⟩) ∧ Summable fun x => ∑' y, f ⟨x, y⟩ 
goal: Summable f ↔ (∀ (x : α), Summable fun y => f ⟨x, y⟩) ∧ Summable fun x => ∑' (y : β x), f ⟨x, y⟩

full_name: NNReal.indicator_summable
code: theorem indicator_summable {f : α → ℝ≥0} (hf : Summable f) (s : Set α) :
    Summable (s.indicator f) 
goal: Summable (s.indicator f)

full_name: NNReal.tsum_indicator_ne_zero
code: theorem tsum_indicator_ne_zero {f : α → ℝ≥0} (hf : Summable f) {s : Set α} (h : ∃ a ∈ s, f a ≠ 0) :
    (∑' x, (s.indicator f) x) ≠ 0 
goal: ∑' (x : α), s.indicator f x ≠ 0

full_name: NNReal.tendsto_sum_nat_add
code: /-- For `f : ℕ → ℝ≥0`, then `∑' k, f (k + i)` tends to zero. This does not require a summability
assumption on `f`, as otherwise all sums are zero. -/
theorem tendsto_sum_nat_add (f : ℕ → ℝ≥0) : Tendsto (fun i => ∑' k, f (k + i)) atTop (𝓝 0) 
goal: Filter.Tendsto (fun i => ∑' (k : ℕ), f (k + i)) Filter.atTop (𝓝 0)

full_name: NNReal.hasSum_lt
code: nonrec theorem hasSum_lt {f g : α → ℝ≥0} {sf sg : ℝ≥0} {i : α} (h : ∀ a : α, f a ≤ g a)
    (hi : f i < g i) (hf : HasSum f sf) (hg : HasSum g sg) : sf < sg 
goal: sf < sg

full_name: NNReal.hasSum_strict_mono
code: @[mono]
theorem hasSum_strict_mono {f g : α → ℝ≥0} {sf sg : ℝ≥0} (hf : HasSum f sf) (hg : HasSum g sg)
    (h : f < g) : sf < sg 
goal: sf < sg

full_name: NNReal.tsum_lt_tsum
code: theorem tsum_lt_tsum {f g : α → ℝ≥0} {i : α} (h : ∀ a : α, f a ≤ g a) (hi : f i < g i)
    (hg : Summable g) : ∑' n, f n < ∑' n, g n 
goal: ∑' (n : α), f n < ∑' (n : α), g n

full_name: NNReal.tsum_strict_mono
code: @[mono]
theorem tsum_strict_mono {f g : α → ℝ≥0} (hg : Summable g) (h : f < g) : ∑' n, f n < ∑' n, g n 
goal: ∑' (n : α), f n < ∑' (n : α), g n

full_name: NNReal.tsum_pos
code: theorem tsum_pos {g : α → ℝ≥0} (hg : Summable g) (i : α) (hi : 0 < g i) : 0 < ∑' b, g b 
goal: 0 < ∑' (b : α), g b

full_name: NNReal.tsum_eq_add_tsum_ite
code: theorem tsum_eq_add_tsum_ite {f : α → ℝ≥0} (hf : Summable f) (i : α) :
    ∑' x, f x = f i + ∑' x, ite (x = i) 0 (f x) 
goal: ∑' (x : α), f x = f i + ∑' (x : α), if x = i then 0 else f x

full_name: ENNReal.tsum_toNNReal_eq
code: theorem tsum_toNNReal_eq {f : α → ℝ≥0∞} (hf : ∀ a, f a ≠ ∞) :
    (∑' a, f a).toNNReal = ∑' a, (f a).toNNReal 
goal: (∑' (a : α), f a).toNNReal = ∑' (a : α), (f a).toNNReal

full_name: ENNReal.tsum_toReal_eq
code: theorem tsum_toReal_eq {f : α → ℝ≥0∞} (hf : ∀ a, f a ≠ ∞) :
    (∑' a, f a).toReal = ∑' a, (f a).toReal 
goal: (∑' (a : α), f a).toReal = ∑' (a : α), (f a).toReal

full_name: ENNReal.tendsto_sum_nat_add
code: theorem tendsto_sum_nat_add (f : ℕ → ℝ≥0∞) (hf : ∑' i, f i ≠ ∞) :
    Tendsto (fun i => ∑' k, f (k + i)) atTop (𝓝 0) 
goal: Filter.Tendsto (fun i => ∑' (k : ℕ), f (k + i)) Filter.atTop (𝓝 0)

full_name: ENNReal.tsum_le_of_sum_range_le
code: theorem tsum_le_of_sum_range_le {f : ℕ → ℝ≥0∞} {c : ℝ≥0∞}
    (h : ∀ n, ∑ i ∈ Finset.range n, f i ≤ c) : ∑' n, f n ≤ c 
goal: ∑' (n : ℕ), f n ≤ c

full_name: ENNReal.hasSum_lt
code: theorem hasSum_lt {f g : α → ℝ≥0∞} {sf sg : ℝ≥0∞} {i : α} (h : ∀ a : α, f a ≤ g a) (hi : f i < g i)
    (hsf : sf ≠ ∞) (hf : HasSum f sf) (hg : HasSum g sg) : sf < sg 
goal: sf < sg

full_name: ENNReal.tsum_lt_tsum
code: theorem tsum_lt_tsum {f g : α → ℝ≥0∞} {i : α} (hfi : tsum f ≠ ∞) (h : ∀ a : α, f a ≤ g a)
    (hi : f i < g i) : ∑' x, f x < ∑' x, g x 
goal: ∑' (x : α), f x < ∑' (x : α), g x

full_name: tsum_comp_le_tsum_of_inj
code: theorem tsum_comp_le_tsum_of_inj {β : Type*} {f : α → ℝ} (hf : Summable f) (hn : ∀ a, 0 ≤ f a)
    {i : β → α} (hi : Function.Injective i) : tsum (f ∘ i) ≤ tsum f 
goal: tsum (f ∘ i) ≤ tsum f

full_name: Summable.of_nonneg_of_le
code: /-- Comparison test of convergence of series of non-negative real numbers. -/
theorem Summable.of_nonneg_of_le {f g : β → ℝ} (hg : ∀ b, 0 ≤ g b) (hgf : ∀ b, g b ≤ f b)
    (hf : Summable f) : Summable g 
goal: Summable g

full_name: Summable.toNNReal
code: theorem Summable.toNNReal {f : α → ℝ} (hf : Summable f) : Summable fun n => (f n).toNNReal 
goal: Summable fun n => (f n).toNNReal

full_name: Summable.countable_support_ennreal
code: /-- Finitely summable non-negative functions have countable support -/
theorem _root_.Summable.countable_support_ennreal {f : α → ℝ≥0∞} (h : ∑' (i : α), f i ≠ ∞) :
    f.support.Countable 
goal: (Function.support f).Countable

full_name: hasSum_iff_tendsto_nat_of_nonneg
code: /-- A series of non-negative real numbers converges to `r` in the sense of `HasSum` if and only if
the sequence of partial sum converges to `r`. -/
theorem hasSum_iff_tendsto_nat_of_nonneg {f : ℕ → ℝ} (hf : ∀ i, 0 ≤ f i) (r : ℝ) :
    HasSum f r ↔ Tendsto (fun n : ℕ => ∑ i ∈ Finset.range n, f i) atTop (𝓝 r) 
goal: HasSum f r ↔ Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop (𝓝 r)

full_name: ENNReal.ofReal_tsum_of_nonneg
code: theorem ENNReal.ofReal_tsum_of_nonneg {f : α → ℝ} (hf_nonneg : ∀ n, 0 ≤ f n) (hf : Summable f) :
    ENNReal.ofReal (∑' n, f n) = ∑' n, ENNReal.ofReal (f n) 
goal: ENNReal.ofReal (∑' (n : α), f n) = ∑' (n : α), ENNReal.ofReal (f n)

full_name: edist_ne_top_of_mem_ball
code: /-- In an emetric ball, the distance between points is everywhere finite -/
theorem edist_ne_top_of_mem_ball {a : β} {r : ℝ≥0∞} (x y : ball a r) : edist x.1 y.1 ≠ ∞ 
goal: edist ↑x ↑y ≠ ⊤

full_name: metricSpaceEMetricBall
code: /-- Each ball in an extended metric space gives us a metric space, as the edist
is everywhere finite. -/
def metricSpaceEMetricBall (a : β) (r : ℝ≥0∞) : MetricSpace (ball a r) 
goal: MetricSpace ↑(EMetric.ball a r)

full_name: nhds_eq_nhds_emetric_ball
code: theorem nhds_eq_nhds_emetric_ball (a x : β) (r : ℝ≥0∞) (h : x ∈ ball a r) :
    𝓝 x = map ((↑) : ball a r → β) (𝓝 ⟨x, h⟩) 
goal: 𝓝 x = Filter.map Subtype.val (𝓝 ⟨x, h⟩)

full_name: tendsto_iff_edist_tendsto_0
code: theorem tendsto_iff_edist_tendsto_0 {l : Filter β} {f : β → α} {y : α} :
    Tendsto f l (𝓝 y) ↔ Tendsto (fun x => edist (f x) y) l (𝓝 0) 
goal: Filter.Tendsto f l (𝓝 y) ↔ Filter.Tendsto (fun x => edist (f x) y) l (𝓝 0)

full_name: EMetric.cauchySeq_iff_le_tendsto_0
code: /-- Yet another metric characterization of Cauchy sequences on integers. This one is often the
most efficient. -/
theorem EMetric.cauchySeq_iff_le_tendsto_0 [Nonempty β] [SemilatticeSup β] {s : β → α} :
    CauchySeq s ↔ ∃ b : β → ℝ≥0∞, (∀ n m N : β, N ≤ n → N ≤ m → edist (s n) (s m) ≤ b N) ∧
      Tendsto b atTop (𝓝 0) 
goal: CauchySeq s ↔ ∃ b, (∀ (n m N : β), N ≤ n → N ≤ m → edist (s n) (s m) ≤ b N) ∧ Filter.Tendsto b Filter.atTop (𝓝 0)

full_name: continuous_of_le_add_edist
code: theorem continuous_of_le_add_edist {f : α → ℝ≥0∞} (C : ℝ≥0∞) (hC : C ≠ ∞)
    (h : ∀ x y, f x ≤ f y + C * edist x y) : Continuous f 
goal: Continuous f

full_name: continuous_edist
code: theorem continuous_edist : Continuous fun p : α × α => edist p.1 p.2 
goal: Continuous fun p => edist p.1 p.2

full_name: Continuous.edist
code: @[continuity, fun_prop]
theorem Continuous.edist [TopologicalSpace β] {f g : β → α} (hf : Continuous f)
    (hg : Continuous g) : Continuous fun b => edist (f b) (g b) 
goal: Continuous fun b => edist (f b) (g b)

full_name: Filter.Tendsto.edist
code: theorem Filter.Tendsto.edist {f g : β → α} {x : Filter β} {a b : α} (hf : Tendsto f x (𝓝 a))
    (hg : Tendsto g x (𝓝 b)) : Tendsto (fun x => edist (f x) (g x)) x (𝓝 (edist a b)) 
goal: Filter.Tendsto (fun x => edist (f x) (g x)) x (𝓝 (edist a b))

full_name: cauchySeq_of_edist_le_of_summable
code: /-- If the extended distance between consecutive points of a sequence is estimated
by a summable series of `NNReal`s, then the original sequence is a Cauchy sequence. -/
theorem cauchySeq_of_edist_le_of_summable [PseudoEMetricSpace α] {f : ℕ → α} (d : ℕ → ℝ≥0)
    (hf : ∀ n, edist (f n) (f n.succ) ≤ d n) (hd : Summable d) : CauchySeq f 
goal: CauchySeq f

full_name: cauchySeq_of_edist_le_of_tsum_ne_top
code: theorem cauchySeq_of_edist_le_of_tsum_ne_top {f : ℕ → α} (d : ℕ → ℝ≥0∞)
    (hf : ∀ n, edist (f n) (f n.succ) ≤ d n) (hd : tsum d ≠ ∞) : CauchySeq f 
goal: CauchySeq f

full_name: EMetric.isClosed_ball
code: theorem EMetric.isClosed_ball {a : α} {r : ℝ≥0∞} : IsClosed (closedBall a r) 
goal: IsClosed (EMetric.closedBall a r)

full_name: EMetric.diam_closure
code: @[simp]
theorem EMetric.diam_closure (s : Set α) : diam (closure s) = diam s 
goal: EMetric.diam (closure s) = EMetric.diam s

full_name: Metric.diam_closure
code: @[simp]
theorem Metric.diam_closure {α : Type*} [PseudoMetricSpace α] (s : Set α) :
    Metric.diam (closure s) = diam s 
goal: Metric.diam (closure s) = Metric.diam s

full_name: isClosed_setOf_lipschitzOnWith
code: theorem isClosed_setOf_lipschitzOnWith {α β} [PseudoEMetricSpace α] [PseudoEMetricSpace β] (K : ℝ≥0)
    (s : Set α) : IsClosed { f : α → β | LipschitzOnWith K f s } 
goal: IsClosed {f | LipschitzOnWith K f s}

full_name: isClosed_setOf_lipschitzWith
code: theorem isClosed_setOf_lipschitzWith {α β} [PseudoEMetricSpace α] [PseudoEMetricSpace β] (K : ℝ≥0) :
    IsClosed { f : α → β | LipschitzWith K f } 
goal: IsClosed {f | LipschitzWith K f}

full_name: Real.ediam_eq
code: /-- For a bounded set `s : Set ℝ`, its `EMetric.diam` is equal to `sSup s - sInf s` reinterpreted as
`ℝ≥0∞`. -/
theorem ediam_eq {s : Set ℝ} (h : Bornology.IsBounded s) :
    EMetric.diam s = ENNReal.ofReal (sSup s - sInf s) 
goal: EMetric.diam s = ENNReal.ofReal (sSup s - sInf s)

full_name: Real.diam_eq
code: /-- For a bounded set `s : Set ℝ`, its `Metric.diam` is equal to `sSup s - sInf s`. -/
theorem diam_eq {s : Set ℝ} (h : Bornology.IsBounded s) : Metric.diam s = sSup s - sInf s 
goal: Metric.diam s = sSup s - sInf s

full_name: Real.ediam_Ioo
code: @[simp]
theorem ediam_Ioo (a b : ℝ) : EMetric.diam (Ioo a b) = ENNReal.ofReal (b - a) 
goal: EMetric.diam (Set.Ioo a b) = ENNReal.ofReal (b - a)

full_name: Real.ediam_Icc
code: @[simp]
theorem ediam_Icc (a b : ℝ) : EMetric.diam (Icc a b) = ENNReal.ofReal (b - a) 
goal: EMetric.diam (Set.Icc a b) = ENNReal.ofReal (b - a)

full_name: Real.ediam_Ico
code: @[simp]
theorem ediam_Ico (a b : ℝ) : EMetric.diam (Ico a b) = ENNReal.ofReal (b - a) 
goal: EMetric.diam (Set.Ico a b) = ENNReal.ofReal (b - a)

full_name: Real.ediam_Ioc
code: @[simp]
theorem ediam_Ioc (a b : ℝ) : EMetric.diam (Ioc a b) = ENNReal.ofReal (b - a) 
goal: EMetric.diam (Set.Ioc a b) = ENNReal.ofReal (b - a)

full_name: Real.diam_Icc
code: theorem diam_Icc {a b : ℝ} (h : a ≤ b) : Metric.diam (Icc a b) = b - a 
goal: Metric.diam (Set.Icc a b) = b - a

full_name: Real.diam_Ico
code: theorem diam_Ico {a b : ℝ} (h : a ≤ b) : Metric.diam (Ico a b) = b - a 
goal: Metric.diam (Set.Ico a b) = b - a

full_name: Real.diam_Ioc
code: theorem diam_Ioc {a b : ℝ} (h : a ≤ b) : Metric.diam (Ioc a b) = b - a 
goal: Metric.diam (Set.Ioc a b) = b - a

full_name: Real.diam_Ioo
code: theorem diam_Ioo {a b : ℝ} (h : a ≤ b) : Metric.diam (Ioo a b) = b - a 
goal: Metric.diam (Set.Ioo a b) = b - a

full_name: edist_le_tsum_of_edist_le_of_tendsto
code: /-- If `edist (f n) (f (n+1))` is bounded above by a function `d : ℕ → ℝ≥0∞`,
then the distance from `f n` to the limit is bounded by `∑'_{k=n}^∞ d k`. -/
theorem edist_le_tsum_of_edist_le_of_tendsto {f : ℕ → α} (d : ℕ → ℝ≥0∞)
    (hf : ∀ n, edist (f n) (f n.succ) ≤ d n) {a : α} (ha : Tendsto f atTop (𝓝 a)) (n : ℕ) :
    edist (f n) a ≤ ∑' m, d (n + m) 
goal: edist (f n) a ≤ ∑' (m : ℕ), d (n + m)

full_name: edist_le_tsum_of_edist_le_of_tendsto₀
code: /-- If `edist (f n) (f (n+1))` is bounded above by a function `d : ℕ → ℝ≥0∞`,
then the distance from `f 0` to the limit is bounded by `∑'_{k=0}^∞ d k`. -/
theorem edist_le_tsum_of_edist_le_of_tendsto₀ {f : ℕ → α} (d : ℕ → ℝ≥0∞)
    (hf : ∀ n, edist (f n) (f n.succ) ≤ d n) {a : α} (ha : Tendsto f atTop (𝓝 a)) :
    edist (f 0) a ≤ ∑' m, d m 
goal: edist (f 0) a ≤ ∑' (m : ℕ), d m

full_name: ENNReal.truncateToReal
code: /-- With truncation level `t`, the truncated cast `ℝ≥0∞ → ℝ` is given by `x ↦ (min t x).toReal`.
Unlike `ENNReal.toReal`, this cast is continuous and monotone when `t ≠ ∞`. -/
noncomputable def truncateToReal (t x : ℝ≥0∞) : ℝ 
goal: ℝ

full_name: ENNReal.truncateToReal_eq_toReal
code: lemma truncateToReal_eq_toReal {t x : ℝ≥0∞} (t_ne_top : t ≠ ∞) (x_le : x ≤ t) :
    truncateToReal t x = x.toReal 
goal: t.truncateToReal x = x.toReal

full_name: ENNReal.truncateToReal_le
code: lemma truncateToReal_le {t : ℝ≥0∞} (t_ne_top : t ≠ ∞) {x : ℝ≥0∞} :
    truncateToReal t x ≤ t.toReal 
goal: t.truncateToReal x ≤ t.toReal

full_name: ENNReal.truncateToReal_nonneg
code: lemma truncateToReal_nonneg {t x : ℝ≥0∞} : 0 ≤ truncateToReal t x 
goal: 0 ≤ t.truncateToReal x

full_name: ENNReal.monotone_truncateToReal
code: /-- The truncated cast `ENNReal.truncateToReal t : ℝ≥0∞ → ℝ` is monotone when `t ≠ ∞`. -/
lemma monotone_truncateToReal {t : ℝ≥0∞} (t_ne_top : t ≠ ∞) : Monotone (truncateToReal t) 
goal: Monotone t.truncateToReal

full_name: ENNReal.continuous_truncateToReal
code: /-- The truncated cast `ENNReal.truncateToReal t : ℝ≥0∞ → ℝ` is continuous when `t ≠ ∞`. -/
lemma continuous_truncateToReal {t : ℝ≥0∞} (t_ne_top : t ≠ ∞) : Continuous (truncateToReal t) 
goal: Continuous t.truncateToReal

full_name: ENNReal.limsup_sub_const
code: lemma limsup_sub_const (F : Filter ι) [NeBot F] (f : ι → ℝ≥0∞) (c : ℝ≥0∞) :
    Filter.limsup (fun i ↦ f i - c) F = Filter.limsup f F - c 
goal: Filter.limsup (fun i => f i - c) F = Filter.limsup f F - c

full_name: ENNReal.liminf_sub_const
code: lemma liminf_sub_const (F : Filter ι) [NeBot F] (f : ι → ℝ≥0∞) (c : ℝ≥0∞) :
    Filter.liminf (fun i ↦ f i - c) F = Filter.liminf f F - c 
goal: Filter.liminf (fun i => f i - c) F = Filter.liminf f F - c

full_name: ENNReal.limsup_const_sub
code: lemma limsup_const_sub (F : Filter ι) [NeBot F] (f : ι → ℝ≥0∞)
    {c : ℝ≥0∞} (c_ne_top : c ≠ ∞) :
    Filter.limsup (fun i ↦ c - f i) F = c - Filter.liminf f F 
goal: Filter.limsup (fun i => c - f i) F = c - Filter.liminf f F

full_name: ENNReal.liminf_const_sub
code: lemma liminf_const_sub (F : Filter ι) [NeBot F] (f : ι → ℝ≥0∞)
    {c : ℝ≥0∞} (c_ne_top : c ≠ ∞) :
    Filter.liminf (fun i ↦ c - f i) F = c - Filter.limsup f F 
goal: Filter.liminf (fun i => c - f i) F = c - Filter.limsup f F

full_name: ENNReal.liminf_toReal_eq
code: /-- If `xs : ι → ℝ≥0∞` is bounded, then we have `liminf (toReal ∘ xs) = toReal (liminf xs)`. -/
lemma liminf_toReal_eq {ι : Type*} {F : Filter ι} [NeBot F] {b : ℝ≥0∞} (b_ne_top : b ≠ ∞)
    {xs : ι → ℝ≥0∞} (le_b : ∀ᶠ i in F, xs i ≤ b) :
    F.liminf (fun i ↦ (xs i).toReal) = (F.liminf xs).toReal 
goal: Filter.liminf (fun i => (xs i).toReal) F = (Filter.liminf xs F).toReal

full_name: ENNReal.limsup_toReal_eq
code: /-- If `xs : ι → ℝ≥0∞` is bounded, then we have `liminf (toReal ∘ xs) = toReal (liminf xs)`. -/
lemma limsup_toReal_eq {ι : Type*} {F : Filter ι} [NeBot F] {b : ℝ≥0∞} (b_ne_top : b ≠ ∞)
    {xs : ι → ℝ≥0∞} (le_b : ∀ᶠ i in F, xs i ≤ b) :
    F.limsup (fun i ↦ (xs i).toReal) = (F.limsup xs).toReal 
goal: Filter.limsup (fun i => (xs i).toReal) F = (Filter.limsup xs F).toReal