File: Mathlib/Topology/Connected/TotallyDisconnected.lean

full_name: IsTotallyDisconnected
code: /-- A set `s` is called totally disconnected if every subset `t ⊆ s` which is preconnected is
a subsingleton, ie either empty or a singleton. -/
def IsTotallyDisconnected (s : Set α) : Prop 
goal: Prop

full_name: isTotallyDisconnected_empty
code: theorem isTotallyDisconnected_empty : IsTotallyDisconnected (∅ : Set α) 
goal: IsTotallyDisconnected ∅

full_name: isTotallyDisconnected_singleton
code: theorem isTotallyDisconnected_singleton {x} : IsTotallyDisconnected ({x} : Set α) 
goal: IsTotallyDisconnected {x}

full_name: TotallyDisconnectedSpace.isTotallyDisconnected_univ
code: /-- A space is totally disconnected if all of its connected components are singletons. -/
@[mk_iff]
class TotallyDisconnectedSpace (α : Type u) [TopologicalSpace α] : Prop where
  /-- The universal set `Set.univ` in a totally disconnected space is totally disconnected. -/
  isTotallyDisconnected_univ : IsTotallyDisconnected (univ : Set α)
goal: IsTotallyDisconnected Set.univ

full_name: totallyDisconnectedSpace_iff
code: /-- A space is totally disconnected if all of its connected components are singletons. -/
@[mk_iff]
class TotallyDisconnectedSpace (α : Type u) [TopologicalSpace α] : Prop where
  /-- The universal set `Set.univ` in a totally disconnected space is totally disconnected. -/
  isTotallyDisconnected_univ : IsTotallyDisconnected (univ : Set α)
goal: TotallyDisconnectedSpace α ↔ IsTotallyDisconnected Set.univ

full_name: TotallyDisconnectedSpace
code: /-- A space is totally disconnected if all of its connected components are singletons. -/
@[mk_iff]
class TotallyDisconnectedSpace (α : Type u) [TopologicalSpace α] : Prop where
  /-- The universal set `Set.univ` in a totally disconnected space is totally disconnected. -/
  isTotallyDisconnected_univ : IsTotallyDisconnected (univ : Set α)
goal: Prop

full_name: IsPreconnected.subsingleton
code: theorem IsPreconnected.subsingleton [TotallyDisconnectedSpace α] {s : Set α}
    (h : IsPreconnected s) : s.Subsingleton 
goal: s.Subsingleton

full_name: Pi.totallyDisconnectedSpace
code: instance Pi.totallyDisconnectedSpace {α : Type*} {β : α → Type*}
    [∀ a, TopologicalSpace (β a)] [∀ a, TotallyDisconnectedSpace (β a)] :
    TotallyDisconnectedSpace (∀ a : α, β a) 
goal: TotallyDisconnectedSpace ((a : α) → β a)

full_name: Prod.totallyDisconnectedSpace
code: instance Prod.totallyDisconnectedSpace [TopologicalSpace β] [TotallyDisconnectedSpace α]
    [TotallyDisconnectedSpace β] : TotallyDisconnectedSpace (α × β) 
goal: TotallyDisconnectedSpace (α × β)

full_name: instTotallyDisconnectedSpaceSum
code: instance [TopologicalSpace β] [TotallyDisconnectedSpace α] [TotallyDisconnectedSpace β] :
    TotallyDisconnectedSpace (α ⊕ β) 
goal: TotallyDisconnectedSpace (α ⊕ β)

full_name: instTotallyDisconnectedSpaceSigma
code: instance [∀ i, TopologicalSpace (π i)] [∀ i, TotallyDisconnectedSpace (π i)] :
    TotallyDisconnectedSpace (Σi, π i) 
goal: TotallyDisconnectedSpace ((i : ι) × π i)

full_name: isTotallyDisconnected_of_isClopen_set
code: /-- Let `X` be a topological space, and suppose that for all distinct `x,y ∈ X`, there
  is some clopen set `U` such that `x ∈ U` and `y ∉ U`. Then `X` is totally disconnected. -/
theorem isTotallyDisconnected_of_isClopen_set {X : Type*} [TopologicalSpace X]
    (hX : Pairwise fun x y => ∃ (U : Set X), IsClopen U ∧ x ∈ U ∧ y ∉ U) :
    IsTotallyDisconnected (Set.univ : Set X) 
goal: IsTotallyDisconnected Set.univ

full_name: totallyDisconnectedSpace_iff_connectedComponent_subsingleton
code: /-- A space is totally disconnected iff its connected components are subsingletons. -/
theorem totallyDisconnectedSpace_iff_connectedComponent_subsingleton :
    TotallyDisconnectedSpace α ↔ ∀ x : α, (connectedComponent x).Subsingleton 
goal: TotallyDisconnectedSpace α ↔ ∀ (x : α), (connectedComponent x).Subsingleton

full_name: totallyDisconnectedSpace_iff_connectedComponent_singleton
code: /-- A space is totally disconnected iff its connected components are singletons. -/
theorem totallyDisconnectedSpace_iff_connectedComponent_singleton :
    TotallyDisconnectedSpace α ↔ ∀ x : α, connectedComponent x = {x} 
goal: TotallyDisconnectedSpace α ↔ ∀ (x : α), connectedComponent x = {x}

full_name: connectedComponent_eq_singleton
code: @[simp] theorem connectedComponent_eq_singleton [TotallyDisconnectedSpace α] (x : α) :
    connectedComponent x = {x} 
goal: connectedComponent x = {x}

full_name: Continuous.image_connectedComponent_eq_singleton
code: /-- The image of a connected component in a totally disconnected space is a singleton. -/
@[simp]
theorem Continuous.image_connectedComponent_eq_singleton {β : Type*} [TopologicalSpace β]
    [TotallyDisconnectedSpace β] {f : α → β} (h : Continuous f) (a : α) :
    f '' connectedComponent a = {f a} 
goal: f '' connectedComponent a = {f a}

full_name: isTotallyDisconnected_of_totallyDisconnectedSpace
code: theorem isTotallyDisconnected_of_totallyDisconnectedSpace [TotallyDisconnectedSpace α] (s : Set α) :
    IsTotallyDisconnected s 
goal: IsTotallyDisconnected s

full_name: isTotallyDisconnected_of_image
code: theorem isTotallyDisconnected_of_image [TopologicalSpace β] {f : α → β} (hf : ContinuousOn f s)
    (hf' : Injective f) (h : IsTotallyDisconnected (f '' s)) : IsTotallyDisconnected s 
goal: IsTotallyDisconnected s

full_name: Embedding.isTotallyDisconnected
code: theorem Embedding.isTotallyDisconnected [TopologicalSpace β] {f : α → β} (hf : Embedding f)
    {s : Set α} (h : IsTotallyDisconnected (f '' s)) : IsTotallyDisconnected s 
goal: IsTotallyDisconnected s

full_name: Embedding.isTotallyDisconnected_image
code: lemma Embedding.isTotallyDisconnected_image [TopologicalSpace β] {f : α → β} (hf : Embedding f)
    {s : Set α} : IsTotallyDisconnected (f '' s) ↔ IsTotallyDisconnected s 
goal: IsTotallyDisconnected (f '' s) ↔ IsTotallyDisconnected s

full_name: Embedding.isTotallyDisconnected_range
code: lemma Embedding.isTotallyDisconnected_range [TopologicalSpace β] {f : α → β} (hf : Embedding f) :
    IsTotallyDisconnected (range f) ↔ TotallyDisconnectedSpace α 
goal: IsTotallyDisconnected (Set.range f) ↔ TotallyDisconnectedSpace α

full_name: totallyDisconnectedSpace_subtype_iff
code: lemma totallyDisconnectedSpace_subtype_iff {s : Set α} :
    TotallyDisconnectedSpace s ↔ IsTotallyDisconnected s 
goal: TotallyDisconnectedSpace ↑s ↔ IsTotallyDisconnected s

full_name: Subtype.totallyDisconnectedSpace
code: instance Subtype.totallyDisconnectedSpace {α : Type*} {p : α → Prop} [TopologicalSpace α]
    [TotallyDisconnectedSpace α] : TotallyDisconnectedSpace (Subtype p) 
goal: TotallyDisconnectedSpace (Subtype p)

full_name: IsTotallySeparated
code: /-- A set `s` is called totally separated if any two points of this set can be separated
by two disjoint open sets covering `s`. -/
def IsTotallySeparated (s : Set α) : Prop 
goal: Prop

full_name: isTotallySeparated_empty
code: theorem isTotallySeparated_empty : IsTotallySeparated (∅ : Set α) 
goal: IsTotallySeparated ∅

full_name: isTotallySeparated_singleton
code: theorem isTotallySeparated_singleton {x} : IsTotallySeparated ({x} : Set α) 
goal: IsTotallySeparated {x}

full_name: isTotallyDisconnected_of_isTotallySeparated
code: theorem isTotallyDisconnected_of_isTotallySeparated {s : Set α} (H : IsTotallySeparated s) :
    IsTotallyDisconnected s 
goal: IsTotallyDisconnected s

full_name: TotallySeparatedSpace.isTotallySeparated_univ
code: /-- A space is totally separated if any two points can be separated by two disjoint open sets
covering the whole space. -/
class TotallySeparatedSpace (α : Type u) [TopologicalSpace α] : Prop where
  /-- The universal set `Set.univ` in a totally separated space is totally separated. -/
  isTotallySeparated_univ : IsTotallySeparated (univ : Set α)
goal: IsTotallySeparated Set.univ

full_name: TotallySeparatedSpace
code: /-- A space is totally separated if any two points can be separated by two disjoint open sets
covering the whole space. -/
class TotallySeparatedSpace (α : Type u) [TopologicalSpace α] : Prop where
  /-- The universal set `Set.univ` in a totally separated space is totally separated. -/
  isTotallySeparated_univ : IsTotallySeparated (univ : Set α)
goal: Prop

full_name: TotallySeparatedSpace.totallyDisconnectedSpace
code: instance (priority := 100) TotallySeparatedSpace.totallyDisconnectedSpace (α : Type u)
    [TopologicalSpace α] [TotallySeparatedSpace α] : TotallyDisconnectedSpace α 
goal: TotallyDisconnectedSpace α

full_name: TotallySeparatedSpace.of_discrete
code: instance (priority := 100) TotallySeparatedSpace.of_discrete (α : Type*) [TopologicalSpace α]
    [DiscreteTopology α] : TotallySeparatedSpace α 
goal: TotallySeparatedSpace α

full_name: exists_isClopen_of_totally_separated
code: theorem exists_isClopen_of_totally_separated {α : Type*} [TopologicalSpace α]
    [TotallySeparatedSpace α] {x y : α} (hxy : x ≠ y) :
    ∃ U : Set α, IsClopen U ∧ x ∈ U ∧ y ∈ Uᶜ 
goal: ∃ U, IsClopen U ∧ x ∈ U ∧ y ∈ Uᶜ

full_name: Continuous.image_eq_of_connectedComponent_eq
code: theorem Continuous.image_eq_of_connectedComponent_eq (h : Continuous f) (a b : α)
    (hab : connectedComponent a = connectedComponent b) : f a = f b 
goal: f a = f b

full_name: Continuous.connectedComponentsLift
code: /--
The lift to `connectedComponents α` of a continuous map from `α` to a totally disconnected space
-/
def Continuous.connectedComponentsLift (h : Continuous f) : ConnectedComponents α → β 
goal: ConnectedComponents α → β

full_name: Continuous.connectedComponentsLift_continuous
code: @[continuity]
theorem Continuous.connectedComponentsLift_continuous (h : Continuous f) :
    Continuous h.connectedComponentsLift 
goal: Continuous h.connectedComponentsLift

full_name: Continuous.connectedComponentsLift_apply_coe
code: @[simp]
theorem Continuous.connectedComponentsLift_apply_coe (h : Continuous f) (x : α) :
    h.connectedComponentsLift x = f x 
goal: h.connectedComponentsLift (ConnectedComponents.mk x) = f x

full_name: Continuous.connectedComponentsLift_comp_coe
code: @[simp]
theorem Continuous.connectedComponentsLift_comp_coe (h : Continuous f) :
    h.connectedComponentsLift ∘ (↑) = f 
goal: h.connectedComponentsLift ∘ ConnectedComponents.mk = f

full_name: connectedComponents_lift_unique'
code: theorem connectedComponents_lift_unique' {β : Sort*} {g₁ g₂ : ConnectedComponents α → β}
    (hg : g₁ ∘ ((↑) : α → ConnectedComponents α) = g₂ ∘ (↑)) : g₁ = g₂ 
goal: g₁ = g₂

full_name: Continuous.connectedComponentsLift_unique
code: theorem Continuous.connectedComponentsLift_unique (h : Continuous f) (g : ConnectedComponents α → β)
    (hg : g ∘ (↑) = f) : g = h.connectedComponentsLift 
goal: g = h.connectedComponentsLift

full_name: ConnectedComponents.totallyDisconnectedSpace
code: instance ConnectedComponents.totallyDisconnectedSpace :
    TotallyDisconnectedSpace (ConnectedComponents α) 
goal: TotallyDisconnectedSpace (ConnectedComponents α)

full_name: Continuous.connectedComponentsMap
code: /-- Functoriality of `connectedComponents` -/
def Continuous.connectedComponentsMap {β : Type*} [TopologicalSpace β] {f : α → β}
    (h : Continuous f) : ConnectedComponents α → ConnectedComponents β 
goal: ConnectedComponents α → ConnectedComponents β

full_name: Continuous.connectedComponentsMap_continuous
code: theorem Continuous.connectedComponentsMap_continuous {β : Type*} [TopologicalSpace β] {f : α → β}
    (h : Continuous f) : Continuous h.connectedComponentsMap 
goal: Continuous h.connectedComponentsMap

full_name: IsPreconnected.constant
code: /-- A preconnected set `s` has the property that every map to a
discrete space that is continuous on `s` is constant on `s` -/
theorem IsPreconnected.constant {Y : Type*} [TopologicalSpace Y] [DiscreteTopology Y] {s : Set α}
    (hs : IsPreconnected s) {f : α → Y} (hf : ContinuousOn f s) {x y : α} (hx : x ∈ s)
    (hy : y ∈ s) : f x = f y 
goal: f x = f y

full_name: PreconnectedSpace.constant
code: /-- A `PreconnectedSpace` version of `isPreconnected.constant` -/
theorem PreconnectedSpace.constant {Y : Type*} [TopologicalSpace Y] [DiscreteTopology Y]
    (hp : PreconnectedSpace α) {f : α → Y} (hf : Continuous f) {x y : α} : f x = f y 
goal: f x = f y

full_name: IsPreconnected.constant_of_mapsTo
code: /-- Refinement of `IsPreconnected.constant` only assuming the map factors through a
discrete subset of the target. -/
theorem IsPreconnected.constant_of_mapsTo {S : Set α} (hS : IsPreconnected S)
    {T : Set β} [DiscreteTopology T] {f : α → β} (hc : ContinuousOn f S) (hTm : MapsTo f S T)
    {x y : α} (hx : x ∈ S) (hy : y ∈ S) : f x = f y 
goal: f x = f y

full_name: IsPreconnected.eqOn_const_of_mapsTo
code: /-- A version of `IsPreconnected.constant_of_mapsTo` that assumes that the codomain is nonempty and
proves that `f` is equal to `const α y` on `S` for some `y ∈ T`. -/
theorem IsPreconnected.eqOn_const_of_mapsTo {S : Set α} (hS : IsPreconnected S)
    {T : Set β} [DiscreteTopology T] {f : α → β} (hc : ContinuousOn f S) (hTm : MapsTo f S T)
    (hne : T.Nonempty) : ∃ y ∈ T, EqOn f (const α y) S 
goal: ∃ y ∈ T, Set.EqOn f (Function.const α y) S