Homotopic maps induce naturally isomorphic functors

Main definitions

• FundamentalGroupoidFunctor.homotopicMapsNatIso H The natural isomorphism between the induced functors f : π(X) ⥤ π(Y) and g : π(X) ⥤ π(Y), given a homotopy H : f ∼ g

• FundamentalGroupoidFunctor.equivOfHomotopyEquiv hequiv The equivalence of the categories π(X) and π(Y) given a homotopy equivalence hequiv : X ≃ₕ Y between them.

Implementation notes

• In order to be more universe polymorphic, we define ContinuousMap.Homotopy.uliftMap which lifts a homotopy from I × X → Y to (TopCat.of ((ULift I) × X)) → Y. This is because this construction uses FundamentalGroupoidFunctor.prodToProdTop to convert between pairs of paths in I and X and the corresponding path after passing through a homotopy H. But FundamentalGroupoidFunctor.prodToProdTop requires two spaces in the same universe.

def unitInterval.path01 : Path 0 1

The path 0 ⟶ 1 in I

Equations

• unitInterval.path01 = { toFun := id, continuous_toFun := unitInterval.path01._proof_1, source' := unitInterval.path01._proof_2, target' := unitInterval.path01._proof_3 }

def unitInterval.upath01 : Path { down := 0 } { down := 1 }

The path 0 ⟶ 1 in ULift I

Equations

• unitInterval.upath01 = { toFun := ULift.up, continuous_toFun := unitInterval.upath01._proof_1, source' := unitInterval.upath01._proof_2, target' := unitInterval.upath01._proof_3 }

def unitInterval.uhpath01 : FundamentalGroupoid.fromTop { down := 0 } ⟶ FundamentalGroupoid.fromTop { down := 1 }

The homotopy path class of 0 → 1 in ULift I

Equations

• unitInterval.uhpath01 = ⟦unitInterval.upath01⟧

@[reducible, inline]

abbrev ContinuousMap.Homotopy.hcast {X : TopCat} {x₀ x₁ : ↑X} (hx : x₀ = x₁) : FundamentalGroupoid.fromTop x₀ ⟶ FundamentalGroupoid.fromTop x₁

Abbreviation for eqToHom that accepts points in a topological space

Equations

• ContinuousMap.Homotopy.hcast hx = CategoryTheory.eqToHom ⋯

@[simp]

theorem ContinuousMap.Homotopy.hcast_def {X : TopCat} {x₀ x₁ : ↑X} (hx₀ : x₀ = x₁) : hcast hx₀ = CategoryTheory.eqToHom ⋯

theorem ContinuousMap.Homotopy.heq_path_of_eq_image {X₁ X₂ Y : TopCat} {f : C(↑X₁, ↑Y)} {g : C(↑X₂, ↑Y)} {x₀ x₁ : ↑X₁} {x₂ x₃ : ↑X₂} {p : Path x₀ x₁} {q : Path x₂ x₃} (hfg : ∀ (t : ↑unitInterval), f (p t) = g (q t)) : (FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom f)).map ⟦p⟧ ≍ (FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom g)).map ⟦q⟧

If f(p(t) = g(q(t)) for two paths p and q, then the induced path homotopy classes f(p) and g(p) are the same as well, despite having a priori different types

theorem ContinuousMap.Homotopy.eq_path_of_eq_image {X₁ X₂ Y : TopCat} {f : C(↑X₁, ↑Y)} {g : C(↑X₂, ↑Y)} {x₀ x₁ : ↑X₁} {x₂ x₃ : ↑X₂} {p : Path x₀ x₁} {q : Path x₂ x₃} (hfg : ∀ (t : ↑unitInterval), f (p t) = g (q t)) : (FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom f)).map ⟦p⟧ = CategoryTheory.CategoryStruct.comp (hcast ⋯) (CategoryTheory.CategoryStruct.comp ((FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom g)).map ⟦q⟧) (hcast ⋯))

These definitions set up the following diagram, for each path p:

        f(p)
    *--------*
    | \      |
H₀  |   \ d  |  H₁
    |     \  |
    *--------*
        g(p)

Here, H₀ = H.evalAt x₀ is the path from f(x₀) to g(x₀), and similarly for H₁. Similarly, f(p) denotes the path in Y that the induced map f takes p, and similarly for g(p).

Finally, d, the diagonal path, is H(0 ⟶ 1, p), the result of the induced H on Path.Homotopic.prod (0 ⟶ 1) p, where (0 ⟶ 1) denotes the path from 0 to 1 in I.

It is clear that the diagram commutes (H₀ ≫ g(p) = d = f(p) ≫ H₁), but unfortunately, many of the paths do not have defeq starting/ending points, so we end up needing some casting.

def ContinuousMap.Homotopy.uliftMap {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) : C(↑(TopCat.of (ULift.{u, 0} ↑unitInterval × ↑X)), ↑Y)

Interpret a homotopy H : C(I × X, Y) as a map C(ULift I × X, Y)

Equations

• H.uliftMap = { toFun := fun (x : ↑(TopCat.of (ULift.{?u.34, 0} ↑unitInterval × ↑X))) => H (x.1.down, x.2), continuous_toFun := ⋯ }

theorem ContinuousMap.Homotopy.ulift_apply {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) (i : ULift.{u, 0} ↑unitInterval) (x : ↑X) : H.uliftMap (i, x) = H (i.down, x)

@[reducible, inline]

abbrev ContinuousMap.Homotopy.prodToProdTopI {X : TopCat} {a₁ a₂ : ↑(TopCat.of (ULift.{u, 0} ↑unitInterval))} {b₁ b₂ : ↑X} (p₁ : FundamentalGroupoid.fromTop a₁ ⟶ FundamentalGroupoid.fromTop a₂) (p₂ : FundamentalGroupoid.fromTop b₁ ⟶ FundamentalGroupoid.fromTop b₂) : (FundamentalGroupoidFunctor.prodToProdTop (TopCat.of (ULift.{u, 0} ↑unitInterval)) X).obj ({ as := a₁ }, { as := b₁ }) ⟶ (FundamentalGroupoidFunctor.prodToProdTop (TopCat.of (ULift.{u, 0} ↑unitInterval)) X).obj ({ as := a₂ }, { as := b₂ })

An abbreviation for prodToProdTop, with some types already in place to help the typechecker. In particular, the first path should be on the ulifted unit interval.

Equations

• ContinuousMap.Homotopy.prodToProdTopI p₁ p₂ = (FundamentalGroupoidFunctor.prodToProdTop (TopCat.of (ULift.{?u.60, 0} ↑unitInterval)) X).map (p₁, p₂)

def ContinuousMap.Homotopy.diagonalPath {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) {x₀ x₁ : ↑X} (p : FundamentalGroupoid.fromTop x₀ ⟶ FundamentalGroupoid.fromTop x₁) : FundamentalGroupoid.fromTop (H (0, x₀)) ⟶ FundamentalGroupoid.fromTop (H (1, x₁))

The diagonal path d of a homotopy H on a path p

Equations

• H.diagonalPath p = (FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom H.uliftMap)).map (ContinuousMap.Homotopy.prodToProdTopI unitInterval.uhpath01 p)

def ContinuousMap.Homotopy.diagonalPath' {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) {x₀ x₁ : ↑X} (p : FundamentalGroupoid.fromTop x₀ ⟶ FundamentalGroupoid.fromTop x₁) : FundamentalGroupoid.fromTop (f x₀) ⟶ FundamentalGroupoid.fromTop (g x₁)

The diagonal path, but starting from f x₀ and going to g x₁

Equations

• H.diagonalPath' p = CategoryTheory.CategoryStruct.comp (ContinuousMap.Homotopy.hcast ⋯) (CategoryTheory.CategoryStruct.comp (H.diagonalPath p) (ContinuousMap.Homotopy.hcast ⋯))

theorem ContinuousMap.Homotopy.apply_zero_path {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) {x₀ x₁ : ↑X} (p : FundamentalGroupoid.fromTop x₀ ⟶ FundamentalGroupoid.fromTop x₁) : (FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom f)).map p = CategoryTheory.CategoryStruct.comp (hcast ⋯) (CategoryTheory.CategoryStruct.comp ((FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom H.uliftMap)).map (prodToProdTopI (CategoryTheory.CategoryStruct.id (FundamentalGroupoid.fromTop { down := 0 })) p)) (hcast ⋯))

Proof that f(p) = H(0 ⟶ 0, p), with the appropriate casts

theorem ContinuousMap.Homotopy.apply_one_path {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) {x₀ x₁ : ↑X} (p : FundamentalGroupoid.fromTop x₀ ⟶ FundamentalGroupoid.fromTop x₁) : (FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom g)).map p = CategoryTheory.CategoryStruct.comp (hcast ⋯) (CategoryTheory.CategoryStruct.comp ((FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom H.uliftMap)).map (prodToProdTopI (CategoryTheory.CategoryStruct.id (FundamentalGroupoid.fromTop { down := 1 })) p)) (hcast ⋯))

Proof that g(p) = H(1 ⟶ 1, p), with the appropriate casts

theorem ContinuousMap.Homotopy.evalAt_eq {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) (x : ↑X) : ⟦H.evalAt x⟧ = CategoryTheory.CategoryStruct.comp (hcast ⋯) (CategoryTheory.CategoryStruct.comp ((FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom H.uliftMap)).map (prodToProdTopI unitInterval.uhpath01 (CategoryTheory.CategoryStruct.id (FundamentalGroupoid.fromTop x)))) (hcast ⋯))

Proof that H.evalAt x = H(0 ⟶ 1, x ⟶ x), with the appropriate casts

theorem ContinuousMap.Homotopy.eq_diag_path {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) {x₀ x₁ : ↑X} (p : FundamentalGroupoid.fromTop x₀ ⟶ FundamentalGroupoid.fromTop x₁) : CategoryTheory.CategoryStruct.comp ((FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom f)).map p) ⟦H.evalAt x₁⟧ = H.diagonalPath' p ∧ CategoryTheory.CategoryStruct.comp ⟦H.evalAt x₀⟧ ((FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom g)).map p) = H.diagonalPath' p

def FundamentalGroupoidFunctor.homotopicMapsNatIso {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) : FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom f) ⟶ FundamentalGroupoid.fundamentalGroupoidFunctor.map (TopCat.ofHom g)

Given a homotopy H : f ∼ g, we have an associated natural isomorphism between the induced functors f and g

Equations

• FundamentalGroupoidFunctor.homotopicMapsNatIso H = { app := fun (x : ↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj (TopCat.of ↑X))) => ⟦H.evalAt x.as⟧, naturality := ⋯ }

instance FundamentalGroupoidFunctor.instIsIsoFunctorαGroupoidObjTopCatGrpdFundamentalGroupoidFunctorOfCarrierHomotopicMapsNatIso {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) : CategoryTheory.IsIso (homotopicMapsNatIso H)

def FundamentalGroupoidFunctor.equivOfHomotopyEquiv {X Y : TopCat} (hequiv : ContinuousMap.HomotopyEquiv ↑X ↑Y) : ↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj X) ≌ ↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj Y)

Homotopy equivalent topological spaces have equivalent fundamental groupoids.

Equations

• One or more equations did not get rendered due to their size.