# Documentation

Mathlib.Topology.Connected.PathConnected

# Path connectedness #

## Main definitions #

In the file the unit interval [0, 1] in ℝ is denoted by I, and X is a topological space.

• Path (x y : X) is the type of paths from x to y, i.e., continuous maps from I to X mapping 0 to x and 1 to y.
• Path.map is the image of a path under a continuous map.
• Joined (x y : X) means there is a path between x and y.
• Joined.somePath (h : Joined x y) selects some path between two points x and y.
• pathComponent (x : X) is the set of points joined to x.
• PathConnectedSpace X is a predicate class asserting that X is non-empty and every two points of X are joined.

Then there are corresponding relative notions for F : Set X.

• JoinedIn F (x y : X) means there is a path γ joining x to y with values in F.
• JoinedIn.somePath (h : JoinedIn F x y) selects a path from x to y inside F.
• pathComponentIn F (x : X) is the set of points joined to x in F.
• IsPathConnected F asserts that F is non-empty and every two points of F are joined in F.
• LocPathConnectedSpace X is a predicate class asserting that X is locally path-connected: each point has a basis of path-connected neighborhoods (we do not ask these to be open).

## Main theorems

• Joined and JoinedIn F are transitive relations.

One can link the absolute and relative version in two directions, using (univ : Set X) or the subtype ↥F.

• pathConnectedSpace_iff_univ : PathConnectedSpace X ↔ IsPathConnected (univ : Set X)
• isPathConnected_iff_pathConnectedSpace : IsPathConnected F ↔ PathConnectedSpace ↥F

For locally path connected spaces, we have

• pathConnectedSpace_iff_connectedSpace : PathConnectedSpace X ↔ ConnectedSpace X
• IsOpen.isConnected_iff_isPathConnected (U_op : IsOpen U) : IsPathConnected U ↔ IsConnected U

## Implementation notes #

By default, all paths have I as their source and X as their target, but there is an operation Set.IccExtend that will extend any continuous map γ : I → X into a continuous map IccExtend zero_le_one γ : ℝ → X that is constant before 0 and after 1.

This is used to define Path.extend that turns γ : Path x y into a continuous map γ.extend : ℝ → X whose restriction to I is the original γ, and is equal to x on (-∞, 0] and to y on [1, +∞).

### Paths #

structure Path {X : Type u_1} [] (x : X) (y : X) extends :
Type u_1

Continuous path connecting two points x and y in a topological space

Instances For
instance Path.continuousMapClass {X : Type u_1} [] {x : X} {y : X} :
Equations
theorem Path.ext {X : Type u_1} [] {x : X} {y : X} {γ₁ : Path x y} {γ₂ : Path x y} :
γ₁ = γ₂γ₁ = γ₂
@[simp]
theorem Path.coe_mk_mk {X : Type u_1} [] {x : X} {y : X} (f : X) (h₁ : ) (h₂ : f 0 = x) (h₃ : f 1 = y) :
{ toContinuousMap := , source' := h₂, target' := h₃ } = f
theorem Path.continuous {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
@[simp]
theorem Path.source {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
γ 0 = x
@[simp]
theorem Path.target {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
γ 1 = y
def Path.simps.apply {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
X

See Note [custom simps projection]. We need to specify this projection explicitly in this case, because it is a composition of multiple projections.

Equations
Instances For
@[simp]
theorem Path.coe_toContinuousMap {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
γ.toContinuousMap = γ
@[simp]
theorem Path.coe_mk {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
γ = γ
instance Path.hasUncurryPath {X : Type u_4} {α : Type u_5} [] {x : αX} {y : αX} :
Function.HasUncurry ((a : α) → Path (x a) (y a)) () X

Any function φ : Π (a : α), Path (x a) (y a) can be seen as a function α × I → X.

Equations
• Path.hasUncurryPath = { uncurry := fun (φ : (a : α) → Path (x a) (y a)) (p : ) => (φ p.1) p.2 }
@[simp]
theorem Path.refl_apply {X : Type u_1} [] (x : X) (_t : ) :
() _t = x
def Path.refl {X : Type u_1} [] (x : X) :
Path x x

The constant path from a point to itself

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem Path.refl_range {X : Type u_1} [] {a : X} :
Set.range () = {a}
@[simp]
theorem Path.symm_apply {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
∀ (a : ), () a =
def Path.symm {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
Path y x

The reverse of a path from x to y, as a path from y to x

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem Path.symm_symm {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
= γ
theorem Path.symm_bijective {X : Type u_1} [] {x : X} {y : X} :
@[simp]
theorem Path.refl_symm {X : Type u_1} [] {a : X} :
=
@[simp]
theorem Path.symm_range {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) :
Set.range () =

#### Space of paths #

instance Path.topologicalSpace {X : Type u_1} [] {x : X} {y : X} :

The following instance defines the topology on the path space to be induced from the compact-open topology on the space C(I,X) of continuous maps from I to X.

Equations
theorem Path.continuous_eval {X : Type u_1} [] {x : X} {y : X} :
Continuous fun (p : Path x y × ) => p.1 p.2
theorem Continuous.path_eval {X : Type u_1} [] {x : X} {y : X} {Y : Type u_4} [] {f : YPath x y} {g : Y} (hf : ) (hg : ) :
Continuous fun (y_1 : Y) => (f y_1) (g y_1)
theorem Path.continuous_uncurry_iff {X : Type u_1} [] {x : X} {y : X} {Y : Type u_4} [] {g : YPath x y} :
def Path.extend {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
X

A continuous map extending a path to ℝ, constant before 0 and after 1.

Equations
Instances For
theorem Continuous.path_extend {X : Type u_1} {Y : Type u_2} [] [] {x : X} {y : X} {γ : YPath x y} {f : Y} (hγ : ) (hf : ) :
Continuous fun (t : Y) => Path.extend (γ t) (f t)

See Note [continuity lemma statement].

theorem Path.continuous_extend {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :

A useful special case of Continuous.path_extend.

theorem Filter.Tendsto.path_extend {X : Type u_1} {Y : Type u_2} [] [] {l : YX} {r : YX} {y : Y} {l₁ : } {l₂ : } {γ : (y : Y) → Path (l y) (r y)} (hγ : Filter.Tendsto (γ) (nhds y ×ˢ Filter.map (Set.projIcc 0 1 (_ : 0 1)) l₁) l₂) :
Filter.Tendsto (fun (x : Y) => Path.extend (γ x)) (nhds y ×ˢ l₁) l₂
theorem ContinuousAt.path_extend {X : Type u_1} {Y : Type u_2} [] [] {g : Y} {l : YX} {r : YX} (γ : (y : Y) → Path (l y) (r y)) {y : Y} (hγ : ContinuousAt (γ) (y, Set.projIcc 0 1 (_ : 0 1) (g y))) (hg : ) :
ContinuousAt (fun (i : Y) => Path.extend (γ i) (g i)) y
@[simp]
theorem Path.extend_extends {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) {t : } (ht : t Set.Icc 0 1) :
= γ { val := t, property := ht }
theorem Path.extend_zero {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
= x
theorem Path.extend_one {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
= y
@[simp]
theorem Path.extend_extends' {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) (t : (Set.Icc 0 1)) :
Path.extend γ t = γ t
@[simp]
theorem Path.extend_range {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) :
=
theorem Path.extend_of_le_zero {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) {t : } (ht : t 0) :
= a
theorem Path.extend_of_one_le {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) {t : } (ht : 1 t) :
= b
@[simp]
theorem Path.refl_extend {X : Type u_1} [] {a : X} :
= fun (x : ) => a
def Path.ofLine {X : Type u_1} [] {x : X} {y : X} {f : X} (hf : ) (h₀ : f 0 = x) (h₁ : f 1 = y) :
Path x y

The path obtained from a map defined on ℝ by restriction to the unit interval.

Equations
Instances For
theorem Path.ofLine_mem {X : Type u_1} [] {x : X} {y : X} {f : X} (hf : ) (h₀ : f 0 = x) (h₁ : f 1 = y) (t : ) :
(Path.ofLine hf h₀ h₁) t
def Path.trans {X : Type u_1} [] {x : X} {y : X} {z : X} (γ : Path x y) (γ' : Path y z) :
Path x z

Concatenation of two paths from x to y and from y to z, putting the first path on [0, 1/2] and the second one on [1/2, 1].

Equations
• One or more equations did not get rendered due to their size.
Instances For
theorem Path.trans_apply {X : Type u_1} [] {x : X} {y : X} {z : X} (γ : Path x y) (γ' : Path y z) (t : ) :
(Path.trans γ γ') t = if h : t 1 / 2 then γ { val := 2 * t, property := (_ : 2 * t unitInterval) } else γ' { val := 2 * t - 1, property := (_ : 2 * t - 1 unitInterval) }
@[simp]
theorem Path.trans_symm {X : Type u_1} [] {x : X} {y : X} {z : X} (γ : Path x y) (γ' : Path y z) :
@[simp]
theorem Path.refl_trans_refl {X : Type u_1} [] {a : X} :
Path.trans () () =
theorem Path.trans_range {X : Type u_1} [] {a : X} {b : X} {c : X} (γ₁ : Path a b) (γ₂ : Path b c) :
Set.range (Path.trans γ₁ γ₂) = Set.range γ₁ Set.range γ₂
def Path.map' {X : Type u_1} {Y : Type u_2} [] [] {x : X} {y : X} (γ : Path x y) {f : XY} (h : ContinuousOn f ()) :
Path (f x) (f y)

Image of a path from x to y by a map which is continuous on the path.

Equations
• = { toContinuousMap := ContinuousMap.mk (f γ), source' := (_ : f (γ 0) = f x), target' := (_ : f (γ 1) = f y) }
Instances For
def Path.map {X : Type u_1} {Y : Type u_2} [] [] {x : X} {y : X} (γ : Path x y) {f : XY} (h : ) :
Path (f x) (f y)

Image of a path from x to y by a continuous map

Equations
Instances For
@[simp]
theorem Path.map_coe {X : Type u_1} {Y : Type u_2} [] [] {x : X} {y : X} (γ : Path x y) {f : XY} (h : ) :
(Path.map γ h) = f γ
@[simp]
theorem Path.map_symm {X : Type u_1} {Y : Type u_2} [] [] {x : X} {y : X} (γ : Path x y) {f : XY} (h : ) :
@[simp]
theorem Path.map_trans {X : Type u_1} {Y : Type u_2} [] [] {x : X} {y : X} {z : X} (γ : Path x y) (γ' : Path y z) {f : XY} (h : ) :
Path.map (Path.trans γ γ') h = Path.trans (Path.map γ h) (Path.map γ' h)
@[simp]
theorem Path.map_id {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
Path.map γ (_ : ) = γ
@[simp]
theorem Path.map_map {X : Type u_1} {Y : Type u_2} [] [] {x : X} {y : X} (γ : Path x y) {Z : Type u_4} [] {f : XY} (hf : ) {g : YZ} (hg : ) :
Path.map (Path.map γ hf) hg = Path.map γ (_ : Continuous (g f))
def Path.cast {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) {x' : X} {y' : X} (hx : x' = x) (hy : y' = y) :
Path x' y'

Casting a path from x to y to a path from x' to y' when x' = x and y' = y

Equations
• Path.cast γ hx hy = { toContinuousMap := , source' := (_ : γ 0 = x'), target' := (_ : γ 1 = y') }
Instances For
@[simp]
theorem Path.symm_cast {X : Type u_1} [] {a₁ : X} {a₂ : X} {b₁ : X} {b₂ : X} (γ : Path a₂ b₂) (ha : a₁ = a₂) (hb : b₁ = b₂) :
Path.symm (Path.cast γ ha hb) = Path.cast () hb ha
@[simp]
theorem Path.trans_cast {X : Type u_1} [] {a₁ : X} {a₂ : X} {b₁ : X} {b₂ : X} {c₁ : X} {c₂ : X} (γ : Path a₂ b₂) (γ' : Path b₂ c₂) (ha : a₁ = a₂) (hb : b₁ = b₂) (hc : c₁ = c₂) :
Path.trans (Path.cast γ ha hb) (Path.cast γ' hb hc) = Path.cast (Path.trans γ γ') ha hc
@[simp]
theorem Path.cast_coe {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) {x' : X} {y' : X} (hx : x' = x) (hy : y' = y) :
(Path.cast γ hx hy) = γ
theorem Path.symm_continuous_family {X : Type u_1} [] {ι : Type u_4} [] {a : ιX} {b : ιX} (γ : (t : ι) → Path (a t) (b t)) (h : ) :
Continuous fun (t : ι) => Path.symm (γ t)
theorem Path.continuous_symm {X : Type u_1} [] {x : X} {y : X} :
Continuous Path.symm
theorem Path.continuous_uncurry_extend_of_continuous_family {X : Type u_1} [] {ι : Type u_4} [] {a : ιX} {b : ιX} (γ : (t : ι) → Path (a t) (b t)) (h : ) :
Continuous fun (t : ι) => Path.extend (γ t)
theorem Path.trans_continuous_family {X : Type u_1} [] {ι : Type u_4} [] {a : ιX} {b : ιX} {c : ιX} (γ₁ : (t : ι) → Path (a t) (b t)) (h₁ : ) (γ₂ : (t : ι) → Path (b t) (c t)) (h₂ : ) :
Continuous fun (t : ι) => Path.trans (γ₁ t) (γ₂ t)
theorem Continuous.path_trans {X : Type u_1} {Y : Type u_2} [] [] {x : X} {y : X} {z : X} {f : YPath x y} {g : YPath y z} :
Continuous fun (t : Y) => Path.trans (f t) (g t)
theorem Path.continuous_trans {X : Type u_1} [] {x : X} {y : X} {z : X} :
Continuous fun (ρ : Path x y × Path y z) => Path.trans ρ.1 ρ.2

#### Product of paths #

def Path.prod {X : Type u_1} {Y : Type u_2} [] [] {a₁ : X} {a₂ : X} {b₁ : Y} {b₂ : Y} (γ₁ : Path a₁ a₂) (γ₂ : Path b₁ b₂) :
Path (a₁, b₁) (a₂, b₂)

Given a path in X and a path in Y, we can take their pointwise product to get a path in X × Y.

Equations
• Path.prod γ₁ γ₂ = { toContinuousMap := ContinuousMap.prodMk γ₁.toContinuousMap γ₂.toContinuousMap, source' := (_ : (γ₁ 0, γ₂ 0) = (a₁, b₁)), target' := (_ : (γ₁ 1, γ₂ 1) = (a₂, b₂)) }
Instances For
@[simp]
theorem Path.prod_coe {X : Type u_1} {Y : Type u_2} [] [] {a₁ : X} {a₂ : X} {b₁ : Y} {b₂ : Y} (γ₁ : Path a₁ a₂) (γ₂ : Path b₁ b₂) :
(Path.prod γ₁ γ₂) = fun (t : ) => (γ₁ t, γ₂ t)
theorem Path.trans_prod_eq_prod_trans {X : Type u_1} {Y : Type u_2} [] [] {a₁ : X} {a₂ : X} {a₃ : X} {b₁ : Y} {b₂ : Y} {b₃ : Y} (γ₁ : Path a₁ a₂) (δ₁ : Path a₂ a₃) (γ₂ : Path b₁ b₂) (δ₂ : Path b₂ b₃) :
Path.trans (Path.prod γ₁ γ₂) (Path.prod δ₁ δ₂) = Path.prod (Path.trans γ₁ δ₁) (Path.trans γ₂ δ₂)

Path composition commutes with products

def Path.pi {ι : Type u_3} {χ : ιType u_4} [(i : ι) → TopologicalSpace (χ i)] {as : (i : ι) → χ i} {bs : (i : ι) → χ i} (γ : (i : ι) → Path (as i) (bs i)) :
Path as bs

Given a family of paths, one in each Xᵢ, we take their pointwise product to get a path in Π i, Xᵢ.

Equations
• = { toContinuousMap := ContinuousMap.pi fun (i : ι) => (γ i).toContinuousMap, source' := (_ : (fun (x : ι) => (γ x) 0) = as), target' := (_ : (fun (x : ι) => (γ x) 1) = bs) }
Instances For
@[simp]
theorem Path.pi_coe {ι : Type u_3} {χ : ιType u_4} [(i : ι) → TopologicalSpace (χ i)] {as : (i : ι) → χ i} {bs : (i : ι) → χ i} (γ : (i : ι) → Path (as i) (bs i)) :
() = fun (t : ) (i : ι) => (γ i) t
theorem Path.trans_pi_eq_pi_trans {ι : Type u_3} {χ : ιType u_4} [(i : ι) → TopologicalSpace (χ i)] {as : (i : ι) → χ i} {bs : (i : ι) → χ i} {cs : (i : ι) → χ i} (γ₀ : (i : ι) → Path (as i) (bs i)) (γ₁ : (i : ι) → Path (bs i) (cs i)) :
Path.trans (Path.pi γ₀) (Path.pi γ₁) = Path.pi fun (i : ι) => Path.trans (γ₀ i) (γ₁ i)

Path composition commutes with products

#### Pointwise multiplication/addition of two paths in a topological (additive) group #

def Path.add {X : Type u_1} [] [Add X] [] {a₁ : X} {b₁ : X} {a₂ : X} {b₂ : X} (γ₁ : Path a₁ b₁) (γ₂ : Path a₂ b₂) :
Path (a₁ + a₂) (b₁ + b₂)

Equations
Instances For
def Path.mul {X : Type u_1} [] [Mul X] [] {a₁ : X} {b₁ : X} {a₂ : X} {b₂ : X} (γ₁ : Path a₁ b₁) (γ₂ : Path a₂ b₂) :
Path (a₁ * a₂) (b₁ * b₂)

Pointwise multiplication of paths in a topological group. The additive version is probably more useful.

Equations
Instances For
theorem Path.add_apply {X : Type u_1} [] [Add X] [] {a₁ : X} {b₁ : X} {a₂ : X} {b₂ : X} (γ₁ : Path a₁ b₁) (γ₂ : Path a₂ b₂) (t : ) :
(Path.add γ₁ γ₂) t = γ₁ t + γ₂ t
theorem Path.mul_apply {X : Type u_1} [] [Mul X] [] {a₁ : X} {b₁ : X} {a₂ : X} {b₂ : X} (γ₁ : Path a₁ b₁) (γ₂ : Path a₂ b₂) (t : ) :
(Path.mul γ₁ γ₂) t = γ₁ t * γ₂ t

#### Truncating a path #

def Path.truncate {X : Type u_4} [] {a : X} {b : X} (γ : Path a b) (t₀ : ) (t₁ : ) :
Path (Path.extend γ (min t₀ t₁)) (Path.extend γ t₁)

γ.truncate t₀ t₁ is the path which follows the path γ on the time interval [t₀, t₁] and stays still otherwise.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def Path.truncateOfLE {X : Type u_4} [] {a : X} {b : X} (γ : Path a b) {t₀ : } {t₁ : } (h : t₀ t₁) :
Path (Path.extend γ t₀) (Path.extend γ t₁)

γ.truncateOfLE t₀ t₁ h, where h : t₀ ≤ t₁ is γ.truncate t₀ t₁ casted as a path from γ.extend t₀ to γ.extend t₁.

Equations
Instances For
theorem Path.truncate_range {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) {t₀ : } {t₁ : } :
Set.range (Path.truncate γ t₀ t₁)
theorem Path.truncate_continuous_family {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) :
Continuous fun (x : ) => (Path.truncate γ x.1 x.2.1) x.2.2

For a path γ, γ.truncate gives a "continuous family of paths", by which we mean the uncurried function which maps (t₀, t₁, s) to γ.truncate t₀ t₁ s is continuous.

theorem Path.truncate_const_continuous_family {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) (t : ) :
@[simp]
theorem Path.truncate_self {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) (t : ) :
= Path.cast (Path.refl ()) (_ : Path.extend γ (min t t) = ) (_ : = )
@[simp]
theorem Path.truncate_zero_zero {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) :
= Path.cast () (_ : Path.extend γ (min 0 0) = a) (_ : = a)
@[simp]
theorem Path.truncate_one_one {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) :
= Path.cast () (_ : Path.extend γ (min 1 1) = b) (_ : = b)
@[simp]
theorem Path.truncate_zero_one {X : Type u_1} [] {a : X} {b : X} (γ : Path a b) :
= Path.cast γ (_ : Path.extend γ (min 0 1) = a) (_ : = b)

#### Reparametrising a path #

def Path.reparam {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) (f : ) (hfcont : ) (hf₀ : f 0 = 0) (hf₁ : f 1 = 1) :
Path x y

Given a path γ and a function f : I → I where f 0 = 0 and f 1 = 1, γ.reparam f is the path defined by γ ∘ f.

Equations
Instances For
@[simp]
theorem Path.coe_reparam {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) {f : } (hfcont : ) (hf₀ : f 0 = 0) (hf₁ : f 1 = 1) :
(Path.reparam γ f hfcont hf₀ hf₁) = γ f
@[simp]
theorem Path.reparam_id {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) :
Path.reparam γ id (_ : ) (_ : id 0 = id 0) (_ : id 1 = id 1) = γ
theorem Path.range_reparam {X : Type u_1} [] {x : X} {y : X} (γ : Path x y) {f : } (hfcont : ) (hf₀ : f 0 = 0) (hf₁ : f 1 = 1) :
Set.range (Path.reparam γ f hfcont hf₀ hf₁) =
theorem Path.refl_reparam {X : Type u_1} [] {x : X} {f : } (hfcont : ) (hf₀ : f 0 = 0) (hf₁ : f 1 = 1) :
Path.reparam () f hfcont hf₀ hf₁ =

### Being joined by a path #

def Joined {X : Type u_1} [] (x : X) (y : X) :

The relation "being joined by a path". This is an equivalence relation.

Equations
Instances For
theorem Joined.refl {X : Type u_1} [] (x : X) :
Joined x x
def Joined.somePath {X : Type u_1} [] {x : X} {y : X} (h : Joined x y) :
Path x y

When two points are joined, choose some path from x to y.

Equations
Instances For
theorem Joined.symm {X : Type u_1} [] {x : X} {y : X} (h : Joined x y) :
Joined y x
theorem Joined.trans {X : Type u_1} [] {x : X} {y : X} {z : X} (hxy : Joined x y) (hyz : Joined y z) :
Joined x z
def pathSetoid (X : Type u_1) [] :

The setoid corresponding the equivalence relation of being joined by a continuous path.

Equations
Instances For
def ZerothHomotopy (X : Type u_1) [] :
Type u_1

The quotient type of points of a topological space modulo being joined by a continuous path.

Equations
Instances For

### Being joined by a path inside a set #

def JoinedIn {X : Type u_1} [] (F : Set X) (x : X) (y : X) :

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.

Equations
Instances For
theorem JoinedIn.mem {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : JoinedIn F x y) :
x F y F
theorem JoinedIn.source_mem {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : JoinedIn F x y) :
x F
theorem JoinedIn.target_mem {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : JoinedIn F x y) :
y F
def JoinedIn.somePath {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : JoinedIn F x y) :
Path x y

When x and y are joined in F, choose a path from x to y inside F

Equations
Instances For
theorem JoinedIn.somePath_mem {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : JoinedIn F x y) (t : ) :
t F
theorem JoinedIn.joined_subtype {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : JoinedIn F x y) :
Joined { val := x, property := (_ : x F) } { val := y, property := (_ : y F) }

If x and y are joined in the set F, then they are joined in the subtype F.

theorem JoinedIn.ofLine {X : Type u_1} [] {x : X} {y : X} {F : Set X} {f : X} (hf : ) (h₀ : f 0 = x) (h₁ : f 1 = y) (hF : F) :
JoinedIn F x y
theorem JoinedIn.joined {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : JoinedIn F x y) :
Joined x y
theorem joinedIn_iff_joined {X : Type u_1} [] {x : X} {y : X} {F : Set X} (x_in : x F) (y_in : y F) :
JoinedIn F x y Joined { val := x, property := x_in } { val := y, property := y_in }
@[simp]
theorem joinedIn_univ {X : Type u_1} [] {x : X} {y : X} :
JoinedIn Set.univ x y Joined x y
theorem JoinedIn.mono {X : Type u_1} [] {x : X} {y : X} {U : Set X} {V : Set X} (h : JoinedIn U x y) (hUV : U V) :
JoinedIn V x y
theorem JoinedIn.refl {X : Type u_1} [] {x : X} {F : Set X} (h : x F) :
JoinedIn F x x
theorem JoinedIn.symm {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : JoinedIn F x y) :
JoinedIn F y x
theorem JoinedIn.trans {X : Type u_1} [] {x : X} {y : X} {z : X} {F : Set X} (hxy : JoinedIn F x y) (hyz : JoinedIn F y z) :
JoinedIn F x z
theorem Specializes.joinedIn {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : x y) (hx : x F) (hy : y F) :
JoinedIn F x y
theorem Inseparable.joinedIn {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : ) (hx : x F) (hy : y F) :
JoinedIn F x y

### Path component #

def pathComponent {X : Type u_1} [] (x : X) :
Set X

The path component of x is the set of points that can be joined to x.

Equations
Instances For
@[simp]
theorem mem_pathComponent_self {X : Type u_1} [] (x : X) :
@[simp]
theorem pathComponent.nonempty {X : Type u_1} [] (x : X) :
theorem mem_pathComponent_of_mem {X : Type u_1} [] {x : X} {y : X} (h : ) :
theorem pathComponent_symm {X : Type u_1} [] {x : X} {y : X} :
theorem pathComponent_congr {X : Type u_1} [] {x : X} {y : X} (h : ) :
theorem pathComponent_subset_component {X : Type u_1} [] (x : X) :
def pathComponentIn {X : Type u_1} [] (x : X) (F : Set X) :
Set X

The path component of x in F is the set of points that can be joined to x in F.

Equations
Instances For
@[simp]
theorem pathComponentIn_univ {X : Type u_1} [] (x : X) :
pathComponentIn x Set.univ =
theorem Joined.mem_pathComponent {X : Type u_1} [] {x : X} {y : X} {z : X} (hyz : Joined y z) (hxy : ) :

### Path connected sets #

def IsPathConnected {X : Type u_1} [] (F : Set X) :

A set F is path connected if it contains a point that can be joined to all other in F.

Equations
Instances For
theorem isPathConnected_iff_eq {X : Type u_1} [] {F : Set X} :
∃ x ∈ F, = F
theorem IsPathConnected.joinedIn {X : Type u_1} [] {F : Set X} (h : ) (x : X) :
x FyF, JoinedIn F x y
theorem isPathConnected_iff {X : Type u_1} [] {F : Set X} :
xF, yF, JoinedIn F x y
theorem IsPathConnected.image' {X : Type u_1} {Y : Type u_2} [] [] {F : Set X} (hF : ) {f : XY} (hf : ) :

If f is continuous on F and F is path-connected, so is f(F).

theorem IsPathConnected.image {X : Type u_1} {Y : Type u_2} [] [] {F : Set X} (hF : ) {f : XY} (hf : ) :

If f is continuous and F is path-connected, so is f(F).

theorem Inducing.isPathConnected_iff {X : Type u_1} {Y : Type u_2} [] [] {F : Set X} {f : XY} (hf : ) :

If f : X → Y is a Inducing, f(F) is path-connected iff F is.

@[simp]
theorem Homeomorph.isPathConnected_image {X : Type u_1} {Y : Type u_2} [] [] {s : Set X} (h : X ≃ₜ Y) :

If h : X → Y is a homeomorphism, h(s) is path-connected iff s is.

@[simp]
theorem Homeomorph.isPathConnected_preimage {X : Type u_1} {Y : Type u_2} [] [] {s : Set Y} (h : X ≃ₜ Y) :

If h : X → Y is a homeomorphism, h⁻¹(s) is path-connected iff s is.

theorem IsPathConnected.mem_pathComponent {X : Type u_1} [] {x : X} {y : X} {F : Set X} (h : ) (x_in : x F) (y_in : y F) :
theorem IsPathConnected.subset_pathComponent {X : Type u_1} [] {x : X} {F : Set X} (h : ) (x_in : x F) :
theorem isPathConnected_singleton {X : Type u_1} [] (x : X) :
theorem IsPathConnected.union {X : Type u_1} [] {U : Set X} {V : Set X} (hU : ) (hV : ) (hUV : Set.Nonempty (U V)) :
theorem IsPathConnected.preimage_coe {X : Type u_1} [] {U : Set X} {W : Set X} (hW : ) (hWU : W U) :
IsPathConnected (Subtype.val ⁻¹' W)

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).

theorem IsPathConnected.exists_path_through_family {X : Type u_1} [] {n : } {s : Set X} (h : ) (p : Fin (n + 1)X) (hp : ∀ (i : Fin (n + 1)), p i s) :
∃ (γ : Path (p 0) (p n)), s ∀ (i : Fin (n + 1)), p i
theorem IsPathConnected.exists_path_through_family' {X : Type u_1} [] {n : } {s : Set X} (h : ) (p : Fin (n + 1)X) (hp : ∀ (i : Fin (n + 1)), p i s) :
∃ (γ : Path (p 0) (p n)) (t : Fin (n + 1)), (∀ (t : ), γ t s) ∀ (i : Fin (n + 1)), γ (t i) = p i

### Path connected spaces #

class PathConnectedSpace (X : Type u_4) [] :

A topological space is path-connected if it is non-empty and every two points can be joined by a continuous path.

• nonempty :

A path-connected space must be nonempty.

• joined : ∀ (x y : X), Joined x y

Any two points in a path-connected space must be joined by a continuous path.

Instances
def PathConnectedSpace.somePath {X : Type u_1} [] (x : X) (y : X) :
Path x y

Use path-connectedness to build a path between two points.

Equations
Instances For
theorem isPathConnected_univ {X : Type u_1} [] :
theorem isPathConnected_range {X : Type u_1} {Y : Type u_2} [] [] {f : XY} (hf : ) :
theorem Function.Surjective.pathConnectedSpace {X : Type u_1} {Y : Type u_2} [] [] {f : XY} (hf : ) (hf' : ) :
instance Quotient.instPathConnectedSpace {X : Type u_1} [] {s : } :
Equations
• (_ : ) = (_ : )

This is a special case of NormedSpace.instPathConnectedSpace (and TopologicalAddGroup.pathConnectedSpace). It exists only to simplify dependencies.

Equations
theorem pathConnectedSpace_iff_eq {X : Type u_1} [] :
∃ (x : X), = Set.univ
instance PathConnectedSpace.connectedSpace {X : Type u_1} [] :
Equations
• (_ : ) = (_ : )
theorem IsPathConnected.isConnected {X : Type u_1} [] {F : Set X} (hF : ) :
theorem PathConnectedSpace.exists_path_through_family {X : Type u_1} [] {n : } (p : Fin (n + 1)X) :
∃ (γ : Path (p 0) (p n)), ∀ (i : Fin (n + 1)), p i
theorem PathConnectedSpace.exists_path_through_family' {X : Type u_1} [] {n : } (p : Fin (n + 1)X) :
∃ (γ : Path (p 0) (p n)) (t : Fin (n + 1)), ∀ (i : Fin (n + 1)), γ (t i) = p i

### Locally path connected spaces #

class LocPathConnectedSpace (X : Type u_4) [] :

A topological space is locally path connected, at every point, path connected neighborhoods form a neighborhood basis.

• path_connected_basis : ∀ (x : X), Filter.HasBasis (nhds x) (fun (s : Set X) => s nhds x ) id

Each neighborhood filter has a basis of path-connected neighborhoods.

Instances
theorem locPathConnected_of_bases {X : Type u_1} [] {ι : Type u_3} {p : ιProp} {s : XιSet X} (h : ∀ (x : X), Filter.HasBasis (nhds x) p (s x)) (h' : ∀ (x : X) (i : ι), p iIsPathConnected (s x i)) :
theorem pathConnected_subset_basis {X : Type u_1} [] {x : X} {U : Set X} (h : ) (hx : x U) :
Filter.HasBasis (nhds x) (fun (s : Set X) => s nhds x s U) id
theorem locPathConnected_of_isOpen {X : Type u_1} [] {U : Set X} (h : ) :
theorem IsOpen.isConnected_iff_isPathConnected {X : Type u_1} [] {U : Set X} (U_op : ) :