Documentation

Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps

Homotopic maps induce naturally isomorphic functors #

Main definitions #

theorem Path.Homotopic.map_trans_evalAt {X : Type u_1} {Y : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] {f g : C(X, Y)} (F : f.Homotopy g) {x₁ x₂ : X} (p : Path x₁ x₂) :
((p.map ).trans (F.evalAt x₂)).Homotopic ((F.evalAt x₁).trans (p.map ))

Let F be a homotopy between two continuous maps f g : C(X, Y). Given a path p : Path x₁ x₂ in the domain, consider the following two paths in the codomain. One path goes along the image of p under f, then along the trajectory of x₂ under F. The other path goes along the trajectory of x₁ under F, then along the image of p under g.

These two paths are homotopic.

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

Instances For

    Homotopy equivalent topological spaces have equivalent fundamental groupoids.

    Instances For

      Old proof #

      The rest of the file contains definitions and theorems required to write the same proof in a slightly different manner.

      The proof was rewritten in 2025 for two reasons:

      TODO: review which of these definitions and theorems are useful for other reasons, then deprecate the rest of them.

      The path 0 ⟶ 1 in I

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

        The path 0 ⟶ 1 in ULift I

        Instances For

          The homotopy path class of 0 → 1 in ULift I

          Instances For
            @[reducible, inline]
            noncomputable abbrev ContinuousMap.Homotopy.hcast {X : TopCat} {x₀ x₁ : X} (hx : x₀ = x₁) :

            Abbreviation for eqToHom that accepts points in a topological space

            Instances For
              @[simp]
              theorem ContinuousMap.Homotopy.hcast_def {X : TopCat} {x₀ x₁ : X} (hx₀ : x₀ = x₁) :
              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)) :

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

              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)

              Instances For
                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.

                Instances For
                  noncomputable 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₁) :

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

                  Instances For
                    noncomputable 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₁) :

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

                    Instances For