Theorem: Path.Homotopy.trans_refl_reparam
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

tactic: continuity
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p : Path x₀ x₁
⊢ Continuous fun t => { val := transReflReparamAux t, property := (_ : transReflReparamAux t ∈ I) }

tactic: ext
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p : Path x₀ x₁
⊢ Path.trans p (Path.refl x₁) =
    Path.reparam p (fun t => { val := transReflReparamAux t, property := (_ : transReflReparamAux t ∈ I) })
      (_ : Continuous fun x => { val := transReflReparamAux x, property := (_ : transReflReparamAux x ∈ I) })
      (_ : (fun t => { val := transReflReparamAux t, property := (_ : transReflReparamAux t ∈ I) }) 0 = 0)
      (_ : (fun t => { val := transReflReparamAux t, property := (_ : transReflReparamAux t ∈ I) }) 1 = 1)

tactic: unfold transReflReparamAux
state_before: case a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p : Path x₀ x₁
x✝ : ↑I
⊢ ↑(Path.trans p (Path.refl x₁)) x✝ =
    ↑(Path.reparam p (fun t => { val := transReflReparamAux t, property := (_ : transReflReparamAux t ∈ I) })
          (_ : Continuous fun x => { val := transReflReparamAux x, property := (_ : transReflReparamAux x ∈ I) })
          (_ : (fun t => { val := transReflReparamAux t, property := (_ : transReflReparamAux t ∈ I) }) 0 = 0)
          (_ : (fun t => { val := transReflReparamAux t, property := (_ : transReflReparamAux t ∈ I) }) 1 = 1))
      x✝

tactic: simp only [Path.trans_apply, not_le, coe_reparam, Function.comp_apply, one_div, Path.refl_apply]
state_before: case a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p : Path x₀ x₁
x✝ : ↑I
⊢ ↑(Path.trans p (Path.refl x₁)) x✝ =
    ↑(Path.reparam p (fun t => { val := if ↑t ≤ 1 / 2 then 2 * ↑t else 1, property := (_ : transReflReparamAux t ∈ I) })
          (_ :
            Continuous fun x =>
              { val := if ↑x ≤ 1 / 2 then 2 * ↑x else 1, property := (_ : transReflReparamAux x ∈ I) })
          (_ :
            (fun t => { val := if ↑t ≤ 1 / 2 then 2 * ↑t else 1, property := (_ : transReflReparamAux t ∈ I) }) 0 = 0)
          (_ :
            (fun t => { val := if ↑t ≤ 1 / 2 then 2 * ↑t else 1, property := (_ : transReflReparamAux t ∈ I) }) 1 = 1))
      x✝

tactic: split_ifs
state_before: case a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p : Path x₀ x₁
x✝ : ↑I
⊢ (if h : ↑x✝ ≤ 2⁻¹ then ↑p { val := 2 * ↑x✝, property := (_ : 2 * ↑x✝ ∈ I) } else x₁) =
    ↑p
      { val := if ↑x✝ ≤ 2⁻¹ then 2 * ↑x✝ else 1, property := (_ : (fun x => x ∈ I) (if ↑x✝ ≤ 2⁻¹ then 2 * ↑x✝ else 1)) }

tactic: rfl
state_before: case a.h.inl.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p : Path x₀ x₁
x✝ : ↑I
h✝¹ : ↑x✝ ≤ 2⁻¹
h✝ : ↑x✝ ≤ 2⁻¹
⊢ ↑p { val := 2 * ↑x✝, property := (_ : 2 * ↑x✝ ∈ I) } =
    ↑p { val := 2 * ↑x✝, property := (_ : (fun x => x ∈ I) (2 * ↑x✝)) }

tactic: rfl
state_before: case a.h.inl.inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p : Path x₀ x₁
x✝ : ↑I
h✝¹ : ↑x✝ ≤ 2⁻¹
h✝ : ¬↑x✝ ≤ 2⁻¹
⊢ ↑p { val := 2 * ↑x✝, property := (_ : 2 * ↑x✝ ∈ I) } =
    ↑p { val := 2 * ↑x✝, property := (_ : (fun x => x ∈ I) (2 * ↑x✝)) }

tactic: simp
state_before: case a.h.inr.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p : Path x₀ x₁
x✝ : ↑I
h✝¹ : ¬↑x✝ ≤ 2⁻¹
h✝ : ↑x✝ ≤ 2⁻¹
⊢ x₁ = ↑p { val := 1, property := (_ : (fun x => x ∈ I) 1) }

tactic: simp
state_before: case a.h.inr.inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
p : Path x₀ x₁
x✝ : ↑I
h✝¹ : ¬↑x✝ ≤ 2⁻¹
h✝ : ¬↑x✝ ≤ 2⁻¹
⊢ x₁ = ↑p { val := 1, property := (_ : (fun x => x ∈ I) 1) }