File: Mathlib/Topology/Connected/Basic.lean

full_name: IsPreconnected
code: /-- A preconnected set is one where there is no non-trivial open partition. -/
def IsPreconnected (s : Set α) : Prop 
goal: Prop

full_name: IsConnected
code: /-- A connected set is one that is nonempty and where there is no non-trivial open partition. -/
def IsConnected (s : Set α) : Prop 
goal: Prop

full_name: IsConnected.nonempty
code: theorem IsConnected.nonempty {s : Set α} (h : IsConnected s) : s.Nonempty 
goal: s.Nonempty

full_name: IsConnected.isPreconnected
code: theorem IsConnected.isPreconnected {s : Set α} (h : IsConnected s) : IsPreconnected s 
goal: IsPreconnected s

full_name: IsPreirreducible.isPreconnected
code: theorem IsPreirreducible.isPreconnected {s : Set α} (H : IsPreirreducible s) : IsPreconnected s 
goal: IsPreconnected s

full_name: IsIrreducible.isConnected
code: theorem IsIrreducible.isConnected {s : Set α} (H : IsIrreducible s) : IsConnected s 
goal: IsConnected s

full_name: isPreconnected_empty
code: theorem isPreconnected_empty : IsPreconnected (∅ : Set α) 
goal: IsPreconnected ∅

full_name: isConnected_singleton
code: theorem isConnected_singleton {x} : IsConnected ({x} : Set α) 
goal: IsConnected {x}

full_name: isPreconnected_singleton
code: theorem isPreconnected_singleton {x} : IsPreconnected ({x} : Set α) 
goal: IsPreconnected {x}

full_name: Set.Subsingleton.isPreconnected
code: theorem Set.Subsingleton.isPreconnected {s : Set α} (hs : s.Subsingleton) : IsPreconnected s 
goal: IsPreconnected s

full_name: isPreconnected_of_forall
code: /-- If any point of a set is joined to a fixed point by a preconnected subset,
then the original set is preconnected as well. -/
theorem isPreconnected_of_forall {s : Set α} (x : α)
    (H : ∀ y ∈ s, ∃ t, t ⊆ s ∧ x ∈ t ∧ y ∈ t ∧ IsPreconnected t) : IsPreconnected s 
goal: IsPreconnected s

full_name: isPreconnected_of_forall_pair
code: /-- If any two points of a set are contained in a preconnected subset,
then the original set is preconnected as well. -/
theorem isPreconnected_of_forall_pair {s : Set α}
    (H : ∀ x ∈ s, ∀ y ∈ s, ∃ t, t ⊆ s ∧ x ∈ t ∧ y ∈ t ∧ IsPreconnected t) :
    IsPreconnected s 
goal: IsPreconnected s

full_name: isPreconnected_sUnion
code: /-- A union of a family of preconnected sets with a common point is preconnected as well. -/
theorem isPreconnected_sUnion (x : α) (c : Set (Set α)) (H1 : ∀ s ∈ c, x ∈ s)
    (H2 : ∀ s ∈ c, IsPreconnected s) : IsPreconnected (⋃₀ c) 
goal: IsPreconnected (⋃₀ c)

full_name: isPreconnected_iUnion
code: theorem isPreconnected_iUnion {ι : Sort*} {s : ι → Set α} (h₁ : (⋂ i, s i).Nonempty)
    (h₂ : ∀ i, IsPreconnected (s i)) : IsPreconnected (⋃ i, s i) 
goal: IsPreconnected (⋃ i, s i)

full_name: IsPreconnected.union
code: theorem IsPreconnected.union (x : α) {s t : Set α} (H1 : x ∈ s) (H2 : x ∈ t) (H3 : IsPreconnected s)
    (H4 : IsPreconnected t) : IsPreconnected (s ∪ t) 
goal: IsPreconnected (s ∪ t)

full_name: IsPreconnected.union'
code: theorem IsPreconnected.union' {s t : Set α} (H : (s ∩ t).Nonempty) (hs : IsPreconnected s)
    (ht : IsPreconnected t) : IsPreconnected (s ∪ t) 
goal: IsPreconnected (s ∪ t)

full_name: IsConnected.union
code: theorem IsConnected.union {s t : Set α} (H : (s ∩ t).Nonempty) (Hs : IsConnected s)
    (Ht : IsConnected t) : IsConnected (s ∪ t) 
goal: IsConnected (s ∪ t)

full_name: IsPreconnected.sUnion_directed
code: /-- The directed sUnion of a set S of preconnected subsets is preconnected. -/
theorem IsPreconnected.sUnion_directed {S : Set (Set α)} (K : DirectedOn (· ⊆ ·) S)
    (H : ∀ s ∈ S, IsPreconnected s) : IsPreconnected (⋃₀ S) 
goal: IsPreconnected (⋃₀ S)

full_name: IsPreconnected.biUnion_of_reflTransGen
code: /-- The biUnion of a family of preconnected sets is preconnected if the graph determined by
whether two sets intersect is preconnected. -/
theorem IsPreconnected.biUnion_of_reflTransGen {ι : Type*} {t : Set ι} {s : ι → Set α}
    (H : ∀ i ∈ t, IsPreconnected (s i))
    (K : ∀ i, i ∈ t → ∀ j, j ∈ t → ReflTransGen (fun i j => (s i ∩ s j).Nonempty ∧ i ∈ t) i j) :
    IsPreconnected (⋃ n ∈ t, s n) 
goal: IsPreconnected (⋃ n ∈ t, s n)

full_name: IsConnected.biUnion_of_reflTransGen
code: /-- The biUnion of a family of preconnected sets is preconnected if the graph determined by
whether two sets intersect is preconnected. -/
theorem IsConnected.biUnion_of_reflTransGen {ι : Type*} {t : Set ι} {s : ι → Set α}
    (ht : t.Nonempty) (H : ∀ i ∈ t, IsConnected (s i))
    (K : ∀ i, i ∈ t → ∀ j, j ∈ t → ReflTransGen (fun i j : ι => (s i ∩ s j).Nonempty ∧ i ∈ t) i j) :
    IsConnected (⋃ n ∈ t, s n) 
goal: IsConnected (⋃ n ∈ t, s n)

full_name: IsPreconnected.iUnion_of_reflTransGen
code: /-- Preconnectedness of the iUnion of a family of preconnected sets
indexed by the vertices of a preconnected graph,
where two vertices are joined when the corresponding sets intersect. -/
theorem IsPreconnected.iUnion_of_reflTransGen {ι : Type*} {s : ι → Set α}
    (H : ∀ i, IsPreconnected (s i))
    (K : ∀ i j, ReflTransGen (fun i j : ι => (s i ∩ s j).Nonempty) i j) :
    IsPreconnected (⋃ n, s n) 
goal: IsPreconnected (⋃ n, s n)

full_name: IsConnected.iUnion_of_reflTransGen
code: theorem IsConnected.iUnion_of_reflTransGen {ι : Type*} [Nonempty ι] {s : ι → Set α}
    (H : ∀ i, IsConnected (s i))
    (K : ∀ i j, ReflTransGen (fun i j : ι => (s i ∩ s j).Nonempty) i j) : IsConnected (⋃ n, s n) 
goal: IsConnected (⋃ n, s n)

full_name: IsPreconnected.iUnion_of_chain
code: /-- The iUnion of connected sets indexed by a type with an archimedean successor (like `ℕ` or `ℤ`)
  such that any two neighboring sets meet is preconnected. -/
theorem IsPreconnected.iUnion_of_chain {s : β → Set α} (H : ∀ n, IsPreconnected (s n))
    (K : ∀ n, (s n ∩ s (succ n)).Nonempty) : IsPreconnected (⋃ n, s n) 
goal: IsPreconnected (⋃ n, s n)

full_name: IsConnected.iUnion_of_chain
code: /-- The iUnion of connected sets indexed by a type with an archimedean successor (like `ℕ` or `ℤ`)
  such that any two neighboring sets meet is connected. -/
theorem IsConnected.iUnion_of_chain [Nonempty β] {s : β → Set α} (H : ∀ n, IsConnected (s n))
    (K : ∀ n, (s n ∩ s (succ n)).Nonempty) : IsConnected (⋃ n, s n) 
goal: IsConnected (⋃ n, s n)

full_name: IsPreconnected.biUnion_of_chain
code: /-- The iUnion of preconnected sets indexed by a subset of a type with an archimedean successor
  (like `ℕ` or `ℤ`) such that any two neighboring sets meet is preconnected. -/
theorem IsPreconnected.biUnion_of_chain {s : β → Set α} {t : Set β} (ht : OrdConnected t)
    (H : ∀ n ∈ t, IsPreconnected (s n))
    (K : ∀ n : β, n ∈ t → succ n ∈ t → (s n ∩ s (succ n)).Nonempty) :
    IsPreconnected (⋃ n ∈ t, s n) 
goal: IsPreconnected (⋃ n ∈ t, s n)

full_name: IsConnected.biUnion_of_chain
code: /-- The iUnion of connected sets indexed by a subset of a type with an archimedean successor
  (like `ℕ` or `ℤ`) such that any two neighboring sets meet is preconnected. -/
theorem IsConnected.biUnion_of_chain {s : β → Set α} {t : Set β} (hnt : t.Nonempty)
    (ht : OrdConnected t) (H : ∀ n ∈ t, IsConnected (s n))
    (K : ∀ n : β, n ∈ t → succ n ∈ t → (s n ∩ s (succ n)).Nonempty) : IsConnected (⋃ n ∈ t, s n) 
goal: IsConnected (⋃ n ∈ t, s n)

full_name: IsPreconnected.subset_closure
code: /-- Theorem of bark and tree: if a set is within a preconnected set and its closure, then it is
preconnected as well. See also `IsConnected.subset_closure`. -/
protected theorem IsPreconnected.subset_closure {s : Set α} {t : Set α} (H : IsPreconnected s)
    (Kst : s ⊆ t) (Ktcs : t ⊆ closure s) : IsPreconnected t 
goal: IsPreconnected t

full_name: IsConnected.subset_closure
code: /-- Theorem of bark and tree: if a set is within a connected set and its closure, then it is
connected as well. See also `IsPreconnected.subset_closure`. -/
protected theorem IsConnected.subset_closure {s : Set α} {t : Set α} (H : IsConnected s)
    (Kst : s ⊆ t) (Ktcs : t ⊆ closure s) : IsConnected t 
goal: IsConnected t

full_name: IsPreconnected.closure
code: /-- The closure of a preconnected set is preconnected as well. -/
protected theorem IsPreconnected.closure {s : Set α} (H : IsPreconnected s) :
    IsPreconnected (closure s) 
goal: IsPreconnected (closure s)

full_name: IsConnected.closure
code: /-- The closure of a connected set is connected as well. -/
protected theorem IsConnected.closure {s : Set α} (H : IsConnected s) : IsConnected (closure s) 
goal: IsConnected (closure s)

full_name: IsPreconnected.image
code: /-- The image of a preconnected set is preconnected as well. -/
protected theorem IsPreconnected.image [TopologicalSpace β] {s : Set α} (H : IsPreconnected s)
    (f : α → β) (hf : ContinuousOn f s) : IsPreconnected (f '' s) 
goal: IsPreconnected (f '' s)

full_name: IsConnected.image
code: /-- The image of a connected set is connected as well. -/
protected theorem IsConnected.image [TopologicalSpace β] {s : Set α} (H : IsConnected s) (f : α → β)
    (hf : ContinuousOn f s) : IsConnected (f '' s) 
goal: IsConnected (f '' s)

full_name: isPreconnected_closed_iff
code: theorem isPreconnected_closed_iff {s : Set α} :
    IsPreconnected s ↔ ∀ t t', IsClosed t → IsClosed t' →
      s ⊆ t ∪ t' → (s ∩ t).Nonempty → (s ∩ t').Nonempty → (s ∩ (t ∩ t')).Nonempty 
goal: IsPreconnected s ↔
  ∀ (t t' : Set α),
    IsClosed t → IsClosed t' → s ⊆ t ∪ t' → (s ∩ t).Nonempty → (s ∩ t').Nonempty → (s ∩ (t ∩ t')).Nonempty

full_name: Inducing.isPreconnected_image
code: theorem Inducing.isPreconnected_image [TopologicalSpace β] {s : Set α} {f : α → β}
    (hf : Inducing f) : IsPreconnected (f '' s) ↔ IsPreconnected s 
goal: IsPreconnected (f '' s) ↔ IsPreconnected s

full_name: IsPreconnected.preimage_of_isOpenMap
code: theorem IsPreconnected.preimage_of_isOpenMap [TopologicalSpace β] {f : α → β} {s : Set β}
    (hs : IsPreconnected s) (hinj : Function.Injective f) (hf : IsOpenMap f) (hsf : s ⊆ range f) :
    IsPreconnected (f ⁻¹' s) 
goal: IsPreconnected (f ⁻¹' s)

full_name: IsPreconnected.preimage_of_isClosedMap
code: theorem IsPreconnected.preimage_of_isClosedMap [TopologicalSpace β] {s : Set β}
    (hs : IsPreconnected s) {f : α → β} (hinj : Function.Injective f) (hf : IsClosedMap f)
    (hsf : s ⊆ range f) : IsPreconnected (f ⁻¹' s) 
goal: IsPreconnected (f ⁻¹' s)

full_name: IsConnected.preimage_of_isOpenMap
code: theorem IsConnected.preimage_of_isOpenMap [TopologicalSpace β] {s : Set β} (hs : IsConnected s)
    {f : α → β} (hinj : Function.Injective f) (hf : IsOpenMap f) (hsf : s ⊆ range f) :
    IsConnected (f ⁻¹' s) 
goal: IsConnected (f ⁻¹' s)

full_name: IsConnected.preimage_of_isClosedMap
code: theorem IsConnected.preimage_of_isClosedMap [TopologicalSpace β] {s : Set β} (hs : IsConnected s)
    {f : α → β} (hinj : Function.Injective f) (hf : IsClosedMap f) (hsf : s ⊆ range f) :
    IsConnected (f ⁻¹' s) 
goal: IsConnected (f ⁻¹' s)

full_name: IsPreconnected.subset_or_subset
code: theorem IsPreconnected.subset_or_subset (hu : IsOpen u) (hv : IsOpen v) (huv : Disjoint u v)
    (hsuv : s ⊆ u ∪ v) (hs : IsPreconnected s) : s ⊆ u ∨ s ⊆ v 
goal: s ⊆ u ∨ s ⊆ v

full_name: IsPreconnected.subset_left_of_subset_union
code: theorem IsPreconnected.subset_left_of_subset_union (hu : IsOpen u) (hv : IsOpen v)
    (huv : Disjoint u v) (hsuv : s ⊆ u ∪ v) (hsu : (s ∩ u).Nonempty) (hs : IsPreconnected s) :
    s ⊆ u 
goal: s ⊆ u

full_name: IsPreconnected.subset_right_of_subset_union
code: theorem IsPreconnected.subset_right_of_subset_union (hu : IsOpen u) (hv : IsOpen v)
    (huv : Disjoint u v) (hsuv : s ⊆ u ∪ v) (hsv : (s ∩ v).Nonempty) (hs : IsPreconnected s) :
    s ⊆ v 
goal: s ⊆ v

full_name: IsPreconnected.subset_of_closure_inter_subset
code: /-- If a preconnected set `s` intersects an open set `u`, and limit points of `u` inside `s` are
contained in `u`, then the whole set `s` is contained in `u`. -/
theorem IsPreconnected.subset_of_closure_inter_subset (hs : IsPreconnected s) (hu : IsOpen u)
    (h'u : (s ∩ u).Nonempty) (h : closure u ∩ s ⊆ u) : s ⊆ u 
goal: s ⊆ u

full_name: IsPreconnected.prod
code: theorem IsPreconnected.prod [TopologicalSpace β] {s : Set α} {t : Set β} (hs : IsPreconnected s)
    (ht : IsPreconnected t) : IsPreconnected (s ×ˢ t) 
goal: IsPreconnected (s ×ˢ t)

full_name: IsConnected.prod
code: theorem IsConnected.prod [TopologicalSpace β] {s : Set α} {t : Set β} (hs : IsConnected s)
    (ht : IsConnected t) : IsConnected (s ×ˢ t) 
goal: IsConnected (s ×ˢ t)

full_name: isPreconnected_univ_pi
code: theorem isPreconnected_univ_pi [∀ i, TopologicalSpace (π i)] {s : ∀ i, Set (π i)}
    (hs : ∀ i, IsPreconnected (s i)) : IsPreconnected (pi univ s) 
goal: IsPreconnected (Set.univ.pi s)

full_name: isConnected_univ_pi
code: @[simp]
theorem isConnected_univ_pi [∀ i, TopologicalSpace (π i)] {s : ∀ i, Set (π i)} :
    IsConnected (pi univ s) ↔ ∀ i, IsConnected (s i) 
goal: IsConnected (Set.univ.pi s) ↔ ∀ (i : ι), IsConnected (s i)

full_name: connectedComponent
code: /-- The connected component of a point is the maximal connected set
that contains this point. -/
def connectedComponent (x : α) : Set α 
goal: Set α

full_name: connectedComponentIn
code: /-- Given a set `F` in a topological space `α` and a point `x : α`, the connected
component of `x` in `F` is the connected component of `x` in the subtype `F` seen as
a set in `α`. This definition does not make sense if `x` is not in `F` so we return the
empty set in this case. -/
def connectedComponentIn (F : Set α) (x : α) : Set α 
goal: Set α

full_name: connectedComponentIn_eq_image
code: theorem connectedComponentIn_eq_image {F : Set α} {x : α} (h : x ∈ F) :
    connectedComponentIn F x = (↑) '' connectedComponent (⟨x, h⟩ : F) 
goal: connectedComponentIn F x = Subtype.val '' connectedComponent ⟨x, h⟩

full_name: connectedComponentIn_eq_empty
code: theorem connectedComponentIn_eq_empty {F : Set α} {x : α} (h : x ∉ F) :
    connectedComponentIn F x = ∅ 
goal: connectedComponentIn F x = ∅

full_name: mem_connectedComponent
code: theorem mem_connectedComponent {x : α} : x ∈ connectedComponent x 
goal: x ∈ connectedComponent x

full_name: mem_connectedComponentIn
code: theorem mem_connectedComponentIn {x : α} {F : Set α} (hx : x ∈ F) :
    x ∈ connectedComponentIn F x 
goal: x ∈ connectedComponentIn F x

full_name: connectedComponent_nonempty
code: theorem connectedComponent_nonempty {x : α} : (connectedComponent x).Nonempty 
goal: (connectedComponent x).Nonempty

full_name: connectedComponentIn_nonempty_iff
code: theorem connectedComponentIn_nonempty_iff {x : α} {F : Set α} :
    (connectedComponentIn F x).Nonempty ↔ x ∈ F 
goal: (connectedComponentIn F x).Nonempty ↔ x ∈ F

full_name: connectedComponentIn_subset
code: theorem connectedComponentIn_subset (F : Set α) (x : α) : connectedComponentIn F x ⊆ F 
goal: connectedComponentIn F x ⊆ F

full_name: isPreconnected_connectedComponent
code: theorem isPreconnected_connectedComponent {x : α} : IsPreconnected (connectedComponent x) 
goal: IsPreconnected (connectedComponent x)

full_name: isPreconnected_connectedComponentIn
code: theorem isPreconnected_connectedComponentIn {x : α} {F : Set α} :
    IsPreconnected (connectedComponentIn F x) 
goal: IsPreconnected (connectedComponentIn F x)

full_name: isConnected_connectedComponent
code: theorem isConnected_connectedComponent {x : α} : IsConnected (connectedComponent x) 
goal: IsConnected (connectedComponent x)

full_name: isConnected_connectedComponentIn_iff
code: theorem isConnected_connectedComponentIn_iff {x : α} {F : Set α} :
    IsConnected (connectedComponentIn F x) ↔ x ∈ F 
goal: IsConnected (connectedComponentIn F x) ↔ x ∈ F

full_name: IsPreconnected.subset_connectedComponent
code: theorem IsPreconnected.subset_connectedComponent {x : α} {s : Set α} (H1 : IsPreconnected s)
    (H2 : x ∈ s) : s ⊆ connectedComponent x 
goal: s ⊆ connectedComponent x

full_name: IsPreconnected.subset_connectedComponentIn
code: theorem IsPreconnected.subset_connectedComponentIn {x : α} {F : Set α} (hs : IsPreconnected s)
    (hxs : x ∈ s) (hsF : s ⊆ F) : s ⊆ connectedComponentIn F x 
goal: s ⊆ connectedComponentIn F x

full_name: IsConnected.subset_connectedComponent
code: theorem IsConnected.subset_connectedComponent {x : α} {s : Set α} (H1 : IsConnected s)
    (H2 : x ∈ s) : s ⊆ connectedComponent x 
goal: s ⊆ connectedComponent x

full_name: IsPreconnected.connectedComponentIn
code: theorem IsPreconnected.connectedComponentIn {x : α} {F : Set α} (h : IsPreconnected F)
    (hx : x ∈ F) : connectedComponentIn F x = F 
goal: connectedComponentIn F x = F

full_name: connectedComponent_eq
code: theorem connectedComponent_eq {x y : α} (h : y ∈ connectedComponent x) :
    connectedComponent x = connectedComponent y 
goal: connectedComponent x = connectedComponent y

full_name: connectedComponent_eq_iff_mem
code: theorem connectedComponent_eq_iff_mem {x y : α} :
    connectedComponent x = connectedComponent y ↔ x ∈ connectedComponent y 
goal: connectedComponent x = connectedComponent y ↔ x ∈ connectedComponent y

full_name: connectedComponentIn_eq
code: theorem connectedComponentIn_eq {x y : α} {F : Set α} (h : y ∈ connectedComponentIn F x) :
    connectedComponentIn F x = connectedComponentIn F y 
goal: connectedComponentIn F x = connectedComponentIn F y

full_name: connectedComponentIn_univ
code: theorem connectedComponentIn_univ (x : α) : connectedComponentIn univ x = connectedComponent x 
goal: connectedComponentIn Set.univ x = connectedComponent x

full_name: connectedComponent_disjoint
code: theorem connectedComponent_disjoint {x y : α} (h : connectedComponent x ≠ connectedComponent y) :
    Disjoint (connectedComponent x) (connectedComponent y) 
goal: Disjoint (connectedComponent x) (connectedComponent y)

full_name: isClosed_connectedComponent
code: theorem isClosed_connectedComponent {x : α} : IsClosed (connectedComponent x) 
goal: IsClosed (connectedComponent x)

full_name: Continuous.image_connectedComponent_subset
code: theorem Continuous.image_connectedComponent_subset [TopologicalSpace β] {f : α → β}
    (h : Continuous f) (a : α) : f '' connectedComponent a ⊆ connectedComponent (f a) 
goal: f '' connectedComponent a ⊆ connectedComponent (f a)

full_name: Continuous.image_connectedComponentIn_subset
code: theorem Continuous.image_connectedComponentIn_subset [TopologicalSpace β] {f : α → β} {s : Set α}
    {a : α} (hf : Continuous f) (hx : a ∈ s) :
    f '' connectedComponentIn s a ⊆ connectedComponentIn (f '' s) (f a) 
goal: f '' connectedComponentIn s a ⊆ connectedComponentIn (f '' s) (f a)

full_name: Continuous.mapsTo_connectedComponent
code: theorem Continuous.mapsTo_connectedComponent [TopologicalSpace β] {f : α → β} (h : Continuous f)
    (a : α) : MapsTo f (connectedComponent a) (connectedComponent (f a)) 
goal: Set.MapsTo f (connectedComponent a) (connectedComponent (f a))

full_name: Continuous.mapsTo_connectedComponentIn
code: theorem Continuous.mapsTo_connectedComponentIn [TopologicalSpace β] {f : α → β} {s : Set α}
    (h : Continuous f) {a : α} (hx : a ∈ s) :
    MapsTo f (connectedComponentIn s a) (connectedComponentIn (f '' s) (f a)) 
goal: Set.MapsTo f (connectedComponentIn s a) (connectedComponentIn (f '' s) (f a))

full_name: irreducibleComponent_subset_connectedComponent
code: theorem irreducibleComponent_subset_connectedComponent {x : α} :
    irreducibleComponent x ⊆ connectedComponent x 
goal: irreducibleComponent x ⊆ connectedComponent x

full_name: connectedComponentIn_mono
code: @[mono]
theorem connectedComponentIn_mono (x : α) {F G : Set α} (h : F ⊆ G) :
    connectedComponentIn F x ⊆ connectedComponentIn G x 
goal: connectedComponentIn F x ⊆ connectedComponentIn G x

full_name: PreconnectedSpace.isPreconnected_univ
code: /-- A preconnected space is one where there is no non-trivial open partition. -/
class PreconnectedSpace (α : Type u) [TopologicalSpace α] : Prop where
  /-- The universal set `Set.univ` in a preconnected space is a preconnected set. -/
  isPreconnected_univ : IsPreconnected (univ : Set α)
goal: IsPreconnected Set.univ

full_name: PreconnectedSpace
code: /-- A preconnected space is one where there is no non-trivial open partition. -/
class PreconnectedSpace (α : Type u) [TopologicalSpace α] : Prop where
  /-- The universal set `Set.univ` in a preconnected space is a preconnected set. -/
  isPreconnected_univ : IsPreconnected (univ : Set α)
goal: Prop

full_name: ConnectedSpace
code: /-- A connected space is a nonempty one where there is no non-trivial open partition. -/
class ConnectedSpace (α : Type u) [TopologicalSpace α] extends PreconnectedSpace α : Prop where
  /-- A connected space is nonempty. -/
  toNonempty : Nonempty α
goal: Prop

full_name: ConnectedSpace.toNonempty
code: /-- A connected space is a nonempty one where there is no non-trivial open partition. -/
class ConnectedSpace (α : Type u) [TopologicalSpace α] extends PreconnectedSpace α : Prop where
  /-- A connected space is nonempty. -/
  toNonempty : Nonempty α
goal: Nonempty α

full_name: isConnected_univ
code: theorem isConnected_univ [ConnectedSpace α] : IsConnected (univ : Set α) 
goal: IsConnected Set.univ

full_name: preconnectedSpace_iff_univ
code: lemma preconnectedSpace_iff_univ : PreconnectedSpace α ↔ IsPreconnected (univ : Set α) 
goal: PreconnectedSpace α ↔ IsPreconnected Set.univ

full_name: connectedSpace_iff_univ
code: lemma connectedSpace_iff_univ : ConnectedSpace α ↔ IsConnected (univ : Set α) 
goal: ConnectedSpace α ↔ IsConnected Set.univ

full_name: isPreconnected_range
code: theorem isPreconnected_range [TopologicalSpace β] [PreconnectedSpace α] {f : α → β}
    (h : Continuous f) : IsPreconnected (range f) 
goal: IsPreconnected (Set.range f)

full_name: isConnected_range
code: theorem isConnected_range [TopologicalSpace β] [ConnectedSpace α] {f : α → β} (h : Continuous f) :
    IsConnected (range f) 
goal: IsConnected (Set.range f)

full_name: Function.Surjective.connectedSpace
code: theorem Function.Surjective.connectedSpace [ConnectedSpace α] [TopologicalSpace β]
    {f : α → β} (hf : Surjective f) (hf' : Continuous f) : ConnectedSpace β 
goal: ConnectedSpace β

full_name: Quotient.instConnectedSpace
code: instance Quotient.instConnectedSpace {s : Setoid α} [ConnectedSpace α] :
    ConnectedSpace (Quotient s) 
goal: ConnectedSpace (Quotient s)

full_name: DenseRange.preconnectedSpace
code: theorem DenseRange.preconnectedSpace [TopologicalSpace β] [PreconnectedSpace α] {f : α → β}
    (hf : DenseRange f) (hc : Continuous f) : PreconnectedSpace β 
goal: PreconnectedSpace β

full_name: connectedSpace_iff_connectedComponent
code: theorem connectedSpace_iff_connectedComponent :
    ConnectedSpace α ↔ ∃ x : α, connectedComponent x = univ 
goal: ConnectedSpace α ↔ ∃ x, connectedComponent x = Set.univ

full_name: preconnectedSpace_iff_connectedComponent
code: theorem preconnectedSpace_iff_connectedComponent :
    PreconnectedSpace α ↔ ∀ x : α, connectedComponent x = univ 
goal: PreconnectedSpace α ↔ ∀ (x : α), connectedComponent x = Set.univ

full_name: PreconnectedSpace.connectedComponent_eq_univ
code: @[simp]
theorem PreconnectedSpace.connectedComponent_eq_univ {X : Type*} [TopologicalSpace X]
    [h : PreconnectedSpace X] (x : X) : connectedComponent x = univ 
goal: connectedComponent x = Set.univ

full_name: instPreconnectedSpaceProd
code: instance [TopologicalSpace β] [PreconnectedSpace α] [PreconnectedSpace β] :
    PreconnectedSpace (α × β) 
goal: PreconnectedSpace (α × β)

full_name: instConnectedSpaceProd
code: instance [TopologicalSpace β] [ConnectedSpace α] [ConnectedSpace β] : ConnectedSpace (α × β) 
goal: ConnectedSpace (α × β)

full_name: instPreconnectedSpaceForall
code: instance [∀ i, TopologicalSpace (π i)] [∀ i, PreconnectedSpace (π i)] :
    PreconnectedSpace (∀ i, π i) 
goal: PreconnectedSpace ((i : ι) → π i)

full_name: instConnectedSpaceForall
code: instance [∀ i, TopologicalSpace (π i)] [∀ i, ConnectedSpace (π i)] : ConnectedSpace (∀ i, π i) 
goal: ConnectedSpace ((i : ι) → π i)

full_name: PreirreducibleSpace.preconnectedSpace
code: instance (priority := 100) PreirreducibleSpace.preconnectedSpace (α : Type u) [TopologicalSpace α]
    [PreirreducibleSpace α] : PreconnectedSpace α 
goal: PreconnectedSpace α

full_name: IrreducibleSpace.connectedSpace
code: instance (priority := 100) IrreducibleSpace.connectedSpace (α : Type u) [TopologicalSpace α]
    [IrreducibleSpace α] : ConnectedSpace α 
goal: ConnectedSpace α

full_name: Subtype.preconnectedSpace
code: theorem Subtype.preconnectedSpace {s : Set α} (h : IsPreconnected s) : PreconnectedSpace s 
goal: PreconnectedSpace ↑s

full_name: Subtype.connectedSpace
code: theorem Subtype.connectedSpace {s : Set α} (h : IsConnected s) : ConnectedSpace s 
goal: ConnectedSpace ↑s

full_name: isPreconnected_iff_preconnectedSpace
code: theorem isPreconnected_iff_preconnectedSpace {s : Set α} : IsPreconnected s ↔ PreconnectedSpace s 
goal: IsPreconnected s ↔ PreconnectedSpace ↑s

full_name: isConnected_iff_connectedSpace
code: theorem isConnected_iff_connectedSpace {s : Set α} : IsConnected s ↔ ConnectedSpace s 
goal: IsConnected s ↔ ConnectedSpace ↑s