# Documentation

Mathlib.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 #

• Path.Homotopy p₀ p₁ is the type of homotopies between paths p₀ and p₁
• Path.Homotopy.refl p is the constant homotopy between p and itself
• Path.Homotopy.symm F is the Path.Homotopy p₁ p₀ defined by reversing the homotopy
• Path.Homotopy.trans F G, where F : Path.Homotopy p₀ p₁, G : Path.Homotopy p₁ p₂ is the Path.Homotopy p₀ p₂ defined by putting the first homotopy on [0, 1/2] and the second on [1/2, 1]
• Path.Homotopy.hcomp F G, where F : Path.Homotopy p₀ q₀ and G : Path.Homotopy p₁ q₁ is a Path.Homotopy (p₀.trans p₁) (q₀.trans q₁)
• Path.Homotopic p₀ p₁ is the relation saying that there is a homotopy between p₀ and p₁
• Path.Homotopic.setoid x₀ x₁ is the setoid on Paths from Path.Homotopic
• Path.Homotopic.Quotient x₀ x₁ is the quotient type from Path x₀ x₀ by Path.Homotopic.setoid
@[inline, reducible]
abbrev Path.Homotopy {X : Type u} [] {x₀ : X} {x₁ : X} (p₀ : Path x₀ x₁) (p₁ : Path x₀ x₁) :

The type of homotopies between two paths.

Instances For
theorem Path.Homotopy.coeFn_injective {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} :
Function.Injective FunLike.coe
@[simp]
theorem Path.Homotopy.source {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (t : ) :
F (t, 0) = x₀
@[simp]
theorem Path.Homotopy.target {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (t : ) :
F (t, 1) = x₁
def Path.Homotopy.eval {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (t : ) :
Path x₀ x₁

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

Instances For
@[simp]
theorem Path.Homotopy.eval_zero {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) :
= p₀
@[simp]
theorem Path.Homotopy.eval_one {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) :
= p₁
@[simp]
theorem Path.Homotopy.refl_toFun {X : Type u} [] {x₀ : X} {x₁ : X} (p : Path x₀ x₁) (x : ) :
↑() x = p x.snd
@[simp]
theorem Path.Homotopy.refl_apply {X : Type u} [] {x₀ : X} {x₁ : X} (p : Path x₀ x₁) (x : ) :
↑() x = p x.snd
def Path.Homotopy.refl {X : Type u} [] {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.

Instances For
@[simp]
theorem Path.Homotopy.symm_apply {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (x : ) :
↑() x = F (unitInterval.symm x.fst, x.snd)
@[simp]
theorem Path.Homotopy.symm_toFun {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (x : ) :
↑() x = F (unitInterval.symm x.fst, x.snd)
def Path.Homotopy.symm {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) :
Path.Homotopy p₁ p₀

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

Instances For
@[simp]
theorem Path.Homotopy.symm_symm {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) :
def Path.Homotopy.trans {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} {p₂ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (G : Path.Homotopy p₁ p₂) :
Path.Homotopy p₀ 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].

Instances For
theorem Path.Homotopy.trans_apply {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} {p₂ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (G : Path.Homotopy p₁ p₂) (x : ) :
↑() x = if h : x.fst 1 / 2 then F ({ val := 2 * x.fst, property := (_ : 2 * x.fst unitInterval) }, x.snd) else G ({ val := 2 * x.fst - 1, property := (_ : 2 * x.fst - 1 unitInterval) }, x.snd)
theorem Path.Homotopy.symm_trans {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} {p₂ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (G : Path.Homotopy p₁ p₂) :
@[simp]
theorem Path.Homotopy.cast_toFun {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} {q₀ : Path x₀ x₁} {q₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (h₀ : p₀ = q₀) (h₁ : p₁ = q₁) (a : ) :
↑(Path.Homotopy.cast F h₀ h₁) a = F a
@[simp]
theorem Path.Homotopy.cast_apply {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} {q₀ : Path x₀ x₁} {q₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (h₀ : p₀ = q₀) (h₁ : p₁ = q₁) (a : ) :
↑(Path.Homotopy.cast F h₀ h₁) a = F a
def Path.Homotopy.cast {X : Type u} [] {x₀ : X} {x₁ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} {q₀ : Path x₀ x₁} {q₁ : Path x₀ x₁} (F : Path.Homotopy p₀ p₁) (h₀ : p₀ = q₀) (h₁ : p₁ = q₁) :
Path.Homotopy q₀ q₁

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

Instances For
def Path.Homotopy.hcomp {X : Type u} [] {x₀ : X} {x₁ : X} {x₂ : X} {p₀ : Path x₀ x₁} {q₀ : Path x₀ x₁} {p₁ : Path x₁ x₂} {q₁ : Path x₁ x₂} (F : Path.Homotopy p₀ q₀) (G : Path.Homotopy p₁ q₁) :
Path.Homotopy (Path.trans p₀ p₁) (Path.trans q₀ 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₁.

Instances For
theorem Path.Homotopy.hcomp_apply {X : Type u} [] {x₀ : X} {x₁ : X} {x₂ : X} {p₀ : Path x₀ x₁} {q₀ : Path x₀ x₁} {p₁ : Path x₁ x₂} {q₁ : Path x₁ x₂} (F : Path.Homotopy p₀ q₀) (G : Path.Homotopy p₁ q₁) (x : ) :
↑() x = if h : x.snd 1 / 2 then ↑(Path.Homotopy.eval F x.fst) { val := 2 * x.snd, property := (_ : 2 * x.snd unitInterval) } else ↑(Path.Homotopy.eval G x.fst) { val := 2 * x.snd - 1, property := (_ : 2 * x.snd - 1 unitInterval) }
theorem Path.Homotopy.hcomp_half {X : Type u} [] {x₀ : X} {x₁ : X} {x₂ : X} {p₀ : Path x₀ x₁} {q₀ : Path x₀ x₁} {p₁ : Path x₁ x₂} {q₁ : Path x₁ x₂} (F : Path.Homotopy p₀ q₀) (G : Path.Homotopy p₁ q₁) (t : ) :
↑() (t, { val := 1 / 2, property := (_ : 0 1 / 2 1 / 2 1) }) = x₁
def Path.Homotopy.reparam {X : Type u} [] {x₀ : X} {x₁ : X} (p : Path x₀ x₁) (f : ) (hf : ) (hf₀ : f 0 = 0) (hf₁ : f 1 = 1) :
Path.Homotopy p (Path.reparam p 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.

Instances For
@[simp]
theorem Path.Homotopy.symm₂_apply {X : Type u} [] {x₀ : X} {x₁ : X} {p : Path x₀ x₁} {q : Path x₀ x₁} (F : ) (x : ) :
↑() x = F (x.fst, unitInterval.symm x.snd)
@[simp]
theorem Path.Homotopy.symm₂_toFun {X : Type u} [] {x₀ : X} {x₁ : X} {p : Path x₀ x₁} {q : Path x₀ x₁} (F : ) (x : ) :
↑() x = F (x.fst, unitInterval.symm x.snd)
def Path.Homotopy.symm₂ {X : Type u} [] {x₀ : X} {x₁ : X} {p : Path x₀ x₁} {q : Path x₀ x₁} (F : ) :

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

Instances For
@[simp]
theorem Path.Homotopy.map_apply {X : Type u} {Y : Type v} [] [] {x₀ : X} {x₁ : X} {p : Path x₀ x₁} {q : Path x₀ x₁} (F : ) (f : C(X, Y)) :
∀ (a : ), ↑() a = (f F) a
@[simp]
theorem Path.Homotopy.map_toFun {X : Type u} {Y : Type v} [] [] {x₀ : X} {x₁ : X} {p : Path x₀ x₁} {q : Path x₀ x₁} (F : ) (f : C(X, Y)) :
∀ (a : ), ↑() a = (f F) a
def Path.Homotopy.map {X : Type u} {Y : Type v} [] [] {x₀ : X} {x₁ : X} {p : Path x₀ x₁} {q : Path x₀ x₁} (F : ) (f : C(X, Y)) :
Path.Homotopy (Path.map p (_ : )) (Path.map q (_ : ))

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.

Instances For
def Path.Homotopic {X : Type u} [] {x₀ : X} {x₁ : X} (p₀ : Path x₀ x₁) (p₁ : Path x₀ x₁) :

Two paths p₀ and p₁ are Path.Homotopic if there exists a Homotopy between them.

Instances For
theorem Path.Homotopic.refl {X : Type u} [] {x₀ : X} {x₁ : X} (p : Path x₀ x₁) :
theorem Path.Homotopic.symm {X : Type u} [] {x₀ : X} {x₁ : X} ⦃p₀ : Path x₀ x₁ ⦃p₁ : Path x₀ x₁ (h : Path.Homotopic p₀ p₁) :
Path.Homotopic p₁ p₀
theorem Path.Homotopic.trans {X : Type u} [] {x₀ : X} {x₁ : X} ⦃p₀ : Path x₀ x₁ ⦃p₁ : Path x₀ x₁ ⦃p₂ : Path x₀ x₁ (h₀ : Path.Homotopic p₀ p₁) (h₁ : Path.Homotopic p₁ p₂) :
Path.Homotopic p₀ p₂
theorem Path.Homotopic.equivalence {X : Type u} [] {x₀ : X} {x₁ : X} :
Equivalence Path.Homotopic
theorem Path.Homotopic.map {X : Type u} {Y : Type v} [] [] {x₀ : X} {x₁ : X} {p : Path x₀ x₁} {q : Path x₀ x₁} (h : ) (f : C(X, Y)) :
Path.Homotopic (Path.map p (_ : )) (Path.map q (_ : ))
theorem Path.Homotopic.hcomp {X : Type u} [] {x₀ : X} {x₁ : X} {x₂ : X} {p₀ : Path x₀ x₁} {p₁ : Path x₀ x₁} {q₀ : Path x₁ x₂} {q₁ : Path x₁ x₂} (hp : Path.Homotopic p₀ p₁) (hq : Path.Homotopic q₀ q₁) :
Path.Homotopic (Path.trans p₀ q₀) (Path.trans p₁ q₁)
def Path.Homotopic.setoid {X : Type u} [] (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.

Instances For
def Path.Homotopic.Quotient {X : Type u} [] (x₀ : X) (x₁ : X) :

The quotient on Path x₀ x₁ by the equivalence relation Path.Homotopic.

Instances For
def Path.Homotopic.Quotient.comp {X : Type u} [] {x₀ : X} {x₁ : X} {x₂ : X} (P₀ : ) (P₁ : ) :

The composition of path homotopy classes. This is Path.trans descended to the quotient.

Instances For
theorem Path.Homotopic.comp_lift {X : Type u} [] {x₀ : X} {x₁ : X} {x₂ : X} (P₀ : Path x₀ x₁) (P₁ : Path x₁ x₂) :
def Path.Homotopic.Quotient.mapFn {X : Type u} {Y : Type v} [] [] {x₀ : X} {x₁ : X} (P₀ : ) (f : C(X, Y)) :
Path.Homotopic.Quotient (f x₀) (f x₁)

The image of a path homotopy class P₀ under a map f. This is Path.map descended to the quotient.

Instances For
theorem Path.Homotopic.map_lift {X : Type u} {Y : Type v} [] [] {x₀ : X} {x₁ : X} (P₀ : Path x₀ x₁) (f : C(X, Y)) :
Quotient.mk (Path.Homotopic.setoid (f x₀) (f x₁)) (Path.map P₀ (_ : )) =
theorem Path.Homotopic.hpath_hext {X : Type u} [] {x₀ : X} {x₁ : X} {x₂ : X} {x₃ : X} {p₁ : Path x₀ x₁} {p₂ : Path x₂ x₃} (hp : ∀ (t : ), p₁ t = p₂ t) :
HEq (Quotient.mk () p₁) (Quotient.mk () p₂)
@[simp]
theorem Path.toHomotopyConst_apply {X : Type u} {Y : Type v} [] [] {x₀ : X} {x₁ : X} (p : Path x₀ x₁) :
∀ (a : ), ↑() a = p a.fst
def Path.toHomotopyConst {X : Type u} {Y : Type v} [] [] {x₀ : X} {x₁ : X} (p : Path x₀ x₁) :

A path Path x₀ x₁ generates a homotopy between constant functions fun _ ↦ x₀ and fun _ ↦ x₁.

Instances For
@[simp]
theorem ContinuousMap.homotopic_const_iff {X : Type u} {Y : Type v} [] [] {x₀ : X} {x₁ : X} [] :
Joined x₀ x₁

Two constant continuous maps with nonempty domain are homotopic if and only if their values are joined by a path in the codomain.

def ContinuousMap.Homotopy.evalAt {X : Type u_1} {Y : Type u_2} [] [] {f : C(X, Y)} {g : C(X, Y)} (H : ) (x : X) :
Path (f x) (g x)

Given a homotopy H : f ∼ g, get the path traced by the point x as it moves from f x to g x.

Instances For