File: Mathlib/Topology/Bases.lean

full_name: TopologicalSpace.IsTopologicalBasis.exists_subset_inter
code: /-- A topological basis is one that satisfies the necessary conditions so that
  it suffices to take unions of the basis sets to get a topology (without taking
  finite intersections as well). -/
structure IsTopologicalBasis (s : Set (Set α)) : Prop where
  /-- For every point `x`, the set of `t ∈ s` such that `x ∈ t` is directed downwards.  -/
  exists_subset_inter : ∀ t₁ ∈ s, ∀ t₂ ∈ s, ∀ x ∈ t₁ ∩ t₂, ∃ t₃ ∈ s, x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂
  /-- The sets from `s` cover the whole space. -/
  sUnion_eq : ⋃₀ s = univ
  /-- The topology is generated by sets from `s`. -/
  eq_generateFrom : t = generateFrom s
goal: t₁ ∈ s → ∀ t₂ ∈ s, ∀ x ∈ t₁ ∩ t₂, ∃ t₃ ∈ s, x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂

full_name: TopologicalSpace.IsTopologicalBasis.sUnion_eq
code: /-- A topological basis is one that satisfies the necessary conditions so that
  it suffices to take unions of the basis sets to get a topology (without taking
  finite intersections as well). -/
structure IsTopologicalBasis (s : Set (Set α)) : Prop where
  /-- For every point `x`, the set of `t ∈ s` such that `x ∈ t` is directed downwards.  -/
  exists_subset_inter : ∀ t₁ ∈ s, ∀ t₂ ∈ s, ∀ x ∈ t₁ ∩ t₂, ∃ t₃ ∈ s, x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂
  /-- The sets from `s` cover the whole space. -/
  sUnion_eq : ⋃₀ s = univ
  /-- The topology is generated by sets from `s`. -/
  eq_generateFrom : t = generateFrom s
goal: ⋃₀ s = Set.univ

full_name: TopologicalSpace.IsTopologicalBasis.eq_generateFrom
code: /-- A topological basis is one that satisfies the necessary conditions so that
  it suffices to take unions of the basis sets to get a topology (without taking
  finite intersections as well). -/
structure IsTopologicalBasis (s : Set (Set α)) : Prop where
  /-- For every point `x`, the set of `t ∈ s` such that `x ∈ t` is directed downwards.  -/
  exists_subset_inter : ∀ t₁ ∈ s, ∀ t₂ ∈ s, ∀ x ∈ t₁ ∩ t₂, ∃ t₃ ∈ s, x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂
  /-- The sets from `s` cover the whole space. -/
  sUnion_eq : ⋃₀ s = univ
  /-- The topology is generated by sets from `s`. -/
  eq_generateFrom : t = generateFrom s
goal: t = TopologicalSpace.generateFrom s

full_name: TopologicalSpace.IsTopologicalBasis
code: /-- A topological basis is one that satisfies the necessary conditions so that
  it suffices to take unions of the basis sets to get a topology (without taking
  finite intersections as well). -/
structure IsTopologicalBasis (s : Set (Set α)) : Prop where
  /-- For every point `x`, the set of `t ∈ s` such that `x ∈ t` is directed downwards.  -/
  exists_subset_inter : ∀ t₁ ∈ s, ∀ t₂ ∈ s, ∀ x ∈ t₁ ∩ t₂, ∃ t₃ ∈ s, x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂
  /-- The sets from `s` cover the whole space. -/
  sUnion_eq : ⋃₀ s = univ
  /-- The topology is generated by sets from `s`. -/
  eq_generateFrom : t = generateFrom s
goal: Prop

full_name: TopologicalSpace.IsTopologicalBasis.insert_empty
code: theorem IsTopologicalBasis.insert_empty {s : Set (Set α)} (h : IsTopologicalBasis s) :
    IsTopologicalBasis (insert ∅ s) 
goal: TopologicalSpace.IsTopologicalBasis (insert ∅ s)

full_name: TopologicalSpace.IsTopologicalBasis.diff_empty
code: theorem IsTopologicalBasis.diff_empty {s : Set (Set α)} (h : IsTopologicalBasis s) :
    IsTopologicalBasis (s \ {∅}) 
goal: TopologicalSpace.IsTopologicalBasis (s \ {∅})

full_name: TopologicalSpace.isTopologicalBasis_of_subbasis
code: /-- If a family of sets `s` generates the topology, then intersections of finite
subcollections of `s` form a topological basis. -/
theorem isTopologicalBasis_of_subbasis {s : Set (Set α)} (hs : t = generateFrom s) :
    IsTopologicalBasis ((fun f => ⋂₀ f) '' { f : Set (Set α) | f.Finite ∧ f ⊆ s }) 
goal: TopologicalSpace.IsTopologicalBasis ((fun f => ⋂₀ f) '' {f | f.Finite ∧ f ⊆ s})

full_name: TopologicalSpace.isTopologicalBasis_of_subbasis_of_finiteInter
code: theorem isTopologicalBasis_of_subbasis_of_finiteInter {s : Set (Set α)} (hsg : t = generateFrom s)
    (hsi : FiniteInter s) : IsTopologicalBasis s 
goal: TopologicalSpace.IsTopologicalBasis s

full_name: TopologicalSpace.isTopologicalBasis_of_subbasis_of_inter
code: theorem isTopologicalBasis_of_subbasis_of_inter {r : Set (Set α)} (hsg : t = generateFrom r)
    (hsi : ∀ ⦃s⦄, s ∈ r → ∀ ⦃t⦄, t ∈ r → s ∩ t ∈ r) : IsTopologicalBasis (insert univ r) 
goal: TopologicalSpace.IsTopologicalBasis (insert Set.univ r)

full_name: TopologicalSpace.IsTopologicalBasis.of_hasBasis_nhds
code: theorem IsTopologicalBasis.of_hasBasis_nhds {s : Set (Set α)}
    (h_nhds : ∀ a, (𝓝 a).HasBasis (fun t ↦ t ∈ s ∧ a ∈ t) id) : IsTopologicalBasis s 
goal: TopologicalSpace.IsTopologicalBasis s

full_name: TopologicalSpace.isTopologicalBasis_of_isOpen_of_nhds
code: /-- If a family of open sets `s` is such that every open neighbourhood contains some
member of `s`, then `s` is a topological basis. -/
theorem isTopologicalBasis_of_isOpen_of_nhds {s : Set (Set α)} (h_open : ∀ u ∈ s, IsOpen u)
    (h_nhds : ∀ (a : α) (u : Set α), a ∈ u → IsOpen u → ∃ v ∈ s, a ∈ v ∧ v ⊆ u) :
    IsTopologicalBasis s 
goal: TopologicalSpace.IsTopologicalBasis s

full_name: TopologicalSpace.IsTopologicalBasis.mem_nhds_iff
code: /-- A set `s` is in the neighbourhood of `a` iff there is some basis set `t`, which
contains `a` and is itself contained in `s`. -/
theorem IsTopologicalBasis.mem_nhds_iff {a : α} {s : Set α} {b : Set (Set α)}
    (hb : IsTopologicalBasis b) : s ∈ 𝓝 a ↔ ∃ t ∈ b, a ∈ t ∧ t ⊆ s 
goal: s ∈ 𝓝 a ↔ ∃ t ∈ b, a ∈ t ∧ t ⊆ s

full_name: TopologicalSpace.IsTopologicalBasis.isOpen_iff
code: theorem IsTopologicalBasis.isOpen_iff {s : Set α} {b : Set (Set α)} (hb : IsTopologicalBasis b) :
    IsOpen s ↔ ∀ a ∈ s, ∃ t ∈ b, a ∈ t ∧ t ⊆ s 
goal: IsOpen s ↔ ∀ a ∈ s, ∃ t ∈ b, a ∈ t ∧ t ⊆ s

full_name: TopologicalSpace.IsTopologicalBasis.nhds_hasBasis
code: theorem IsTopologicalBasis.nhds_hasBasis {b : Set (Set α)} (hb : IsTopologicalBasis b) {a : α} :
    (𝓝 a).HasBasis (fun t : Set α => t ∈ b ∧ a ∈ t) fun t => t 
goal: (𝓝 a).HasBasis (fun t => t ∈ b ∧ a ∈ t) fun t => t

full_name: TopologicalSpace.IsTopologicalBasis.isOpen
code: protected theorem IsTopologicalBasis.isOpen {s : Set α} {b : Set (Set α)}
    (hb : IsTopologicalBasis b) (hs : s ∈ b) : IsOpen s 
goal: IsOpen s

full_name: TopologicalSpace.IsTopologicalBasis.mem_nhds
code: protected theorem IsTopologicalBasis.mem_nhds {a : α} {s : Set α} {b : Set (Set α)}
    (hb : IsTopologicalBasis b) (hs : s ∈ b) (ha : a ∈ s) : s ∈ 𝓝 a 
goal: s ∈ 𝓝 a

full_name: TopologicalSpace.IsTopologicalBasis.exists_subset_of_mem_open
code: theorem IsTopologicalBasis.exists_subset_of_mem_open {b : Set (Set α)} (hb : IsTopologicalBasis b)
    {a : α} {u : Set α} (au : a ∈ u) (ou : IsOpen u) : ∃ v ∈ b, a ∈ v ∧ v ⊆ u 
goal: ∃ v ∈ b, a ∈ v ∧ v ⊆ u

full_name: TopologicalSpace.IsTopologicalBasis.open_eq_sUnion'
code: /-- Any open set is the union of the basis sets contained in it. -/
theorem IsTopologicalBasis.open_eq_sUnion' {B : Set (Set α)} (hB : IsTopologicalBasis B) {u : Set α}
    (ou : IsOpen u) : u = ⋃₀ { s ∈ B | s ⊆ u } 
goal: u = ⋃₀ {s | s ∈ B ∧ s ⊆ u}

full_name: TopologicalSpace.IsTopologicalBasis.open_eq_sUnion
code: theorem IsTopologicalBasis.open_eq_sUnion {B : Set (Set α)} (hB : IsTopologicalBasis B) {u : Set α}
    (ou : IsOpen u) : ∃ S ⊆ B, u = ⋃₀ S 
goal: ∃ S ⊆ B, u = ⋃₀ S

full_name: TopologicalSpace.IsTopologicalBasis.open_iff_eq_sUnion
code: theorem IsTopologicalBasis.open_iff_eq_sUnion {B : Set (Set α)} (hB : IsTopologicalBasis B)
    {u : Set α} : IsOpen u ↔ ∃ S ⊆ B, u = ⋃₀ S 
goal: IsOpen u ↔ ∃ S ⊆ B, u = ⋃₀ S

full_name: TopologicalSpace.IsTopologicalBasis.open_eq_iUnion
code: theorem IsTopologicalBasis.open_eq_iUnion {B : Set (Set α)} (hB : IsTopologicalBasis B) {u : Set α}
    (ou : IsOpen u) : ∃ (β : Type u) (f : β → Set α), (u = ⋃ i, f i) ∧ ∀ i, f i ∈ B 
goal: ∃ β f, u = ⋃ i, f i ∧ ∀ (i : β), f i ∈ B

full_name: TopologicalSpace.IsTopologicalBasis.subset_of_forall_subset
code: lemma IsTopologicalBasis.subset_of_forall_subset {t : Set α} (hB : IsTopologicalBasis B)
    (hs : IsOpen s) (h : ∀ U ∈ B, U ⊆ s → U ⊆ t) : s ⊆ t 
goal: ∀ {t_1 : Set α}, TopologicalSpace.IsTopologicalBasis B → IsOpen s → (∀ U ∈ B, U ⊆ s → U ⊆ t_1) → s ⊆ t_1

full_name: TopologicalSpace.IsTopologicalBasis.eq_of_forall_subset_iff
code: lemma IsTopologicalBasis.eq_of_forall_subset_iff {t : Set α} (hB : IsTopologicalBasis B)
    (hs : IsOpen s) (ht : IsOpen t) (h : ∀ U ∈ B, U ⊆ s ↔ U ⊆ t) : s = t 
goal: ∀ {t_1 : Set α}, TopologicalSpace.IsTopologicalBasis B → IsOpen s → IsOpen t_1 → (∀ U ∈ B, U ⊆ s ↔ U ⊆ t_1) → s = t_1

full_name: TopologicalSpace.IsTopologicalBasis.mem_closure_iff
code: /-- A point `a` is in the closure of `s` iff all basis sets containing `a` intersect `s`. -/
theorem IsTopologicalBasis.mem_closure_iff {b : Set (Set α)} (hb : IsTopologicalBasis b) {s : Set α}
    {a : α} : a ∈ closure s ↔ ∀ o ∈ b, a ∈ o → (o ∩ s).Nonempty 
goal: a ∈ closure s ↔ ∀ o ∈ b, a ∈ o → (o ∩ s).Nonempty

full_name: TopologicalSpace.IsTopologicalBasis.dense_iff
code: /-- A set is dense iff it has non-trivial intersection with all basis sets. -/
theorem IsTopologicalBasis.dense_iff {b : Set (Set α)} (hb : IsTopologicalBasis b) {s : Set α} :
    Dense s ↔ ∀ o ∈ b, Set.Nonempty o → (o ∩ s).Nonempty 
goal: Dense s ↔ ∀ o ∈ b, o.Nonempty → (o ∩ s).Nonempty

full_name: TopologicalSpace.IsTopologicalBasis.isOpenMap_iff
code: theorem IsTopologicalBasis.isOpenMap_iff {β} [TopologicalSpace β] {B : Set (Set α)}
    (hB : IsTopologicalBasis B) {f : α → β} : IsOpenMap f ↔ ∀ s ∈ B, IsOpen (f '' s) 
goal: IsOpenMap f ↔ ∀ s ∈ B, IsOpen (f '' s)

full_name: TopologicalSpace.IsTopologicalBasis.exists_nonempty_subset
code: theorem IsTopologicalBasis.exists_nonempty_subset {B : Set (Set α)} (hb : IsTopologicalBasis B)
    {u : Set α} (hu : u.Nonempty) (ou : IsOpen u) : ∃ v ∈ B, Set.Nonempty v ∧ v ⊆ u 
goal: ∃ v ∈ B, v.Nonempty ∧ v ⊆ u

full_name: TopologicalSpace.isTopologicalBasis_opens
code: theorem isTopologicalBasis_opens : IsTopologicalBasis { U : Set α | IsOpen U } 
goal: TopologicalSpace.IsTopologicalBasis {U | IsOpen U}

full_name: TopologicalSpace.IsTopologicalBasis.inducing
code: protected theorem IsTopologicalBasis.inducing {β} [TopologicalSpace β] {f : α → β} {T : Set (Set β)}
    (hf : Inducing f) (h : IsTopologicalBasis T) : IsTopologicalBasis ((preimage f) '' T) 
goal: TopologicalSpace.IsTopologicalBasis (Set.preimage f '' T)

full_name: TopologicalSpace.IsTopologicalBasis.induced
code: protected theorem IsTopologicalBasis.induced [s : TopologicalSpace β] (f : α → β)
    {T : Set (Set β)} (h : IsTopologicalBasis T) :
    IsTopologicalBasis (t := induced f s) ((preimage f) '' T) 
goal: TopologicalSpace.IsTopologicalBasis (Set.preimage f '' T)

full_name: TopologicalSpace.IsTopologicalBasis.inf
code: protected theorem IsTopologicalBasis.inf {t₁ t₂ : TopologicalSpace β} {B₁ B₂ : Set (Set β)}
    (h₁ : IsTopologicalBasis (t := t₁) B₁) (h₂ : IsTopologicalBasis (t := t₂) B₂) :
    IsTopologicalBasis (t := t₁ ⊓ t₂) (image2 (· ∩ ·) B₁ B₂) 
goal: TopologicalSpace.IsTopologicalBasis (Set.image2 (fun x x_1 => x ∩ x_1) B₁ B₂)

full_name: TopologicalSpace.IsTopologicalBasis.inf_induced
code: theorem IsTopologicalBasis.inf_induced {γ} [s : TopologicalSpace β] {B₁ : Set (Set α)}
    {B₂ : Set (Set β)} (h₁ : IsTopologicalBasis B₁) (h₂ : IsTopologicalBasis B₂) (f₁ : γ → α)
    (f₂ : γ → β) :
    IsTopologicalBasis (t := induced f₁ t ⊓ induced f₂ s) (image2 (f₁ ⁻¹' · ∩ f₂ ⁻¹' ·) B₁ B₂) 
goal: TopologicalSpace.IsTopologicalBasis (Set.image2 (fun x x_1 => f₁ ⁻¹' x ∩ f₂ ⁻¹' x_1) B₁ B₂)

full_name: TopologicalSpace.IsTopologicalBasis.prod
code: protected theorem IsTopologicalBasis.prod {β} [TopologicalSpace β] {B₁ : Set (Set α)}
    {B₂ : Set (Set β)} (h₁ : IsTopologicalBasis B₁) (h₂ : IsTopologicalBasis B₂) :
    IsTopologicalBasis (image2 (· ×ˢ ·) B₁ B₂) 
goal: TopologicalSpace.IsTopologicalBasis (Set.image2 (fun x x_1 => x ×ˢ x_1) B₁ B₂)

full_name: TopologicalSpace.isTopologicalBasis_of_cover
code: theorem isTopologicalBasis_of_cover {ι} {U : ι → Set α} (Uo : ∀ i, IsOpen (U i))
    (Uc : ⋃ i, U i = univ) {b : ∀ i, Set (Set (U i))} (hb : ∀ i, IsTopologicalBasis (b i)) :
    IsTopologicalBasis (⋃ i : ι, image ((↑) : U i → α) '' b i) 
goal: TopologicalSpace.IsTopologicalBasis (⋃ i, Set.image Subtype.val '' b i)

full_name: TopologicalSpace.IsTopologicalBasis.continuous_iff
code: protected theorem IsTopologicalBasis.continuous_iff {β : Type*} [TopologicalSpace β]
    {B : Set (Set β)} (hB : IsTopologicalBasis B) {f : α → β} :
    Continuous f ↔ ∀ s ∈ B, IsOpen (f ⁻¹' s) 
goal: Continuous f ↔ ∀ s ∈ B, IsOpen (f ⁻¹' s)

full_name: TopologicalSpace.IsTopologicalBasis.continuous
code: @[deprecated (since := "2023-12-24")]
protected theorem IsTopologicalBasis.continuous {β : Type*} [TopologicalSpace β] {B : Set (Set β)}
    (hB : IsTopologicalBasis B) (f : α → β) (hf : ∀ s ∈ B, IsOpen (f ⁻¹' s)) : Continuous f 
goal: Continuous f

full_name: TopologicalSpace.separableSpace_iff
code: /-- A separable space is one with a countable dense subset, available through
`TopologicalSpace.exists_countable_dense`. If `α` is also known to be nonempty, then
`TopologicalSpace.denseSeq` provides a sequence `ℕ → α` with dense range, see
`TopologicalSpace.denseRange_denseSeq`.

If `α` is a uniform space with countably generated uniformity filter (e.g., an `EMetricSpace`), then
this condition is equivalent to `SecondCountableTopology α`. In this case the
latter should be used as a typeclass argument in theorems because Lean can automatically deduce
`TopologicalSpace.SeparableSpace` from `SecondCountableTopology` but it can't
deduce `SecondCountableTopology` from `TopologicalSpace.SeparableSpace`.

Porting note (#11215): TODO: the previous paragraph describes the state of the art in Lean 3.
We can have instance cycles in Lean 4 but we might want to
postpone adding them till after the port. -/
@[mk_iff] class SeparableSpace : Prop where
  /-- There exists a countable dense set. -/
  exists_countable_dense : ∃ s : Set α, s.Countable ∧ Dense s
goal: TopologicalSpace.SeparableSpace α ↔ ∃ s, s.Countable ∧ Dense s

full_name: TopologicalSpace.SeparableSpace.exists_countable_dense
code: /-- A separable space is one with a countable dense subset, available through
`TopologicalSpace.exists_countable_dense`. If `α` is also known to be nonempty, then
`TopologicalSpace.denseSeq` provides a sequence `ℕ → α` with dense range, see
`TopologicalSpace.denseRange_denseSeq`.

If `α` is a uniform space with countably generated uniformity filter (e.g., an `EMetricSpace`), then
this condition is equivalent to `SecondCountableTopology α`. In this case the
latter should be used as a typeclass argument in theorems because Lean can automatically deduce
`TopologicalSpace.SeparableSpace` from `SecondCountableTopology` but it can't
deduce `SecondCountableTopology` from `TopologicalSpace.SeparableSpace`.

Porting note (#11215): TODO: the previous paragraph describes the state of the art in Lean 3.
We can have instance cycles in Lean 4 but we might want to
postpone adding them till after the port. -/
@[mk_iff] class SeparableSpace : Prop where
  /-- There exists a countable dense set. -/
  exists_countable_dense : ∃ s : Set α, s.Countable ∧ Dense s
goal: ∃ s, s.Countable ∧ Dense s

full_name: TopologicalSpace.SeparableSpace
code: /-- A separable space is one with a countable dense subset, available through
`TopologicalSpace.exists_countable_dense`. If `α` is also known to be nonempty, then
`TopologicalSpace.denseSeq` provides a sequence `ℕ → α` with dense range, see
`TopologicalSpace.denseRange_denseSeq`.

If `α` is a uniform space with countably generated uniformity filter (e.g., an `EMetricSpace`), then
this condition is equivalent to `SecondCountableTopology α`. In this case the
latter should be used as a typeclass argument in theorems because Lean can automatically deduce
`TopologicalSpace.SeparableSpace` from `SecondCountableTopology` but it can't
deduce `SecondCountableTopology` from `TopologicalSpace.SeparableSpace`.

Porting note (#11215): TODO: the previous paragraph describes the state of the art in Lean 3.
We can have instance cycles in Lean 4 but we might want to
postpone adding them till after the port. -/
@[mk_iff] class SeparableSpace : Prop where
  /-- There exists a countable dense set. -/
  exists_countable_dense : ∃ s : Set α, s.Countable ∧ Dense s
goal: Prop

full_name: TopologicalSpace.exists_countable_dense
code: theorem exists_countable_dense [SeparableSpace α] : ∃ s : Set α, s.Countable ∧ Dense s 
goal: ∃ s, s.Countable ∧ Dense s

full_name: TopologicalSpace.exists_dense_seq
code: /-- A nonempty separable space admits a sequence with dense range. Instead of running `cases` on the
conclusion of this lemma, you might want to use `TopologicalSpace.denseSeq` and
`TopologicalSpace.denseRange_denseSeq`.

If `α` might be empty, then `TopologicalSpace.exists_countable_dense` is the main way to use
separability of `α`. -/
theorem exists_dense_seq [SeparableSpace α] [Nonempty α] : ∃ u : ℕ → α, DenseRange u 
goal: ∃ u, DenseRange u

full_name: TopologicalSpace.denseSeq
code: /-- A dense sequence in a non-empty separable topological space.

If `α` might be empty, then `TopologicalSpace.exists_countable_dense` is the main way to use
separability of `α`. -/
def denseSeq [SeparableSpace α] [Nonempty α] : ℕ → α 
goal: ℕ → α

full_name: TopologicalSpace.denseRange_denseSeq
code: /-- The sequence `TopologicalSpace.denseSeq α` has dense range. -/
@[simp]
theorem denseRange_denseSeq [SeparableSpace α] [Nonempty α] : DenseRange (denseSeq α) 
goal: DenseRange (TopologicalSpace.denseSeq α)

full_name: TopologicalSpace.Countable.to_separableSpace
code: instance (priority := 100) Countable.to_separableSpace [Countable α] : SeparableSpace α 
goal: TopologicalSpace.SeparableSpace α

full_name: TopologicalSpace.SeparableSpace.of_denseRange
code: /-- If `f` has a dense range and its domain is countable, then its codomain is a separable space.
See also `DenseRange.separableSpace`. -/
theorem SeparableSpace.of_denseRange {ι : Sort _} [Countable ι] (u : ι → α) (hu : DenseRange u) :
    SeparableSpace α 
goal: TopologicalSpace.SeparableSpace α

full_name: DenseRange.separableSpace
code: /-- If `α` is a separable space and `f : α → β` is a continuous map with dense range, then `β` is
a separable space as well. E.g., the completion of a separable uniform space is separable. -/
protected theorem _root_.DenseRange.separableSpace [SeparableSpace α] [TopologicalSpace β]
    {f : α → β} (h : DenseRange f) (h' : Continuous f) : SeparableSpace β 
goal: TopologicalSpace.SeparableSpace β

full_name: QuotientMap.separableSpace
code: theorem _root_.QuotientMap.separableSpace [SeparableSpace α] [TopologicalSpace β] {f : α → β}
    (hf : QuotientMap f) : SeparableSpace β 
goal: TopologicalSpace.SeparableSpace β

full_name: TopologicalSpace.instSeparableSpaceProd
code: /-- The product of two separable spaces is a separable space. -/
instance [TopologicalSpace β] [SeparableSpace α] [SeparableSpace β] : SeparableSpace (α × β) 
goal: TopologicalSpace.SeparableSpace (α × β)

full_name: TopologicalSpace.instSeparableSpaceForallOfCountable
code: /-- The product of a countable family of separable spaces is a separable space. -/
instance {ι : Type*} {X : ι → Type*} [∀ i, TopologicalSpace (X i)] [∀ i, SeparableSpace (X i)]
    [Countable ι] : SeparableSpace (∀ i, X i) 
goal: TopologicalSpace.SeparableSpace ((i : ι) → X i)

full_name: TopologicalSpace.instSeparableSpaceQuot
code: instance [SeparableSpace α] {r : α → α → Prop} : SeparableSpace (Quot r) 
goal: TopologicalSpace.SeparableSpace (Quot r)

full_name: TopologicalSpace.instSeparableSpaceQuotient
code: instance [SeparableSpace α] {s : Setoid α} : SeparableSpace (Quotient s) 
goal: TopologicalSpace.SeparableSpace (Quotient s)

full_name: TopologicalSpace.separableSpace_iff_countable
code: /-- A topological space with discrete topology is separable iff it is countable. -/
theorem separableSpace_iff_countable [DiscreteTopology α] : SeparableSpace α ↔ Countable α 
goal: TopologicalSpace.SeparableSpace α ↔ Countable α

full_name: Pairwise.countable_of_isOpen_disjoint
code: /-- In a separable space, a family of nonempty disjoint open sets is countable. -/
theorem _root_.Pairwise.countable_of_isOpen_disjoint [SeparableSpace α] {ι : Type*}
    {s : ι → Set α} (hd : Pairwise (Disjoint on s)) (ho : ∀ i, IsOpen (s i))
    (hne : ∀ i, (s i).Nonempty) : Countable ι 
goal: Countable ι

full_name: Set.PairwiseDisjoint.countable_of_isOpen
code: /-- In a separable space, a family of nonempty disjoint open sets is countable. -/
theorem _root_.Set.PairwiseDisjoint.countable_of_isOpen [SeparableSpace α] {ι : Type*}
    {s : ι → Set α} {a : Set ι} (h : a.PairwiseDisjoint s) (ho : ∀ i ∈ a, IsOpen (s i))
    (hne : ∀ i ∈ a, (s i).Nonempty) : a.Countable 
goal: a.Countable

full_name: Set.PairwiseDisjoint.countable_of_nonempty_interior
code: /-- In a separable space, a family of disjoint sets with nonempty interiors is countable. -/
theorem _root_.Set.PairwiseDisjoint.countable_of_nonempty_interior [SeparableSpace α] {ι : Type*}
    {s : ι → Set α} {a : Set ι} (h : a.PairwiseDisjoint s)
    (ha : ∀ i ∈ a, (interior (s i)).Nonempty) : a.Countable 
goal: a.Countable

full_name: TopologicalSpace.IsSeparable
code: /-- A set `s` in a topological space is separable if it is contained in the closure of a countable
set `c`. Beware that this definition does not require that `c` is contained in `s` (to express the
latter, use `TopologicalSpace.SeparableSpace s` or
`TopologicalSpace.IsSeparable (univ : Set s))`. In metric spaces, the two definitions are
equivalent, see `TopologicalSpace.IsSeparable.separableSpace`. -/
def IsSeparable (s : Set α) 
goal: Prop

full_name: TopologicalSpace.IsSeparable.mono
code: theorem IsSeparable.mono {s u : Set α} (hs : IsSeparable s) (hu : u ⊆ s) : IsSeparable u 
goal: TopologicalSpace.IsSeparable u

full_name: TopologicalSpace.IsSeparable.iUnion
code: theorem IsSeparable.iUnion {ι : Sort*} [Countable ι] {s : ι → Set α}
    (hs : ∀ i, IsSeparable (s i)) : IsSeparable (⋃ i, s i) 
goal: TopologicalSpace.IsSeparable (⋃ i, s i)

full_name: TopologicalSpace.isSeparable_iUnion
code: @[simp]
theorem isSeparable_iUnion {ι : Sort*} [Countable ι] {s : ι → Set α} :
    IsSeparable (⋃ i, s i) ↔ ∀ i, IsSeparable (s i) 
goal: TopologicalSpace.IsSeparable (⋃ i, s i) ↔ ∀ (i : ι), TopologicalSpace.IsSeparable (s i)

full_name: TopologicalSpace.isSeparable_union
code: @[simp]
theorem isSeparable_union {s t : Set α} : IsSeparable (s ∪ t) ↔ IsSeparable s ∧ IsSeparable t 
goal: ∀ {t_1 : Set α},
  TopologicalSpace.IsSeparable (s ∪ t_1) ↔ TopologicalSpace.IsSeparable s ∧ TopologicalSpace.IsSeparable t_1

full_name: TopologicalSpace.IsSeparable.union
code: theorem IsSeparable.union {s u : Set α} (hs : IsSeparable s) (hu : IsSeparable u) :
    IsSeparable (s ∪ u) 
goal: TopologicalSpace.IsSeparable (s ∪ u)

full_name: TopologicalSpace.isSeparable_closure
code: @[simp]
theorem isSeparable_closure : IsSeparable (closure s) ↔ IsSeparable s 
goal: TopologicalSpace.IsSeparable (closure s) ↔ TopologicalSpace.IsSeparable s

full_name: Set.Countable.isSeparable
code: theorem _root_.Set.Countable.isSeparable {s : Set α} (hs : s.Countable) : IsSeparable s 
goal: TopologicalSpace.IsSeparable s

full_name: Set.Finite.isSeparable
code: theorem _root_.Set.Finite.isSeparable {s : Set α} (hs : s.Finite) : IsSeparable s 
goal: TopologicalSpace.IsSeparable s

full_name: TopologicalSpace.IsSeparable.univ_pi
code: theorem IsSeparable.univ_pi {ι : Type*} [Countable ι] {X : ι → Type*} {s : ∀ i, Set (X i)}
    [∀ i, TopologicalSpace (X i)] (h : ∀ i, IsSeparable (s i)) :
    IsSeparable (univ.pi s) 
goal: TopologicalSpace.IsSeparable (Set.univ.pi s)

full_name: TopologicalSpace.isSeparable_pi
code: lemma isSeparable_pi {ι : Type*} [Countable ι] {α : ι → Type*} {s : ∀ i, Set (α i)}
    [∀ i, TopologicalSpace (α i)] (h : ∀ i, IsSeparable (s i)) :
    IsSeparable {f : ∀ i, α i | ∀ i, f i ∈ s i} 
goal: TopologicalSpace.IsSeparable {f | ∀ (i : ι), f i ∈ s i}

full_name: TopologicalSpace.IsSeparable.prod
code: lemma IsSeparable.prod {β : Type*} [TopologicalSpace β]
    {s : Set α} {t : Set β} (hs : IsSeparable s) (ht : IsSeparable t) :
    IsSeparable (s ×ˢ t) 
goal: ∀ {t_1 : Set β},
  TopologicalSpace.IsSeparable s → TopologicalSpace.IsSeparable t_1 → TopologicalSpace.IsSeparable (s ×ˢ t_1)

full_name: TopologicalSpace.IsSeparable.image
code: theorem IsSeparable.image {β : Type*} [TopologicalSpace β] {s : Set α} (hs : IsSeparable s)
    {f : α → β} (hf : Continuous f) : IsSeparable (f '' s) 
goal: TopologicalSpace.IsSeparable (f '' s)

full_name: Dense.isSeparable_iff
code: theorem _root_.Dense.isSeparable_iff (hs : Dense s) :
    IsSeparable s ↔ SeparableSpace α 
goal: TopologicalSpace.IsSeparable s ↔ TopologicalSpace.SeparableSpace α

full_name: TopologicalSpace.isSeparable_univ_iff
code: theorem isSeparable_univ_iff : IsSeparable (univ : Set α) ↔ SeparableSpace α 
goal: TopologicalSpace.IsSeparable Set.univ ↔ TopologicalSpace.SeparableSpace α

full_name: TopologicalSpace.isSeparable_range
code: theorem isSeparable_range [TopologicalSpace β] [SeparableSpace α] {f : α → β} (hf : Continuous f) :
    IsSeparable (range f) 
goal: TopologicalSpace.IsSeparable (Set.range f)

full_name: TopologicalSpace.IsSeparable.of_subtype
code: theorem IsSeparable.of_subtype (s : Set α) [SeparableSpace s] : IsSeparable s 
goal: TopologicalSpace.IsSeparable s

full_name: TopologicalSpace.IsSeparable.of_separableSpace
code: theorem IsSeparable.of_separableSpace [h : SeparableSpace α] (s : Set α) : IsSeparable s 
goal: TopologicalSpace.IsSeparable s

full_name: IsTopologicalBasis.iInf
code: protected theorem IsTopologicalBasis.iInf {β : Type*} {ι : Type*} {t : ι → TopologicalSpace β}
    {T : ι → Set (Set β)} (h_basis : ∀ i, IsTopologicalBasis (t := t i) (T i)) :
    IsTopologicalBasis (t := ⨅ i, t i)
      { S | ∃ (U : ι → Set β) (F : Finset ι), (∀ i, i ∈ F → U i ∈ T i) ∧ S = ⋂ i ∈ F, U i } 
goal: TopologicalSpace.IsTopologicalBasis {S | ∃ U F, (∀ i ∈ F, U i ∈ T i) ∧ S = ⋂ i ∈ F, U i}

full_name: IsTopologicalBasis.iInf_induced
code: theorem IsTopologicalBasis.iInf_induced {β : Type*} {ι : Type*} {X : ι → Type*}
    [t : Π i, TopologicalSpace (X i)] {T : Π i, Set (Set (X i))}
    (cond : ∀ i, IsTopologicalBasis (T i)) (f : Π i, β → X i) :
    IsTopologicalBasis (t := ⨅ i, induced (f i) (t i))
      { S | ∃ (U : ∀ i, Set (X i)) (F : Finset ι),
        (∀ i, i ∈ F → U i ∈ T i) ∧ S = ⋂ (i) (_ : i ∈ F), f i ⁻¹' U i } 
goal: TopologicalSpace.IsTopologicalBasis {S | ∃ U F, (∀ i ∈ F, U i ∈ T i) ∧ S = ⋂ i ∈ F, f i ⁻¹' U i}

full_name: isTopologicalBasis_pi
code: theorem isTopologicalBasis_pi {ι : Type*} {X : ι → Type*} [∀ i, TopologicalSpace (X i)]
    {T : ∀ i, Set (Set (X i))} (cond : ∀ i, IsTopologicalBasis (T i)) :
    IsTopologicalBasis { S | ∃ (U : ∀ i, Set (X i)) (F : Finset ι),
      (∀ i, i ∈ F → U i ∈ T i) ∧ S = (F : Set ι).pi U } 
goal: TopologicalSpace.IsTopologicalBasis {S | ∃ U F, (∀ i ∈ F, U i ∈ T i) ∧ S = (↑F).pi U}

full_name: isTopologicalBasis_singletons
code: theorem isTopologicalBasis_singletons (α : Type*) [TopologicalSpace α] [DiscreteTopology α] :
    IsTopologicalBasis { s | ∃ x : α, (s : Set α) = {x} } 
goal: TopologicalSpace.IsTopologicalBasis {s | ∃ x, s = {x}}

full_name: isTopologicalBasis_subtype
code: theorem isTopologicalBasis_subtype
    {α : Type*} [TopologicalSpace α] {B : Set (Set α)}
    (h : TopologicalSpace.IsTopologicalBasis B) (p : α → Prop) :
    IsTopologicalBasis (Set.preimage (Subtype.val (p := p)) '' B) 
goal: TopologicalSpace.IsTopologicalBasis (Set.preimage Subtype.val '' B)

full_name: isOpenMap_eval
code: lemma isOpenMap_eval (i : ι) : IsOpenMap (Function.eval i : (∀ i, π i) → π i) 
goal: IsOpenMap (Function.eval i)

full_name: Dense.exists_countable_dense_subset
code: theorem Dense.exists_countable_dense_subset {α : Type*} [TopologicalSpace α] {s : Set α}
    [SeparableSpace s] (hs : Dense s) : ∃ t ⊆ s, t.Countable ∧ Dense t 
goal: ∃ t ⊆ s, t.Countable ∧ Dense t

full_name: Dense.exists_countable_dense_subset_bot_top
code: /-- Let `s` be a dense set in a topological space `α` with partial order structure. If `s` is a
separable space (e.g., if `α` has a second countable topology), then there exists a countable
dense subset `t ⊆ s` such that `t` contains bottom/top element of `α` when they exist and belong
to `s`. For a dense subset containing neither bot nor top elements, see
`Dense.exists_countable_dense_subset_no_bot_top`. -/
theorem Dense.exists_countable_dense_subset_bot_top {α : Type*} [TopologicalSpace α]
    [PartialOrder α] {s : Set α} [SeparableSpace s] (hs : Dense s) :
    ∃ t ⊆ s, t.Countable ∧ Dense t ∧ (∀ x, IsBot x → x ∈ s → x ∈ t) ∧
      ∀ x, IsTop x → x ∈ s → x ∈ t 
goal: ∃ t ⊆ s, t.Countable ∧ Dense t ∧ (∀ (x : α), IsBot x → x ∈ s → x ∈ t) ∧ ∀ (x : α), IsTop x → x ∈ s → x ∈ t

full_name: separableSpace_univ
code: instance separableSpace_univ {α : Type*} [TopologicalSpace α] [SeparableSpace α] :
    SeparableSpace (univ : Set α) 
goal: TopologicalSpace.SeparableSpace ↑Set.univ

full_name: exists_countable_dense_bot_top
code: /-- If `α` is a separable topological space with a partial order, then there exists a countable
dense set `s : Set α` that contains those of both bottom and top elements of `α` that actually
exist. For a dense set containing neither bot nor top elements, see
`exists_countable_dense_no_bot_top`. -/
theorem exists_countable_dense_bot_top (α : Type*) [TopologicalSpace α] [SeparableSpace α]
    [PartialOrder α] :
    ∃ s : Set α, s.Countable ∧ Dense s ∧ (∀ x, IsBot x → x ∈ s) ∧ ∀ x, IsTop x → x ∈ s 
goal: ∃ s, s.Countable ∧ Dense s ∧ (∀ (x : α), IsBot x → x ∈ s) ∧ ∀ (x : α), IsTop x → x ∈ s

full_name: FirstCountableTopology.nhds_generated_countable
code: /-- A first-countable space is one in which every point has a
  countable neighborhood basis. -/
class _root_.FirstCountableTopology : Prop where
  /-- The filter `𝓝 a` is countably generated for all points `a`. -/
  nhds_generated_countable : ∀ a : α, (𝓝 a).IsCountablyGenerated
goal: (𝓝 a).IsCountablyGenerated

full_name: FirstCountableTopology
code: /-- A first-countable space is one in which every point has a
  countable neighborhood basis. -/
class _root_.FirstCountableTopology : Prop where
  /-- The filter `𝓝 a` is countably generated for all points `a`. -/
  nhds_generated_countable : ∀ a : α, (𝓝 a).IsCountablyGenerated
goal: Prop

full_name: TopologicalSpace.firstCountableTopology_induced
code: /-- If `β` is a first-countable space, then its induced topology via `f` on `α` is also
first-countable. -/
theorem firstCountableTopology_induced (α β : Type*) [t : TopologicalSpace β]
    [FirstCountableTopology β] (f : α → β) : @FirstCountableTopology α (t.induced f) 
goal: FirstCountableTopology α

full_name: TopologicalSpace.Subtype.firstCountableTopology
code: instance Subtype.firstCountableTopology (s : Set α) [FirstCountableTopology α] :
    FirstCountableTopology s 
goal: FirstCountableTopology ↑s

full_name: Inducing.firstCountableTopology
code: protected theorem _root_.Inducing.firstCountableTopology {β : Type*}
    [TopologicalSpace β] [FirstCountableTopology β] {f : α → β} (hf : Inducing f) :
    FirstCountableTopology α 
goal: FirstCountableTopology α

full_name: Embedding.firstCountableTopology
code: protected theorem _root_.Embedding.firstCountableTopology {β : Type*}
    [TopologicalSpace β] [FirstCountableTopology β] {f : α → β} (hf : Embedding f) :
    FirstCountableTopology α 
goal: FirstCountableTopology α

full_name: TopologicalSpace.FirstCountableTopology.tendsto_subseq
code: /-- In a first-countable space, a cluster point `x` of a sequence
is the limit of some subsequence. -/
theorem tendsto_subseq [FirstCountableTopology α] {u : ℕ → α} {x : α}
    (hx : MapClusterPt x atTop u) : ∃ ψ : ℕ → ℕ, StrictMono ψ ∧ Tendsto (u ∘ ψ) atTop (𝓝 x) 
goal: ∃ ψ, StrictMono ψ ∧ Filter.Tendsto (u ∘ ψ) Filter.atTop (𝓝 x)

full_name: TopologicalSpace.instFirstCountableTopologyProd
code: instance {β} [TopologicalSpace β] [FirstCountableTopology α] [FirstCountableTopology β] :
    FirstCountableTopology (α × β) 
goal: FirstCountableTopology (α × β)

full_name: TopologicalSpace.instFirstCountableTopologyForallOfCountable
code: instance {ι : Type*} {π : ι → Type*} [Countable ι] [∀ i, TopologicalSpace (π i)]
    [∀ i, FirstCountableTopology (π i)] : FirstCountableTopology (∀ i, π i) 
goal: FirstCountableTopology ((i : ι) → π i)

full_name: TopologicalSpace.isCountablyGenerated_nhdsWithin
code: instance isCountablyGenerated_nhdsWithin (x : α) [IsCountablyGenerated (𝓝 x)] (s : Set α) :
    IsCountablyGenerated (𝓝[s] x) 
goal: (𝓝[s] x).IsCountablyGenerated

full_name: SecondCountableTopology
code: /-- A second-countable space is one with a countable basis. -/
class _root_.SecondCountableTopology : Prop where
  /-- There exists a countable set of sets that generates the topology. -/
  is_open_generated_countable : ∃ b : Set (Set α), b.Countable ∧ t = TopologicalSpace.generateFrom b
goal: Prop

full_name: SecondCountableTopology.is_open_generated_countable
code: /-- A second-countable space is one with a countable basis. -/
class _root_.SecondCountableTopology : Prop where
  /-- There exists a countable set of sets that generates the topology. -/
  is_open_generated_countable : ∃ b : Set (Set α), b.Countable ∧ t = TopologicalSpace.generateFrom b
goal: ∃ b, b.Countable ∧ t = TopologicalSpace.generateFrom b

full_name: TopologicalSpace.IsTopologicalBasis.secondCountableTopology
code: protected theorem IsTopologicalBasis.secondCountableTopology {b : Set (Set α)}
    (hb : IsTopologicalBasis b) (hc : b.Countable) : SecondCountableTopology α 
goal: SecondCountableTopology α

full_name: TopologicalSpace.SecondCountableTopology.mk'
code: lemma SecondCountableTopology.mk' {b : Set (Set α)} (hc : b.Countable) :
    @SecondCountableTopology α (generateFrom b) 
goal: SecondCountableTopology α

full_name: Finite.toSecondCountableTopology
code: instance _root_.Finite.toSecondCountableTopology [Finite α] : SecondCountableTopology α 
goal: SecondCountableTopology α

full_name: TopologicalSpace.exists_countable_basis
code: theorem exists_countable_basis [SecondCountableTopology α] :
    ∃ b : Set (Set α), b.Countable ∧ ∅ ∉ b ∧ IsTopologicalBasis b 
goal: ∃ b, b.Countable ∧ ∅ ∉ b ∧ TopologicalSpace.IsTopologicalBasis b

full_name: TopologicalSpace.countableBasis
code: /-- A countable topological basis of `α`. -/
def countableBasis [SecondCountableTopology α] : Set (Set α) 
goal: Set (Set α)

full_name: TopologicalSpace.countable_countableBasis
code: theorem countable_countableBasis [SecondCountableTopology α] : (countableBasis α).Countable 
goal: (TopologicalSpace.countableBasis α).Countable

full_name: TopologicalSpace.encodableCountableBasis
code: instance encodableCountableBasis [SecondCountableTopology α] : Encodable (countableBasis α) 
goal: Encodable ↑(TopologicalSpace.countableBasis α)

full_name: TopologicalSpace.empty_nmem_countableBasis
code: theorem empty_nmem_countableBasis [SecondCountableTopology α] : ∅ ∉ countableBasis α 
goal: ∅ ∉ TopologicalSpace.countableBasis α

full_name: TopologicalSpace.isBasis_countableBasis
code: theorem isBasis_countableBasis [SecondCountableTopology α] :
    IsTopologicalBasis (countableBasis α) 
goal: TopologicalSpace.IsTopologicalBasis (TopologicalSpace.countableBasis α)

full_name: TopologicalSpace.eq_generateFrom_countableBasis
code: theorem eq_generateFrom_countableBasis [SecondCountableTopology α] :
    ‹TopologicalSpace α› = generateFrom (countableBasis α) 
goal: t = TopologicalSpace.generateFrom (TopologicalSpace.countableBasis α)

full_name: TopologicalSpace.isOpen_of_mem_countableBasis
code: theorem isOpen_of_mem_countableBasis [SecondCountableTopology α] {s : Set α}
    (hs : s ∈ countableBasis α) : IsOpen s 
goal: IsOpen s

full_name: TopologicalSpace.nonempty_of_mem_countableBasis
code: theorem nonempty_of_mem_countableBasis [SecondCountableTopology α] {s : Set α}
    (hs : s ∈ countableBasis α) : s.Nonempty 
goal: s.Nonempty

full_name: TopologicalSpace.SecondCountableTopology.to_firstCountableTopology
code: instance (priority := 100) SecondCountableTopology.to_firstCountableTopology
    [SecondCountableTopology α] : FirstCountableTopology α 
goal: FirstCountableTopology α

full_name: TopologicalSpace.secondCountableTopology_induced
code: /-- If `β` is a second-countable space, then its induced topology via
`f` on `α` is also second-countable. -/
theorem secondCountableTopology_induced (β) [t : TopologicalSpace β] [SecondCountableTopology β]
    (f : α → β) : @SecondCountableTopology α (t.induced f) 
goal: SecondCountableTopology α

full_name: TopologicalSpace.Subtype.secondCountableTopology
code: instance Subtype.secondCountableTopology (s : Set α) [SecondCountableTopology α] :
    SecondCountableTopology s 
goal: SecondCountableTopology ↑s

full_name: TopologicalSpace.secondCountableTopology_iInf
code: lemma secondCountableTopology_iInf {ι} [Countable ι] {t : ι → TopologicalSpace α}
    (ht : ∀ i, @SecondCountableTopology α (t i)) : @SecondCountableTopology α (⨅ i, t i) 
goal: SecondCountableTopology α

full_name: TopologicalSpace.instSecondCountableTopologyProd
code: instance {β : Type*} [TopologicalSpace β] [SecondCountableTopology α] [SecondCountableTopology β] :
    SecondCountableTopology (α × β) 
goal: SecondCountableTopology (α × β)

full_name: TopologicalSpace.instSecondCountableTopologyForallOfCountable
code: instance {ι : Type*} {π : ι → Type*} [Countable ι] [∀ a, TopologicalSpace (π a)]
    [∀ a, SecondCountableTopology (π a)] : SecondCountableTopology (∀ a, π a) 
goal: SecondCountableTopology ((a : ι) → π a)

full_name: TopologicalSpace.SecondCountableTopology.to_separableSpace
code: instance (priority := 100) SecondCountableTopology.to_separableSpace [SecondCountableTopology α] :
    SeparableSpace α 
goal: TopologicalSpace.SeparableSpace α

full_name: TopologicalSpace.secondCountableTopology_of_countable_cover
code: /-- A countable open cover induces a second-countable topology if all open covers
are themselves second countable. -/
theorem secondCountableTopology_of_countable_cover {ι} [Countable ι] {U : ι → Set α}
    [∀ i, SecondCountableTopology (U i)] (Uo : ∀ i, IsOpen (U i)) (hc : ⋃ i, U i = univ) :
    SecondCountableTopology α 
goal: SecondCountableTopology α

full_name: TopologicalSpace.isOpen_iUnion_countable
code: /-- In a second-countable space, an open set, given as a union of open sets,
is equal to the union of countably many of those sets.
In particular, any open covering of `α` has a countable subcover: α is a Lindelöf space. -/
theorem isOpen_iUnion_countable [SecondCountableTopology α] {ι} (s : ι → Set α)
    (H : ∀ i, IsOpen (s i)) : ∃ T : Set ι, T.Countable ∧ ⋃ i ∈ T, s i = ⋃ i, s i 
goal: ∃ T, T.Countable ∧ ⋃ i ∈ T, s i = ⋃ i, s i

full_name: TopologicalSpace.isOpen_biUnion_countable
code: theorem isOpen_biUnion_countable [SecondCountableTopology α] {ι : Type*} (I : Set ι) (s : ι → Set α)
    (H : ∀ i ∈ I, IsOpen (s i)) : ∃ T ⊆ I, T.Countable ∧ ⋃ i ∈ T, s i = ⋃ i ∈ I, s i 
goal: ∃ T ⊆ I, T.Countable ∧ ⋃ i ∈ T, s i = ⋃ i ∈ I, s i

full_name: TopologicalSpace.isOpen_sUnion_countable
code: theorem isOpen_sUnion_countable [SecondCountableTopology α] (S : Set (Set α))
    (H : ∀ s ∈ S, IsOpen s) : ∃ T : Set (Set α), T.Countable ∧ T ⊆ S ∧ ⋃₀ T = ⋃₀ S 
goal: ∃ T, T.Countable ∧ T ⊆ S ∧ ⋃₀ T = ⋃₀ S

full_name: TopologicalSpace.countable_cover_nhds
code: /-- In a topological space with second countable topology, if `f` is a function that sends each
point `x` to a neighborhood of `x`, then for some countable set `s`, the neighborhoods `f x`,
`x ∈ s`, cover the whole space. -/
theorem countable_cover_nhds [SecondCountableTopology α] {f : α → Set α} (hf : ∀ x, f x ∈ 𝓝 x) :
    ∃ s : Set α, s.Countable ∧ ⋃ x ∈ s, f x = univ 
goal: ∃ s, s.Countable ∧ ⋃ x ∈ s, f x = Set.univ

full_name: TopologicalSpace.countable_cover_nhdsWithin
code: theorem countable_cover_nhdsWithin [SecondCountableTopology α] {f : α → Set α} {s : Set α}
    (hf : ∀ x ∈ s, f x ∈ 𝓝[s] x) : ∃ t ⊆ s, t.Countable ∧ s ⊆ ⋃ x ∈ t, f x 
goal: ∃ t ⊆ s, t.Countable ∧ s ⊆ ⋃ x ∈ t, f x

full_name: TopologicalSpace.IsTopologicalBasis.sigma
code: /-- In a disjoint union space `Σ i, E i`, one can form a topological basis by taking the union of
topological bases on each of the parts of the space. -/
theorem IsTopologicalBasis.sigma {s : ∀ i : ι, Set (Set (E i))}
    (hs : ∀ i, IsTopologicalBasis (s i)) :
    IsTopologicalBasis (⋃ i : ι, (fun u => (Sigma.mk i '' u : Set (Σi, E i))) '' s i) 
goal: TopologicalSpace.IsTopologicalBasis (⋃ i, (fun u => Sigma.mk i '' u) '' s i)

full_name: TopologicalSpace.instSecondCountableTopologySigmaOfCountable
code: /-- A countable disjoint union of second countable spaces is second countable. -/
instance [Countable ι] [∀ i, SecondCountableTopology (E i)] :
    SecondCountableTopology (Σi, E i) 
goal: SecondCountableTopology ((i : ι) × E i)

full_name: TopologicalSpace.IsTopologicalBasis.sum
code: /-- In a sum space `α ⊕ β`, one can form a topological basis by taking the union of
topological bases on each of the two components. -/
theorem IsTopologicalBasis.sum {s : Set (Set α)} (hs : IsTopologicalBasis s) {t : Set (Set β)}
    (ht : IsTopologicalBasis t) :
    IsTopologicalBasis ((fun u => Sum.inl '' u) '' s ∪ (fun u => Sum.inr '' u) '' t) 
goal: TopologicalSpace.IsTopologicalBasis ((fun u => Sum.inl '' u) '' s ∪ (fun u => Sum.inr '' u) '' t)

full_name: TopologicalSpace.instSecondCountableTopologySum
code: /-- A sum type of two second countable spaces is second countable. -/
instance [SecondCountableTopology α] [SecondCountableTopology β] :
    SecondCountableTopology (α ⊕ β) 
goal: SecondCountableTopology (α ⊕ β)

full_name: TopologicalSpace.IsTopologicalBasis.quotientMap
code: /-- The image of a topological basis under an open quotient map is a topological basis. -/
theorem IsTopologicalBasis.quotientMap {V : Set (Set X)} (hV : IsTopologicalBasis V)
    (h' : QuotientMap π) (h : IsOpenMap π) : IsTopologicalBasis (Set.image π '' V) 
goal: TopologicalSpace.IsTopologicalBasis (Set.image π '' V)

full_name: QuotientMap.secondCountableTopology
code: /-- A second countable space is mapped by an open quotient map to a second countable space. -/
theorem _root_.QuotientMap.secondCountableTopology [SecondCountableTopology X] (h' : QuotientMap π)
    (h : IsOpenMap π) : SecondCountableTopology Y 
goal: SecondCountableTopology Y

full_name: TopologicalSpace.IsTopologicalBasis.quotient
code: /-- The image of a topological basis "downstairs" in an open quotient is a topological basis. -/
theorem IsTopologicalBasis.quotient {V : Set (Set X)} (hV : IsTopologicalBasis V)
    (h : IsOpenMap (Quotient.mk' : X → Quotient S)) :
    IsTopologicalBasis (Set.image (Quotient.mk' : X → Quotient S) '' V) 
goal: TopologicalSpace.IsTopologicalBasis (Set.image Quotient.mk' '' V)

full_name: TopologicalSpace.Quotient.secondCountableTopology
code: /-- An open quotient of a second countable space is second countable. -/
theorem Quotient.secondCountableTopology [SecondCountableTopology X]
    (h : IsOpenMap (Quotient.mk' : X → Quotient S)) : SecondCountableTopology (Quotient S) 
goal: SecondCountableTopology (Quotient S)

full_name: Inducing.secondCountableTopology
code: protected theorem Inducing.secondCountableTopology [SecondCountableTopology β] (hf : Inducing f) :
    SecondCountableTopology α 
goal: SecondCountableTopology α

full_name: Embedding.secondCountableTopology
code: protected theorem Embedding.secondCountableTopology [SecondCountableTopology β] (hf : Embedding f) :
    SecondCountableTopology α 
goal: SecondCountableTopology α

full_name: Embedding.separableSpace
code: protected theorem Embedding.separableSpace [TopologicalSpace α]
    [TopologicalSpace β] [SecondCountableTopology β] {f : α → β} (hf : Embedding f) :
    TopologicalSpace.SeparableSpace α 
goal: TopologicalSpace.SeparableSpace α