Theorem: Path.trans_range
File: Mathlib/Topology/PathConnected.lean

tactic: rw [Path.trans]
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.252948
γ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
⊢ range ↑(trans γ₁ γ₂) = range ↑γ₁ ∪ range ↑γ₂

tactic: apply eq_of_subset_of_subset
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.252948
γ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
⊢ range
      ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) } =
    range ↑γ₁ ∪ range ↑γ₂

tactic: rintro x ⟨⟨t, ht0, ht1⟩, hxt⟩
state_before: case a
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.252948
γ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
⊢ range
      ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) } ⊆
    range ↑γ₁ ∪ range ↑γ₂

tactic: by_cases h : t ≤ 1 / 2
state_before: case a.intro.mk.intro
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
⊢ x ∈ range ↑γ₁ ∪ range ↑γ₂

tactic: left
state_before: case pos
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : t ≤ 1 / 2
⊢ x ∈ range ↑γ₁ ∪ range ↑γ₂

tactic: use ⟨2 * t, ⟨by linarith, by linarith⟩⟩
state_before: case pos.h
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : t ≤ 1 / 2
⊢ x ∈ range ↑γ₁

tactic: rw [← γ₁.extend_extends]
state_before: case pos.h
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : t ≤ 1 / 2
⊢ ↑γ₁ { val := 2 * t, property := (_ : 0 ≤ 2 * t ∧ 2 * t ≤ 1) } = x

tactic: rwa [coe_mk_mk, Function.comp_apply, if_pos h] at hxt
state_before: case pos.h
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : t ≤ 1 / 2
⊢ extend γ₁ (2 * t) = x

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : t ≤ 1 / 2
⊢ 0 ≤ 2 * t

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : t ≤ 1 / 2
⊢ 2 * t ≤ 1

tactic: right
state_before: case neg
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : ¬t ≤ 1 / 2
⊢ x ∈ range ↑γ₁ ∪ range ↑γ₂

tactic: use ⟨2 * t - 1, ⟨by linarith, by linarith⟩⟩
state_before: case neg.h
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : ¬t ≤ 1 / 2
⊢ x ∈ range ↑γ₂

tactic: rw [← γ₂.extend_extends]
state_before: case neg.h
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : ¬t ≤ 1 / 2
⊢ ↑γ₂ { val := 2 * t - 1, property := (_ : 0 ≤ 2 * t - 1 ∧ 2 * t - 1 ≤ 1) } = x

tactic: rwa [coe_mk_mk, Function.comp_apply, if_neg h] at hxt
state_before: case neg.h
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : ¬t ≤ 1 / 2
⊢ extend γ₂ (2 * t - 1) = x

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : ¬t ≤ 1 / 2
⊢ 0 ≤ 2 * t - 1

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt :
  ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } =
    x
h : ¬t ≤ 1 / 2
⊢ 2 * t - 1 ≤ 1

tactic: rintro x (⟨⟨t, ht0, ht1⟩, hxt⟩ | ⟨⟨t, ht0, ht1⟩, hxt⟩)
state_before: case a
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.252948
γ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
⊢ range ↑γ₁ ∪ range ↑γ₂ ⊆
    range
      ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }

tactic: use ⟨t / 2, ⟨by linarith, by linarith⟩⟩
state_before: case a.inl.intro.mk.intro
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₁ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
⊢ x ∈
    range
      ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }

tactic: have : t / 2 ≤ 1 / 2 := (div_le_div_right (zero_lt_two : (0 : ℝ) < 2)).mpr ht1
state_before: case a.inl.intro.mk.intro
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₁ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
⊢ ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t / 2, property := (_ : 0 ≤ t / 2 ∧ t / 2 ≤ 1) } =
    x

tactic: rw [coe_mk_mk, Function.comp_apply, if_pos this, Subtype.coe_mk]
state_before: case a.inl.intro.mk.intro
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₁ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
this : t / 2 ≤ 1 / 2
⊢ ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := t / 2, property := (_ : 0 ≤ t / 2 ∧ t / 2 ≤ 1) } =
    x

tactic: ring_nf
state_before: case a.inl.intro.mk.intro
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₁ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
this : t / 2 ≤ 1 / 2
⊢ extend γ₁ (2 * (t / 2)) = x

tactic: rwa [γ₁.extend_extends]
state_before: case a.inl.intro.mk.intro
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₁ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
this : t / 2 ≤ 1 / 2
⊢ extend γ₁ t = x

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₁ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
⊢ 0 ≤ t / 2

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₁ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
⊢ t / 2 ≤ 1

tactic: by_cases h : t = 0
state_before: case a.inr.intro.mk.intro
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
⊢ x ∈
    range
      ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }

tactic: use ⟨1 / 2, ⟨by linarith, by linarith⟩⟩
state_before: case pos
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t = 0
⊢ x ∈
    range
      ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }

tactic: rw [coe_mk_mk, Function.comp_apply, if_pos le_rfl, Subtype.coe_mk,
  mul_one_div_cancel (two_ne_zero' ℝ)]
state_before: case pos
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t = 0
⊢ ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := 1 / 2, property := (_ : 0 ≤ 1 / 2 ∧ 1 / 2 ≤ 1) } =
    x

tactic: rw [γ₁.extend_one]
state_before: case pos
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t = 0
⊢ extend γ₁ 1 = x

tactic: rwa [← γ₂.extend_extends, h, γ₂.extend_zero] at hxt
state_before: case pos
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t = 0
⊢ b = x

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t = 0
⊢ 0 ≤ 1 / 2

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t = 0
⊢ 1 / 2 ≤ 1

tactic: use ⟨(t + 1) / 2, ⟨by linarith, by linarith⟩⟩
state_before: case neg
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : ¬t = 0
⊢ x ∈
    range
      ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }

tactic: replace h : t ≠ 0 := h
state_before: case neg
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : ¬t = 0
⊢ ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := (t + 1) / 2, property := (_ : 0 ≤ (t + 1) / 2 ∧ (t + 1) / 2 ≤ 1) } =
    x

tactic: have ht0 := lt_of_le_of_ne ht0 h.symm
state_before: case neg
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t ≠ 0
⊢ ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := (t + 1) / 2, property := (_ : 0 ≤ (t + 1) / 2 ∧ (t + 1) / 2 ≤ 1) } =
    x

tactic: have : ¬(t + 1) / 2 ≤ 1 / 2 := by
  rw [not_le]
  linarith
state_before: case neg
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0✝ : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t ≠ 0
ht0 : 0 < t
⊢ ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := (t + 1) / 2, property := (_ : 0 ≤ (t + 1) / 2 ∧ (t + 1) / 2 ≤ 1) } =
    x

tactic: rw [coe_mk_mk, Function.comp_apply, Subtype.coe_mk, if_neg this]
state_before: case neg
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0✝ : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t ≠ 0
ht0 : 0 < t
this : ¬(t + 1) / 2 ≤ 1 / 2
⊢ ↑{
          toContinuousMap :=
            ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ₁ (2 * t) else extend γ₂ (2 * t - 1)) ∘ Subtype.val),
          source' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 0 = a),
          target' :=
            (_ : ((fun x => if x ≤ 1 / 2 then extend γ₁ (2 * x) else extend γ₂ (2 * x - 1)) ∘ Subtype.val) 1 = c) }
      { val := (t + 1) / 2, property := (_ : 0 ≤ (t + 1) / 2 ∧ (t + 1) / 2 ≤ 1) } =
    x

tactic: ring_nf
state_before: case neg
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0✝ : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t ≠ 0
ht0 : 0 < t
this : ¬(t + 1) / 2 ≤ 1 / 2
⊢ extend γ₂ (2 * ((t + 1) / 2) - 1) = x

tactic: rwa [γ₂.extend_extends]
state_before: case neg
X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0✝ : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t ≠ 0
ht0 : 0 < t
this : ¬(t + 1) / 2 ≤ 1 / 2
⊢ extend γ₂ t = x

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : ¬t = 0
⊢ 0 ≤ (t + 1) / 2

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0 : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : ¬t = 0
⊢ (t + 1) / 2 ≤ 1

tactic: rw [not_le]
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0✝ : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t ≠ 0
ht0 : 0 < t
⊢ ¬(t + 1) / 2 ≤ 1 / 2

tactic: linarith
state_before: X✝ : Type ?u.252930
Y : Type ?u.252933
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.252948
γ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b c : X
γ₁ : Path a b
γ₂ : Path b c
x : X
t : ℝ
ht0✝ : 0 ≤ t
ht1 : t ≤ 1
hxt : ↑γ₂ { val := t, property := (_ : 0 ≤ t ∧ t ≤ 1) } = x
h : t ≠ 0
ht0 : 0 < t
⊢ 1 / 2 < (t + 1) / 2