Theorem: Path.Homotopy.trans_assoc_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₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
⊢ Continuous fun t => { val := transAssocReparamAux t, property := (_ : transAssocReparamAux t ∈ I) }

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

tactic: simp only [transAssocReparamAux, Path.trans_apply, mul_inv_cancel_left₀, not_le,
  Function.comp_apply, Ne.def, not_false_iff, bit0_eq_zero, one_ne_zero, mul_ite, Subtype.coe_mk,
  Path.coe_reparam]
state_before: case a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
⊢ ↑(Path.trans (Path.trans p q) r) x =
    ↑(Path.reparam (Path.trans p (Path.trans q r))
          (fun t => { val := transAssocReparamAux t, property := (_ : transAssocReparamAux t ∈ I) })
          (_ : Continuous fun x => { val := transAssocReparamAux x, property := (_ : transAssocReparamAux x ∈ I) })
          (_ : (fun t => { val := transAssocReparamAux t, property := (_ : transAssocReparamAux t ∈ I) }) 0 = 0)
          (_ : (fun t => { val := transAssocReparamAux t, property := (_ : transAssocReparamAux t ∈ I) }) 1 = 1))
      x

tactic: split_ifs with h₁ h₂ h₃ h₄ h₅
state_before: case a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
⊢ (if h : ↑x ≤ 1 / 2 then
      if h_1 : 2 * ↑x ≤ 1 / 2 then
        ↑p { val := 2 * (2 * ↑x), property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } ∈ I) }
      else
        ↑q { val := 2 * (2 * ↑x) - 1, property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } - 1 ∈ I) }
    else ↑r { val := 2 * ↑x - 1, property := (_ : 2 * ↑x - 1 ∈ I) }) =
    if h : (if ↑x ≤ 1 / 4 then 2 * ↑x else if ↑x ≤ 1 / 2 then ↑x + 1 / 4 else 1 / 2 * (↑x + 1)) ≤ 1 / 2 then
      ↑p
        { val := if ↑x ≤ 1 / 4 then 2 * (2 * ↑x) else if ↑x ≤ 1 / 2 then 2 * (↑x + 1 / 4) else 2 * (1 / 2 * (↑x + 1)),
          property :=
            (_ :
              (fun x => x ∈ I)
                (if ↑x ≤ 1 / 4 then 2 * (2 * ↑x)
                else if ↑x ≤ 1 / 2 then 2 * (↑x + 1 / 4) else 2 * (1 / 2 * (↑x + 1)))) }
    else
      if h_1 :
          (if ↑x ≤ 1 / 4 then 2 * (2 * ↑x) else if ↑x ≤ 1 / 2 then 2 * (↑x + 1 / 4) else 2 * (1 / 2 * (↑x + 1))) - 1 ≤
            1 / 2 then
        ↑q
          {
            val :=
              2 *
                ((if ↑x ≤ 1 / 4 then 2 * (2 * ↑x)
                  else if ↑x ≤ 1 / 2 then 2 * (↑x + 1 / 4) else 2 * (1 / 2 * (↑x + 1))) -
                  1),
            property :=
              (_ :
                2 *
                    ↑{
                        val :=
                          (if ↑x ≤ 1 / 4 then 2 * (2 * ↑x)
                            else if ↑x ≤ 1 / 2 then 2 * (↑x + 1 / 4) else 2 * (1 / 2 * (↑x + 1))) -
                            1,
                        property :=
                          (_ :
                            (fun x => x ∈ I)
                              ((if ↑x ≤ 1 / 4 then 2 * (2 * ↑x)
                                else if ↑x ≤ 1 / 2 then 2 * (↑x + 1 / 4) else 2 * (1 / 2 * (↑x + 1))) -
                                1)) } ∈
                  I) }
      else
        ↑r
          {
            val :=
              2 *
                  ((if ↑x ≤ 1 / 4 then 2 * (2 * ↑x)
                    else if ↑x ≤ 1 / 2 then 2 * (↑x + 1 / 4) else 2 * (1 / 2 * (↑x + 1))) -
                    1) -
                1,
            property :=
              (_ :
                2 *
                      ↑{
                          val :=
                            (if ↑x ≤ 1 / 4 then 2 * (2 * ↑x)
                              else if ↑x ≤ 1 / 2 then 2 * (↑x + 1 / 4) else 2 * (1 / 2 * (↑x + 1))) -
                              1,
                          property :=
                            (_ :
                              (fun x => x ∈ I)
                                ((if ↑x ≤ 1 / 4 then 2 * (2 * ↑x)
                                  else if ↑x ≤ 1 / 2 then 2 * (↑x + 1 / 4) else 2 * (1 / 2 * (↑x + 1))) -
                                  1)) } -
                    1 ∈
                  I) }

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

tactic: exfalso
state_before: case a.h.inl.inl.inr.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : 2 * ↑x ≤ 1 / 2
h₃ : ¬↑x ≤ 1 / 4
h₄ : ↑x + 1 / 4 ≤ 1 / 2
⊢ ↑p { val := 2 * (2 * ↑x), property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } ∈ I) } =
    ↑p { val := 2 * (↑x + 1 / 4), property := (_ : (fun x => x ∈ I) (2 * (↑x + 1 / 4))) }

tactic: linarith
state_before: case a.h.inl.inl.inr.inl.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : 2 * ↑x ≤ 1 / 2
h₃ : ¬↑x ≤ 1 / 4
h₄ : ↑x + 1 / 4 ≤ 1 / 2
⊢ False

tactic: exfalso
state_before: case a.h.inl.inl.inr.inr.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : 2 * ↑x ≤ 1 / 2
h₃ : ¬↑x ≤ 1 / 4
h₄ : ¬↑x + 1 / 4 ≤ 1 / 2
h₅ : 2 * (↑x + 1 / 4) - 1 ≤ 1 / 2
⊢ ↑p { val := 2 * (2 * ↑x), property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } ∈ I) } =
    ↑q { val := 2 * (2 * (↑x + 1 / 4) - 1), property := (_ : (fun x => x ∈ I) (2 * (2 * (↑x + 1 / 4) - 1))) }

tactic: linarith
state_before: case a.h.inl.inl.inr.inr.inl.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : 2 * ↑x ≤ 1 / 2
h₃ : ¬↑x ≤ 1 / 4
h₄ : ¬↑x + 1 / 4 ≤ 1 / 2
h₅ : 2 * (↑x + 1 / 4) - 1 ≤ 1 / 2
⊢ False

tactic: exfalso
state_before: case a.h.inl.inl.inr.inr.inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : 2 * ↑x ≤ 1 / 2
h₃ : ¬↑x ≤ 1 / 4
h₄ : ¬↑x + 1 / 4 ≤ 1 / 2
h₅ : ¬2 * (↑x + 1 / 4) - 1 ≤ 1 / 2
⊢ ↑p { val := 2 * (2 * ↑x), property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } ∈ I) } =
    ↑r { val := 2 * (2 * (↑x + 1 / 4) - 1) - 1, property := (_ : (fun x => x ∈ I) (2 * (2 * (↑x + 1 / 4) - 1) - 1)) }

tactic: linarith
state_before: case a.h.inl.inl.inr.inr.inr.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : 2 * ↑x ≤ 1 / 2
h₃ : ¬↑x ≤ 1 / 4
h₄ : ¬↑x + 1 / 4 ≤ 1 / 2
h₅ : ¬2 * (↑x + 1 / 4) - 1 ≤ 1 / 2
⊢ False

tactic: exfalso
state_before: case a.h.inl.inr.inl.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝¹ : ↑x ≤ 1 / 4
h✝ : 2 * (2 * ↑x) - 1 ≤ 1 / 2
⊢ ↑q { val := 2 * (2 * ↑x) - 1, property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } - 1 ∈ I) } =
    ↑q { val := 2 * (2 * (2 * ↑x) - 1), property := (_ : (fun x => x ∈ I) (2 * (2 * (2 * ↑x) - 1))) }

tactic: linarith
state_before: case a.h.inl.inr.inl.inl.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝¹ : ↑x ≤ 1 / 4
h✝ : 2 * (2 * ↑x) - 1 ≤ 1 / 2
⊢ False

tactic: exfalso
state_before: case a.h.inl.inr.inl.inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝¹ : ↑x ≤ 1 / 4
h✝ : ¬2 * (2 * ↑x) - 1 ≤ 1 / 2
⊢ ↑q { val := 2 * (2 * ↑x) - 1, property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } - 1 ∈ I) } =
    ↑r { val := 2 * (2 * (2 * ↑x) - 1) - 1, property := (_ : (fun x => x ∈ I) (2 * (2 * (2 * ↑x) - 1) - 1)) }

tactic: linarith
state_before: case a.h.inl.inr.inl.inr.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝¹ : ↑x ≤ 1 / 4
h✝ : ¬2 * (2 * ↑x) - 1 ≤ 1 / 2
⊢ False

tactic: exfalso
state_before: case a.h.inl.inr.inr.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝¹ : ¬↑x ≤ 1 / 4
h✝ : ↑x + 1 / 4 ≤ 1 / 2
⊢ ↑q { val := 2 * (2 * ↑x) - 1, property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } - 1 ∈ I) } =
    ↑p { val := 2 * (↑x + 1 / 4), property := (_ : (fun x => x ∈ I) (2 * (↑x + 1 / 4))) }

tactic: linarith
state_before: case a.h.inl.inr.inr.inl.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝¹ : ¬↑x ≤ 1 / 4
h✝ : ↑x + 1 / 4 ≤ 1 / 2
⊢ False

tactic: have h : 2 * (2 * (x : ℝ)) - 1 = 2 * (2 * (↑x + 1 / 4) - 1) := by linarith
state_before: case a.h.inl.inr.inr.inr.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝² : ¬↑x ≤ 1 / 4
h✝¹ : ¬↑x + 1 / 4 ≤ 1 / 2
h✝ : 2 * (↑x + 1 / 4) - 1 ≤ 1 / 2
⊢ ↑q { val := 2 * (2 * ↑x) - 1, property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } - 1 ∈ I) } =
    ↑q { val := 2 * (2 * (↑x + 1 / 4) - 1), property := (_ : (fun x => x ∈ I) (2 * (2 * (↑x + 1 / 4) - 1))) }

tactic: simp [h₂, h₁, h, dif_neg (show ¬False from id), dif_pos True.intro, if_false, if_true]
state_before: case a.h.inl.inr.inr.inr.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝² : ¬↑x ≤ 1 / 4
h✝¹ : ¬↑x + 1 / 4 ≤ 1 / 2
h✝ : 2 * (↑x + 1 / 4) - 1 ≤ 1 / 2
h : 2 * (2 * ↑x) - 1 = 2 * (2 * (↑x + 1 / 4) - 1)
⊢ ↑q { val := 2 * (2 * ↑x) - 1, property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } - 1 ∈ I) } =
    ↑q { val := 2 * (2 * (↑x + 1 / 4) - 1), property := (_ : (fun x => x ∈ I) (2 * (2 * (↑x + 1 / 4) - 1))) }

tactic: linarith
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝² : ¬↑x ≤ 1 / 4
h✝¹ : ¬↑x + 1 / 4 ≤ 1 / 2
h✝ : 2 * (↑x + 1 / 4) - 1 ≤ 1 / 2
⊢ 2 * (2 * ↑x) - 1 = 2 * (2 * (↑x + 1 / 4) - 1)

tactic: exfalso
state_before: case a.h.inl.inr.inr.inr.inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝² : ¬↑x ≤ 1 / 4
h✝¹ : ¬↑x + 1 / 4 ≤ 1 / 2
h✝ : ¬2 * (↑x + 1 / 4) - 1 ≤ 1 / 2
⊢ ↑q { val := 2 * (2 * ↑x) - 1, property := (_ : 2 * ↑{ val := 2 * ↑x, property := (_ : 2 * ↑x ∈ I) } - 1 ∈ I) } =
    ↑r { val := 2 * (2 * (↑x + 1 / 4) - 1) - 1, property := (_ : (fun x => x ∈ I) (2 * (2 * (↑x + 1 / 4) - 1) - 1)) }

tactic: linarith
state_before: case a.h.inl.inr.inr.inr.inr.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ↑x ≤ 1 / 2
h₂ : ¬2 * ↑x ≤ 1 / 2
h✝² : ¬↑x ≤ 1 / 4
h✝¹ : ¬↑x + 1 / 4 ≤ 1 / 2
h✝ : ¬2 * (↑x + 1 / 4) - 1 ≤ 1 / 2
⊢ False

tactic: exfalso
state_before: case a.h.inr.inl.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝¹ : ↑x ≤ 1 / 4
h✝ : 2 * ↑x ≤ 1 / 2
⊢ ↑r { val := 2 * ↑x - 1, property := (_ : 2 * ↑x - 1 ∈ I) } =
    ↑p { val := 2 * (2 * ↑x), property := (_ : (fun x => x ∈ I) (2 * (2 * ↑x))) }

tactic: linarith
state_before: case a.h.inr.inl.inl.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝¹ : ↑x ≤ 1 / 4
h✝ : 2 * ↑x ≤ 1 / 2
⊢ False

tactic: exfalso
state_before: case a.h.inr.inl.inr.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝² : ↑x ≤ 1 / 4
h✝¹ : ¬2 * ↑x ≤ 1 / 2
h✝ : 2 * (2 * ↑x) - 1 ≤ 1 / 2
⊢ ↑r { val := 2 * ↑x - 1, property := (_ : 2 * ↑x - 1 ∈ I) } =
    ↑q { val := 2 * (2 * (2 * ↑x) - 1), property := (_ : (fun x => x ∈ I) (2 * (2 * (2 * ↑x) - 1))) }

tactic: linarith
state_before: case a.h.inr.inl.inr.inl.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝² : ↑x ≤ 1 / 4
h✝¹ : ¬2 * ↑x ≤ 1 / 2
h✝ : 2 * (2 * ↑x) - 1 ≤ 1 / 2
⊢ False

tactic: exfalso
state_before: case a.h.inr.inl.inr.inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝² : ↑x ≤ 1 / 4
h✝¹ : ¬2 * ↑x ≤ 1 / 2
h✝ : ¬2 * (2 * ↑x) - 1 ≤ 1 / 2
⊢ ↑r { val := 2 * ↑x - 1, property := (_ : 2 * ↑x - 1 ∈ I) } =
    ↑r { val := 2 * (2 * (2 * ↑x) - 1) - 1, property := (_ : (fun x => x ∈ I) (2 * (2 * (2 * ↑x) - 1) - 1)) }

tactic: linarith
state_before: case a.h.inr.inl.inr.inr.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝² : ↑x ≤ 1 / 4
h✝¹ : ¬2 * ↑x ≤ 1 / 2
h✝ : ¬2 * (2 * ↑x) - 1 ≤ 1 / 2
⊢ False

tactic: exfalso
state_before: case a.h.inr.inr.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝¹ : ¬↑x ≤ 1 / 4
h✝ : 1 / 2 * (↑x + 1) ≤ 1 / 2
⊢ ↑r { val := 2 * ↑x - 1, property := (_ : 2 * ↑x - 1 ∈ I) } =
    ↑p { val := 2 * (1 / 2 * (↑x + 1)), property := (_ : (fun x => x ∈ I) (2 * (1 / 2 * (↑x + 1)))) }

tactic: linarith
state_before: case a.h.inr.inr.inl.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝¹ : ¬↑x ≤ 1 / 4
h✝ : 1 / 2 * (↑x + 1) ≤ 1 / 2
⊢ False

tactic: exfalso
state_before: case a.h.inr.inr.inr.inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝² : ¬↑x ≤ 1 / 4
h✝¹ : ¬1 / 2 * (↑x + 1) ≤ 1 / 2
h✝ : 2 * (1 / 2 * (↑x + 1)) - 1 ≤ 1 / 2
⊢ ↑r { val := 2 * ↑x - 1, property := (_ : 2 * ↑x - 1 ∈ I) } =
    ↑q
      { val := 2 * (2 * (1 / 2 * (↑x + 1)) - 1), property := (_ : (fun x => x ∈ I) (2 * (2 * (1 / 2 * (↑x + 1)) - 1))) }

tactic: linarith
state_before: case a.h.inr.inr.inr.inl.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝² : ¬↑x ≤ 1 / 4
h✝¹ : ¬1 / 2 * (↑x + 1) ≤ 1 / 2
h✝ : 2 * (1 / 2 * (↑x + 1)) - 1 ≤ 1 / 2
⊢ False

tactic: simp only [h₁, if_false, dif_neg (show ¬False from id)]
state_before: case a.h.inr.inr.inr.inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝² : ¬↑x ≤ 1 / 4
h✝¹ : ¬1 / 2 * (↑x + 1) ≤ 1 / 2
h✝ : ¬2 * (1 / 2 * (↑x + 1)) - 1 ≤ 1 / 2
⊢ ↑r { val := 2 * ↑x - 1, property := (_ : 2 * ↑x - 1 ∈ I) } =
    ↑r
      { val := 2 * (2 * (1 / 2 * (↑x + 1)) - 1) - 1,
        property := (_ : (fun x => x ∈ I) (2 * (2 * (1 / 2 * (↑x + 1)) - 1) - 1)) }

tactic: congr
state_before: case a.h.inr.inr.inr.inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝² : ¬↑x ≤ 1 / 4
h✝¹ : ¬1 / 2 * (↑x + 1) ≤ 1 / 2
h✝ : ¬2 * (1 / 2 * (↑x + 1)) - 1 ≤ 1 / 2
⊢ ↑r { val := 2 * ↑x - 1, property := (_ : 2 * ↑x - 1 ∈ I) } =
    ↑r
      { val := 2 * (2 * (1 / 2 * (↑x + 1)) - 1) - 1,
        property := (_ : (fun x => x ∈ I) (2 * (2 * (1 / 2 * (↑x + 1)) - 1) - 1)) }

tactic: ring
state_before: case a.h.inr.inr.inr.inr.h.e_6.h.e_val.e_a.e_a
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀✝ x₁✝ x₀ x₁ x₂ x₃ : X
p : Path x₀ x₁
q : Path x₁ x₂
r : Path x₂ x₃
x : ↑I
h₁ : ¬↑x ≤ 1 / 2
h✝² : ¬↑x ≤ 1 / 4
h✝¹ : ¬1 / 2 * (↑x + 1) ≤ 1 / 2
h✝ : ¬2 * (1 / 2 * (↑x + 1)) - 1 ≤ 1 / 2
⊢ ↑x = 2 * (1 / 2 * (↑x + 1)) - 1