File: Mathlib/Topology/Filter.lean

full_name: Filter.instTopologicalSpace
code: /-- The topology on `Filter α` is generated by the sets `Set.Iic (𝓟 s) = {l : Filter α | s ∈ l}`,
`s : Set α`. A set `s : Set (Filter α)` is open if and only if it is a union of a family of these
basic open sets, see `Filter.isOpen_iff`. -/
instance : TopologicalSpace (Filter α) 
goal: TopologicalSpace (Filter α)

full_name: Filter.isOpen_Iic_principal
code: theorem isOpen_Iic_principal {s : Set α} : IsOpen (Iic (𝓟 s)) 
goal: IsOpen (Set.Iic (𝓟 s))

full_name: Filter.isOpen_setOf_mem
code: theorem isOpen_setOf_mem {s : Set α} : IsOpen { l : Filter α | s ∈ l } 
goal: IsOpen {l | s ∈ l}

full_name: Filter.isTopologicalBasis_Iic_principal
code: theorem isTopologicalBasis_Iic_principal :
    IsTopologicalBasis (range (Iic ∘ 𝓟 : Set α → Set (Filter α))) 
goal: TopologicalSpace.IsTopologicalBasis (Set.range (Set.Iic ∘ 𝓟))

full_name: Filter.isOpen_iff
code: theorem isOpen_iff {s : Set (Filter α)} : IsOpen s ↔ ∃ T : Set (Set α), s = ⋃ t ∈ T, Iic (𝓟 t) 
goal: IsOpen s ↔ ∃ T, s = ⋃ t ∈ T, Set.Iic (𝓟 t)

full_name: Filter.nhds_eq
code: theorem nhds_eq (l : Filter α) : 𝓝 l = l.lift' (Iic ∘ 𝓟) 
goal: 𝓝 l = l.lift' (Set.Iic ∘ 𝓟)

full_name: Filter.nhds_eq'
code: theorem nhds_eq' (l : Filter α) : 𝓝 l = l.lift' fun s => { l' | s ∈ l' } 
goal: 𝓝 l = l.lift' fun s => {l' | s ∈ l'}

full_name: Filter.tendsto_nhds
code: protected theorem tendsto_nhds {la : Filter α} {lb : Filter β} {f : α → Filter β} :
    Tendsto f la (𝓝 lb) ↔ ∀ s ∈ lb, ∀ᶠ a in la, s ∈ f a 
goal: Filter.Tendsto f la (𝓝 lb) ↔ ∀ s ∈ lb, ∀ᶠ (a : α) in la, s ∈ f a

full_name: Filter.HasBasis.nhds
code: protected theorem HasBasis.nhds {l : Filter α} {p : ι → Prop} {s : ι → Set α} (h : HasBasis l p s) :
    HasBasis (𝓝 l) p fun i => Iic (𝓟 (s i)) 
goal: (𝓝 l).HasBasis p fun i => Set.Iic (𝓟 (s i))

full_name: Filter.tendsto_pure_self
code: protected theorem tendsto_pure_self (l : Filter X) :
    Tendsto (pure : X → Filter X) l (𝓝 l) 
goal: Filter.Tendsto pure l (𝓝 l)

full_name: Filter.instIsCountablyGeneratedNhds
code: /-- Neighborhoods of a countably generated filter is a countably generated filter. -/
instance {l : Filter α} [IsCountablyGenerated l] : IsCountablyGenerated (𝓝 l) 
goal: (𝓝 l).IsCountablyGenerated

full_name: Filter.HasBasis.nhds'
code: theorem HasBasis.nhds' {l : Filter α} {p : ι → Prop} {s : ι → Set α} (h : HasBasis l p s) :
    HasBasis (𝓝 l) p fun i => { l' | s i ∈ l' } 
goal: (𝓝 l).HasBasis p fun i => {l' | s i ∈ l'}

full_name: Filter.mem_nhds_iff
code: protected theorem mem_nhds_iff {l : Filter α} {S : Set (Filter α)} :
    S ∈ 𝓝 l ↔ ∃ t ∈ l, Iic (𝓟 t) ⊆ S 
goal: S ∈ 𝓝 l ↔ ∃ t ∈ l, Set.Iic (𝓟 t) ⊆ S

full_name: Filter.mem_nhds_iff'
code: theorem mem_nhds_iff' {l : Filter α} {S : Set (Filter α)} :
    S ∈ 𝓝 l ↔ ∃ t ∈ l, ∀ ⦃l' : Filter α⦄, t ∈ l' → l' ∈ S 
goal: S ∈ 𝓝 l ↔ ∃ t ∈ l, ∀ ⦃l' : Filter α⦄, t ∈ l' → l' ∈ S

full_name: Filter.nhds_bot
code: @[simp]
theorem nhds_bot : 𝓝 (⊥ : Filter α) = pure ⊥ 
goal: 𝓝 ⊥ = pure ⊥

full_name: Filter.nhds_top
code: @[simp]
theorem nhds_top : 𝓝 (⊤ : Filter α) = ⊤ 
goal: 𝓝 ⊤ = ⊤

full_name: Filter.nhds_principal
code: @[simp]
theorem nhds_principal (s : Set α) : 𝓝 (𝓟 s) = 𝓟 (Iic (𝓟 s)) 
goal: 𝓝 (𝓟 s) = 𝓟 (Set.Iic (𝓟 s))

full_name: Filter.nhds_pure
code: @[simp]
theorem nhds_pure (x : α) : 𝓝 (pure x : Filter α) = 𝓟 {⊥, pure x} 
goal: 𝓝 (pure x) = 𝓟 {⊥, pure x}

full_name: Filter.nhds_iInf
code: @[simp]
theorem nhds_iInf (f : ι → Filter α) : 𝓝 (⨅ i, f i) = ⨅ i, 𝓝 (f i) 
goal: 𝓝 (⨅ i, f i) = ⨅ i, 𝓝 (f i)

full_name: Filter.nhds_inf
code: @[simp]
theorem nhds_inf (l₁ l₂ : Filter α) : 𝓝 (l₁ ⊓ l₂) = 𝓝 l₁ ⊓ 𝓝 l₂ 
goal: 𝓝 (l₁ ⊓ l₂) = 𝓝 l₁ ⊓ 𝓝 l₂

full_name: Filter.monotone_nhds
code: theorem monotone_nhds : Monotone (𝓝 : Filter α → Filter (Filter α)) 
goal: Monotone 𝓝

full_name: Filter.sInter_nhds
code: theorem sInter_nhds (l : Filter α) : ⋂₀ { s | s ∈ 𝓝 l } = Iic l 
goal: ⋂₀ {s | s ∈ 𝓝 l} = Set.Iic l

full_name: Filter.nhds_mono
code: @[simp]
theorem nhds_mono {l₁ l₂ : Filter α} : 𝓝 l₁ ≤ 𝓝 l₂ ↔ l₁ ≤ l₂ 
goal: 𝓝 l₁ ≤ 𝓝 l₂ ↔ l₁ ≤ l₂

full_name: Filter.mem_interior
code: protected theorem mem_interior {s : Set (Filter α)} {l : Filter α} :
    l ∈ interior s ↔ ∃ t ∈ l, Iic (𝓟 t) ⊆ s 
goal: l ∈ interior s ↔ ∃ t ∈ l, Set.Iic (𝓟 t) ⊆ s

full_name: Filter.mem_closure
code: protected theorem mem_closure {s : Set (Filter α)} {l : Filter α} :
    l ∈ closure s ↔ ∀ t ∈ l, ∃ l' ∈ s, t ∈ l' 
goal: l ∈ closure s ↔ ∀ t ∈ l, ∃ l' ∈ s, t ∈ l'

full_name: Filter.closure_singleton
code: @[simp]
protected theorem closure_singleton (l : Filter α) : closure {l} = Ici l 
goal: closure {l} = Set.Ici l

full_name: Filter.specializes_iff_le
code: @[simp]
theorem specializes_iff_le {l₁ l₂ : Filter α} : l₁ ⤳ l₂ ↔ l₁ ≤ l₂ 
goal: l₁ ⤳ l₂ ↔ l₁ ≤ l₂

full_name: Filter.instT0Space
code: instance : T0Space (Filter α) 
goal: T0Space (Filter α)

full_name: Filter.nhds_atTop
code: theorem nhds_atTop [Preorder α] : 𝓝 atTop = ⨅ x : α, 𝓟 (Iic (𝓟 (Ici x))) 
goal: 𝓝 Filter.atTop = ⨅ x, 𝓟 (Set.Iic (𝓟 (Set.Ici x)))

full_name: Filter.tendsto_nhds_atTop_iff
code: protected theorem tendsto_nhds_atTop_iff [Preorder β] {l : Filter α} {f : α → Filter β} :
    Tendsto f l (𝓝 atTop) ↔ ∀ y, ∀ᶠ a in l, Ici y ∈ f a 
goal: Filter.Tendsto f l (𝓝 Filter.atTop) ↔ ∀ (y : β), ∀ᶠ (a : α) in l, Set.Ici y ∈ f a

full_name: Filter.nhds_atBot
code: theorem nhds_atBot [Preorder α] : 𝓝 atBot = ⨅ x : α, 𝓟 (Iic (𝓟 (Iic x))) 
goal: 𝓝 Filter.atBot = ⨅ x, 𝓟 (Set.Iic (𝓟 (Set.Iic x)))

full_name: Filter.tendsto_nhds_atBot_iff
code: protected theorem tendsto_nhds_atBot_iff [Preorder β] {l : Filter α} {f : α → Filter β} :
    Tendsto f l (𝓝 atBot) ↔ ∀ y, ∀ᶠ a in l, Iic y ∈ f a 
goal: Filter.Tendsto f l (𝓝 Filter.atBot) ↔ ∀ (y : β), ∀ᶠ (a : α) in l, Set.Iic y ∈ f a

full_name: Filter.nhds_nhds
code: theorem nhds_nhds (x : X) :
    𝓝 (𝓝 x) = ⨅ (s : Set X) (_ : IsOpen s) (_ : x ∈ s), 𝓟 (Iic (𝓟 s)) 
goal: 𝓝 (𝓝 x) = ⨅ s, ⨅ (_ : IsOpen s), ⨅ (_ : x ∈ s), 𝓟 (Set.Iic (𝓟 s))

full_name: Filter.inducing_nhds
code: theorem inducing_nhds : Inducing (𝓝 : X → Filter X) 
goal: Inducing 𝓝

full_name: Filter.continuous_nhds
code: @[continuity]
theorem continuous_nhds : Continuous (𝓝 : X → Filter X) 
goal: Continuous 𝓝

full_name: Filter.Tendsto.nhds
code: protected theorem Tendsto.nhds {f : α → X} {l : Filter α} {x : X} (h : Tendsto f l (𝓝 x)) :
    Tendsto (𝓝 ∘ f) l (𝓝 (𝓝 x)) 
goal: Filter.Tendsto (𝓝 ∘ f) l (𝓝 (𝓝 x))

full_name: ContinuousWithinAt.nhds
code: protected nonrec theorem ContinuousWithinAt.nhds (h : ContinuousWithinAt f s x) :
    ContinuousWithinAt (𝓝 ∘ f) s x 
goal: ContinuousWithinAt (𝓝 ∘ f) s x

full_name: ContinuousAt.nhds
code: protected nonrec theorem ContinuousAt.nhds (h : ContinuousAt f x) : ContinuousAt (𝓝 ∘ f) x 
goal: ContinuousAt (𝓝 ∘ f) x

full_name: ContinuousOn.nhds
code: protected nonrec theorem ContinuousOn.nhds (h : ContinuousOn f s) : ContinuousOn (𝓝 ∘ f) s 
goal: ContinuousOn (𝓝 ∘ f) s

full_name: Continuous.nhds
code: protected nonrec theorem Continuous.nhds (h : Continuous f) : Continuous (𝓝 ∘ f) 
goal: Continuous (𝓝 ∘ f)