mathlib documentation

topology.homotopy.path

Homotopy between paths #

In this file, we define a homotopy between two paths. In addition, we define a relation homotopic on paths, and prove that it is an equivalence relation.

Definitions #

def path.homotopy {X : Type u} [topological_space X] {x₀ x₁ : X} (p₀ p₁ : path x₀ x₁) :
Type u

The type of homotopies between two paths.

@[protected, instance]
noncomputable def path.homotopy.has_coe_to_fun {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} :
has_coe_to_fun (p₀.homotopy p₁) (λ (_x : p₀.homotopy p₁), unit_interval × unit_interval → X)
Equations
theorem path.homotopy.coe_fn_injective {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} :
@[simp]
theorem path.homotopy.source {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} (F : p₀.homotopy p₁) (t : unit_interval) :
F (t, 0) = x₀
@[simp]
theorem path.homotopy.target {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} (F : p₀.homotopy p₁) (t : unit_interval) :
F (t, 1) = x₁
noncomputable def path.homotopy.eval {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} (F : p₀.homotopy p₁) (t : unit_interval) :
path x₀ x₁

Evaluating a path homotopy at an intermediate point, giving us a path.

Equations
@[simp]
theorem path.homotopy.eval_zero {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} (F : p₀.homotopy p₁) :
F.eval 0 = p₀
@[simp]
theorem path.homotopy.eval_one {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} (F : p₀.homotopy p₁) :
F.eval 1 = p₁
@[simp]
theorem path.homotopy.refl_apply {X : Type u} [topological_space X] {x₀ x₁ : X} (p : path x₀ x₁) (x : unit_interval × unit_interval) :
noncomputable def path.homotopy.refl {X : Type u} [topological_space X] {x₀ x₁ : X} (p : path x₀ x₁) :

Given a path p, we can define a homotopy p p by F (t, x) = p x

Equations
noncomputable def path.homotopy.symm {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} (F : p₀.homotopy p₁) :
p₁.homotopy p₀

Given a homotopy p₀ p₁, we can define a homotopy p₁ p₀ by reversing the homotopy.

Equations
@[simp]
theorem path.homotopy.symm_apply {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} (F : p₀.homotopy p₁) (x : unit_interval × unit_interval) :
@[simp]
theorem path.homotopy.symm_to_homotopy {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} (F : p₀.homotopy p₁) :
@[simp]
theorem path.homotopy.symm_symm {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ : path x₀ x₁} (F : p₀.homotopy p₁) :
F.symm.symm = F
noncomputable def path.homotopy.trans {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ p₂ : path x₀ x₁} (F : p₀.homotopy p₁) (G : p₁.homotopy p₂) :
p₀.homotopy p₂

Given homotopy p₀ p₁ and homotopy p₁ p₂, we can define a homotopy p₀ p₂ by putting the first homotopy on [0, 1/2] and the second on [1/2, 1].

Equations
theorem path.homotopy.trans_apply {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ p₂ : path x₀ x₁} (F : p₀.homotopy p₁) (G : p₁.homotopy p₂) (x : unit_interval × unit_interval) :
(F.trans G) x = dite ((x.fst) 1 / 2) (λ (h : (x.fst) 1 / 2), F (2 * (x.fst), _⟩, x.snd)) (λ (h : ¬(x.fst) 1 / 2), G (2 * (x.fst) - 1, _⟩, x.snd))
theorem path.homotopy.symm_trans {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ p₂ : path x₀ x₁} (F : p₀.homotopy p₁) (G : p₁.homotopy p₂) :
noncomputable def path.homotopy.cast {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ q₀ q₁ : path x₀ x₁} (F : p₀.homotopy p₁) (h₀ : p₀ = q₀) (h₁ : p₁ = q₁) :
q₀.homotopy q₁

Casting a homotopy p₀ p₁ to a homotopy q₀ q₁ where p₀ = q₀ and p₁ = q₁.

Equations
@[simp]
theorem path.homotopy.cast_apply {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ q₀ q₁ : path x₀ x₁} (F : p₀.homotopy p₁) (h₀ : p₀ = q₀) (h₁ : p₁ = q₁) (ᾰ : unit_interval × unit_interval) :
(F.cast h₀ h₁) = F ᾰ
@[simp]
theorem path.homotopy.cast_to_homotopy {X : Type u} [topological_space X] {x₀ x₁ : X} {p₀ p₁ q₀ q₁ : path x₀ x₁} (F : p₀.homotopy p₁) (h₀ : p₀ = q₀) (h₁ : p₁ = q₁) :
(F.cast h₀ h₁).to_homotopy = F.to_homotopy.cast _ _
noncomputable def path.homotopy.hcomp {X : Type u} [topological_space X] {x₀ x₁ x₂ : X} {p₀ q₀ : path x₀ x₁} {p₁ q₁ : path x₁ x₂} (F : p₀.homotopy q₀) (G : p₁.homotopy q₁) :
(p₀.trans p₁).homotopy (q₀.trans q₁)

Suppose p₀ and q₀ are paths from x₀ to x₁, p₁ and q₁ are paths from x₁ to x₂. Furthermore, suppose F : homotopy p₀ q₀ and G : homotopy p₁ q₁. Then we can define a homotopy from p₀.trans p₁ to q₀.trans q₁.

Equations
theorem path.homotopy.hcomp_apply {X : Type u} [topological_space X] {x₀ x₁ x₂ : X} {p₀ q₀ : path x₀ x₁} {p₁ q₁ : path x₁ x₂} (F : p₀.homotopy q₀) (G : p₁.homotopy q₁) (x : unit_interval × unit_interval) :
(F.hcomp G) x = dite ((x.snd) 1 / 2) (λ (h : (x.snd) 1 / 2), (F.eval x.fst) 2 * (x.snd), _⟩) (λ (h : ¬(x.snd) 1 / 2), (G.eval x.fst) 2 * (x.snd) - 1, _⟩)
theorem path.homotopy.hcomp_half {X : Type u} [topological_space X] {x₀ x₁ x₂ : X} {p₀ q₀ : path x₀ x₁} {p₁ q₁ : path x₁ x₂} (F : p₀.homotopy q₀) (G : p₁.homotopy q₁) (t : unit_interval) :
(F.hcomp G) (t, 1 / 2, _⟩) = x₁
noncomputable def path.homotopy.reparam {X : Type u} [topological_space X] {x₀ x₁ : X} (p : path x₀ x₁) (f : unit_intervalunit_interval) (hf : continuous f) (hf₀ : f 0 = 0) (hf₁ : f 1 = 1) :
p.homotopy (p.reparam f hf hf₀ hf₁)

Suppose p is a path, then we have a homotopy from p to p.reparam f by the convexity of I.

Equations
noncomputable def path.homotopy.symm₂ {X : Type u} [topological_space X] {x₀ x₁ : X} {p q : path x₀ x₁} (F : p.homotopy q) :

Suppose F : homotopy p q. Then we have a homotopy p.symm q.symm by reversing the second argument.

Equations
@[simp]
theorem path.homotopy.symm₂_apply {X : Type u} [topological_space X] {x₀ x₁ : X} {p q : path x₀ x₁} (F : p.homotopy q) (x : unit_interval × unit_interval) :
@[simp]
theorem path.homotopy.symm₂_to_homotopy_apply {X : Type u} [topological_space X] {x₀ x₁ : X} {p q : path x₀ x₁} (F : p.homotopy q) (x : unit_interval × unit_interval) :
@[simp]
theorem path.homotopy.map_apply {X : Type u} {Y : Type v} [topological_space X] [topological_space Y] {x₀ x₁ : X} {p q : path x₀ x₁} (F : p.homotopy q) (f : C(X, Y)) (ᾰ : unit_interval × unit_interval) :
(F.map f) = (f F)
@[simp]
theorem path.homotopy.map_to_homotopy_apply {X : Type u} {Y : Type v} [topological_space X] [topological_space Y] {x₀ x₁ : X} {p q : path x₀ x₁} (F : p.homotopy q) (f : C(X, Y)) (ᾰ : unit_interval × unit_interval) :
((F.map f).to_homotopy) = (f F)
noncomputable def path.homotopy.map {X : Type u} {Y : Type v} [topological_space X] [topological_space Y] {x₀ x₁ : X} {p q : path x₀ x₁} (F : p.homotopy q) (f : C(X, Y)) :
(p.map _).homotopy (q.map _)

Given F : homotopy p q, and f : C(X, Y), we can define a homotopy from p.map f.continuous to q.map f.continuous.

Equations
def path.homotopic {X : Type u} [topological_space X] {x₀ x₁ : X} (p₀ p₁ : path x₀ x₁) :
Prop

Two paths p₀ and p₁ are path.homotopic if there exists a homotopy between them.

Equations
theorem path.homotopic.refl {X : Type u} [topological_space X] {x₀ x₁ : X} (p : path x₀ x₁) :
theorem path.homotopic.symm {X : Type u} [topological_space X] {x₀ x₁ : X} ⦃p₀ p₁ : path x₀ x₁⦄ (h : p₀.homotopic p₁) :
p₁.homotopic p₀
theorem path.homotopic.trans {X : Type u} [topological_space X] {x₀ x₁ : X} ⦃p₀ p₁ p₂ : path x₀ x₁⦄ (h₀ : p₀.homotopic p₁) (h₁ : p₁.homotopic p₂) :
p₀.homotopic p₂
theorem path.homotopic.equivalence {X : Type u} [topological_space X] {x₀ x₁ : X} :
theorem path.homotopic.map {X : Type u} {Y : Type v} [topological_space X] [topological_space Y] {x₀ x₁ : X} {p q : path x₀ x₁} (h : p.homotopic q) (f : C(X, Y)) :
(p.map _).homotopic (q.map _)
theorem path.homotopic.hcomp {X : Type u} [topological_space X] {x₀ x₁ x₂ : X} {p₀ p₁ : path x₀ x₁} {q₀ q₁ : path x₁ x₂} (hp : p₀.homotopic p₁) (hq : q₀.homotopic q₁) :
(p₀.trans q₀).homotopic (p₁.trans q₁)
@[protected]
def path.homotopic.setoid {X : Type u} [topological_space X] (x₀ x₁ : X) :
setoid (path x₀ x₁)

The setoid on paths defined by the equivalence relation path.homotopic. That is, two paths are equivalent if there is a homotopy between them.

Equations
@[protected]
def path.homotopic.quotient {X : Type u} [topological_space X] (x₀ x₁ : X) :
Type u

The quotient on path x₀ x₁ by the equivalence relation path.homotopic.

Equations