File: Mathlib/AlgebraicTopology/FundamentalGroupoid/InducedMaps.lean

full_name: unitInterval.path01
code: /-- The path 0 ⟶ 1 in `I` -/
def path01 : Path (0 : I) 1 
goal: Path 0 1

full_name: unitInterval.upath01
code: /-- The path 0 ⟶ 1 in `ULift I` -/
def upath01 : Path (ULift.up 0 : ULift.{u} I) (ULift.up 1) 
goal: Path { down := 0 } { down := 1 }

full_name: unitInterval.uhpath01
code: /-- The homotopy path class of 0 → 1 in `ULift I` -/
def uhpath01 : @fromTop (TopCat.of <| ULift.{u} I) (ULift.up (0 : I)) ⟶ fromTop (ULift.up 1) 
goal: FundamentalGroupoid.fromTop { down := 0 } ⟶ FundamentalGroupoid.fromTop { down := 1 }

full_name: ContinuousMap.Homotopy.hcast
code: /-- Abbreviation for `eqToHom` that accepts points in a topological space -/
abbrev hcast {X : TopCat} {x₀ x₁ : X} (hx : x₀ = x₁) : fromTop x₀ ⟶ fromTop x₁ 
goal: FundamentalGroupoid.fromTop x₀ ⟶ FundamentalGroupoid.fromTop x₁

full_name: ContinuousMap.Homotopy.hcast_def
code: @[simp]
theorem hcast_def {X : TopCat} {x₀ x₁ : X} (hx₀ : x₀ = x₁) :
    hcast hx₀ = eqToHom (FundamentalGroupoid.ext _ _ hx₀) 
goal: ContinuousMap.Homotopy.hcast hx₀ = CategoryTheory.eqToHom ⋯

full_name: ContinuousMap.Homotopy.heq_path_of_eq_image
code: /-- 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 heq_path_of_eq_image : HEq ((πₘ f).map ⟦p⟧) ((πₘ g).map ⟦q⟧) 
goal: HEq ((π.map f).map ⟦p⟧) ((π.map g).map ⟦q⟧)

full_name: _private.Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps.0.ContinuousMap.Homotopy.start_path
code: private theorem start_path : f x₀ = g x₂ 
goal: f x₀ = g x₂

full_name: _private.Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps.0.ContinuousMap.Homotopy.end_path
code: private theorem end_path : f x₁ = g x₃ 
goal: f x₁ = g x₃

full_name: ContinuousMap.Homotopy.eq_path_of_eq_image
code: theorem eq_path_of_eq_image :
    (πₘ f).map ⟦p⟧ = hcast (start_path hfg) ≫ (πₘ g).map ⟦q⟧ ≫ hcast (end_path hfg).symm 
goal: (π.map f).map ⟦p⟧ = ContinuousMap.Homotopy.hcast ⋯ ≫ (π.map g).map ⟦q⟧ ≫ ContinuousMap.Homotopy.hcast ⋯

full_name: ContinuousMap.Homotopy.uliftMap
code: /-- Interpret a homotopy `H : C(I × X, Y)` as a map `C(ULift I × X, Y)` -/
def uliftMap : C(TopCat.of (ULift.{u} I × X), Y) 
goal: C(↑(TopCat.of (ULift.{u, 0} ↑I × ↑X)), ↑Y)

full_name: ContinuousMap.Homotopy.ulift_apply
code: @[simp, nolint simpNF]
theorem ulift_apply (i : ULift.{u} I) (x : X) : H.uliftMap (i, x) = H (i.down, x) 
goal: H.uliftMap (i, x) = H (i.down, x)

full_name: ContinuousMap.Homotopy.prodToProdTopI
code: /-- 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. -/
abbrev prodToProdTopI {a₁ a₂ : TopCat.of (ULift I)} {b₁ b₂ : X} (p₁ : fromTop a₁ ⟶ fromTop a₂)
    (p₂ : fromTop b₁ ⟶ fromTop b₂) 
goal: (FundamentalGroupoidFunctor.prodToProdTop (TopCat.of (ULift.{u, 0} ↑I)) X).obj ({ as := a₁ }, { as := b₁ }) ⟶
  (FundamentalGroupoidFunctor.prodToProdTop (TopCat.of (ULift.{u, 0} ↑I)) X).obj ({ as := a₂ }, { as := b₂ })

full_name: ContinuousMap.Homotopy.diagonalPath
code: /-- The diagonal path `d` of a homotopy `H` on a path `p` -/
def diagonalPath : fromTop (H (0, x₀)) ⟶ fromTop (H (1, x₁)) 
goal: FundamentalGroupoid.fromTop (H (0, x₀)) ⟶ FundamentalGroupoid.fromTop (H (1, x₁))

full_name: ContinuousMap.Homotopy.diagonalPath'
code: /-- The diagonal path, but starting from `f x₀` and going to `g x₁` -/
def diagonalPath' : fromTop (f x₀) ⟶ fromTop (g x₁) 
goal: FundamentalGroupoid.fromTop (f x₀) ⟶ FundamentalGroupoid.fromTop (g x₁)

full_name: ContinuousMap.Homotopy.apply_zero_path
code: /-- Proof that `f(p) = H(0 ⟶ 0, p)`, with the appropriate casts -/
theorem apply_zero_path : (πₘ f).map p = hcast (H.apply_zero x₀).symm ≫
    (πₘ H.uliftMap).map (prodToProdTopI (𝟙 (@fromTop (TopCat.of _) (ULift.up 0))) p) ≫
    hcast (H.apply_zero x₁) 
goal: (π.map f).map p =
  ContinuousMap.Homotopy.hcast ⋯ ≫
    (π.map H.uliftMap).map (ContinuousMap.Homotopy.prodToProdTopI (𝟙 (FundamentalGroupoid.fromTop { down := 0 })) p) ≫
      ContinuousMap.Homotopy.hcast ⋯

full_name: ContinuousMap.Homotopy.apply_one_path
code: /-- Proof that `g(p) = H(1 ⟶ 1, p)`, with the appropriate casts -/
theorem apply_one_path : (πₘ g).map p = hcast (H.apply_one x₀).symm ≫
    (πₘ H.uliftMap).map (prodToProdTopI (𝟙 (@fromTop (TopCat.of _) (ULift.up 1))) p) ≫
    hcast (H.apply_one x₁) 
goal: (π.map g).map p =
  ContinuousMap.Homotopy.hcast ⋯ ≫
    (π.map H.uliftMap).map (ContinuousMap.Homotopy.prodToProdTopI (𝟙 (FundamentalGroupoid.fromTop { down := 1 })) p) ≫
      ContinuousMap.Homotopy.hcast ⋯

full_name: ContinuousMap.Homotopy.evalAt_eq
code: /-- Proof that `H.evalAt x = H(0 ⟶ 1, x ⟶ x)`, with the appropriate casts -/
theorem evalAt_eq (x : X) : ⟦H.evalAt x⟧ = hcast (H.apply_zero x).symm ≫
    (πₘ H.uliftMap).map (prodToProdTopI uhpath01 (𝟙 (fromTop x))) ≫
      hcast (H.apply_one x).symm.symm 
goal: ⟦H.evalAt x⟧ =
  ContinuousMap.Homotopy.hcast ⋯ ≫
    (π.map H.uliftMap).map
        (ContinuousMap.Homotopy.prodToProdTopI unitInterval.uhpath01 (𝟙 (FundamentalGroupoid.fromTop x))) ≫
      ContinuousMap.Homotopy.hcast ⋯

full_name: ContinuousMap.Homotopy.eq_diag_path
code: theorem eq_diag_path : (πₘ f).map p ≫ ⟦H.evalAt x₁⟧ = H.diagonalPath' p ∧
    (⟦H.evalAt x₀⟧ ≫ (πₘ g).map p : fromTop (f x₀) ⟶ fromTop (g x₁)) = H.diagonalPath' p 
goal: (π.map f).map p ≫ ⟦H.evalAt x₁⟧ = H.diagonalPath' p ∧ ⟦H.evalAt x₀⟧ ≫ (π.map g).map p = H.diagonalPath' p

full_name: FundamentalGroupoidFunctor.homotopicMapsNatIso
code: /-- Given a homotopy H : f ∼ g, we have an associated natural isomorphism between the induced
functors `f` and `g` -/
-- Porting note: couldn't use category arrow `\hom` in statement, needed to expand
def homotopicMapsNatIso : @Quiver.Hom _ Functor.category.toQuiver (πₘ f) (πₘ g) 
goal: π.map f ⟶ π.map g

full_name: FundamentalGroupoidFunctor.instIsIsoFunctorαGroupoidObjTopCatGrpdFundamentalGroupoidFunctorHomotopicMapsNatIso
code: instance : IsIso (homotopicMapsNatIso H) 
goal: CategoryTheory.IsIso (FundamentalGroupoidFunctor.homotopicMapsNatIso H)

full_name: FundamentalGroupoidFunctor.equivOfHomotopyEquiv
code: /-- Homotopy equivalent topological spaces have equivalent fundamental groupoids. -/
def equivOfHomotopyEquiv (hequiv : X ≃ₕ Y) : πₓ X ≌ πₓ Y 
goal: ↑(π.obj X) ≌ ↑(π.obj Y)