ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- UniformEquiv.uniformEmbedding
protected theorem uniformEmbedding (h : α ≃ᵤ β) : UniformEmbedding h 
Arguments: {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β)
Goal: UniformEmbedding ⇑h
-- UniformEquiv.completeSpace_iff
theorem completeSpace_iff (h : α ≃ᵤ β) : CompleteSpace α ↔ CompleteSpace β 
Arguments: {α : Type u} {β : Type u_1} [UniformSpace α] [UniformSpace β] (h : α ≃ᵤ β)
Goal: CompleteSpace α ↔ CompleteSpace β
-- UniformEquiv.prodCongr_symm
@[simp]
theorem prodCongr_symm (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ) :
    (h₁.prodCongr h₂).symm = h₁.symm.prodCongr h₂.symm 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} [UniformSpace α] [UniformSpace β] [UniformSpace γ] [UniformSpace δ] (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ)
Goal: (h₁.prodCongr h₂).symm = h₁.symm.prodCongr h₂.symm
-- UniformEquiv.coe_prodCongr
@[simp]
theorem coe_prodCongr (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ) : ⇑(h₁.prodCongr h₂) = Prod.map h₁ h₂ 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} [UniformSpace α] [UniformSpace β] [UniformSpace γ] [UniformSpace δ] (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ)
Goal: ⇑(h₁.prodCongr h₂) = Prod.map ⇑h₁ ⇑h₂
-- UniformEquiv.prodComm_symm
@[simp]
theorem prodComm_symm : (prodComm α β).symm = prodComm β α 
Arguments: (α : Type u) (β : Type u_1) [UniformSpace α] [UniformSpace β]
Goal: (UniformEquiv.prodComm α β).symm = UniformEquiv.prodComm β α
-- UniformEquiv.coe_prodComm
@[simp]
theorem coe_prodComm : ⇑(prodComm α β) = Prod.swap 
Arguments: (α : Type u) (β : Type u_1) [UniformSpace α] [UniformSpace β]
Goal: ⇑(UniformEquiv.prodComm α β) = Prod.swap
-- UniformEquiv.prodPunit_apply
@[simps! (config := .asFn) apply]
def prodPunit : α × PUnit ≃ᵤ α 
Arguments: (α : Type u) [UniformSpace α]
Goal: ⇑(UniformEquiv.prodPunit α) = fun p => p.1
-- UniformEquiv.coe_punitProd
@[simp]
theorem coe_punitProd : ⇑(punitProd α) = Prod.snd 
Arguments: (α : Type u) [UniformSpace α]
Goal: ⇑(UniformEquiv.punitProd α) = Prod.snd
-- UniformEquiv.piCongrLeft_toEquiv
@[simps! apply toEquiv]
def piCongrLeft {ι ι' : Type*} {β : ι' → Type*} [∀ j, UniformSpace (β j)]
    (e : ι ≃ ι') : (∀ i, β (e i)) ≃ᵤ ∀ j, β j 
Arguments: {ι : Type u_4} {ι' : Type u_5} {β : ι' → Type u_6} [(j : ι') → UniformSpace (β j)] (e : ι ≃ ι')
Goal: (UniformEquiv.piCongrLeft e).toEquiv = Equiv.piCongrLeft β e
-- UniformEquiv.piCongrLeft_apply
@[simps! apply toEquiv]
def piCongrLeft {ι ι' : Type*} {β : ι' → Type*} [∀ j, UniformSpace (β j)]
    (e : ι ≃ ι') : (∀ i, β (e i)) ≃ᵤ ∀ j, β j 
Arguments: {ι : Type u_4} {ι' : Type u_5} {β : ι' → Type u_6} [(j : ι') → UniformSpace (β j)] (e : ι ≃ ι')
Goal: ∀ (a : (b : ι) → β (e.symm.symm b)) (a_1 : ι'),
  (UniformEquiv.piCongrLeft e) a a_1 = (Equiv.piCongrLeft' β e.symm).symm a a_1
-- UniformEquiv.piCongrRight_apply
@[simps! apply toEquiv]
def piCongrRight {ι : Type*} {β₁ β₂ : ι → Type*} [∀ i, UniformSpace (β₁ i)]
    [∀ i, UniformSpace (β₂ i)] (F : ∀ i, β₁ i ≃ᵤ β₂ i) : (∀ i, β₁ i) ≃ᵤ ∀ i, β₂ i 
Arguments: {ι : Type u_4} {β₁ : ι → Type u_5} {β₂ : ι → Type u_6} [(i : ι) → UniformSpace (β₁ i)] [(i : ι) → UniformSpace (β₂ i)] (F : (i : ι) → β₁ i ≃ᵤ β₂ i) (H : (a : ι) → β₁ a) (a : ι)
Goal: (UniformEquiv.piCongrRight F) H a = (F a) (H a)
-- UniformEquiv.piCongrRight_toEquiv
@[simps! apply toEquiv]
def piCongrRight {ι : Type*} {β₁ β₂ : ι → Type*} [∀ i, UniformSpace (β₁ i)]
    [∀ i, UniformSpace (β₂ i)] (F : ∀ i, β₁ i ≃ᵤ β₂ i) : (∀ i, β₁ i) ≃ᵤ ∀ i, β₂ i 
Arguments: {ι : Type u_4} {β₁ : ι → Type u_5} {β₂ : ι → Type u_6} [(i : ι) → UniformSpace (β₁ i)] [(i : ι) → UniformSpace (β₂ i)] (F : (i : ι) → β₁ i ≃ᵤ β₂ i)
Goal: (UniformEquiv.piCongrRight F).toEquiv = Equiv.piCongrRight fun i => (F i).toEquiv
-- UniformEquiv.piCongrRight_symm
@[simp]
theorem piCongrRight_symm {ι : Type*} {β₁ β₂ : ι → Type*} [∀ i, UniformSpace (β₁ i)]
    [∀ i, UniformSpace (β₂ i)] (F : ∀ i, β₁ i ≃ᵤ β₂ i) :
    (piCongrRight F).symm = piCongrRight fun i => (F i).symm 
Arguments: {ι : Type u_4} {β₁ : ι → Type u_5} {β₂ : ι → Type u_6} [(i : ι) → UniformSpace (β₁ i)] [(i : ι) → UniformSpace (β₂ i)] (F : (i : ι) → β₁ i ≃ᵤ β₂ i)
Goal: (UniformEquiv.piCongrRight F).symm = UniformEquiv.piCongrRight fun i => (F i).symm
-- UniformEquiv.piCongr_apply
@[simps! apply toEquiv]
def piCongr {ι₁ ι₂ : Type*} {β₁ : ι₁ → Type*} {β₂ : ι₂ → Type*}
    [∀ i₁, UniformSpace (β₁ i₁)] [∀ i₂, UniformSpace (β₂ i₂)]
    (e : ι₁ ≃ ι₂) (F : ∀ i₁, β₁ i₁ ≃ᵤ β₂ (e i₁)) : (∀ i₁, β₁ i₁) ≃ᵤ ∀ i₂, β₂ i₂ 
Arguments: {ι₁ : Type u_4} {ι₂ : Type u_5} {β₁ : ι₁ → Type u_6} {β₂ : ι₂ → Type u_7} [(i₁ : ι₁) → UniformSpace (β₁ i₁)] [(i₂ : ι₂) → UniformSpace (β₂ i₂)] (e : ι₁ ≃ ι₂) (F : (i₁ : ι₁) → β₁ i₁ ≃ᵤ β₂ (e i₁))
Goal: ∀ (a : (i : ι₁) → β₁ i) (i₂ : ι₂),
  (UniformEquiv.piCongr e F) a i₂ = ⋯ ▸ (Equiv.piCongrRight fun i => (F i).toEquiv) a (e.symm i₂)
-- UniformEquiv.piCongr_toEquiv
@[simps! apply toEquiv]
def piCongr {ι₁ ι₂ : Type*} {β₁ : ι₁ → Type*} {β₂ : ι₂ → Type*}
    [∀ i₁, UniformSpace (β₁ i₁)] [∀ i₂, UniformSpace (β₂ i₂)]
    (e : ι₁ ≃ ι₂) (F : ∀ i₁, β₁ i₁ ≃ᵤ β₂ (e i₁)) : (∀ i₁, β₁ i₁) ≃ᵤ ∀ i₂, β₂ i₂ 
Arguments: {ι₁ : Type u_4} {ι₂ : Type u_5} {β₁ : ι₁ → Type u_6} {β₂ : ι₂ → Type u_7} [(i₁ : ι₁) → UniformSpace (β₁ i₁)] [(i₂ : ι₂) → UniformSpace (β₂ i₂)] (e : ι₁ ≃ ι₂) (F : (i₁ : ι₁) → β₁ i₁ ≃ᵤ β₂ (e i₁))
Goal: (UniformEquiv.piCongr e F).toEquiv = (Equiv.piCongrRight fun i => (F i).toEquiv).trans (Equiv.piCongrLeft β₂ e)
-- UniformEquiv.funUnique_apply
@[simps! (config := .asFn)]
def funUnique (ι α : Type*) [Unique ι] [UniformSpace α] : (ι → α) ≃ᵤ α 
Arguments: (ι : Type u_4) (α : Type u_5) [Unique ι] [UniformSpace α]
Goal: ⇑(UniformEquiv.funUnique ι α) = fun f => f default
-- UniformEquiv.funUnique_symm_apply
@[simps! (config := .asFn)]
def funUnique (ι α : Type*) [Unique ι] [UniformSpace α] : (ι → α) ≃ᵤ α 
Arguments: (ι : Type u_4) (α : Type u_5) [Unique ι] [UniformSpace α]
Goal: ⇑(UniformEquiv.funUnique ι α).symm = uniqueElim
-- UniformEquiv.piFinTwo_symm_apply
@[simps! (config := .asFn)]
def piFinTwo (α : Fin 2 → Type u) [∀ i, UniformSpace (α i)] : (∀ i, α i) ≃ᵤ α 0 × α 1 
Arguments: (α : Fin 2 → Type u) [(i : Fin 2) → UniformSpace (α i)]
Goal: ⇑(UniformEquiv.piFinTwo α).symm = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim)
-- UniformEquiv.piFinTwo_apply
@[simps! (config := .asFn)]
def piFinTwo (α : Fin 2 → Type u) [∀ i, UniformSpace (α i)] : (∀ i, α i) ≃ᵤ α 0 × α 1 
Arguments: (α : Fin 2 → Type u) [(i : Fin 2) → UniformSpace (α i)]
Goal: ⇑(UniformEquiv.piFinTwo α) = fun f => (f 0, f 1)
-- UniformEquiv.finTwoArrow_symm_apply
-- Porting note: made `α` explicit
@[simps! (config := .asFn)]
def finTwoArrow (α : Type*) [UniformSpace α] : (Fin 2 → α) ≃ᵤ α × α 
Arguments: (α : Type u_4) [UniformSpace α]
Goal: ⇑(UniformEquiv.finTwoArrow α).symm = fun x => ![x.1, x.2]
-- UniformEquiv.finTwoArrow_apply
-- Porting note: made `α` explicit
@[simps! (config := .asFn)]
def finTwoArrow (α : Type*) [UniformSpace α] : (Fin 2 → α) ≃ᵤ α × α 
Arguments: (α : Type u_4) [UniformSpace α]
Goal: ⇑(UniformEquiv.finTwoArrow α) = fun f => (f 0, f 1)
-- ENNReal.embedding_coe
theorem embedding_coe : Embedding ((↑) : ℝ≥0 → ℝ≥0∞) 
Goal: Embedding ENNReal.ofNNReal
-- ENNReal.isOpen_ne_top
theorem isOpen_ne_top : IsOpen { a : ℝ≥0∞ | a ≠ ∞ } 
Goal: IsOpen {a | a ≠ ⊤}
-- ENNReal.isOpen_Ico_zero
theorem isOpen_Ico_zero : IsOpen (Ico 0 b) 
Arguments: {b : ℝ≥0∞}
Goal: IsOpen (Set.Ico 0 b)
-- ENNReal.openEmbedding_coe
theorem openEmbedding_coe : OpenEmbedding ((↑) : ℝ≥0 → ℝ≥0∞) 
Goal: OpenEmbedding ENNReal.ofNNReal
-- ENNReal.coe_range_mem_nhds
theorem coe_range_mem_nhds : range ((↑) : ℝ≥0 → ℝ≥0∞) ∈ 𝓝 (r : ℝ≥0∞) 
Arguments: {r : ℝ≥0}
Goal: Set.range ENNReal.ofNNReal ∈ 𝓝 ↑r
-- ENNReal.tendsto_coe
@[norm_cast]
theorem tendsto_coe {f : Filter α} {m : α → ℝ≥0} {a : ℝ≥0} :
    Tendsto (fun a => (m a : ℝ≥0∞)) f (𝓝 ↑a) ↔ Tendsto m f (𝓝 a) 
Arguments: {α : Type u_1} {f : Filter α} {m : α → ℝ≥0} {a : ℝ≥0}
Goal: Filter.Tendsto (fun a => ↑(m a)) f (𝓝 ↑a) ↔ Filter.Tendsto m f (𝓝 a)
-- ENNReal.continuous_coe
@[fun_prop]
theorem continuous_coe : Continuous ((↑) : ℝ≥0 → ℝ≥0∞) 
Goal: Continuous ENNReal.ofNNReal
-- ENNReal.continuous_coe_iff
theorem continuous_coe_iff {α} [TopologicalSpace α] {f : α → ℝ≥0} :
    (Continuous fun a => (f a : ℝ≥0∞)) ↔ Continuous f 
Arguments: {α : Type u_4} [TopologicalSpace α] {f : α → ℝ≥0}
Goal: (Continuous fun a => ↑(f a)) ↔ Continuous f
-- ENNReal.nhds_coe
theorem nhds_coe {r : ℝ≥0} : 𝓝 (r : ℝ≥0∞) = (𝓝 r).map (↑) 
Arguments: {r : ℝ≥0}
Goal: 𝓝 ↑r = Filter.map ENNReal.ofNNReal (𝓝 r)
-- ENNReal.tendsto_nhds_coe_iff
theorem tendsto_nhds_coe_iff {α : Type*} {l : Filter α} {x : ℝ≥0} {f : ℝ≥0∞ → α} :
    Tendsto f (𝓝 ↑x) l ↔ Tendsto (f ∘ (↑) : ℝ≥0 → α) (𝓝 x) l 
Arguments: {α : Type u_4} {l : Filter α} {x : ℝ≥0} {f : ℝ≥0∞ → α}
Goal: Filter.Tendsto f (𝓝 ↑x) l ↔ Filter.Tendsto (f ∘ ENNReal.ofNNReal) (𝓝 x) l
-- ENNReal.continuousAt_coe_iff
theorem continuousAt_coe_iff {α : Type*} [TopologicalSpace α] {x : ℝ≥0} {f : ℝ≥0∞ → α} :
    ContinuousAt f ↑x ↔ ContinuousAt (f ∘ (↑) : ℝ≥0 → α) x 
Arguments: {α : Type u_4} [TopologicalSpace α] {x : ℝ≥0} {f : ℝ≥0∞ → α}
Goal: ContinuousAt f ↑x ↔ ContinuousAt (f ∘ ENNReal.ofNNReal) x
-- ENNReal.nhds_coe_coe
theorem nhds_coe_coe {r p : ℝ≥0} :
    𝓝 ((r : ℝ≥0∞), (p : ℝ≥0∞)) = (𝓝 (r, p)).map fun p : ℝ≥0 × ℝ≥0 => (↑p.1, ↑p.2) 
Arguments: {r p : ℝ≥0}
Goal: 𝓝 (↑r, ↑p) = Filter.map (fun p => (↑p.1, ↑p.2)) (𝓝 (r, p))
-- ENNReal.continuous_ofReal
theorem continuous_ofReal : Continuous ENNReal.ofReal 
Goal: Continuous ENNReal.ofReal
-- ENNReal.tendsto_ofReal
theorem tendsto_ofReal {f : Filter α} {m : α → ℝ} {a : ℝ} (h : Tendsto m f (𝓝 a)) :
    Tendsto (fun a => ENNReal.ofReal (m a)) f (𝓝 (ENNReal.ofReal a)) 
Arguments: {α : Type u_1} {f : Filter α} {m : α → ℝ} {a : ℝ} (h : Filter.Tendsto m f (𝓝 a))
Goal: Filter.Tendsto (fun a => ENNReal.ofReal (m a)) f (𝓝 (ENNReal.ofReal a))
-- ENNReal.tendsto_toNNReal
theorem tendsto_toNNReal {a : ℝ≥0∞} (ha : a ≠ ∞) :
    Tendsto ENNReal.toNNReal (𝓝 a) (𝓝 a.toNNReal) 
Arguments: {a : ℝ≥0∞} (ha : a ≠ ⊤)
Goal: Filter.Tendsto ENNReal.toNNReal (𝓝 a) (𝓝 a.toNNReal)
-- ENNReal.eventuallyEq_of_toReal_eventuallyEq
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 
Arguments: {α : Type u_1} {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)
Goal: f =ᶠ[l] g
-- ENNReal.continuousOn_toNNReal
theorem continuousOn_toNNReal : ContinuousOn ENNReal.toNNReal { a | a ≠ ∞ } 
Goal: ContinuousOn ENNReal.toNNReal {a | a ≠ ⊤}
-- ENNReal.tendsto_toReal
theorem tendsto_toReal {a : ℝ≥0∞} (ha : a ≠ ∞) : Tendsto ENNReal.toReal (𝓝 a) (𝓝 a.toReal) 
Arguments: {a : ℝ≥0∞} (ha : a ≠ ⊤)
Goal: Filter.Tendsto ENNReal.toReal (𝓝 a) (𝓝 a.toReal)
-- ENNReal.continuousOn_toReal
lemma continuousOn_toReal : ContinuousOn ENNReal.toReal { a | a ≠ ∞ } 
Goal: ContinuousOn ENNReal.toReal {a | a ≠ ⊤}
-- ENNReal.continuousAt_toReal
lemma continuousAt_toReal (hx : x ≠ ∞) : ContinuousAt ENNReal.toReal x 
Arguments: {x : ℝ≥0∞} (hx : x ≠ ⊤)
Goal: ContinuousAt ENNReal.toReal x
-- ENNReal.nhds_top
theorem nhds_top : 𝓝 ∞ = ⨅ (a) (_ : a ≠ ∞), 𝓟 (Ioi a) 
Goal: 𝓝 ⊤ = ⨅ a, ⨅ (_ : a ≠ ⊤), 𝓟 (Set.Ioi a)
-- ENNReal.nhds_top'
theorem nhds_top' : 𝓝 ∞ = ⨅ r : ℝ≥0, 𝓟 (Ioi ↑r) 
Goal: 𝓝 ⊤ = ⨅ r, 𝓟 (Set.Ioi ↑r)
-- ENNReal.nhds_top_basis
theorem nhds_top_basis : (𝓝 ∞).HasBasis (fun a => a < ∞) fun a => Ioi a 
Goal: (𝓝 ⊤).HasBasis (fun a => a < ⊤) fun a => Set.Ioi a
-- ENNReal.tendsto_nhds_top_iff_nnreal
theorem tendsto_nhds_top_iff_nnreal {m : α → ℝ≥0∞} {f : Filter α} :
    Tendsto m f (𝓝 ∞) ↔ ∀ x : ℝ≥0, ∀ᶠ a in f, ↑x < m a 
Arguments: {α : Type u_1} {m : α → ℝ≥0∞} {f : Filter α}
Goal: Filter.Tendsto m f (𝓝 ⊤) ↔ ∀ (x : ℝ≥0), ∀ᶠ (a : α) in f, ↑x < m a
-- ENNReal.tendsto_nhds_top_iff_nat
theorem tendsto_nhds_top_iff_nat {m : α → ℝ≥0∞} {f : Filter α} :
    Tendsto m f (𝓝 ∞) ↔ ∀ n : ℕ, ∀ᶠ a in f, ↑n < m a 
Arguments: {α : Type u_1} {m : α → ℝ≥0∞} {f : Filter α}
Goal: Filter.Tendsto m f (𝓝 ⊤) ↔ ∀ (n : ℕ), ∀ᶠ (a : α) in f, ↑n < m a
-- ENNReal.tendsto_nhds_top
theorem tendsto_nhds_top {m : α → ℝ≥0∞} {f : Filter α} (h : ∀ n : ℕ, ∀ᶠ a in f, ↑n < m a) :
    Tendsto m f (𝓝 ∞) 
Arguments: {α : Type u_1} {m : α → ℝ≥0∞} {f : Filter α} (h : ∀ (n : ℕ), ∀ᶠ (a : α) in f, ↑n < m a)
Goal: Filter.Tendsto m f (𝓝 ⊤)
-- ENNReal.tendsto_nat_nhds_top
theorem tendsto_nat_nhds_top : Tendsto (fun n : ℕ => ↑n) atTop (𝓝 ∞) 
Goal: Filter.Tendsto (fun n => ↑n) Filter.atTop (𝓝 ⊤)
-- ENNReal.tendsto_coe_nhds_top
@[simp, norm_cast]
theorem tendsto_coe_nhds_top {f : α → ℝ≥0} {l : Filter α} :
    Tendsto (fun x => (f x : ℝ≥0∞)) l (𝓝 ∞) ↔ Tendsto f l atTop 
Arguments: {α : Type u_1} {f : α → ℝ≥0} {l : Filter α}
Goal: Filter.Tendsto (fun x => ↑(f x)) l (𝓝 ⊤) ↔ Filter.Tendsto f l Filter.atTop
-- ENNReal.tendsto_ofReal_nhds_top
@[simp]
theorem tendsto_ofReal_nhds_top {f : α → ℝ} {l : Filter α} :
    Tendsto (fun x ↦ ENNReal.ofReal (f x)) l (𝓝 ∞) ↔ Tendsto f l atTop 
Arguments: {α : Type u_1} {f : α → ℝ} {l : Filter α}
Goal: Filter.Tendsto (fun x => ENNReal.ofReal (f x)) l (𝓝 ⊤) ↔ Filter.Tendsto f l Filter.atTop
-- ENNReal.tendsto_ofReal_atTop
theorem tendsto_ofReal_atTop : Tendsto ENNReal.ofReal atTop (𝓝 ∞) 
Goal: Filter.Tendsto ENNReal.ofReal Filter.atTop (𝓝 ⊤)
-- ENNReal.nhds_zero
theorem nhds_zero : 𝓝 (0 : ℝ≥0∞) = ⨅ (a) (_ : a ≠ 0), 𝓟 (Iio a) 
Goal: 𝓝 0 = ⨅ a, ⨅ (_ : a ≠ 0), 𝓟 (Set.Iio a)
-- ENNReal.nhds_zero_basis
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
-- ENNReal.nhds_zero_basis_Iic
theorem nhds_zero_basis_Iic : (𝓝 (0 : ℝ≥0∞)).HasBasis (fun a : ℝ≥0∞ => 0 < a) Iic 
Goal: (𝓝 0).HasBasis (fun a => 0 < a) Set.Iic
-- ENNReal.nhdsWithin_Ioi_coe_neBot
@[instance]
theorem nhdsWithin_Ioi_coe_neBot {r : ℝ≥0} : (𝓝[>] (r : ℝ≥0∞)).NeBot 
Arguments: {r : ℝ≥0}
Goal: (𝓝[>] ↑r).NeBot
-- ENNReal.nhdsWithin_Ioi_zero_neBot
@[instance]
theorem nhdsWithin_Ioi_zero_neBot : (𝓝[>] (0 : ℝ≥0∞)).NeBot 
Goal: (𝓝[>] 0).NeBot
-- ENNReal.nhdsWithin_Ioi_one_neBot
@[instance]
theorem nhdsWithin_Ioi_one_neBot : (𝓝[>] (1 : ℝ≥0∞)).NeBot 
Goal: (𝓝[>] 1).NeBot
-- ENNReal.nhdsWithin_Ioi_nat_neBot
@[instance]
theorem nhdsWithin_Ioi_nat_neBot (n : ℕ) : (𝓝[>] (n : ℝ≥0∞)).NeBot 
Arguments: (n : ℕ)
Goal: (𝓝[>] ↑n).NeBot
-- ENNReal.nhdsWithin_Ioi_ofNat_nebot
@[instance]
theorem nhdsWithin_Ioi_ofNat_nebot (n : ℕ) [n.AtLeastTwo] :
    (𝓝[>] (OfNat.ofNat n : ℝ≥0∞)).NeBot 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: (𝓝[>] OfNat.ofNat n).NeBot
-- ENNReal.nhdsWithin_Iio_neBot
@[instance]
theorem nhdsWithin_Iio_neBot [NeZero x] : (𝓝[<] x).NeBot 
Arguments: {x : ℝ≥0∞} [NeZero x]
Goal: (𝓝[<] x).NeBot
-- ENNReal.hasBasis_nhds_of_ne_top'
theorem hasBasis_nhds_of_ne_top' (xt : x ≠ ∞) :
    (𝓝 x).HasBasis (· ≠ 0) (fun ε => Icc (x - ε) (x + ε)) 
Arguments: {x : ℝ≥0∞} (xt : x ≠ ⊤)
Goal: (𝓝 x).HasBasis (fun x => x ≠ 0) fun ε => Set.Icc (x - ε) (x + ε)
-- ENNReal.hasBasis_nhds_of_ne_top
theorem hasBasis_nhds_of_ne_top (xt : x ≠ ∞) :
    (𝓝 x).HasBasis (0 < ·) (fun ε => Icc (x - ε) (x + ε)) 
Arguments: {x : ℝ≥0∞} (xt : x ≠ ⊤)
Goal: (𝓝 x).HasBasis (fun x => 0 < x) fun ε => Set.Icc (x - ε) (x + ε)
-- ENNReal.Icc_mem_nhds
theorem Icc_mem_nhds (xt : x ≠ ∞) (ε0 : ε ≠ 0) : Icc (x - ε) (x + ε) ∈ 𝓝 x 
Arguments: {x ε : ℝ≥0∞} (xt : x ≠ ⊤) (ε0 : ε ≠ 0)
Goal: Set.Icc (x - ε) (x + ε) ∈ 𝓝 x
-- ENNReal.nhds_of_ne_top
theorem nhds_of_ne_top (xt : x ≠ ∞) : 𝓝 x = ⨅ ε > 0, 𝓟 (Icc (x - ε) (x + ε)) 
Arguments: {x : ℝ≥0∞} (xt : x ≠ ⊤)
Goal: 𝓝 x = ⨅ ε, ⨅ (_ : ε > 0), 𝓟 (Set.Icc (x - ε) (x + ε))
-- ENNReal.biInf_le_nhds
theorem biInf_le_nhds : ∀ x : ℝ≥0∞, ⨅ ε > 0, 𝓟 (Icc (x - ε) (x + ε)) ≤ 𝓝 x
  
Arguments: (x : ℝ≥0∞)
Goal: ⨅ ε, ⨅ (_ : ε > 0), 𝓟 (Set.Icc (x - ε) (x + ε)) ≤ 𝓝 x
-- ENNReal.tendsto_nhds_of_Icc
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) 
Arguments: {α : Type u_1} {f : Filter α} {u : α → ℝ≥0∞} {a : ℝ≥0∞} (h : ∀ ε > 0, ∀ᶠ (x : α) in f, u x ∈ Set.Icc (a - ε) (a + ε))
Goal: Filter.Tendsto u f (𝓝 a)
-- ENNReal.tendsto_nhds
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 + ε) 
Arguments: {α : Type u_1} {f : Filter α} {u : α → ℝ≥0∞} {a : ℝ≥0∞} (ha : a ≠ ⊤)
Goal: Filter.Tendsto u f (𝓝 a) ↔ ∀ ε > 0, ∀ᶠ (x : α) in f, u x ∈ Set.Icc (a - ε) (a + ε)
-- ENNReal.tendsto_nhds_zero
protected theorem tendsto_nhds_zero {f : Filter α} {u : α → ℝ≥0∞} :
    Tendsto u f (𝓝 0) ↔ ∀ ε > 0, ∀ᶠ x in f, u x ≤ ε 
Arguments: {α : Type u_1} {f : Filter α} {u : α → ℝ≥0∞}
Goal: Filter.Tendsto u f (𝓝 0) ↔ ∀ ε > 0, ∀ᶠ (x : α) in f, u x ≤ ε
-- ENNReal.tendsto_atTop
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 + ε) 
Arguments: {β : Type u_2} [Nonempty β] [SemilatticeSup β] {f : β → ℝ≥0∞} {a : ℝ≥0∞} (ha : a ≠ ⊤)
Goal: Filter.Tendsto f Filter.atTop (𝓝 a) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, f n ∈ Set.Icc (a - ε) (a + ε)
-- ENNReal.tendsto_atTop_zero
protected theorem tendsto_atTop_zero [Nonempty β] [SemilatticeSup β] {f : β → ℝ≥0∞} :
    Tendsto f atTop (𝓝 0) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, f n ≤ ε 
Arguments: {β : Type u_2} [Nonempty β] [SemilatticeSup β] {f : β → ℝ≥0∞}
Goal: Filter.Tendsto f Filter.atTop (𝓝 0) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, f n ≤ ε
-- ENNReal.tendsto_sub
theorem tendsto_sub : ∀ {a b : ℝ≥0∞}, (a ≠ ∞ ∨ b ≠ ∞) →
    Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 - p.2) (𝓝 (a, b)) (𝓝 (a - b))
  
Arguments: {a b : ℝ≥0∞}
Goal: a ≠ ⊤ ∨ b ≠ ⊤ → Filter.Tendsto (fun p => p.1 - p.2) (𝓝 (a, b)) (𝓝 (a - b))
-- ENNReal.Tendsto.sub
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)) 
Arguments: {α : Type u_1} {f : Filter α} {ma mb : α → ℝ≥0∞} {a b : ℝ≥0∞} (hma : Filter.Tendsto ma f (𝓝 a)) (hmb : Filter.Tendsto mb f (𝓝 b)) (h : a ≠ ⊤ ∨ b ≠ ⊤)
Goal: Filter.Tendsto (fun a => ma a - mb a) f (𝓝 (a - b))
-- ENNReal.tendsto_mul
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)) 
Arguments: {a b : ℝ≥0∞} (ha : a ≠ 0 ∨ b ≠ ⊤) (hb : b ≠ 0 ∨ a ≠ ⊤)
Goal: Filter.Tendsto (fun p => p.1 * p.2) (𝓝 (a, b)) (𝓝 (a * b))
-- ENNReal.Tendsto.mul
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)) 
Arguments: {α : Type u_1} {f : Filter α} {ma mb : α → ℝ≥0∞} {a b : ℝ≥0∞} (hma : Filter.Tendsto ma f (𝓝 a)) (ha : a ≠ 0 ∨ b ≠ ⊤) (hmb : Filter.Tendsto mb f (𝓝 b)) (hb : b ≠ 0 ∨ a ≠ ⊤)
Goal: Filter.Tendsto (fun a => ma a * mb a) f (𝓝 (a * b))
-- ContinuousOn.ennreal_mul
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 
Arguments: {α : Type u_1} [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 ≠ ⊤)
Goal: ContinuousOn (fun x => f x * g x) s
-- Continuous.ennreal_mul
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 
Arguments: {α : Type u_1} [TopologicalSpace α] {f g : α → ℝ≥0∞} (hf : Continuous f) (hg : Continuous g) (h₁ : ∀ (x : α), f x ≠ 0 ∨ g x ≠ ⊤) (h₂ : ∀ (x : α), g x ≠ 0 ∨ f x ≠ ⊤)
Goal: Continuous fun x => f x * g x
-- ENNReal.Tendsto.const_mul
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)) 
Arguments: {α : Type u_1} {f : Filter α} {m : α → ℝ≥0∞} {a b : ℝ≥0∞} (hm : Filter.Tendsto m f (𝓝 b)) (hb : b ≠ 0 ∨ a ≠ ⊤)
Goal: Filter.Tendsto (fun b => a * m b) f (𝓝 (a * b))
-- ENNReal.Tendsto.mul_const
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)) 
Arguments: {α : Type u_1} {f : Filter α} {m : α → ℝ≥0∞} {a b : ℝ≥0∞} (hm : Filter.Tendsto m f (𝓝 a)) (ha : a ≠ 0 ∨ b ≠ ⊤)
Goal: Filter.Tendsto (fun x => m x * b) f (𝓝 (a * b))
-- ENNReal.tendsto_finset_prod_of_ne_top
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)) 
Arguments: {α : Type u_1} {ι : Type u_4} {f : ι → α → ℝ≥0∞} {x : Filter α} {a : ι → ℝ≥0∞} (s : Finset ι) (h : ∀ i ∈ s, Filter.Tendsto (f i) x (𝓝 (a i))) (h' : ∀ i ∈ s, a i ≠ ⊤)
Goal: Filter.Tendsto (fun b => ∏ c ∈ s, f c b) x (𝓝 (∏ c ∈ s, a c))
-- ENNReal.continuousAt_const_mul
protected theorem continuousAt_const_mul {a b : ℝ≥0∞} (h : a ≠ ∞ ∨ b ≠ 0) :
    ContinuousAt (a * ·) b 
Arguments: {a b : ℝ≥0∞} (h : a ≠ ⊤ ∨ b ≠ 0)
Goal: ContinuousAt (fun x => a * x) b
-- ENNReal.continuousAt_mul_const
protected theorem continuousAt_mul_const {a b : ℝ≥0∞} (h : a ≠ ∞ ∨ b ≠ 0) :
    ContinuousAt (fun x => x * a) b 
Arguments: {a b : ℝ≥0∞} (h : a ≠ ⊤ ∨ b ≠ 0)
Goal: ContinuousAt (fun x => x * a) b
-- ENNReal.continuous_const_mul
protected theorem continuous_const_mul {a : ℝ≥0∞} (ha : a ≠ ∞) : Continuous (a * ·) 
Arguments: {a : ℝ≥0∞} (ha : a ≠ ⊤)
Goal: Continuous fun x => a * x
-- ENNReal.continuous_mul_const
protected theorem continuous_mul_const {a : ℝ≥0∞} (ha : a ≠ ∞) : Continuous fun x => x * a 
Arguments: {a : ℝ≥0∞} (ha : a ≠ ⊤)
Goal: Continuous fun x => x * a
-- ENNReal.continuous_div_const
protected theorem continuous_div_const (c : ℝ≥0∞) (c_ne_zero : c ≠ 0) :
    Continuous fun x : ℝ≥0∞ => x / c 
Arguments: (c : ℝ≥0∞) (c_ne_zero : c ≠ 0)
Goal: Continuous fun x => x / c
-- ENNReal.continuous_pow
@[continuity]
theorem continuous_pow (n : ℕ) : Continuous fun a : ℝ≥0∞ => a ^ n 
Arguments: (n : ℕ)
Goal: Continuous fun a => a ^ n
-- ENNReal.continuousOn_sub
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 ≠ (⊤, ⊤)}
-- ENNReal.continuous_sub_left
theorem continuous_sub_left {a : ℝ≥0∞} (a_ne_top : a ≠ ∞) : Continuous (a - ·) 
Arguments: {a : ℝ≥0∞} (a_ne_top : a ≠ ⊤)
Goal: Continuous fun x => a - x
-- ENNReal.continuous_nnreal_sub
theorem continuous_nnreal_sub {a : ℝ≥0} : Continuous fun x : ℝ≥0∞ => (a : ℝ≥0∞) - x 
Arguments: {a : ℝ≥0}
Goal: Continuous fun x => ↑a - x
-- ENNReal.continuousOn_sub_left
theorem continuousOn_sub_left (a : ℝ≥0∞) : ContinuousOn (a - ·) { x : ℝ≥0∞ | x ≠ ∞ } 
Arguments: (a : ℝ≥0∞)
Goal: ContinuousOn (fun x => a - x) {x | x ≠ ⊤}
-- ENNReal.continuous_sub_right
theorem continuous_sub_right (a : ℝ≥0∞) : Continuous fun x : ℝ≥0∞ => x - a 
Arguments: (a : ℝ≥0∞)
Goal: Continuous fun x => x - a
-- ENNReal.Tendsto.pow
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)) 
Arguments: {α : Type u_1} {f : Filter α} {m : α → ℝ≥0∞} {a : ℝ≥0∞} {n : ℕ} (hm : Filter.Tendsto m f (𝓝 a))
Goal: Filter.Tendsto (fun x => m x ^ n) f (𝓝 (a ^ n))
-- ENNReal.le_of_forall_lt_one_mul_le
theorem le_of_forall_lt_one_mul_le {x y : ℝ≥0∞} (h : ∀ a < 1, a * x ≤ y) : x ≤ y 
Arguments: {x y : ℝ≥0∞} (h : ∀ a < 1, a * x ≤ y)
Goal: x ≤ y
-- ENNReal.iInf_mul_left'
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 
Arguments: {ι : Sort u_4} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} (h : a = ⊤ → ⨅ i, f i = 0 → ∃ i, f i = 0) (h0 : a = 0 → Nonempty ι)
Goal: ⨅ i, a * f i = a * ⨅ i, f i