/-- 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₁`.
-/
def hcomp (F : Homotopy p₀ q₀) (G : Homotopy p₁ q₁) : Homotopy (p₀.trans p₁) (q₀.trans q₁) where
  toFun x :=
    if (x.2 : ℝ) ≤ 1 / 2 then (F.eval x.1).extend (2 * x.2) else (G.eval x.1).extend (2 * x.2 - 1)
  continuous_toFun := continuous_if_le (continuous_induced_dom.comp continuous_snd) continuous_const
    (F.toHomotopy.continuous.comp (by continuity)).continuousOn
    (G.toHomotopy.continuous.comp (by continuity)).continuousOn fun x hx => by norm_num [hx]
  map_zero_left x := by simp [Path.trans]
  map_one_left x := by simp [Path.trans]
  prop' x t ht := by
    cases' ht with ht ht
    · norm_num [ht]
    · rw [Set.mem_singleton_iff] at ht
      

Proof state:
case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ q₀ : Path x₀ x₁
p₁ q₁ : Path x₁ x₂
F : Homotopy p₀ q₀
G : Homotopy p₁ q₁
x t : ↑I
ht : t = 1
⊢ (ContinuousMap.mk fun x_1 =>
        ContinuousMap.toFun
          {
              toContinuousMap :=
                ContinuousMap.mk fun x =>
                  if ↑x.2 ≤ 1 / 2 then extend (eval F x.1) (2 * ↑x.2) else extend (eval G x.1) (2 * ↑x.2 - 1),
              map_zero_left :=
                (_ :
                  ∀ (x : ↑I),
                    (if ↑(0, x).2 ≤ 1 / 2 then extend (eval F (0, x).1) (2 * ↑(0, x).2)
                      else extend (eval G (0, x).1) (2 * ↑(0, x).2 - 1)) =
                      {
                            toContinuousMap :=
                              ContinuousMap.mk
                                ((fun t => if t ≤ 1 / 2 then extend p₀ (2 * t) else extend p₁ (2 * t - 1)) ∘
                                  Subtype.val),
                            source' :=
                              (_ :
                                ((fun x => if x ≤ 1 / 2 then extend p₀ (2 * x) else extend p₁ (2 * x - 1)) ∘
                                      Subtype.val)
                                    0 =
                                  x₀),
                            target' :=
                              (_ :
                                ((fun x => if x ≤ 1 / 2 then extend p₀ (2 * x) else extend p₁ (2 * x - 1)) ∘
                                      Subtype.val)
                                    1 =
                                  x₂) }.toContinuousMap
                        x),
              map_one_left :=
                (_ :
                  ∀ (x : ↑I),
                    (if ↑(1, x).2 ≤ 1 / 2 then extend (eval F (1, x).1) (2 * ↑(1, x).2)
                      else extend (eval G (1, x).1) (2 * ↑(1, x).2 - 1)) =
                      {
                            toContinuousMap :=
                              ContinuousMap.mk
                                ((fun t => if t ≤ 1 / 2 then extend q₀ (2 * t) else extend q₁ (2 * t - 1)) ∘
                                  Subtype.val),
                            source' :=
                              (_ :
                                ((fun x => if x ≤ 1 / 2 then extend q₀ (2 * x) else extend q₁ (2 * x - 1)) ∘
                                      Subtype.val)
                                    0 =
                                  x₀),
                            target' :=
                              (_ :
                                ((fun x => if x ≤ 1 / 2 then extend q₀ (2 * x) else extend q₁ (2 * x - 1)) ∘
                                      Subtype.val)
                                    1 =
                                  x₂) }.toContinuousMap
                        x) }.toContinuousMap
          (x, x_1))
      t =
    (Path.trans p₀ p₁).toContinuousMap t

Next tactic:
norm_num [ht]