ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- DiscreteQuotient.leComap_id
theorem leComap_id : LEComap (.id X) A A 
Arguments: {X : Type u_2} [TopologicalSpace X] (A : DiscreteQuotient X)
Goal: DiscreteQuotient.LEComap (ContinuousMap.id X) A A
-- DiscreteQuotient.leComap_id_iff
@[simp]
theorem leComap_id_iff : LEComap (ContinuousMap.id X) A A' ↔ A ≤ A' 
Arguments: {X : Type u_2} [TopologicalSpace X] {A A' : DiscreteQuotient X}
Goal: DiscreteQuotient.LEComap (ContinuousMap.id X) A A' ↔ A ≤ A'
-- DiscreteQuotient.LEComap.comp
theorem LEComap.comp : LEComap g B C → LEComap f A B → LEComap (g.comp f) A C 
Arguments: {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {f : C(X, Y)} {A : DiscreteQuotient X} {B : DiscreteQuotient Y} {g : C(Y, Z)} {C : DiscreteQuotient Z}
Goal: DiscreteQuotient.LEComap g B C → DiscreteQuotient.LEComap f A B → DiscreteQuotient.LEComap (g.comp f) A C
-- DiscreteQuotient.LEComap.mono
@[mono]
theorem LEComap.mono (h : LEComap f A B) (hA : A' ≤ A) (hB : B ≤ B') : LEComap f A' B' 
Arguments: {X : Type u_2} {Y : Type u_3} [TopologicalSpace X] [TopologicalSpace Y] {f : C(X, Y)} {A A' : DiscreteQuotient X} {B B' : DiscreteQuotient Y} (h : DiscreteQuotient.LEComap f A B) (hA : A' ≤ A) (hB : B ≤ B')
Goal: DiscreteQuotient.LEComap f A' B'
-- DiscreteQuotient.map_continuous
theorem map_continuous (cond : LEComap f A B) : Continuous (map f cond) 
Arguments: {X : Type u_2} {Y : Type u_3} [TopologicalSpace X] [TopologicalSpace Y] {f : C(X, Y)} {A : DiscreteQuotient X} {B : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B)
Goal: Continuous (DiscreteQuotient.map f cond)
-- DiscreteQuotient.map_comp_proj
@[simp]
theorem map_comp_proj (cond : LEComap f A B) : map f cond ∘ A.proj = B.proj ∘ f 
Arguments: {X : Type u_2} {Y : Type u_3} [TopologicalSpace X] [TopologicalSpace Y] {f : C(X, Y)} {A : DiscreteQuotient X} {B : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B)
Goal: DiscreteQuotient.map f cond ∘ A.proj = B.proj ∘ ⇑f
-- DiscreteQuotient.map_proj
@[simp]
theorem map_proj (cond : LEComap f A B) (x : X) : map f cond (A.proj x) = B.proj (f x) 
Arguments: {X : Type u_2} {Y : Type u_3} [TopologicalSpace X] [TopologicalSpace Y] {f : C(X, Y)} {A : DiscreteQuotient X} {B : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B) (x : X)
Goal: DiscreteQuotient.map f cond (A.proj x) = B.proj (f x)
-- DiscreteQuotient.map_id
@[simp]
theorem map_id : map _ (leComap_id A) = id 
Arguments: {X : Type u_2} [TopologicalSpace X] {A : DiscreteQuotient X}
Goal: DiscreteQuotient.map (ContinuousMap.id X) ⋯ = id
-- DiscreteQuotient.map_comp
theorem map_comp (h1 : LEComap g B C) (h2 : LEComap f A B) :
    map (g.comp f) (h1.comp h2) = map g h1 ∘ map f h2 
Arguments: {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {f : C(X, Y)} {A : DiscreteQuotient X} {B : DiscreteQuotient Y} {g : C(Y, Z)} {C : DiscreteQuotient Z} (h1 : DiscreteQuotient.LEComap g B C) (h2 : DiscreteQuotient.LEComap f A B)
Goal: DiscreteQuotient.map (g.comp f) ⋯ = DiscreteQuotient.map g h1 ∘ DiscreteQuotient.map f h2
-- DiscreteQuotient.ofLE_map
@[simp]
theorem ofLE_map (cond : LEComap f A B) (h : B ≤ B') (a : A) :
    ofLE h (map f cond a) = map f (cond.mono le_rfl h) a 
Arguments: {X : Type u_2} {Y : Type u_3} [TopologicalSpace X] [TopologicalSpace Y] {f : C(X, Y)} {A : DiscreteQuotient X} {B B' : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B) (h : B ≤ B') (a : Quotient A.toSetoid)
Goal: DiscreteQuotient.ofLE h (DiscreteQuotient.map f cond a) = DiscreteQuotient.map f ⋯ a
-- DiscreteQuotient.ofLE_comp_map
@[simp]
theorem ofLE_comp_map (cond : LEComap f A B) (h : B ≤ B') :
    ofLE h ∘ map f cond = map f (cond.mono le_rfl h) 
Arguments: {X : Type u_2} {Y : Type u_3} [TopologicalSpace X] [TopologicalSpace Y] {f : C(X, Y)} {A : DiscreteQuotient X} {B B' : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B) (h : B ≤ B')
Goal: DiscreteQuotient.ofLE h ∘ DiscreteQuotient.map f cond = DiscreteQuotient.map f ⋯
-- DiscreteQuotient.map_ofLE
@[simp]
theorem map_ofLE (cond : LEComap f A B) (h : A' ≤ A) (c : A') :
    map f cond (ofLE h c) = map f (cond.mono h le_rfl) c 
Arguments: {X : Type u_2} {Y : Type u_3} [TopologicalSpace X] [TopologicalSpace Y] {f : C(X, Y)} {A A' : DiscreteQuotient X} {B : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B) (h : A' ≤ A) (c : Quotient A'.toSetoid)
Goal: DiscreteQuotient.map f cond (DiscreteQuotient.ofLE h c) = DiscreteQuotient.map f ⋯ c
-- DiscreteQuotient.map_comp_ofLE
@[simp]
theorem map_comp_ofLE (cond : LEComap f A B) (h : A' ≤ A) :
    map f cond ∘ ofLE h = map f (cond.mono h le_rfl) 
Arguments: {X : Type u_2} {Y : Type u_3} [TopologicalSpace X] [TopologicalSpace Y] {f : C(X, Y)} {A A' : DiscreteQuotient X} {B : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B) (h : A' ≤ A)
Goal: DiscreteQuotient.map f cond ∘ DiscreteQuotient.ofLE h = DiscreteQuotient.map f ⋯
-- DiscreteQuotient.eq_of_forall_proj_eq
theorem eq_of_forall_proj_eq [T2Space X] [CompactSpace X] [disc : TotallyDisconnectedSpace X]
    {x y : X} (h : ∀ Q : DiscreteQuotient X, Q.proj x = Q.proj y) : x = y 
Arguments: {X : Type u_2} [TopologicalSpace X] [T2Space X] [CompactSpace X] [disc : TotallyDisconnectedSpace X] {x y : X} (h : ∀ (Q : DiscreteQuotient X), Q.proj x = Q.proj y)
Goal: x = y
-- DiscreteQuotient.fiber_subset_ofLE
theorem fiber_subset_ofLE {A B : DiscreteQuotient X} (h : A ≤ B) (a : A) :
    A.proj ⁻¹' {a} ⊆ B.proj ⁻¹' {ofLE h a} 
Arguments: {X : Type u_2} [TopologicalSpace X] {A B : DiscreteQuotient X} (h : A ≤ B) (a : Quotient A.toSetoid)
Goal: A.proj ⁻¹' {a} ⊆ B.proj ⁻¹' {DiscreteQuotient.ofLE h a}
-- DiscreteQuotient.exists_of_compat
theorem exists_of_compat [CompactSpace X] (Qs : (Q : DiscreteQuotient X) → Q)
    (compat : ∀ (A B : DiscreteQuotient X) (h : A ≤ B), ofLE h (Qs _) = Qs _) :
    ∃ x : X, ∀ Q : DiscreteQuotient X, Q.proj x = Qs _ 
Arguments: {X : Type u_2} [TopologicalSpace X] [CompactSpace X] (Qs : (Q : DiscreteQuotient X) → Quotient Q.toSetoid) (compat : ∀ (A B : DiscreteQuotient X) (h : A ≤ B), DiscreteQuotient.ofLE h (Qs A) = Qs B)
Goal: ∃ x, ∀ (Q : DiscreteQuotient X), Q.proj x = Qs Q
-- DiscreteQuotient.comp_finsetClopens
lemma comp_finsetClopens [CompactSpace X] :
    (Set.image (fun (t : Clopens X) ↦ t.carrier) ∘ Finset.toSet) ∘
      finsetClopens X = fun ⟨f, _⟩ ↦ f.classes 
Arguments: (X : Type u_2) [TopologicalSpace X] [CompactSpace X]
Goal: ((Set.image fun t => t.carrier) ∘ Finset.toSet) ∘ DiscreteQuotient.finsetClopens X = fun x =>
  match x with
  | { toSetoid := f, isOpen_setOf_rel := isOpen_setOf_rel } => f.classes
-- DiscreteQuotient.finsetClopens_inj
theorem finsetClopens_inj [CompactSpace X] :
    (finsetClopens X).Injective 
Arguments: (X : Type u_2) [TopologicalSpace X] [CompactSpace X]
Goal: Function.Injective (DiscreteQuotient.finsetClopens X)
-- LocallyConstant.lift_comp_proj
@[simp]
theorem lift_comp_proj : f.lift ∘ f.discreteQuotient.proj = f 
Arguments: {α : Type u_1} {X : Type u_2} [TopologicalSpace X] (f : LocallyConstant X α)
Goal: ⇑f.lift ∘ f.discreteQuotient.proj = ⇑f
-- IsSpectralMap.isCompact_preimage_of_isOpen
structure IsSpectralMap (f : α → β) extends Continuous f : Prop where
    isCompact_preimage_of_isOpen ⦃s : Set β⦄ : IsOpen s → IsCompact s → IsCompact (f ⁻¹' s)
Arguments: {α : Type u_2} {β : Type u_3} [TopologicalSpace α] [TopologicalSpace β] {f : α → β} (self : IsSpectralMap f) ⦃s : Set β⦄
Goal: IsOpen s → IsCompact s → IsCompact (f ⁻¹' s)
-- IsCompact.preimage_of_isOpen
theorem IsCompact.preimage_of_isOpen (hf : IsSpectralMap f) (h₀ : IsCompact s) (h₁ : IsOpen s) :
    IsCompact (f ⁻¹' s) 
Arguments: {α : Type u_2} {β : Type u_3} [TopologicalSpace α] [TopologicalSpace β] {f : α → β} {s : Set β} (hf : IsSpectralMap f) (h₀ : IsCompact s) (h₁ : IsOpen s)
Goal: IsCompact (f ⁻¹' s)
-- IsSpectralMap.continuous
theorem IsSpectralMap.continuous {f : α → β} (hf : IsSpectralMap f) : Continuous f 
Arguments: {α : Type u_2} {β : Type u_3} [TopologicalSpace α] [TopologicalSpace β] {f : α → β} (hf : IsSpectralMap f)
Goal: Continuous f
-- isSpectralMap_id
theorem isSpectralMap_id : IsSpectralMap (@id α) 
Arguments: {α : Type u_2} [TopologicalSpace α]
Goal: IsSpectralMap id
-- IsSpectralMap.comp
theorem IsSpectralMap.comp {f : β → γ} {g : α → β} (hf : IsSpectralMap f) (hg : IsSpectralMap g) :
    IsSpectralMap (f ∘ g) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] {f : β → γ} {g : α → β} (hf : IsSpectralMap f) (hg : IsSpectralMap g)
Goal: IsSpectralMap (f ∘ g)
-- SpectralMap.spectral'
structure SpectralMap (α β : Type*) [TopologicalSpace α] [TopologicalSpace β] where
    toFun : α → β
    spectral' : IsSpectralMap toFun
Arguments: {α : Type u_6} {β : Type u_7} [TopologicalSpace α] [TopologicalSpace β] (self : SpectralMap α β)
Goal: IsSpectralMap self.toFun
-- SpectralMapClass.map_spectral
class SpectralMapClass (F α β : Type*) [TopologicalSpace α] [TopologicalSpace β]
    [FunLike F α β] : Prop where
    map_spectral (f : F) : IsSpectralMap f
Arguments: {F : Type u_6} {α : Type u_7} {β : Type u_8} [TopologicalSpace α] [TopologicalSpace β] [FunLike F α β] [self : SpectralMapClass F α β] (f : F)
Goal: IsSpectralMap ⇑f
-- SpectralMap.toFun_eq_coe
@[simp]
theorem toFun_eq_coe {f : SpectralMap α β} : f.toFun = (f : α → β) 
Arguments: {α : Type u_2} {β : Type u_3} [TopologicalSpace α] [TopologicalSpace β] {f : SpectralMap α β}
Goal: f.toFun = ⇑f
-- SpectralMap.ext
@[ext]
theorem ext {f g : SpectralMap α β} (h : ∀ a, f a = g a) : f = g 
Arguments: {α : Type u_2} {β : Type u_3} [TopologicalSpace α] [TopologicalSpace β] {f g : SpectralMap α β} (h : ∀ (a : α), f a = g a)
Goal: f = g
-- SpectralMap.coe_copy
@[simp]
theorem coe_copy (f : SpectralMap α β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f' 
Arguments: {α : Type u_2} {β : Type u_3} [TopologicalSpace α] [TopologicalSpace β] (f : SpectralMap α β) (f' : α → β) (h : f' = ⇑f)
Goal: ⇑(f.copy f' h) = f'
-- SpectralMap.copy_eq
theorem copy_eq (f : SpectralMap α β) (f' : α → β) (h : f' = f) : f.copy f' h = f 
Arguments: {α : Type u_2} {β : Type u_3} [TopologicalSpace α] [TopologicalSpace β] (f : SpectralMap α β) (f' : α → β) (h : f' = ⇑f)
Goal: f.copy f' h = f
-- SpectralMap.coe_id
@[simp]
theorem coe_id : ⇑(SpectralMap.id α) = id 
Arguments: (α : Type u_2) [TopologicalSpace α]
Goal: ⇑(SpectralMap.id α) = id
-- SpectralMap.id_apply
@[simp]
theorem id_apply (a : α) : SpectralMap.id α a = a 
Arguments: {α : Type u_2} [TopologicalSpace α] (a : α)
Goal: (SpectralMap.id α) a = a
-- SpectralMap.coe_comp
@[simp]
theorem coe_comp (f : SpectralMap β γ) (g : SpectralMap α β) : (f.comp g : α → γ) = f ∘ g 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] (f : SpectralMap β γ) (g : SpectralMap α β)
Goal: ⇑(f.comp g) = ⇑f ∘ ⇑g
-- SpectralMap.comp_apply
@[simp]
theorem comp_apply (f : SpectralMap β γ) (g : SpectralMap α β) (a : α) : (f.comp g) a = f (g a) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] (f : SpectralMap β γ) (g : SpectralMap α β) (a : α)
Goal: (f.comp g) a = f (g a)
-- SpectralMap.coe_comp_continuousMap
theorem coe_comp_continuousMap (f : SpectralMap β γ) (g : SpectralMap α β) :
    f ∘ g = (f : ContinuousMap β γ) ∘ (g : ContinuousMap α β) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] (f : SpectralMap β γ) (g : SpectralMap α β)
Goal: ⇑f ∘ ⇑g = ⇑↑f ∘ ⇑↑g
-- SpectralMap.coe_comp_continuousMap'
@[simp]
theorem coe_comp_continuousMap' (f : SpectralMap β γ) (g : SpectralMap α β) :
    (f.comp g : ContinuousMap α γ) = (f : ContinuousMap β γ).comp g 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] (f : SpectralMap β γ) (g : SpectralMap α β)
Goal: ↑(f.comp g) = (↑f).comp ↑g
-- SpectralMap.comp_assoc
@[simp]
theorem comp_assoc (f : SpectralMap γ δ) (g : SpectralMap β γ) (h : SpectralMap α β) :
    (f.comp g).comp h = f.comp (g.comp h) 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} {δ : Type u_5} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] [TopologicalSpace δ] (f : SpectralMap γ δ) (g : SpectralMap β γ) (h : SpectralMap α β)
Goal: (f.comp g).comp h = f.comp (g.comp h)
-- SpectralMap.comp_id
@[simp]
theorem comp_id (f : SpectralMap α β) : f.comp (SpectralMap.id α) = f 
Arguments: {α : Type u_2} {β : Type u_3} [TopologicalSpace α] [TopologicalSpace β] (f : SpectralMap α β)
Goal: f.comp (SpectralMap.id α) = f
-- SpectralMap.id_comp
@[simp]
theorem id_comp (f : SpectralMap α β) : (SpectralMap.id β).comp f = f 
Arguments: {α : Type u_2} {β : Type u_3} [TopologicalSpace α] [TopologicalSpace β] (f : SpectralMap α β)
Goal: (SpectralMap.id β).comp f = f
-- SpectralMap.cancel_right
@[simp]
theorem cancel_right {g₁ g₂ : SpectralMap β γ} {f : SpectralMap α β} (hf : Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] {g₁ g₂ : SpectralMap β γ} {f : SpectralMap α β} (hf : Function.Surjective ⇑f)
Goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂
-- SpectralMap.cancel_left
@[simp]
theorem cancel_left {g : SpectralMap β γ} {f₁ f₂ : SpectralMap α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
Arguments: {α : Type u_2} {β : Type u_3} {γ : Type u_4} [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ] {g : SpectralMap β γ} {f₁ f₂ : SpectralMap α β} (hg : Function.Injective ⇑g)
Goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- ParacompactSpace.locallyFinite_refinement
class ParacompactSpace (X : Type v) [TopologicalSpace X] : Prop where
    locallyFinite_refinement :
    ∀ (α : Type v) (s : α → Set X), (∀ a, IsOpen (s a)) → (⋃ a, s a = univ) →
      ∃ (β : Type v) (t : β → Set X),
        (∀ b, IsOpen (t b)) ∧ (⋃ b, t b = univ) ∧ LocallyFinite t ∧ ∀ b, ∃ a, t b ⊆ s a
Arguments: {X : Type v} [TopologicalSpace X] [self : ParacompactSpace X] (α : Type v) (s : α → Set X)
Goal: (∀ (a : α), IsOpen (s a)) →
  ⋃ a, s a = Set.univ →
    ∃ β t, (∀ (b : β), IsOpen (t b)) ∧ ⋃ b, t b = Set.univ ∧ LocallyFinite t ∧ ∀ (b : β), ∃ a, t b ⊆ s a
-- precise_refinement
theorem precise_refinement [ParacompactSpace X] (u : ι → Set X) (uo : ∀ a, IsOpen (u a))
    (uc : ⋃ i, u i = univ) : ∃ v : ι → Set X, (∀ a, IsOpen (v a)) ∧ ⋃ i, v i = univ ∧
    LocallyFinite v ∧ ∀ a, v a ⊆ u a 
Arguments: {ι : Type u} {X : Type v} [TopologicalSpace X] [ParacompactSpace X] (u : ι → Set X) (uo : ∀ (a : ι), IsOpen (u a)) (uc : ⋃ i, u i = Set.univ)
Goal: ∃ v, (∀ (a : ι), IsOpen (v a)) ∧ ⋃ i, v i = Set.univ ∧ LocallyFinite v ∧ ∀ (a : ι), v a ⊆ u a
-- precise_refinement_set
theorem precise_refinement_set [ParacompactSpace X] {s : Set X} (hs : IsClosed s) (u : ι → Set X)
    (uo : ∀ i, IsOpen (u i)) (us : s ⊆ ⋃ i, u i) :
    ∃ v : ι → Set X, (∀ i, IsOpen (v i)) ∧ (s ⊆ ⋃ i, v i) ∧ LocallyFinite v ∧ ∀ i, v i ⊆ u i 
Arguments: {ι : Type u} {X : Type v} [TopologicalSpace X] [ParacompactSpace X] {s : Set X} (hs : IsClosed s) (u : ι → Set X) (uo : ∀ (i : ι), IsOpen (u i)) (us : s ⊆ ⋃ i, u i)
Goal: ∃ v, (∀ (i : ι), IsOpen (v i)) ∧ s ⊆ ⋃ i, v i ∧ LocallyFinite v ∧ ∀ (i : ι), v i ⊆ u i
-- ClosedEmbedding.paracompactSpace
theorem ClosedEmbedding.paracompactSpace [ParacompactSpace Y] {e : X → Y} (he : ClosedEmbedding e) :
    ParacompactSpace X 
Arguments: {X : Type v} {Y : Type w} [TopologicalSpace X] [TopologicalSpace Y] [ParacompactSpace Y] {e : X → Y} (he : ClosedEmbedding e)
Goal: ParacompactSpace X
-- Homeomorph.paracompactSpace_iff
theorem Homeomorph.paracompactSpace_iff (e : X ≃ₜ Y) : ParacompactSpace X ↔ ParacompactSpace Y 
Arguments: {X : Type v} {Y : Type w} [TopologicalSpace X] [TopologicalSpace Y] (e : X ≃ₜ Y)
Goal: ParacompactSpace X ↔ ParacompactSpace Y
-- refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set
theorem refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set [WeaklyLocallyCompactSpace X]
    [SigmaCompactSpace X] [T2Space X] {ι : X → Type u} {p : ∀ x, ι x → Prop} {B : ∀ x, ι x → Set X}
    {s : Set X} (hs : IsClosed s) (hB : ∀ x ∈ s, (𝓝 x).HasBasis (p x) (B x)) :
    ∃ (α : Type v) (c : α → X) (r : ∀ a, ι (c a)),
      (∀ a, c a ∈ s ∧ p (c a) (r a)) ∧
        (s ⊆ ⋃ a, B (c a) (r a)) ∧ LocallyFinite fun a ↦ B (c a) (r a) 
Arguments: {X : Type v} [TopologicalSpace X] [WeaklyLocallyCompactSpace X] [SigmaCompactSpace X] [T2Space X] {ι : X → Type u} {p : (x : X) → ι x → Prop} {B : (x : X) → ι x → Set X} {s : Set X} (hs : IsClosed s) (hB : ∀ x ∈ s, (𝓝 x).HasBasis (p x) (B x))
Goal: ∃ α c r, (∀ (a : α), c a ∈ s ∧ p (c a) (r a)) ∧ s ⊆ ⋃ a, B (c a) (r a) ∧ LocallyFinite fun a => B (c a) (r a)
-- refinement_of_locallyCompact_sigmaCompact_of_nhds_basis
theorem refinement_of_locallyCompact_sigmaCompact_of_nhds_basis [WeaklyLocallyCompactSpace X]
    [SigmaCompactSpace X] [T2Space X] {ι : X → Type u} {p : ∀ x, ι x → Prop} {B : ∀ x, ι x → Set X}
    (hB : ∀ x, (𝓝 x).HasBasis (p x) (B x)) :
    ∃ (α : Type v) (c : α → X) (r : ∀ a, ι (c a)),
      (∀ a, p (c a) (r a)) ∧ ⋃ a, B (c a) (r a) = univ ∧ LocallyFinite fun a ↦ B (c a) (r a) 
Arguments: {X : Type v} [TopologicalSpace X] [WeaklyLocallyCompactSpace X] [SigmaCompactSpace X] [T2Space X] {ι : X → Type u} {p : (x : X) → ι x → Prop} {B : (x : X) → ι x → Set X} (hB : ∀ (x : X), (𝓝 x).HasBasis (p x) (B x))
Goal: ∃ α c r, (∀ (a : α), p (c a) (r a)) ∧ ⋃ a, B (c a) (r a) = Set.univ ∧ LocallyFinite fun a => B (c a) (r a)
-- nhdsSet_diagonal
theorem nhdsSet_diagonal (X) [TopologicalSpace (X × X)] :
    𝓝ˢ (diagonal X) = ⨆ (x : X), 𝓝 (x, x) 
Arguments: (X : Type u_3) [TopologicalSpace (X × X)]
Goal: 𝓝ˢ (Set.diagonal X) = ⨆ x, 𝓝 (x, x)
-- mem_nhdsSet_iff_forall
theorem mem_nhdsSet_iff_forall : s ∈ 𝓝ˢ t ↔ ∀ x : X, x ∈ t → s ∈ 𝓝 x 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X}
Goal: s ∈ 𝓝ˢ t ↔ ∀ x ∈ t, s ∈ 𝓝 x
-- nhdsSet_le
lemma nhdsSet_le : 𝓝ˢ s ≤ f ↔ ∀ x ∈ s, 𝓝 x ≤ f 
Arguments: {X : Type u_1} [TopologicalSpace X] {f : Filter X} {s : Set X}
Goal: 𝓝ˢ s ≤ f ↔ ∀ x ∈ s, 𝓝 x ≤ f
-- bUnion_mem_nhdsSet
theorem bUnion_mem_nhdsSet {t : X → Set X} (h : ∀ x ∈ s, t x ∈ 𝓝 x) : (⋃ x ∈ s, t x) ∈ 𝓝ˢ s 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X} {t : X → Set X} (h : ∀ x ∈ s, t x ∈ 𝓝 x)
Goal: ⋃ x ∈ s, t x ∈ 𝓝ˢ s
-- subset_interior_iff_mem_nhdsSet
theorem subset_interior_iff_mem_nhdsSet : s ⊆ interior t ↔ t ∈ 𝓝ˢ s 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X}
Goal: s ⊆ interior t ↔ t ∈ 𝓝ˢ s
-- disjoint_principal_nhdsSet
theorem disjoint_principal_nhdsSet : Disjoint (𝓟 s) (𝓝ˢ t) ↔ Disjoint (closure s) t 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X}
Goal: Disjoint (𝓟 s) (𝓝ˢ t) ↔ Disjoint (closure s) t
-- disjoint_nhdsSet_principal
theorem disjoint_nhdsSet_principal : Disjoint (𝓝ˢ s) (𝓟 t) ↔ Disjoint s (closure t) 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X}
Goal: Disjoint (𝓝ˢ s) (𝓟 t) ↔ Disjoint s (closure t)
-- mem_nhdsSet_iff_exists
theorem mem_nhdsSet_iff_exists : s ∈ 𝓝ˢ t ↔ ∃ U : Set X, IsOpen U ∧ t ⊆ U ∧ U ⊆ s 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X}
Goal: s ∈ 𝓝ˢ t ↔ ∃ U, IsOpen U ∧ t ⊆ U ∧ U ⊆ s
-- eventually_nhdsSet_iff_exists
theorem eventually_nhdsSet_iff_exists {p : X → Prop} :
    (∀ᶠ x in 𝓝ˢ s, p x) ↔ ∃ t, IsOpen t ∧ s ⊆ t ∧ ∀ x, x ∈ t → p x 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X} {p : X → Prop}
Goal: (∀ᶠ (x : X) in 𝓝ˢ s, p x) ↔ ∃ t, IsOpen t ∧ s ⊆ t ∧ ∀ x ∈ t, p x
-- eventually_nhdsSet_iff_forall
theorem eventually_nhdsSet_iff_forall {p : X → Prop} :
    (∀ᶠ x in 𝓝ˢ s, p x) ↔ ∀ x, x ∈ s → ∀ᶠ y in 𝓝 x, p y 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X} {p : X → Prop}
Goal: (∀ᶠ (x : X) in 𝓝ˢ s, p x) ↔ ∀ x ∈ s, ∀ᶠ (y : X) in 𝓝 x, p y
-- hasBasis_nhdsSet
theorem hasBasis_nhdsSet (s : Set X) : (𝓝ˢ s).HasBasis (fun U => IsOpen U ∧ s ⊆ U) fun U => U 
Arguments: {X : Type u_1} [TopologicalSpace X] (s : Set X)
Goal: (𝓝ˢ s).HasBasis (fun U => IsOpen U ∧ s ⊆ U) fun U => U
-- lift'_nhdsSet_interior
@[simp]
lemma lift'_nhdsSet_interior (s : Set X) : (𝓝ˢ s).lift' interior = 𝓝ˢ s 
Arguments: {X : Type u_1} [TopologicalSpace X] (s : Set X)
Goal: (𝓝ˢ s).lift' interior = 𝓝ˢ s
-- Filter.HasBasis.nhdsSet_interior
lemma Filter.HasBasis.nhdsSet_interior {ι : Sort*} {p : ι → Prop} {s : ι → Set X} {t : Set X}
    (h : (𝓝ˢ t).HasBasis p s) : (𝓝ˢ t).HasBasis p (interior <| s ·) 
Arguments: {X : Type u_1} [TopologicalSpace X] {ι : Sort u_3} {p : ι → Prop} {s : ι → Set X} {t : Set X} (h : (𝓝ˢ t).HasBasis p s)
Goal: (𝓝ˢ t).HasBasis p fun x => interior (s x)
-- IsOpen.mem_nhdsSet
theorem IsOpen.mem_nhdsSet (hU : IsOpen s) : s ∈ 𝓝ˢ t ↔ t ⊆ s 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X} (hU : IsOpen s)
Goal: s ∈ 𝓝ˢ t ↔ t ⊆ s
-- IsOpen.mem_nhdsSet_self
theorem IsOpen.mem_nhdsSet_self (ho : IsOpen s) : s ∈ 𝓝ˢ s 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X} (ho : IsOpen s)
Goal: s ∈ 𝓝ˢ s
-- principal_le_nhdsSet
theorem principal_le_nhdsSet : 𝓟 s ≤ 𝓝ˢ s 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X}
Goal: 𝓟 s ≤ 𝓝ˢ s
-- subset_of_mem_nhdsSet
theorem subset_of_mem_nhdsSet (h : t ∈ 𝓝ˢ s) : s ⊆ t 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X} (h : t ∈ 𝓝ˢ s)
Goal: s ⊆ t
-- Filter.Eventually.self_of_nhdsSet
theorem Filter.Eventually.self_of_nhdsSet {p : X → Prop} (h : ∀ᶠ x in 𝓝ˢ s, p x) : ∀ x ∈ s, p x 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X} {p : X → Prop} (h : ∀ᶠ (x : X) in 𝓝ˢ s, p x) (x : X)
Goal: x ∈ s → p x
-- Filter.EventuallyEq.self_of_nhdsSet
nonrec theorem Filter.EventuallyEq.self_of_nhdsSet {f g : X → Y} (h : f =ᶠ[𝓝ˢ s] g) : EqOn f g s 
Arguments: {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] {s : Set X} {f g : X → Y} (h : f =ᶠ[𝓝ˢ s] g)
Goal: Set.EqOn f g s
-- nhdsSet_eq_principal_iff
@[simp]
theorem nhdsSet_eq_principal_iff : 𝓝ˢ s = 𝓟 s ↔ IsOpen s 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X}
Goal: 𝓝ˢ s = 𝓟 s ↔ IsOpen s
-- nhdsSet_interior
@[simp]
theorem nhdsSet_interior : 𝓝ˢ (interior s) = 𝓟 (interior s) 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X}
Goal: 𝓝ˢ (interior s) = 𝓟 (interior s)
-- nhdsSet_singleton
@[simp]
theorem nhdsSet_singleton : 𝓝ˢ {x} = 𝓝 x 
Arguments: {X : Type u_1} [TopologicalSpace X] {x : X}
Goal: 𝓝ˢ {x} = 𝓝 x
-- mem_nhdsSet_interior
theorem mem_nhdsSet_interior : s ∈ 𝓝ˢ (interior s) 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X}
Goal: s ∈ 𝓝ˢ (interior s)
-- nhdsSet_empty
@[simp]
theorem nhdsSet_empty : 𝓝ˢ (∅ : Set X) = ⊥ 
Arguments: {X : Type u_1} [TopologicalSpace X]
Goal: 𝓝ˢ ∅ = ⊥
-- mem_nhdsSet_empty
theorem mem_nhdsSet_empty : s ∈ 𝓝ˢ (∅ : Set X) 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X}
Goal: s ∈ 𝓝ˢ ∅
-- nhdsSet_univ
@[simp]
theorem nhdsSet_univ : 𝓝ˢ (univ : Set X) = ⊤ 
Arguments: {X : Type u_1} [TopologicalSpace X]
Goal: 𝓝ˢ Set.univ = ⊤
-- nhdsSet_mono
@[mono]
theorem nhdsSet_mono (h : s ⊆ t) : 𝓝ˢ s ≤ 𝓝ˢ t 
Arguments: {X : Type u_1} [TopologicalSpace X] {s t : Set X} (h : s ⊆ t)
Goal: 𝓝ˢ s ≤ 𝓝ˢ t
-- monotone_nhdsSet
theorem monotone_nhdsSet : Monotone (𝓝ˢ : Set X → Filter X) 
Arguments: {X : Type u_1} [TopologicalSpace X]
Goal: Monotone 𝓝ˢ
-- nhds_le_nhdsSet
theorem nhds_le_nhdsSet (h : x ∈ s) : 𝓝 x ≤ 𝓝ˢ s 
Arguments: {X : Type u_1} [TopologicalSpace X] {s : Set X} {x : X} (h : x ∈ s)
Goal: 𝓝 x ≤ 𝓝ˢ s
-- nhdsSet_union
@[simp]
theorem nhdsSet_union (s t : Set X) : 𝓝ˢ (s ∪ t) = 𝓝ˢ s ⊔ 𝓝ˢ t 
Arguments: {X : Type u_1} [TopologicalSpace X] (s t : Set X)
Goal: 𝓝ˢ (s ∪ t) = 𝓝ˢ s ⊔ 𝓝ˢ t
-- union_mem_nhdsSet
theorem union_mem_nhdsSet (h₁ : s₁ ∈ 𝓝ˢ t₁) (h₂ : s₂ ∈ 𝓝ˢ t₂) : s₁ ∪ s₂ ∈ 𝓝ˢ (t₁ ∪ t₂) 
Arguments: {X : Type u_1} [TopologicalSpace X] {s₁ s₂ t₁ t₂ : Set X} (h₁ : s₁ ∈ 𝓝ˢ t₁) (h₂ : s₂ ∈ 𝓝ˢ t₂)
Goal: s₁ ∪ s₂ ∈ 𝓝ˢ (t₁ ∪ t₂)
-- nhdsSet_insert
@[simp]
theorem nhdsSet_insert (x : X) (s : Set X) : 𝓝ˢ (insert x s) = 𝓝 x ⊔ 𝓝ˢ s 
Arguments: {X : Type u_1} [TopologicalSpace X] (x : X) (s : Set X)
Goal: 𝓝ˢ (insert x s) = 𝓝 x ⊔ 𝓝ˢ s
-- Continuous.tendsto_nhdsSet
theorem Continuous.tendsto_nhdsSet {f : X → Y} {t : Set Y} (hf : Continuous f)
    (hst : MapsTo f s t) : Tendsto f (𝓝ˢ s) (𝓝ˢ t) 
Arguments: {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {s : Set X} {f : X → Y} {t : Set Y} (hf : Continuous f) (hst : Set.MapsTo f s t)
Goal: Filter.Tendsto f (𝓝ˢ s) (𝓝ˢ t)