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 ⌀ |
|---|---|---|---|---|---|---|
JoinedIn.target_mem (h : JoinedIn F x y) : y ∈ F :=
h.mem.2 | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.target_mem | null |
JoinedIn.somePath (h : JoinedIn F x y) : Path x y :=
Classical.choose h | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.somePath | When `x` and `y` are joined in `F`, choose a path from `x` to `y` inside `F` |
JoinedIn.somePath_mem (h : JoinedIn F x y) (t : I) : h.somePath t ∈ F :=
Classical.choose_spec h t | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.somePath_mem | null |
JoinedIn.joined_subtype (h : JoinedIn F x y) :
Joined (⟨x, h.source_mem⟩ : F) (⟨y, h.target_mem⟩ : F) :=
⟨{ toFun := fun t => ⟨h.somePath t, h.somePath_mem t⟩
continuous_toFun := by fun_prop
source' := by simp
target' := by simp }⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.joined_subtype | If `x` and `y` are joined in the set `F`, then they are joined in the subtype `F`. |
JoinedIn.ofLine {f : ℝ → X} (hf : ContinuousOn f I) (h₀ : f 0 = x) (h₁ : f 1 = y)
(hF : f '' I ⊆ F) : JoinedIn F x y :=
⟨Path.ofLine hf h₀ h₁, fun t => hF <| Path.ofLine_mem hf h₀ h₁ t⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.ofLine | null |
JoinedIn.joined (h : JoinedIn F x y) : Joined x y :=
⟨h.somePath⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.joined | null |
joinedIn_iff_joined (x_in : x ∈ F) (y_in : y ∈ F) :
JoinedIn F x y ↔ Joined (⟨x, x_in⟩ : F) (⟨y, y_in⟩ : F) :=
⟨fun h => h.joined_subtype, fun h => ⟨h.somePath.map continuous_subtype_val, by simp⟩⟩
@[simp] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | joinedIn_iff_joined | null |
joinedIn_univ : JoinedIn univ x y ↔ Joined x y := by
simp [JoinedIn, Joined, exists_true_iff_nonempty] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | joinedIn_univ | null |
JoinedIn.mono {U V : Set X} (h : JoinedIn U x y) (hUV : U ⊆ V) : JoinedIn V x y :=
⟨h.somePath, fun t => hUV (h.somePath_mem t)⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.mono | null |
JoinedIn.refl (h : x ∈ F) : JoinedIn F x x :=
⟨Path.refl x, fun _t => h⟩
@[symm] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.refl | null |
JoinedIn.symm (h : JoinedIn F x y) : JoinedIn F y x := by
obtain ⟨hx, hy⟩ := h.mem
simp_all only [joinedIn_iff_joined]
exact h.symm | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.symm | null |
JoinedIn.trans (hxy : JoinedIn F x y) (hyz : JoinedIn F y z) : JoinedIn F x z := by
obtain ⟨hx, hy⟩ := hxy.mem
obtain ⟨hx, hy⟩ := hyz.mem
simp_all only [joinedIn_iff_joined]
exact hxy.trans hyz | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.trans | null |
Specializes.joinedIn (h : x ⤳ y) (hx : x ∈ F) (hy : y ∈ F) : JoinedIn F x y := by
refine ⟨⟨⟨Set.piecewise {1} (const I y) (const I x), ?_⟩, by simp, by simp⟩, fun t ↦ ?_⟩
· exact isClosed_singleton.continuous_piecewise_of_specializes continuous_const continuous_const
fun _ ↦ h
· simp only [Path.coe_mk_mk, piecewise]
split_ifs <;> assumption | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Specializes.joinedIn | null |
Inseparable.joinedIn (h : Inseparable x y) (hx : x ∈ F) (hy : y ∈ F) : JoinedIn F x y :=
h.specializes.joinedIn hx hy | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Inseparable.joinedIn | null |
JoinedIn.map_continuousOn (h : JoinedIn F x y) {f : X → Y} (hf : ContinuousOn f F) :
JoinedIn (f '' F) (f x) (f y) :=
let ⟨γ, hγ⟩ := h
⟨γ.map' <| hf.mono (range_subset_iff.mpr hγ), fun t ↦ mem_image_of_mem _ (hγ t)⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.map_continuousOn | null |
JoinedIn.map (h : JoinedIn F x y) {f : X → Y} (hf : Continuous f) :
JoinedIn (f '' F) (f x) (f y) :=
h.map_continuousOn hf.continuousOn | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.map | null |
Topology.IsInducing.joinedIn_image {f : X → Y} (hf : IsInducing f) (hx : x ∈ F)
(hy : y ∈ F) : JoinedIn (f '' F) (f x) (f y) ↔ JoinedIn F x y := by
refine ⟨?_, (.map · hf.continuous)⟩
rintro ⟨γ, hγ⟩
choose γ' hγ'F hγ' using hγ
have h₀ : x ⤳ γ' 0 := by rw [← hf.specializes_iff, hγ', γ.source]
have h₁ : γ' 1 ⤳ y := by rw [← hf.specializes_iff, hγ', γ.target]
have h : JoinedIn F (γ' 0) (γ' 1) := by
refine ⟨⟨⟨γ', ?_⟩, rfl, rfl⟩, hγ'F⟩
simpa only [hf.continuous_iff, comp_def, hγ'] using map_continuous γ
exact (h₀.joinedIn hx (hγ'F _)).trans <| h.trans <| h₁.joinedIn (hγ'F _) hy
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Topology.IsInducing.joinedIn_image | null |
JoinedIn.mul {M : Type*} [Mul M] [TopologicalSpace M] [ContinuousMul M]
{s t : Set M} {a b c d : M} (hs : JoinedIn s a b) (ht : JoinedIn t c d) :
JoinedIn (s * t) (a * c) (b * d) :=
⟨hs.somePath.mul ht.somePath, fun t ↦ Set.mul_mem_mul (hs.somePath_mem t) (ht.somePath_mem t)⟩
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.mul | null |
JoinedIn.inv {G : Type*} [InvolutiveInv G] [TopologicalSpace G] [ContinuousInv G]
{s : Set G} {a b : G} (hs : JoinedIn s a b) :
JoinedIn s⁻¹ a⁻¹ b⁻¹ :=
⟨hs.somePath.inv, fun t ↦ Set.inv_mem_inv.mpr (hs.somePath_mem t)⟩
/-! ### Path component -/ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | JoinedIn.inv | null |
pathComponent (x : X) :=
{ y | Joined x y } | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponent | The path component of `x` is the set of points that can be joined to `x`. |
mem_pathComponent_iff : x ∈ pathComponent y ↔ Joined y x := .rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | mem_pathComponent_iff | null |
mem_pathComponent_self (x : X) : x ∈ pathComponent x :=
Joined.refl x
@[simp] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | mem_pathComponent_self | null |
pathComponent.nonempty (x : X) : (pathComponent x).Nonempty :=
⟨x, mem_pathComponent_self x⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponent.nonempty | null |
mem_pathComponent_of_mem (h : x ∈ pathComponent y) : y ∈ pathComponent x :=
Joined.symm h | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | mem_pathComponent_of_mem | null |
pathComponent_symm : x ∈ pathComponent y ↔ y ∈ pathComponent x :=
⟨fun h => mem_pathComponent_of_mem h, fun h => mem_pathComponent_of_mem h⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponent_symm | null |
pathComponent_congr (h : x ∈ pathComponent y) : pathComponent x = pathComponent y := by
ext z
constructor
· intro h'
rw [pathComponent_symm]
exact (h.trans h').symm
· intro h'
rw [pathComponent_symm] at h' ⊢
exact h'.trans h | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponent_congr | null |
pathComponent_subset_component (x : X) : pathComponent x ⊆ connectedComponent x :=
fun y h =>
(isConnected_range h.somePath.continuous).subset_connectedComponent ⟨0, by simp⟩ ⟨1, by simp⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponent_subset_component | null |
pathComponentIn (F : Set X) (x : X) :=
{ y | JoinedIn F x y }
@[simp] | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponentIn | The path component of `x` in `F` is the set of points that can be joined to `x` in `F`. |
pathComponentIn_univ (x : X) : pathComponentIn univ x = pathComponent x := by
simp [pathComponentIn, pathComponent, JoinedIn, Joined, exists_true_iff_nonempty] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponentIn_univ | null |
Joined.mem_pathComponent (hyz : Joined y z) (hxy : y ∈ pathComponent x) :
z ∈ pathComponent x :=
hxy.trans hyz | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Joined.mem_pathComponent | null |
mem_pathComponentIn_self (h : x ∈ F) : x ∈ pathComponentIn F x :=
JoinedIn.refl h | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | mem_pathComponentIn_self | null |
pathComponentIn_subset : pathComponentIn F x ⊆ F :=
fun _ hy ↦ hy.target_mem | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponentIn_subset | null |
pathComponentIn_nonempty_iff : (pathComponentIn F x).Nonempty ↔ x ∈ F :=
⟨fun ⟨_, ⟨γ, hγ⟩⟩ ↦ γ.source ▸ hγ 0, fun hx ↦ ⟨x, mem_pathComponentIn_self hx⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponentIn_nonempty_iff | null |
pathComponentIn_congr (h : x ∈ pathComponentIn F y) :
pathComponentIn F x = pathComponentIn F y := by
ext; exact ⟨h.trans, h.symm.trans⟩
@[gcongr] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponentIn_congr | null |
pathComponentIn_mono {G : Set X} (h : F ⊆ G) :
pathComponentIn F x ⊆ pathComponentIn G x :=
fun _ ⟨γ, hγ⟩ ↦ ⟨γ, fun t ↦ h (hγ t)⟩
/-! ### Path component of the identity in a group -/ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathComponentIn_mono | null |
@[to_additive (attr := simps) /-- The path component of the identity in an additive topological
monoid, as an additive submonoid. -/]
Submonoid.pathComponentOne (M : Type*) [Monoid M] [TopologicalSpace M] [ContinuousMul M] :
Submonoid M where
carrier := pathComponent (1 : M)
mul_mem' {m₁ m₂} hm₁ hm₂ := by simpa using hm₁.mul hm₂
one_mem' := mem_pathComponent_self 1 | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Submonoid.pathComponentOne | The path component of the identity in a topological monoid, as a submonoid. |
@[to_additive (attr := simps!) /-- The path component of the identity in an additive topological
group, as an additive subgroup. -/]
Subgroup.pathComponentOne (G : Type*) [Group G] [TopologicalSpace G] [IsTopologicalGroup G] :
Subgroup G where
toSubmonoid := .pathComponentOne G
inv_mem' {g} hg := by simpa using hg.inv | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Subgroup.pathComponentOne | The path component of the identity in a topological group, as a subgroup. |
@[to_additive]
Subgroup.Normal.pathComponentOne (G : Type*) [Group G] [TopologicalSpace G]
[IsTopologicalGroup G] : (Subgroup.pathComponentOne G).Normal where
conj_mem _ := fun ⟨γ⟩ g ↦ ⟨⟨⟨(g * γ · * g⁻¹), by fun_prop⟩, by simp, by simp⟩⟩
/-! ### Path connected sets -/ | instance | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Subgroup.Normal.pathComponentOne | The path component of the identity in a topological group is normal. |
IsPathConnected (F : Set X) : Prop :=
∃ x ∈ F, ∀ ⦃y⦄, y ∈ F → JoinedIn F x y | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected | A set `F` is path connected if it contains a point that can be joined to all other in `F`. |
isPathConnected_iff_eq : IsPathConnected F ↔ ∃ x ∈ F, pathComponentIn F x = F := by
constructor <;> rintro ⟨x, x_in, h⟩ <;> use x, x_in
· ext y
exact ⟨fun hy => hy.mem.2, @h _⟩
· intro y y_in
rwa [← h] at y_in | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | isPathConnected_iff_eq | null |
IsPathConnected.joinedIn (h : IsPathConnected F) :
∀ᵉ (x ∈ F) (y ∈ F), JoinedIn F x y := fun _x x_in _y y_in =>
let ⟨_b, _b_in, hb⟩ := h
(hb x_in).symm.trans (hb y_in) | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.joinedIn | null |
isPathConnected_iff :
IsPathConnected F ↔ F.Nonempty ∧ ∀ᵉ (x ∈ F) (y ∈ F), JoinedIn F x y :=
⟨fun h =>
⟨let ⟨b, b_in, _hb⟩ := h; ⟨b, b_in⟩, h.joinedIn⟩,
fun ⟨⟨b, b_in⟩, h⟩ => ⟨b, b_in, h _ b_in⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | isPathConnected_iff | null |
IsPathConnected.image' (hF : IsPathConnected F)
{f : X → Y} (hf : ContinuousOn f F) : IsPathConnected (f '' F) := by
rcases hF with ⟨x, x_in, hx⟩
use f x, mem_image_of_mem f x_in
rintro _ ⟨y, y_in, rfl⟩
refine ⟨(hx y_in).somePath.map' ?_, fun t ↦ ⟨_, (hx y_in).somePath_mem t, rfl⟩⟩
exact hf.mono (range_subset_iff.2 (hx y_in).somePath_mem) | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.image' | If `f` is continuous on `F` and `F` is path-connected, so is `f(F)`. |
IsPathConnected.image (hF : IsPathConnected F) {f : X → Y} (hf : Continuous f) :
IsPathConnected (f '' F) :=
hF.image' hf.continuousOn
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.image | If `f` is continuous and `F` is path-connected, so is `f(F)`. |
IsPathConnected.mul {M : Type*} [Mul M] [TopologicalSpace M] [ContinuousMul M]
{s t : Set M} (hs : IsPathConnected s) (ht : IsPathConnected t) :
IsPathConnected (s * t) :=
let ⟨a, ha_mem, ha⟩ := hs; let ⟨b, hb_mem, hb⟩ := ht
⟨a * b, mul_mem_mul ha_mem hb_mem, Set.forall_mem_image2.2 fun _x hx _y hy ↦ (ha hx).mul (hb hy)⟩
@[to_additive] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.mul | null |
IsPathConnected.inv {G : Type*} [InvolutiveInv G] [TopologicalSpace G] [ContinuousInv G]
{s : Set G} (hs : IsPathConnected s) :
IsPathConnected s⁻¹ :=
let ⟨a, ha_mem, ha⟩ := hs
⟨a⁻¹, inv_mem_inv.mpr ha_mem, fun x hx ↦ by simpa using ha (mem_inv.mp hx) |>.map continuous_inv⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.inv | null |
@[simp]
Homeomorph.isPathConnected_image {s : Set X} (h : X ≃ₜ Y) :
IsPathConnected (h '' s) ↔ IsPathConnected s :=
h.isInducing.isPathConnected_iff.symm | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Homeomorph.isPathConnected_image | If `f : X → Y` is an inducing map, `f(F)` is path-connected iff `F` is. -/
nonrec theorem Topology.IsInducing.isPathConnected_iff {f : X → Y} (hf : IsInducing f) :
IsPathConnected F ↔ IsPathConnected (f '' F) := by
simp only [IsPathConnected, forall_mem_image, exists_mem_image]
refine exists_congr fun x ↦ and_congr_right fun hx ↦ forall₂_congr fun y hy ↦ ?_
rw [hf.joinedIn_image hx hy]
/-- If `h : X → Y` is a homeomorphism, `h(s)` is path-connected iff `s` is. |
@[simp]
Homeomorph.isPathConnected_preimage {s : Set Y} (h : X ≃ₜ Y) :
IsPathConnected (h ⁻¹' s) ↔ IsPathConnected s := by
rw [← Homeomorph.image_symm]; exact h.symm.isPathConnected_image | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Homeomorph.isPathConnected_preimage | If `h : X → Y` is a homeomorphism, `h⁻¹(s)` is path-connected iff `s` is. |
IsPathConnected.mem_pathComponent (h : IsPathConnected F) (x_in : x ∈ F) (y_in : y ∈ F) :
y ∈ pathComponent x :=
(h.joinedIn x x_in y y_in).joined | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.mem_pathComponent | null |
IsPathConnected.subset_pathComponent (h : IsPathConnected F) (x_in : x ∈ F) :
F ⊆ pathComponent x := fun _y y_in => h.mem_pathComponent x_in y_in | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.subset_pathComponent | null |
IsPathConnected.subset_pathComponentIn {s : Set X} (hs : IsPathConnected s)
(hxs : x ∈ s) (hsF : s ⊆ F) : s ⊆ pathComponentIn F x :=
fun y hys ↦ (hs.joinedIn x hxs y hys).mono hsF | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.subset_pathComponentIn | null |
isPathConnected_singleton (x : X) : IsPathConnected ({x} : Set X) := by
refine ⟨x, rfl, ?_⟩
rintro y rfl
exact JoinedIn.refl rfl | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | isPathConnected_singleton | null |
isPathConnected_pathComponentIn (h : x ∈ F) : IsPathConnected (pathComponentIn F x) :=
⟨x, mem_pathComponentIn_self h, fun _ ⟨γ, hγ⟩ ↦ by
refine ⟨γ, fun t ↦
⟨(γ.truncateOfLE t.2.1).cast (γ.extend_zero.symm) (γ.extend_extends' t).symm, fun t' ↦ ?_⟩⟩
dsimp [Path.truncateOfLE, Path.truncate]
exact γ.extend_extends' ⟨min (max t'.1 0) t.1, by simp [t.2.1, t.2.2]⟩ ▸ hγ _⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | isPathConnected_pathComponentIn | null |
isPathConnected_pathComponent : IsPathConnected (pathComponent x) := by
rw [← pathComponentIn_univ]
exact isPathConnected_pathComponentIn (mem_univ x) | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | isPathConnected_pathComponent | null |
IsPathConnected.union {U V : Set X} (hU : IsPathConnected U) (hV : IsPathConnected V)
(hUV : (U ∩ V).Nonempty) : IsPathConnected (U ∪ V) := by
rcases hUV with ⟨x, xU, xV⟩
use x, Or.inl xU
rintro y (yU | yV)
· exact (hU.joinedIn x xU y yU).mono subset_union_left
· exact (hV.joinedIn x xV y yV).mono subset_union_right | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.union | null |
IsPathConnected.preimage_coe {U W : Set X} (hW : IsPathConnected W) (hWU : W ⊆ U) :
IsPathConnected (((↑) : U → X) ⁻¹' W) := by
rwa [IsInducing.subtypeVal.isPathConnected_iff, Subtype.image_preimage_val, inter_eq_right.2 hWU] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.preimage_coe | If a set `W` is path-connected, then it is also path-connected when seen as a set in a smaller
ambient type `U` (when `U` contains `W`). |
IsPathConnected.exists_path_through_family {n : ℕ}
{s : Set X} (h : IsPathConnected s) (p : Fin (n + 1) → X) (hp : ∀ i, p i ∈ s) :
∃ γ : Path (p 0) (p (last n)), range γ ⊆ s ∧ ∀ i, p i ∈ range γ := by
cases p using snocCases with | _ p x => ?_
simp only [forall_fin_succ', snoc_castSucc, snoc_last, Path.cast_coe,
Path.target_mem_range, and_true] at hp ⊢
obtain ⟨hp, hx⟩ := hp
induction p using snocInduction generalizing x with
| h0 =>
simp only [snoc_zero, Path.cast_coe]
use Path.refl x
simp [hx]
| @h n p y hp₂ =>
simp only [forall_fin_succ', snoc_castSucc, snoc_last, snoc_apply_zero, Path.cast_coe] at hp ⊢
obtain ⟨hp, hy⟩ := hp
specialize hp₂ y hp hy
obtain ⟨γ₀, hγ₀s, hγ₀p⟩ := hp₂
obtain ⟨γ₁, hγ₁⟩ := h.joinedIn y hy x hx
rw [← range_subset_iff] at hγ₁
use γ₀.trans γ₁
simp only [Path.trans_range, mem_union, Path.source_mem_range, or_true, and_true,
union_subset_iff]
tauto | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.exists_path_through_family | null |
IsPathConnected.exists_path_through_family' {n : ℕ}
{s : Set X} (h : IsPathConnected s) (p : Fin (n + 1) → X) (hp : ∀ i, p i ∈ s) :
∃ (γ : Path (p 0) (p (last n))) (t : Fin (n + 1) → I), (∀ t, γ t ∈ s) ∧ ∀ i, γ (t i) = p i := by
rcases h.exists_path_through_family p hp with ⟨γ, hγ⟩
rcases hγ with ⟨h₁, h₂⟩
simp only [range, mem_setOf_eq] at h₂
rw [range_subset_iff] at h₁
choose! t ht using h₂
exact ⟨γ, t, h₁, ht⟩
/-! ### Path connected spaces -/ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.exists_path_through_family' | null |
@[mk_iff]
PathConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
/-- A path-connected space must be nonempty. -/
nonempty : Nonempty X
/-- Any two points in a path-connected space must be joined by a continuous path. -/
joined : ∀ x y : X, Joined x y | class | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | PathConnectedSpace | A topological space is path-connected if it is non-empty and every two points can be
joined by a continuous path. |
pathConnectedSpace_iff_zerothHomotopy :
PathConnectedSpace X ↔ Nonempty (ZerothHomotopy X) ∧ Subsingleton (ZerothHomotopy X) := by
letI := pathSetoid X
constructor
· intro h
refine ⟨(nonempty_quotient_iff _).mpr h.1, ⟨?_⟩⟩
rintro ⟨x⟩ ⟨y⟩
exact Quotient.sound (PathConnectedSpace.joined x y)
· unfold ZerothHomotopy
rintro ⟨h, h'⟩
exact ⟨(nonempty_quotient_iff _).mp h, fun x y => Quotient.exact <| Subsingleton.elim ⟦x⟧ ⟦y⟧⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathConnectedSpace_iff_zerothHomotopy | null |
somePath (x y : X) : Path x y :=
Nonempty.some (joined x y) | def | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | somePath | Use path-connectedness to build a path between two points. |
pathConnectedSpace_iff_univ : PathConnectedSpace X ↔ IsPathConnected (univ : Set X) := by
simp [pathConnectedSpace_iff, isPathConnected_iff, nonempty_iff_univ_nonempty] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathConnectedSpace_iff_univ | null |
isPathConnected_iff_pathConnectedSpace : IsPathConnected F ↔ PathConnectedSpace F := by
rw [pathConnectedSpace_iff_univ, IsInducing.subtypeVal.isPathConnected_iff, image_univ,
Subtype.range_val_subtype, setOf_mem_eq] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | isPathConnected_iff_pathConnectedSpace | null |
isPathConnected_univ [PathConnectedSpace X] : IsPathConnected (univ : Set X) :=
pathConnectedSpace_iff_univ.mp inferInstance | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | isPathConnected_univ | null |
isPathConnected_range [PathConnectedSpace X] {f : X → Y} (hf : Continuous f) :
IsPathConnected (range f) := by
rw [← image_univ]
exact isPathConnected_univ.image hf | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | isPathConnected_range | null |
Function.Surjective.pathConnectedSpace [PathConnectedSpace X]
{f : X → Y} (hf : Surjective f) (hf' : Continuous f) : PathConnectedSpace Y := by
rw [pathConnectedSpace_iff_univ, ← hf.range_eq]
exact isPathConnected_range hf' | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Function.Surjective.pathConnectedSpace | null |
Quotient.instPathConnectedSpace {s : Setoid X} [PathConnectedSpace X] :
PathConnectedSpace (Quotient s) :=
Quotient.mk'_surjective.pathConnectedSpace continuous_coinduced_rng | instance | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Quotient.instPathConnectedSpace | null |
Real.instPathConnectedSpace : PathConnectedSpace ℝ where
joined x y := ⟨⟨⟨fun (t : I) ↦ (1 - t) * x + t * y, by fun_prop⟩, by simp, by simp⟩⟩
nonempty := inferInstance | instance | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | Real.instPathConnectedSpace | This is a special case of `NormedSpace.instPathConnectedSpace` (and
`IsTopologicalAddGroup.pathConnectedSpace`). It exists only to simplify dependencies. |
pathConnectedSpace_iff_eq : PathConnectedSpace X ↔ ∃ x : X, pathComponent x = univ := by
simp [pathConnectedSpace_iff_univ, isPathConnected_iff_eq] | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | pathConnectedSpace_iff_eq | null |
IsPathConnected.isConnected (hF : IsPathConnected F) : IsConnected F := by
rw [isConnected_iff_connectedSpace]
rw [isPathConnected_iff_pathConnectedSpace] at hF
exact @PathConnectedSpace.connectedSpace _ _ hF | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | IsPathConnected.isConnected | A path-connected set is connected.
(See `Counterexamples.TopologistsSineCurve` for the standard counterexample showing that the
converse is false.) |
exists_path_through_family {n : ℕ} (p : Fin (n + 1) → X) :
∃ γ : Path (p 0) (p (last n)), ∀ i, p i ∈ range γ := by
have : IsPathConnected (univ : Set X) := pathConnectedSpace_iff_univ.mp (by infer_instance)
rcases this.exists_path_through_family p fun _i => True.intro with ⟨γ, -, h⟩
exact ⟨γ, h⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | exists_path_through_family | null |
exists_path_through_family' {n : ℕ} (p : Fin (n + 1) → X) :
∃ (γ : Path (p 0) (p (last n))) (t : Fin (n + 1) → I), ∀ i, γ (t i) = p i := by
have : IsPathConnected (univ : Set X) := pathConnectedSpace_iff_univ.mp (by infer_instance)
rcases this.exists_path_through_family' p fun _i => True.intro with ⟨γ, t, -, h⟩
exact ⟨γ, t, h⟩ | theorem | Topology | [
"Mathlib.Topology.Path"
] | Mathlib/Topology/Connected/PathConnected.lean | exists_path_through_family' | null |
TotallySeparatedSpace.t2Space [TotallySeparatedSpace X] : T2Space X where
t2 x y h := by
obtain ⟨u, v, h₁, h₂, h₃, h₄, _, h₅⟩ := isTotallySeparated_univ trivial trivial h
exact ⟨u, v, h₁, h₂, h₃, h₄, h₅⟩ | instance | Topology | [
"Mathlib.Topology.Separation.Hausdorff",
"Mathlib.Topology.Connected.TotallyDisconnected"
] | Mathlib/Topology/Connected/Separation.lean | TotallySeparatedSpace.t2Space | A totally separated space is T2. |
IsTotallyDisconnected (s : Set α) : Prop :=
∀ t, t ⊆ s → IsPreconnected t → t.Subsingleton | def | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | IsTotallyDisconnected | A set `s` is called totally disconnected if every subset `t ⊆ s` which is preconnected is
a subsingleton, i.e. either empty or a singleton. |
isTotallyDisconnected_empty : IsTotallyDisconnected (∅ : Set α) := fun _ ht _ _ x_in _ _ =>
(ht x_in).elim | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | isTotallyDisconnected_empty | null |
isTotallyDisconnected_singleton {x} : IsTotallyDisconnected ({x} : Set α) := fun _ ht _ =>
subsingleton_singleton.anti ht | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | isTotallyDisconnected_singleton | null |
@[mk_iff]
TotallyDisconnectedSpace (α : Type u) [TopologicalSpace α] : Prop where
/-- The universal set `Set.univ` in a totally disconnected space is totally disconnected. -/
isTotallyDisconnected_univ : IsTotallyDisconnected (univ : Set α) | class | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | TotallyDisconnectedSpace | A space is totally disconnected if all of its connected components are singletons. |
IsPreconnected.subsingleton [TotallyDisconnectedSpace α] {s : Set α}
(h : IsPreconnected s) : s.Subsingleton :=
TotallyDisconnectedSpace.isTotallyDisconnected_univ s (subset_univ s) h | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | IsPreconnected.subsingleton | null |
Pi.totallyDisconnectedSpace {α : Type*} {β : α → Type*}
[∀ a, TopologicalSpace (β a)] [∀ a, TotallyDisconnectedSpace (β a)] :
TotallyDisconnectedSpace (∀ a : α, β a) :=
⟨fun t _ h2 =>
have this : ∀ a, IsPreconnected ((fun x : ∀ a, β a => x a) '' t) := fun a =>
h2.image (fun x => x a) (continuous_apply a).continuousOn
fun x x_in y y_in => funext fun a => (this a).subsingleton ⟨x, x_in, rfl⟩ ⟨y, y_in, rfl⟩⟩ | instance | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | Pi.totallyDisconnectedSpace | null |
Prod.totallyDisconnectedSpace [TopologicalSpace β] [TotallyDisconnectedSpace α]
[TotallyDisconnectedSpace β] : TotallyDisconnectedSpace (α × β) :=
⟨fun t _ h2 =>
have H1 : IsPreconnected (Prod.fst '' t) := h2.image Prod.fst continuous_fst.continuousOn
have H2 : IsPreconnected (Prod.snd '' t) := h2.image Prod.snd continuous_snd.continuousOn
fun x hx y hy =>
Prod.ext (H1.subsingleton ⟨x, hx, rfl⟩ ⟨y, hy, rfl⟩)
(H2.subsingleton ⟨x, hx, rfl⟩ ⟨y, hy, rfl⟩)⟩ | instance | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | Prod.totallyDisconnectedSpace | null |
totallyDisconnectedSpace_iff_connectedComponent_subsingleton :
TotallyDisconnectedSpace α ↔ ∀ x : α, (connectedComponent x).Subsingleton := by
constructor
· intro h x
apply h.1
· exact subset_univ _
exact isPreconnected_connectedComponent
intro h; constructor
intro s s_sub hs
rcases eq_empty_or_nonempty s with (rfl | ⟨x, x_in⟩)
· exact subsingleton_empty
· exact (h x).anti (hs.subset_connectedComponent x_in) | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | totallyDisconnectedSpace_iff_connectedComponent_subsingleton | A space is totally disconnected iff its connected components are subsingletons. |
totallyDisconnectedSpace_iff_connectedComponent_singleton :
TotallyDisconnectedSpace α ↔ ∀ x : α, connectedComponent x = {x} := by
rw [totallyDisconnectedSpace_iff_connectedComponent_subsingleton]
refine forall_congr' fun x => ?_
rw [subsingleton_iff_singleton]
exact mem_connectedComponent
@[simp] theorem connectedComponent_eq_singleton [TotallyDisconnectedSpace α] (x : α) :
connectedComponent x = {x} :=
totallyDisconnectedSpace_iff_connectedComponent_singleton.1 ‹_› x | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | totallyDisconnectedSpace_iff_connectedComponent_singleton | A space is totally disconnected iff its connected components are singletons. |
@[simp]
Continuous.image_connectedComponent_eq_singleton {β : Type*} [TopologicalSpace β]
[TotallyDisconnectedSpace β] {f : α → β} (h : Continuous f) (a : α) :
f '' connectedComponent a = {f a} :=
(Set.subsingleton_iff_singleton <| mem_image_of_mem f mem_connectedComponent).mp
(isPreconnected_connectedComponent.image f h.continuousOn).subsingleton | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | Continuous.image_connectedComponent_eq_singleton | The image of a connected component in a totally disconnected space is a singleton. |
isTotallyDisconnected_of_totallyDisconnectedSpace [TotallyDisconnectedSpace α] (s : Set α) :
IsTotallyDisconnected s := fun t _ ht =>
TotallyDisconnectedSpace.isTotallyDisconnected_univ _ t.subset_univ ht | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | isTotallyDisconnected_of_totallyDisconnectedSpace | null |
TotallyDisconnectedSpace.eq_of_continuous [TopologicalSpace β]
[PreconnectedSpace α] [TotallyDisconnectedSpace β] (f : α → β) (hf : Continuous f)
(i j : α) : f i = f j :=
(isPreconnected_univ.image f hf.continuousOn).subsingleton ⟨i, trivial, rfl⟩ ⟨j, trivial, rfl⟩ | lemma | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | TotallyDisconnectedSpace.eq_of_continuous | null |
@[simps! symm_apply_apply]
noncomputable TotallyDisconnectedSpace.continuousMapEquivOfConnectedSpace
(X Y : Type*) [TopologicalSpace X]
[TopologicalSpace Y] [TotallyDisconnectedSpace Y] [ConnectedSpace X] :
C(X, Y) ≃ Y where
toFun f := f (Classical.arbitrary _)
invFun y := ⟨fun _ ↦ y, by continuity⟩
left_inv f := ContinuousMap.ext (TotallyDisconnectedSpace.eq_of_continuous _ f.2 _)
right_inv _ := rfl | def | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | TotallyDisconnectedSpace.continuousMapEquivOfConnectedSpace | The bijection `C(X, Y) ≃ Y` when `Y` is totally disconnected and `X` is connected. |
isTotallyDisconnected_of_image [TopologicalSpace β] {f : α → β} (hf : ContinuousOn f s)
(hf' : Injective f) (h : IsTotallyDisconnected (f '' s)) : IsTotallyDisconnected s :=
fun _t hts ht _x x_in _y y_in =>
hf' <|
h _ (image_mono hts) (ht.image f <| hf.mono hts) (mem_image_of_mem f x_in)
(mem_image_of_mem f y_in) | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | isTotallyDisconnected_of_image | null |
Topology.IsEmbedding.isTotallyDisconnected [TopologicalSpace β] {f : α → β} {s : Set α}
(hf : IsEmbedding f) (h : IsTotallyDisconnected (f '' s)) : IsTotallyDisconnected s :=
isTotallyDisconnected_of_image hf.continuous.continuousOn hf.injective h | lemma | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | Topology.IsEmbedding.isTotallyDisconnected | null |
Topology.IsEmbedding.isTotallyDisconnected_image [TopologicalSpace β] {f : α → β} {s : Set α}
(hf : IsEmbedding f) : IsTotallyDisconnected (f '' s) ↔ IsTotallyDisconnected s := by
refine ⟨hf.isTotallyDisconnected, fun hs u hus hu ↦ ?_⟩
obtain ⟨v, hvs, rfl⟩ : ∃ v, v ⊆ s ∧ f '' v = u :=
⟨f ⁻¹' u ∩ s, inter_subset_right, by rwa [image_preimage_inter, inter_eq_left]⟩
rw [hf.isInducing.isPreconnected_image] at hu
exact (hs v hvs hu).image _ | lemma | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | Topology.IsEmbedding.isTotallyDisconnected_image | null |
Topology.IsEmbedding.isTotallyDisconnected_range [TopologicalSpace β] {f : α → β}
(hf : IsEmbedding f) : IsTotallyDisconnected (range f) ↔ TotallyDisconnectedSpace α := by
rw [totallyDisconnectedSpace_iff, ← image_univ, hf.isTotallyDisconnected_image] | lemma | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | Topology.IsEmbedding.isTotallyDisconnected_range | null |
totallyDisconnectedSpace_subtype_iff {s : Set α} :
TotallyDisconnectedSpace s ↔ IsTotallyDisconnected s := by
rw [← IsEmbedding.subtypeVal.isTotallyDisconnected_range, Subtype.range_val] | lemma | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | totallyDisconnectedSpace_subtype_iff | null |
Subtype.totallyDisconnectedSpace {α : Type*} {p : α → Prop} [TopologicalSpace α]
[TotallyDisconnectedSpace α] : TotallyDisconnectedSpace (Subtype p) :=
totallyDisconnectedSpace_subtype_iff.2 (isTotallyDisconnected_of_totallyDisconnectedSpace _) | instance | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | Subtype.totallyDisconnectedSpace | null |
IsTotallySeparated (s : Set α) : Prop :=
Set.Pairwise s fun x y =>
∃ u v : Set α, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ s ⊆ u ∪ v ∧ Disjoint u v | def | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | IsTotallySeparated | A set `s` is called totally separated if any two points of this set can be separated
by two disjoint open sets covering `s`. |
isTotallySeparated_empty : IsTotallySeparated (∅ : Set α) := fun _ => False.elim | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | isTotallySeparated_empty | null |
isTotallySeparated_singleton {x} : IsTotallySeparated ({x} : Set α) := fun _ hp _ hq hpq =>
(hpq <| (eq_of_mem_singleton hp).symm ▸ (eq_of_mem_singleton hq).symm).elim | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | isTotallySeparated_singleton | null |
isTotallyDisconnected_of_isTotallySeparated {s : Set α} (H : IsTotallySeparated s) :
IsTotallyDisconnected s := by
intro t hts ht x x_in y y_in
by_contra h
obtain
⟨u : Set α, v : Set α, hu : IsOpen u, hv : IsOpen v, hxu : x ∈ u, hyv : y ∈ v, hs : s ⊆ u ∪ v,
huv⟩ :=
H (hts x_in) (hts y_in) h
refine (ht _ _ hu hv (hts.trans hs) ⟨x, x_in, hxu⟩ ⟨y, y_in, hyv⟩).ne_empty ?_
rw [huv.inter_eq, inter_empty]
alias IsTotallySeparated.isTotallyDisconnected := isTotallyDisconnected_of_isTotallySeparated | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | isTotallyDisconnected_of_isTotallySeparated | null |
@[mk_iff] TotallySeparatedSpace (α : Type u) [TopologicalSpace α] : Prop where
/-- The universal set `Set.univ` in a totally separated space is totally separated. -/
isTotallySeparated_univ : IsTotallySeparated (univ : Set α) | class | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | TotallySeparatedSpace | A space is totally separated if any two points can be separated by two disjoint open sets
covering the whole space. |
totallySeparatedSpace_iff_exists_isClopen {α : Type*} [TopologicalSpace α] :
TotallySeparatedSpace α ↔ Pairwise (∃ U : Set α, IsClopen U ∧ · ∈ U ∧ · ∈ Uᶜ) := by
simp only [totallySeparatedSpace_iff, IsTotallySeparated, Set.Pairwise, mem_univ, true_implies]
refine forall₃_congr fun x y _ ↦
⟨fun ⟨U, V, hU, hV, Ux, Vy, f, disj⟩ ↦ ?_, fun ⟨U, hU, Ux, Ucy⟩ ↦ ?_⟩
· exact ⟨U, isClopen_of_disjoint_cover_open f hU hV disj,
Ux, fun Uy ↦ Set.disjoint_iff.mp disj ⟨Uy, Vy⟩⟩
· exact ⟨U, Uᶜ, hU.2, hU.compl.2, Ux, Ucy, (Set.union_compl_self U).ge, disjoint_compl_right⟩ | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | totallySeparatedSpace_iff_exists_isClopen | null |
exists_isClopen_of_totally_separated {α : Type*} [TopologicalSpace α]
[TotallySeparatedSpace α] : Pairwise (∃ U : Set α, IsClopen U ∧ · ∈ U ∧ · ∈ Uᶜ) :=
totallySeparatedSpace_iff_exists_isClopen.mp ‹_› | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | exists_isClopen_of_totally_separated | null |
@[deprecated totallySeparatedSpace_iff_exists_isClopen (since := "2025-04-03")]
isTotallyDisconnected_of_isClopen_set {X : Type*} [TopologicalSpace X]
(hX : Pairwise (∃ (U : Set X), IsClopen U ∧ · ∈ U ∧ · ∉ U)) :
IsTotallyDisconnected (Set.univ : Set X) :=
(totallySeparatedSpace_iff X).mp (totallySeparatedSpace_iff_exists_isClopen.mpr hX)
|>.isTotallyDisconnected | theorem | Topology | [
"Mathlib.Topology.Connected.Clopen"
] | Mathlib/Topology/Connected/TotallyDisconnected.lean | isTotallyDisconnected_of_isClopen_set | 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. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.