fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
isPreconnected_iff_preconnectedSpace {s : Set α} : IsPreconnected s ↔ PreconnectedSpace s :=
⟨Subtype.preconnectedSpace, fun h => by
simpa using isPreconnected_univ.image ((↑) : s → α) continuous_subtype_val.continuousOn⟩ | theorem | Topology | [
"Mathlib.Data.Set.SymmDiff",
"Mathlib.Order.SuccPred.Relation",
"Mathlib.Topology.Irreducible"
] | Mathlib/Topology/Connected/Basic.lean | isPreconnected_iff_preconnectedSpace | null |
isConnected_iff_connectedSpace {s : Set α} : IsConnected s ↔ ConnectedSpace s :=
⟨Subtype.connectedSpace, fun h =>
⟨nonempty_subtype.mp h.2, isPreconnected_iff_preconnectedSpace.mpr h.1⟩⟩ | theorem | Topology | [
"Mathlib.Data.Set.SymmDiff",
"Mathlib.Order.SuccPred.Relation",
"Mathlib.Topology.Irreducible"
] | Mathlib/Topology/Connected/Basic.lean | isConnected_iff_connectedSpace | null |
IsPreconnected.subset_isClopen {s t : Set α} (hs : IsPreconnected s) (ht : IsClopen t)
(hne : (s ∩ t).Nonempty) : s ⊆ t :=
hs.subset_left_of_subset_union ht.isOpen ht.compl.isOpen disjoint_compl_right (by simp) hne | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | IsPreconnected.subset_isClopen | Preconnected sets are either contained in or disjoint to any given clopen set. |
Sigma.isConnected_iff [∀ i, TopologicalSpace (X i)] {s : Set (Σ i, X i)} :
IsConnected s ↔ ∃ i t, IsConnected t ∧ s = Sigma.mk i '' t := by
refine ⟨fun hs => ?_, ?_⟩
· obtain ⟨⟨i, x⟩, hx⟩ := hs.nonempty
have : s ⊆ range (Sigma.mk i) :=
hs.isPreconnected.subset_isClopen isClopen_range_sigmaMk ⟨⟨i, x⟩, hx, x, rfl⟩
exact ⟨i, Sigma.mk i ⁻¹' s, hs.preimage_of_isOpenMap sigma_mk_injective isOpenMap_sigmaMk this,
(Set.image_preimage_eq_of_subset this).symm⟩
· rintro ⟨i, t, ht, rfl⟩
exact ht.image _ continuous_sigmaMk.continuousOn | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | Sigma.isConnected_iff | null |
Sigma.isPreconnected_iff [hι : Nonempty ι] [∀ i, TopologicalSpace (X i)]
{s : Set (Σ i, X i)} : IsPreconnected s ↔ ∃ i t, IsPreconnected t ∧ s = Sigma.mk i '' t := by
refine ⟨fun hs => ?_, ?_⟩
· obtain rfl | h := s.eq_empty_or_nonempty
· exact ⟨Classical.choice hι, ∅, isPreconnected_empty, (Set.image_empty _).symm⟩
· obtain ⟨a, t, ht, rfl⟩ := Sigma.isConnected_iff.1 ⟨h, hs⟩
exact ⟨a, t, ht.isPreconnected, rfl⟩
· rintro ⟨a, t, ht, rfl⟩
exact ht.image _ continuous_sigmaMk.continuousOn | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | Sigma.isPreconnected_iff | null |
Sum.isConnected_iff [TopologicalSpace β] {s : Set (α ⊕ β)} :
IsConnected s ↔
(∃ t, IsConnected t ∧ s = Sum.inl '' t) ∨ ∃ t, IsConnected t ∧ s = Sum.inr '' t := by
refine ⟨fun hs => ?_, ?_⟩
· obtain ⟨x | x, hx⟩ := hs.nonempty
· have h : s ⊆ range Sum.inl :=
hs.isPreconnected.subset_isClopen isClopen_range_inl ⟨.inl x, hx, x, rfl⟩
refine Or.inl ⟨Sum.inl ⁻¹' s, ?_, ?_⟩
· exact hs.preimage_of_isOpenMap Sum.inl_injective isOpenMap_inl h
· exact (image_preimage_eq_of_subset h).symm
· have h : s ⊆ range Sum.inr :=
hs.isPreconnected.subset_isClopen isClopen_range_inr ⟨.inr x, hx, x, rfl⟩
refine Or.inr ⟨Sum.inr ⁻¹' s, ?_, ?_⟩
· exact hs.preimage_of_isOpenMap Sum.inr_injective isOpenMap_inr h
· exact (image_preimage_eq_of_subset h).symm
· rintro (⟨t, ht, rfl⟩ | ⟨t, ht, rfl⟩)
· exact ht.image _ continuous_inl.continuousOn
· exact ht.image _ continuous_inr.continuousOn | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | Sum.isConnected_iff | null |
Sum.isPreconnected_iff [TopologicalSpace β] {s : Set (α ⊕ β)} :
IsPreconnected s ↔
(∃ t, IsPreconnected t ∧ s = Sum.inl '' t) ∨ ∃ t, IsPreconnected t ∧ s = Sum.inr '' t := by
refine ⟨fun hs => ?_, ?_⟩
· obtain rfl | h := s.eq_empty_or_nonempty
· exact Or.inl ⟨∅, isPreconnected_empty, (Set.image_empty _).symm⟩
obtain ⟨t, ht, rfl⟩ | ⟨t, ht, rfl⟩ := Sum.isConnected_iff.1 ⟨h, hs⟩
· exact Or.inl ⟨t, ht.isPreconnected, rfl⟩
· exact Or.inr ⟨t, ht.isPreconnected, rfl⟩
· rintro (⟨t, ht, rfl⟩ | ⟨t, ht, rfl⟩)
· exact ht.image _ continuous_inl.continuousOn
· exact ht.image _ continuous_inr.continuousOn | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | Sum.isPreconnected_iff | null |
Continuous.exists_lift_sigma [ConnectedSpace α] [∀ i, TopologicalSpace (X i)]
{f : α → Σ i, X i} (hf : Continuous f) :
∃ (i : ι) (g : α → X i), Continuous g ∧ f = Sigma.mk i ∘ g := by
obtain ⟨i, hi⟩ : ∃ i, range f ⊆ range (.mk i) := by
rcases Sigma.isConnected_iff.1 (isConnected_range hf) with ⟨i, s, -, hs⟩
exact ⟨i, hs.trans_subset (image_subset_range _ _)⟩
rcases range_subset_range_iff_exists_comp.1 hi with ⟨g, rfl⟩
refine ⟨i, g, ?_, rfl⟩
rwa [← IsEmbedding.sigmaMk.continuous_iff] at hf | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | Continuous.exists_lift_sigma | A continuous map from a connected space to a disjoint union `Σ i, X i` can be lifted to one of
the components `X i`. See also `ContinuousMap.exists_lift_sigma` for a version with bundled
`ContinuousMap`s. |
nonempty_inter [PreconnectedSpace α] {s t : Set α} :
IsOpen s → IsOpen t → s ∪ t = univ → s.Nonempty → t.Nonempty → (s ∩ t).Nonempty := by
simpa only [univ_inter, univ_subset_iff] using @PreconnectedSpace.isPreconnected_univ α _ _ s t | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | nonempty_inter | null |
isClopen_iff [PreconnectedSpace α] {s : Set α} : IsClopen s ↔ s = ∅ ∨ s = univ :=
⟨fun hs =>
by_contradiction fun h =>
have h1 : s ≠ ∅ ∧ sᶜ ≠ ∅ :=
⟨mt Or.inl h,
mt (fun h2 => Or.inr <| (by rw [← compl_compl s, h2, compl_empty] : s = univ)) h⟩
let ⟨_, h2, h3⟩ :=
nonempty_inter hs.2 hs.1.isOpen_compl (union_compl_self s) (nonempty_iff_ne_empty.2 h1.1)
(nonempty_iff_ne_empty.2 h1.2)
h3 h2,
by rintro (rfl | rfl) <;> [exact isClopen_empty; exact isClopen_univ]⟩ | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | isClopen_iff | null |
IsClopen.eq_univ [PreconnectedSpace α] {s : Set α} (h' : IsClopen s) (h : s.Nonempty) :
s = univ :=
(isClopen_iff.mp h').resolve_left h.ne_empty
open Set.Notation in | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | IsClopen.eq_univ | null |
isClopen_preimage_val {X : Type*} [TopologicalSpace X] {u v : Set X}
(hu : IsOpen u) (huv : Disjoint (frontier u) v) : IsClopen (v ↓∩ u) := by
refine ⟨?_, isOpen_induced hu (f := Subtype.val)⟩
refine isClosed_induced_iff.mpr ⟨closure u, isClosed_closure, ?_⟩
apply image_val_injective
simp only [Subtype.image_preimage_coe]
rw [closure_eq_self_union_frontier, inter_union_distrib_left, inter_comm _ (frontier u),
huv.inter_eq, union_empty] | lemma | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | isClopen_preimage_val | null |
subsingleton_of_disjoint_isClopen
(h_clopen : ∀ i, IsClopen (s i)) :
Subsingleton ι := by
replace h_nonempty : ∀ i, s i ≠ ∅ := by intro i; rw [← nonempty_iff_ne_empty]; exact h_nonempty i
rw [← not_nontrivial_iff_subsingleton]
by_contra contra
obtain ⟨i, j, h_ne⟩ := contra
replace h_ne : s i ∩ s j = ∅ := by
simpa only [← bot_eq_empty, eq_bot_iff, ← inf_eq_inter, ← disjoint_iff_inf_le] using h_disj h_ne
rcases isClopen_iff.mp (h_clopen i) with hi | hi
· exact h_nonempty i hi
· rw [hi, univ_inter] at h_ne
exact h_nonempty j h_ne | lemma | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | subsingleton_of_disjoint_isClopen | In a preconnected space, any disjoint family of non-empty clopen subsets has at most one
element. |
subsingleton_of_disjoint_isOpen_iUnion_eq_univ
(h_open : ∀ i, IsOpen (s i)) (h_Union : ⋃ i, s i = univ) :
Subsingleton ι := by
refine subsingleton_of_disjoint_isClopen h_nonempty h_disj (fun i ↦ ⟨?_, h_open i⟩)
rw [← isOpen_compl_iff, compl_eq_univ_diff, ← h_Union, iUnion_diff]
refine isOpen_iUnion (fun j ↦ ?_)
rcases eq_or_ne i j with rfl | h_ne
· simp
· simpa only [(h_disj h_ne.symm).sdiff_eq_left] using h_open j | lemma | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | subsingleton_of_disjoint_isOpen_iUnion_eq_univ | In a preconnected space, any disjoint cover by non-empty open subsets has at most one
element. |
subsingleton_of_disjoint_isClosed_iUnion_eq_univ [Finite ι]
(h_closed : ∀ i, IsClosed (s i)) (h_Union : ⋃ i, s i = univ) :
Subsingleton ι := by
refine subsingleton_of_disjoint_isClopen h_nonempty h_disj (fun i ↦ ⟨h_closed i, ?_⟩)
rw [← isClosed_compl_iff, compl_eq_univ_diff, ← h_Union, iUnion_diff]
refine isClosed_iUnion_of_finite (fun j ↦ ?_)
rcases eq_or_ne i j with rfl | h_ne
· simp
· simpa only [(h_disj h_ne.symm).sdiff_eq_left] using h_closed j | lemma | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | subsingleton_of_disjoint_isClosed_iUnion_eq_univ | In a preconnected space, any finite disjoint cover by non-empty closed subsets has at most one
element. |
frontier_eq_empty_iff [PreconnectedSpace α] {s : Set α} :
frontier s = ∅ ↔ s = ∅ ∨ s = univ :=
isClopen_iff_frontier_eq_empty.symm.trans isClopen_iff | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | frontier_eq_empty_iff | null |
nonempty_frontier_iff [PreconnectedSpace α] {s : Set α} :
(frontier s).Nonempty ↔ s.Nonempty ∧ s ≠ univ := by
simp only [nonempty_iff_ne_empty, Ne, frontier_eq_empty_iff, not_or] | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | nonempty_frontier_iff | null |
PreconnectedSpace.induction₂' [PreconnectedSpace α] (P : α → α → Prop)
(h : ∀ x, ∀ᶠ y in 𝓝 x, P x y ∧ P y x) (h' : Transitive P) (x y : α) :
P x y := by
let u := {z | P x z}
have A : IsClosed u := by
apply isClosed_iff_nhds.2 (fun z hz ↦ ?_)
rcases hz _ (h z) with ⟨t, ht, h't⟩
exact h' h't ht.2
have B : IsOpen u := by
apply isOpen_iff_mem_nhds.2 (fun z hz ↦ ?_)
filter_upwards [h z] with t ht
exact h' hz ht.1
have C : u.Nonempty := ⟨x, (mem_of_mem_nhds (h x)).1⟩
have D : u = Set.univ := IsClopen.eq_univ ⟨A, B⟩ C
change y ∈ u
simp [D] | lemma | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | PreconnectedSpace.induction₂' | In a preconnected space, given a transitive relation `P`, if `P x y` and `P y x` are true
for `y` close enough to `x`, then `P x y` holds for all `x, y`. This is a version of the fact
that, if an equivalence relation has open classes, then it has a single equivalence class. |
PreconnectedSpace.induction₂ [PreconnectedSpace α] (P : α → α → Prop)
(h : ∀ x, ∀ᶠ y in 𝓝 x, P x y) (h' : Transitive P) (h'' : Symmetric P) (x y : α) :
P x y := by
refine PreconnectedSpace.induction₂' P (fun z ↦ ?_) h' x y
filter_upwards [h z] with a ha
exact ⟨ha, h'' ha⟩ | lemma | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | PreconnectedSpace.induction₂ | In a preconnected space, if a symmetric transitive relation `P x y` is true for `y` close
enough to `x`, then it holds for all `x, y`. This is a version of the fact that, if an equivalence
relation has open classes, then it has a single equivalence class. |
IsPreconnected.induction₂' {s : Set α} (hs : IsPreconnected s) (P : α → α → Prop)
(h : ∀ x ∈ s, ∀ᶠ y in 𝓝[s] x, P x y ∧ P y x)
(h' : ∀ x y z, x ∈ s → y ∈ s → z ∈ s → P x y → P y z → P x z)
{x y : α} (hx : x ∈ s) (hy : y ∈ s) : P x y := by
let Q : s → s → Prop := fun a b ↦ P a b
change Q ⟨x, hx⟩ ⟨y, hy⟩
have : PreconnectedSpace s := Subtype.preconnectedSpace hs
apply PreconnectedSpace.induction₂'
· rintro ⟨x, hx⟩
have Z := h x hx
rwa [nhdsWithin_eq_map_subtype_coe] at Z
· rintro ⟨a, ha⟩ ⟨b, hb⟩ ⟨c, hc⟩ hab hbc
exact h' a b c ha hb hc hab hbc | lemma | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | IsPreconnected.induction₂' | In a preconnected set, given a transitive relation `P`, if `P x y` and `P y x` are true
for `y` close enough to `x`, then `P x y` holds for all `x, y`. This is a version of the fact
that, if an equivalence relation has open classes, then it has a single equivalence class. |
IsPreconnected.induction₂ {s : Set α} (hs : IsPreconnected s) (P : α → α → Prop)
(h : ∀ x ∈ s, ∀ᶠ y in 𝓝[s] x, P x y)
(h' : ∀ x y z, x ∈ s → y ∈ s → z ∈ s → P x y → P y z → P x z)
(h'' : ∀ x y, x ∈ s → y ∈ s → P x y → P y x)
{x y : α} (hx : x ∈ s) (hy : y ∈ s) : P x y := by
apply hs.induction₂' P (fun z hz ↦ ?_) h' hx hy
filter_upwards [h z hz, self_mem_nhdsWithin] with a ha h'a
exact ⟨ha, h'' z a hz h'a ha⟩ | lemma | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | IsPreconnected.induction₂ | In a preconnected set, if a symmetric transitive relation `P x y` is true for `y` close
enough to `x`, then it holds for all `x, y`. This is a version of the fact that, if an equivalence
relation has open classes, then it has a single equivalence class. |
isPreconnected_iff_subset_of_disjoint {s : Set α} :
IsPreconnected s ↔
∀ u v, IsOpen u → IsOpen v → s ⊆ u ∪ v → s ∩ (u ∩ v) = ∅ → s ⊆ u ∨ s ⊆ v := by
constructor <;> intro h
· intro u v hu hv hs huv
specialize h u v hu hv hs
contrapose! huv
simp only [not_subset] at huv
rcases huv with ⟨⟨x, hxs, hxu⟩, ⟨y, hys, hyv⟩⟩
have hxv : x ∈ v := or_iff_not_imp_left.mp (hs hxs) hxu
have hyu : y ∈ u := or_iff_not_imp_right.mp (hs hys) hyv
exact h ⟨y, hys, hyu⟩ ⟨x, hxs, hxv⟩
· intro u v hu hv hs hsu hsv
by_contra H
specialize h u v hu hv hs (Set.not_nonempty_iff_eq_empty.mp H)
apply H
rcases h with h | h
· rcases hsv with ⟨x, hxs, hxv⟩
exact ⟨x, hxs, ⟨h hxs, hxv⟩⟩
· rcases hsu with ⟨x, hxs, hxu⟩
exact ⟨x, hxs, ⟨hxu, h hxs⟩⟩ | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | isPreconnected_iff_subset_of_disjoint | A set `s` is preconnected if and only if for every cover by two open sets that are disjoint on
`s`, it is contained in one of the two covering sets. |
isConnected_iff_sUnion_disjoint_open {s : Set α} :
IsConnected s ↔
∀ U : Finset (Set α), (∀ u v : Set α, u ∈ U → v ∈ U → (s ∩ (u ∩ v)).Nonempty → u = v) →
(∀ u ∈ U, IsOpen u) → (s ⊆ ⋃₀ ↑U) → ∃ u ∈ U, s ⊆ u := by
rw [IsConnected, isPreconnected_iff_subset_of_disjoint]
classical
refine ⟨fun ⟨hne, h⟩ U hU hUo hsU => ?_, fun h => ⟨?_, fun u v hu hv hs hsuv => ?_⟩⟩
· induction U using Finset.induction_on with
| empty => exact absurd (by simpa using hsU) hne.not_subset_empty
| insert u U uU IH =>
simp only [← forall_cond_comm, Finset.forall_mem_insert, Finset.exists_mem_insert,
Finset.coe_insert, sUnion_insert, implies_true, true_and] at *
refine (h _ hUo.1 (⋃₀ ↑U) (isOpen_sUnion hUo.2) hsU ?_).imp_right ?_
· refine subset_empty_iff.1 fun x ⟨hxs, hxu, v, hvU, hxv⟩ => ?_
exact ne_of_mem_of_not_mem hvU uU (hU.1 v hvU ⟨x, hxs, hxu, hxv⟩).symm
· exact IH (fun u hu => (hU.2 u hu).2) hUo.2
· simpa [subset_empty_iff, nonempty_iff_ne_empty] using h ∅
· rw [← not_nonempty_iff_eq_empty] at hsuv
have := hsuv; rw [inter_comm u] at this
simpa [*, or_imp, forall_and] using h {u, v} | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | isConnected_iff_sUnion_disjoint_open | A set `s` is connected if and only if
for every cover by a finite collection of open sets that are pairwise disjoint on `s`,
it is contained in one of the members of the collection. |
disjoint_or_subset_of_isClopen {s t : Set α} (hs : IsPreconnected s) (ht : IsClopen t) :
Disjoint s t ∨ s ⊆ t :=
(disjoint_or_nonempty_inter s t).imp_right <| hs.subset_isClopen ht | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | disjoint_or_subset_of_isClopen | Preconnected sets are either contained in or disjoint to any given clopen set. |
isPreconnected_iff_subset_of_disjoint_closed :
IsPreconnected s ↔
∀ u v, IsClosed u → IsClosed v → s ⊆ u ∪ v → s ∩ (u ∩ v) = ∅ → s ⊆ u ∨ s ⊆ v := by
constructor <;> intro h
· intro u v hu hv hs huv
rw [isPreconnected_closed_iff] at h
specialize h u v hu hv hs
contrapose! huv
simp only [not_subset] at huv
rcases huv with ⟨⟨x, hxs, hxu⟩, ⟨y, hys, hyv⟩⟩
have hxv : x ∈ v := or_iff_not_imp_left.mp (hs hxs) hxu
have hyu : y ∈ u := or_iff_not_imp_right.mp (hs hys) hyv
exact h ⟨y, hys, hyu⟩ ⟨x, hxs, hxv⟩
· rw [isPreconnected_closed_iff]
intro u v hu hv hs hsu hsv
by_contra H
specialize h u v hu hv hs (Set.not_nonempty_iff_eq_empty.mp H)
apply H
rcases h with h | h
· rcases hsv with ⟨x, hxs, hxv⟩
exact ⟨x, hxs, ⟨h hxs, hxv⟩⟩
· rcases hsu with ⟨x, hxs, hxu⟩
exact ⟨x, hxs, ⟨hxu, h hxs⟩⟩ | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | isPreconnected_iff_subset_of_disjoint_closed | A set `s` is preconnected if and only if
for every cover by two closed sets that are disjoint on `s`,
it is contained in one of the two covering sets. |
isPreconnected_iff_subset_of_fully_disjoint_closed {s : Set α} (hs : IsClosed s) :
IsPreconnected s ↔
∀ u v, IsClosed u → IsClosed v → s ⊆ u ∪ v → Disjoint u v → s ⊆ u ∨ s ⊆ v := by
refine isPreconnected_iff_subset_of_disjoint_closed.trans ⟨?_, ?_⟩ <;> intro H u v hu hv hss huv
· apply H u v hu hv hss
rw [huv.inter_eq, inter_empty]
have H1 := H (u ∩ s) (v ∩ s)
rw [subset_inter_iff, subset_inter_iff] at H1
simp only [Subset.refl, and_true] at H1
apply H1 (hu.inter hs) (hv.inter hs)
· rw [← union_inter_distrib_right]
exact subset_inter hss Subset.rfl
· rwa [disjoint_iff_inter_eq_empty, ← inter_inter_distrib_right, inter_comm] | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | isPreconnected_iff_subset_of_fully_disjoint_closed | A closed set `s` is preconnected if and only if for every cover by two closed sets that are
disjoint, it is contained in one of the two covering sets. |
IsClopen.connectedComponent_subset {x} (hs : IsClopen s) (hx : x ∈ s) :
connectedComponent x ⊆ s :=
isPreconnected_connectedComponent.subset_isClopen hs ⟨x, mem_connectedComponent, hx⟩ | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | IsClopen.connectedComponent_subset | null |
connectedComponent_subset_iInter_isClopen {x : α} :
connectedComponent x ⊆ ⋂ Z : { Z : Set α // IsClopen Z ∧ x ∈ Z }, Z :=
subset_iInter fun Z => Z.2.1.connectedComponent_subset Z.2.2 | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | connectedComponent_subset_iInter_isClopen | The connected component of a point is always a subset of the intersection of all its clopen
neighbourhoods. |
IsClopen.biUnion_connectedComponent_eq {Z : Set α} (h : IsClopen Z) :
⋃ x ∈ Z, connectedComponent x = Z :=
Subset.antisymm (iUnion₂_subset fun _ => h.connectedComponent_subset) fun _ h =>
mem_iUnion₂_of_mem h mem_connectedComponent
open Set.Notation in | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | IsClopen.biUnion_connectedComponent_eq | A clopen set is the union of its connected components. |
IsClopen.biUnion_connectedComponentIn {X : Type*} [TopologicalSpace X] {u v : Set X}
(hu : IsClopen (v ↓∩ u)) (huv₁ : u ⊆ v) :
u = ⋃ x ∈ u, connectedComponentIn v x := by
have := congr(((↑) : Set v → Set X) $(hu.biUnion_connectedComponent_eq.symm))
simp only [Subtype.image_preimage_coe, mem_preimage, iUnion_coe_set, image_val_iUnion,
inter_eq_right.mpr huv₁] at this
nth_rw 1 [this]
congr! 2 with x hx
simp only [← connectedComponentIn_eq_image]
exact le_antisymm (iUnion_subset fun _ ↦ le_rfl) <|
iUnion_subset fun hx ↦ subset_iUnion₂_of_subset (huv₁ hx) hx le_rfl
variable [TopologicalSpace β] {f : α → β} | lemma | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | IsClopen.biUnion_connectedComponentIn | If `u v : Set X` and `u ⊆ v` is clopen in `v`, then `u` is the union of the connected
components of `v` in `X` which intersect `u`. |
preimage_connectedComponent_connected
(connected_fibers : ∀ t : β, IsConnected (f ⁻¹' {t}))
(hcl : ∀ T : Set β, IsClosed T ↔ IsClosed (f ⁻¹' T)) (t : β) :
IsConnected (f ⁻¹' connectedComponent t) := by
have hf : Surjective f := Surjective.of_comp fun t : β => (connected_fibers t).1
refine ⟨Nonempty.preimage connectedComponent_nonempty hf, ?_⟩
have hT : IsClosed (f ⁻¹' connectedComponent t) :=
(hcl (connectedComponent t)).1 isClosed_connectedComponent
rw [isPreconnected_iff_subset_of_fully_disjoint_closed hT]
intro u v hu hv huv uv_disj
let T₁ := { t' ∈ connectedComponent t | f ⁻¹' {t'} ⊆ u }
let T₂ := { t' ∈ connectedComponent t | f ⁻¹' {t'} ⊆ v }
have fiber_decomp : ∀ t' ∈ connectedComponent t, f ⁻¹' {t'} ⊆ u ∨ f ⁻¹' {t'} ⊆ v := by
intro t' ht'
apply isPreconnected_iff_subset_of_disjoint_closed.1 (connected_fibers t').2 u v hu hv
· exact Subset.trans (preimage_mono (singleton_subset_iff.2 ht')) huv
rw [uv_disj.inter_eq, inter_empty]
have T₁_u : f ⁻¹' T₁ = f ⁻¹' connectedComponent t ∩ u := by
apply eq_of_subset_of_subset
· rw [← biUnion_preimage_singleton]
refine iUnion₂_subset fun t' ht' => subset_inter ?_ ht'.2
rw [hf.preimage_subset_preimage_iff, singleton_subset_iff]
exact ht'.1
rintro a ⟨hat, hau⟩
constructor
· exact mem_preimage.1 hat
refine (fiber_decomp (f a) (mem_preimage.1 hat)).resolve_right fun h => ?_
exact uv_disj.subset_compl_right hau (h rfl)
have T₂_v : f ⁻¹' T₂ = f ⁻¹' connectedComponent t ∩ v := by
apply eq_of_subset_of_subset
· rw [← biUnion_preimage_singleton]
refine iUnion₂_subset fun t' ht' => subset_inter ?_ ht'.2
rw [hf.preimage_subset_preimage_iff, singleton_subset_iff]
exact ht'.1
rintro a ⟨hat, hav⟩
constructor
· exact mem_preimage.1 hat
· refine (fiber_decomp (f a) (mem_preimage.1 hat)).resolve_left fun h => ?_
exact uv_disj.subset_compl_left hav (h rfl)
have hT₁ : IsClosed T₁ := (hcl T₁).2 (T₁_u.symm ▸ IsClosed.inter hT hu)
have hT₂ : IsClosed T₂ := (hcl T₂).2 (T₂_v.symm ▸ IsClosed.inter hT hv)
have T_decomp : connectedComponent t ⊆ T₁ ∪ T₂ := fun t' ht' => by
rw [mem_union t' T₁ T₂]
rcases fiber_decomp t' ht' with htu | htv
· left; exact ⟨ht', htu⟩
· right; exact ⟨ht', htv⟩
have T_disjoint : Disjoint T₁ T₂ := by
refine Disjoint.of_preimage hf ?_
rw [T₁_u, T₂_v, disjoint_iff_inter_eq_empty, ← inter_inter_distrib_left, uv_disj.inter_eq,
inter_empty]
rcases (isPreconnected_iff_subset_of_fully_disjoint_closed isClosed_connectedComponent).1
... | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | preimage_connectedComponent_connected | The preimage of a connected component is preconnected if the function has connected fibers
and a subset is closed iff the preimage is. |
Topology.IsQuotientMap.preimage_connectedComponent (hf : IsQuotientMap f)
(h_fibers : ∀ y : β, IsConnected (f ⁻¹' {y})) (a : α) :
f ⁻¹' connectedComponent (f a) = connectedComponent a :=
((preimage_connectedComponent_connected h_fibers (fun _ => hf.isClosed_preimage.symm)
_).subset_connectedComponent mem_connectedComponent).antisymm
(hf.continuous.mapsTo_connectedComponent a) | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | Topology.IsQuotientMap.preimage_connectedComponent | null |
Topology.IsQuotientMap.image_connectedComponent {f : α → β} (hf : IsQuotientMap f)
(h_fibers : ∀ y : β, IsConnected (f ⁻¹' {y})) (a : α) :
f '' connectedComponent a = connectedComponent (f a) := by
rw [← hf.preimage_connectedComponent h_fibers, image_preimage_eq _ hf.surjective] | lemma | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | Topology.IsQuotientMap.image_connectedComponent | null |
connectedComponentSetoid (α : Type*) [TopologicalSpace α] : Setoid α :=
⟨fun x y => connectedComponent x = connectedComponent y,
⟨fun x => by trivial, fun h1 => h1.symm, fun h1 h2 => h1.trans h2⟩⟩ | def | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | connectedComponentSetoid | The setoid of connected components of a topological space |
ConnectedComponents (α : Type u) [TopologicalSpace α] :=
Quotient (connectedComponentSetoid α) | def | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | ConnectedComponents | The quotient of a space by its connected components |
mk : α → ConnectedComponents α := Quotient.mk'' | def | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | mk | Coercion from a topological space to the set of connected components of this space. |
@[simp]
coe_eq_coe {x y : α} :
(x : ConnectedComponents α) = y ↔ connectedComponent x = connectedComponent y :=
Quotient.eq'' | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | coe_eq_coe | null |
coe_ne_coe {x y : α} :
(x : ConnectedComponents α) ≠ y ↔ connectedComponent x ≠ connectedComponent y :=
coe_eq_coe.not | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | coe_ne_coe | null |
coe_eq_coe' {x y : α} : (x : ConnectedComponents α) = y ↔ x ∈ connectedComponent y :=
coe_eq_coe.trans connectedComponent_eq_iff_mem | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | coe_eq_coe' | null |
surjective_coe : Surjective (mk : α → ConnectedComponents α) :=
Quot.mk_surjective | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | surjective_coe | null |
isQuotientMap_coe : IsQuotientMap (mk : α → ConnectedComponents α) :=
isQuotientMap_quot_mk
@[continuity] | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | isQuotientMap_coe | null |
continuous_coe : Continuous (mk : α → ConnectedComponents α) :=
isQuotientMap_coe.continuous
@[simp] | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | continuous_coe | null |
range_coe : range (mk : α → ConnectedComponents α) = univ :=
surjective_coe.range_eq | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | range_coe | null |
connectedComponents_preimage_singleton {x : α} :
(↑) ⁻¹' ({↑x} : Set (ConnectedComponents α)) = connectedComponent x := by
ext y
rw [mem_preimage, mem_singleton_iff, ConnectedComponents.coe_eq_coe'] | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | connectedComponents_preimage_singleton | The preimage of a singleton in `connectedComponents` is the connected component
of an element in the equivalence class. |
connectedComponents_preimage_image (U : Set α) :
(↑) ⁻¹' ((↑) '' U : Set (ConnectedComponents α)) = ⋃ x ∈ U, connectedComponent x := by
simp only [connectedComponents_preimage_singleton, preimage_iUnion₂, image_eq_iUnion] | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | connectedComponents_preimage_image | The preimage of the image of a set under the quotient map to `connectedComponents α`
is the union of the connected components of the elements in it. |
isPreconnected_of_forall_constant {s : Set α}
(hs : ∀ f : α → Bool, ContinuousOn f s → ∀ x ∈ s, ∀ y ∈ s, f x = f y) : IsPreconnected s := by
unfold IsPreconnected
by_contra!
rcases this with ⟨u, v, u_op, v_op, hsuv, ⟨x, x_in_s, x_in_u⟩, ⟨y, y_in_s, y_in_v⟩, H⟩
have hy : y ∉ u := fun y_in_u => eq_empty_iff_forall_notMem.mp H y ⟨y_in_s, ⟨y_in_u, y_in_v⟩⟩
have : ContinuousOn u.boolIndicator s := by
apply (continuousOn_boolIndicator_iff_isClopen _ _).mpr ⟨_, _⟩
· rw [preimage_subtype_coe_eq_compl hsuv H]
exact (v_op.preimage continuous_subtype_val).isClosed_compl
· exact u_op.preimage continuous_subtype_val
simpa [(u.mem_iff_boolIndicator _).mp x_in_u, (u.notMem_iff_boolIndicator _).mp hy] using
hs _ this x x_in_s y y_in_s | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | isPreconnected_of_forall_constant | If every map to `Bool` (a discrete two-element space), that is
continuous on a set `s`, is constant on s, then s is preconnected |
preconnectedSpace_of_forall_constant
(hs : ∀ f : α → Bool, Continuous f → ∀ x y, f x = f y) : PreconnectedSpace α :=
⟨isPreconnected_of_forall_constant fun f hf x _ y _ =>
hs f (continuousOn_univ.mp hf) x y⟩ | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | preconnectedSpace_of_forall_constant | A `PreconnectedSpace` version of `isPreconnected_of_forall_constant` |
preconnectedSpace_iff_clopen :
PreconnectedSpace α ↔ ∀ s : Set α, IsClopen s → s = ∅ ∨ s = Set.univ := by
refine ⟨fun _ _ => isClopen_iff.mp, fun h ↦ ?_⟩
refine preconnectedSpace_of_forall_constant fun f hf x y ↦ ?_
have : f ⁻¹' {false} = (f ⁻¹' {true})ᶜ := by
rw [← Set.preimage_compl, Bool.compl_singleton, Bool.not_true]
obtain (h | h) := h _ ((isClopen_discrete {true}).preimage hf) <;> simp_all | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | preconnectedSpace_iff_clopen | null |
connectedSpace_iff_clopen :
ConnectedSpace α ↔ Nonempty α ∧ ∀ s : Set α, IsClopen s → s = ∅ ∨ s = Set.univ := by
rw [connectedSpace_iff_univ, IsConnected, ← preconnectedSpace_iff_univ,
preconnectedSpace_iff_clopen, Set.nonempty_iff_univ_nonempty] | theorem | Topology | [
"Mathlib.Data.Set.Subset",
"Mathlib.Topology.Clopen",
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/Clopen.lean | connectedSpace_iff_clopen | null |
LocallyConnectedSpace (α : Type*) [TopologicalSpace α] : Prop where
/-- Open connected neighborhoods form a basis of the neighborhoods filter. -/
open_connected_basis : ∀ x, (𝓝 x).HasBasis (fun s : Set α => IsOpen s ∧ x ∈ s ∧ IsConnected s) id | class | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | LocallyConnectedSpace | A topological space is **locally connected** if each neighborhood filter admits a basis
of connected *open* sets. Note that it is equivalent to each point having a basis of connected
(not necessarily open) sets but in a non-trivial way, so we choose this definition and prove the
equivalence later in `locallyConnectedSpace_iff_connected_basis`. |
locallyConnectedSpace_iff_hasBasis_isOpen_isConnected :
LocallyConnectedSpace α ↔
∀ x, (𝓝 x).HasBasis (fun s : Set α => IsOpen s ∧ x ∈ s ∧ IsConnected s) id :=
⟨@LocallyConnectedSpace.open_connected_basis _ _, LocallyConnectedSpace.mk⟩ | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | locallyConnectedSpace_iff_hasBasis_isOpen_isConnected | null |
locallyConnectedSpace_iff_subsets_isOpen_isConnected :
LocallyConnectedSpace α ↔
∀ x, ∀ U ∈ 𝓝 x, ∃ V : Set α, V ⊆ U ∧ IsOpen V ∧ x ∈ V ∧ IsConnected V := by
simp_rw [locallyConnectedSpace_iff_hasBasis_isOpen_isConnected]
refine forall_congr' fun _ => ?_
constructor
· intro h U hU
rcases h.mem_iff.mp hU with ⟨V, hV, hVU⟩
exact ⟨V, hVU, hV⟩
· exact fun h => ⟨fun U => ⟨fun hU =>
let ⟨V, hVU, hV⟩ := h U hU
⟨V, hV, hVU⟩, fun ⟨V, ⟨hV, hxV, _⟩, hVU⟩ => mem_nhds_iff.mpr ⟨V, hVU, hV, hxV⟩⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | locallyConnectedSpace_iff_subsets_isOpen_isConnected | null |
connectedComponentIn_mem_nhds [LocallyConnectedSpace α] {F : Set α} {x : α} (h : F ∈ 𝓝 x) :
connectedComponentIn F x ∈ 𝓝 x := by
rw [(LocallyConnectedSpace.open_connected_basis x).mem_iff] at h
rcases h with ⟨s, ⟨h1s, hxs, h2s⟩, hsF⟩
exact mem_nhds_iff.mpr ⟨s, h2s.isPreconnected.subset_connectedComponentIn hxs hsF, h1s, hxs⟩ | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | connectedComponentIn_mem_nhds | null |
protected IsOpen.connectedComponentIn [LocallyConnectedSpace α] {F : Set α} {x : α}
(hF : IsOpen F) : IsOpen (connectedComponentIn F x) := by
rw [isOpen_iff_mem_nhds]
intro y hy
rw [connectedComponentIn_eq hy]
exact connectedComponentIn_mem_nhds (hF.mem_nhds <| connectedComponentIn_subset F x hy) | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | IsOpen.connectedComponentIn | null |
isOpen_connectedComponent [LocallyConnectedSpace α] {x : α} :
IsOpen (connectedComponent x) := by
rw [← connectedComponentIn_univ]
exact isOpen_univ.connectedComponentIn | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | isOpen_connectedComponent | null |
isClopen_connectedComponent [LocallyConnectedSpace α] {x : α} :
IsClopen (connectedComponent x) :=
⟨isClosed_connectedComponent, isOpen_connectedComponent⟩ | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | isClopen_connectedComponent | null |
locallyConnectedSpace_iff_connectedComponentIn_open :
LocallyConnectedSpace α ↔
∀ F : Set α, IsOpen F → ∀ x ∈ F, IsOpen (connectedComponentIn F x) := by
constructor
· intro h
exact fun F hF x _ => hF.connectedComponentIn
· intro h
rw [locallyConnectedSpace_iff_subsets_isOpen_isConnected]
refine fun x U hU =>
⟨connectedComponentIn (interior U) x,
(connectedComponentIn_subset _ _).trans interior_subset, h _ isOpen_interior x ?_,
mem_connectedComponentIn ?_, isConnected_connectedComponentIn_iff.mpr ?_⟩ <;>
exact mem_interior_iff_mem_nhds.mpr hU | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | locallyConnectedSpace_iff_connectedComponentIn_open | null |
locallyConnectedSpace_iff_connected_subsets :
LocallyConnectedSpace α ↔ ∀ (x : α), ∀ U ∈ 𝓝 x, ∃ V ∈ 𝓝 x, IsPreconnected V ∧ V ⊆ U := by
constructor
· rw [locallyConnectedSpace_iff_subsets_isOpen_isConnected]
intro h x U hxU
rcases h x U hxU with ⟨V, hVU, hV₁, hxV, hV₂⟩
exact ⟨V, hV₁.mem_nhds hxV, hV₂.isPreconnected, hVU⟩
· rw [locallyConnectedSpace_iff_connectedComponentIn_open]
refine fun h U hU x _ => isOpen_iff_mem_nhds.mpr fun y hy => ?_
rw [connectedComponentIn_eq hy]
rcases h y U (hU.mem_nhds <| (connectedComponentIn_subset _ _) hy) with ⟨V, hVy, hV, hVU⟩
exact Filter.mem_of_superset hVy (hV.subset_connectedComponentIn (mem_of_mem_nhds hVy) hVU) | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | locallyConnectedSpace_iff_connected_subsets | null |
locallyConnectedSpace_iff_connected_basis :
LocallyConnectedSpace α ↔
∀ x, (𝓝 x).HasBasis (fun s : Set α => s ∈ 𝓝 x ∧ IsPreconnected s) id := by
rw [locallyConnectedSpace_iff_connected_subsets]
exact forall_congr' fun x => Filter.hasBasis_self.symm | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | locallyConnectedSpace_iff_connected_basis | null |
locallyConnectedSpace_of_connected_bases {ι : Type*} (b : α → ι → Set α) (p : α → ι → Prop)
(hbasis : ∀ x, (𝓝 x).HasBasis (p x) (b x))
(hconnected : ∀ x i, p x i → IsPreconnected (b x i)) : LocallyConnectedSpace α := by
rw [locallyConnectedSpace_iff_connected_basis]
exact fun x =>
(hbasis x).to_hasBasis
(fun i hi => ⟨b x i, ⟨(hbasis x).mem_of_mem hi, hconnected x i hi⟩, subset_rfl⟩) fun s hs =>
⟨(hbasis x).index s hs.1, ⟨(hbasis x).property_index hs.1, (hbasis x).set_index_subset hs.1⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | locallyConnectedSpace_of_connected_bases | null |
Topology.IsOpenEmbedding.locallyConnectedSpace [LocallyConnectedSpace α] [TopologicalSpace β]
{f : β → α} (h : IsOpenEmbedding f) : LocallyConnectedSpace β := by
refine locallyConnectedSpace_of_connected_bases (fun _ s ↦ f ⁻¹' s)
(fun x s ↦ (IsOpen s ∧ f x ∈ s ∧ IsConnected s) ∧ s ⊆ range f) (fun x ↦ ?_)
(fun x s hxs ↦ hxs.1.2.2.isPreconnected.preimage_of_isOpenMap h.injective h.isOpenMap hxs.2)
rw [h.nhds_eq_comap]
exact LocallyConnectedSpace.open_connected_basis (f x) |>.restrict_subset
(h.isOpen_range.mem_nhds <| mem_range_self _) |>.comap _ | lemma | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | Topology.IsOpenEmbedding.locallyConnectedSpace | null |
IsOpen.locallyConnectedSpace [LocallyConnectedSpace α] {U : Set α} (hU : IsOpen U) :
LocallyConnectedSpace U :=
hU.isOpenEmbedding_subtypeVal.locallyConnectedSpace | theorem | Topology | [
"Mathlib.Topology.Connected.Basic"
] | Mathlib/Topology/Connected/LocallyConnected.lean | IsOpen.locallyConnectedSpace | null |
LocPathConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
/-- Each neighborhood filter has a basis of path-connected neighborhoods. -/
path_connected_basis : ∀ x : X, (𝓝 x).HasBasis (fun s : Set X => s ∈ 𝓝 x ∧ IsPathConnected s) id
export LocPathConnectedSpace (path_connected_basis) | class | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | LocPathConnectedSpace | A topological space is locally path connected, at every point, path connected
neighborhoods form a neighborhood basis. |
LocPathConnectedSpace.of_bases {p : X → ι → Prop} {s : X → ι → Set X}
(h : ∀ x, (𝓝 x).HasBasis (p x) (s x)) (h' : ∀ x i, p x i → IsPathConnected (s x i)) :
LocPathConnectedSpace X where
path_connected_basis x := by
rw [hasBasis_self]
intro t ht
rcases (h x).mem_iff.mp ht with ⟨i, hpi, hi⟩
exact ⟨s x i, (h x).mem_of_mem hpi, h' x i hpi, hi⟩
variable [LocPathConnectedSpace X] | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | LocPathConnectedSpace.of_bases | null |
protected IsOpen.pathComponentIn (hF : IsOpen F) (x : X) :
IsOpen (pathComponentIn F x) := by
rw [isOpen_iff_mem_nhds]
intro y hy
let ⟨s, hs⟩ := (path_connected_basis y).mem_iff.mp (hF.mem_nhds (pathComponentIn_subset hy))
exact mem_of_superset hs.1.1 <| pathComponentIn_congr hy ▸
hs.1.2.subset_pathComponentIn (mem_of_mem_nhds hs.1.1) hs.2 | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | IsOpen.pathComponentIn | null |
protected IsOpen.pathComponent (x : X) : IsOpen (pathComponent x) := by
rw [← pathComponentIn_univ]
exact isOpen_univ.pathComponentIn _ | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | IsOpen.pathComponent | In a locally path connected space, each path component is an open set. |
protected IsClosed.pathComponent (x : X) : IsClosed (pathComponent x) := by
rw [← isOpen_compl_iff, isOpen_iff_mem_nhds]
intro y hxy
rcases (path_connected_basis y).ex_mem with ⟨V, hVy, hVc⟩
filter_upwards [hVy] with z hz hxz
exact hxy <| hxz.trans (hVc.joinedIn _ hz _ (mem_of_mem_nhds hVy)).joined | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | IsClosed.pathComponent | In a locally path connected space, each path component is a closed set. |
protected IsClopen.pathComponent (x : X) : IsClopen (pathComponent x) :=
⟨.pathComponent x, .pathComponent x⟩ | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | IsClopen.pathComponent | In a locally path connected space, each path component is a clopen set. |
pathComponentIn_mem_nhds (hF : F ∈ 𝓝 x) : pathComponentIn F x ∈ 𝓝 x := by
let ⟨u, huF, hu, hxu⟩ := mem_nhds_iff.mp hF
exact mem_nhds_iff.mpr ⟨pathComponentIn u x, pathComponentIn_mono huF,
hu.pathComponentIn x, mem_pathComponentIn_self hxu⟩ | lemma | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | pathComponentIn_mem_nhds | null |
pathConnectedSpace_iff_connectedSpace : PathConnectedSpace X ↔ ConnectedSpace X := by
refine ⟨fun _ ↦ inferInstance, fun h ↦ ⟨inferInstance, fun x y ↦ ?_⟩⟩
rw [← mem_pathComponent_iff, (IsClopen.pathComponent _).eq_univ] <;> simp | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | pathConnectedSpace_iff_connectedSpace | null |
pathComponent_eq_connectedComponent (x : X) : pathComponent x = connectedComponent x :=
(pathComponent_subset_component x).antisymm <|
(IsClopen.pathComponent x).connectedComponent_subset (mem_pathComponent_self _) | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | pathComponent_eq_connectedComponent | null |
pathConnected_subset_basis {U : Set X} (h : IsOpen U) (hx : x ∈ U) :
(𝓝 x).HasBasis (fun s : Set X => s ∈ 𝓝 x ∧ IsPathConnected s ∧ s ⊆ U) id :=
(path_connected_basis x).hasBasis_self_subset (IsOpen.mem_nhds h hx) | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | pathConnected_subset_basis | null |
isOpen_isPathConnected_basis (x : X) :
(𝓝 x).HasBasis (fun s : Set X ↦ IsOpen s ∧ x ∈ s ∧ IsPathConnected s) id := by
refine ⟨fun s ↦ ⟨fun hs ↦ ?_, fun ⟨u, hu⟩ ↦ mem_nhds_iff.mpr ⟨u, hu.2, hu.1.1, hu.1.2.1⟩⟩⟩
have ⟨u, hus, hu, hxu⟩ := mem_nhds_iff.mp hs
exact ⟨pathComponentIn u x, ⟨hu.pathComponentIn _, ⟨mem_pathComponentIn_self hxu,
isPathConnected_pathComponentIn hxu⟩⟩, pathComponentIn_subset.trans hus⟩ | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | isOpen_isPathConnected_basis | null |
Topology.IsOpenEmbedding.locPathConnectedSpace {e : Y → X} (he : IsOpenEmbedding e) :
LocPathConnectedSpace Y :=
have (y : Y) :
(𝓝 y).HasBasis (fun s ↦ s ∈ 𝓝 (e y) ∧ IsPathConnected s ∧ s ⊆ range e) (e ⁻¹' ·) :=
he.basis_nhds <| pathConnected_subset_basis he.isOpen_range (mem_range_self _)
.of_bases this fun x s ⟨_, hs, hse⟩ ↦ by
rwa [he.isPathConnected_iff, image_preimage_eq_of_subset hse] | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | Topology.IsOpenEmbedding.locPathConnectedSpace | null |
IsOpen.locPathConnectedSpace {U : Set X} (h : IsOpen U) : LocPathConnectedSpace U :=
h.isOpenEmbedding_subtypeVal.locPathConnectedSpace | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | IsOpen.locPathConnectedSpace | null |
IsOpen.isConnected_iff_isPathConnected {U : Set X} (U_op : IsOpen U) :
IsConnected U ↔ IsPathConnected U := by
rw [isConnected_iff_connectedSpace, isPathConnected_iff_pathConnectedSpace]
haveI := U_op.locPathConnectedSpace
exact pathConnectedSpace_iff_connectedSpace.symm | theorem | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | IsOpen.isConnected_iff_isPathConnected | null |
locPathConnectedSpace_iff_isOpen_pathComponentIn {X : Type*} [TopologicalSpace X] :
LocPathConnectedSpace X ↔ ∀ (x : X) (u : Set X), IsOpen u → IsOpen (pathComponentIn u x) :=
⟨fun _ _ _ hu ↦ hu.pathComponentIn _, fun h ↦ ⟨fun x ↦ ⟨fun s ↦ by
refine ⟨fun hs ↦ ?_, fun ⟨_, ht⟩ ↦ Filter.mem_of_superset ht.1.1 ht.2⟩
let ⟨u, hu⟩ := mem_nhds_iff.mp hs
exact ⟨pathComponentIn u x, ⟨(h x u hu.2.1).mem_nhds (mem_pathComponentIn_self hu.2.2),
isPathConnected_pathComponentIn hu.2.2⟩, pathComponentIn_subset.trans hu.1⟩⟩⟩⟩ | lemma | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | locPathConnectedSpace_iff_isOpen_pathComponentIn | Locally path-connected spaces are locally connected. -/
instance : LocallyConnectedSpace X := by
refine ⟨forall_imp (fun x h ↦ ⟨fun s ↦ ?_⟩) isOpen_isPathConnected_basis⟩
refine ⟨fun hs ↦ ?_, fun ⟨u, ⟨hu, hxu, _⟩, hus⟩ ↦ mem_nhds_iff.mpr ⟨u, hus, hu, hxu⟩⟩
let ⟨u, ⟨hu, hxu, hu'⟩, hus⟩ := (h.mem_iff' s).mp hs
exact ⟨u, ⟨hu, hxu, hu'.isConnected⟩, hus⟩
/-- A space is locally path-connected iff all path components of open subsets are open. |
locPathConnectedSpace_iff_pathComponentIn_mem_nhds {X : Type*} [TopologicalSpace X] :
LocPathConnectedSpace X ↔
∀ x : X, ∀ u : Set X, IsOpen u → x ∈ u → pathComponentIn u x ∈ nhds x := by
rw [locPathConnectedSpace_iff_isOpen_pathComponentIn]
simp_rw [forall_comm (β := Set X), ← imp_forall_iff]
refine forall_congr' fun u ↦ imp_congr_right fun _ ↦ ?_
exact ⟨fun h x hxu ↦ (h x).mem_nhds (mem_pathComponentIn_self hxu),
fun h x ↦ isOpen_iff_mem_nhds.mpr fun y hy ↦
pathComponentIn_congr hy ▸ h y <| pathComponentIn_subset hy⟩ | lemma | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | locPathConnectedSpace_iff_pathComponentIn_mem_nhds | A space is locally path-connected iff all path components of open subsets are neighbourhoods. |
LocPathConnectedSpace.coinduced {Y : Type*} (f : X → Y) :
@LocPathConnectedSpace Y (.coinduced f ‹_›) := by
let _ := TopologicalSpace.coinduced f ‹_›; have hf : Continuous f := continuous_coinduced_rng
refine locPathConnectedSpace_iff_isOpen_pathComponentIn.mpr fun y u hu ↦
isOpen_coinduced.mpr <| isOpen_iff_mem_nhds.mpr fun x hx ↦ ?_
have hx' := preimage_mono pathComponentIn_subset hx
refine mem_nhds_iff.mpr ⟨pathComponentIn (f ⁻¹' u) x, ?_,
(hu.preimage hf).pathComponentIn _, mem_pathComponentIn_self hx'⟩
rw [← image_subset_iff, ← pathComponentIn_congr hx]
exact ((isPathConnected_pathComponentIn hx').image hf).subset_pathComponentIn
⟨x, mem_pathComponentIn_self hx', rfl⟩ <|
(image_mono pathComponentIn_subset).trans <| u.image_preimage_subset f | lemma | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | LocPathConnectedSpace.coinduced | Any topology coinduced by a locally path-connected topology is locally path-connected. |
Topology.IsQuotientMap.locPathConnectedSpace {f : X → Y} (h : IsQuotientMap f) :
LocPathConnectedSpace Y :=
h.2 ▸ LocPathConnectedSpace.coinduced f | lemma | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | Topology.IsQuotientMap.locPathConnectedSpace | Quotients of locally path-connected spaces are locally path-connected. |
Quot.locPathConnectedSpace {r : X → X → Prop} : LocPathConnectedSpace (Quot r) :=
isQuotientMap_quot_mk.locPathConnectedSpace | instance | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | Quot.locPathConnectedSpace | Quotients of locally path-connected spaces are locally path-connected. |
Quotient.locPathConnectedSpace {s : Setoid X} : LocPathConnectedSpace (Quotient s) :=
isQuotientMap_quotient_mk'.locPathConnectedSpace | instance | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | Quotient.locPathConnectedSpace | Quotients of locally path-connected spaces are locally path-connected. |
Sum.locPathConnectedSpace.{u} {X Y : Type u} [TopologicalSpace X] [TopologicalSpace Y]
[LocPathConnectedSpace X] [LocPathConnectedSpace Y] :
LocPathConnectedSpace (X ⊕ Y) := by
rw [locPathConnectedSpace_iff_pathComponentIn_mem_nhds]; intro x u hu hxu; rw [mem_nhds_iff]
obtain x | y := x
· refine ⟨Sum.inl '' (pathComponentIn (Sum.inl ⁻¹' u) x), ?_, ?_, ?_⟩
· apply IsPathConnected.subset_pathComponentIn
· exact (isPathConnected_pathComponentIn (by exact hxu)).image continuous_inl
· exact ⟨x, mem_pathComponentIn_self hxu, rfl⟩
· exact (image_mono pathComponentIn_subset).trans (u.image_preimage_subset _)
· exact isOpenMap_inl _ <| (hu.preimage continuous_inl).pathComponentIn _
· exact ⟨x, mem_pathComponentIn_self hxu, rfl⟩
· refine ⟨Sum.inr '' (pathComponentIn (Sum.inr ⁻¹' u) y), ?_, ?_, ?_⟩
· apply IsPathConnected.subset_pathComponentIn
· exact (isPathConnected_pathComponentIn (by exact hxu)).image continuous_inr
· exact ⟨y, mem_pathComponentIn_self hxu, rfl⟩
· exact (image_mono pathComponentIn_subset).trans (u.image_preimage_subset _)
· exact isOpenMap_inr _ <| (hu.preimage continuous_inr).pathComponentIn _
· exact ⟨y, mem_pathComponentIn_self hxu, rfl⟩ | instance | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | Sum.locPathConnectedSpace. | Disjoint unions of locally path-connected spaces are locally path-connected. |
Sigma.locPathConnectedSpace {X : ι → Type*}
[(i : ι) → TopologicalSpace (X i)] [(i : ι) → LocPathConnectedSpace (X i)] :
LocPathConnectedSpace ((i : ι) × X i) := by
rw [locPathConnectedSpace_iff_pathComponentIn_mem_nhds]; intro x u hu hxu; rw [mem_nhds_iff]
refine ⟨(Sigma.mk x.1) '' (pathComponentIn ((Sigma.mk x.1) ⁻¹' u) x.2), ?_, ?_, ?_⟩
· apply IsPathConnected.subset_pathComponentIn
· exact (isPathConnected_pathComponentIn (by exact hxu)).image continuous_sigmaMk
· exact ⟨x.2, mem_pathComponentIn_self hxu, rfl⟩
· exact (image_mono pathComponentIn_subset).trans (u.image_preimage_subset _)
· exact isOpenMap_sigmaMk _ <| (hu.preimage continuous_sigmaMk).pathComponentIn _
· exact ⟨x.2, mem_pathComponentIn_self hxu, rfl⟩ | instance | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | Sigma.locPathConnectedSpace | Disjoint unions of locally path-connected spaces are locally path-connected. |
AlexandrovDiscrete.locPathConnectedSpace [AlexandrovDiscrete X] :
LocPathConnectedSpace X := by
apply LocPathConnectedSpace.of_bases nhds_basis_nhdsKer_singleton
simp only [forall_const, IsPathConnected, mem_nhdsKer_singleton]
intro x
exists x, specializes_rfl
intro y hy
symm
apply hy.joinedIn <;> rewrite [mem_nhdsKer_singleton] <;> [assumption; rfl] | instance | Topology | [
"Mathlib.Topology.Connected.PathConnected",
"Mathlib.Topology.AlexandrovDiscrete"
] | Mathlib/Topology/Connected/LocPathConnected.lean | AlexandrovDiscrete.locPathConnectedSpace | null |
@[to_additive (attr := simps!)
/-- The path component of the identity in a locally path connected additive topological group,
as an open normal additive subgroup. It is, in fact, clopen. -/]
OpenNormalSubgroup.pathComponentOne [Group G]
[IsTopologicalGroup G] [LocPathConnectedSpace G] :
OpenNormalSubgroup G where
toSubgroup := .pathComponentOne G
isOpen' := .pathComponent 1
isNormal' := .pathComponentOne G | def | Topology | [
"Mathlib.Topology.Algebra.OpenSubgroup",
"Mathlib.Topology.Connected.LocPathConnected"
] | Mathlib/Topology/Connected/PathComponentOne.lean | OpenNormalSubgroup.pathComponentOne | The path component of the identity in a locally path connected topological group,
as an open normal subgroup. It is, in fact, clopen. |
Joined (x y : X) : Prop :=
Nonempty (Path x y)
@[refl] | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Joined | The relation "being joined by a path". This is an equivalence relation. |
Joined.refl (x : X) : Joined x x :=
⟨Path.refl x⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Joined.refl | null |
Joined.somePath (h : Joined x y) : Path x y :=
Nonempty.some h
@[symm] | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Joined.somePath | When two points are joined, choose some path from `x` to `y`. |
Joined.symm {x y : X} (h : Joined x y) : Joined y x :=
⟨h.somePath.symm⟩
@[trans] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Joined.symm | null |
Joined.trans {x y z : X} (hxy : Joined x y) (hyz : Joined y z) : Joined x z :=
⟨hxy.somePath.trans hyz.somePath⟩
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Joined.trans | null |
Joined.mul {M : Type*} [Mul M] [TopologicalSpace M] [ContinuousMul M]
{a b c d : M} (hs : Joined a b) (ht : Joined c d) : Joined (a * c) (b * d) :=
⟨hs.somePath.mul ht.somePath⟩
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Joined.mul | null |
Joined.listProd {M : Type*} [MulOneClass M] [TopologicalSpace M] [ContinuousMul M]
{l l' : List M} (h : List.Forall₂ Joined l l') :
Joined l.prod l'.prod := by
induction h with
| nil => rfl
| cons h₁ _ h₂ => exact h₁.mul h₂
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Joined.listProd | null |
Joined.inv {G : Type*} [Inv G] [TopologicalSpace G] [ContinuousInv G]
{x y : G} (h : Joined x y) : Joined x⁻¹ y⁻¹ :=
⟨h.somePath.inv⟩
variable (X) | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Joined.inv | null |
pathSetoid : Setoid X where
r := Joined
iseqv := Equivalence.mk Joined.refl Joined.symm Joined.trans | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathSetoid | The setoid corresponding the equivalence relation of being joined by a continuous path. |
ZerothHomotopy :=
Quotient (pathSetoid X) | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | ZerothHomotopy | The quotient type of points of a topological space modulo being joined by a continuous path. |
ZerothHomotopy.inhabited : Inhabited (ZerothHomotopy ℝ) :=
⟨@Quotient.mk' ℝ (pathSetoid ℝ) 0⟩
variable {X}
/-! ### Being joined by a path inside a set -/ | instance | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | ZerothHomotopy.inhabited | null |
JoinedIn (F : Set X) (x y : X) : Prop :=
∃ γ : Path x y, ∀ t, γ t ∈ F
variable {F : Set X} | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn | The relation "being joined by a path in `F`". Not quite an equivalence relation since it's not
reflexive for points that do not belong to `F`. |
JoinedIn.mem (h : JoinedIn F x y) : x ∈ F ∧ y ∈ F := by
rcases h with ⟨γ, γ_in⟩
have : γ 0 ∈ F ∧ γ 1 ∈ F := by constructor <;> apply γ_in
simpa using this | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.mem | null |
JoinedIn.source_mem (h : JoinedIn F x y) : x ∈ F :=
h.mem.1 | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.source_mem | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.