[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : Homotopy p₀ p₁
t : ↑I
⊢ ContinuousMap.toFun (ContinuousMap.mk ↑(↑(ContinuousMap.Homotopy.curry F.toHomotopy) t)) 0 = x₀
[PROOFSTEP]
simp
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : Homotopy p₀ p₁
t : ↑I
⊢ ContinuousMap.toFun (ContinuousMap.mk ↑(↑(ContinuousMap.Homotopy.curry F.toHomotopy) t)) 1 = x₁
[PROOFSTEP]
simp
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : Homotopy p₀ p₁
⊢ eval F 0 = p₀
[PROOFSTEP]
ext t
[GOAL]
case a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : Homotopy p₀ p₁
t : ↑I
⊢ ↑(eval F 0) t = ↑p₀ t
[PROOFSTEP]
simp [eval]
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : Homotopy p₀ p₁
⊢ eval F 1 = p₁
[PROOFSTEP]
ext t
[GOAL]
case a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : Homotopy p₀ p₁
t : ↑I
⊢ ↑(eval F 1) t = ↑p₁ t
[PROOFSTEP]
simp [eval]
[GOAL]
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₁
⊢ Continuous fun x => (x.fst, Set.projIcc 0 1 extend.proof_1 (2 * ↑x.snd))
[PROOFSTEP]
continuity
[GOAL]
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₁
⊢ Continuous fun x => (x.fst, Set.projIcc 0 1 extend.proof_1 (2 * ↑x.snd - 1))
[PROOFSTEP]
continuity
[GOAL]
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 : ↑I × ↑I
hx : ↑x.snd = 1 / 2
⊢ extend (eval F x.fst) (2 * ↑x.snd) = extend (eval G x.fst) (2 * ↑x.snd - 1)
[PROOFSTEP]
rw [hx]
[GOAL]
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 : ↑I × ↑I
hx : ↑x.snd = 1 / 2
⊢ extend (eval F x.fst) (2 * (1 / 2)) = extend (eval G x.fst) (2 * (1 / 2) - 1)
[PROOFSTEP]
norm_num
[GOAL]
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 : ↑I
⊢ ContinuousMap.toFun
      (ContinuousMap.mk fun x =>
        if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd) else extend (eval G x.fst) (2 * ↑x.snd - 1))
      (0, x) =
    ↑(Path.trans p₀ p₁).toContinuousMap x
[PROOFSTEP]
simp [Path.trans]
[GOAL]
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 : ↑I
⊢ ContinuousMap.toFun
      (ContinuousMap.mk fun x =>
        if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd) else extend (eval G x.fst) (2 * ↑x.snd - 1))
      (1, x) =
    ↑(Path.trans q₀ q₁).toContinuousMap x
[PROOFSTEP]
simp [Path.trans]
[GOAL]
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 ∈ {0, 1}
⊢ ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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 ∧
    ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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 q₀ q₁).toContinuousMap t
[PROOFSTEP]
cases' ht with ht ht
[GOAL]
case inl
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 = 0
⊢ ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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 ∧
    ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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 q₀ q₁).toContinuousMap t
[PROOFSTEP]
rw [ht]
[GOAL]
case inl
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 = 0
⊢ ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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))
        0 =
      ↑(Path.trans p₀ p₁).toContinuousMap 0 ∧
    ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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))
        0 =
      ↑(Path.trans q₀ q₁).toContinuousMap 0
[PROOFSTEP]
norm_num
[GOAL]
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.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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 ∧
    ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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 q₀ q₁).toContinuousMap t
[PROOFSTEP]
rw [Set.mem_singleton_iff] at ht
[GOAL]
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.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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 ∧
    ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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 q₀ q₁).toContinuousMap t
[PROOFSTEP]
rw [ht]
[GOAL]
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.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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))
        1 =
      ↑(Path.trans p₀ p₁).toContinuousMap 1 ∧
    ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd)
                      else extend (eval G x.fst) (2 * ↑x.snd - 1),
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        (if ↑(0, x).snd ≤ 1 / 2 then extend (eval F (0, x).fst) (2 * ↑(0, x).snd)
                          else extend (eval G (0, x).fst) (2 * ↑(0, x).snd - 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).snd ≤ 1 / 2 then extend (eval F (1, x).fst) (2 * ↑(1, x).snd)
                          else extend (eval G (1, x).fst) (2 * ↑(1, x).snd - 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))
        1 =
      ↑(Path.trans q₀ q₁).toContinuousMap 1
[PROOFSTEP]
norm_num
[GOAL]
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 : ↑I × ↑I
⊢ (if ↑x.snd ≤ 1 / 2 then extend (eval F x.fst) (2 * ↑x.snd) else extend (eval G x.fst) (2 * ↑x.snd - 1)) =
    if h : ↑x.snd ≤ 1 / 2 then ↑(eval F x.fst) { val := 2 * ↑x.snd, property := (_ : 2 * ↑x.snd ∈ I) }
    else ↑(eval G x.fst) { val := 2 * ↑x.snd - 1, property := (_ : 2 * ↑x.snd - 1 ∈ I) }
[PROOFSTEP]
split_ifs
[GOAL]
case pos
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 : ↑I × ↑I
h✝ : ↑x.snd ≤ 1 / 2
⊢ extend (eval F x.fst) (2 * ↑x.snd) = ↑(eval F x.fst) { val := 2 * ↑x.snd, property := (_ : 2 * ↑x.snd ∈ I) }
[PROOFSTEP]
exact Path.extend_extends _ _
[GOAL]
case neg
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 : ↑I × ↑I
h✝ : ¬↑x.snd ≤ 1 / 2
⊢ extend (eval G x.fst) (2 * ↑x.snd - 1) =
    ↑(eval G x.fst) { val := 2 * ↑x.snd - 1, property := (_ : 2 * ↑x.snd - 1 ∈ I) }
[PROOFSTEP]
exact Path.extend_extends _ _
[GOAL]
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₁
t : ↑I
⊢ 0 ≤ 1 / 2
[PROOFSTEP]
norm_num
[GOAL]
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₁
t : ↑I
⊢ 1 / 2 ≤ 1
[PROOFSTEP]
norm_num
[GOAL]
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₁
t : ↑I
⊢ (if ↑(t, { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) }).snd ≤ 1 / 2 then
      extend (eval F (t, { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) }).fst)
        (2 * ↑(t, { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) }).snd)
    else
      extend (eval G (t, { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) }).fst)
        (2 * ↑(t, { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) }).snd - 1)) =
    x₁
[PROOFSTEP]
norm_num
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
x : ↑I × ↑I
⊢ 0 ≤ ↑(σ x.fst)
[PROOFSTEP]
unit_interval
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
x : ↑I × ↑I
⊢ 0 ≤ ↑x.fst
[PROOFSTEP]
unit_interval
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
x : ↑I × ↑I
⊢ ↑(σ x.fst) + ↑x.fst = 1
[PROOFSTEP]
simp
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
⊢ Continuous fun x =>
    ↑p
      { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
        property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) }
[PROOFSTEP]
refine continuous_const.path_eval ?_
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
⊢ Continuous fun x =>
    { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
      property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) }
[PROOFSTEP]
apply Continuous.subtype_mk
[GOAL]
case h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
⊢ Continuous fun x => ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd)
[PROOFSTEP]
apply Continuous.add
[GOAL]
case h.hf
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
⊢ Continuous fun x => ↑(σ x.fst) * ↑x.snd
[PROOFSTEP]
apply Continuous.mul
[GOAL]
case h.hg
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
⊢ Continuous fun x => ↑x.fst * ↑(f x.snd)
[PROOFSTEP]
apply Continuous.mul
[GOAL]
case h.hf.hf
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
⊢ Continuous fun x => ↑(σ x.fst)
[PROOFSTEP]
exact continuous_induced_dom.comp (unitInterval.continuous_symm.comp continuous_fst)
[GOAL]
case h.hf.hg
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
⊢ Continuous fun x => ↑x.snd
[PROOFSTEP]
continuity
[GOAL]
case h.hg.hf
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
⊢ Continuous fun x => ↑x.fst
[PROOFSTEP]
continuity
[GOAL]
case h.hg.hg
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
⊢ Continuous fun x => ↑(f x.snd)
[PROOFSTEP]
continuity
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
x : ↑I
⊢ ContinuousMap.toFun
      (ContinuousMap.mk fun x =>
        ↑p
          { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
            property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) })
      (0, x) =
    ↑p.toContinuousMap x
[PROOFSTEP]
norm_num
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
x : ↑I
⊢ ContinuousMap.toFun
      (ContinuousMap.mk fun x =>
        ↑p
          { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
            property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) })
      (1, x) =
    ↑(Path.reparam p f hf hf₀ hf₁).toContinuousMap x
[PROOFSTEP]
norm_num
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
t x : ↑I
hx : x ∈ {0, 1}
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        x =
      ↑p.toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.reparam p f hf hf₀ hf₁).toContinuousMap x
[PROOFSTEP]
cases' hx with hx hx
[GOAL]
case inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
t x : ↑I
hx : x = 0
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        x =
      ↑p.toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.reparam p f hf hf₀ hf₁).toContinuousMap x
[PROOFSTEP]
rw [hx]
[GOAL]
case inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
t x : ↑I
hx : x = 0
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        0 =
      ↑p.toContinuousMap 0 ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        0 =
      ↑(Path.reparam p f hf hf₀ hf₁).toContinuousMap 0
[PROOFSTEP]
simp [hf₀]
  -- Porting note: Originally `norm_num [hf₀]`
[GOAL]
case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
t x : ↑I
hx : x ∈ {1}
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        x =
      ↑p.toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.reparam p f hf hf₀ hf₁).toContinuousMap x
[PROOFSTEP]
rw [Set.mem_singleton_iff] at hx
[GOAL]
case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
t x : ↑I
hx : x = 1
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        x =
      ↑p.toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.reparam p f hf hf₀ hf₁).toContinuousMap x
[PROOFSTEP]
rw [hx]
[GOAL]
case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
f : ↑I → ↑I
hf : Continuous f
hf₀ : f 0 = 0
hf₁ : f 1 = 1
t x : ↑I
hx : x = 1
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        1 =
      ↑p.toContinuousMap 1 ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              {
                  toContinuousMap :=
                    ContinuousMap.mk fun x =>
                      ↑p
                        { val := ↑(σ x.fst) * ↑x.snd + ↑x.fst * ↑(f x.snd),
                          property := (_ : ↑(σ x.fst) • ↑x.snd + ↑x.fst • ↑(f x.snd) ∈ I) },
                  map_zero_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (0, x).fst) * ↑(0, x).snd + ↑(0, x).fst * ↑(f (0, x).snd),
                              property := (_ : ↑(σ (0, x).fst) • ↑(0, x).snd + ↑(0, x).fst • ↑(f (0, x).snd) ∈ I) } =
                          ↑p x),
                  map_one_left :=
                    (_ :
                      ∀ (x : ↑I),
                        ↑p
                            { val := ↑(σ (1, x).fst) * ↑(1, x).snd + ↑(1, x).fst * ↑(f (1, x).snd),
                              property := (_ : ↑(σ (1, x).fst) • ↑(1, x).snd + ↑(1, x).fst • ↑(f (1, x).snd) ∈ I) } =
                          ↑p (f x)) }.toContinuousMap
              (t, x))
        1 =
      ↑(Path.reparam p f hf hf₀ hf₁).toContinuousMap 1
[PROOFSTEP]
simp [hf₁]
  -- Porting note: Originally `norm_num [hf₀]`
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
⊢ ∀ (x : ↑I),
    ContinuousMap.toFun (ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd)) (0, x) = ↑(Path.symm p).toContinuousMap x
[PROOFSTEP]
simp [Path.symm]
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
⊢ ∀ (x : ↑I),
    ContinuousMap.toFun (ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd)) (1, x) = ↑(Path.symm q).toContinuousMap x
[PROOFSTEP]
simp [Path.symm]
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
t x : ↑I
hx : x ∈ {0, 1}
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.symm p).toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.symm q).toContinuousMap x
[PROOFSTEP]
cases' hx with hx hx
[GOAL]
case inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
t x : ↑I
hx : x = 0
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.symm p).toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.symm q).toContinuousMap x
[PROOFSTEP]
rw [hx]
[GOAL]
case inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
t x : ↑I
hx : x = 0
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        0 =
      ↑(Path.symm p).toContinuousMap 0 ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        0 =
      ↑(Path.symm q).toContinuousMap 0
[PROOFSTEP]
simp
[GOAL]
case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
t x : ↑I
hx : x ∈ {1}
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.symm p).toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.symm q).toContinuousMap x
[PROOFSTEP]
rw [Set.mem_singleton_iff] at hx
[GOAL]
case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
t x : ↑I
hx : x = 1
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.symm p).toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.symm q).toContinuousMap x
[PROOFSTEP]
rw [hx]
[GOAL]
case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
t x : ↑I
hx : x = 1
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        1 =
      ↑(Path.symm p).toContinuousMap 1 ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun x => ↑F (x.fst, σ x.snd),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑F (0, σ a) = ↑p (σ a)),
                  map_one_left := (_ : ∀ (a : ↑I), ↑F (1, σ a) = ↑q (σ a)) }.toContinuousMap
              (t, x))
        1 =
      ↑(Path.symm q).toContinuousMap 1
[PROOFSTEP]
simp
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
f : C(X, Y)
⊢ ∀ (x : ↑I),
    ContinuousMap.toFun (ContinuousMap.mk (↑f ∘ ↑F)) (0, x) = ↑(Path.map p (_ : Continuous ↑f)).toContinuousMap x
[PROOFSTEP]
simp
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
f : C(X, Y)
⊢ ∀ (x : ↑I),
    ContinuousMap.toFun (ContinuousMap.mk (↑f ∘ ↑F)) (1, x) = ↑(Path.map q (_ : Continuous ↑f)).toContinuousMap x
[PROOFSTEP]
simp
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
f : C(X, Y)
t x : ↑I
hx : x ∈ {0, 1}
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk (↑f ∘ ↑F),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑f (↑F (0, a)) = ↑(Path.map p (_ : Continuous ↑f)) a),
                  map_one_left :=
                    (_ : ∀ (a : ↑I), ↑f (↑F (1, a)) = ↑(Path.map q (_ : Continuous ↑f)) a) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.map p (_ : Continuous ↑f)).toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk (↑f ∘ ↑F),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑f (↑F (0, a)) = ↑(Path.map p (_ : Continuous ↑f)) a),
                  map_one_left :=
                    (_ : ∀ (a : ↑I), ↑f (↑F (1, a)) = ↑(Path.map q (_ : Continuous ↑f)) a) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.map q (_ : Continuous ↑f)).toContinuousMap x
[PROOFSTEP]
cases' hx with hx hx
[GOAL]
case inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
f : C(X, Y)
t x : ↑I
hx : x = 0
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk (↑f ∘ ↑F),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑f (↑F (0, a)) = ↑(Path.map p (_ : Continuous ↑f)) a),
                  map_one_left :=
                    (_ : ∀ (a : ↑I), ↑f (↑F (1, a)) = ↑(Path.map q (_ : Continuous ↑f)) a) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.map p (_ : Continuous ↑f)).toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk (↑f ∘ ↑F),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑f (↑F (0, a)) = ↑(Path.map p (_ : Continuous ↑f)) a),
                  map_one_left :=
                    (_ : ∀ (a : ↑I), ↑f (↑F (1, a)) = ↑(Path.map q (_ : Continuous ↑f)) a) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.map q (_ : Continuous ↑f)).toContinuousMap x
[PROOFSTEP]
simp [hx]
[GOAL]
case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
f : C(X, Y)
t x : ↑I
hx : x ∈ {1}
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk (↑f ∘ ↑F),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑f (↑F (0, a)) = ↑(Path.map p (_ : Continuous ↑f)) a),
                  map_one_left :=
                    (_ : ∀ (a : ↑I), ↑f (↑F (1, a)) = ↑(Path.map q (_ : Continuous ↑f)) a) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.map p (_ : Continuous ↑f)).toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk (↑f ∘ ↑F),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑f (↑F (0, a)) = ↑(Path.map p (_ : Continuous ↑f)) a),
                  map_one_left :=
                    (_ : ∀ (a : ↑I), ↑f (↑F (1, a)) = ↑(Path.map q (_ : Continuous ↑f)) a) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.map q (_ : Continuous ↑f)).toContinuousMap x
[PROOFSTEP]
rw [Set.mem_singleton_iff] at hx
[GOAL]
case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : Homotopy p q
f : C(X, Y)
t x : ↑I
hx : x = 1
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk (↑f ∘ ↑F),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑f (↑F (0, a)) = ↑(Path.map p (_ : Continuous ↑f)) a),
                  map_one_left :=
                    (_ : ∀ (a : ↑I), ↑f (↑F (1, a)) = ↑(Path.map q (_ : Continuous ↑f)) a) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.map p (_ : Continuous ↑f)).toContinuousMap x ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk (↑f ∘ ↑F),
                  map_zero_left := (_ : ∀ (a : ↑I), ↑f (↑F (0, a)) = ↑(Path.map p (_ : Continuous ↑f)) a),
                  map_one_left :=
                    (_ : ∀ (a : ↑I), ↑f (↑F (1, a)) = ↑(Path.map q (_ : Continuous ↑f)) a) }.toContinuousMap
              (t, x))
        x =
      ↑(Path.map q (_ : Continuous ↑f)).toContinuousMap x
[PROOFSTEP]
simp [hx]
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₁ : Path x₀ x₁
p₂ : Path x₂ x₃
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ HEq (Quotient.mk (Homotopic.setoid x₀ x₁) p₁) (Quotient.mk (Homotopic.setoid x₂ x₃) p₂)
[PROOFSTEP]
obtain rfl : x₀ = x₂ := by convert hp 0 <;> simp
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₁ : Path x₀ x₁
p₂ : Path x₂ x₃
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ x₀ = x₂
[PROOFSTEP]
convert hp 0
[GOAL]
case h.e'_2
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₁ : Path x₀ x₁
p₂ : Path x₂ x₃
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ x₀ = ↑p₁ 0
[PROOFSTEP]
simp
[GOAL]
case h.e'_3
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₁ : Path x₀ x₁
p₂ : Path x₂ x₃
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ x₂ = ↑p₂ 0
[PROOFSTEP]
simp
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₃ : X
p₁ : Path x₀ x₁
p₂ : Path x₀ x₃
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ HEq (Quotient.mk (Homotopic.setoid x₀ x₁) p₁) (Quotient.mk (Homotopic.setoid x₀ x₃) p₂)
[PROOFSTEP]
obtain rfl : x₁ = x₃ := by convert hp 1 <;> simp
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₃ : X
p₁ : Path x₀ x₁
p₂ : Path x₀ x₃
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ x₁ = x₃
[PROOFSTEP]
convert hp 1
[GOAL]
case h.e'_2
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₃ : X
p₁ : Path x₀ x₁
p₂ : Path x₀ x₃
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ x₁ = ↑p₁ 1
[PROOFSTEP]
simp
[GOAL]
case h.e'_3
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₃ : X
p₁ : Path x₀ x₁
p₂ : Path x₀ x₃
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ x₃ = ↑p₂ 1
[PROOFSTEP]
simp
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p₁ p₂ : Path x₀ x₁
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ HEq (Quotient.mk (Homotopic.setoid x₀ x₁) p₁) (Quotient.mk (Homotopic.setoid x₀ x₁) p₂)
[PROOFSTEP]
rw [heq_iff_eq]
[GOAL]
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p₁ p₂ : Path x₀ x₁
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ Quotient.mk (Homotopic.setoid x₀ x₁) p₁ = Quotient.mk (Homotopic.setoid x₀ x₁) p₂
[PROOFSTEP]
congr
[GOAL]
case e_a
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p₁ p₂ : Path x₀ x₁
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
⊢ p₁ = p₂
[PROOFSTEP]
ext t
[GOAL]
case e_a.a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p₁ p₂ : Path x₀ x₁
hp : ∀ (t : ↑I), ↑p₁ t = ↑p₂ t
t : ↑I
⊢ ↑p₁ t = ↑p₂ t
[PROOFSTEP]
exact hp t
[GOAL]
X : Type u
Y : Type v
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
inst✝ : Nonempty Y
⊢ Homotopic (const Y x₀) (const Y x₁) ↔ Joined x₀ x₁
[PROOFSTEP]
inhabit Y
[GOAL]
X : Type u
Y : Type v
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
inst✝ : Nonempty Y
inhabited_h : Inhabited Y
⊢ Homotopic (const Y x₀) (const Y x₁) ↔ Joined x₀ x₁
[PROOFSTEP]
refine ⟨fun ⟨H⟩ ↦ ⟨⟨(H.toContinuousMap.comp .prodSwap).curry default, ?_, ?_⟩⟩, fun ⟨p⟩ ↦ ⟨p.toHomotopyConst⟩⟩
[GOAL]
case refine_1
X : Type u
Y : Type v
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
inst✝ : Nonempty Y
inhabited_h : Inhabited Y
x✝ : Homotopic (const Y x₀) (const Y x₁)
H : Homotopy (const Y x₀) (const Y x₁)
⊢ ContinuousMap.toFun (↑(curry (comp H.toContinuousMap prodSwap)) default) 0 = x₀
[PROOFSTEP]
simp
[GOAL]
case refine_2
X : Type u
Y : Type v
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
inst✝ : Nonempty Y
inhabited_h : Inhabited Y
x✝ : Homotopic (const Y x₀) (const Y x₁)
H : Homotopy (const Y x₀) (const Y x₁)
⊢ ContinuousMap.toFun (↑(curry (comp H.toContinuousMap prodSwap)) default) 1 = x₁
[PROOFSTEP]
simp