l3lab/ntp-mathlib huggingface dataset:
@[simp]
theorem symm_symm (γ : Path x y) : γ.symm.symm = γ := by
  ext t
  show γ (σ (σ t)) = γ t
  

Proof state:
case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
t : ↑I
⊢ γ (σ (σ t)) = γ t

Next tactic:
rw [unitInterval.symm_symm]
@[simp]
theorem refl_symm {a : X} : (Path.refl a).symm = Path.refl a := by
  

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
a : X
⊢ symm (refl a) = refl a

Next tactic:
ext
@[simp]
theorem refl_symm {a : X} : (Path.refl a).symm = Path.refl a := by
  ext
  

Proof state:
case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
a : X
x✝ : ↑I
⊢ (symm (refl a)) x✝ = (refl a) x✝

Next tactic:
rfl
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ := by
  

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ : Path x y
a b : X
γ : Path a b
⊢ range ⇑(symm γ) = range ⇑γ

Next tactic:
ext x
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ := by
  ext x
  

Proof state:
case h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type u_3
γ✝ : Path x✝ y
a b : X
γ : Path a b
x : X
⊢ x ∈ range ⇑(symm γ) ↔ x ∈ range ⇑γ

Next tactic:
simp only [mem_range, Path.symm, FunLike.coe, unitInterval.symm, SetCoe.exists, comp_apply,
    Subtype.coe_mk]
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ := by
  ext x
  simp only [mem_range, Path.symm, FunLike.coe, unitInterval.symm, SetCoe.exists, comp_apply,
    Subtype.coe_mk]
  

Proof state:
case h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type u_3
γ✝ : Path x✝ y
a b : X
γ : Path a b
x : X
⊢ (∃ x_1,
      ∃ (h : x_1 ∈ I),
        ContinuousMap.toFun γ.toContinuousMap
            { val := 1 - x_1, property := (_ : 1 - ↑{ val := x_1, property := (_ : x_1 ∈ I) } ∈ I) } =
          x) ↔
    ∃ x_1, ∃ (h : x_1 ∈ I), ContinuousMap.toFun γ.toContinuousMap { val := x_1, property := h } = x

Next tactic:
constructor
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ := by
  ext x
  simp only [mem_range, Path.symm, FunLike.coe, unitInterval.symm, SetCoe.exists, comp_apply,
    Subtype.coe_mk]
  constructor <;> 

Proof state:
case h.mp
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type u_3
γ✝ : Path x✝ y
a b : X
γ : Path a b
x : X
⊢ (∃ x_1,
      ∃ (h : x_1 ∈ I),
        ContinuousMap.toFun γ.toContinuousMap
            { val := 1 - x_1, property := (_ : 1 - ↑{ val := x_1, property := (_ : x_1 ∈ I) } ∈ I) } =
          x) →
    ∃ x_1, ∃ (h : x_1 ∈ I), ContinuousMap.toFun γ.toContinuousMap { val := x_1, property := h } = x

Next tactic:
rintro ⟨y, hy, hxy⟩
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ := by
  ext x
  simp only [mem_range, Path.symm, FunLike.coe, unitInterval.symm, SetCoe.exists, comp_apply,
    Subtype.coe_mk]
  constructor <;> 

Proof state:
case h.mpr
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y z : X
ι : Type u_3
γ✝ : Path x✝ y
a b : X
γ : Path a b
x : X
⊢ (∃ x_1, ∃ (h : x_1 ∈ I), ContinuousMap.toFun γ.toContinuousMap { val := x_1, property := h } = x) →
    ∃ x_1,
      ∃ (h : x_1 ∈ I),
        ContinuousMap.toFun γ.toContinuousMap
            { val := 1 - x_1, property := (_ : 1 - ↑{ val := x_1, property := (_ : x_1 ∈ I) } ∈ I) } =
          x

Next tactic:
rintro ⟨y, hy, hxy⟩
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ := by
  ext x
  simp only [mem_range, Path.symm, FunLike.coe, unitInterval.symm, SetCoe.exists, comp_apply,
    Subtype.coe_mk]
  constructor <;> rintro ⟨y, hy, hxy⟩ <;> 

Proof state:
case h.mp.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y✝ z : X
ι : Type u_3
γ✝ : Path x✝ y✝
a b : X
γ : Path a b
x : X
y : ℝ
hy : y ∈ I
hxy :
  ContinuousMap.toFun γ.toContinuousMap
      { val := 1 - y, property := (_ : 1 - ↑{ val := y, property := (_ : y ∈ I) } ∈ I) } =
    x
⊢ ∃ x_1, ∃ (h : x_1 ∈ I), ContinuousMap.toFun γ.toContinuousMap { val := x_1, property := h } = x

Next tactic:
refine' ⟨1 - y, mem_iff_one_sub_mem.mp hy, _⟩
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ := by
  ext x
  simp only [mem_range, Path.symm, FunLike.coe, unitInterval.symm, SetCoe.exists, comp_apply,
    Subtype.coe_mk]
  constructor <;> rintro ⟨y, hy, hxy⟩ <;> 

Proof state:
case h.mpr.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y✝ z : X
ι : Type u_3
γ✝ : Path x✝ y✝
a b : X
γ : Path a b
x : X
y : ℝ
hy : y ∈ I
hxy : ContinuousMap.toFun γ.toContinuousMap { val := y, property := hy } = x
⊢ ∃ x_1,
    ∃ (h : x_1 ∈ I),
      ContinuousMap.toFun γ.toContinuousMap
          { val := 1 - x_1, property := (_ : 1 - ↑{ val := x_1, property := (_ : x_1 ∈ I) } ∈ I) } =
        x

Next tactic:
refine' ⟨1 - y, mem_iff_one_sub_mem.mp hy, _⟩
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ := by
  ext x
  simp only [mem_range, Path.symm, FunLike.coe, unitInterval.symm, SetCoe.exists, comp_apply,
    Subtype.coe_mk]
  constructor <;> rintro ⟨y, hy, hxy⟩ <;> refine' ⟨1 - y, mem_iff_one_sub_mem.mp hy, _⟩ <;>
    

Proof state:
case h.mp.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y✝ z : X
ι : Type u_3
γ✝ : Path x✝ y✝
a b : X
γ : Path a b
x : X
y : ℝ
hy : y ∈ I
hxy :
  ContinuousMap.toFun γ.toContinuousMap
      { val := 1 - y, property := (_ : 1 - ↑{ val := y, property := (_ : y ∈ I) } ∈ I) } =
    x
⊢ ContinuousMap.toFun γ.toContinuousMap { val := 1 - y, property := (_ : 1 - y ∈ I) } = x

Next tactic:
convert hxy
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ := by
  ext x
  simp only [mem_range, Path.symm, FunLike.coe, unitInterval.symm, SetCoe.exists, comp_apply,
    Subtype.coe_mk]
  constructor <;> rintro ⟨y, hy, hxy⟩ <;> refine' ⟨1 - y, mem_iff_one_sub_mem.mp hy, _⟩ <;>
    

Proof state:
case h.mpr.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y✝ z : X
ι : Type u_3
γ✝ : Path x✝ y✝
a b : X
γ : Path a b
x : X
y : ℝ
hy : y ∈ I
hxy : ContinuousMap.toFun γ.toContinuousMap { val := y, property := hy } = x
⊢ ContinuousMap.toFun γ.toContinuousMap
      { val := 1 - (1 - y), property := (_ : 1 - ↑{ val := 1 - y, property := (_ : 1 - y ∈ I) } ∈ I) } =
    x

Next tactic:
convert hxy
@[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ := by
  ext x
  simp only [mem_range, Path.symm, FunLike.coe, unitInterval.symm, SetCoe.exists, comp_apply,
    Subtype.coe_mk]
  constructor <;> rintro ⟨y, hy, hxy⟩ <;> refine' ⟨1 - y, mem_iff_one_sub_mem.mp hy, _⟩ <;>
    convert hxy
  

Proof state:
case h.e'_2.h.e'_6.h.e'_3
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x✝ y✝ z : X
ι : Type u_3
γ✝ : Path x✝ y✝
a b : X
γ : Path a b
x : X
y : ℝ
hy : y ∈ I
hxy : ContinuousMap.toFun γ.toContinuousMap { val := y, property := hy } = x
⊢ 1 - (1 - y) = y

Next tactic:
simp
theorem extend_zero : γ.extend 0 = x := by 

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
⊢ extend γ 0 = x

Next tactic:
simp
theorem extend_one : γ.extend 1 = y := by 

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
⊢ extend γ 1 = y

Next tactic:
simp
/-- Concatenation of two paths from `x` to `y` and from `y` to `z`, putting the first
path on `[0, 1/2]` and the second one on `[1/2, 1]`. -/
@[trans]
def trans (γ : Path x y) (γ' : Path y z) : Path x z where
  toFun := (fun t : ℝ => if t ≤ 1 / 2 then γ.extend (2 * t) else γ'.extend (2 * t - 1)) ∘ (↑)
  continuous_toFun := by
    

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
⊢ Continuous ((fun t => if t ≤ 1 / 2 then extend γ (2 * t) else extend γ' (2 * t - 1)) ∘ Subtype.val)

Next tactic:
refine'
      (Continuous.if_le _ _ continuous_id continuous_const (by norm_num)).comp
        continuous_subtype_val
/-- Concatenation of two paths from `x` to `y` and from `y` to `z`, putting the first
path on `[0, 1/2]` and the second one on `[1/2, 1]`. -/
@[trans]
def trans (γ : Path x y) (γ' : Path y z) : Path x z where
  toFun := (fun t : ℝ => if t ≤ 1 / 2 then γ.extend (2 * t) else γ'.extend (2 * t - 1)) ∘ (↑)
  continuous_toFun := by
    refine'
      (Continuous.if_le _ _ continuous_id continuous_const (by 

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
⊢ ∀ (x_1 : ℝ), id x_1 = 1 / 2 → extend γ (2 * x_1) = extend γ' (2 * x_1 - 1)

Next tactic:
norm_num
/-- Concatenation of two paths from `x` to `y` and from `y` to `z`, putting the first
path on `[0, 1/2]` and the second one on `[1/2, 1]`. -/
@[trans]
def trans (γ : Path x y) (γ' : Path y z) : Path x z where
  toFun := (fun t : ℝ => if t ≤ 1 / 2 then γ.extend (2 * t) else γ'.extend (2 * t - 1)) ∘ (↑)
  continuous_toFun := by
    refine'
      (Continuous.if_le _ _ continuous_id continuous_const (by norm_num)).comp
        continuous_subtype_val <;>
    

Proof state:
case refine'_1
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
⊢ Continuous fun t => extend γ (2 * t)

Next tactic:
continuity
/-- Concatenation of two paths from `x` to `y` and from `y` to `z`, putting the first
path on `[0, 1/2]` and the second one on `[1/2, 1]`. -/
@[trans]
def trans (γ : Path x y) (γ' : Path y z) : Path x z where
  toFun := (fun t : ℝ => if t ≤ 1 / 2 then γ.extend (2 * t) else γ'.extend (2 * t - 1)) ∘ (↑)
  continuous_toFun := by
    refine'
      (Continuous.if_le _ _ continuous_id continuous_const (by norm_num)).comp
        continuous_subtype_val <;>
    

Proof state:
case refine'_2
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
⊢ Continuous fun t => extend γ' (2 * t - 1)

Next tactic:
continuity
/-- Concatenation of two paths from `x` to `y` and from `y` to `z`, putting the first
path on `[0, 1/2]` and the second one on `[1/2, 1]`. -/
@[trans]
def trans (γ : Path x y) (γ' : Path y z) : Path x z where
  toFun := (fun t : ℝ => if t ≤ 1 / 2 then γ.extend (2 * t) else γ'.extend (2 * t - 1)) ∘ (↑)
  continuous_toFun := by
    refine'
      (Continuous.if_le _ _ continuous_id continuous_const (by norm_num)).comp
        continuous_subtype_val <;>
    continuity
  source' := by 

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
⊢ ContinuousMap.toFun
      (ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ (2 * t) else extend γ' (2 * t - 1)) ∘ Subtype.val)) 0 =
    x

Next tactic:
norm_num
/-- Concatenation of two paths from `x` to `y` and from `y` to `z`, putting the first
path on `[0, 1/2]` and the second one on `[1/2, 1]`. -/
@[trans]
def trans (γ : Path x y) (γ' : Path y z) : Path x z where
  toFun := (fun t : ℝ => if t ≤ 1 / 2 then γ.extend (2 * t) else γ'.extend (2 * t - 1)) ∘ (↑)
  continuous_toFun := by
    refine'
      (Continuous.if_le _ _ continuous_id continuous_const (by norm_num)).comp
        continuous_subtype_val <;>
    continuity
  source' := by norm_num
  target' := by 

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
⊢ ContinuousMap.toFun
      (ContinuousMap.mk ((fun t => if t ≤ 1 / 2 then extend γ (2 * t) else extend γ' (2 * t - 1)) ∘ Subtype.val)) 1 =
    z

Next tactic:
norm_num
theorem trans_apply (γ : Path x y) (γ' : Path y z) (t : I) :
    (γ.trans γ') t =
      if h : (t : ℝ) ≤ 1 / 2 then γ ⟨2 * t, (mul_pos_mem_iff zero_lt_two).2 ⟨t.2.1, h⟩⟩
      else γ' ⟨2 * t - 1, two_mul_sub_one_mem_iff.2 ⟨(not_le.1 h).le, t.2.2⟩⟩ :=
  show ite _ _ _ = _ by 

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
⊢ (if ↑t ≤ 1 / 2 then extend γ (2 * ↑t) else extend γ' (2 * ↑t - 1)) =
    if h : ↑t ≤ 1 / 2 then γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
    else γ' { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) }

Next tactic:
split_ifs
theorem trans_apply (γ : Path x y) (γ' : Path y z) (t : I) :
    (γ.trans γ') t =
      if h : (t : ℝ) ≤ 1 / 2 then γ ⟨2 * t, (mul_pos_mem_iff zero_lt_two).2 ⟨t.2.1, h⟩⟩
      else γ' ⟨2 * t - 1, two_mul_sub_one_mem_iff.2 ⟨(not_le.1 h).le, t.2.2⟩⟩ :=
  show ite _ _ _ = _ by split_ifs <;> 

Proof state:
case pos
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ↑t ≤ 1 / 2
⊢ extend γ (2 * ↑t) = γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }

Next tactic:
rw [extend_extends]
theorem trans_apply (γ : Path x y) (γ' : Path y z) (t : I) :
    (γ.trans γ') t =
      if h : (t : ℝ) ≤ 1 / 2 then γ ⟨2 * t, (mul_pos_mem_iff zero_lt_two).2 ⟨t.2.1, h⟩⟩
      else γ' ⟨2 * t - 1, two_mul_sub_one_mem_iff.2 ⟨(not_le.1 h).le, t.2.2⟩⟩ :=
  show ite _ _ _ = _ by split_ifs <;> 

Proof state:
case neg
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ¬↑t ≤ 1 / 2
⊢ extend γ' (2 * ↑t - 1) = γ' { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) }

Next tactic:
rw [extend_extends]
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
⊢ symm (trans γ γ') = trans (symm γ') (symm γ)

Next tactic:
ext t
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  

Proof state:
case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
⊢ (symm (trans γ γ')) t = (trans (symm γ') (symm γ)) t

Next tactic:
simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  

Proof state:
case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
⊢ (if h : ↑(σ t) ≤ 1 / 2 then γ { val := 2 * ↑(σ t), property := (_ : 2 * ↑(σ t) ∈ I) }
    else γ' { val := 2 * ↑(σ t) - 1, property := (_ : 2 * ↑(σ t) - 1 ∈ I) }) =
    if h : ↑t ≤ 1 / 2 then γ' (σ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) })
    else γ (σ { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) })

Next tactic:
split_ifs with h h₁ h₂
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> 

Proof state:
case pos
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h : ↑(σ t) ≤ 1 / 2
h₁ : ↑t ≤ 1 / 2
⊢ γ { val := 2 * ↑(σ t), property := (_ : 2 * ↑(σ t) ∈ I) } = γ' (σ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) })

Next tactic:
rw [coe_symm_eq] at h
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> 

Proof state:
case neg
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h : ↑(σ t) ≤ 1 / 2
h₁ : ¬↑t ≤ 1 / 2
⊢ γ { val := 2 * ↑(σ t), property := (_ : 2 * ↑(σ t) ∈ I) } =
    γ (σ { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) })

Next tactic:
rw [coe_symm_eq] at h
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> 

Proof state:
case pos
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h : ¬↑(σ t) ≤ 1 / 2
h₂ : ↑t ≤ 1 / 2
⊢ γ' { val := 2 * ↑(σ t) - 1, property := (_ : 2 * ↑(σ t) - 1 ∈ I) } =
    γ' (σ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) })

Next tactic:
rw [coe_symm_eq] at h
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> 

Proof state:
case neg
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h : ¬↑(σ t) ≤ 1 / 2
h₂ : ¬↑t ≤ 1 / 2
⊢ γ' { val := 2 * ↑(σ t) - 1, property := (_ : 2 * ↑(σ t) - 1 ∈ I) } =
    γ (σ { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) })

Next tactic:
rw [coe_symm_eq] at h
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> rw [coe_symm_eq] at h
  · 

Proof state:
case pos
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ↑(σ t) ≤ 1 / 2
h : 1 - ↑t ≤ 1 / 2
h₁ : ↑t ≤ 1 / 2
⊢ γ { val := 2 * ↑(σ t), property := (_ : 2 * ↑(σ t) ∈ I) } = γ' (σ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) })

Next tactic:
have ht : (t : ℝ) = 1 / 2 := by linarith
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> rw [coe_symm_eq] at h
  · have ht : (t : ℝ) = 1 / 2 := by 

Proof state:
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ↑(σ t) ≤ 1 / 2
h : 1 - ↑t ≤ 1 / 2
h₁ : ↑t ≤ 1 / 2
⊢ ↑t = 1 / 2

Next tactic:
linarith
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> rw [coe_symm_eq] at h
  · have ht : (t : ℝ) = 1 / 2 := by linarith
    

Proof state:
case pos
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ↑(σ t) ≤ 1 / 2
h : 1 - ↑t ≤ 1 / 2
h₁ : ↑t ≤ 1 / 2
ht : ↑t = 1 / 2
⊢ γ { val := 2 * ↑(σ t), property := (_ : 2 * ↑(σ t) ∈ I) } = γ' (σ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) })

Next tactic:
norm_num [ht]
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> rw [coe_symm_eq] at h
  · have ht : (t : ℝ) = 1 / 2 := by linarith
    norm_num [ht]
  · 

Proof state:
case neg
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ↑(σ t) ≤ 1 / 2
h : 1 - ↑t ≤ 1 / 2
h₁ : ¬↑t ≤ 1 / 2
⊢ γ { val := 2 * ↑(σ t), property := (_ : 2 * ↑(σ t) ∈ I) } =
    γ (σ { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) })

Next tactic:
refine' congr_arg _ (Subtype.ext _)
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> rw [coe_symm_eq] at h
  · have ht : (t : ℝ) = 1 / 2 := by linarith
    norm_num [ht]
  · refine' congr_arg _ (Subtype.ext _)
    

Proof state:
case neg
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ↑(σ t) ≤ 1 / 2
h : 1 - ↑t ≤ 1 / 2
h₁ : ¬↑t ≤ 1 / 2
⊢ ↑{ val := 2 * ↑(σ t), property := (_ : 2 * ↑(σ t) ∈ I) } =
    ↑(σ { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) })

Next tactic:
norm_num [sub_sub_eq_add_sub, mul_sub]
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> rw [coe_symm_eq] at h
  · have ht : (t : ℝ) = 1 / 2 := by linarith
    norm_num [ht]
  · refine' congr_arg _ (Subtype.ext _)
    norm_num [sub_sub_eq_add_sub, mul_sub]
  · 

Proof state:
case pos
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ¬↑(σ t) ≤ 1 / 2
h : ¬1 - ↑t ≤ 1 / 2
h₂ : ↑t ≤ 1 / 2
⊢ γ' { val := 2 * ↑(σ t) - 1, property := (_ : 2 * ↑(σ t) - 1 ∈ I) } =
    γ' (σ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) })

Next tactic:
refine' congr_arg _ (Subtype.ext _)
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> rw [coe_symm_eq] at h
  · have ht : (t : ℝ) = 1 / 2 := by linarith
    norm_num [ht]
  · refine' congr_arg _ (Subtype.ext _)
    norm_num [sub_sub_eq_add_sub, mul_sub]
  · refine' congr_arg _ (Subtype.ext _)
    

Proof state:
case pos
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ¬↑(σ t) ≤ 1 / 2
h : ¬1 - ↑t ≤ 1 / 2
h₂ : ↑t ≤ 1 / 2
⊢ ↑{ val := 2 * ↑(σ t) - 1, property := (_ : 2 * ↑(σ t) - 1 ∈ I) } =
    ↑(σ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) })

Next tactic:
norm_num [mul_sub, h]
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> rw [coe_symm_eq] at h
  · have ht : (t : ℝ) = 1 / 2 := by linarith
    norm_num [ht]
  · refine' congr_arg _ (Subtype.ext _)
    norm_num [sub_sub_eq_add_sub, mul_sub]
  · refine' congr_arg _ (Subtype.ext _)
    norm_num [mul_sub, h]
    

Proof state:
case pos
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ¬↑(σ t) ≤ 1 / 2
h : ¬1 - ↑t ≤ 1 / 2
h₂ : ↑t ≤ 1 / 2
⊢ 2 - 2 * ↑t - 1 = 1 - 2 * ↑t

Next tactic:
ring
@[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm := by
  ext t
  simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
  split_ifs with h h₁ h₂ <;> rw [coe_symm_eq] at h
  · have ht : (t : ℝ) = 1 / 2 := by linarith
    norm_num [ht]
  · refine' congr_arg _ (Subtype.ext _)
    norm_num [sub_sub_eq_add_sub, mul_sub]
  · refine' congr_arg _ (Subtype.ext _)
    norm_num [mul_sub, h]
    ring -- TODO norm_num should really do this
  · 

Proof state:
case neg
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ¬↑(σ t) ≤ 1 / 2
h : ¬1 - ↑t ≤ 1 / 2
h₂ : ¬↑t ≤ 1 / 2
⊢ γ' { val := 2 * ↑(σ t) - 1, property := (_ : 2 * ↑(σ t) - 1 ∈ I) } =
    γ (σ { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) })

Next tactic:
exfalso