File: Mathlib/Topology/Basic.lean

full_name: TopologicalSpace.ofClosed
code: /-- A constructor for topologies by specifying the closed sets,
and showing that they satisfy the appropriate conditions. -/
def TopologicalSpace.ofClosed {X : Type u} (T : Set (Set X)) (empty_mem : ∅ ∈ T)
    (sInter_mem : ∀ A, A ⊆ T → ⋂₀ A ∈ T)
    (union_mem : ∀ A, A ∈ T → ∀ B, B ∈ T → A ∪ B ∈ T) : TopologicalSpace X 
goal: TopologicalSpace X

full_name: isOpen_mk
code: lemma isOpen_mk {p h₁ h₂ h₃} : IsOpen[⟨p, h₁, h₂, h₃⟩] s ↔ p s 
goal: IsOpen s ↔ p s

full_name: TopologicalSpace.ext
code: @[ext]
protected theorem TopologicalSpace.ext :
    ∀ {f g : TopologicalSpace X}, IsOpen[f] = IsOpen[g] → f = g
  
goal: IsOpen = IsOpen → f = g

full_name: TopologicalSpace.ext_iff
code: protected theorem TopologicalSpace.ext_iff {t t' : TopologicalSpace X} :
    t = t' ↔ ∀ s, IsOpen[t] s ↔ IsOpen[t'] s 
goal: t = t' ↔ ∀ (s : Set X), IsOpen s ↔ IsOpen s

full_name: isOpen_fold
code: theorem isOpen_fold {t : TopologicalSpace X} : t.IsOpen s = IsOpen[t] s 
goal: TopologicalSpace.IsOpen s = IsOpen s

full_name: isOpen_iUnion
code: theorem isOpen_iUnion {f : ι → Set X} (h : ∀ i, IsOpen (f i)) : IsOpen (⋃ i, f i) 
goal: IsOpen (⋃ i, f i)

full_name: isOpen_biUnion
code: theorem isOpen_biUnion {s : Set α} {f : α → Set X} (h : ∀ i ∈ s, IsOpen (f i)) :
    IsOpen (⋃ i ∈ s, f i) 
goal: IsOpen (⋃ i ∈ s, f i)

full_name: IsOpen.union
code: theorem IsOpen.union (h₁ : IsOpen s₁) (h₂ : IsOpen s₂) : IsOpen (s₁ ∪ s₂) 
goal: IsOpen (s₁ ∪ s₂)

full_name: isOpen_iff_of_cover
code: lemma isOpen_iff_of_cover {f : α → Set X} (ho : ∀ i, IsOpen (f i)) (hU : (⋃ i, f i) = univ) :
    IsOpen s ↔ ∀ i, IsOpen (f i ∩ s) 
goal: IsOpen s ↔ ∀ (i : α), IsOpen (f i ∩ s)

full_name: isOpen_empty
code: @[simp] theorem isOpen_empty : IsOpen (∅ : Set X) 
goal: IsOpen ∅

full_name: Set.Finite.isOpen_sInter
code: theorem Set.Finite.isOpen_sInter {s : Set (Set X)} (hs : s.Finite) :
    (∀ t ∈ s, IsOpen t) → IsOpen (⋂₀ s) 
goal: (∀ t ∈ s, IsOpen t) → IsOpen (⋂₀ s)

full_name: Set.Finite.isOpen_biInter
code: theorem Set.Finite.isOpen_biInter {s : Set α} {f : α → Set X} (hs : s.Finite)
    (h : ∀ i ∈ s, IsOpen (f i)) :
    IsOpen (⋂ i ∈ s, f i) 
goal: IsOpen (⋂ i ∈ s, f i)

full_name: isOpen_iInter_of_finite
code: theorem isOpen_iInter_of_finite [Finite ι] {s : ι → Set X} (h : ∀ i, IsOpen (s i)) :
    IsOpen (⋂ i, s i) 
goal: IsOpen (⋂ i, s i)

full_name: isOpen_biInter_finset
code: theorem isOpen_biInter_finset {s : Finset α} {f : α → Set X} (h : ∀ i ∈ s, IsOpen (f i)) :
    IsOpen (⋂ i ∈ s, f i) 
goal: IsOpen (⋂ i ∈ s, f i)

full_name: isOpen_const
code: @[simp] -- Porting note: added `simp`
theorem isOpen_const {p : Prop} : IsOpen { _x : X | p } 
goal: IsOpen {_x | p}

full_name: IsOpen.and
code: theorem IsOpen.and : IsOpen { x | p₁ x } → IsOpen { x | p₂ x } → IsOpen { x | p₁ x ∧ p₂ x } 
goal: IsOpen {x | p₁ x} → IsOpen {x | p₂ x} → IsOpen {x | p₁ x ∧ p₂ x}

full_name: isOpen_compl_iff
code: @[simp] theorem isOpen_compl_iff : IsOpen sᶜ ↔ IsClosed s 
goal: IsOpen sᶜ ↔ IsClosed s

full_name: TopologicalSpace.ext_iff_isClosed
code: theorem TopologicalSpace.ext_iff_isClosed {t₁ t₂ : TopologicalSpace X} :
    t₁ = t₂ ↔ ∀ s, IsClosed[t₁] s ↔ IsClosed[t₂] s 
goal: t₁ = t₂ ↔ ∀ (s : Set X), IsClosed s ↔ IsClosed s

full_name: isClosed_const
code: theorem isClosed_const {p : Prop} : IsClosed { _x : X | p } 
goal: IsClosed {_x | p}

full_name: isClosed_empty
code: @[simp] theorem isClosed_empty : IsClosed (∅ : Set X) 
goal: IsClosed ∅

full_name: isClosed_univ
code: @[simp] theorem isClosed_univ : IsClosed (univ : Set X) 
goal: IsClosed Set.univ

full_name: IsClosed.union
code: theorem IsClosed.union : IsClosed s₁ → IsClosed s₂ → IsClosed (s₁ ∪ s₂) 
goal: IsClosed s₁ → IsClosed s₂ → IsClosed (s₁ ∪ s₂)

full_name: isClosed_sInter
code: theorem isClosed_sInter {s : Set (Set X)} : (∀ t ∈ s, IsClosed t) → IsClosed (⋂₀ s) 
goal: (∀ t ∈ s, IsClosed t) → IsClosed (⋂₀ s)

full_name: isClosed_iInter
code: theorem isClosed_iInter {f : ι → Set X} (h : ∀ i, IsClosed (f i)) : IsClosed (⋂ i, f i) 
goal: IsClosed (⋂ i, f i)

full_name: isClosed_biInter
code: theorem isClosed_biInter {s : Set α} {f : α → Set X} (h : ∀ i ∈ s, IsClosed (f i)) :
    IsClosed (⋂ i ∈ s, f i) 
goal: IsClosed (⋂ i ∈ s, f i)

full_name: isClosed_compl_iff
code: @[simp]
theorem isClosed_compl_iff {s : Set X} : IsClosed sᶜ ↔ IsOpen s 
goal: IsClosed sᶜ ↔ IsOpen s

full_name: IsOpen.sdiff
code: theorem IsOpen.sdiff (h₁ : IsOpen s) (h₂ : IsClosed t) : IsOpen (s \ t) 
goal: IsOpen (s \ t)

full_name: IsClosed.inter
code: theorem IsClosed.inter (h₁ : IsClosed s₁) (h₂ : IsClosed s₂) : IsClosed (s₁ ∩ s₂) 
goal: IsClosed (s₁ ∩ s₂)

full_name: IsClosed.sdiff
code: theorem IsClosed.sdiff (h₁ : IsClosed s) (h₂ : IsOpen t) : IsClosed (s \ t) 
goal: IsClosed (s \ t)

full_name: Set.Finite.isClosed_biUnion
code: theorem Set.Finite.isClosed_biUnion {s : Set α} {f : α → Set X} (hs : s.Finite)
    (h : ∀ i ∈ s, IsClosed (f i)) :
    IsClosed (⋃ i ∈ s, f i) 
goal: IsClosed (⋃ i ∈ s, f i)

full_name: isClosed_biUnion_finset
code: lemma isClosed_biUnion_finset {s : Finset α} {f : α → Set X} (h : ∀ i ∈ s, IsClosed (f i)) :
    IsClosed (⋃ i ∈ s, f i) 
goal: IsClosed (⋃ i ∈ s, f i)

full_name: isClosed_iUnion_of_finite
code: theorem isClosed_iUnion_of_finite [Finite ι] {s : ι → Set X} (h : ∀ i, IsClosed (s i)) :
    IsClosed (⋃ i, s i) 
goal: IsClosed (⋃ i, s i)

full_name: isClosed_imp
code: theorem isClosed_imp {p q : X → Prop} (hp : IsOpen { x | p x }) (hq : IsClosed { x | q x }) :
    IsClosed { x | p x → q x } 
goal: IsClosed {x | p x → q x}

full_name: IsClosed.not
code: theorem IsClosed.not : IsClosed { a | p a } → IsOpen { a | ¬p a } 
goal: IsClosed {a | p a} → IsOpen {a | ¬p a}

full_name: mem_interior
code: theorem mem_interior : x ∈ interior s ↔ ∃ t ⊆ s, IsOpen t ∧ x ∈ t 
goal: x ∈ interior s ↔ ∃ t ⊆ s, IsOpen t ∧ x ∈ t

full_name: isOpen_interior
code: @[simp]
theorem isOpen_interior : IsOpen (interior s) 
goal: IsOpen (interior s)

full_name: interior_subset
code: theorem interior_subset : interior s ⊆ s 
goal: interior s ⊆ s

full_name: interior_maximal
code: theorem interior_maximal (h₁ : t ⊆ s) (h₂ : IsOpen t) : t ⊆ interior s 
goal: t ⊆ interior s

full_name: IsOpen.interior_eq
code: theorem IsOpen.interior_eq (h : IsOpen s) : interior s = s 
goal: interior s = s

full_name: interior_eq_iff_isOpen
code: theorem interior_eq_iff_isOpen : interior s = s ↔ IsOpen s 
goal: interior s = s ↔ IsOpen s

full_name: subset_interior_iff_isOpen
code: theorem subset_interior_iff_isOpen : s ⊆ interior s ↔ IsOpen s 
goal: s ⊆ interior s ↔ IsOpen s

full_name: IsOpen.subset_interior_iff
code: theorem IsOpen.subset_interior_iff (h₁ : IsOpen s) : s ⊆ interior t ↔ s ⊆ t 
goal: s ⊆ interior t ↔ s ⊆ t

full_name: subset_interior_iff
code: theorem subset_interior_iff : t ⊆ interior s ↔ ∃ U, IsOpen U ∧ t ⊆ U ∧ U ⊆ s 
goal: t ⊆ interior s ↔ ∃ U, IsOpen U ∧ t ⊆ U ∧ U ⊆ s

full_name: interior_subset_iff
code: lemma interior_subset_iff : interior s ⊆ t ↔ ∀ U, IsOpen U → U ⊆ s → U ⊆ t 
goal: interior s ⊆ t ↔ ∀ (U : Set X), IsOpen U → U ⊆ s → U ⊆ t

full_name: interior_mono
code: @[mono, gcongr]
theorem interior_mono (h : s ⊆ t) : interior s ⊆ interior t 
goal: interior s ⊆ interior t

full_name: interior_empty
code: @[simp]
theorem interior_empty : interior (∅ : Set X) = ∅ 
goal: interior ∅ = ∅

full_name: interior_univ
code: @[simp]
theorem interior_univ : interior (univ : Set X) = univ 
goal: interior Set.univ = Set.univ

full_name: interior_eq_univ
code: @[simp]
theorem interior_eq_univ : interior s = univ ↔ s = univ 
goal: interior s = Set.univ ↔ s = Set.univ

full_name: interior_interior
code: @[simp]
theorem interior_interior : interior (interior s) = interior s 
goal: interior (interior s) = interior s

full_name: interior_inter
code: @[simp]
theorem interior_inter : interior (s ∩ t) = interior s ∩ interior t 
goal: interior (s ∩ t) = interior s ∩ interior t

full_name: Set.Finite.interior_biInter
code: theorem Set.Finite.interior_biInter {ι : Type*} {s : Set ι} (hs : s.Finite) (f : ι → Set X) :
    interior (⋂ i ∈ s, f i) = ⋂ i ∈ s, interior (f i) 
goal: interior (⋂ i ∈ s, f i) = ⋂ i ∈ s, interior (f i)

full_name: Set.Finite.interior_sInter
code: theorem Set.Finite.interior_sInter {S : Set (Set X)} (hS : S.Finite) :
    interior (⋂₀ S) = ⋂ s ∈ S, interior s 
goal: interior (⋂₀ S) = ⋂ s ∈ S, interior s

full_name: Finset.interior_iInter
code: @[simp]
theorem Finset.interior_iInter {ι : Type*} (s : Finset ι) (f : ι → Set X) :
    interior (⋂ i ∈ s, f i) = ⋂ i ∈ s, interior (f i) 
goal: interior (⋂ i ∈ s, f i) = ⋂ i ∈ s, interior (f i)

full_name: interior_iInter_of_finite
code: @[simp]
theorem interior_iInter_of_finite [Finite ι] (f : ι → Set X) :
    interior (⋂ i, f i) = ⋂ i, interior (f i) 
goal: interior (⋂ i, f i) = ⋂ i, interior (f i)

full_name: interior_iInter₂_lt_nat
code: @[simp]
theorem interior_iInter₂_lt_nat {n : ℕ} (f : ℕ → Set X) :
    interior (⋂ m < n, f m) = ⋂ m < n, interior (f m) 
goal: interior (⋂ m, ⋂ (_ : m < n), f m) = ⋂ m, ⋂ (_ : m < n), interior (f m)

full_name: interior_iInter₂_le_nat
code: @[simp]
theorem interior_iInter₂_le_nat {n : ℕ} (f : ℕ → Set X) :
    interior (⋂ m ≤ n, f m) = ⋂ m ≤ n, interior (f m) 
goal: interior (⋂ m, ⋂ (_ : m ≤ n), f m) = ⋂ m, ⋂ (_ : m ≤ n), interior (f m)

full_name: interior_union_isClosed_of_interior_empty
code: theorem interior_union_isClosed_of_interior_empty (h₁ : IsClosed s)
    (h₂ : interior t = ∅) : interior (s ∪ t) = interior s 
goal: interior (s ∪ t) = interior s

full_name: isOpen_iff_forall_mem_open
code: theorem isOpen_iff_forall_mem_open : IsOpen s ↔ ∀ x ∈ s, ∃ t, t ⊆ s ∧ IsOpen t ∧ x ∈ t 
goal: IsOpen s ↔ ∀ x ∈ s, ∃ t ⊆ s, IsOpen t ∧ x ∈ t

full_name: interior_iInter_subset
code: theorem interior_iInter_subset (s : ι → Set X) : interior (⋂ i, s i) ⊆ ⋂ i, interior (s i) 
goal: interior (⋂ i, s i) ⊆ ⋂ i, interior (s i)

full_name: interior_iInter₂_subset
code: theorem interior_iInter₂_subset (p : ι → Sort*) (s : ∀ i, p i → Set X) :
    interior (⋂ (i) (j), s i j) ⊆ ⋂ (i) (j), interior (s i j) 
goal: interior (⋂ i, ⋂ j, s i j) ⊆ ⋂ i, ⋂ j, interior (s i j)

full_name: interior_sInter_subset
code: theorem interior_sInter_subset (S : Set (Set X)) : interior (⋂₀ S) ⊆ ⋂ s ∈ S, interior s 
goal: interior (⋂₀ S) ⊆ ⋂ s ∈ S, interior s

full_name: Filter.HasBasis.lift'_interior
code: theorem Filter.HasBasis.lift'_interior {l : Filter X} {p : ι → Prop} {s : ι → Set X}
    (h : l.HasBasis p s) : (l.lift' interior).HasBasis p fun i => interior (s i) 
goal: (l.lift' interior).HasBasis p fun i => interior (s i)

full_name: Filter.lift'_interior_le
code: theorem Filter.lift'_interior_le (l : Filter X) : l.lift' interior ≤ l 
goal: l.lift' interior ≤ l

full_name: Filter.HasBasis.lift'_interior_eq_self
code: theorem Filter.HasBasis.lift'_interior_eq_self {l : Filter X} {p : ι → Prop} {s : ι → Set X}
    (h : l.HasBasis p s) (ho : ∀ i, p i → IsOpen (s i)) : l.lift' interior = l 
goal: l.lift' interior = l

full_name: isClosed_closure
code: @[simp]
theorem isClosed_closure : IsClosed (closure s) 
goal: IsClosed (closure s)

full_name: subset_closure
code: theorem subset_closure : s ⊆ closure s 
goal: s ⊆ closure s

full_name: not_mem_of_not_mem_closure
code: theorem not_mem_of_not_mem_closure {P : X} (hP : P ∉ closure s) : P ∉ s 
goal: P ∉ s

full_name: closure_minimal
code: theorem closure_minimal (h₁ : s ⊆ t) (h₂ : IsClosed t) : closure s ⊆ t 
goal: closure s ⊆ t

full_name: Disjoint.closure_left
code: theorem Disjoint.closure_left (hd : Disjoint s t) (ht : IsOpen t) :
    Disjoint (closure s) t 
goal: Disjoint (closure s) t

full_name: Disjoint.closure_right
code: theorem Disjoint.closure_right (hd : Disjoint s t) (hs : IsOpen s) :
    Disjoint s (closure t) 
goal: Disjoint s (closure t)

full_name: IsClosed.closure_eq
code: theorem IsClosed.closure_eq (h : IsClosed s) : closure s = s 
goal: closure s = s

full_name: IsClosed.closure_subset
code: theorem IsClosed.closure_subset (hs : IsClosed s) : closure s ⊆ s 
goal: closure s ⊆ s

full_name: IsClosed.closure_subset_iff
code: theorem IsClosed.closure_subset_iff (h₁ : IsClosed t) : closure s ⊆ t ↔ s ⊆ t 
goal: closure s ⊆ t ↔ s ⊆ t

full_name: IsClosed.mem_iff_closure_subset
code: theorem IsClosed.mem_iff_closure_subset (hs : IsClosed s) :
    x ∈ s ↔ closure ({x} : Set X) ⊆ s 
goal: x ∈ s ↔ closure {x} ⊆ s

full_name: closure_mono
code: @[mono, gcongr]
theorem closure_mono (h : s ⊆ t) : closure s ⊆ closure t 
goal: closure s ⊆ closure t

full_name: monotone_closure
code: theorem monotone_closure (X : Type*) [TopologicalSpace X] : Monotone (@closure X _) 
goal: Monotone closure

full_name: diff_subset_closure_iff
code: theorem diff_subset_closure_iff : s \ t ⊆ closure t ↔ s ⊆ closure t 
goal: s \ t ⊆ closure t ↔ s ⊆ closure t

full_name: closure_inter_subset_inter_closure
code: theorem closure_inter_subset_inter_closure (s t : Set X) :
    closure (s ∩ t) ⊆ closure s ∩ closure t 
goal: closure (s ∩ t) ⊆ closure s ∩ closure t

full_name: isClosed_of_closure_subset
code: theorem isClosed_of_closure_subset (h : closure s ⊆ s) : IsClosed s 
goal: IsClosed s

full_name: closure_eq_iff_isClosed
code: theorem closure_eq_iff_isClosed : closure s = s ↔ IsClosed s 
goal: closure s = s ↔ IsClosed s

full_name: closure_subset_iff_isClosed
code: theorem closure_subset_iff_isClosed : closure s ⊆ s ↔ IsClosed s 
goal: closure s ⊆ s ↔ IsClosed s

full_name: closure_empty
code: @[simp]
theorem closure_empty : closure (∅ : Set X) = ∅ 
goal: closure ∅ = ∅

full_name: closure_empty_iff
code: @[simp]
theorem closure_empty_iff (s : Set X) : closure s = ∅ ↔ s = ∅ 
goal: closure s = ∅ ↔ s = ∅

full_name: closure_nonempty_iff
code: @[simp]
theorem closure_nonempty_iff : (closure s).Nonempty ↔ s.Nonempty 
goal: (closure s).Nonempty ↔ s.Nonempty

full_name: closure_univ
code: @[simp]
theorem closure_univ : closure (univ : Set X) = univ 
goal: closure Set.univ = Set.univ

full_name: closure_closure
code: @[simp]
theorem closure_closure : closure (closure s) = closure s 
goal: closure (closure s) = closure s

full_name: closure_eq_compl_interior_compl
code: theorem closure_eq_compl_interior_compl : closure s = (interior sᶜ)ᶜ 
goal: closure s = (interior sᶜ)ᶜ

full_name: closure_union
code: @[simp]
theorem closure_union : closure (s ∪ t) = closure s ∪ closure t 
goal: closure (s ∪ t) = closure s ∪ closure t

full_name: Set.Finite.closure_biUnion
code: theorem Set.Finite.closure_biUnion {ι : Type*} {s : Set ι} (hs : s.Finite) (f : ι → Set X) :
    closure (⋃ i ∈ s, f i) = ⋃ i ∈ s, closure (f i) 
goal: closure (⋃ i ∈ s, f i) = ⋃ i ∈ s, closure (f i)

full_name: Set.Finite.closure_sUnion
code: theorem Set.Finite.closure_sUnion {S : Set (Set X)} (hS : S.Finite) :
    closure (⋃₀ S) = ⋃ s ∈ S, closure s 
goal: closure (⋃₀ S) = ⋃ s ∈ S, closure s

full_name: Finset.closure_biUnion
code: @[simp]
theorem Finset.closure_biUnion {ι : Type*} (s : Finset ι) (f : ι → Set X) :
    closure (⋃ i ∈ s, f i) = ⋃ i ∈ s, closure (f i) 
goal: closure (⋃ i ∈ s, f i) = ⋃ i ∈ s, closure (f i)

full_name: closure_iUnion_of_finite
code: @[simp]
theorem closure_iUnion_of_finite [Finite ι] (f : ι → Set X) :
    closure (⋃ i, f i) = ⋃ i, closure (f i) 
goal: closure (⋃ i, f i) = ⋃ i, closure (f i)

full_name: closure_iUnion₂_lt_nat
code: @[simp]
theorem closure_iUnion₂_lt_nat {n : ℕ} (f : ℕ → Set X) :
    closure (⋃ m < n, f m) = ⋃ m < n, closure (f m) 
goal: closure (⋃ m, ⋃ (_ : m < n), f m) = ⋃ m, ⋃ (_ : m < n), closure (f m)

full_name: closure_iUnion₂_le_nat
code: @[simp]
theorem closure_iUnion₂_le_nat {n : ℕ} (f : ℕ → Set X) :
    closure (⋃ m ≤ n, f m) = ⋃ m ≤ n, closure (f m) 
goal: closure (⋃ m, ⋃ (_ : m ≤ n), f m) = ⋃ m, ⋃ (_ : m ≤ n), closure (f m)

full_name: interior_subset_closure
code: theorem interior_subset_closure : interior s ⊆ closure s 
goal: interior s ⊆ closure s

full_name: interior_compl
code: @[simp]
theorem interior_compl : interior sᶜ = (closure s)ᶜ 
goal: interior sᶜ = (closure s)ᶜ

full_name: closure_compl
code: @[simp]
theorem closure_compl : closure sᶜ = (interior s)ᶜ 
goal: closure sᶜ = (interior s)ᶜ

full_name: mem_closure_iff
code: theorem mem_closure_iff :
    x ∈ closure s ↔ ∀ o, IsOpen o → x ∈ o → (o ∩ s).Nonempty 
goal: x ∈ closure s ↔ ∀ (o : Set X), IsOpen o → x ∈ o → (o ∩ s).Nonempty

full_name: closure_inter_open_nonempty_iff
code: theorem closure_inter_open_nonempty_iff (h : IsOpen t) :
    (closure s ∩ t).Nonempty ↔ (s ∩ t).Nonempty 
goal: (closure s ∩ t).Nonempty ↔ (s ∩ t).Nonempty

full_name: Filter.le_lift'_closure
code: theorem Filter.le_lift'_closure (l : Filter X) : l ≤ l.lift' closure 
goal: l ≤ l.lift' closure

full_name: Filter.HasBasis.lift'_closure
code: theorem Filter.HasBasis.lift'_closure {l : Filter X} {p : ι → Prop} {s : ι → Set X}
    (h : l.HasBasis p s) : (l.lift' closure).HasBasis p fun i => closure (s i) 
goal: (l.lift' closure).HasBasis p fun i => closure (s i)

full_name: Filter.HasBasis.lift'_closure_eq_self
code: theorem Filter.HasBasis.lift'_closure_eq_self {l : Filter X} {p : ι → Prop} {s : ι → Set X}
    (h : l.HasBasis p s) (hc : ∀ i, p i → IsClosed (s i)) : l.lift' closure = l 
goal: l.lift' closure = l

full_name: Filter.lift'_closure_eq_bot
code: @[simp]
theorem Filter.lift'_closure_eq_bot {l : Filter X} : l.lift' closure = ⊥ ↔ l = ⊥ 
goal: l.lift' closure = ⊥ ↔ l = ⊥

full_name: dense_iff_closure_eq
code: theorem dense_iff_closure_eq : Dense s ↔ closure s = univ 
goal: Dense s ↔ closure s = Set.univ

full_name: interior_eq_empty_iff_dense_compl
code: theorem interior_eq_empty_iff_dense_compl : interior s = ∅ ↔ Dense sᶜ 
goal: interior s = ∅ ↔ Dense sᶜ

full_name: Dense.interior_compl
code: theorem Dense.interior_compl (h : Dense s) : interior sᶜ = ∅ 
goal: interior sᶜ = ∅

full_name: dense_closure
code: /-- The closure of a set `s` is dense if and only if `s` is dense. -/
@[simp]
theorem dense_closure : Dense (closure s) ↔ Dense s 
goal: Dense (closure s) ↔ Dense s

full_name: dense_univ
code: @[simp]
theorem dense_univ : Dense (univ : Set X) 
goal: Dense Set.univ

full_name: dense_iff_inter_open
code: /-- A set is dense if and only if it has a nonempty intersection with each nonempty open set. -/
theorem dense_iff_inter_open :
    Dense s ↔ ∀ U, IsOpen U → U.Nonempty → (U ∩ s).Nonempty 
goal: Dense s ↔ ∀ (U : Set X), IsOpen U → U.Nonempty → (U ∩ s).Nonempty

full_name: Dense.exists_mem_open
code: theorem Dense.exists_mem_open (hs : Dense s) {U : Set X} (ho : IsOpen U)
    (hne : U.Nonempty) : ∃ x ∈ s, x ∈ U 
goal: ∃ x ∈ s, x ∈ U

full_name: Dense.nonempty_iff
code: theorem Dense.nonempty_iff (hs : Dense s) : s.Nonempty ↔ Nonempty X 
goal: s.Nonempty ↔ Nonempty X

full_name: Dense.nonempty
code: theorem Dense.nonempty [h : Nonempty X] (hs : Dense s) : s.Nonempty 
goal: s.Nonempty

full_name: Dense.mono
code: @[mono]
theorem Dense.mono (h : s₁ ⊆ s₂) (hd : Dense s₁) : Dense s₂ 
goal: Dense s₂

full_name: dense_compl_singleton_iff_not_open
code: /-- Complement to a singleton is dense if and only if the singleton is not an open set. -/
theorem dense_compl_singleton_iff_not_open :
    Dense ({x}ᶜ : Set X) ↔ ¬IsOpen ({x} : Set X) 
goal: Dense {x}ᶜ ↔ ¬IsOpen {x}

full_name: IsOpen.subset_interior_closure
code: theorem IsOpen.subset_interior_closure {s : Set X} (s_open : IsOpen s) :
    s ⊆ interior (closure s) 
goal: s ⊆ interior (closure s)

full_name: IsClosed.closure_interior_subset
code: theorem IsClosed.closure_interior_subset {s : Set X} (s_closed : IsClosed s) :
    closure (interior s) ⊆ s 
goal: closure (interior s) ⊆ s

full_name: closure_diff_interior
code: @[simp]
theorem closure_diff_interior (s : Set X) : closure s \ interior s = frontier s 
goal: closure s \ interior s = frontier s

full_name: disjoint_interior_frontier
code: /-- Interior and frontier are disjoint. -/
lemma disjoint_interior_frontier : Disjoint (interior s) (frontier s) 
goal: Disjoint (interior s) (frontier s)

full_name: closure_diff_frontier
code: @[simp]
theorem closure_diff_frontier (s : Set X) : closure s \ frontier s = interior s 
goal: closure s \ frontier s = interior s

full_name: self_diff_frontier
code: @[simp]
theorem self_diff_frontier (s : Set X) : s \ frontier s = interior s 
goal: s \ frontier s = interior s

full_name: frontier_eq_closure_inter_closure
code: theorem frontier_eq_closure_inter_closure : frontier s = closure s ∩ closure sᶜ 
goal: frontier s = closure s ∩ closure sᶜ

full_name: frontier_subset_closure
code: theorem frontier_subset_closure : frontier s ⊆ closure s 
goal: frontier s ⊆ closure s

full_name: frontier_subset_iff_isClosed
code: theorem frontier_subset_iff_isClosed : frontier s ⊆ s ↔ IsClosed s 
goal: frontier s ⊆ s ↔ IsClosed s

full_name: frontier_closure_subset
code: theorem frontier_closure_subset : frontier (closure s) ⊆ frontier s 
goal: frontier (closure s) ⊆ frontier s

full_name: frontier_interior_subset
code: theorem frontier_interior_subset : frontier (interior s) ⊆ frontier s 
goal: frontier (interior s) ⊆ frontier s

full_name: frontier_compl
code: /-- The complement of a set has the same frontier as the original set. -/
@[simp]
theorem frontier_compl (s : Set X) : frontier sᶜ = frontier s 
goal: frontier sᶜ = frontier s

full_name: frontier_univ
code: @[simp]
theorem frontier_univ : frontier (univ : Set X) = ∅ 
goal: frontier Set.univ = ∅

full_name: frontier_empty
code: @[simp]
theorem frontier_empty : frontier (∅ : Set X) = ∅ 
goal: frontier ∅ = ∅

full_name: frontier_inter_subset
code: theorem frontier_inter_subset (s t : Set X) :
    frontier (s ∩ t) ⊆ frontier s ∩ closure t ∪ closure s ∩ frontier t 
goal: frontier (s ∩ t) ⊆ frontier s ∩ closure t ∪ closure s ∩ frontier t

full_name: frontier_union_subset
code: theorem frontier_union_subset (s t : Set X) :
    frontier (s ∪ t) ⊆ frontier s ∩ closure tᶜ ∪ closure sᶜ ∩ frontier t 
goal: frontier (s ∪ t) ⊆ frontier s ∩ closure tᶜ ∪ closure sᶜ ∩ frontier t

full_name: IsClosed.frontier_eq
code: theorem IsClosed.frontier_eq (hs : IsClosed s) : frontier s = s \ interior s 
goal: frontier s = s \ interior s

full_name: IsOpen.frontier_eq
code: theorem IsOpen.frontier_eq (hs : IsOpen s) : frontier s = closure s \ s 
goal: frontier s = closure s \ s

full_name: IsOpen.inter_frontier_eq
code: theorem IsOpen.inter_frontier_eq (hs : IsOpen s) : s ∩ frontier s = ∅ 
goal: s ∩ frontier s = ∅

full_name: disjoint_frontier_iff_isOpen
code: theorem disjoint_frontier_iff_isOpen : Disjoint (frontier s) s ↔ IsOpen s 
goal: Disjoint (frontier s) s ↔ IsOpen s

full_name: isClosed_frontier
code: /-- The frontier of a set is closed. -/
theorem isClosed_frontier : IsClosed (frontier s) 
goal: IsClosed (frontier s)

full_name: interior_frontier
code: /-- The frontier of a closed set has no interior point. -/
theorem interior_frontier (h : IsClosed s) : interior (frontier s) = ∅ 
goal: interior (frontier s) = ∅

full_name: closure_eq_interior_union_frontier
code: theorem closure_eq_interior_union_frontier (s : Set X) : closure s = interior s ∪ frontier s 
goal: closure s = interior s ∪ frontier s

full_name: closure_eq_self_union_frontier
code: theorem closure_eq_self_union_frontier (s : Set X) : closure s = s ∪ frontier s 
goal: closure s = s ∪ frontier s

full_name: Disjoint.frontier_left
code: theorem Disjoint.frontier_left (ht : IsOpen t) (hd : Disjoint s t) : Disjoint (frontier s) t 
goal: Disjoint (frontier s) t

full_name: Disjoint.frontier_right
code: theorem Disjoint.frontier_right (hs : IsOpen s) (hd : Disjoint s t) : Disjoint s (frontier t) 
goal: Disjoint s (frontier t)

full_name: frontier_eq_inter_compl_interior
code: theorem frontier_eq_inter_compl_interior :
    frontier s = (interior s)ᶜ ∩ (interior sᶜ)ᶜ 
goal: frontier s = (interior s)ᶜ ∩ (interior sᶜ)ᶜ

full_name: compl_frontier_eq_union_interior
code: theorem compl_frontier_eq_union_interior :
    (frontier s)ᶜ = interior s ∪ interior sᶜ 
goal: (frontier s)ᶜ = interior s ∪ interior sᶜ

full_name: nhds_def'
code: theorem nhds_def' (x : X) : 𝓝 x = ⨅ (s : Set X) (_ : IsOpen s) (_ : x ∈ s), 𝓟 s 
goal: 𝓝 x = ⨅ s, ⨅ (_ : IsOpen s), ⨅ (_ : x ∈ s), 𝓟 s

full_name: nhds_basis_opens
code: /-- The open sets containing `x` are a basis for the neighborhood filter. See `nhds_basis_opens'`
for a variant using open neighborhoods instead. -/
theorem nhds_basis_opens (x : X) :
    (𝓝 x).HasBasis (fun s : Set X => x ∈ s ∧ IsOpen s) fun s => s 
goal: (𝓝 x).HasBasis (fun s => x ∈ s ∧ IsOpen s) fun s => s

full_name: nhds_basis_closeds
code: theorem nhds_basis_closeds (x : X) : (𝓝 x).HasBasis (fun s : Set X => x ∉ s ∧ IsClosed s) compl 
goal: (𝓝 x).HasBasis (fun s => x ∉ s ∧ IsClosed s) compl

full_name: lift'_nhds_interior
code: @[simp]
theorem lift'_nhds_interior (x : X) : (𝓝 x).lift' interior = 𝓝 x 
goal: (𝓝 x).lift' interior = 𝓝 x

full_name: Filter.HasBasis.nhds_interior
code: theorem Filter.HasBasis.nhds_interior {x : X} {p : ι → Prop} {s : ι → Set X}
    (h : (𝓝 x).HasBasis p s) : (𝓝 x).HasBasis p (interior <| s ·) 
goal: (𝓝 x).HasBasis p fun x => interior (s x)

full_name: le_nhds_iff
code: /-- A filter lies below the neighborhood filter at `x` iff it contains every open set around `x`. -/
theorem le_nhds_iff {f} : f ≤ 𝓝 x ↔ ∀ s : Set X, x ∈ s → IsOpen s → s ∈ f 
goal: f ≤ 𝓝 x ↔ ∀ (s : Set X), x ∈ s → IsOpen s → s ∈ f

full_name: nhds_le_of_le
code: /-- To show a filter is above the neighborhood filter at `x`, it suffices to show that it is above
the principal filter of some open set `s` containing `x`. -/
theorem nhds_le_of_le {f} (h : x ∈ s) (o : IsOpen s) (sf : 𝓟 s ≤ f) : 𝓝 x ≤ f 
goal: 𝓝 x ≤ f

full_name: mem_nhds_iff
code: theorem mem_nhds_iff : s ∈ 𝓝 x ↔ ∃ t ⊆ s, IsOpen t ∧ x ∈ t 
goal: s ∈ 𝓝 x ↔ ∃ t ⊆ s, IsOpen t ∧ x ∈ t

full_name: eventually_nhds_iff
code: /-- A predicate is true in a neighborhood of `x` iff it is true for all the points in an open set
containing `x`. -/
theorem eventually_nhds_iff {p : X → Prop} :
    (∀ᶠ y in 𝓝 x, p y) ↔ ∃ t : Set X, (∀ y ∈ t, p y) ∧ IsOpen t ∧ x ∈ t 
goal: (∀ᶠ (y : X) in 𝓝 x, p y) ↔ ∃ t, (∀ y ∈ t, p y) ∧ IsOpen t ∧ x ∈ t

full_name: frequently_nhds_iff
code: theorem frequently_nhds_iff {p : X → Prop} :
    (∃ᶠ y in 𝓝 x, p y) ↔ ∀ U : Set X, x ∈ U → IsOpen U → ∃ y ∈ U, p y 
goal: (∃ᶠ (y : X) in 𝓝 x, p y) ↔ ∀ (U : Set X), x ∈ U → IsOpen U → ∃ y ∈ U, p y

full_name: mem_interior_iff_mem_nhds
code: theorem mem_interior_iff_mem_nhds : x ∈ interior s ↔ s ∈ 𝓝 x 
goal: x ∈ interior s ↔ s ∈ 𝓝 x

full_name: map_nhds
code: theorem map_nhds {f : X → α} :
    map f (𝓝 x) = ⨅ s ∈ { s : Set X | x ∈ s ∧ IsOpen s }, 𝓟 (f '' s) 
goal: Filter.map f (𝓝 x) = ⨅ s ∈ {s | x ∈ s ∧ IsOpen s}, 𝓟 (f '' s)

full_name: mem_of_mem_nhds
code: theorem mem_of_mem_nhds : s ∈ 𝓝 x → x ∈ s 
goal: s ∈ 𝓝 x → x ∈ s

full_name: Filter.Eventually.self_of_nhds
code: /-- If a predicate is true in a neighborhood of `x`, then it is true for `x`. -/
theorem Filter.Eventually.self_of_nhds {p : X → Prop} (h : ∀ᶠ y in 𝓝 x, p y) : p x 
goal: p x

full_name: IsOpen.mem_nhds
code: theorem IsOpen.mem_nhds (hs : IsOpen s) (hx : x ∈ s) : s ∈ 𝓝 x 
goal: s ∈ 𝓝 x

full_name: IsOpen.mem_nhds_iff
code: protected theorem IsOpen.mem_nhds_iff (hs : IsOpen s) : s ∈ 𝓝 x ↔ x ∈ s 
goal: s ∈ 𝓝 x ↔ x ∈ s

full_name: IsClosed.compl_mem_nhds
code: theorem IsClosed.compl_mem_nhds (hs : IsClosed s) (hx : x ∉ s) : sᶜ ∈ 𝓝 x 
goal: sᶜ ∈ 𝓝 x

full_name: IsOpen.eventually_mem
code: theorem IsOpen.eventually_mem (hs : IsOpen s) (hx : x ∈ s) :
    ∀ᶠ x in 𝓝 x, x ∈ s 
goal: ∀ᶠ (x : X) in 𝓝 x, x ∈ s

full_name: nhds_basis_opens'
code: /-- The open neighborhoods of `x` are a basis for the neighborhood filter. See `nhds_basis_opens`
for a variant using open sets around `x` instead. -/
theorem nhds_basis_opens' (x : X) :
    (𝓝 x).HasBasis (fun s : Set X => s ∈ 𝓝 x ∧ IsOpen s) fun x => x 
goal: (𝓝 x).HasBasis (fun s => s ∈ 𝓝 x ∧ IsOpen s) fun x => x

full_name: exists_open_set_nhds
code: /-- If `U` is a neighborhood of each point of a set `s` then it is a neighborhood of `s`:
it contains an open set containing `s`. -/
theorem exists_open_set_nhds {U : Set X} (h : ∀ x ∈ s, U ∈ 𝓝 x) :
    ∃ V : Set X, s ⊆ V ∧ IsOpen V ∧ V ⊆ U 
goal: ∃ V, s ⊆ V ∧ IsOpen V ∧ V ⊆ U

full_name: exists_open_set_nhds'
code: /-- If `U` is a neighborhood of each point of a set `s` then it is a neighborhood of s:
it contains an open set containing `s`. -/
theorem exists_open_set_nhds' {U : Set X} (h : U ∈ ⨆ x ∈ s, 𝓝 x) :
    ∃ V : Set X, s ⊆ V ∧ IsOpen V ∧ V ⊆ U 
goal: ∃ V, s ⊆ V ∧ IsOpen V ∧ V ⊆ U

full_name: Filter.Eventually.eventually_nhds
code: /-- If a predicate is true in a neighbourhood of `x`, then for `y` sufficiently close
to `x` this predicate is true in a neighbourhood of `y`. -/
theorem Filter.Eventually.eventually_nhds {p : X → Prop} (h : ∀ᶠ y in 𝓝 x, p y) :
    ∀ᶠ y in 𝓝 x, ∀ᶠ x in 𝓝 y, p x 
goal: ∀ᶠ (y : X) in 𝓝 x, ∀ᶠ (x : X) in 𝓝 y, p x

full_name: eventually_eventually_nhds
code: @[simp]
theorem eventually_eventually_nhds {p : X → Prop} :
    (∀ᶠ y in 𝓝 x, ∀ᶠ x in 𝓝 y, p x) ↔ ∀ᶠ x in 𝓝 x, p x 
goal: (∀ᶠ (y : X) in 𝓝 x, ∀ᶠ (x : X) in 𝓝 y, p x) ↔ ∀ᶠ (x : X) in 𝓝 x, p x

full_name: frequently_frequently_nhds
code: @[simp]
theorem frequently_frequently_nhds {p : X → Prop} :
    (∃ᶠ x' in 𝓝 x, ∃ᶠ x'' in 𝓝 x', p x'') ↔ ∃ᶠ x in 𝓝 x, p x 
goal: (∃ᶠ (x' : X) in 𝓝 x, ∃ᶠ (x'' : X) in 𝓝 x', p x'') ↔ ∃ᶠ (x : X) in 𝓝 x, p x

full_name: eventually_mem_nhds
code: @[simp]
theorem eventually_mem_nhds : (∀ᶠ x' in 𝓝 x, s ∈ 𝓝 x') ↔ s ∈ 𝓝 x 
goal: (∀ᶠ (x' : X) in 𝓝 x, s ∈ 𝓝 x') ↔ s ∈ 𝓝 x

full_name: nhds_bind_nhds
code: @[simp]
theorem nhds_bind_nhds : (𝓝 x).bind 𝓝 = 𝓝 x 
goal: (𝓝 x).bind 𝓝 = 𝓝 x

full_name: eventually_eventuallyEq_nhds
code: @[simp]
theorem eventually_eventuallyEq_nhds {f g : X → α} :
    (∀ᶠ y in 𝓝 x, f =ᶠ[𝓝 y] g) ↔ f =ᶠ[𝓝 x] g 
goal: (∀ᶠ (y : X) in 𝓝 x, f =ᶠ[𝓝 y] g) ↔ f =ᶠ[𝓝 x] g

full_name: Filter.EventuallyEq.eq_of_nhds
code: theorem Filter.EventuallyEq.eq_of_nhds {f g : X → α} (h : f =ᶠ[𝓝 x] g) : f x = g x 
goal: f x = g x

full_name: eventually_eventuallyLE_nhds
code: @[simp]
theorem eventually_eventuallyLE_nhds [LE α] {f g : X → α} :
    (∀ᶠ y in 𝓝 x, f ≤ᶠ[𝓝 y] g) ↔ f ≤ᶠ[𝓝 x] g 
goal: (∀ᶠ (y : X) in 𝓝 x, f ≤ᶠ[𝓝 y] g) ↔ f ≤ᶠ[𝓝 x] g

full_name: Filter.EventuallyEq.eventuallyEq_nhds
code: /-- If two functions are equal in a neighbourhood of `x`, then for `y` sufficiently close
to `x` these functions are equal in a neighbourhood of `y`. -/
theorem Filter.EventuallyEq.eventuallyEq_nhds {f g : X → α} (h : f =ᶠ[𝓝 x] g) :
    ∀ᶠ y in 𝓝 x, f =ᶠ[𝓝 y] g 
goal: ∀ᶠ (y : X) in 𝓝 x, f =ᶠ[𝓝 y] g

full_name: Filter.EventuallyLE.eventuallyLE_nhds
code: /-- If `f x ≤ g x` in a neighbourhood of `x`, then for `y` sufficiently close to `x` we have
`f x ≤ g x` in a neighbourhood of `y`. -/
theorem Filter.EventuallyLE.eventuallyLE_nhds [LE α] {f g : X → α} (h : f ≤ᶠ[𝓝 x] g) :
    ∀ᶠ y in 𝓝 x, f ≤ᶠ[𝓝 y] g 
goal: ∀ᶠ (y : X) in 𝓝 x, f ≤ᶠ[𝓝 y] g

full_name: all_mem_nhds
code: theorem all_mem_nhds (x : X) (P : Set X → Prop) (hP : ∀ s t, s ⊆ t → P s → P t) :
    (∀ s ∈ 𝓝 x, P s) ↔ ∀ s, IsOpen s → x ∈ s → P s 
goal: (∀ s ∈ 𝓝 x, P s) ↔ ∀ (s : Set X), IsOpen s → x ∈ s → P s

full_name: all_mem_nhds_filter
code: theorem all_mem_nhds_filter (x : X) (f : Set X → Set α) (hf : ∀ s t, s ⊆ t → f s ⊆ f t)
    (l : Filter α) : (∀ s ∈ 𝓝 x, f s ∈ l) ↔ ∀ s, IsOpen s → x ∈ s → f s ∈ l 
goal: (∀ s ∈ 𝓝 x, f s ∈ l) ↔ ∀ (s : Set X), IsOpen s → x ∈ s → f s ∈ l

full_name: tendsto_nhds
code: theorem tendsto_nhds {f : α → X} {l : Filter α} :
    Tendsto f l (𝓝 x) ↔ ∀ s, IsOpen s → x ∈ s → f ⁻¹' s ∈ l 
goal: Filter.Tendsto f l (𝓝 x) ↔ ∀ (s : Set X), IsOpen s → x ∈ s → f ⁻¹' s ∈ l

full_name: tendsto_atTop_nhds
code: theorem tendsto_atTop_nhds [Nonempty α] [SemilatticeSup α] {f : α → X} :
    Tendsto f atTop (𝓝 x) ↔ ∀ U : Set X, x ∈ U → IsOpen U → ∃ N, ∀ n, N ≤ n → f n ∈ U 
goal: Filter.Tendsto f Filter.atTop (𝓝 x) ↔ ∀ (U : Set X), x ∈ U → IsOpen U → ∃ N, ∀ (n : α), N ≤ n → f n ∈ U

full_name: tendsto_const_nhds
code: theorem tendsto_const_nhds {f : Filter α} : Tendsto (fun _ : α => x) f (𝓝 x) 
goal: Filter.Tendsto (fun x_1 => x) f (𝓝 x)

full_name: tendsto_atTop_of_eventually_const
code: theorem tendsto_atTop_of_eventually_const {ι : Type*} [SemilatticeSup ι] [Nonempty ι]
    {u : ι → X} {i₀ : ι} (h : ∀ i ≥ i₀, u i = x) : Tendsto u atTop (𝓝 x) 
goal: Filter.Tendsto u Filter.atTop (𝓝 x)

full_name: tendsto_atBot_of_eventually_const
code: theorem tendsto_atBot_of_eventually_const {ι : Type*} [SemilatticeInf ι] [Nonempty ι]
    {u : ι → X} {i₀ : ι} (h : ∀ i ≤ i₀, u i = x) : Tendsto u atBot (𝓝 x) 
goal: Filter.Tendsto u Filter.atBot (𝓝 x)

full_name: pure_le_nhds
code: theorem pure_le_nhds : pure ≤ (𝓝 : X → Filter X) 
goal: pure ≤ 𝓝

full_name: tendsto_pure_nhds
code: theorem tendsto_pure_nhds (f : α → X) (a : α) : Tendsto f (pure a) (𝓝 (f a)) 
goal: Filter.Tendsto f (pure a) (𝓝 (f a))

full_name: OrderTop.tendsto_atTop_nhds
code: theorem OrderTop.tendsto_atTop_nhds [PartialOrder α] [OrderTop α] (f : α → X) :
    Tendsto f atTop (𝓝 (f ⊤)) 
goal: Filter.Tendsto f Filter.atTop (𝓝 (f ⊤))

full_name: nhds_neBot
code: @[simp]
instance nhds_neBot : NeBot (𝓝 x) 
goal: (𝓝 x).NeBot

full_name: tendsto_nhds_of_eventually_eq
code: theorem tendsto_nhds_of_eventually_eq {l : Filter α} {f : α → X} (h : ∀ᶠ x' in l, f x' = x) :
    Tendsto f l (𝓝 x) 
goal: Filter.Tendsto f l (𝓝 x)

full_name: Filter.EventuallyEq.tendsto
code: theorem Filter.EventuallyEq.tendsto {l : Filter α} {f : α → X} (hf : f =ᶠ[l] fun _ ↦ x) :
    Tendsto f l (𝓝 x) 
goal: Filter.Tendsto f l (𝓝 x)

full_name: ClusterPt.neBot
code: theorem ClusterPt.neBot {F : Filter X} (h : ClusterPt x F) : NeBot (𝓝 x ⊓ F) 
goal: (𝓝 x ⊓ F).NeBot

full_name: Filter.HasBasis.clusterPt_iff
code: theorem Filter.HasBasis.clusterPt_iff {ιX ιF} {pX : ιX → Prop} {sX : ιX → Set X} {pF : ιF → Prop}
    {sF : ιF → Set X} {F : Filter X} (hX : (𝓝 x).HasBasis pX sX) (hF : F.HasBasis pF sF) :
    ClusterPt x F ↔ ∀ ⦃i⦄, pX i → ∀ ⦃j⦄, pF j → (sX i ∩ sF j).Nonempty 
goal: ClusterPt x F ↔ ∀ ⦃i : ιX⦄, pX i → ∀ ⦃j : ιF⦄, pF j → (sX i ∩ sF j).Nonempty

full_name: clusterPt_iff
code: theorem clusterPt_iff {F : Filter X} :
    ClusterPt x F ↔ ∀ ⦃U : Set X⦄, U ∈ 𝓝 x → ∀ ⦃V⦄, V ∈ F → (U ∩ V).Nonempty 
goal: ClusterPt x F ↔ ∀ ⦃U : Set X⦄, U ∈ 𝓝 x → ∀ ⦃V : Set X⦄, V ∈ F → (U ∩ V).Nonempty

full_name: clusterPt_iff_not_disjoint
code: theorem clusterPt_iff_not_disjoint {F : Filter X} :
    ClusterPt x F ↔ ¬Disjoint (𝓝 x) F 
goal: ClusterPt x F ↔ ¬Disjoint (𝓝 x) F

full_name: clusterPt_principal_iff
code: /-- `x` is a cluster point of a set `s` if every neighbourhood of `x` meets `s` on a nonempty
set. See also `mem_closure_iff_clusterPt`. -/
theorem clusterPt_principal_iff :
    ClusterPt x (𝓟 s) ↔ ∀ U ∈ 𝓝 x, (U ∩ s).Nonempty 
goal: ClusterPt x (𝓟 s) ↔ ∀ U ∈ 𝓝 x, (U ∩ s).Nonempty

full_name: clusterPt_principal_iff_frequently
code: theorem clusterPt_principal_iff_frequently :
    ClusterPt x (𝓟 s) ↔ ∃ᶠ y in 𝓝 x, y ∈ s 
goal: ClusterPt x (𝓟 s) ↔ ∃ᶠ (y : X) in 𝓝 x, y ∈ s

full_name: ClusterPt.of_le_nhds
code: theorem ClusterPt.of_le_nhds {f : Filter X} (H : f ≤ 𝓝 x) [NeBot f] : ClusterPt x f 
goal: ClusterPt x f

full_name: ClusterPt.of_le_nhds'
code: theorem ClusterPt.of_le_nhds' {f : Filter X} (H : f ≤ 𝓝 x) (_hf : NeBot f) :
    ClusterPt x f 
goal: ClusterPt x f

full_name: ClusterPt.of_nhds_le
code: theorem ClusterPt.of_nhds_le {f : Filter X} (H : 𝓝 x ≤ f) : ClusterPt x f 
goal: ClusterPt x f

full_name: ClusterPt.mono
code: theorem ClusterPt.mono {f g : Filter X} (H : ClusterPt x f) (h : f ≤ g) : ClusterPt x g 
goal: ClusterPt x g

full_name: ClusterPt.of_inf_left
code: theorem ClusterPt.of_inf_left {f g : Filter X} (H : ClusterPt x <| f ⊓ g) : ClusterPt x f 
goal: ClusterPt x f

full_name: ClusterPt.of_inf_right
code: theorem ClusterPt.of_inf_right {f g : Filter X} (H : ClusterPt x <| f ⊓ g) :
    ClusterPt x g 
goal: ClusterPt x g

full_name: Ultrafilter.clusterPt_iff
code: theorem Ultrafilter.clusterPt_iff {f : Ultrafilter X} : ClusterPt x f ↔ ↑f ≤ 𝓝 x 
goal: ClusterPt x ↑f ↔ ↑f ≤ 𝓝 x

full_name: clusterPt_iff_ultrafilter
code: theorem clusterPt_iff_ultrafilter {f : Filter X} : ClusterPt x f ↔
    ∃ u : Ultrafilter X, u ≤ f ∧ u ≤ 𝓝 x 
goal: ClusterPt x f ↔ ∃ u, ↑u ≤ f ∧ ↑u ≤ 𝓝 x

full_name: mapClusterPt_def
code: theorem mapClusterPt_def {ι : Type*} (x : X) (F : Filter ι) (u : ι → X) :
    MapClusterPt x F u ↔ ClusterPt x (map u F) 
goal: MapClusterPt x F u ↔ ClusterPt x (Filter.map u F)

full_name: mapClusterPt_iff
code: theorem mapClusterPt_iff {ι : Type*} (x : X) (F : Filter ι) (u : ι → X) :
    MapClusterPt x F u ↔ ∀ s ∈ 𝓝 x, ∃ᶠ a in F, u a ∈ s 
goal: MapClusterPt x F u ↔ ∀ s ∈ 𝓝 x, ∃ᶠ (a : ι) in F, u a ∈ s

full_name: mapClusterPt_iff_ultrafilter
code: theorem mapClusterPt_iff_ultrafilter {ι : Type*} (x : X) (F : Filter ι) (u : ι → X) :
    MapClusterPt x F u ↔ ∃ U : Ultrafilter ι, U ≤ F ∧ Tendsto u U (𝓝 x) 
goal: MapClusterPt x F u ↔ ∃ U, ↑U ≤ F ∧ Filter.Tendsto u (↑U) (𝓝 x)

full_name: mapClusterPt_comp
code: theorem mapClusterPt_comp {X α β : Type*} {x : X} [TopologicalSpace X] {F : Filter α} {φ : α → β}
    {u : β → X} : MapClusterPt x F (u ∘ φ) ↔ MapClusterPt x (map φ F) u 
goal: MapClusterPt x F (u ∘ φ) ↔ MapClusterPt x (Filter.map φ F) u

full_name: mapClusterPt_of_comp
code: theorem mapClusterPt_of_comp {F : Filter α} {φ : β → α} {p : Filter β}
    {u : α → X} [NeBot p] (h : Tendsto φ p F) (H : Tendsto (u ∘ φ) p (𝓝 x)) :
    MapClusterPt x F u 
goal: MapClusterPt x F u

full_name: accPt_sup
code: theorem accPt_sup (x : X) (F G : Filter X) :
    AccPt x (F ⊔ G) ↔ AccPt x F ∨ AccPt x G 
goal: AccPt x (F ⊔ G) ↔ AccPt x F ∨ AccPt x G

full_name: acc_iff_cluster
code: theorem acc_iff_cluster (x : X) (F : Filter X) : AccPt x F ↔ ClusterPt x (𝓟 {x}ᶜ ⊓ F) 
goal: AccPt x F ↔ ClusterPt x (𝓟 {x}ᶜ ⊓ F)

full_name: acc_principal_iff_cluster
code: /-- `x` is an accumulation point of a set `C` iff it is a cluster point of `C ∖ {x}`. -/
theorem acc_principal_iff_cluster (x : X) (C : Set X) :
    AccPt x (𝓟 C) ↔ ClusterPt x (𝓟 (C \ {x})) 
goal: AccPt x (𝓟 C) ↔ ClusterPt x (𝓟 (C \ {x}))

full_name: accPt_iff_nhds
code: /-- `x` is an accumulation point of a set `C` iff every neighborhood
of `x` contains a point of `C` other than `x`. -/
theorem accPt_iff_nhds (x : X) (C : Set X) : AccPt x (𝓟 C) ↔ ∀ U ∈ 𝓝 x, ∃ y ∈ U ∩ C, y ≠ x 
goal: AccPt x (𝓟 C) ↔ ∀ U ∈ 𝓝 x, ∃ y ∈ U ∩ C, y ≠ x

full_name: accPt_iff_frequently
code: /-- `x` is an accumulation point of a set `C` iff
there are points near `x` in `C` and different from `x`. -/
theorem accPt_iff_frequently (x : X) (C : Set X) : AccPt x (𝓟 C) ↔ ∃ᶠ y in 𝓝 x, y ≠ x ∧ y ∈ C 
goal: AccPt x (𝓟 C) ↔ ∃ᶠ (y : X) in 𝓝 x, y ≠ x ∧ y ∈ C

full_name: AccPt.mono
code: /-- If `x` is an accumulation point of `F` and `F ≤ G`, then
`x` is an accumulation point of `G`. -/
theorem AccPt.mono {F G : Filter X} (h : AccPt x F) (hFG : F ≤ G) : AccPt x G 
goal: AccPt x G

full_name: AccPt.clusterPt
code: theorem AccPt.clusterPt (x : X) (F : Filter X) (h : AccPt x F) : ClusterPt x F 
goal: ClusterPt x F

full_name: interior_eq_nhds'
code: theorem interior_eq_nhds' : interior s = { x | s ∈ 𝓝 x } 
goal: interior s = {x | s ∈ 𝓝 x}

full_name: interior_eq_nhds
code: theorem interior_eq_nhds : interior s = { x | 𝓝 x ≤ 𝓟 s } 
goal: interior s = {x | 𝓝 x ≤ 𝓟 s}

full_name: interior_mem_nhds
code: @[simp]
theorem interior_mem_nhds : interior s ∈ 𝓝 x ↔ s ∈ 𝓝 x 
goal: interior s ∈ 𝓝 x ↔ s ∈ 𝓝 x

full_name: interior_setOf_eq
code: theorem interior_setOf_eq {p : X → Prop} : interior { x | p x } = { x | ∀ᶠ y in 𝓝 x, p y } 
goal: interior {x | p x} = {x | ∀ᶠ (y : X) in 𝓝 x, p y}

full_name: isOpen_setOf_eventually_nhds
code: theorem isOpen_setOf_eventually_nhds {p : X → Prop} : IsOpen { x | ∀ᶠ y in 𝓝 x, p y } 
goal: IsOpen {x | ∀ᶠ (y : X) in 𝓝 x, p y}

full_name: subset_interior_iff_nhds
code: theorem subset_interior_iff_nhds {V : Set X} : s ⊆ interior V ↔ ∀ x ∈ s, V ∈ 𝓝 x 
goal: s ⊆ interior V ↔ ∀ x ∈ s, V ∈ 𝓝 x

full_name: isOpen_iff_nhds
code: theorem isOpen_iff_nhds : IsOpen s ↔ ∀ x ∈ s, 𝓝 x ≤ 𝓟 s 
goal: IsOpen s ↔ ∀ x ∈ s, 𝓝 x ≤ 𝓟 s

full_name: TopologicalSpace.ext_iff_nhds
code: theorem TopologicalSpace.ext_iff_nhds {t t' : TopologicalSpace X} :
    t = t' ↔ ∀ x, @nhds _ t x = @nhds _ t' x 
goal: t = t' ↔ ∀ (x : X), 𝓝 x = 𝓝 x

full_name: isOpen_iff_mem_nhds
code: theorem isOpen_iff_mem_nhds : IsOpen s ↔ ∀ x ∈ s, s ∈ 𝓝 x 
goal: IsOpen s ↔ ∀ x ∈ s, s ∈ 𝓝 x

full_name: isOpen_iff_eventually
code: /-- A set `s` is open iff for every point `x` in `s` and every `y` close to `x`, `y` is in `s`. -/
theorem isOpen_iff_eventually : IsOpen s ↔ ∀ x, x ∈ s → ∀ᶠ y in 𝓝 x, y ∈ s 
goal: IsOpen s ↔ ∀ x ∈ s, ∀ᶠ (y : X) in 𝓝 x, y ∈ s

full_name: isOpen_iff_ultrafilter
code: theorem isOpen_iff_ultrafilter :
    IsOpen s ↔ ∀ x ∈ s, ∀ (l : Ultrafilter X), ↑l ≤ 𝓝 x → s ∈ l 
goal: IsOpen s ↔ ∀ x ∈ s, ∀ (l : Ultrafilter X), ↑l ≤ 𝓝 x → s ∈ l

full_name: isOpen_singleton_iff_nhds_eq_pure
code: theorem isOpen_singleton_iff_nhds_eq_pure (x : X) : IsOpen ({x} : Set X) ↔ 𝓝 x = pure x 
goal: IsOpen {x} ↔ 𝓝 x = pure x

full_name: isOpen_singleton_iff_punctured_nhds
code: theorem isOpen_singleton_iff_punctured_nhds (x : X) : IsOpen ({x} : Set X) ↔ 𝓝[≠] x = ⊥ 
goal: IsOpen {x} ↔ 𝓝[≠] x = ⊥

full_name: mem_closure_iff_frequently
code: theorem mem_closure_iff_frequently : x ∈ closure s ↔ ∃ᶠ x in 𝓝 x, x ∈ s 
goal: x ∈ closure s ↔ ∃ᶠ (x : X) in 𝓝 x, x ∈ s

full_name: isClosed_iff_frequently
code: /-- A set `s` is closed iff for every point `x`, if there is a point `y` close to `x` that belongs
to `s` then `x` is in `s`. -/
theorem isClosed_iff_frequently : IsClosed s ↔ ∀ x, (∃ᶠ y in 𝓝 x, y ∈ s) → x ∈ s 
goal: IsClosed s ↔ ∀ (x : X), (∃ᶠ (y : X) in 𝓝 x, y ∈ s) → x ∈ s

full_name: isClosed_setOf_clusterPt
code: /-- The set of cluster points of a filter is closed. In particular, the set of limit points
of a sequence is closed. -/
theorem isClosed_setOf_clusterPt {f : Filter X} : IsClosed { x | ClusterPt x f } 
goal: IsClosed {x | ClusterPt x f}

full_name: mem_closure_iff_clusterPt
code: theorem mem_closure_iff_clusterPt : x ∈ closure s ↔ ClusterPt x (𝓟 s) 
goal: x ∈ closure s ↔ ClusterPt x (𝓟 s)

full_name: mem_closure_iff_nhds_ne_bot
code: theorem mem_closure_iff_nhds_ne_bot : x ∈ closure s ↔ 𝓝 x ⊓ 𝓟 s ≠ ⊥ 
goal: x ∈ closure s ↔ 𝓝 x ⊓ 𝓟 s ≠ ⊥

full_name: mem_closure_iff_nhdsWithin_neBot
code: theorem mem_closure_iff_nhdsWithin_neBot : x ∈ closure s ↔ NeBot (𝓝[s] x) 
goal: x ∈ closure s ↔ (𝓝[s] x).NeBot

full_name: nhdsWithin_neBot
code: lemma nhdsWithin_neBot : (𝓝[s] x).NeBot ↔ ∀ ⦃t⦄, t ∈ 𝓝 x → (t ∩ s).Nonempty 
goal: (𝓝[s] x).NeBot ↔ ∀ ⦃t : Set X⦄, t ∈ 𝓝 x → (t ∩ s).Nonempty

full_name: nhdsWithin_mono
code: @[gcongr]
theorem nhdsWithin_mono (x : X) {s t : Set X} (h : s ⊆ t) : 𝓝[s] x ≤ 𝓝[t] x 
goal: 𝓝[s] x ≤ 𝓝[t] x

full_name: not_mem_closure_iff_nhdsWithin_eq_bot
code: lemma not_mem_closure_iff_nhdsWithin_eq_bot : x ∉ closure s ↔ 𝓝[s] x = ⊥ 
goal: x ∉ closure s ↔ 𝓝[s] x = ⊥

full_name: dense_compl_singleton
code: /-- If `x` is not an isolated point of a topological space, then `{x}ᶜ` is dense in the whole
space. -/
theorem dense_compl_singleton (x : X) [NeBot (𝓝[≠] x)] : Dense ({x}ᶜ : Set X) 
goal: Dense {x}ᶜ

full_name: closure_compl_singleton
code: /-- If `x` is not an isolated point of a topological space, then the closure of `{x}ᶜ` is the whole
space. -/
-- Porting note (#10618): was a `@[simp]` lemma but `simp` can prove it
theorem closure_compl_singleton (x : X) [NeBot (𝓝[≠] x)] : closure {x}ᶜ = (univ : Set X) 
goal: closure {x}ᶜ = Set.univ

full_name: interior_singleton
code: /-- If `x` is not an isolated point of a topological space, then the interior of `{x}` is empty. -/
@[simp]
theorem interior_singleton (x : X) [NeBot (𝓝[≠] x)] : interior {x} = (∅ : Set X) 
goal: interior {x} = ∅

full_name: not_isOpen_singleton
code: theorem not_isOpen_singleton (x : X) [NeBot (𝓝[≠] x)] : ¬IsOpen ({x} : Set X) 
goal: ¬IsOpen {x}

full_name: closure_eq_cluster_pts
code: theorem closure_eq_cluster_pts : closure s = { a | ClusterPt a (𝓟 s) } 
goal: closure s = {a | ClusterPt a (𝓟 s)}

full_name: mem_closure_iff_nhds
code: theorem mem_closure_iff_nhds : x ∈ closure s ↔ ∀ t ∈ 𝓝 x, (t ∩ s).Nonempty 
goal: x ∈ closure s ↔ ∀ t ∈ 𝓝 x, (t ∩ s).Nonempty

full_name: mem_closure_iff_nhds'
code: theorem mem_closure_iff_nhds' : x ∈ closure s ↔ ∀ t ∈ 𝓝 x, ∃ y : s, ↑y ∈ t 
goal: x ∈ closure s ↔ ∀ t ∈ 𝓝 x, ∃ y, ↑y ∈ t

full_name: mem_closure_iff_comap_neBot
code: theorem mem_closure_iff_comap_neBot :
    x ∈ closure s ↔ NeBot (comap ((↑) : s → X) (𝓝 x)) 
goal: x ∈ closure s ↔ (Filter.comap Subtype.val (𝓝 x)).NeBot

full_name: mem_closure_iff_nhds_basis'
code: theorem mem_closure_iff_nhds_basis' {p : ι → Prop} {s : ι → Set X} (h : (𝓝 x).HasBasis p s) :
    x ∈ closure t ↔ ∀ i, p i → (s i ∩ t).Nonempty 
goal: x ∈ closure t ↔ ∀ (i : ι), p i → (s i ∩ t).Nonempty

full_name: mem_closure_iff_nhds_basis
code: theorem mem_closure_iff_nhds_basis {p : ι → Prop} {s : ι → Set X} (h : (𝓝 x).HasBasis p s) :
    x ∈ closure t ↔ ∀ i, p i → ∃ y ∈ t, y ∈ s i 
goal: x ∈ closure t ↔ ∀ (i : ι), p i → ∃ y ∈ t, y ∈ s i

full_name: clusterPt_iff_forall_mem_closure
code: theorem clusterPt_iff_forall_mem_closure {F : Filter X} :
    ClusterPt x F ↔ ∀ s ∈ F, x ∈ closure s 
goal: ClusterPt x F ↔ ∀ s ∈ F, x ∈ closure s

full_name: clusterPt_iff_lift'_closure
code: theorem clusterPt_iff_lift'_closure {F : Filter X} :
    ClusterPt x F ↔ pure x ≤ (F.lift' closure) 
goal: ClusterPt x F ↔ pure x ≤ F.lift' closure

full_name: clusterPt_iff_lift'_closure'
code: theorem clusterPt_iff_lift'_closure' {F : Filter X} :
    ClusterPt x F ↔ (F.lift' closure ⊓ pure x).NeBot 
goal: ClusterPt x F ↔ (F.lift' closure ⊓ pure x).NeBot

full_name: clusterPt_lift'_closure_iff
code: @[simp]
theorem clusterPt_lift'_closure_iff {F : Filter X} :
    ClusterPt x (F.lift' closure) ↔ ClusterPt x F 
goal: ClusterPt x (F.lift' closure) ↔ ClusterPt x F

full_name: mem_closure_iff_ultrafilter
code: /-- `x` belongs to the closure of `s` if and only if some ultrafilter
  supported on `s` converges to `x`. -/
theorem mem_closure_iff_ultrafilter :
    x ∈ closure s ↔ ∃ u : Ultrafilter X, s ∈ u ∧ ↑u ≤ 𝓝 x 
goal: x ∈ closure s ↔ ∃ u, s ∈ u ∧ ↑u ≤ 𝓝 x

full_name: isClosed_iff_clusterPt
code: theorem isClosed_iff_clusterPt : IsClosed s ↔ ∀ a, ClusterPt a (𝓟 s) → a ∈ s 
goal: IsClosed s ↔ ∀ (a : X), ClusterPt a (𝓟 s) → a ∈ s

full_name: isClosed_iff_ultrafilter
code: theorem isClosed_iff_ultrafilter : IsClosed s ↔
    ∀ x, ∀ u : Ultrafilter X, ↑u ≤ 𝓝 x → s ∈ u → x ∈ s 
goal: IsClosed s ↔ ∀ (x : X) (u : Ultrafilter X), ↑u ≤ 𝓝 x → s ∈ u → x ∈ s

full_name: isClosed_iff_nhds
code: theorem isClosed_iff_nhds :
    IsClosed s ↔ ∀ x, (∀ U ∈ 𝓝 x, (U ∩ s).Nonempty) → x ∈ s 
goal: IsClosed s ↔ ∀ (x : X), (∀ U ∈ 𝓝 x, (U ∩ s).Nonempty) → x ∈ s

full_name: isClosed_iff_forall_filter
code: lemma isClosed_iff_forall_filter :
    IsClosed s ↔ ∀ x, ∀ F : Filter X, F.NeBot → F ≤ 𝓟 s → F ≤ 𝓝 x → x ∈ s 
goal: IsClosed s ↔ ∀ (x : X) (F : Filter X), F.NeBot → F ≤ 𝓟 s → F ≤ 𝓝 x → x ∈ s

full_name: IsClosed.interior_union_left
code: theorem IsClosed.interior_union_left (_ : IsClosed s) :
    interior (s ∪ t) ⊆ s ∪ interior t 
goal: IsClosed s → interior (s ∪ t) ⊆ s ∪ interior t

full_name: IsClosed.interior_union_right
code: theorem IsClosed.interior_union_right (h : IsClosed t) :
    interior (s ∪ t) ⊆ interior s ∪ t 
goal: interior (s ∪ t) ⊆ interior s ∪ t

full_name: IsOpen.inter_closure
code: theorem IsOpen.inter_closure (h : IsOpen s) : s ∩ closure t ⊆ closure (s ∩ t) 
goal: s ∩ closure t ⊆ closure (s ∩ t)

full_name: IsOpen.closure_inter
code: theorem IsOpen.closure_inter (h : IsOpen t) : closure s ∩ t ⊆ closure (s ∩ t) 
goal: closure s ∩ t ⊆ closure (s ∩ t)

full_name: Dense.open_subset_closure_inter
code: theorem Dense.open_subset_closure_inter (hs : Dense s) (ht : IsOpen t) :
    t ⊆ closure (t ∩ s) 
goal: t ⊆ closure (t ∩ s)

full_name: mem_closure_of_mem_closure_union
code: theorem mem_closure_of_mem_closure_union (h : x ∈ closure (s₁ ∪ s₂))
    (h₁ : s₁ᶜ ∈ 𝓝 x) : x ∈ closure s₂ 
goal: x ∈ closure s₂

full_name: Dense.inter_of_isOpen_left
code: /-- The intersection of an open dense set with a dense set is a dense set. -/
theorem Dense.inter_of_isOpen_left (hs : Dense s) (ht : Dense t) (hso : IsOpen s) :
    Dense (s ∩ t) 
goal: Dense (s ∩ t)

full_name: Dense.inter_of_isOpen_right
code: /-- The intersection of a dense set with an open dense set is a dense set. -/
theorem Dense.inter_of_isOpen_right (hs : Dense s) (ht : Dense t) (hto : IsOpen t) :
    Dense (s ∩ t) 
goal: Dense (s ∩ t)

full_name: Dense.inter_nhds_nonempty
code: theorem Dense.inter_nhds_nonempty (hs : Dense s) (ht : t ∈ 𝓝 x) :
    (s ∩ t).Nonempty 
goal: (s ∩ t).Nonempty

full_name: closure_diff
code: theorem closure_diff : closure s \ closure t ⊆ closure (s \ t) 
goal: closure s \ closure t ⊆ closure (s \ t)

full_name: Filter.Frequently.mem_of_closed
code: theorem Filter.Frequently.mem_of_closed (h : ∃ᶠ x in 𝓝 x, x ∈ s)
    (hs : IsClosed s) : x ∈ s 
goal: x ∈ s

full_name: IsClosed.mem_of_frequently_of_tendsto
code: theorem IsClosed.mem_of_frequently_of_tendsto {f : α → X} {b : Filter α}
    (hs : IsClosed s) (h : ∃ᶠ x in b, f x ∈ s) (hf : Tendsto f b (𝓝 x)) : x ∈ s 
goal: x ∈ s

full_name: IsClosed.mem_of_tendsto
code: theorem IsClosed.mem_of_tendsto {f : α → X} {b : Filter α} [NeBot b]
    (hs : IsClosed s) (hf : Tendsto f b (𝓝 x)) (h : ∀ᶠ x in b, f x ∈ s) : x ∈ s 
goal: x ∈ s

full_name: mem_closure_of_frequently_of_tendsto
code: theorem mem_closure_of_frequently_of_tendsto {f : α → X} {b : Filter α}
    (h : ∃ᶠ x in b, f x ∈ s) (hf : Tendsto f b (𝓝 x)) : x ∈ closure s 
goal: x ∈ closure s

full_name: mem_closure_of_tendsto
code: theorem mem_closure_of_tendsto {f : α → X} {b : Filter α} [NeBot b]
    (hf : Tendsto f b (𝓝 x)) (h : ∀ᶠ x in b, f x ∈ s) : x ∈ closure s 
goal: x ∈ closure s

full_name: tendsto_inf_principal_nhds_iff_of_forall_eq
code: /-- Suppose that `f` sends the complement to `s` to a single point `x`, and `l` is some filter.
Then `f` tends to `x` along `l` restricted to `s` if and only if it tends to `x` along `l`. -/
theorem tendsto_inf_principal_nhds_iff_of_forall_eq {f : α → X} {l : Filter α} {s : Set α}
    (h : ∀ a ∉ s, f a = x) : Tendsto f (l ⊓ 𝓟 s) (𝓝 x) ↔ Tendsto f l (𝓝 x) 
goal: Filter.Tendsto f (l ⊓ 𝓟 s) (𝓝 x) ↔ Filter.Tendsto f l (𝓝 x)

full_name: le_nhds_lim
code: /-- If a filter `f` is majorated by some `𝓝 x`, then it is majorated by `𝓝 (Filter.lim f)`. We
formulate this lemma with a `[Nonempty X]` argument of `lim` derived from `h` to make it useful for
types without a `[Nonempty X]` instance. Because of the built-in proof irrelevance, Lean will unify
this instance with any other instance. -/
theorem le_nhds_lim {f : Filter X} (h : ∃ x, f ≤ 𝓝 x) : f ≤ 𝓝 (@lim _ _ (nonempty_of_exists h) f) 
goal: f ≤ 𝓝 (lim f)

full_name: tendsto_nhds_limUnder
code: /-- If `g` tends to some `𝓝 x` along `f`, then it tends to `𝓝 (Filter.limUnder f g)`. We formulate
this lemma with a `[Nonempty X]` argument of `lim` derived from `h` to make it useful for types
without a `[Nonempty X]` instance. Because of the built-in proof irrelevance, Lean will unify this
instance with any other instance. -/
theorem tendsto_nhds_limUnder {f : Filter α} {g : α → X} (h : ∃ x, Tendsto g f (𝓝 x)) :
    Tendsto g f (𝓝 (@limUnder _ _ _ (nonempty_of_exists h) f g)) 
goal: Filter.Tendsto g f (𝓝 (limUnder f g))

full_name: continuous_def
code: theorem continuous_def {_ : TopologicalSpace X} {_ : TopologicalSpace Y} {f : X → Y} :
    Continuous f ↔ ∀ s, IsOpen s → IsOpen (f ⁻¹' s) 
goal: ∀ {x : TopologicalSpace X} {x_1 : TopologicalSpace Y} {f : X → Y},
  Continuous f ↔ ∀ (s : Set Y), IsOpen s → IsOpen (f ⁻¹' s)

full_name: IsOpen.preimage
code: theorem IsOpen.preimage (hf : Continuous f) {t : Set Y} (h : IsOpen t) :
    IsOpen (f ⁻¹' t) 
goal: IsOpen (f ⁻¹' t)

full_name: continuous_congr
code: theorem continuous_congr {g : X → Y} (h : ∀ x, f x = g x) :
    Continuous f ↔ Continuous g 
goal: Continuous f ↔ Continuous g

full_name: Continuous.congr
code: theorem Continuous.congr {g : X → Y} (h : Continuous f) (h' : ∀ x, f x = g x) : Continuous g 
goal: Continuous g

full_name: ContinuousAt.tendsto
code: theorem ContinuousAt.tendsto (h : ContinuousAt f x) :
    Tendsto f (𝓝 x) (𝓝 (f x)) 
goal: Filter.Tendsto f (𝓝 x) (𝓝 (f x))

full_name: continuousAt_def
code: theorem continuousAt_def : ContinuousAt f x ↔ ∀ A ∈ 𝓝 (f x), f ⁻¹' A ∈ 𝓝 x 
goal: ContinuousAt f x ↔ ∀ A ∈ 𝓝 (f x), f ⁻¹' A ∈ 𝓝 x

full_name: continuousAt_congr
code: theorem continuousAt_congr {g : X → Y} (h : f =ᶠ[𝓝 x] g) :
    ContinuousAt f x ↔ ContinuousAt g x 
goal: ContinuousAt f x ↔ ContinuousAt g x

full_name: ContinuousAt.congr
code: theorem ContinuousAt.congr {g : X → Y} (hf : ContinuousAt f x) (h : f =ᶠ[𝓝 x] g) :
    ContinuousAt g x 
goal: ContinuousAt g x

full_name: ContinuousAt.preimage_mem_nhds
code: theorem ContinuousAt.preimage_mem_nhds {t : Set Y} (h : ContinuousAt f x)
    (ht : t ∈ 𝓝 (f x)) : f ⁻¹' t ∈ 𝓝 x 
goal: f ⁻¹' t ∈ 𝓝 x

full_name: ContinuousAt.eventually_mem
code: /-- If `f x ∈ s ∈ 𝓝 (f x)` for continuous `f`, then `f y ∈ s` near `x`.

This is essentially `Filter.Tendsto.eventually_mem`, but infers in more cases when applied. -/
theorem ContinuousAt.eventually_mem {f : X → Y} {x : X} (hf : ContinuousAt f x) {s : Set Y}
    (hs : s ∈ 𝓝 (f x)) : ∀ᶠ y in 𝓝 x, f y ∈ s 
goal: ∀ᶠ (y : X) in 𝓝 x, f y ∈ s

full_name: eventuallyEq_zero_nhds
code: /-- Deprecated, please use `not_mem_tsupport_iff_eventuallyEq` instead. -/
@[deprecated (since := "2024-01-15")]
theorem eventuallyEq_zero_nhds {M₀} [Zero M₀] {f : X → M₀} :
    f =ᶠ[𝓝 x] 0 ↔ x ∉ closure (Function.support f) 
goal: f =ᶠ[𝓝 x] 0 ↔ x ∉ closure (Function.support f)

full_name: ClusterPt.map
code: theorem ClusterPt.map {lx : Filter X} {ly : Filter Y} (H : ClusterPt x lx)
    (hfc : ContinuousAt f x) (hf : Tendsto f lx ly) : ClusterPt (f x) ly 
goal: ClusterPt (f x) ly

full_name: preimage_interior_subset_interior_preimage
code: /-- See also `interior_preimage_subset_preimage_interior`. -/
theorem preimage_interior_subset_interior_preimage {t : Set Y} (hf : Continuous f) :
    f ⁻¹' interior t ⊆ interior (f ⁻¹' t) 
goal: f ⁻¹' interior t ⊆ interior (f ⁻¹' t)

full_name: continuous_id
code: @[continuity]
theorem continuous_id : Continuous (id : X → X) 
goal: Continuous id

full_name: continuous_id'
code: @[continuity, fun_prop]
theorem continuous_id' : Continuous (fun (x : X) => x) 
goal: Continuous fun x => x

full_name: Continuous.comp
code: theorem Continuous.comp {g : Y → Z} (hg : Continuous g) (hf : Continuous f) :
    Continuous (g ∘ f) 
goal: Continuous (g ∘ f)

full_name: Continuous.comp'
code: @[continuity, fun_prop]
theorem Continuous.comp' {g : Y → Z} (hg : Continuous g) (hf : Continuous f) :
    Continuous (fun x => g (f x)) 
goal: Continuous fun x => g (f x)

full_name: Continuous.iterate
code: theorem Continuous.iterate {f : X → X} (h : Continuous f) (n : ℕ) : Continuous f^[n] 
goal: Continuous f^[n]

full_name: ContinuousAt.comp
code: nonrec theorem ContinuousAt.comp {g : Y → Z} (hg : ContinuousAt g (f x))
    (hf : ContinuousAt f x) : ContinuousAt (g ∘ f) x 
goal: ContinuousAt (g ∘ f) x

full_name: ContinuousAt.comp'
code: @[fun_prop]
theorem ContinuousAt.comp' {g : Y → Z} {x : X} (hg : ContinuousAt g (f x))
    (hf : ContinuousAt f x) : ContinuousAt (fun x => g (f x)) x 
goal: ContinuousAt (fun x => g (f x)) x

full_name: ContinuousAt.comp_of_eq
code: /-- See note [comp_of_eq lemmas] -/
theorem ContinuousAt.comp_of_eq {g : Y → Z} (hg : ContinuousAt g y)
    (hf : ContinuousAt f x) (hy : f x = y) : ContinuousAt (g ∘ f) x 
goal: ContinuousAt (g ∘ f) x

full_name: Continuous.tendsto
code: theorem Continuous.tendsto (hf : Continuous f) (x) : Tendsto f (𝓝 x) (𝓝 (f x)) 
goal: Filter.Tendsto f (𝓝 x) (𝓝 (f x))

full_name: Continuous.tendsto'
code: /-- A version of `Continuous.tendsto` that allows one to specify a simpler form of the limit.
E.g., one can write `continuous_exp.tendsto' 0 1 exp_zero`. -/
theorem Continuous.tendsto' (hf : Continuous f) (x : X) (y : Y) (h : f x = y) :
    Tendsto f (𝓝 x) (𝓝 y) 
goal: Filter.Tendsto f (𝓝 x) (𝓝 y)

full_name: Continuous.continuousAt
code: @[fun_prop]
theorem Continuous.continuousAt (h : Continuous f) : ContinuousAt f x 
goal: ContinuousAt f x

full_name: continuous_iff_continuousAt
code: theorem continuous_iff_continuousAt : Continuous f ↔ ∀ x, ContinuousAt f x 
goal: Continuous f ↔ ∀ (x : X), ContinuousAt f x

full_name: continuousAt_const
code: @[fun_prop]
theorem continuousAt_const : ContinuousAt (fun _ : X => y) x 
goal: ContinuousAt (fun x => y) x

full_name: continuous_const
code: @[continuity, fun_prop]
theorem continuous_const : Continuous fun _ : X => y 
goal: Continuous fun x => y

full_name: Filter.EventuallyEq.continuousAt
code: theorem Filter.EventuallyEq.continuousAt (h : f =ᶠ[𝓝 x] fun _ => y) :
    ContinuousAt f x 
goal: ContinuousAt f x

full_name: continuous_of_const
code: theorem continuous_of_const (h : ∀ x y, f x = f y) : Continuous f 
goal: Continuous f

full_name: continuousAt_id
code: theorem continuousAt_id : ContinuousAt id x 
goal: ContinuousAt id x

full_name: continuousAt_id'
code: @[fun_prop]
theorem continuousAt_id' (y) : ContinuousAt (fun x : X => x) y 
goal: ContinuousAt (fun x => x) y

full_name: ContinuousAt.iterate
code: theorem ContinuousAt.iterate {f : X → X} (hf : ContinuousAt f x) (hx : f x = x) (n : ℕ) :
    ContinuousAt f^[n] x 
goal: ContinuousAt f^[n] x

full_name: continuous_iff_isClosed
code: theorem continuous_iff_isClosed : Continuous f ↔ ∀ s, IsClosed s → IsClosed (f ⁻¹' s) 
goal: Continuous f ↔ ∀ (s : Set Y), IsClosed s → IsClosed (f ⁻¹' s)

full_name: IsClosed.preimage
code: theorem IsClosed.preimage (hf : Continuous f) {t : Set Y} (h : IsClosed t) :
    IsClosed (f ⁻¹' t) 
goal: IsClosed (f ⁻¹' t)

full_name: mem_closure_image
code: theorem mem_closure_image (hf : ContinuousAt f x)
    (hx : x ∈ closure s) : f x ∈ closure (f '' s) 
goal: f x ∈ closure (f '' s)

full_name: continuousAt_iff_ultrafilter
code: theorem continuousAt_iff_ultrafilter :
    ContinuousAt f x ↔ ∀ g : Ultrafilter X, ↑g ≤ 𝓝 x → Tendsto f g (𝓝 (f x)) 
goal: ContinuousAt f x ↔ ∀ (g : Ultrafilter X), ↑g ≤ 𝓝 x → Filter.Tendsto f (↑g) (𝓝 (f x))

full_name: continuous_iff_ultrafilter
code: theorem continuous_iff_ultrafilter :
    Continuous f ↔ ∀ (x) (g : Ultrafilter X), ↑g ≤ 𝓝 x → Tendsto f g (𝓝 (f x)) 
goal: Continuous f ↔ ∀ (x : X) (g : Ultrafilter X), ↑g ≤ 𝓝 x → Filter.Tendsto f (↑g) (𝓝 (f x))

full_name: Continuous.closure_preimage_subset
code: theorem Continuous.closure_preimage_subset (hf : Continuous f) (t : Set Y) :
    closure (f ⁻¹' t) ⊆ f ⁻¹' closure t 
goal: closure (f ⁻¹' t) ⊆ f ⁻¹' closure t

full_name: Continuous.frontier_preimage_subset
code: theorem Continuous.frontier_preimage_subset (hf : Continuous f) (t : Set Y) :
    frontier (f ⁻¹' t) ⊆ f ⁻¹' frontier t 
goal: frontier (f ⁻¹' t) ⊆ f ⁻¹' frontier t

full_name: Set.MapsTo.closure
code: /-- If a continuous map `f` maps `s` to `t`, then it maps `closure s` to `closure t`. -/
protected theorem Set.MapsTo.closure {t : Set Y} (h : MapsTo f s t)
    (hc : Continuous f) : MapsTo f (closure s) (closure t) 
goal: Set.MapsTo f (closure s) (closure t)

full_name: image_closure_subset_closure_image
code: /-- See also `IsClosedMap.closure_image_eq_of_continuous`. -/
theorem image_closure_subset_closure_image (h : Continuous f) :
    f '' closure s ⊆ closure (f '' s) 
goal: f '' closure s ⊆ closure (f '' s)

full_name: closure_image_closure
code: theorem closure_image_closure (h : Continuous f) :
    closure (f '' closure s) = closure (f '' s) 
goal: closure (f '' closure s) = closure (f '' s)

full_name: closure_subset_preimage_closure_image
code: theorem closure_subset_preimage_closure_image (h : Continuous f) :
    closure s ⊆ f ⁻¹' closure (f '' s) 
goal: closure s ⊆ f ⁻¹' closure (f '' s)

full_name: map_mem_closure
code: theorem map_mem_closure {t : Set Y} (hf : Continuous f)
    (hx : x ∈ closure s) (ht : MapsTo f s t) : f x ∈ closure t 
goal: f x ∈ closure t

full_name: Set.MapsTo.closure_left
code: /-- If a continuous map `f` maps `s` to a closed set `t`, then it maps `closure s` to `t`. -/
theorem Set.MapsTo.closure_left {t : Set Y} (h : MapsTo f s t)
    (hc : Continuous f) (ht : IsClosed t) : MapsTo f (closure s) t 
goal: Set.MapsTo f (closure s) t

full_name: Filter.Tendsto.lift'_closure
code: theorem Filter.Tendsto.lift'_closure (hf : Continuous f) {l l'} (h : Tendsto f l l') :
    Tendsto f (l.lift' closure) (l'.lift' closure) 
goal: Filter.Tendsto f (l.lift' closure) (l'.lift' closure)

full_name: tendsto_lift'_closure_nhds
code: theorem tendsto_lift'_closure_nhds (hf : Continuous f) (x : X) :
    Tendsto f ((𝓝 x).lift' closure) ((𝓝 (f x)).lift' closure) 
goal: Filter.Tendsto f ((𝓝 x).lift' closure) ((𝓝 (f x)).lift' closure)

full_name: Function.Surjective.denseRange
code: /-- A surjective map has dense range. -/
theorem Function.Surjective.denseRange (hf : Function.Surjective f) : DenseRange f 
goal: DenseRange f

full_name: denseRange_id
code: theorem denseRange_id : DenseRange (id : X → X) 
goal: DenseRange id

full_name: denseRange_iff_closure_range
code: theorem denseRange_iff_closure_range : DenseRange f ↔ closure (range f) = univ 
goal: DenseRange f ↔ closure (Set.range f) = Set.univ

full_name: DenseRange.closure_range
code: theorem DenseRange.closure_range (h : DenseRange f) : closure (range f) = univ 
goal: closure (Set.range f) = Set.univ

full_name: denseRange_subtype_val
code: @[simp]
lemma denseRange_subtype_val {p : X → Prop} : DenseRange (@Subtype.val _ p) ↔ Dense {x | p x} 
goal: DenseRange Subtype.val ↔ Dense {x | p x}

full_name: Dense.denseRange_val
code: theorem Dense.denseRange_val (h : Dense s) : DenseRange ((↑) : s → X) 
goal: DenseRange Subtype.val

full_name: Continuous.range_subset_closure_image_dense
code: theorem Continuous.range_subset_closure_image_dense {f : X → Y} (hf : Continuous f)
    (hs : Dense s) : range f ⊆ closure (f '' s) 
goal: Set.range f ⊆ closure (f '' s)

full_name: DenseRange.dense_image
code: /-- The image of a dense set under a continuous map with dense range is a dense set. -/
theorem DenseRange.dense_image {f : X → Y} (hf' : DenseRange f) (hf : Continuous f)
    (hs : Dense s) : Dense (f '' s) 
goal: Dense (f '' s)

full_name: DenseRange.subset_closure_image_preimage_of_isOpen
code: /-- If `f` has dense range and `s` is an open set in the codomain of `f`, then the image of the
preimage of `s` under `f` is dense in `s`. -/
theorem DenseRange.subset_closure_image_preimage_of_isOpen (hf : DenseRange f) (hs : IsOpen s) :
    s ⊆ closure (f '' (f ⁻¹' s)) 
goal: s ⊆ closure (f '' (f ⁻¹' s))

full_name: DenseRange.dense_of_mapsTo
code: /-- If a continuous map with dense range maps a dense set to a subset of `t`, then `t` is a dense
set. -/
theorem DenseRange.dense_of_mapsTo {f : X → Y} (hf' : DenseRange f) (hf : Continuous f)
    (hs : Dense s) {t : Set Y} (ht : MapsTo f s t) : Dense t 
goal: Dense t

full_name: DenseRange.comp
code: /-- Composition of a continuous map with dense range and a function with dense range has dense
range. -/
theorem DenseRange.comp {g : Y → Z} {f : α → Y} (hg : DenseRange g) (hf : DenseRange f)
    (cg : Continuous g) : DenseRange (g ∘ f) 
goal: DenseRange (g ∘ f)

full_name: DenseRange.nonempty_iff
code: nonrec theorem DenseRange.nonempty_iff (hf : DenseRange f) : Nonempty α ↔ Nonempty X 
goal: Nonempty α ↔ Nonempty X

full_name: DenseRange.nonempty
code: theorem DenseRange.nonempty [h : Nonempty X] (hf : DenseRange f) : Nonempty α 
goal: Nonempty α

full_name: DenseRange.some
code: /-- Given a function `f : X → Y` with dense range and `y : Y`, returns some `x : X`. -/
def DenseRange.some (hf : DenseRange f) (x : X) : α 
goal: α

full_name: DenseRange.exists_mem_open
code: nonrec theorem DenseRange.exists_mem_open (hf : DenseRange f) (ho : IsOpen s) (hs : s.Nonempty) :
    ∃ a, f a ∈ s 
goal: ∃ a, f a ∈ s

full_name: DenseRange.mem_nhds
code: theorem DenseRange.mem_nhds (h : DenseRange f) (hs : s ∈ 𝓝 x) :
    ∃ a, f a ∈ s 
goal: ∃ a, f a ∈ s