File: Mathlib/Topology/NhdsSet.lean

full_name: nhdsSet_diagonal
code: theorem nhdsSet_diagonal (X) [TopologicalSpace (X × X)] :
    𝓝ˢ (diagonal X) = ⨆ (x : X), 𝓝 (x, x) 
goal: 𝓝ˢ (Set.diagonal X) = ⨆ x, 𝓝 (x, x)

full_name: mem_nhdsSet_iff_forall
code: theorem mem_nhdsSet_iff_forall : s ∈ 𝓝ˢ t ↔ ∀ x : X, x ∈ t → s ∈ 𝓝 x 
goal: s ∈ 𝓝ˢ t ↔ ∀ x ∈ t, s ∈ 𝓝 x

full_name: nhdsSet_le
code: lemma nhdsSet_le : 𝓝ˢ s ≤ f ↔ ∀ x ∈ s, 𝓝 x ≤ f 
goal: 𝓝ˢ s ≤ f ↔ ∀ x ∈ s, 𝓝 x ≤ f

full_name: bUnion_mem_nhdsSet
code: theorem bUnion_mem_nhdsSet {t : X → Set X} (h : ∀ x ∈ s, t x ∈ 𝓝 x) : (⋃ x ∈ s, t x) ∈ 𝓝ˢ s 
goal: ⋃ x ∈ s, t x ∈ 𝓝ˢ s

full_name: subset_interior_iff_mem_nhdsSet
code: theorem subset_interior_iff_mem_nhdsSet : s ⊆ interior t ↔ t ∈ 𝓝ˢ s 
goal: s ⊆ interior t ↔ t ∈ 𝓝ˢ s

full_name: disjoint_principal_nhdsSet
code: theorem disjoint_principal_nhdsSet : Disjoint (𝓟 s) (𝓝ˢ t) ↔ Disjoint (closure s) t 
goal: Disjoint (𝓟 s) (𝓝ˢ t) ↔ Disjoint (closure s) t

full_name: disjoint_nhdsSet_principal
code: theorem disjoint_nhdsSet_principal : Disjoint (𝓝ˢ s) (𝓟 t) ↔ Disjoint s (closure t) 
goal: Disjoint (𝓝ˢ s) (𝓟 t) ↔ Disjoint s (closure t)

full_name: mem_nhdsSet_iff_exists
code: theorem mem_nhdsSet_iff_exists : s ∈ 𝓝ˢ t ↔ ∃ U : Set X, IsOpen U ∧ t ⊆ U ∧ U ⊆ s 
goal: s ∈ 𝓝ˢ t ↔ ∃ U, IsOpen U ∧ t ⊆ U ∧ U ⊆ s

full_name: eventually_nhdsSet_iff_exists
code: /-- A proposition is true on a set neighborhood of `s` iff it is true on a larger open set -/
theorem eventually_nhdsSet_iff_exists {p : X → Prop} :
    (∀ᶠ x in 𝓝ˢ s, p x) ↔ ∃ t, IsOpen t ∧ s ⊆ t ∧ ∀ x, x ∈ t → p x 
goal: (∀ᶠ (x : X) in 𝓝ˢ s, p x) ↔ ∃ t, IsOpen t ∧ s ⊆ t ∧ ∀ x ∈ t, p x

full_name: eventually_nhdsSet_iff_forall
code: /-- A proposition is true on a set neighborhood of `s`
iff it is eventually true near each point in the set. -/
theorem eventually_nhdsSet_iff_forall {p : X → Prop} :
    (∀ᶠ x in 𝓝ˢ s, p x) ↔ ∀ x, x ∈ s → ∀ᶠ y in 𝓝 x, p y 
goal: (∀ᶠ (x : X) in 𝓝ˢ s, p x) ↔ ∀ x ∈ s, ∀ᶠ (y : X) in 𝓝 x, p y

full_name: hasBasis_nhdsSet
code: theorem hasBasis_nhdsSet (s : Set X) : (𝓝ˢ s).HasBasis (fun U => IsOpen U ∧ s ⊆ U) fun U => U 
goal: (𝓝ˢ s).HasBasis (fun U => IsOpen U ∧ s ⊆ U) fun U => U

full_name: lift'_nhdsSet_interior
code: @[simp]
lemma lift'_nhdsSet_interior (s : Set X) : (𝓝ˢ s).lift' interior = 𝓝ˢ s 
goal: (𝓝ˢ s).lift' interior = 𝓝ˢ s

full_name: Filter.HasBasis.nhdsSet_interior
code: lemma Filter.HasBasis.nhdsSet_interior {ι : Sort*} {p : ι → Prop} {s : ι → Set X} {t : Set X}
    (h : (𝓝ˢ t).HasBasis p s) : (𝓝ˢ t).HasBasis p (interior <| s ·) 
goal: (𝓝ˢ t).HasBasis p fun x => interior (s x)

full_name: IsOpen.mem_nhdsSet
code: theorem IsOpen.mem_nhdsSet (hU : IsOpen s) : s ∈ 𝓝ˢ t ↔ t ⊆ s 
goal: s ∈ 𝓝ˢ t ↔ t ⊆ s

full_name: IsOpen.mem_nhdsSet_self
code: /-- An open set belongs to its own set neighborhoods filter. -/
theorem IsOpen.mem_nhdsSet_self (ho : IsOpen s) : s ∈ 𝓝ˢ s 
goal: s ∈ 𝓝ˢ s

full_name: principal_le_nhdsSet
code: theorem principal_le_nhdsSet : 𝓟 s ≤ 𝓝ˢ s 
goal: 𝓟 s ≤ 𝓝ˢ s

full_name: subset_of_mem_nhdsSet
code: theorem subset_of_mem_nhdsSet (h : t ∈ 𝓝ˢ s) : s ⊆ t 
goal: s ⊆ t

full_name: Filter.Eventually.self_of_nhdsSet
code: theorem Filter.Eventually.self_of_nhdsSet {p : X → Prop} (h : ∀ᶠ x in 𝓝ˢ s, p x) : ∀ x ∈ s, p x 
goal: x ∈ s → p x

full_name: Filter.EventuallyEq.self_of_nhdsSet
code: nonrec theorem Filter.EventuallyEq.self_of_nhdsSet {f g : X → Y} (h : f =ᶠ[𝓝ˢ s] g) : EqOn f g s 
goal: Set.EqOn f g s

full_name: nhdsSet_eq_principal_iff
code: @[simp]
theorem nhdsSet_eq_principal_iff : 𝓝ˢ s = 𝓟 s ↔ IsOpen s 
goal: 𝓝ˢ s = 𝓟 s ↔ IsOpen s

full_name: nhdsSet_interior
code: @[simp]
theorem nhdsSet_interior : 𝓝ˢ (interior s) = 𝓟 (interior s) 
goal: 𝓝ˢ (interior s) = 𝓟 (interior s)

full_name: nhdsSet_singleton
code: @[simp]
theorem nhdsSet_singleton : 𝓝ˢ {x} = 𝓝 x 
goal: 𝓝ˢ {x} = 𝓝 x

full_name: mem_nhdsSet_interior
code: theorem mem_nhdsSet_interior : s ∈ 𝓝ˢ (interior s) 
goal: s ∈ 𝓝ˢ (interior s)

full_name: nhdsSet_empty
code: @[simp]
theorem nhdsSet_empty : 𝓝ˢ (∅ : Set X) = ⊥ 
goal: 𝓝ˢ ∅ = ⊥

full_name: mem_nhdsSet_empty
code: theorem mem_nhdsSet_empty : s ∈ 𝓝ˢ (∅ : Set X) 
goal: s ∈ 𝓝ˢ ∅

full_name: nhdsSet_univ
code: @[simp]
theorem nhdsSet_univ : 𝓝ˢ (univ : Set X) = ⊤ 
goal: 𝓝ˢ Set.univ = ⊤

full_name: nhdsSet_mono
code: @[mono]
theorem nhdsSet_mono (h : s ⊆ t) : 𝓝ˢ s ≤ 𝓝ˢ t 
goal: 𝓝ˢ s ≤ 𝓝ˢ t

full_name: monotone_nhdsSet
code: theorem monotone_nhdsSet : Monotone (𝓝ˢ : Set X → Filter X) 
goal: Monotone 𝓝ˢ

full_name: nhds_le_nhdsSet
code: theorem nhds_le_nhdsSet (h : x ∈ s) : 𝓝 x ≤ 𝓝ˢ s 
goal: 𝓝 x ≤ 𝓝ˢ s

full_name: nhdsSet_union
code: @[simp]
theorem nhdsSet_union (s t : Set X) : 𝓝ˢ (s ∪ t) = 𝓝ˢ s ⊔ 𝓝ˢ t 
goal: 𝓝ˢ (s ∪ t) = 𝓝ˢ s ⊔ 𝓝ˢ t

full_name: union_mem_nhdsSet
code: theorem union_mem_nhdsSet (h₁ : s₁ ∈ 𝓝ˢ t₁) (h₂ : s₂ ∈ 𝓝ˢ t₂) : s₁ ∪ s₂ ∈ 𝓝ˢ (t₁ ∪ t₂) 
goal: s₁ ∪ s₂ ∈ 𝓝ˢ (t₁ ∪ t₂)

full_name: nhdsSet_insert
code: @[simp]
theorem nhdsSet_insert (x : X) (s : Set X) : 𝓝ˢ (insert x s) = 𝓝 x ⊔ 𝓝ˢ s 
goal: 𝓝ˢ (insert x s) = 𝓝 x ⊔ 𝓝ˢ s

full_name: Continuous.tendsto_nhdsSet
code: /-- Preimage of a set neighborhood of `t` under a continuous map `f` is a set neighborhood of `s`
provided that `f` maps `s` to `t`.  -/
theorem Continuous.tendsto_nhdsSet {f : X → Y} {t : Set Y} (hf : Continuous f)
    (hst : MapsTo f s t) : Tendsto f (𝓝ˢ s) (𝓝ˢ t) 
goal: Filter.Tendsto f (𝓝ˢ s) (𝓝ˢ t)

full_name: Continuous.tendsto_nhdsSet_nhds
code: lemma Continuous.tendsto_nhdsSet_nhds
    {y : Y} {f : X → Y} (h : Continuous f) (h' : EqOn f (fun _ ↦ y) s) :
    Tendsto f (𝓝ˢ s) (𝓝 y) 
goal: Filter.Tendsto f (𝓝ˢ s) (𝓝 y)

full_name: nhdsSet_inter_le
code: theorem nhdsSet_inter_le (s t : Set X) : 𝓝ˢ (s ∩ t) ≤ 𝓝ˢ s ⊓ 𝓝ˢ t 
goal: 𝓝ˢ (s ∩ t) ≤ 𝓝ˢ s ⊓ 𝓝ˢ t

full_name: IsClosed.nhdsSet_le_sup
code: theorem IsClosed.nhdsSet_le_sup (h : IsClosed t) : 𝓝ˢ s ≤ 𝓝ˢ (s ∩ t) ⊔ 𝓟 (tᶜ) 
goal: 𝓝ˢ s ≤ 𝓝ˢ (s ∩ t) ⊔ 𝓟 tᶜ

full_name: IsClosed.nhdsSet_le_sup'
code: theorem IsClosed.nhdsSet_le_sup' (h : IsClosed t) :
    𝓝ˢ s ≤ 𝓝ˢ (t ∩ s) ⊔ 𝓟 (tᶜ) 
goal: 𝓝ˢ s ≤ 𝓝ˢ (t ∩ s) ⊔ 𝓟 tᶜ

full_name: Filter.Eventually.eventually_nhdsSet
code: theorem Filter.Eventually.eventually_nhdsSet {p : X → Prop} (h : ∀ᶠ y in 𝓝ˢ s, p y) :
    ∀ᶠ y in 𝓝ˢ s, ∀ᶠ x in 𝓝 y, p x 
goal: ∀ᶠ (y : X) in 𝓝ˢ s, ∀ᶠ (x : X) in 𝓝 y, p x

full_name: Filter.Eventually.union_nhdsSet
code: theorem Filter.Eventually.union_nhdsSet {p : X → Prop} :
    (∀ᶠ x in 𝓝ˢ (s ∪ t), p x) ↔ (∀ᶠ x in 𝓝ˢ s, p x) ∧ ∀ᶠ x in 𝓝ˢ t, p x 
goal: (∀ᶠ (x : X) in 𝓝ˢ (s ∪ t), p x) ↔ (∀ᶠ (x : X) in 𝓝ˢ s, p x) ∧ ∀ᶠ (x : X) in 𝓝ˢ t, p x

full_name: Filter.Eventually.union
code: theorem Filter.Eventually.union {p : X → Prop} (hs : ∀ᶠ x in 𝓝ˢ s, p x) (ht : ∀ᶠ x in 𝓝ˢ t, p x) :
    ∀ᶠ x in 𝓝ˢ (s ∪ t), p x 
goal: ∀ᶠ (x : X) in 𝓝ˢ (s ∪ t), p x

full_name: nhdsSet_iUnion
code: theorem nhdsSet_iUnion {ι : Sort*} (s : ι → Set X) : 𝓝ˢ (⋃ i, s i) = ⨆ i, 𝓝ˢ (s i) 
goal: 𝓝ˢ (⋃ i, s i) = ⨆ i, 𝓝ˢ (s i)

full_name: eventually_nhdsSet_iUnion₂
code: theorem eventually_nhdsSet_iUnion₂ {ι : Sort*} {p : ι → Prop} {s : ι → Set X} {P : X → Prop} :
    (∀ᶠ x in 𝓝ˢ (⋃ (i) (_ : p i), s i), P x) ↔ ∀ i, p i → ∀ᶠ x in 𝓝ˢ (s i), P x 
goal: (∀ᶠ (x : X) in 𝓝ˢ (⋃ i, ⋃ (_ : p i), s i), P x) ↔ ∀ (i : ι), p i → ∀ᶠ (x : X) in 𝓝ˢ (s i), P x

full_name: eventually_nhdsSet_iUnion
code: theorem eventually_nhdsSet_iUnion {ι : Sort*} {s : ι → Set X} {P : X → Prop} :
    (∀ᶠ x in 𝓝ˢ (⋃ i, s i), P x) ↔ ∀ i, ∀ᶠ x in 𝓝ˢ (s i), P x 
goal: (∀ᶠ (x : X) in 𝓝ˢ (⋃ i, s i), P x) ↔ ∀ (i : ι), ∀ᶠ (x : X) in 𝓝ˢ (s i), P x