File: Mathlib/Topology/Separation.lean

full_name: SeparatedNhds
code: /--
`SeparatedNhds` is a predicate on pairs of sub`Set`s of a topological space.  It holds if the two
sub`Set`s are contained in disjoint open sets.
-/
def SeparatedNhds : Set X → Set X → Prop 
goal: Set X → Set X → Prop

full_name: separatedNhds_iff_disjoint
code: theorem separatedNhds_iff_disjoint {s t : Set X} : SeparatedNhds s t ↔ Disjoint (𝓝ˢ s) (𝓝ˢ t) 
goal: SeparatedNhds s t ↔ Disjoint (𝓝ˢ s) (𝓝ˢ t)

full_name: HasSeparatingCover
code: /-- `HasSeparatingCover`s can be useful witnesses for `SeparatedNhds`. -/
def HasSeparatingCover : Set X → Set X → Prop 
goal: Set X → Set X → Prop

full_name: hasSeparatingCovers_iff_separatedNhds
code: /-- Used to prove that a regular topological space with Lindelöf topology is a normal space,
and (todo) a perfectly normal space is a completely normal space. -/
theorem hasSeparatingCovers_iff_separatedNhds {s t : Set X} :
    HasSeparatingCover s t ∧ HasSeparatingCover t s ↔ SeparatedNhds s t 
goal: HasSeparatingCover s t ∧ HasSeparatingCover t s ↔ SeparatedNhds s t

full_name: Set.hasSeparatingCover_empty_left
code: theorem Set.hasSeparatingCover_empty_left (s : Set X) : HasSeparatingCover ∅ s 
goal: HasSeparatingCover ∅ s

full_name: Set.hasSeparatingCover_empty_right
code: theorem Set.hasSeparatingCover_empty_right (s : Set X) : HasSeparatingCover s ∅ 
goal: HasSeparatingCover s ∅

full_name: HasSeparatingCover.mono
code: theorem HasSeparatingCover.mono {s₁ s₂ t₁ t₂ : Set X} (sc_st : HasSeparatingCover s₂ t₂)
    (s_sub : s₁ ⊆ s₂) (t_sub : t₁ ⊆ t₂) : HasSeparatingCover s₁ t₁ 
goal: HasSeparatingCover s₁ t₁

full_name: SeparatedNhds.symm
code: @[symm]
theorem symm : SeparatedNhds s t → SeparatedNhds t s 
goal: SeparatedNhds s t → SeparatedNhds t s

full_name: SeparatedNhds.comm
code: theorem comm (s t : Set X) : SeparatedNhds s t ↔ SeparatedNhds t s 
goal: SeparatedNhds s t ↔ SeparatedNhds t s

full_name: SeparatedNhds.preimage
code: theorem preimage [TopologicalSpace Y] {f : X → Y} {s t : Set Y} (h : SeparatedNhds s t)
    (hf : Continuous f) : SeparatedNhds (f ⁻¹' s) (f ⁻¹' t) 
goal: SeparatedNhds (f ⁻¹' s) (f ⁻¹' t)

full_name: SeparatedNhds.disjoint
code: protected theorem disjoint (h : SeparatedNhds s t) : Disjoint s t 
goal: Disjoint s t

full_name: SeparatedNhds.disjoint_closure_left
code: theorem disjoint_closure_left (h : SeparatedNhds s t) : Disjoint (closure s) t 
goal: Disjoint (closure s) t

full_name: SeparatedNhds.disjoint_closure_right
code: theorem disjoint_closure_right (h : SeparatedNhds s t) : Disjoint s (closure t) 
goal: Disjoint s (closure t)

full_name: SeparatedNhds.empty_right
code: @[simp] theorem empty_right (s : Set X) : SeparatedNhds s ∅ 
goal: SeparatedNhds s ∅

full_name: SeparatedNhds.empty_left
code: @[simp] theorem empty_left (s : Set X) : SeparatedNhds ∅ s 
goal: SeparatedNhds ∅ s

full_name: SeparatedNhds.mono
code: theorem mono (h : SeparatedNhds s₂ t₂) (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : SeparatedNhds s₁ t₁ 
goal: SeparatedNhds s₁ t₁

full_name: SeparatedNhds.union_left
code: theorem union_left : SeparatedNhds s u → SeparatedNhds t u → SeparatedNhds (s ∪ t) u 
goal: SeparatedNhds s u → SeparatedNhds t u → SeparatedNhds (s ∪ t) u

full_name: SeparatedNhds.union_right
code: theorem union_right (ht : SeparatedNhds s t) (hu : SeparatedNhds s u) : SeparatedNhds s (t ∪ u) 
goal: SeparatedNhds s (t ∪ u)

full_name: T0Space.t0
code: /-- A T₀ space, also known as a Kolmogorov space, is a topological space such that for every pair
`x ≠ y`, there is an open set containing one but not the other. We formulate the definition in terms
of the `Inseparable` relation.  -/
class T0Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- Two inseparable points in a T₀ space are equal. -/
  t0 : ∀ ⦃x y : X⦄, Inseparable x y → x = y
goal: Inseparable x y → x = y

full_name: T0Space
code: /-- A T₀ space, also known as a Kolmogorov space, is a topological space such that for every pair
`x ≠ y`, there is an open set containing one but not the other. We formulate the definition in terms
of the `Inseparable` relation.  -/
class T0Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- Two inseparable points in a T₀ space are equal. -/
  t0 : ∀ ⦃x y : X⦄, Inseparable x y → x = y
goal: Prop

full_name: t0Space_iff_inseparable
code: theorem t0Space_iff_inseparable (X : Type u) [TopologicalSpace X] :
    T0Space X ↔ ∀ x y : X, Inseparable x y → x = y 
goal: T0Space X ↔ ∀ (x y : X), Inseparable x y → x = y

full_name: t0Space_iff_not_inseparable
code: theorem t0Space_iff_not_inseparable (X : Type u) [TopologicalSpace X] :
    T0Space X ↔ Pairwise fun x y : X => ¬Inseparable x y 
goal: T0Space X ↔ Pairwise fun x y => ¬Inseparable x y

full_name: Inseparable.eq
code: theorem Inseparable.eq [T0Space X] {x y : X} (h : Inseparable x y) : x = y 
goal: x = y

full_name: Inducing.injective
code: /-- A topology `Inducing` map from a T₀ space is injective. -/
protected theorem Inducing.injective [TopologicalSpace Y] [T0Space X] {f : X → Y}
    (hf : Inducing f) : Injective f 
goal: Function.Injective f

full_name: Inducing.embedding
code: /-- A topology `Inducing` map from a T₀ space is a topological embedding. -/
protected theorem Inducing.embedding [TopologicalSpace Y] [T0Space X] {f : X → Y}
    (hf : Inducing f) : Embedding f 
goal: Embedding f

full_name: embedding_iff_inducing
code: lemma embedding_iff_inducing [TopologicalSpace Y] [T0Space X] {f : X → Y} :
    Embedding f ↔ Inducing f 
goal: Embedding f ↔ Inducing f

full_name: t0Space_iff_nhds_injective
code: theorem t0Space_iff_nhds_injective (X : Type u) [TopologicalSpace X] :
    T0Space X ↔ Injective (𝓝 : X → Filter X) 
goal: T0Space X ↔ Function.Injective 𝓝

full_name: nhds_injective
code: theorem nhds_injective [T0Space X] : Injective (𝓝 : X → Filter X) 
goal: Function.Injective 𝓝

full_name: inseparable_iff_eq
code: theorem inseparable_iff_eq [T0Space X] {x y : X} : Inseparable x y ↔ x = y 
goal: Inseparable x y ↔ x = y

full_name: nhds_eq_nhds_iff
code: @[simp]
theorem nhds_eq_nhds_iff [T0Space X] {a b : X} : 𝓝 a = 𝓝 b ↔ a = b 
goal: 𝓝 a = 𝓝 b ↔ a = b

full_name: inseparable_eq_eq
code: @[simp]
theorem inseparable_eq_eq [T0Space X] : Inseparable = @Eq X 
goal: Inseparable = Eq

full_name: TopologicalSpace.IsTopologicalBasis.inseparable_iff
code: theorem TopologicalSpace.IsTopologicalBasis.inseparable_iff {b : Set (Set X)}
    (hb : IsTopologicalBasis b) {x y : X} : Inseparable x y ↔ ∀ s ∈ b, (x ∈ s ↔ y ∈ s) 
goal: Inseparable x y ↔ ∀ s ∈ b, x ∈ s ↔ y ∈ s

full_name: TopologicalSpace.IsTopologicalBasis.eq_iff
code: theorem TopologicalSpace.IsTopologicalBasis.eq_iff [T0Space X] {b : Set (Set X)}
    (hb : IsTopologicalBasis b) {x y : X} : x = y ↔ ∀ s ∈ b, (x ∈ s ↔ y ∈ s) 
goal: x = y ↔ ∀ s ∈ b, x ∈ s ↔ y ∈ s

full_name: t0Space_iff_exists_isOpen_xor'_mem
code: theorem t0Space_iff_exists_isOpen_xor'_mem (X : Type u) [TopologicalSpace X] :
    T0Space X ↔ Pairwise fun x y => ∃ U : Set X, IsOpen U ∧ Xor' (x ∈ U) (y ∈ U) 
goal: T0Space X ↔ Pairwise fun x y => ∃ U, IsOpen U ∧ Xor' (x ∈ U) (y ∈ U)

full_name: exists_isOpen_xor'_mem
code: theorem exists_isOpen_xor'_mem [T0Space X] {x y : X} (h : x ≠ y) :
    ∃ U : Set X, IsOpen U ∧ Xor' (x ∈ U) (y ∈ U) 
goal: ∃ U, IsOpen U ∧ Xor' (x ∈ U) (y ∈ U)

full_name: specializationOrder
code: /-- Specialization forms a partial order on a t0 topological space. -/
def specializationOrder (X) [TopologicalSpace X] [T0Space X] : PartialOrder X 
goal: PartialOrder X

full_name: SeparationQuotient.instT0Space
code: instance SeparationQuotient.instT0Space : T0Space (SeparationQuotient X) 
goal: T0Space (SeparationQuotient X)

full_name: minimal_nonempty_closed_subsingleton
code: theorem minimal_nonempty_closed_subsingleton [T0Space X] {s : Set X} (hs : IsClosed s)
    (hmin : ∀ t, t ⊆ s → t.Nonempty → IsClosed t → t = s) : s.Subsingleton 
goal: s.Subsingleton

full_name: minimal_nonempty_closed_eq_singleton
code: theorem minimal_nonempty_closed_eq_singleton [T0Space X] {s : Set X} (hs : IsClosed s)
    (hne : s.Nonempty) (hmin : ∀ t, t ⊆ s → t.Nonempty → IsClosed t → t = s) : ∃ x, s = {x} 
goal: ∃ x, s = {x}

full_name: IsClosed.exists_closed_singleton
code: /-- Given a closed set `S` in a compact T₀ space, there is some `x ∈ S` such that `{x}` is
closed. -/
theorem IsClosed.exists_closed_singleton [T0Space X] [CompactSpace X] {S : Set X}
    (hS : IsClosed S) (hne : S.Nonempty) : ∃ x : X, x ∈ S ∧ IsClosed ({x} : Set X) 
goal: ∃ x ∈ S, IsClosed {x}

full_name: minimal_nonempty_open_subsingleton
code: theorem minimal_nonempty_open_subsingleton [T0Space X] {s : Set X} (hs : IsOpen s)
    (hmin : ∀ t, t ⊆ s → t.Nonempty → IsOpen t → t = s) : s.Subsingleton 
goal: s.Subsingleton

full_name: minimal_nonempty_open_eq_singleton
code: theorem minimal_nonempty_open_eq_singleton [T0Space X] {s : Set X} (hs : IsOpen s)
    (hne : s.Nonempty) (hmin : ∀ t, t ⊆ s → t.Nonempty → IsOpen t → t = s) : ∃ x, s = {x} 
goal: ∃ x, s = {x}

full_name: exists_isOpen_singleton_of_isOpen_finite
code: /-- Given an open finite set `S` in a T₀ space, there is some `x ∈ S` such that `{x}` is open. -/
theorem exists_isOpen_singleton_of_isOpen_finite [T0Space X] {s : Set X} (hfin : s.Finite)
    (hne : s.Nonempty) (ho : IsOpen s) : ∃ x ∈ s, IsOpen ({x} : Set X) 
goal: ∃ x ∈ s, IsOpen {x}

full_name: exists_open_singleton_of_finite
code: theorem exists_open_singleton_of_finite [T0Space X] [Finite X] [Nonempty X] :
    ∃ x : X, IsOpen ({x} : Set X) 
goal: ∃ x, IsOpen {x}

full_name: t0Space_of_injective_of_continuous
code: theorem t0Space_of_injective_of_continuous [TopologicalSpace Y] {f : X → Y}
    (hf : Function.Injective f) (hf' : Continuous f) [T0Space Y] : T0Space X 
goal: T0Space X

full_name: Embedding.t0Space
code: protected theorem Embedding.t0Space [TopologicalSpace Y] [T0Space Y] {f : X → Y}
    (hf : Embedding f) : T0Space X 
goal: T0Space X

full_name: Subtype.t0Space
code: instance Subtype.t0Space [T0Space X] {p : X → Prop} : T0Space (Subtype p) 
goal: T0Space (Subtype p)

full_name: t0Space_iff_or_not_mem_closure
code: theorem t0Space_iff_or_not_mem_closure (X : Type u) [TopologicalSpace X] :
    T0Space X ↔ Pairwise fun a b : X => a ∉ closure ({b} : Set X) ∨ b ∉ closure ({a} : Set X) 
goal: T0Space X ↔ Pairwise fun a b => a ∉ closure {b} ∨ b ∉ closure {a}

full_name: Prod.instT0Space
code: instance Prod.instT0Space [TopologicalSpace Y] [T0Space X] [T0Space Y] : T0Space (X × Y) 
goal: T0Space (X × Y)

full_name: Pi.instT0Space
code: instance Pi.instT0Space {ι : Type*} {X : ι → Type*} [∀ i, TopologicalSpace (X i)]
    [∀ i, T0Space (X i)] :
    T0Space (∀ i, X i) 
goal: T0Space ((i : ι) → X i)

full_name: ULift.instT0Space
code: instance ULift.instT0Space [T0Space X] : T0Space (ULift X) 
goal: T0Space (ULift.{u_3, u_1} X)

full_name: T0Space.of_cover
code: theorem T0Space.of_cover (h : ∀ x y, Inseparable x y → ∃ s : Set X, x ∈ s ∧ y ∈ s ∧ T0Space s) :
    T0Space X 
goal: T0Space X

full_name: T0Space.of_open_cover
code: theorem T0Space.of_open_cover (h : ∀ x, ∃ s : Set X, x ∈ s ∧ IsOpen s ∧ T0Space s) : T0Space X 
goal: T0Space X

full_name: R0Space
code: /-- A topological space is called an R₀ space, if `Specializes` relation is symmetric.

In other words, given two points `x y : X`,
if every neighborhood of `y` contains `x`, then every neighborhood of `x` contains `y`. -/
@[mk_iff]
class R0Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- In an R₀ space, the `Specializes` relation is symmetric. -/
  specializes_symmetric : Symmetric (Specializes : X → X → Prop)
goal: Prop

full_name: R0Space.specializes_symmetric
code: /-- A topological space is called an R₀ space, if `Specializes` relation is symmetric.

In other words, given two points `x y : X`,
if every neighborhood of `y` contains `x`, then every neighborhood of `x` contains `y`. -/
@[mk_iff]
class R0Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- In an R₀ space, the `Specializes` relation is symmetric. -/
  specializes_symmetric : Symmetric (Specializes : X → X → Prop)
goal: Symmetric Specializes

full_name: r0Space_iff
code: /-- A topological space is called an R₀ space, if `Specializes` relation is symmetric.

In other words, given two points `x y : X`,
if every neighborhood of `y` contains `x`, then every neighborhood of `x` contains `y`. -/
@[mk_iff]
class R0Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- In an R₀ space, the `Specializes` relation is symmetric. -/
  specializes_symmetric : Symmetric (Specializes : X → X → Prop)
goal: R0Space X ↔ Symmetric Specializes

full_name: Specializes.symm
code: /-- In an R₀ space, the `Specializes` relation is symmetric, dot notation version. -/
theorem Specializes.symm (h : x ⤳ y) : y ⤳ x 
goal: y ⤳ x

full_name: specializes_comm
code: /-- In an R₀ space, the `Specializes` relation is symmetric, `Iff` version. -/
theorem specializes_comm : x ⤳ y ↔ y ⤳ x 
goal: x ⤳ y ↔ y ⤳ x

full_name: specializes_iff_inseparable
code: /-- In an R₀ space, `Specializes` is equivalent to `Inseparable`. -/
theorem specializes_iff_inseparable : x ⤳ y ↔ Inseparable x y 
goal: x ⤳ y ↔ Inseparable x y

full_name: Inducing.r0Space
code: theorem Inducing.r0Space [TopologicalSpace Y] {f : Y → X} (hf : Inducing f) : R0Space Y 
goal: R0Space Y

full_name: instR0SpaceSubtype
code: instance {p : X → Prop} : R0Space {x // p x} 
goal: R0Space { x // p x }

full_name: instR0SpaceProd
code: instance [TopologicalSpace Y] [R0Space Y] : R0Space (X × Y) 
goal: R0Space (X × Y)

full_name: instR0SpaceForall
code: instance {ι : Type*} {X : ι → Type*} [∀ i, TopologicalSpace (X i)] [∀ i, R0Space (X i)] :
    R0Space (∀ i, X i) 
goal: R0Space ((i : ι) → X i)

full_name: isCompact_closure_singleton
code: /-- In an R₀ space, the closure of a singleton is a compact set. -/
theorem isCompact_closure_singleton : IsCompact (closure {x}) 
goal: IsCompact (closure {x})

full_name: Filter.coclosedCompact_le_cofinite
code: theorem Filter.coclosedCompact_le_cofinite : coclosedCompact X ≤ cofinite 
goal: Filter.coclosedCompact X ≤ Filter.cofinite

full_name: Bornology.relativelyCompact
code: /-- In an R₀ space, relatively compact sets form a bornology.
Its cobounded filter is `Filter.coclosedCompact`.
See also `Bornology.inCompact` the bornology of sets contained in a compact set. -/
def Bornology.relativelyCompact : Bornology X 
goal: Bornology X

full_name: Bornology.relativelyCompact.isBounded_iff
code: theorem Bornology.relativelyCompact.isBounded_iff {s : Set X} :
    @Bornology.IsBounded _ (Bornology.relativelyCompact X) s ↔ IsCompact (closure s) 
goal: Bornology.IsBounded s ↔ IsCompact (closure s)

full_name: Set.Finite.isCompact_closure
code: /-- In an R₀ space, the closure of a finite set is a compact set. -/
theorem Set.Finite.isCompact_closure {s : Set X} (hs : s.Finite) : IsCompact (closure s) 
goal: IsCompact (closure s)

full_name: T1Space
code: /-- A T₁ space, also known as a Fréchet space, is a topological space
  where every singleton set is closed. Equivalently, for every pair
  `x ≠ y`, there is an open set containing `x` and not `y`. -/
class T1Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- A singleton in a T₁ space is a closed set. -/
  t1 : ∀ x, IsClosed ({x} : Set X)
goal: Prop

full_name: T1Space.t1
code: /-- A T₁ space, also known as a Fréchet space, is a topological space
  where every singleton set is closed. Equivalently, for every pair
  `x ≠ y`, there is an open set containing `x` and not `y`. -/
class T1Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- A singleton in a T₁ space is a closed set. -/
  t1 : ∀ x, IsClosed ({x} : Set X)
goal: IsClosed {x}

full_name: isClosed_singleton
code: theorem isClosed_singleton [T1Space X] {x : X} : IsClosed ({x} : Set X) 
goal: IsClosed {x}

full_name: isOpen_compl_singleton
code: theorem isOpen_compl_singleton [T1Space X] {x : X} : IsOpen ({x}ᶜ : Set X) 
goal: IsOpen {x}ᶜ

full_name: isOpen_ne
code: theorem isOpen_ne [T1Space X] {x : X} : IsOpen { y | y ≠ x } 
goal: IsOpen {y | y ≠ x}

full_name: Continuous.isOpen_mulSupport
code: @[to_additive]
theorem Continuous.isOpen_mulSupport [T1Space X] [One X] [TopologicalSpace Y] {f : Y → X}
    (hf : Continuous f) : IsOpen (mulSupport f) 
goal: IsOpen (Function.mulSupport f)

full_name: Continuous.isOpen_support
code: @[to_additive]
theorem Continuous.isOpen_mulSupport [T1Space X] [One X] [TopologicalSpace Y] {f : Y → X}
    (hf : Continuous f) : IsOpen (mulSupport f) 
goal: IsOpen (Function.support f)

full_name: Ne.nhdsWithin_compl_singleton
code: theorem Ne.nhdsWithin_compl_singleton [T1Space X] {x y : X} (h : x ≠ y) : 𝓝[{y}ᶜ] x = 𝓝 x 
goal: 𝓝[{y}ᶜ] x = 𝓝 x

full_name: Ne.nhdsWithin_diff_singleton
code: theorem Ne.nhdsWithin_diff_singleton [T1Space X] {x y : X} (h : x ≠ y) (s : Set X) :
    𝓝[s \ {y}] x = 𝓝[s] x 
goal: 𝓝[s \ {y}] x = 𝓝[s] x

full_name: nhdsWithin_compl_singleton_le
code: lemma nhdsWithin_compl_singleton_le [T1Space X] (x y : X) : 𝓝[{x}ᶜ] x ≤ 𝓝[{y}ᶜ] x 
goal: 𝓝[≠] x ≤ 𝓝[{y}ᶜ] x

full_name: isOpen_setOf_eventually_nhdsWithin
code: theorem isOpen_setOf_eventually_nhdsWithin [T1Space X] {p : X → Prop} :
    IsOpen { x | ∀ᶠ y in 𝓝[≠] x, p y } 
goal: IsOpen {x | ∀ᶠ (y : X) in 𝓝[≠] x, p y}

full_name: Set.Finite.isClosed
code: protected theorem Set.Finite.isClosed [T1Space X] {s : Set X} (hs : Set.Finite s) : IsClosed s 
goal: IsClosed s

full_name: TopologicalSpace.IsTopologicalBasis.exists_mem_of_ne
code: theorem TopologicalSpace.IsTopologicalBasis.exists_mem_of_ne [T1Space X] {b : Set (Set X)}
    (hb : IsTopologicalBasis b) {x y : X} (h : x ≠ y) : ∃ a ∈ b, x ∈ a ∧ y ∉ a 
goal: ∃ a ∈ b, x ∈ a ∧ y ∉ a

full_name: Finset.isClosed
code: protected theorem Finset.isClosed [T1Space X] (s : Finset X) : IsClosed (s : Set X) 
goal: IsClosed ↑s

full_name: t1Space_TFAE
code: theorem t1Space_TFAE (X : Type u) [TopologicalSpace X] :
    List.TFAE [T1Space X,
      ∀ x, IsClosed ({ x } : Set X),
      ∀ x, IsOpen ({ x }ᶜ : Set X),
      Continuous (@CofiniteTopology.of X),
      ∀ ⦃x y : X⦄, x ≠ y → {y}ᶜ ∈ 𝓝 x,
      ∀ ⦃x y : X⦄, x ≠ y → ∃ s ∈ 𝓝 x, y ∉ s,
      ∀ ⦃x y : X⦄, x ≠ y → ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ y ∉ U,
      ∀ ⦃x y : X⦄, x ≠ y → Disjoint (𝓝 x) (pure y),
      ∀ ⦃x y : X⦄, x ≠ y → Disjoint (pure x) (𝓝 y),
      ∀ ⦃x y : X⦄, x ⤳ y → x = y] 
goal: [T1Space X, ∀ (x : X), IsClosed {x}, ∀ (x : X), IsOpen {x}ᶜ, Continuous ⇑CofiniteTopology.of,
    ∀ ⦃x y : X⦄, x ≠ y → {y}ᶜ ∈ 𝓝 x, ∀ ⦃x y : X⦄, x ≠ y → ∃ s ∈ 𝓝 x, y ∉ s,
    ∀ ⦃x y : X⦄, x ≠ y → ∃ U, IsOpen U ∧ x ∈ U ∧ y ∉ U, ∀ ⦃x y : X⦄, x ≠ y → Disjoint (𝓝 x) (pure y),
    ∀ ⦃x y : X⦄, x ≠ y → Disjoint (pure x) (𝓝 y), ∀ ⦃x y : X⦄, x ⤳ y → x = y].TFAE

full_name: t1Space_iff_continuous_cofinite_of
code: theorem t1Space_iff_continuous_cofinite_of : T1Space X ↔ Continuous (@CofiniteTopology.of X) 
goal: T1Space X ↔ Continuous ⇑CofiniteTopology.of

full_name: CofiniteTopology.continuous_of
code: theorem CofiniteTopology.continuous_of [T1Space X] : Continuous (@CofiniteTopology.of X) 
goal: Continuous ⇑CofiniteTopology.of

full_name: t1Space_iff_exists_open
code: theorem t1Space_iff_exists_open :
    T1Space X ↔ Pairwise fun x y => ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ y ∉ U 
goal: T1Space X ↔ Pairwise fun x y => ∃ U, IsOpen U ∧ x ∈ U ∧ y ∉ U

full_name: t1Space_iff_disjoint_pure_nhds
code: theorem t1Space_iff_disjoint_pure_nhds : T1Space X ↔ ∀ ⦃x y : X⦄, x ≠ y → Disjoint (pure x) (𝓝 y) 
goal: T1Space X ↔ ∀ ⦃x y : X⦄, x ≠ y → Disjoint (pure x) (𝓝 y)

full_name: t1Space_iff_disjoint_nhds_pure
code: theorem t1Space_iff_disjoint_nhds_pure : T1Space X ↔ ∀ ⦃x y : X⦄, x ≠ y → Disjoint (𝓝 x) (pure y) 
goal: T1Space X ↔ ∀ ⦃x y : X⦄, x ≠ y → Disjoint (𝓝 x) (pure y)

full_name: t1Space_iff_specializes_imp_eq
code: theorem t1Space_iff_specializes_imp_eq : T1Space X ↔ ∀ ⦃x y : X⦄, x ⤳ y → x = y 
goal: T1Space X ↔ ∀ ⦃x y : X⦄, x ⤳ y → x = y

full_name: disjoint_pure_nhds
code: theorem disjoint_pure_nhds [T1Space X] {x y : X} (h : x ≠ y) : Disjoint (pure x) (𝓝 y) 
goal: Disjoint (pure x) (𝓝 y)

full_name: disjoint_nhds_pure
code: theorem disjoint_nhds_pure [T1Space X] {x y : X} (h : x ≠ y) : Disjoint (𝓝 x) (pure y) 
goal: Disjoint (𝓝 x) (pure y)

full_name: Specializes.eq
code: theorem Specializes.eq [T1Space X] {x y : X} (h : x ⤳ y) : x = y 
goal: x = y

full_name: specializes_iff_eq
code: theorem specializes_iff_eq [T1Space X] {x y : X} : x ⤳ y ↔ x = y 
goal: x ⤳ y ↔ x = y

full_name: specializes_eq_eq
code: @[simp] theorem specializes_eq_eq [T1Space X] : (· ⤳ ·) = @Eq X 
goal: (fun x x_1 => x ⤳ x_1) = Eq

full_name: pure_le_nhds_iff
code: @[simp]
theorem pure_le_nhds_iff [T1Space X] {a b : X} : pure a ≤ 𝓝 b ↔ a = b 
goal: pure a ≤ 𝓝 b ↔ a = b

full_name: nhds_le_nhds_iff
code: @[simp]
theorem nhds_le_nhds_iff [T1Space X] {a b : X} : 𝓝 a ≤ 𝓝 b ↔ a = b 
goal: 𝓝 a ≤ 𝓝 b ↔ a = b

full_name: instR0SpaceOfT1Space
code: instance (priority := 100) [T1Space X] : R0Space X 
goal: R0Space X

full_name: instT1SpaceCofiniteTopology
code: instance : T1Space (CofiniteTopology X) 
goal: T1Space (CofiniteTopology X)

full_name: t1Space_antitone
code: theorem t1Space_antitone : Antitone (@T1Space X) 
goal: Antitone (@T1Space X)

full_name: continuousWithinAt_update_of_ne
code: theorem continuousWithinAt_update_of_ne [T1Space X] [DecidableEq X] [TopologicalSpace Y] {f : X → Y}
    {s : Set X} {x x' : X} {y : Y} (hne : x' ≠ x) :
    ContinuousWithinAt (Function.update f x y) s x' ↔ ContinuousWithinAt f s x' 
goal: ContinuousWithinAt (Function.update f x y) s x' ↔ ContinuousWithinAt f s x'

full_name: continuousAt_update_of_ne
code: theorem continuousAt_update_of_ne [T1Space X] [DecidableEq X] [TopologicalSpace Y]
    {f : X → Y} {x x' : X} {y : Y} (hne : x' ≠ x) :
    ContinuousAt (Function.update f x y) x' ↔ ContinuousAt f x' 
goal: ContinuousAt (Function.update f x y) x' ↔ ContinuousAt f x'

full_name: continuousOn_update_iff
code: theorem continuousOn_update_iff [T1Space X] [DecidableEq X] [TopologicalSpace Y] {f : X → Y}
    {s : Set X} {x : X} {y : Y} :
    ContinuousOn (Function.update f x y) s ↔
      ContinuousOn f (s \ {x}) ∧ (x ∈ s → Tendsto f (𝓝[s \ {x}] x) (𝓝 y)) 
goal: ContinuousOn (Function.update f x y) s ↔ ContinuousOn f (s \ {x}) ∧ (x ∈ s → Filter.Tendsto f (𝓝[s \ {x}] x) (𝓝 y))

full_name: t1Space_of_injective_of_continuous
code: theorem t1Space_of_injective_of_continuous [TopologicalSpace Y] {f : X → Y}
    (hf : Function.Injective f) (hf' : Continuous f) [T1Space Y] : T1Space X 
goal: T1Space X

full_name: Embedding.t1Space
code: protected theorem Embedding.t1Space [TopologicalSpace Y] [T1Space Y] {f : X → Y}
    (hf : Embedding f) : T1Space X 
goal: T1Space X

full_name: Subtype.t1Space
code: instance Subtype.t1Space {X : Type u} [TopologicalSpace X] [T1Space X] {p : X → Prop} :
    T1Space (Subtype p) 
goal: T1Space (Subtype p)

full_name: instT1SpaceProd
code: instance [TopologicalSpace Y] [T1Space X] [T1Space Y] : T1Space (X × Y) 
goal: T1Space (X × Y)

full_name: instT1SpaceForall
code: instance {ι : Type*} {X : ι → Type*} [∀ i, TopologicalSpace (X i)] [∀ i, T1Space (X i)] :
    T1Space (∀ i, X i) 
goal: T1Space ((i : ι) → X i)

full_name: ULift.instT1Space
code: instance ULift.instT1Space [T1Space X] : T1Space (ULift X) 
goal: T1Space (ULift.{u_3, u_1} X)

full_name: TotallyDisconnectedSpace.t1Space
code: instance (priority := 100) TotallyDisconnectedSpace.t1Space [h : TotallyDisconnectedSpace X] :
    T1Space X 
goal: T1Space X

full_name: T1Space.t0Space
code: instance (priority := 100) T1Space.t0Space [T1Space X] : T0Space X 
goal: T0Space X

full_name: compl_singleton_mem_nhds_iff
code: @[simp]
theorem compl_singleton_mem_nhds_iff [T1Space X] {x y : X} : {x}ᶜ ∈ 𝓝 y ↔ y ≠ x 
goal: {x}ᶜ ∈ 𝓝 y ↔ y ≠ x

full_name: compl_singleton_mem_nhds
code: theorem compl_singleton_mem_nhds [T1Space X] {x y : X} (h : y ≠ x) : {x}ᶜ ∈ 𝓝 y 
goal: {x}ᶜ ∈ 𝓝 y

full_name: closure_singleton
code: @[simp]
theorem closure_singleton [T1Space X] {x : X} : closure ({x} : Set X) = {x} 
goal: closure {x} = {x}

full_name: Set.Subsingleton.closure
code: theorem Set.Subsingleton.closure [T1Space X] {s : Set X} (hs : s.Subsingleton) :
    (closure s).Subsingleton 
goal: (closure s).Subsingleton

full_name: subsingleton_closure
code: @[simp]
theorem subsingleton_closure [T1Space X] {s : Set X} : (closure s).Subsingleton ↔ s.Subsingleton 
goal: (closure s).Subsingleton ↔ s.Subsingleton

full_name: isClosedMap_const
code: theorem isClosedMap_const {X Y} [TopologicalSpace X] [TopologicalSpace Y] [T1Space Y] {y : Y} :
    IsClosedMap (Function.const X y) 
goal: IsClosedMap (Function.const X y)

full_name: nhdsWithin_insert_of_ne
code: theorem nhdsWithin_insert_of_ne [T1Space X] {x y : X} {s : Set X} (hxy : x ≠ y) :
    𝓝[insert y s] x = 𝓝[s] x 
goal: 𝓝[insert y s] x = 𝓝[s] x

full_name: insert_mem_nhdsWithin_of_subset_insert
code: /-- If `t` is a subset of `s`, except for one point,
then `insert x s` is a neighborhood of `x` within `t`. -/
theorem insert_mem_nhdsWithin_of_subset_insert [T1Space X] {x y : X} {s t : Set X}
    (hu : t ⊆ insert y s) : insert x s ∈ 𝓝[t] x 
goal: insert x s ∈ 𝓝[t] x

full_name: ker_nhds
code: @[simp]
theorem ker_nhds [T1Space X] (x : X) : (𝓝 x).ker = {x} 
goal: (𝓝 x).ker = {x}

full_name: biInter_basis_nhds
code: theorem biInter_basis_nhds [T1Space X] {ι : Sort*} {p : ι → Prop} {s : ι → Set X} {x : X}
    (h : (𝓝 x).HasBasis p s) : ⋂ (i) (_ : p i), s i = {x} 
goal: ⋂ i, ⋂ (_ : p i), s i = {x}

full_name: compl_singleton_mem_nhdsSet_iff
code: @[simp]
theorem compl_singleton_mem_nhdsSet_iff [T1Space X] {x : X} {s : Set X} : {x}ᶜ ∈ 𝓝ˢ s ↔ x ∉ s 
goal: {x}ᶜ ∈ 𝓝ˢ s ↔ x ∉ s

full_name: nhdsSet_le_iff
code: @[simp]
theorem nhdsSet_le_iff [T1Space X] {s t : Set X} : 𝓝ˢ s ≤ 𝓝ˢ t ↔ s ⊆ t 
goal: 𝓝ˢ s ≤ 𝓝ˢ t ↔ s ⊆ t

full_name: nhdsSet_inj_iff
code: @[simp]
theorem nhdsSet_inj_iff [T1Space X] {s t : Set X} : 𝓝ˢ s = 𝓝ˢ t ↔ s = t 
goal: 𝓝ˢ s = 𝓝ˢ t ↔ s = t

full_name: injective_nhdsSet
code: theorem injective_nhdsSet [T1Space X] : Function.Injective (𝓝ˢ : Set X → Filter X) 
goal: Function.Injective 𝓝ˢ

full_name: strictMono_nhdsSet
code: theorem strictMono_nhdsSet [T1Space X] : StrictMono (𝓝ˢ : Set X → Filter X) 
goal: StrictMono 𝓝ˢ

full_name: nhds_le_nhdsSet_iff
code: @[simp]
theorem nhds_le_nhdsSet_iff [T1Space X] {s : Set X} {x : X} : 𝓝 x ≤ 𝓝ˢ s ↔ x ∈ s 
goal: 𝓝 x ≤ 𝓝ˢ s ↔ x ∈ s

full_name: Dense.diff_singleton
code: /-- Removing a non-isolated point from a dense set, one still obtains a dense set. -/
theorem Dense.diff_singleton [T1Space X] {s : Set X} (hs : Dense s) (x : X) [NeBot (𝓝[≠] x)] :
    Dense (s \ {x}) 
goal: Dense (s \ {x})

full_name: Dense.diff_finset
code: /-- Removing a finset from a dense set in a space without isolated points, one still
obtains a dense set. -/
theorem Dense.diff_finset [T1Space X] [∀ x : X, NeBot (𝓝[≠] x)] {s : Set X} (hs : Dense s)
    (t : Finset X) : Dense (s \ t) 
goal: Dense (s \ ↑t)

full_name: Dense.diff_finite
code: /-- Removing a finite set from a dense set in a space without isolated points, one still
obtains a dense set. -/
theorem Dense.diff_finite [T1Space X] [∀ x : X, NeBot (𝓝[≠] x)] {s : Set X} (hs : Dense s)
    {t : Set X} (ht : t.Finite) : Dense (s \ t) 
goal: Dense (s \ t)

full_name: eq_of_tendsto_nhds
code: /-- If a function to a `T1Space` tends to some limit `y` at some point `x`, then necessarily
`y = f x`. -/
theorem eq_of_tendsto_nhds [TopologicalSpace Y] [T1Space Y] {f : X → Y} {x : X} {y : Y}
    (h : Tendsto f (𝓝 x) (𝓝 y)) : f x = y 
goal: f x = y

full_name: Filter.Tendsto.eventually_ne
code: theorem Filter.Tendsto.eventually_ne [TopologicalSpace Y] [T1Space Y] {g : X → Y}
    {l : Filter X} {b₁ b₂ : Y} (hg : Tendsto g l (𝓝 b₁)) (hb : b₁ ≠ b₂) : ∀ᶠ z in l, g z ≠ b₂ 
goal: ∀ᶠ (z : X) in l, g z ≠ b₂

full_name: ContinuousAt.eventually_ne
code: theorem ContinuousAt.eventually_ne [TopologicalSpace Y] [T1Space Y] {g : X → Y} {x : X} {y : Y}
    (hg1 : ContinuousAt g x) (hg2 : g x ≠ y) : ∀ᶠ z in 𝓝 x, g z ≠ y 
goal: ∀ᶠ (z : X) in 𝓝 x, g z ≠ y

full_name: eventually_ne_nhds
code: theorem eventually_ne_nhds [T1Space X] {a b : X} (h : a ≠ b) : ∀ᶠ x in 𝓝 a, x ≠ b 
goal: ∀ᶠ (x : X) in 𝓝 a, x ≠ b

full_name: eventually_ne_nhdsWithin
code: theorem eventually_ne_nhdsWithin [T1Space X] {a b : X} {s : Set X} (h : a ≠ b) :
    ∀ᶠ x in 𝓝[s] a, x ≠ b 
goal: ∀ᶠ (x : X) in 𝓝[s] a, x ≠ b

full_name: continuousAt_of_tendsto_nhds
code: /-- To prove a function to a `T1Space` is continuous at some point `x`, it suffices to prove that
`f` admits *some* limit at `x`. -/
theorem continuousAt_of_tendsto_nhds [TopologicalSpace Y] [T1Space Y] {f : X → Y} {x : X} {y : Y}
    (h : Tendsto f (𝓝 x) (𝓝 y)) : ContinuousAt f x 
goal: ContinuousAt f x

full_name: tendsto_const_nhds_iff
code: @[simp]
theorem tendsto_const_nhds_iff [T1Space X] {l : Filter Y} [NeBot l] {c d : X} :
    Tendsto (fun _ => c) l (𝓝 d) ↔ c = d 
goal: Filter.Tendsto (fun x => c) l (𝓝 d) ↔ c = d

full_name: isOpen_singleton_of_finite_mem_nhds
code: /-- A point with a finite neighborhood has to be isolated. -/
theorem isOpen_singleton_of_finite_mem_nhds [T1Space X] (x : X)
    {s : Set X} (hs : s ∈ 𝓝 x) (hsf : s.Finite) : IsOpen ({x} : Set X) 
goal: IsOpen {x}

full_name: infinite_of_mem_nhds
code: /-- If the punctured neighborhoods of a point form a nontrivial filter, then any neighborhood is
infinite. -/
theorem infinite_of_mem_nhds {X} [TopologicalSpace X] [T1Space X] (x : X) [hx : NeBot (𝓝[≠] x)]
    {s : Set X} (hs : s ∈ 𝓝 x) : Set.Infinite s 
goal: s.Infinite

full_name: Finite.instDiscreteTopology
code: instance Finite.instDiscreteTopology [T1Space X] [Finite X] : DiscreteTopology X 
goal: DiscreteTopology X

full_name: Set.Finite.continuousOn
code: theorem Set.Finite.continuousOn [T1Space X] [TopologicalSpace Y] {s : Set X} (hs : s.Finite)
    (f : X → Y) : ContinuousOn f s 
goal: ContinuousOn f s

full_name: PreconnectedSpace.trivial_of_discrete
code: theorem PreconnectedSpace.trivial_of_discrete [PreconnectedSpace X] [DiscreteTopology X] :
    Subsingleton X 
goal: Subsingleton X

full_name: IsPreconnected.infinite_of_nontrivial
code: theorem IsPreconnected.infinite_of_nontrivial [T1Space X] {s : Set X} (h : IsPreconnected s)
    (hs : s.Nontrivial) : s.Infinite 
goal: s.Infinite

full_name: ConnectedSpace.infinite
code: theorem ConnectedSpace.infinite [ConnectedSpace X] [Nontrivial X] [T1Space X] : Infinite X 
goal: Infinite X

full_name: ConnectedSpace.neBot_nhdsWithin_compl_of_nontrivial_of_t1space
code: /-- A non-trivial connected T1 space has no isolated points. -/
instance (priority := 100) ConnectedSpace.neBot_nhdsWithin_compl_of_nontrivial_of_t1space
    [ConnectedSpace X] [Nontrivial X] [T1Space X] (x : X) :
    NeBot (𝓝[≠] x) 
goal: (𝓝[≠] x).NeBot

full_name: IsGδ.compl_singleton
code: theorem IsGδ.compl_singleton (x : X) [T1Space X] : IsGδ ({x}ᶜ : Set X) 
goal: IsGδ {x}ᶜ

full_name: Set.Countable.isGδ_compl
code: theorem Set.Countable.isGδ_compl {s : Set X} [T1Space X] (hs : s.Countable) : IsGδ sᶜ 
goal: IsGδ sᶜ

full_name: Set.Finite.isGδ_compl
code: theorem Set.Finite.isGδ_compl {s : Set X} [T1Space X] (hs : s.Finite) : IsGδ sᶜ 
goal: IsGδ sᶜ

full_name: Set.Subsingleton.isGδ_compl
code: theorem Set.Subsingleton.isGδ_compl {s : Set X} [T1Space X] (hs : s.Subsingleton) : IsGδ sᶜ 
goal: IsGδ sᶜ

full_name: Finset.isGδ_compl
code: theorem Finset.isGδ_compl [T1Space X] (s : Finset X) : IsGδ (sᶜ : Set X) 
goal: IsGδ (↑s)ᶜ

full_name: IsGδ.singleton
code: protected theorem IsGδ.singleton [T1Space X] (x : X) : IsGδ ({x} : Set X) 
goal: IsGδ {x}

full_name: Set.Finite.isGδ
code: theorem Set.Finite.isGδ {s : Set X} [T1Space X] (hs : s.Finite) : IsGδ s 
goal: IsGδ s

full_name: SeparationQuotient.t1Space_iff
code: theorem SeparationQuotient.t1Space_iff : T1Space (SeparationQuotient X) ↔ R0Space X 
goal: T1Space (SeparationQuotient X) ↔ R0Space X

full_name: Set.Subsingleton.isClosed
code: lemma Set.Subsingleton.isClosed [T1Space X] {A : Set X} (h : A.Subsingleton) : IsClosed A 
goal: IsClosed A

full_name: isClosed_inter_singleton
code: lemma isClosed_inter_singleton [T1Space X] {A : Set X} {a : X} : IsClosed (A ∩ {a}) 
goal: IsClosed (A ∩ {a})

full_name: isClosed_singleton_inter
code: lemma isClosed_singleton_inter [T1Space X] {A : Set X} {a : X} : IsClosed ({a} ∩ A) 
goal: IsClosed ({a} ∩ A)

full_name: singleton_mem_nhdsWithin_of_mem_discrete
code: theorem singleton_mem_nhdsWithin_of_mem_discrete {s : Set X} [DiscreteTopology s] {x : X}
    (hx : x ∈ s) : {x} ∈ 𝓝[s] x 
goal: {x} ∈ 𝓝[s] x

full_name: nhdsWithin_of_mem_discrete
code: /-- The neighbourhoods filter of `x` within `s`, under the discrete topology, is equal to
the pure `x` filter (which is the principal filter at the singleton `{x}`.) -/
theorem nhdsWithin_of_mem_discrete {s : Set X} [DiscreteTopology s] {x : X} (hx : x ∈ s) :
    𝓝[s] x = pure x 
goal: 𝓝[s] x = pure x

full_name: Filter.HasBasis.exists_inter_eq_singleton_of_mem_discrete
code: theorem Filter.HasBasis.exists_inter_eq_singleton_of_mem_discrete {ι : Type*} {p : ι → Prop}
    {t : ι → Set X} {s : Set X} [DiscreteTopology s] {x : X} (hb : (𝓝 x).HasBasis p t)
    (hx : x ∈ s) : ∃ i, p i ∧ t i ∩ s = {x} 
goal: ∃ i, p i ∧ t i ∩ s = {x}

full_name: nhds_inter_eq_singleton_of_mem_discrete
code: /-- A point `x` in a discrete subset `s` of a topological space admits a neighbourhood
that only meets `s` at `x`.  -/
theorem nhds_inter_eq_singleton_of_mem_discrete {s : Set X} [DiscreteTopology s] {x : X}
    (hx : x ∈ s) : ∃ U ∈ 𝓝 x, U ∩ s = {x} 
goal: ∃ U ∈ 𝓝 x, U ∩ s = {x}

full_name: isOpen_inter_eq_singleton_of_mem_discrete
code: /-- Let `x` be a point in a discrete subset `s` of a topological space, then there exists an open
set that only meets `s` at `x`.  -/
theorem isOpen_inter_eq_singleton_of_mem_discrete {s : Set X} [DiscreteTopology s] {x : X}
    (hx : x ∈ s) : ∃ U : Set X, IsOpen U ∧ U ∩ s = {x} 
goal: ∃ U, IsOpen U ∧ U ∩ s = {x}

full_name: disjoint_nhdsWithin_of_mem_discrete
code: /-- For point `x` in a discrete subset `s` of a topological space, there is a set `U`
such that
1. `U` is a punctured neighborhood of `x` (ie. `U ∪ {x}` is a neighbourhood of `x`),
2. `U` is disjoint from `s`.
-/
theorem disjoint_nhdsWithin_of_mem_discrete {s : Set X} [DiscreteTopology s] {x : X} (hx : x ∈ s) :
    ∃ U ∈ 𝓝[≠] x, Disjoint U s 
goal: ∃ U ∈ 𝓝[≠] x, Disjoint U s

full_name: closedEmbedding_update
code: theorem closedEmbedding_update {ι : Type*} {β : ι → Type*}
    [DecidableEq ι] [(i : ι) → TopologicalSpace (β i)]
    (x : (i : ι) → β i) (i : ι) [(i : ι) → T1Space (β i)] :
    ClosedEmbedding (update x i) 
goal: ClosedEmbedding (Function.update x i)

full_name: R1Space.specializes_or_disjoint_nhds
code: /-- A topological space is called a *preregular* (a.k.a. R₁) space,
if any two topologically distinguishable points have disjoint neighbourhoods. -/
@[mk_iff r1Space_iff_specializes_or_disjoint_nhds]
class R1Space (X : Type*) [TopologicalSpace X] : Prop where
  specializes_or_disjoint_nhds (x y : X) : Specializes x y ∨ Disjoint (𝓝 x) (𝓝 y)
goal: x ⤳ y ∨ Disjoint (𝓝 x) (𝓝 y)

full_name: r1Space_iff_specializes_or_disjoint_nhds
code: /-- A topological space is called a *preregular* (a.k.a. R₁) space,
if any two topologically distinguishable points have disjoint neighbourhoods. -/
@[mk_iff r1Space_iff_specializes_or_disjoint_nhds]
class R1Space (X : Type*) [TopologicalSpace X] : Prop where
  specializes_or_disjoint_nhds (x y : X) : Specializes x y ∨ Disjoint (𝓝 x) (𝓝 y)
goal: R1Space X ↔ ∀ (x y : X), x ⤳ y ∨ Disjoint (𝓝 x) (𝓝 y)

full_name: R1Space
code: /-- A topological space is called a *preregular* (a.k.a. R₁) space,
if any two topologically distinguishable points have disjoint neighbourhoods. -/
@[mk_iff r1Space_iff_specializes_or_disjoint_nhds]
class R1Space (X : Type*) [TopologicalSpace X] : Prop where
  specializes_or_disjoint_nhds (x y : X) : Specializes x y ∨ Disjoint (𝓝 x) (𝓝 y)
goal: Prop

full_name: instR0Space
code: instance (priority := 100) : R0Space X 
goal: R0Space X

full_name: disjoint_nhds_nhds_iff_not_specializes
code: theorem disjoint_nhds_nhds_iff_not_specializes : Disjoint (𝓝 x) (𝓝 y) ↔ ¬x ⤳ y 
goal: Disjoint (𝓝 x) (𝓝 y) ↔ ¬x ⤳ y

full_name: specializes_iff_not_disjoint
code: theorem specializes_iff_not_disjoint : x ⤳ y ↔ ¬Disjoint (𝓝 x) (𝓝 y) 
goal: x ⤳ y ↔ ¬Disjoint (𝓝 x) (𝓝 y)

full_name: disjoint_nhds_nhds_iff_not_inseparable
code: theorem disjoint_nhds_nhds_iff_not_inseparable : Disjoint (𝓝 x) (𝓝 y) ↔ ¬Inseparable x y 
goal: Disjoint (𝓝 x) (𝓝 y) ↔ ¬Inseparable x y

full_name: r1Space_iff_inseparable_or_disjoint_nhds
code: theorem r1Space_iff_inseparable_or_disjoint_nhds {X : Type*} [TopologicalSpace X] :
    R1Space X ↔ ∀ x y : X, Inseparable x y ∨ Disjoint (𝓝 x) (𝓝 y) 
goal: R1Space X ↔ ∀ (x y : X), Inseparable x y ∨ Disjoint (𝓝 x) (𝓝 y)

full_name: isClosed_setOf_specializes
code: theorem isClosed_setOf_specializes : IsClosed { p : X × X | p.1 ⤳ p.2 } 
goal: IsClosed {p | p.1 ⤳ p.2}

full_name: isClosed_setOf_inseparable
code: theorem isClosed_setOf_inseparable : IsClosed { p : X × X | Inseparable p.1 p.2 } 
goal: IsClosed {p | Inseparable p.1 p.2}

full_name: IsCompact.mem_closure_iff_exists_inseparable
code: /-- In an R₁ space, a point belongs to the closure of a compact set `K`
if and only if it is topologically inseparable from some point of `K`. -/
theorem IsCompact.mem_closure_iff_exists_inseparable {K : Set X} (hK : IsCompact K) :
    y ∈ closure K ↔ ∃ x ∈ K, Inseparable x y 
goal: y ∈ closure K ↔ ∃ x ∈ K, Inseparable x y

full_name: IsCompact.closure_eq_biUnion_inseparable
code: theorem IsCompact.closure_eq_biUnion_inseparable {K : Set X} (hK : IsCompact K) :
    closure K = ⋃ x ∈ K, {y | Inseparable x y} 
goal: closure K = ⋃ x ∈ K, {y | Inseparable x y}

full_name: IsCompact.closure_eq_biUnion_closure_singleton
code: /-- In an R₁ space, the closure of a compact set is the union of the closures of its points. -/
theorem IsCompact.closure_eq_biUnion_closure_singleton {K : Set X} (hK : IsCompact K) :
    closure K = ⋃ x ∈ K, closure {x} 
goal: closure K = ⋃ x ∈ K, closure {x}

full_name: IsCompact.closure_subset_of_isOpen
code: /-- In an R₁ space, if a compact set `K` is contained in an open set `U`,
then its closure is also contained in `U`. -/
theorem IsCompact.closure_subset_of_isOpen {K : Set X} (hK : IsCompact K)
    {U : Set X} (hU : IsOpen U) (hKU : K ⊆ U) : closure K ⊆ U 
goal: closure K ⊆ U

full_name: IsCompact.closure
code: /-- The closure of a compact set in an R₁ space is a compact set. -/
protected theorem IsCompact.closure {K : Set X} (hK : IsCompact K) : IsCompact (closure K) 
goal: IsCompact (closure K)

full_name: IsCompact.closure_of_subset
code: theorem IsCompact.closure_of_subset {s K : Set X} (hK : IsCompact K) (h : s ⊆ K) :
    IsCompact (closure s) 
goal: IsCompact (closure s)

full_name: exists_isCompact_superset_iff
code: @[simp]
theorem exists_isCompact_superset_iff {s : Set X} :
    (∃ K, IsCompact K ∧ s ⊆ K) ↔ IsCompact (closure s) 
goal: (∃ K, IsCompact K ∧ s ⊆ K) ↔ IsCompact (closure s)

full_name: SeparatedNhds.of_isCompact_isCompact_isClosed
code: /-- If `K` and `L` are disjoint compact sets in an R₁ topological space
and `L` is also closed, then `K` and `L` have disjoint neighborhoods.  -/
theorem SeparatedNhds.of_isCompact_isCompact_isClosed {K L : Set X} (hK : IsCompact K)
    (hL : IsCompact L) (h'L : IsClosed L) (hd : Disjoint K L) : SeparatedNhds K L 
goal: SeparatedNhds K L

full_name: IsCompact.binary_compact_cover
code: /-- If a compact set is covered by two open sets, then we can cover it by two compact subsets. -/
theorem IsCompact.binary_compact_cover {K U V : Set X}
    (hK : IsCompact K) (hU : IsOpen U) (hV : IsOpen V) (h2K : K ⊆ U ∪ V) :
    ∃ K₁ K₂ : Set X, IsCompact K₁ ∧ IsCompact K₂ ∧ K₁ ⊆ U ∧ K₂ ⊆ V ∧ K = K₁ ∪ K₂ 
goal: ∃ K₁ K₂, IsCompact K₁ ∧ IsCompact K₂ ∧ K₁ ⊆ U ∧ K₂ ⊆ V ∧ K = K₁ ∪ K₂

full_name: IsCompact.finite_compact_cover
code: /-- For every finite open cover `Uᵢ` of a compact set, there exists a compact cover `Kᵢ ⊆ Uᵢ`. -/
theorem IsCompact.finite_compact_cover {s : Set X} (hs : IsCompact s) {ι : Type*}
    (t : Finset ι) (U : ι → Set X) (hU : ∀ i ∈ t, IsOpen (U i)) (hsC : s ⊆ ⋃ i ∈ t, U i) :
    ∃ K : ι → Set X, (∀ i, IsCompact (K i)) ∧ (∀ i, K i ⊆ U i) ∧ s = ⋃ i ∈ t, K i 
goal: ∃ K, (∀ (i : ι), IsCompact (K i)) ∧ (∀ (i : ι), K i ⊆ U i) ∧ s = ⋃ i ∈ t, K i

full_name: R1Space.of_continuous_specializes_imp
code: theorem R1Space.of_continuous_specializes_imp [TopologicalSpace Y] {f : Y → X} (hc : Continuous f)
    (hspec : ∀ x y, f x ⤳ f y → x ⤳ y) : R1Space Y 
goal: R1Space Y

full_name: Inducing.r1Space
code: theorem Inducing.r1Space [TopologicalSpace Y] {f : Y → X} (hf : Inducing f) : R1Space Y 
goal: R1Space Y

full_name: R1Space.induced
code: protected theorem R1Space.induced (f : Y → X) : @R1Space Y (.induced f ‹_›) 
goal: R1Space Y

full_name: instR1SpaceSubtype
code: instance (p : X → Prop) : R1Space (Subtype p) 
goal: R1Space (Subtype p)

full_name: R1Space.sInf
code: protected theorem R1Space.sInf {X : Type*} {T : Set (TopologicalSpace X)}
    (hT : ∀ t ∈ T, @R1Space X t) : @R1Space X (sInf T) 
goal: R1Space X

full_name: R1Space.iInf
code: protected theorem R1Space.iInf {ι X : Type*} {t : ι → TopologicalSpace X}
    (ht : ∀ i, @R1Space X (t i)) : @R1Space X (iInf t) 
goal: R1Space X

full_name: R1Space.inf
code: protected theorem R1Space.inf {X : Type*} {t₁ t₂ : TopologicalSpace X}
    (h₁ : @R1Space X t₁) (h₂ : @R1Space X t₂) : @R1Space X (t₁ ⊓ t₂) 
goal: R1Space X

full_name: instR1SpaceProd
code: instance [TopologicalSpace Y] [R1Space Y] : R1Space (X × Y) 
goal: R1Space (X × Y)

full_name: instR1SpaceForall
code: instance {ι : Type*} {X : ι → Type*} [∀ i, TopologicalSpace (X i)] [∀ i, R1Space (X i)] :
    R1Space (∀ i, X i) 
goal: R1Space ((i : ι) → X i)

full_name: exists_mem_nhds_isCompact_mapsTo_of_isCompact_mem_nhds
code: theorem exists_mem_nhds_isCompact_mapsTo_of_isCompact_mem_nhds
    {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] [R1Space Y] {f : X → Y} {x : X}
    {K : Set X} {s : Set Y} (hf : Continuous f) (hs : s ∈ 𝓝 (f x)) (hKc : IsCompact K)
    (hKx : K ∈ 𝓝 x) : ∃ K ∈ 𝓝 x, IsCompact K ∧ MapsTo f K s 
goal: ∃ K ∈ 𝓝 x, IsCompact K ∧ Set.MapsTo f K s

full_name: instLocallyCompactPairOfWeaklyLocallyCompactSpaceOfR1Space
code: instance (priority := 900) {X Y : Type*} [TopologicalSpace X] [WeaklyLocallyCompactSpace X]
    [TopologicalSpace Y] [R1Space Y] : LocallyCompactPair X Y 
goal: LocallyCompactPair X Y

full_name: IsCompact.isCompact_isClosed_basis_nhds
code: /-- If a point in an R₁ space has a compact neighborhood,
then it has a basis of compact closed neighborhoods. -/
theorem IsCompact.isCompact_isClosed_basis_nhds {x : X} {L : Set X} (hLc : IsCompact L)
    (hxL : L ∈ 𝓝 x) : (𝓝 x).HasBasis (fun K ↦ K ∈ 𝓝 x ∧ IsCompact K ∧ IsClosed K) (·) 
goal: (𝓝 x).HasBasis (fun K => K ∈ 𝓝 x ∧ IsCompact K ∧ IsClosed K) fun x => x

full_name: Filter.coclosedCompact_eq_cocompact
code: /-- In an R₁ space, the filters `coclosedCompact` and `cocompact` are equal. -/
@[simp]
theorem Filter.coclosedCompact_eq_cocompact : coclosedCompact X = cocompact X 
goal: Filter.coclosedCompact X = Filter.cocompact X

full_name: Bornology.relativelyCompact_eq_inCompact
code: /-- In an R₁ space, the bornologies `relativelyCompact` and `inCompact` are equal. -/
@[simp]
theorem Bornology.relativelyCompact_eq_inCompact :
    Bornology.relativelyCompact X = Bornology.inCompact X 
goal: Bornology.relativelyCompact X = Bornology.inCompact X

full_name: isCompact_isClosed_basis_nhds
code: /-- In a (weakly) locally compact R₁ space, compact closed neighborhoods of a point `x`
form a basis of neighborhoods of `x`. -/
theorem isCompact_isClosed_basis_nhds (x : X) :
    (𝓝 x).HasBasis (fun K => K ∈ 𝓝 x ∧ IsCompact K ∧ IsClosed K) (·) 
goal: (𝓝 x).HasBasis (fun K => K ∈ 𝓝 x ∧ IsCompact K ∧ IsClosed K) fun x => x

full_name: exists_mem_nhds_isCompact_isClosed
code: /-- In a (weakly) locally compact R₁ space, each point admits a compact closed neighborhood. -/
theorem exists_mem_nhds_isCompact_isClosed (x : X) : ∃ K ∈ 𝓝 x, IsCompact K ∧ IsClosed K 
goal: ∃ K ∈ 𝓝 x, IsCompact K ∧ IsClosed K

full_name: WeaklyLocallyCompactSpace.locallyCompactSpace
code: /-- A weakly locally compact R₁ space is locally compact. -/
instance (priority := 80) WeaklyLocallyCompactSpace.locallyCompactSpace : LocallyCompactSpace X 
goal: LocallyCompactSpace X

full_name: exists_isOpen_superset_and_isCompact_closure
code: /-- In a weakly locally compact R₁ space,
every compact set has an open neighborhood with compact closure. -/
theorem exists_isOpen_superset_and_isCompact_closure {K : Set X} (hK : IsCompact K) :
    ∃ V, IsOpen V ∧ K ⊆ V ∧ IsCompact (closure V) 
goal: ∃ V, IsOpen V ∧ K ⊆ V ∧ IsCompact (closure V)

full_name: exists_isOpen_mem_isCompact_closure
code: /-- In a weakly locally compact R₁ space,
every point has an open neighborhood with compact closure. -/
theorem exists_isOpen_mem_isCompact_closure (x : X) :
    ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ IsCompact (closure U) 
goal: ∃ U, IsOpen U ∧ x ∈ U ∧ IsCompact (closure U)

full_name: t2Space_iff
code: /-- A T₂ space, also known as a Hausdorff space, is one in which for every
  `x ≠ y` there exists disjoint open sets around `x` and `y`. This is
  the most widely used of the separation axioms. -/
@[mk_iff]
class T2Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- Every two points in a Hausdorff space admit disjoint open neighbourhoods. -/
  t2 : Pairwise fun x y => ∃ u v : Set X, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v
goal: T2Space X ↔ Pairwise fun x y => ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v

full_name: T2Space.t2
code: /-- A T₂ space, also known as a Hausdorff space, is one in which for every
  `x ≠ y` there exists disjoint open sets around `x` and `y`. This is
  the most widely used of the separation axioms. -/
@[mk_iff]
class T2Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- Every two points in a Hausdorff space admit disjoint open neighbourhoods. -/
  t2 : Pairwise fun x y => ∃ u v : Set X, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v
goal: Pairwise fun x y => ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v

full_name: T2Space
code: /-- A T₂ space, also known as a Hausdorff space, is one in which for every
  `x ≠ y` there exists disjoint open sets around `x` and `y`. This is
  the most widely used of the separation axioms. -/
@[mk_iff]
class T2Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- Every two points in a Hausdorff space admit disjoint open neighbourhoods. -/
  t2 : Pairwise fun x y => ∃ u v : Set X, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v
goal: Prop

full_name: t2_separation
code: /-- Two different points can be separated by open sets. -/
theorem t2_separation [T2Space X] {x y : X} (h : x ≠ y) :
    ∃ u v : Set X, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v 
goal: ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v

full_name: t2Space_iff_disjoint_nhds
code: theorem t2Space_iff_disjoint_nhds : T2Space X ↔ Pairwise fun x y : X => Disjoint (𝓝 x) (𝓝 y) 
goal: T2Space X ↔ Pairwise fun x y => Disjoint (𝓝 x) (𝓝 y)

full_name: disjoint_nhds_nhds
code: @[simp]
theorem disjoint_nhds_nhds [T2Space X] {x y : X} : Disjoint (𝓝 x) (𝓝 y) ↔ x ≠ y 
goal: Disjoint (𝓝 x) (𝓝 y) ↔ x ≠ y

full_name: pairwise_disjoint_nhds
code: theorem pairwise_disjoint_nhds [T2Space X] : Pairwise (Disjoint on (𝓝 : X → Filter X)) 
goal: Pairwise (Disjoint on 𝓝)

full_name: Set.pairwiseDisjoint_nhds
code: protected theorem Set.pairwiseDisjoint_nhds [T2Space X] (s : Set X) : s.PairwiseDisjoint 𝓝 
goal: s.PairwiseDisjoint 𝓝

full_name: Set.Finite.t2_separation
code: /-- Points of a finite set can be separated by open sets from each other. -/
theorem Set.Finite.t2_separation [T2Space X] {s : Set X} (hs : s.Finite) :
    ∃ U : X → Set X, (∀ x, x ∈ U x ∧ IsOpen (U x)) ∧ s.PairwiseDisjoint U 
goal: ∃ U, (∀ (x : X), x ∈ U x ∧ IsOpen (U x)) ∧ s.PairwiseDisjoint U

full_name: T2Space.t1Space
code: instance (priority := 100) T2Space.t1Space [T2Space X] : T1Space X 
goal: T1Space X

full_name: T2Space.r1Space
code: instance (priority := 100) T2Space.r1Space [T2Space X] : R1Space X 
goal: R1Space X

full_name: SeparationQuotient.t2Space_iff
code: theorem SeparationQuotient.t2Space_iff : T2Space (SeparationQuotient X) ↔ R1Space X 
goal: T2Space (SeparationQuotient X) ↔ R1Space X

full_name: SeparationQuotient.t2Space
code: instance SeparationQuotient.t2Space [R1Space X] : T2Space (SeparationQuotient X) 
goal: T2Space (SeparationQuotient X)

full_name: instT2SpaceOfR1SpaceOfT0Space
code: instance (priority := 80) [R1Space X] [T0Space X] : T2Space X 
goal: T2Space X

full_name: R1Space.t2Space_iff_t0Space
code: theorem R1Space.t2Space_iff_t0Space [R1Space X] : T2Space X ↔ T0Space X 
goal: T2Space X ↔ T0Space X

full_name: t2_iff_nhds
code: /-- A space is T₂ iff the neighbourhoods of distinct points generate the bottom filter. -/
theorem t2_iff_nhds : T2Space X ↔ ∀ {x y : X}, NeBot (𝓝 x ⊓ 𝓝 y) → x = y 
goal: T2Space X ↔ ∀ {x y : X}, (𝓝 x ⊓ 𝓝 y).NeBot → x = y

full_name: eq_of_nhds_neBot
code: theorem eq_of_nhds_neBot [T2Space X] {x y : X} (h : NeBot (𝓝 x ⊓ 𝓝 y)) : x = y 
goal: x = y

full_name: t2Space_iff_nhds
code: theorem t2Space_iff_nhds :
    T2Space X ↔ Pairwise fun x y : X => ∃ U ∈ 𝓝 x, ∃ V ∈ 𝓝 y, Disjoint U V 
goal: T2Space X ↔ Pairwise fun x y => ∃ U ∈ 𝓝 x, ∃ V ∈ 𝓝 y, Disjoint U V

full_name: t2_separation_nhds
code: theorem t2_separation_nhds [T2Space X] {x y : X} (h : x ≠ y) :
    ∃ u v, u ∈ 𝓝 x ∧ v ∈ 𝓝 y ∧ Disjoint u v 
goal: ∃ u v, u ∈ 𝓝 x ∧ v ∈ 𝓝 y ∧ Disjoint u v

full_name: t2_separation_compact_nhds
code: theorem t2_separation_compact_nhds [LocallyCompactSpace X] [T2Space X] {x y : X} (h : x ≠ y) :
    ∃ u v, u ∈ 𝓝 x ∧ v ∈ 𝓝 y ∧ IsCompact u ∧ IsCompact v ∧ Disjoint u v 
goal: ∃ u v, u ∈ 𝓝 x ∧ v ∈ 𝓝 y ∧ IsCompact u ∧ IsCompact v ∧ Disjoint u v

full_name: t2_iff_ultrafilter
code: theorem t2_iff_ultrafilter :
    T2Space X ↔ ∀ {x y : X} (f : Ultrafilter X), ↑f ≤ 𝓝 x → ↑f ≤ 𝓝 y → x = y 
goal: T2Space X ↔ ∀ {x y : X} (f : Ultrafilter X), ↑f ≤ 𝓝 x → ↑f ≤ 𝓝 y → x = y

full_name: t2_iff_isClosed_diagonal
code: theorem t2_iff_isClosed_diagonal : T2Space X ↔ IsClosed (diagonal X) 
goal: T2Space X ↔ IsClosed (Set.diagonal X)

full_name: isClosed_diagonal
code: theorem isClosed_diagonal [T2Space X] : IsClosed (diagonal X) 
goal: IsClosed (Set.diagonal X)

full_name: tendsto_nhds_unique
code: theorem tendsto_nhds_unique [T2Space X] {f : Y → X} {l : Filter Y} {a b : X} [NeBot l]
    (ha : Tendsto f l (𝓝 a)) (hb : Tendsto f l (𝓝 b)) : a = b 
goal: a = b

full_name: tendsto_nhds_unique'
code: theorem tendsto_nhds_unique' [T2Space X] {f : Y → X} {l : Filter Y} {a b : X} (_ : NeBot l)
    (ha : Tendsto f l (𝓝 a)) (hb : Tendsto f l (𝓝 b)) : a = b 
goal: l.NeBot → Filter.Tendsto f l (𝓝 a) → Filter.Tendsto f l (𝓝 b) → a = b

full_name: tendsto_nhds_unique_of_eventuallyEq
code: theorem tendsto_nhds_unique_of_eventuallyEq [T2Space X] {f g : Y → X} {l : Filter Y} {a b : X}
    [NeBot l] (ha : Tendsto f l (𝓝 a)) (hb : Tendsto g l (𝓝 b)) (hfg : f =ᶠ[l] g) : a = b 
goal: a = b

full_name: tendsto_nhds_unique_of_frequently_eq
code: theorem tendsto_nhds_unique_of_frequently_eq [T2Space X] {f g : Y → X} {l : Filter Y} {a b : X}
    (ha : Tendsto f l (𝓝 a)) (hb : Tendsto g l (𝓝 b)) (hfg : ∃ᶠ x in l, f x = g x) : a = b 
goal: a = b

full_name: IsCompact.nhdsSet_inter_eq
code: /-- If `s` and `t` are compact sets in a T₂ space, then the set neighborhoods filter of `s ∩ t`
is the infimum of set neighborhoods filters for `s` and `t`.

For general sets, only the `≤` inequality holds, see `nhdsSet_inter_le`. -/
theorem IsCompact.nhdsSet_inter_eq [T2Space X] {s t : Set X} (hs : IsCompact s) (ht : IsCompact t) :
    𝓝ˢ (s ∩ t) = 𝓝ˢ s ⊓ 𝓝ˢ t 
goal: 𝓝ˢ (s ∩ t) = 𝓝ˢ s ⊓ 𝓝ˢ t

full_name: Set.InjOn.exists_mem_nhdsSet
code: /-- If a function `f` is

- injective on a compact set `s`;
- continuous at every point of this set;
- injective on a neighborhood of each point of this set,

then it is injective on a neighborhood of this set. -/
theorem Set.InjOn.exists_mem_nhdsSet {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    [T2Space Y] {f : X → Y} {s : Set X} (inj : InjOn f s) (sc : IsCompact s)
    (fc : ∀ x ∈ s, ContinuousAt f x) (loc : ∀ x ∈ s, ∃ u ∈ 𝓝 x, InjOn f u) :
    ∃ t ∈ 𝓝ˢ s, InjOn f t 
goal: ∃ t ∈ 𝓝ˢ s, Set.InjOn f t

full_name: Set.InjOn.exists_isOpen_superset
code: /-- If a function `f` is

- injective on a compact set `s`;
- continuous at every point of this set;
- injective on a neighborhood of each point of this set,

then it is injective on an open neighborhood of this set. -/
theorem Set.InjOn.exists_isOpen_superset {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    [T2Space Y] {f : X → Y} {s : Set X} (inj : InjOn f s) (sc : IsCompact s)
    (fc : ∀ x ∈ s, ContinuousAt f x) (loc : ∀ x ∈ s, ∃ u ∈ 𝓝 x, InjOn f u) :
    ∃ t, IsOpen t ∧ s ⊆ t ∧ InjOn f t 
goal: ∃ t, IsOpen t ∧ s ⊆ t ∧ Set.InjOn f t

full_name: lim_eq
code: theorem lim_eq {x : X} [NeBot f] (h : f ≤ 𝓝 x) : @lim _ _ ⟨x⟩ f = x 
goal: lim f = x

full_name: lim_eq_iff
code: theorem lim_eq_iff [NeBot f] (h : ∃ x : X, f ≤ 𝓝 x) {x} : @lim _ _ ⟨x⟩ f = x ↔ f ≤ 𝓝 x 
goal: lim f = x ↔ f ≤ 𝓝 x

full_name: Ultrafilter.lim_eq_iff_le_nhds
code: theorem Ultrafilter.lim_eq_iff_le_nhds [CompactSpace X] {x : X} {F : Ultrafilter X} :
    F.lim = x ↔ ↑F ≤ 𝓝 x 
goal: F.lim = x ↔ ↑F ≤ 𝓝 x

full_name: isOpen_iff_ultrafilter'
code: theorem isOpen_iff_ultrafilter' [CompactSpace X] (U : Set X) :
    IsOpen U ↔ ∀ F : Ultrafilter X, F.lim ∈ U → U ∈ F.1 
goal: IsOpen U ↔ ∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F

full_name: Filter.Tendsto.limUnder_eq
code: theorem Filter.Tendsto.limUnder_eq {x : X} {f : Filter Y} [NeBot f] {g : Y → X}
    (h : Tendsto g f (𝓝 x)) : @limUnder _ _ _ ⟨x⟩ f g = x 
goal: limUnder f g = x

full_name: Filter.limUnder_eq_iff
code: theorem Filter.limUnder_eq_iff {f : Filter Y} [NeBot f] {g : Y → X} (h : ∃ x, Tendsto g f (𝓝 x))
    {x} : @limUnder _ _ _ ⟨x⟩ f g = x ↔ Tendsto g f (𝓝 x) 
goal: limUnder f g = x ↔ Filter.Tendsto g f (𝓝 x)

full_name: Continuous.limUnder_eq
code: theorem Continuous.limUnder_eq [TopologicalSpace Y] {f : Y → X} (h : Continuous f) (y : Y) :
    @limUnder _ _ _ ⟨f y⟩ (𝓝 y) f = f y 
goal: limUnder (𝓝 y) f = f y

full_name: lim_nhds
code: @[simp]
theorem lim_nhds (x : X) : @lim _ _ ⟨x⟩ (𝓝 x) = x 
goal: lim (𝓝 x) = x

full_name: limUnder_nhds_id
code: @[simp]
theorem limUnder_nhds_id (x : X) : @limUnder _ _ _ ⟨x⟩ (𝓝 x) id = x 
goal: limUnder (𝓝 x) id = x

full_name: lim_nhdsWithin
code: @[simp]
theorem lim_nhdsWithin {x : X} {s : Set X} (h : x ∈ closure s) : @lim _ _ ⟨x⟩ (𝓝[s] x) = x 
goal: lim (𝓝[s] x) = x

full_name: limUnder_nhdsWithin_id
code: @[simp]
theorem limUnder_nhdsWithin_id {x : X} {s : Set X} (h : x ∈ closure s) :
    @limUnder _ _ _ ⟨x⟩ (𝓝[s] x) id = x 
goal: limUnder (𝓝[s] x) id = x

full_name: DiscreteTopology.toT2Space
code: instance (priority := 100) DiscreteTopology.toT2Space
    [DiscreteTopology X] : T2Space X 
goal: T2Space X

full_name: separated_by_continuous
code: theorem separated_by_continuous [TopologicalSpace Y] [T2Space Y]
    {f : X → Y} (hf : Continuous f) {x y : X} (h : f x ≠ f y) :
    ∃ u v : Set X, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v 
goal: ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v

full_name: separated_by_openEmbedding
code: theorem separated_by_openEmbedding [TopologicalSpace Y] [T2Space X]
    {f : X → Y} (hf : OpenEmbedding f) {x y : X} (h : x ≠ y) :
    ∃ u v : Set Y, IsOpen u ∧ IsOpen v ∧ f x ∈ u ∧ f y ∈ v ∧ Disjoint u v 
goal: ∃ u v, IsOpen u ∧ IsOpen v ∧ f x ∈ u ∧ f y ∈ v ∧ Disjoint u v

full_name: instT2SpaceSubtype
code: instance {p : X → Prop} [T2Space X] : T2Space (Subtype p) 
goal: T2Space (Subtype p)

full_name: Prod.t2Space
code: instance Prod.t2Space [T2Space X] [TopologicalSpace Y] [T2Space Y] : T2Space (X × Y) 
goal: T2Space (X × Y)

full_name: T2Space.of_injective_continuous
code: /-- If the codomain of an injective continuous function is a Hausdorff space, then so is its
domain. -/
theorem T2Space.of_injective_continuous [TopologicalSpace Y] [T2Space Y] {f : X → Y}
    (hinj : Injective f) (hc : Continuous f) : T2Space X 
goal: T2Space X

full_name: Embedding.t2Space
code: /-- If the codomain of a topological embedding is a Hausdorff space, then so is its domain.
See also `T2Space.of_continuous_injective`. -/
theorem Embedding.t2Space [TopologicalSpace Y] [T2Space Y] {f : X → Y} (hf : Embedding f) :
    T2Space X 
goal: T2Space X

full_name: ULift.instT2Space
code: instance ULift.instT2Space [T2Space X] : T2Space (ULift X) 
goal: T2Space (ULift.{u_3, u_1} X)

full_name: instT2SpaceSum
code: instance [T2Space X] [TopologicalSpace Y] [T2Space Y] :
    T2Space (X ⊕ Y) 
goal: T2Space (X ⊕ Y)

full_name: Pi.t2Space
code: instance Pi.t2Space {Y : X → Type v} [∀ a, TopologicalSpace (Y a)]
    [∀ a, T2Space (Y a)] : T2Space (∀ a, Y a) 
goal: T2Space ((a : X) → Y a)

full_name: Sigma.t2Space
code: instance Sigma.t2Space {ι} {X : ι → Type*} [∀ i, TopologicalSpace (X i)] [∀ a, T2Space (X a)] :
    T2Space (Σi, X i) 
goal: T2Space ((i : ι) × X i)

full_name: t2Setoid
code: /-- The smallest equivalence relation on a topological space giving a T2 quotient. -/
def t2Setoid : Setoid X 
goal: Setoid X

full_name: t2Quotient
code: /-- The largest T2 quotient of a topological space. This construction is left-adjoint to the
inclusion of T2 spaces into all topological spaces. -/
def t2Quotient 
goal: Type u_1

full_name: t2Quotient.instTopologicalSpace
code: instance : TopologicalSpace (t2Quotient X) 
goal: TopologicalSpace (t2Quotient X)

full_name: t2Quotient.mk
code: /-- The map from a topological space to its largest T2 quotient. -/
def mk : X → t2Quotient X 
goal: X → t2Quotient X

full_name: t2Quotient.mk_eq
code: lemma mk_eq {x y : X} : mk x = mk y ↔ ∀ s : Setoid X, T2Space (Quotient s) → s.Rel x y 
goal: t2Quotient.mk x = t2Quotient.mk y ↔ ∀ (s : Setoid X), T2Space (Quotient s) → s.Rel x y

full_name: t2Quotient.surjective_mk
code: lemma surjective_mk : Surjective (mk : X → t2Quotient X) 
goal: Function.Surjective t2Quotient.mk

full_name: t2Quotient.continuous_mk
code: lemma continuous_mk : Continuous (mk : X → t2Quotient X) 
goal: Continuous t2Quotient.mk

full_name: t2Quotient.inductionOn
code: @[elab_as_elim]
protected lemma inductionOn {motive : t2Quotient X → Prop} (q : t2Quotient X)
    (h : ∀ x, motive (t2Quotient.mk x)) : motive q 
goal: motive q

full_name: t2Quotient.inductionOn₂
code: @[elab_as_elim]
protected lemma inductionOn₂ [TopologicalSpace Y] {motive : t2Quotient X → t2Quotient Y → Prop}
    (q : t2Quotient X) (q' : t2Quotient Y) (h : ∀ x y, motive (mk x) (mk y)) : motive q q' 
goal: motive q q'

full_name: t2Quotient.instT2Space
code: /-- The largest T2 quotient of a topological space is indeed T2. -/
instance : T2Space (t2Quotient X) 
goal: T2Space (t2Quotient X)

full_name: t2Quotient.compatible
code: lemma compatible {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] [T2Space Y]
    {f : X → Y} (hf : Continuous f) : letI _ := t2Setoid X
    ∀ (a b : X), a ≈ b → f a = f b 
goal: a ≈ b → f a = f b

full_name: t2Quotient.lift
code: /-- The universal property of the largest T2 quotient of a topological space `X`: any continuous
map from `X` to a T2 space `Y` uniquely factors through `t2Quotient X`. This declaration builds the
factored map. Its continuity is `t2Quotient.continuous_lift`, the fact that it indeed factors the
original map is `t2Quotient.lift_mk` and uniquenes is `t2Quotient.unique_lift`. -/
def lift {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] [T2Space Y]
    {f : X → Y} (hf : Continuous f) : t2Quotient X → Y 
goal: t2Quotient X → Y

full_name: t2Quotient.continuous_lift
code: lemma continuous_lift {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] [T2Space Y]
    {f : X → Y} (hf : Continuous f) : Continuous (t2Quotient.lift hf) 
goal: Continuous (t2Quotient.lift hf)

full_name: t2Quotient.lift_mk
code: @[simp]
lemma lift_mk {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] [T2Space Y]
    {f : X → Y} (hf : Continuous f) (x : X) : lift hf (mk x) = f x 
goal: t2Quotient.lift hf (t2Quotient.mk x) = f x

full_name: t2Quotient.unique_lift
code: lemma unique_lift {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] [T2Space Y]
    {f : X → Y} (hf : Continuous f) {g : t2Quotient X → Y} (hfg : g ∘ mk = f) :
    g = lift hf 
goal: g = t2Quotient.lift hf

full_name: isClosed_eq
code: theorem isClosed_eq [T2Space X] {f g : Y → X} (hf : Continuous f) (hg : Continuous g) :
    IsClosed { y : Y | f y = g y } 
goal: IsClosed {y | f y = g y}

full_name: isOpen_ne_fun
code: theorem isOpen_ne_fun [T2Space X] {f g : Y → X} (hf : Continuous f) (hg : Continuous g) :
    IsOpen { y : Y | f y ≠ g y } 
goal: IsOpen {y | f y ≠ g y}

full_name: Set.EqOn.closure
code: /-- If two continuous maps are equal on `s`, then they are equal on the closure of `s`. See also
`Set.EqOn.of_subset_closure` for a more general version. -/
protected theorem Set.EqOn.closure [T2Space X] {s : Set Y} {f g : Y → X} (h : EqOn f g s)
    (hf : Continuous f) (hg : Continuous g) : EqOn f g (closure s) 
goal: Set.EqOn f g (closure s)

full_name: Continuous.ext_on
code: /-- If two continuous functions are equal on a dense set, then they are equal. -/
theorem Continuous.ext_on [T2Space X] {s : Set Y} (hs : Dense s) {f g : Y → X} (hf : Continuous f)
    (hg : Continuous g) (h : EqOn f g s) : f = g 
goal: f = g

full_name: eqOn_closure₂'
code: theorem eqOn_closure₂' [T2Space Z] {s : Set X} {t : Set Y} {f g : X → Y → Z}
    (h : ∀ x ∈ s, ∀ y ∈ t, f x y = g x y) (hf₁ : ∀ x, Continuous (f x))
    (hf₂ : ∀ y, Continuous fun x => f x y) (hg₁ : ∀ x, Continuous (g x))
    (hg₂ : ∀ y, Continuous fun x => g x y) : ∀ x ∈ closure s, ∀ y ∈ closure t, f x y = g x y 
goal: x ∈ closure s → ∀ y ∈ closure t, f x y = g x y

full_name: eqOn_closure₂
code: theorem eqOn_closure₂ [T2Space Z] {s : Set X} {t : Set Y} {f g : X → Y → Z}
    (h : ∀ x ∈ s, ∀ y ∈ t, f x y = g x y) (hf : Continuous (uncurry f))
    (hg : Continuous (uncurry g)) : ∀ x ∈ closure s, ∀ y ∈ closure t, f x y = g x y 
goal: x ∈ closure s → ∀ y ∈ closure t, f x y = g x y

full_name: Set.EqOn.of_subset_closure
code: /-- If `f x = g x` for all `x ∈ s` and `f`, `g` are continuous on `t`, `s ⊆ t ⊆ closure s`, then
`f x = g x` for all `x ∈ t`. See also `Set.EqOn.closure`. -/
theorem Set.EqOn.of_subset_closure [T2Space Y] {s t : Set X} {f g : X → Y} (h : EqOn f g s)
    (hf : ContinuousOn f t) (hg : ContinuousOn g t) (hst : s ⊆ t) (hts : t ⊆ closure s) :
    EqOn f g t 
goal: Set.EqOn f g t

full_name: Function.LeftInverse.isClosed_range
code: theorem Function.LeftInverse.isClosed_range [T2Space X] {f : X → Y} {g : Y → X}
    (h : Function.LeftInverse f g) (hf : Continuous f) (hg : Continuous g) : IsClosed (range g) 
goal: IsClosed (Set.range g)

full_name: Function.LeftInverse.closedEmbedding
code: theorem Function.LeftInverse.closedEmbedding [T2Space X] {f : X → Y} {g : Y → X}
    (h : Function.LeftInverse f g) (hf : Continuous f) (hg : Continuous g) : ClosedEmbedding g 
goal: ClosedEmbedding g

full_name: SeparatedNhds.of_isCompact_isCompact
code: theorem SeparatedNhds.of_isCompact_isCompact [T2Space X] {s t : Set X} (hs : IsCompact s)
    (ht : IsCompact t) (hst : Disjoint s t) : SeparatedNhds s t 
goal: SeparatedNhds s t

full_name: SeparatedNhds.of_finset_finset
code: theorem SeparatedNhds.of_finset_finset [T2Space X] (s t : Finset X) (h : Disjoint s t) :
    SeparatedNhds (s : Set X) t 
goal: SeparatedNhds ↑s ↑t

full_name: SeparatedNhds.of_singleton_finset
code: theorem SeparatedNhds.of_singleton_finset [T2Space X] {x : X} {s : Finset X} (h : x ∉ s) :
    SeparatedNhds ({x} : Set X) s 
goal: SeparatedNhds {x} ↑s

full_name: IsCompact.isClosed
code: /-- In a `T2Space`, every compact set is closed. -/
theorem IsCompact.isClosed [T2Space X] {s : Set X} (hs : IsCompact s) : IsClosed s 
goal: IsClosed s

full_name: IsCompact.preimage_continuous
code: theorem IsCompact.preimage_continuous [CompactSpace X] [T2Space Y] {f : X → Y} {s : Set Y}
    (hs : IsCompact s) (hf : Continuous f) : IsCompact (f ⁻¹' s) 
goal: IsCompact (f ⁻¹' s)

full_name: Pi.isCompact_iff
code: lemma Pi.isCompact_iff {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    [∀ i, T2Space (π i)] {s : Set (Π i, π i)} :
    IsCompact s ↔ IsClosed s ∧ ∀ i, IsCompact (eval i '' s) 
goal: IsCompact s ↔ IsClosed s ∧ ∀ (i : ι), IsCompact (Function.eval i '' s)

full_name: Pi.isCompact_closure_iff
code: lemma Pi.isCompact_closure_iff {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    [∀ i, T2Space (π i)] {s : Set (Π i, π i)} :
    IsCompact (closure s) ↔ ∀ i, IsCompact (closure <| eval i '' s) 
goal: IsCompact (closure s) ↔ ∀ (i : ι), IsCompact (closure (Function.eval i '' s))

full_name: exists_subset_nhds_of_isCompact
code: /-- If `V : ι → Set X` is a decreasing family of compact sets then any neighborhood of
`⋂ i, V i` contains some `V i`. This is a version of `exists_subset_nhds_of_isCompact'` where we
don't need to assume each `V i` closed because it follows from compactness since `X` is
assumed to be Hausdorff. -/
theorem exists_subset_nhds_of_isCompact [T2Space X] {ι : Type*} [Nonempty ι] {V : ι → Set X}
    (hV : Directed (· ⊇ ·) V) (hV_cpct : ∀ i, IsCompact (V i)) {U : Set X}
    (hU : ∀ x ∈ ⋂ i, V i, U ∈ 𝓝 x) : ∃ i, V i ⊆ U 
goal: ∃ i, V i ⊆ U

full_name: CompactExhaustion.isClosed
code: theorem CompactExhaustion.isClosed [T2Space X] (K : CompactExhaustion X) (n : ℕ) : IsClosed (K n) 
goal: IsClosed (K n)

full_name: IsCompact.inter
code: theorem IsCompact.inter [T2Space X] {s t : Set X} (hs : IsCompact s) (ht : IsCompact t) :
    IsCompact (s ∩ t) 
goal: IsCompact (s ∩ t)

full_name: image_closure_of_isCompact
code: theorem image_closure_of_isCompact [T2Space Y] {s : Set X} (hs : IsCompact (closure s)) {f : X → Y}
    (hf : ContinuousOn f (closure s)) : f '' closure s = closure (f '' s) 
goal: f '' closure s = closure (f '' s)

full_name: Continuous.isClosedMap
code: /-- A continuous map from a compact space to a Hausdorff space is a closed map. -/
protected theorem Continuous.isClosedMap [CompactSpace X] [T2Space Y] {f : X → Y}
    (h : Continuous f) : IsClosedMap f 
goal: IsClosedMap f

full_name: Continuous.closedEmbedding
code: /-- A continuous injective map from a compact space to a Hausdorff space is a closed embedding. -/
theorem Continuous.closedEmbedding [CompactSpace X] [T2Space Y] {f : X → Y} (h : Continuous f)
    (hf : Function.Injective f) : ClosedEmbedding f 
goal: ClosedEmbedding f

full_name: QuotientMap.of_surjective_continuous
code: /-- A continuous surjective map from a compact space to a Hausdorff space is a quotient map. -/
theorem QuotientMap.of_surjective_continuous [CompactSpace X] [T2Space Y] {f : X → Y}
    (hsurj : Surjective f) (hcont : Continuous f) : QuotientMap f 
goal: QuotientMap f

full_name: isPreirreducible_iff_subsingleton
code: theorem isPreirreducible_iff_subsingleton [T2Space X] {S : Set X} :
    IsPreirreducible S ↔ S.Subsingleton 
goal: IsPreirreducible S ↔ S.Subsingleton

full_name: IsPreirreducible.subsingleton
code: protected lemma IsPreirreducible.subsingleton [T2Space X] {S : Set X} (h : IsPreirreducible S) :
    S.Subsingleton 
goal: S.Subsingleton

full_name: isIrreducible_iff_singleton
code: theorem isIrreducible_iff_singleton [T2Space X] {S : Set X} : IsIrreducible S ↔ ∃ x, S = {x} 
goal: IsIrreducible S ↔ ∃ x, S = {x}

full_name: not_preirreducible_nontrivial_t2
code: /-- There does not exist a nontrivial preirreducible T₂ space. -/
theorem not_preirreducible_nontrivial_t2 (X) [TopologicalSpace X] [PreirreducibleSpace X]
    [Nontrivial X] [T2Space X] : False 
goal: False

full_name: regularSpace_iff
code: /-- A topological space is called a *regular space* if for any closed set `s` and `a ∉ s`, there
exist disjoint open sets `U ⊇ s` and `V ∋ a`. We formulate this condition in terms of `Disjoint`ness
of filters `𝓝ˢ s` and `𝓝 a`. -/
@[mk_iff]
class RegularSpace (X : Type u) [TopologicalSpace X] : Prop where
  /-- If `a` is a point that does not belong to a closed set `s`, then `a` and `s` admit disjoint
  neighborhoods.  -/
  regular : ∀ {s : Set X} {a}, IsClosed s → a ∉ s → Disjoint (𝓝ˢ s) (𝓝 a)
goal: RegularSpace X ↔ ∀ {s : Set X} {a : X}, IsClosed s → a ∉ s → Disjoint (𝓝ˢ s) (𝓝 a)

full_name: RegularSpace
code: /-- A topological space is called a *regular space* if for any closed set `s` and `a ∉ s`, there
exist disjoint open sets `U ⊇ s` and `V ∋ a`. We formulate this condition in terms of `Disjoint`ness
of filters `𝓝ˢ s` and `𝓝 a`. -/
@[mk_iff]
class RegularSpace (X : Type u) [TopologicalSpace X] : Prop where
  /-- If `a` is a point that does not belong to a closed set `s`, then `a` and `s` admit disjoint
  neighborhoods.  -/
  regular : ∀ {s : Set X} {a}, IsClosed s → a ∉ s → Disjoint (𝓝ˢ s) (𝓝 a)
goal: Prop

full_name: RegularSpace.regular
code: /-- A topological space is called a *regular space* if for any closed set `s` and `a ∉ s`, there
exist disjoint open sets `U ⊇ s` and `V ∋ a`. We formulate this condition in terms of `Disjoint`ness
of filters `𝓝ˢ s` and `𝓝 a`. -/
@[mk_iff]
class RegularSpace (X : Type u) [TopologicalSpace X] : Prop where
  /-- If `a` is a point that does not belong to a closed set `s`, then `a` and `s` admit disjoint
  neighborhoods.  -/
  regular : ∀ {s : Set X} {a}, IsClosed s → a ∉ s → Disjoint (𝓝ˢ s) (𝓝 a)
goal: IsClosed s → a ∉ s → Disjoint (𝓝ˢ s) (𝓝 a)

full_name: regularSpace_TFAE
code: theorem regularSpace_TFAE (X : Type u) [TopologicalSpace X] :
    List.TFAE [RegularSpace X,
      ∀ (s : Set X) x, x ∉ closure s → Disjoint (𝓝ˢ s) (𝓝 x),
      ∀ (x : X) (s : Set X), Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s,
      ∀ (x : X) (s : Set X), s ∈ 𝓝 x → ∃ t ∈ 𝓝 x, IsClosed t ∧ t ⊆ s,
      ∀ x : X, (𝓝 x).lift' closure ≤ 𝓝 x,
      ∀ x : X , (𝓝 x).lift' closure = 𝓝 x] 
goal: [RegularSpace X, ∀ (s : Set X), ∀ x ∉ closure s, Disjoint (𝓝ˢ s) (𝓝 x),
    ∀ (x : X) (s : Set X), Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s, ∀ (x : X), ∀ s ∈ 𝓝 x, ∃ t ∈ 𝓝 x, IsClosed t ∧ t ⊆ s,
    ∀ (x : X), (𝓝 x).lift' closure ≤ 𝓝 x, ∀ (x : X), (𝓝 x).lift' closure = 𝓝 x].TFAE

full_name: RegularSpace.of_lift'_closure_le
code: theorem RegularSpace.of_lift'_closure_le (h : ∀ x : X, (𝓝 x).lift' closure ≤ 𝓝 x) :
    RegularSpace X 
goal: RegularSpace X

full_name: RegularSpace.of_lift'_closure
code: theorem RegularSpace.of_lift'_closure (h : ∀ x : X, (𝓝 x).lift' closure = 𝓝 x) : RegularSpace X 
goal: RegularSpace X

full_name: RegularSpace.of_hasBasis
code: theorem RegularSpace.of_hasBasis {ι : X → Sort*} {p : ∀ a, ι a → Prop} {s : ∀ a, ι a → Set X}
    (h₁ : ∀ a, (𝓝 a).HasBasis (p a) (s a)) (h₂ : ∀ a i, p a i → IsClosed (s a i)) :
    RegularSpace X 
goal: RegularSpace X

full_name: RegularSpace.of_exists_mem_nhds_isClosed_subset
code: theorem RegularSpace.of_exists_mem_nhds_isClosed_subset
    (h : ∀ (x : X), ∀ s ∈ 𝓝 x, ∃ t ∈ 𝓝 x, IsClosed t ∧ t ⊆ s) : RegularSpace X 
goal: RegularSpace X

full_name: instRegularSpaceOfWeaklyLocallyCompactSpaceOfR1Space
code: /-- A weakly locally compact R₁ space is regular. -/
instance (priority := 100) [WeaklyLocallyCompactSpace X] [R1Space X] : RegularSpace X 
goal: RegularSpace X

full_name: disjoint_nhdsSet_nhds
code: theorem disjoint_nhdsSet_nhds : Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s 
goal: Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s

full_name: disjoint_nhds_nhdsSet
code: theorem disjoint_nhds_nhdsSet : Disjoint (𝓝 x) (𝓝ˢ s) ↔ x ∉ closure s 
goal: Disjoint (𝓝 x) (𝓝ˢ s) ↔ x ∉ closure s

full_name: instR1Space
code: /-- A regular space is R₁. -/
instance (priority := 100) : R1Space X 
goal: R1Space X

full_name: exists_mem_nhds_isClosed_subset
code: theorem exists_mem_nhds_isClosed_subset {x : X} {s : Set X} (h : s ∈ 𝓝 x) :
    ∃ t ∈ 𝓝 x, IsClosed t ∧ t ⊆ s 
goal: ∃ t ∈ 𝓝 x, IsClosed t ∧ t ⊆ s

full_name: closed_nhds_basis
code: theorem closed_nhds_basis (x : X) : (𝓝 x).HasBasis (fun s : Set X => s ∈ 𝓝 x ∧ IsClosed s) id 
goal: (𝓝 x).HasBasis (fun s => s ∈ 𝓝 x ∧ IsClosed s) id

full_name: lift'_nhds_closure
code: theorem lift'_nhds_closure (x : X) : (𝓝 x).lift' closure = 𝓝 x 
goal: (𝓝 x).lift' closure = 𝓝 x

full_name: Filter.HasBasis.nhds_closure
code: theorem Filter.HasBasis.nhds_closure {ι : Sort*} {x : X} {p : ι → Prop} {s : ι → Set X}
    (h : (𝓝 x).HasBasis p s) : (𝓝 x).HasBasis p fun i => closure (s i) 
goal: (𝓝 x).HasBasis p fun i => closure (s i)

full_name: hasBasis_nhds_closure
code: theorem hasBasis_nhds_closure (x : X) : (𝓝 x).HasBasis (fun s => s ∈ 𝓝 x) closure 
goal: (𝓝 x).HasBasis (fun s => s ∈ 𝓝 x) closure

full_name: hasBasis_opens_closure
code: theorem hasBasis_opens_closure (x : X) : (𝓝 x).HasBasis (fun s => x ∈ s ∧ IsOpen s) closure 
goal: (𝓝 x).HasBasis (fun s => x ∈ s ∧ IsOpen s) closure

full_name: IsCompact.exists_isOpen_closure_subset
code: theorem IsCompact.exists_isOpen_closure_subset {K U : Set X} (hK : IsCompact K) (hU : U ∈ 𝓝ˢ K) :
    ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U 
goal: ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U

full_name: IsCompact.lift'_closure_nhdsSet
code: theorem IsCompact.lift'_closure_nhdsSet {K : Set X} (hK : IsCompact K) :
    (𝓝ˢ K).lift' closure = 𝓝ˢ K 
goal: (𝓝ˢ K).lift' closure = 𝓝ˢ K

full_name: TopologicalSpace.IsTopologicalBasis.nhds_basis_closure
code: theorem TopologicalSpace.IsTopologicalBasis.nhds_basis_closure {B : Set (Set X)}
    (hB : IsTopologicalBasis B) (x : X) :
    (𝓝 x).HasBasis (fun s : Set X => x ∈ s ∧ s ∈ B) closure 
goal: (𝓝 x).HasBasis (fun s => x ∈ s ∧ s ∈ B) closure

full_name: TopologicalSpace.IsTopologicalBasis.exists_closure_subset
code: theorem TopologicalSpace.IsTopologicalBasis.exists_closure_subset {B : Set (Set X)}
    (hB : IsTopologicalBasis B) {x : X} {s : Set X} (h : s ∈ 𝓝 x) :
    ∃ t ∈ B, x ∈ t ∧ closure t ⊆ s 
goal: ∃ t ∈ B, x ∈ t ∧ closure t ⊆ s

full_name: Inducing.regularSpace
code: protected theorem Inducing.regularSpace [TopologicalSpace Y] {f : Y → X} (hf : Inducing f) :
    RegularSpace Y 
goal: RegularSpace Y

full_name: regularSpace_induced
code: theorem regularSpace_induced (f : Y → X) : @RegularSpace Y (induced f ‹_›) 
goal: RegularSpace Y

full_name: regularSpace_sInf
code: theorem regularSpace_sInf {X} {T : Set (TopologicalSpace X)} (h : ∀ t ∈ T, @RegularSpace X t) :
    @RegularSpace X (sInf T) 
goal: RegularSpace X

full_name: regularSpace_iInf
code: theorem regularSpace_iInf {ι X} {t : ι → TopologicalSpace X} (h : ∀ i, @RegularSpace X (t i)) :
    @RegularSpace X (iInf t) 
goal: RegularSpace X

full_name: RegularSpace.inf
code: theorem RegularSpace.inf {X} {t₁ t₂ : TopologicalSpace X} (h₁ : @RegularSpace X t₁)
    (h₂ : @RegularSpace X t₂) : @RegularSpace X (t₁ ⊓ t₂) 
goal: RegularSpace X

full_name: instRegularSpaceSubtype
code: instance {p : X → Prop} : RegularSpace (Subtype p) 
goal: RegularSpace (Subtype p)

full_name: instRegularSpaceProd
code: instance [TopologicalSpace Y] [RegularSpace Y] : RegularSpace (X × Y) 
goal: RegularSpace (X × Y)

full_name: instRegularSpaceForall
code: instance {ι : Type*} {X : ι → Type*} [∀ i, TopologicalSpace (X i)] [∀ i, RegularSpace (X i)] :
    RegularSpace (∀ i, X i) 
goal: RegularSpace ((i : ι) → X i)

full_name: SeparatedNhds.of_isCompact_isClosed
code: /-- In a regular space, if a compact set and a closed set are disjoint, then they have disjoint
neighborhoods. -/
lemma SeparatedNhds.of_isCompact_isClosed {s t : Set X}
    (hs : IsCompact s) (ht : IsClosed t) (hst : Disjoint s t) : SeparatedNhds s t 
goal: SeparatedNhds s t

full_name: IsClosed.HasSeparatingCover
code: /-- This technique to witness `HasSeparatingCover` in regular Lindelöf topological spaces
will be used to prove regular Lindelöf spaces are normal. -/
lemma IsClosed.HasSeparatingCover {s t : Set X} [r : RegularSpace X] [LindelofSpace X]
    (s_cl : IsClosed s) (t_cl : IsClosed t) (st_dis : Disjoint s t) : HasSeparatingCover s t 
goal: HasSeparatingCover s t

full_name: exists_compact_closed_between
code: /-- In a (possibly non-Hausdorff) locally compact regular space, for every containment `K ⊆ U` of
  a compact set `K` in an open set `U`, there is a compact closed neighborhood `L`
  such that `K ⊆ L ⊆ U`: equivalently, there is a compact closed set `L` such
  that `K ⊆ interior L` and `L ⊆ U`. -/
theorem exists_compact_closed_between [LocallyCompactSpace X] [RegularSpace X]
    {K U : Set X} (hK : IsCompact K) (hU : IsOpen U) (h_KU : K ⊆ U) :
    ∃ L, IsCompact L ∧ IsClosed L ∧ K ⊆ interior L ∧ L ⊆ U 
goal: ∃ L, IsCompact L ∧ IsClosed L ∧ K ⊆ interior L ∧ L ⊆ U

full_name: exists_open_between_and_isCompact_closure
code: /-- In a locally compact regular space, given a compact set `K` inside an open set `U`, we can find
an open set `V` between these sets with compact closure: `K ⊆ V` and the closure of `V` is
inside `U`. -/
theorem exists_open_between_and_isCompact_closure [LocallyCompactSpace X] [RegularSpace X]
    {K U : Set X} (hK : IsCompact K) (hU : IsOpen U) (hKU : K ⊆ U) :
    ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U ∧ IsCompact (closure V) 
goal: ∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U ∧ IsCompact (closure V)

full_name: locally_compact_of_compact
code: @[deprecated WeaklyLocallyCompactSpace.locallyCompactSpace (since := "2023-09-03")]
theorem locally_compact_of_compact [T2Space X] [CompactSpace X] :
    LocallyCompactSpace X 
goal: LocallyCompactSpace X

full_name: T25Space
code: /-- A T₂.₅ space, also known as a Urysohn space, is a topological space
  where for every pair `x ≠ y`, there are two open sets, with the intersection of closures
  empty, one containing `x` and the other `y` . -/
class T25Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- Given two distinct points in a T₂.₅ space, their filters of closed neighborhoods are
  disjoint. -/
  t2_5 : ∀ ⦃x y : X⦄, x ≠ y → Disjoint ((𝓝 x).lift' closure) ((𝓝 y).lift' closure)
goal: Prop

full_name: T25Space.t2_5
code: /-- A T₂.₅ space, also known as a Urysohn space, is a topological space
  where for every pair `x ≠ y`, there are two open sets, with the intersection of closures
  empty, one containing `x` and the other `y` . -/
class T25Space (X : Type u) [TopologicalSpace X] : Prop where
  /-- Given two distinct points in a T₂.₅ space, their filters of closed neighborhoods are
  disjoint. -/
  t2_5 : ∀ ⦃x y : X⦄, x ≠ y → Disjoint ((𝓝 x).lift' closure) ((𝓝 y).lift' closure)
goal: x ≠ y → Disjoint ((𝓝 x).lift' closure) ((𝓝 y).lift' closure)

full_name: disjoint_lift'_closure_nhds
code: @[simp]
theorem disjoint_lift'_closure_nhds [T25Space X] {x y : X} :
    Disjoint ((𝓝 x).lift' closure) ((𝓝 y).lift' closure) ↔ x ≠ y 
goal: Disjoint ((𝓝 x).lift' closure) ((𝓝 y).lift' closure) ↔ x ≠ y

full_name: T25Space.t2Space
code: instance (priority := 100) T25Space.t2Space [T25Space X] : T2Space X 
goal: T2Space X

full_name: exists_nhds_disjoint_closure
code: theorem exists_nhds_disjoint_closure [T25Space X] {x y : X} (h : x ≠ y) :
    ∃ s ∈ 𝓝 x, ∃ t ∈ 𝓝 y, Disjoint (closure s) (closure t) 
goal: ∃ s ∈ 𝓝 x, ∃ t ∈ 𝓝 y, Disjoint (closure s) (closure t)

full_name: exists_open_nhds_disjoint_closure
code: theorem exists_open_nhds_disjoint_closure [T25Space X] {x y : X} (h : x ≠ y) :
    ∃ u : Set X,
      x ∈ u ∧ IsOpen u ∧ ∃ v : Set X, y ∈ v ∧ IsOpen v ∧ Disjoint (closure u) (closure v) 
goal: ∃ u, x ∈ u ∧ IsOpen u ∧ ∃ v, y ∈ v ∧ IsOpen v ∧ Disjoint (closure u) (closure v)

full_name: T25Space.of_injective_continuous
code: theorem T25Space.of_injective_continuous [TopologicalSpace Y] [T25Space Y] {f : X → Y}
    (hinj : Injective f) (hcont : Continuous f) : T25Space X 
goal: T25Space X

full_name: Embedding.t25Space
code: theorem Embedding.t25Space [TopologicalSpace Y] [T25Space Y] {f : X → Y} (hf : Embedding f) :
    T25Space X 
goal: T25Space X

full_name: Subtype.instT25Space
code: instance Subtype.instT25Space [T25Space X] {p : X → Prop} : T25Space {x // p x} 
goal: T25Space { x // p x }

full_name: T3Space
code: /-- A T₃ space is a T₀ space which is a regular space. Any T₃ space is a T₁ space, a T₂ space, and
a T₂.₅ space.  -/
class T3Space (X : Type u) [TopologicalSpace X] extends T0Space X, RegularSpace X : Prop
goal: Prop

full_name: instT3Space
code: instance (priority := 90) instT3Space [T0Space X] [RegularSpace X] : T3Space X 
goal: T3Space X

full_name: RegularSpace.t3Space_iff_t0Space
code: theorem RegularSpace.t3Space_iff_t0Space [RegularSpace X] : T3Space X ↔ T0Space X 
goal: T3Space X ↔ T0Space X

full_name: T3Space.t25Space
code: instance (priority := 100) T3Space.t25Space [T3Space X] : T25Space X 
goal: T25Space X

full_name: Embedding.t3Space
code: protected theorem Embedding.t3Space [TopologicalSpace Y] [T3Space Y] {f : X → Y}
    (hf : Embedding f) : T3Space X 
goal: T3Space X

full_name: Subtype.t3Space
code: instance Subtype.t3Space [T3Space X] {p : X → Prop} : T3Space (Subtype p) 
goal: T3Space (Subtype p)

full_name: ULift.instT3Space
code: instance ULift.instT3Space [T3Space X] : T3Space (ULift X) 
goal: T3Space (ULift.{u_3, u_1} X)

full_name: instT3SpaceProd
code: instance [TopologicalSpace Y] [T3Space X] [T3Space Y] : T3Space (X × Y) 
goal: T3Space (X × Y)

full_name: instT3SpaceForall
code: instance {ι : Type*} {X : ι → Type*} [∀ i, TopologicalSpace (X i)] [∀ i, T3Space (X i)] :
    T3Space (∀ i, X i) 
goal: T3Space ((i : ι) → X i)

full_name: disjoint_nested_nhds
code: /-- Given two points `x ≠ y`, we can find neighbourhoods `x ∈ V₁ ⊆ U₁` and `y ∈ V₂ ⊆ U₂`,
with the `Vₖ` closed and the `Uₖ` open, such that the `Uₖ` are disjoint. -/
theorem disjoint_nested_nhds [T3Space X] {x y : X} (h : x ≠ y) :
    ∃ U₁ ∈ 𝓝 x, ∃ V₁ ∈ 𝓝 x, ∃ U₂ ∈ 𝓝 y, ∃ V₂ ∈ 𝓝 y,
      IsClosed V₁ ∧ IsClosed V₂ ∧ IsOpen U₁ ∧ IsOpen U₂ ∧ V₁ ⊆ U₁ ∧ V₂ ⊆ U₂ ∧ Disjoint U₁ U₂ 
goal: ∃ U₁ ∈ 𝓝 x,
  ∃ V₁ ∈ 𝓝 x,
    ∃ U₂ ∈ 𝓝 y, ∃ V₂ ∈ 𝓝 y, IsClosed V₁ ∧ IsClosed V₂ ∧ IsOpen U₁ ∧ IsOpen U₂ ∧ V₁ ⊆ U₁ ∧ V₂ ⊆ U₂ ∧ Disjoint U₁ U₂

full_name: instT3SpaceSeparationQuotientOfRegularSpace
code: /-- The `SeparationQuotient` of a regular space is a T₃ space. -/
instance [RegularSpace X] : T3Space (SeparationQuotient X) 
goal: T3Space (SeparationQuotient X)

full_name: NormalSpace
code: /-- A topological space is said to be a *normal space* if any two disjoint closed sets
have disjoint open neighborhoods. -/
class NormalSpace (X : Type u) [TopologicalSpace X] : Prop where
  /-- Two disjoint sets in a normal space admit disjoint neighbourhoods. -/
  normal : ∀ s t : Set X, IsClosed s → IsClosed t → Disjoint s t → SeparatedNhds s t
goal: Prop

full_name: NormalSpace.normal
code: /-- A topological space is said to be a *normal space* if any two disjoint closed sets
have disjoint open neighborhoods. -/
class NormalSpace (X : Type u) [TopologicalSpace X] : Prop where
  /-- Two disjoint sets in a normal space admit disjoint neighbourhoods. -/
  normal : ∀ s t : Set X, IsClosed s → IsClosed t → Disjoint s t → SeparatedNhds s t
goal: IsClosed s → IsClosed t → Disjoint s t → SeparatedNhds s t

full_name: normal_separation
code: theorem normal_separation [NormalSpace X] {s t : Set X} (H1 : IsClosed s) (H2 : IsClosed t)
    (H3 : Disjoint s t) : SeparatedNhds s t 
goal: SeparatedNhds s t

full_name: disjoint_nhdsSet_nhdsSet
code: theorem disjoint_nhdsSet_nhdsSet [NormalSpace X] {s t : Set X} (hs : IsClosed s) (ht : IsClosed t)
    (hd : Disjoint s t) : Disjoint (𝓝ˢ s) (𝓝ˢ t) 
goal: Disjoint (𝓝ˢ s) (𝓝ˢ t)

full_name: normal_exists_closure_subset
code: theorem normal_exists_closure_subset [NormalSpace X] {s t : Set X} (hs : IsClosed s) (ht : IsOpen t)
    (hst : s ⊆ t) : ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t 
goal: ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t

full_name: ClosedEmbedding.normalSpace
code: /-- If the codomain of a closed embedding is a normal space, then so is the domain. -/
protected theorem ClosedEmbedding.normalSpace [TopologicalSpace Y] [NormalSpace Y] {f : X → Y}
    (hf : ClosedEmbedding f) : NormalSpace X 
goal: NormalSpace X

full_name: NormalSpace.of_compactSpace_r1Space
code: instance (priority := 100) NormalSpace.of_compactSpace_r1Space [CompactSpace X] [R1Space X] :
    NormalSpace X 
goal: NormalSpace X

full_name: NormalSpace.of_regularSpace_lindelofSpace
code: /-- A regular topological space with a Lindelöf topology is a normal space. A consequence of e.g.
Corollaries 20.8 and 20.10 of [Willard's *General Topology*][zbMATH02107988] (without the
assumption of Hausdorff). -/
instance (priority := 100) NormalSpace.of_regularSpace_lindelofSpace
    [RegularSpace X] [LindelofSpace X] : NormalSpace X 
goal: NormalSpace X

full_name: NormalSpace.of_regularSpace_secondCountableTopology
code: instance (priority := 100) NormalSpace.of_regularSpace_secondCountableTopology
    [RegularSpace X] [SecondCountableTopology X] : NormalSpace X 
goal: NormalSpace X

full_name: T4Space
code: /-- A T₄ space is a normal T₁ space. -/
class T4Space (X : Type u) [TopologicalSpace X] extends T1Space X, NormalSpace X : Prop
goal: Prop

full_name: instT4SpaceOfT1SpaceOfNormalSpace
code: instance (priority := 100) [T1Space X] [NormalSpace X] : T4Space X 
goal: T4Space X

full_name: T4Space.t3Space
code: instance (priority := 100) T4Space.t3Space [T4Space X] : T3Space X 
goal: T3Space X

full_name: T4Space.of_compactSpace_t2Space
code: @[deprecated inferInstance (since := "2024-01-28")]
theorem T4Space.of_compactSpace_t2Space [CompactSpace X] [T2Space X] :
    T4Space X 
goal: T4Space X

full_name: ClosedEmbedding.t4Space
code: /-- If the codomain of a closed embedding is a T₄ space, then so is the domain. -/
protected theorem ClosedEmbedding.t4Space [TopologicalSpace Y] [T4Space Y] {f : X → Y}
    (hf : ClosedEmbedding f) : T4Space X 
goal: T4Space X

full_name: ULift.instT4Space
code: instance ULift.instT4Space [T4Space X] : T4Space (ULift X) 
goal: T4Space (ULift.{u_3, u_1} X)

full_name: SeparationQuotient.instNormalSpace
code: /-- The `SeparationQuotient` of a normal space is a normal space. -/
instance [NormalSpace X] : NormalSpace (SeparationQuotient X) 
goal: NormalSpace (SeparationQuotient X)

full_name: CompletelyNormalSpace
code: /-- A topological space `X` is a *completely normal space* provided that for any two sets `s`, `t`
such that if both `closure s` is disjoint with `t`, and `s` is disjoint with `closure t`,
then there exist disjoint neighbourhoods of `s` and `t`. -/
class CompletelyNormalSpace (X : Type u) [TopologicalSpace X] : Prop where
  /-- If `closure s` is disjoint with `t`, and `s` is disjoint with `closure t`, then `s` and `t`
  admit disjoint neighbourhoods. -/
  completely_normal :
    ∀ ⦃s t : Set X⦄, Disjoint (closure s) t → Disjoint s (closure t) → Disjoint (𝓝ˢ s) (𝓝ˢ t)
goal: Prop

full_name: CompletelyNormalSpace.completely_normal
code: /-- A topological space `X` is a *completely normal space* provided that for any two sets `s`, `t`
such that if both `closure s` is disjoint with `t`, and `s` is disjoint with `closure t`,
then there exist disjoint neighbourhoods of `s` and `t`. -/
class CompletelyNormalSpace (X : Type u) [TopologicalSpace X] : Prop where
  /-- If `closure s` is disjoint with `t`, and `s` is disjoint with `closure t`, then `s` and `t`
  admit disjoint neighbourhoods. -/
  completely_normal :
    ∀ ⦃s t : Set X⦄, Disjoint (closure s) t → Disjoint s (closure t) → Disjoint (𝓝ˢ s) (𝓝ˢ t)
goal: Disjoint (closure s) t → Disjoint s (closure t) → Disjoint (𝓝ˢ s) (𝓝ˢ t)

full_name: CompletelyNormalSpace.toNormalSpace
code: /-- A completely normal space is a normal space. -/
instance (priority := 100) CompletelyNormalSpace.toNormalSpace
    [CompletelyNormalSpace X] : NormalSpace X 
goal: NormalSpace X

full_name: Embedding.completelyNormalSpace
code: theorem Embedding.completelyNormalSpace [TopologicalSpace Y] [CompletelyNormalSpace Y] {e : X → Y}
    (he : Embedding e) : CompletelyNormalSpace X 
goal: CompletelyNormalSpace X

full_name: instCompletelyNormalSpaceSubtype
code: /-- A subspace of a completely normal space is a completely normal space. -/
instance [CompletelyNormalSpace X] {p : X → Prop} : CompletelyNormalSpace { x // p x } 
goal: CompletelyNormalSpace { x // p x }

full_name: ULift.instCompletelyNormalSpace
code: instance ULift.instCompletelyNormalSpace [CompletelyNormalSpace X] :
    CompletelyNormalSpace (ULift X) 
goal: CompletelyNormalSpace (ULift.{u_3, u_1} X)

full_name: T5Space
code: /-- A T₅ space is a completely normal T₁ space. -/
class T5Space (X : Type u) [TopologicalSpace X] extends T1Space X, CompletelyNormalSpace X : Prop
goal: Prop

full_name: Embedding.t5Space
code: theorem Embedding.t5Space [TopologicalSpace Y] [T5Space Y] {e : X → Y} (he : Embedding e) :
    T5Space X 
goal: T5Space X

full_name: T5Space.toT4Space
code: /-- A `T₅` space is a `T₄` space. -/
instance (priority := 100) T5Space.toT4Space [T5Space X] : T4Space X 
goal: T4Space X

full_name: instT5SpaceSubtype
code: /-- A subspace of a T₅ space is a T₅ space. -/
instance [T5Space X] {p : X → Prop} : T5Space { x // p x } 
goal: T5Space { x // p x }

full_name: ULift.instT5Space
code: instance ULift.instT5Space [T5Space X] : T5Space (ULift X) 
goal: T5Space (ULift.{u_3, u_1} X)

full_name: instT5SpaceSeparationQuotientOfCompletelyNormalSpaceOfR0Space
code: /-- The `SeparationQuotient` of a completely normal R₀ space is a T₅ space. -/
instance [CompletelyNormalSpace X] [R0Space X] : T5Space (SeparationQuotient X) 
goal: T5Space (SeparationQuotient X)

full_name: PerfectlyNormalSpace.closed_gdelta
code: /-- A topological space `X` is a *perfectly normal space* provided it is normal and
closed sets are Gδ. -/
class PerfectlyNormalSpace (X : Type u) [TopologicalSpace X] extends NormalSpace X : Prop where
    closed_gdelta : ∀ ⦃h : Set X⦄, IsClosed h → IsGδ h
goal: IsClosed h → IsGδ h

full_name: PerfectlyNormalSpace
code: /-- A topological space `X` is a *perfectly normal space* provided it is normal and
closed sets are Gδ. -/
class PerfectlyNormalSpace (X : Type u) [TopologicalSpace X] extends NormalSpace X : Prop where
    closed_gdelta : ∀ ⦃h : Set X⦄, IsClosed h → IsGδ h
goal: Prop

full_name: Disjoint.hasSeparatingCover_closed_gdelta_right
code: /-- Lemma that allows the easy conclusion that perfectly normal spaces are completely normal. -/
theorem Disjoint.hasSeparatingCover_closed_gdelta_right {s t : Set X} [NormalSpace X]
    (st_dis : Disjoint s t) (t_cl : IsClosed t) (t_gd : IsGδ t) : HasSeparatingCover s t 
goal: HasSeparatingCover s t

full_name: PerfectlyNormalSpace.toCompletelyNormalSpace
code: instance (priority := 100) PerfectlyNormalSpace.toCompletelyNormalSpace
    [PerfectlyNormalSpace X] : CompletelyNormalSpace X 
goal: CompletelyNormalSpace X

full_name: T6Space
code: /-- A T₆ space is a perfectly normal T₁ space. -/
class T6Space (X : Type u) [TopologicalSpace X] extends T1Space X, PerfectlyNormalSpace X : Prop
goal: Prop

full_name: T6Space.toT5Space
code: /-- A `T₆` space is a `T₅` space. -/
instance (priority := 100) T6Space.toT5Space [T6Space X] : T5Space X 
goal: T5Space X

full_name: connectedComponent_eq_iInter_isClopen
code: /-- In a compact T₂ space, the connected component of a point equals the intersection of all
its clopen neighbourhoods. -/
theorem connectedComponent_eq_iInter_isClopen [T2Space X] [CompactSpace X] (x : X) :
    connectedComponent x = ⋂ s : { s : Set X // IsClopen s ∧ x ∈ s }, s 
goal: connectedComponent x = ⋂ s, ↑s

full_name: totallySeparatedSpace_of_t1_of_basis_clopen
code: /-- A T1 space with a clopen basis is totally separated. -/
theorem totallySeparatedSpace_of_t1_of_basis_clopen [T1Space X]
    (h : IsTopologicalBasis { s : Set X | IsClopen s }) : TotallySeparatedSpace X 
goal: TotallySeparatedSpace X

full_name: compact_t2_tot_disc_iff_tot_sep
code: /-- A compact Hausdorff space is totally disconnected if and only if it is totally separated, this
  is also true for locally compact spaces. -/
theorem compact_t2_tot_disc_iff_tot_sep : TotallyDisconnectedSpace X ↔ TotallySeparatedSpace X 
goal: TotallyDisconnectedSpace X ↔ TotallySeparatedSpace X

full_name: instTotallySeparatedSpace
code: /-- A totally disconnected compact Hausdorff space is totally separated. -/
instance (priority := 100) : TotallySeparatedSpace X 
goal: TotallySeparatedSpace X

full_name: nhds_basis_clopen
code: theorem nhds_basis_clopen (x : X) : (𝓝 x).HasBasis (fun s : Set X => x ∈ s ∧ IsClopen s) id 
goal: (𝓝 x).HasBasis (fun s => x ∈ s ∧ IsClopen s) id

full_name: isTopologicalBasis_isClopen
code: theorem isTopologicalBasis_isClopen : IsTopologicalBasis { s : Set X | IsClopen s } 
goal: TopologicalSpace.IsTopologicalBasis {s | IsClopen s}

full_name: compact_exists_isClopen_in_isOpen
code: /-- Every member of an open set in a compact Hausdorff totally disconnected space
  is contained in a clopen set contained in the open set.  -/
theorem compact_exists_isClopen_in_isOpen {x : X} {U : Set X} (is_open : IsOpen U) (memU : x ∈ U) :
    ∃ V : Set X, IsClopen V ∧ x ∈ V ∧ V ⊆ U 
goal: ∃ V, IsClopen V ∧ x ∈ V ∧ V ⊆ U

full_name: loc_compact_Haus_tot_disc_of_zero_dim
code: /-- A locally compact Hausdorff totally disconnected space has a basis with clopen elements. -/
theorem loc_compact_Haus_tot_disc_of_zero_dim [TotallyDisconnectedSpace H] :
    IsTopologicalBasis { s : Set H | IsClopen s } 
goal: TopologicalSpace.IsTopologicalBasis {s | IsClopen s}

full_name: loc_compact_t2_tot_disc_iff_tot_sep
code: /-- A locally compact Hausdorff space is totally disconnected
  if and only if it is totally separated. -/
theorem loc_compact_t2_tot_disc_iff_tot_sep :
    TotallyDisconnectedSpace H ↔ TotallySeparatedSpace H 
goal: TotallyDisconnectedSpace H ↔ TotallySeparatedSpace H

full_name: ConnectedComponents.t2
code: /-- `ConnectedComponents X` is Hausdorff when `X` is Hausdorff and compact -/
instance ConnectedComponents.t2 [T2Space X] [CompactSpace X] : T2Space (ConnectedComponents X) 
goal: T2Space (ConnectedComponents X)