[GOAL]
b : Bool
h : Decidable (b = true)
⊢ decide (b = true) = b
[PROOFSTEP]
cases b
[GOAL]
case false
h : Decidable (false = true)
⊢ decide (false = true) = false
[PROOFSTEP]
exact decide_eq_false $ λ j => by cases j
[GOAL]
h : Decidable (false = true)
j : false = true
⊢ False
[PROOFSTEP]
cases j
[GOAL]
case true
h : Decidable (true = true)
⊢ decide (true = true) = true
[PROOFSTEP]
exact decide_eq_true $ rfl
[GOAL]
p : Prop
inst✝ : Decidable p
⊢ (decide ¬p) = !decide p
[PROOFSTEP]
by_cases p
[GOAL]
p : Prop
inst✝ : Decidable p
⊢ (decide ¬p) = !decide p
[PROOFSTEP]
by_cases p
[GOAL]
case pos
p : Prop
inst✝ : Decidable p
h : p
⊢ (decide ¬p) = !decide p
[PROOFSTEP]
simp [*]
[GOAL]
case neg
p : Prop
inst✝ : Decidable p
h : ¬p
⊢ (decide ¬p) = !decide p
[PROOFSTEP]
simp [*]
[GOAL]
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
⊢ decide (p ∧ q) = (decide p && decide q)
[PROOFSTEP]
by_cases p
[GOAL]
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
⊢ decide (p ∧ q) = (decide p && decide q)
[PROOFSTEP]
by_cases p
[GOAL]
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h : p
⊢ decide (p ∧ q) = (decide p && decide q)
[PROOFSTEP]
by_cases q
[GOAL]
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h : p
⊢ decide (p ∧ q) = (decide p && decide q)
[PROOFSTEP]
by_cases q
[GOAL]
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h : ¬p
⊢ decide (p ∧ q) = (decide p && decide q)
[PROOFSTEP]
by_cases q
[GOAL]
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h : ¬p
⊢ decide (p ∧ q) = (decide p && decide q)
[PROOFSTEP]
by_cases q
[GOAL]
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝ : p
h : q
⊢ decide (p ∧ q) = (decide p && decide q)
[PROOFSTEP]
simp [*]
[GOAL]
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝ : p
h : ¬q
⊢ decide (p ∧ q) = (decide p && decide q)
[PROOFSTEP]
simp [*]
[GOAL]
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝ : ¬p
h : q
⊢ decide (p ∧ q) = (decide p && decide q)
[PROOFSTEP]
simp [*]
[GOAL]
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝ : ¬p
h : ¬q
⊢ decide (p ∧ q) = (decide p && decide q)
[PROOFSTEP]
simp [*]
[GOAL]
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
⊢ decide (p ∨ q) = (decide p || decide q)
[PROOFSTEP]
by_cases p
[GOAL]
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
⊢ decide (p ∨ q) = (decide p || decide q)
[PROOFSTEP]
by_cases p
[GOAL]
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h : p
⊢ decide (p ∨ q) = (decide p || decide q)
[PROOFSTEP]
by_cases q
[GOAL]
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h : p
⊢ decide (p ∨ q) = (decide p || decide q)
[PROOFSTEP]
by_cases q
[GOAL]
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h : ¬p
⊢ decide (p ∨ q) = (decide p || decide q)
[PROOFSTEP]
by_cases q
[GOAL]
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h : ¬p
⊢ decide (p ∨ q) = (decide p || decide q)
[PROOFSTEP]
by_cases q
[GOAL]
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝ : p
h : q
⊢ decide (p ∨ q) = (decide p || decide q)
[PROOFSTEP]
simp [*]
[GOAL]
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝ : p
h : ¬q
⊢ decide (p ∨ q) = (decide p || decide q)
[PROOFSTEP]
simp [*]
[GOAL]
case pos
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝ : ¬p
h : q
⊢ decide (p ∨ q) = (decide p || decide q)
[PROOFSTEP]
simp [*]
[GOAL]
case neg
p q : Prop
inst✝¹ : Decidable p
inst✝ : Decidable q
h✝ : ¬p
h : ¬q
⊢ decide (p ∨ q) = (decide p || decide q)
[PROOFSTEP]
simp [*]
[GOAL]
a b : Bool
⊢ a = b ↔ (a = true ↔ b = true)
[PROOFSTEP]
cases a
[GOAL]
case false
b : Bool
⊢ false = b ↔ (false = true ↔ b = true)
[PROOFSTEP]
cases b
[GOAL]
case true
b : Bool
⊢ true = b ↔ (true = true ↔ b = true)
[PROOFSTEP]
cases b
[GOAL]
case false.false
⊢ false = false ↔ (false = true ↔ false = true)
[PROOFSTEP]
simp
  -- Porting note: new theorem
[GOAL]
case false.true
⊢ false = true ↔ (false = true ↔ true = true)
[PROOFSTEP]
simp
  -- Porting note: new theorem
[GOAL]
case true.false
⊢ true = false ↔ (true = true ↔ false = true)
[PROOFSTEP]
simp
  -- Porting note: new theorem
[GOAL]
case true.true
⊢ true = true ↔ (true = true ↔ true = true)
[PROOFSTEP]
simp
  -- Porting note: new theorem
[GOAL]
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
⊢ (a == b) = true ↔ (b == a) = true
[PROOFSTEP]
simp [@eq_comm α]
[GOAL]
b : Bool
⊢ b = false ∨ b = true
[PROOFSTEP]
cases b
[GOAL]
case false
⊢ false = false ∨ false = true
[PROOFSTEP]
simp
[GOAL]
case true
⊢ true = false ∨ true = true
[PROOFSTEP]
simp
[GOAL]
p : Bool → Prop
h : ∀ (b : Bool), p b
⊢ p false ∧ p true
[PROOFSTEP]
simp [h]
[GOAL]
p : Bool → Prop
x✝ : p false ∧ p true
b : Bool
h₁ : p false
h₂ : p true
⊢ p b
[PROOFSTEP]
cases b
[GOAL]
case false
p : Bool → Prop
x✝ : p false ∧ p true
h₁ : p false
h₂ : p true
⊢ p false
[PROOFSTEP]
assumption
[GOAL]
case true
p : Bool → Prop
x✝ : p false ∧ p true
h₁ : p false
h₂ : p true
⊢ p true
[PROOFSTEP]
assumption
[GOAL]
p : Bool → Prop
x✝ : ∃ b, p b
b : Bool
h : p b
⊢ p false ∨ p true
[PROOFSTEP]
cases b
[GOAL]
case false
p : Bool → Prop
x✝ : ∃ b, p b
h : p false
⊢ p false ∨ p true
case true p : Bool → Prop x✝ : ∃ b, p b h : p true ⊢ p false ∨ p true
[PROOFSTEP]
exact Or.inl h
[GOAL]
case true
p : Bool → Prop
x✝ : ∃ b, p b
h : p true
⊢ p false ∨ p true
[PROOFSTEP]
exact Or.inr h
[GOAL]
α : Type u_1
b : Bool
t e : α
⊢ (bif b then t else e) = if b = true then t else e
[PROOFSTEP]
cases b
[GOAL]
case false
α : Type u_1
t e : α
⊢ (bif false then t else e) = if false = true then t else e
[PROOFSTEP]
simp
[GOAL]
case true
α : Type u_1
t e : α
⊢ (bif true then t else e) = if true = true then t else e
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
p : Prop
inst✝ : Decidable p
t e : α
⊢ (bif decide p then t else e) = if p then t else e
[PROOFSTEP]
by_cases p
[GOAL]
α : Type u_1
p : Prop
inst✝ : Decidable p
t e : α
⊢ (bif decide p then t else e) = if p then t else e
[PROOFSTEP]
by_cases p
[GOAL]
case pos
α : Type u_1
p : Prop
inst✝ : Decidable p
t e : α
h : p
⊢ (bif decide p then t else e) = if p then t else e
[PROOFSTEP]
simp [*]
[GOAL]
case neg
α : Type u_1
p : Prop
inst✝ : Decidable p
t e : α
h : ¬p
⊢ (bif decide p then t else e) = if p then t else e
[PROOFSTEP]
simp [*]
[GOAL]
α : Type u_1
b : Bool
t e : α
⊢ (bif !b then t else e) = bif b then e else t
[PROOFSTEP]
cases b
[GOAL]
case false
α : Type u_1
t e : α
⊢ (bif !false then t else e) = bif false then e else t
[PROOFSTEP]
rfl
[GOAL]
case true
α : Type u_1
t e : α
⊢ (bif !true then t else e) = bif true then e else t
[PROOFSTEP]
rfl
[GOAL]
⊢ ∀ {a b : Bool}, (a = true ↔ b = true) ↔ a = b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {a : Bool}, a ≠ false → a = true
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {a : Bool}, a ≠ true → a = false
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b : Bool), (a || b) = (b || a)
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b c : Bool), (a || (b || c)) = (b || (a || c))
[PROOFSTEP]
decide
[GOAL]
a b : Bool
H : a = true
⊢ (a || b) = true
[PROOFSTEP]
simp [H]
[GOAL]
a b : Bool
H : b = true
⊢ (a || b) = true
[PROOFSTEP]
cases a
[GOAL]
case false
b : Bool
H : b = true
⊢ (false || b) = true
[PROOFSTEP]
simp [H]
[GOAL]
case true
b : Bool
H : b = true
⊢ (true || b) = true
[PROOFSTEP]
simp [H]
[GOAL]
⊢ ∀ (a b : Bool), (a && b) = (b && a)
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b c : Bool), (a && (b && c)) = (b && (a && c))
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {a b : Bool}, (a && b) = true → a = true
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {a b : Bool}, a = true → b = true → (a && b) = true
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {a b : Bool}, (a && b) = true → b = true
[PROOFSTEP]
decide
[GOAL]
a b c : Bool
⊢ (a && (b || c)) = (a && b || a && c)
[PROOFSTEP]
cases a
[GOAL]
case false
b c : Bool
⊢ (false && (b || c)) = (false && b || false && c)
[PROOFSTEP]
simp
[GOAL]
case true
b c : Bool
⊢ (true && (b || c)) = (true && b || true && c)
[PROOFSTEP]
simp
[GOAL]
a b c : Bool
⊢ ((a || b) && c) = (a && c || b && c)
[PROOFSTEP]
cases a
[GOAL]
case false
b c : Bool
⊢ ((false || b) && c) = (false && c || b && c)
[PROOFSTEP]
cases b
[GOAL]
case true
b c : Bool
⊢ ((true || b) && c) = (true && c || b && c)
[PROOFSTEP]
cases b
[GOAL]
case false.false
c : Bool
⊢ ((false || false) && c) = (false && c || false && c)
[PROOFSTEP]
cases c
[GOAL]
case false.true
c : Bool
⊢ ((false || true) && c) = (false && c || true && c)
[PROOFSTEP]
cases c
[GOAL]
case true.false
c : Bool
⊢ ((true || false) && c) = (true && c || false && c)
[PROOFSTEP]
cases c
[GOAL]
case true.true
c : Bool
⊢ ((true || true) && c) = (true && c || true && c)
[PROOFSTEP]
cases c
[GOAL]
case false.false.false
⊢ ((false || false) && false) = (false && false || false && false)
[PROOFSTEP]
simp
[GOAL]
case false.false.true
⊢ ((false || false) && true) = (false && true || false && true)
[PROOFSTEP]
simp
[GOAL]
case false.true.false
⊢ ((false || true) && false) = (false && false || true && false)
[PROOFSTEP]
simp
[GOAL]
case false.true.true
⊢ ((false || true) && true) = (false && true || true && true)
[PROOFSTEP]
simp
[GOAL]
case true.false.false
⊢ ((true || false) && false) = (true && false || false && false)
[PROOFSTEP]
simp
[GOAL]
case true.false.true
⊢ ((true || false) && true) = (true && true || false && true)
[PROOFSTEP]
simp
[GOAL]
case true.true.false
⊢ ((true || true) && false) = (true && false || true && false)
[PROOFSTEP]
simp
[GOAL]
case true.true.true
⊢ ((true || true) && true) = (true && true || true && true)
[PROOFSTEP]
simp
[GOAL]
a b c : Bool
⊢ (a || b && c) = ((a || b) && (a || c))
[PROOFSTEP]
cases a
[GOAL]
case false
b c : Bool
⊢ (false || b && c) = ((false || b) && (false || c))
[PROOFSTEP]
simp
[GOAL]
case true
b c : Bool
⊢ (true || b && c) = ((true || b) && (true || c))
[PROOFSTEP]
simp
[GOAL]
a b c : Bool
⊢ (a && b || c) = ((a || c) && (b || c))
[PROOFSTEP]
cases a
[GOAL]
case false
b c : Bool
⊢ (false && b || c) = ((false || c) && (b || c))
[PROOFSTEP]
cases b
[GOAL]
case true
b c : Bool
⊢ (true && b || c) = ((true || c) && (b || c))
[PROOFSTEP]
cases b
[GOAL]
case false.false
c : Bool
⊢ (false && false || c) = ((false || c) && (false || c))
[PROOFSTEP]
cases c
[GOAL]
case false.true
c : Bool
⊢ (false && true || c) = ((false || c) && (true || c))
[PROOFSTEP]
cases c
[GOAL]
case true.false
c : Bool
⊢ (true && false || c) = ((true || c) && (false || c))
[PROOFSTEP]
cases c
[GOAL]
case true.true
c : Bool
⊢ (true && true || c) = ((true || c) && (true || c))
[PROOFSTEP]
cases c
[GOAL]
case false.false.false
⊢ (false && false || false) = ((false || false) && (false || false))
[PROOFSTEP]
simp
[GOAL]
case false.false.true
⊢ (false && false || true) = ((false || true) && (false || true))
[PROOFSTEP]
simp
[GOAL]
case false.true.false
⊢ (false && true || false) = ((false || false) && (true || false))
[PROOFSTEP]
simp
[GOAL]
case false.true.true
⊢ (false && true || true) = ((false || true) && (true || true))
[PROOFSTEP]
simp
[GOAL]
case true.false.false
⊢ (true && false || false) = ((true || false) && (false || false))
[PROOFSTEP]
simp
[GOAL]
case true.false.true
⊢ (true && false || true) = ((true || true) && (false || true))
[PROOFSTEP]
simp
[GOAL]
case true.true.false
⊢ (true && true || false) = ((true || false) && (true || false))
[PROOFSTEP]
simp
[GOAL]
case true.true.true
⊢ (true && true || true) = ((true || true) && (true || true))
[PROOFSTEP]
simp
[GOAL]
⊢ ∀ {a b : Bool}, a = !b ↔ a ≠ b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {a b : Bool}, (!decide (a = b)) = true ↔ a ≠ b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {a b : Bool}, ¬a = !b ↔ a = b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {a b : Bool}, ¬(!a) = b ↔ a = b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (b : Bool), (!b) ≠ b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (b : Bool), b ≠ !b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b : Bool), a = b ∨ a = !b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {b : Bool}, (!b) = true ↔ ¬b = true
[PROOFSTEP]
simp
[GOAL]
a : Bool
⊢ (!decide (a = false)) = true → a = true
[PROOFSTEP]
cases a
[GOAL]
case false
⊢ (!decide (false = false)) = true → false = true
[PROOFSTEP]
decide
[GOAL]
case true
⊢ (!decide (true = false)) = true → true = true
[PROOFSTEP]
decide
[GOAL]
a : Bool
⊢ (!decide (a = true)) = true → a = false
[PROOFSTEP]
cases a
[GOAL]
case false
⊢ (!decide (false = true)) = true → false = false
[PROOFSTEP]
decide
[GOAL]
case true
⊢ (!decide (true = true)) = true → true = false
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (x : Bool), (x && !x) = false
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (x : Bool), (!x && x) = false
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (x : Bool), (x || !x) = true
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (x : Bool), (!x || x) = true
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b : Bool), xor a b = xor b a
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b c : Bool), xor (xor a b) c = xor a (xor b c)
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b c : Bool), xor a (xor b c) = xor b (xor a c)
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a : Bool), xor (!a) a = true
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a : Bool), (xor a !a) = true
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b : Bool), (xor (!a) !b) = xor a b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a : Bool), xor false a = a
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a : Bool), xor a false = a
[PROOFSTEP]
decide
[GOAL]
a b c : Bool
⊢ (a && xor b c) = xor (a && b) (a && c)
[PROOFSTEP]
cases a
[GOAL]
case false
b c : Bool
⊢ (false && xor b c) = xor (false && b) (false && c)
[PROOFSTEP]
simp
[GOAL]
case true
b c : Bool
⊢ (true && xor b c) = xor (true && b) (true && c)
[PROOFSTEP]
simp
[GOAL]
a b c : Bool
⊢ (xor a b && c) = xor (a && c) (b && c)
[PROOFSTEP]
cases a
[GOAL]
case false
b c : Bool
⊢ (xor false b && c) = xor (false && c) (b && c)
[PROOFSTEP]
cases b
[GOAL]
case true
b c : Bool
⊢ (xor true b && c) = xor (true && c) (b && c)
[PROOFSTEP]
cases b
[GOAL]
case false.false
c : Bool
⊢ (xor false false && c) = xor (false && c) (false && c)
[PROOFSTEP]
cases c
[GOAL]
case false.true
c : Bool
⊢ (xor false true && c) = xor (false && c) (true && c)
[PROOFSTEP]
cases c
[GOAL]
case true.false
c : Bool
⊢ (xor true false && c) = xor (true && c) (false && c)
[PROOFSTEP]
cases c
[GOAL]
case true.true
c : Bool
⊢ (xor true true && c) = xor (true && c) (true && c)
[PROOFSTEP]
cases c
[GOAL]
case false.false.false
⊢ (xor false false && false) = xor (false && false) (false && false)
[PROOFSTEP]
simp
[GOAL]
case false.false.true
⊢ (xor false false && true) = xor (false && true) (false && true)
[PROOFSTEP]
simp
[GOAL]
case false.true.false
⊢ (xor false true && false) = xor (false && false) (true && false)
[PROOFSTEP]
simp
[GOAL]
case false.true.true
⊢ (xor false true && true) = xor (false && true) (true && true)
[PROOFSTEP]
simp
[GOAL]
case true.false.false
⊢ (xor true false && false) = xor (true && false) (false && false)
[PROOFSTEP]
simp
[GOAL]
case true.false.true
⊢ (xor true false && true) = xor (true && true) (false && true)
[PROOFSTEP]
simp
[GOAL]
case true.true.false
⊢ (xor true true && false) = xor (true && false) (true && false)
[PROOFSTEP]
simp
[GOAL]
case true.true.true
⊢ (xor true true && true) = xor (true && true) (true && true)
[PROOFSTEP]
simp
[GOAL]
⊢ ∀ {x y : Bool}, xor x y = true ↔ x ≠ y
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b : Bool), (!(a && b)) = (!a || !b)
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b : Bool), (!(a || b)) = (!a && !b)
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {a b : Bool}, (!a) = !b → a = b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a : Bool), a ≤ a
[PROOFSTEP]
unfold LE.le
[GOAL]
⊢ ∀ (a : Bool), { le := fun a b => a = false ∨ b = true }.1 a a
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b c : Bool), a ≤ b → b ≤ c → a ≤ c
[PROOFSTEP]
unfold LE.le
[GOAL]
⊢ ∀ (a b c : Bool),
    { le := fun a b => a = false ∨ b = true }.1 a b →
      { le := fun a b => a = false ∨ b = true }.1 b c → { le := fun a b => a = false ∨ b = true }.1 a c
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b : Bool), a ≤ b → b ≤ a → a = b
[PROOFSTEP]
unfold LE.le Preorder.toLE
[GOAL]
⊢ ∀ (a b : Bool),
    (Preorder.mk (_ : ∀ (a : Bool), { le := fun a b => a = false ∨ b = true }.1 a a)
              (_ :
                ∀ (a b c : Bool),
                  { le := fun a b => a = false ∨ b = true }.1 a b →
                    { le := fun a b => a = false ∨ b = true }.1 b c →
                      { le := fun a b => a = false ∨ b = true }.1 a c)).1.1
        a b →
      (Preorder.mk (_ : ∀ (a : Bool), { le := fun a b => a = false ∨ b = true }.1 a a)
                (_ :
                  ∀ (a b c : Bool),
                    { le := fun a b => a = false ∨ b = true }.1 a b →
                      { le := fun a b => a = false ∨ b = true }.1 b c →
                        { le := fun a b => a = false ∨ b = true }.1 a c)).1.1
          b a →
        a = b
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (a b : Bool), a ≤ b ∨ b ≤ a
[PROOFSTEP]
unfold LE.le Preorder.toLE PartialOrder.toPreorder
[GOAL]
⊢ ∀ (a b : Bool),
    (PartialOrder.mk
                (_ :
                  ∀ (a b : Bool),
                    (Preorder.mk (_ : ∀ (a : Bool), { le := fun a b => a = false ∨ b = true }.1 a a)
                              (_ :
                                ∀ (a b c : Bool),
                                  { le := fun a b => a = false ∨ b = true }.1 a b →
                                    { le := fun a b => a = false ∨ b = true }.1 b c →
                                      { le := fun a b => a = false ∨ b = true }.1 a c)).1.1
                        a b →
                      (Preorder.mk (_ : ∀ (a : Bool), { le := fun a b => a = false ∨ b = true }.1 a a)
                                (_ :
                                  ∀ (a b c : Bool),
                                    { le := fun a b => a = false ∨ b = true }.1 a b →
                                      { le := fun a b => a = false ∨ b = true }.1 b c →
                                        { le := fun a b => a = false ∨ b = true }.1 a c)).1.1
                          b a →
                        a = b)).1.1.1
        a b ∨
      (PartialOrder.mk
                (_ :
                  ∀ (a b : Bool),
                    (Preorder.mk (_ : ∀ (a : Bool), { le := fun a b => a = false ∨ b = true }.1 a a)
                              (_ :
                                ∀ (a b c : Bool),
                                  { le := fun a b => a = false ∨ b = true }.1 a b →
                                    { le := fun a b => a = false ∨ b = true }.1 b c →
                                      { le := fun a b => a = false ∨ b = true }.1 a c)).1.1
                        a b →
                      (Preorder.mk (_ : ∀ (a : Bool), { le := fun a b => a = false ∨ b = true }.1 a a)
                                (_ :
                                  ∀ (a b c : Bool),
                                    { le := fun a b => a = false ∨ b = true }.1 a b →
                                      { le := fun a b => a = false ∨ b = true }.1 b c →
                                        { le := fun a b => a = false ∨ b = true }.1 a c)).1.1
                          b a →
                        a = b)).1.1.1
        b a
[PROOFSTEP]
decide
[GOAL]
⊢ DecidableRel fun x x_1 => x ≤ x_1
[PROOFSTEP]
unfold LE.le Preorder.toLE PartialOrder.toPreorder
[GOAL]
⊢ DecidableRel fun x x_1 =>
    (PartialOrder.mk
              (_ :
                ∀ (a b : Bool),
                  (Preorder.mk (_ : ∀ (a : Bool), { le := fun a b => a = false ∨ b = true }.1 a a)
                            (_ :
                              ∀ (a b c : Bool),
                                { le := fun a b => a = false ∨ b = true }.1 a b →
                                  { le := fun a b => a = false ∨ b = true }.1 b c →
                                    { le := fun a b => a = false ∨ b = true }.1 a c)).1.1
                      a b →
                    (Preorder.mk (_ : ∀ (a : Bool), { le := fun a b => a = false ∨ b = true }.1 a a)
                              (_ :
                                ∀ (a b c : Bool),
                                  { le := fun a b => a = false ∨ b = true }.1 a b →
                                    { le := fun a b => a = false ∨ b = true }.1 b c →
                                      { le := fun a b => a = false ∨ b = true }.1 a c)).1.1
                        b a →
                      a = b)).1.1.1
      x x_1
[PROOFSTEP]
exact inferInstance
[GOAL]
a b : Bool
⊢ min a b = if a ≤ b then a else b
[PROOFSTEP]
cases a
[GOAL]
case false
b : Bool
⊢ min false b = if false ≤ b then false else b
[PROOFSTEP]
cases b
[GOAL]
case true
b : Bool
⊢ min true b = if true ≤ b then true else b
[PROOFSTEP]
cases b
[GOAL]
case false.false
⊢ min false false = if false ≤ false then false else false
[PROOFSTEP]
decide
[GOAL]
case false.true
⊢ min false true = if false ≤ true then false else true
[PROOFSTEP]
decide
[GOAL]
case true.false
⊢ min true false = if true ≤ false then true else false
[PROOFSTEP]
decide
[GOAL]
case true.true
⊢ min true true = if true ≤ true then true else true
[PROOFSTEP]
decide
[GOAL]
a b : Bool
⊢ max a b = if a ≤ b then b else a
[PROOFSTEP]
cases a
[GOAL]
case false
b : Bool
⊢ max false b = if false ≤ b then b else false
[PROOFSTEP]
cases b
[GOAL]
case true
b : Bool
⊢ max true b = if true ≤ b then b else true
[PROOFSTEP]
cases b
[GOAL]
case false.false
⊢ max false false = if false ≤ false then false else false
[PROOFSTEP]
decide
[GOAL]
case false.true
⊢ max false true = if false ≤ true then true else false
[PROOFSTEP]
decide
[GOAL]
case true.false
⊢ max true false = if true ≤ false then false else true
[PROOFSTEP]
decide
[GOAL]
case true.true
⊢ max true true = if true ≤ true then true else true
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {x y : Bool}, x < y ↔ x = false ∧ y = true
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {x y : Bool}, x ≤ y ↔ x = true → y = true
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (x y : Bool), (x && y) ≤ x
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (x y : Bool), (x && y) ≤ y
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {x y z : Bool}, x ≤ y → x ≤ z → x ≤ (y && z)
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (x y : Bool), x ≤ (x || y)
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ (x y : Bool), y ≤ (x || y)
[PROOFSTEP]
decide
[GOAL]
⊢ ∀ {x y z : Bool}, x ≤ z → y ≤ z → (x || y) ≤ z
[PROOFSTEP]
decide
[GOAL]
n m : ℕ
h : n ≤ m
⊢ ofNat n ≤ ofNat m
[PROOFSTEP]
simp only [ofNat, ne_eq, _root_.decide_not]
[GOAL]
n m : ℕ
h : n ≤ m
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]
cases Nat.decEq n 0 with
| isTrue hn => rw [decide_eq_true hn]; exact false_le
| isFalse hn =>
  cases Nat.decEq m 0 with
  | isFalse hm => rw [decide_eq_false hm]; exact le_true
  | isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
[GOAL]
n m : ℕ
h : n ≤ m
x✝ : Decidable (n = 0)
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]
cases Nat.decEq n 0 with
| isTrue hn => rw [decide_eq_true hn]; exact false_le
| isFalse hn =>
  cases Nat.decEq m 0 with
  | isFalse hm => rw [decide_eq_false hm]; exact le_true
  | isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
[GOAL]
case isTrue
n m : ℕ
h : n ≤ m
hn : n = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]

| isTrue hn => rw [decide_eq_true hn]; exact false_le
[GOAL]
case isTrue
n m : ℕ
h : n ≤ m
hn : n = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]
rw [decide_eq_true hn]
[GOAL]
case isTrue
n m : ℕ
h : n ≤ m
hn : n = 0
⊢ (!true) ≤ !decide (m = 0)
[PROOFSTEP]
exact false_le
[GOAL]
case isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]

| isFalse hn =>
  cases Nat.decEq m 0 with
  | isFalse hm => rw [decide_eq_false hm]; exact le_true
  | isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
[GOAL]
case isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]
cases Nat.decEq m 0 with
| isFalse hm => rw [decide_eq_false hm]; exact le_true
| isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
[GOAL]
case isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
x✝ : Decidable (m = 0)
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]
cases Nat.decEq m 0 with
| isFalse hm => rw [decide_eq_false hm]; exact le_true
| isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
[GOAL]
case isFalse.isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
hm : ¬m = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]

| isFalse hm => rw [decide_eq_false hm]; exact le_true
[GOAL]
case isFalse.isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
hm : ¬m = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]
rw [decide_eq_false hm]
[GOAL]
case isFalse.isFalse
n m : ℕ
h : n ≤ m
hn : ¬n = 0
hm : ¬m = 0
⊢ (!decide (n = 0)) ≤ !false
[PROOFSTEP]
exact le_true
[GOAL]
case isFalse.isTrue
n m : ℕ
h : n ≤ m
hn : ¬n = 0
hm : m = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]

| isTrue hm => subst hm; have h := le_antisymm h (Nat.zero_le n); contradiction
[GOAL]
case isFalse.isTrue
n m : ℕ
h : n ≤ m
hn : ¬n = 0
hm : m = 0
⊢ (!decide (n = 0)) ≤ !decide (m = 0)
[PROOFSTEP]
subst hm
[GOAL]
case isFalse.isTrue
n : ℕ
hn : ¬n = 0
h : n ≤ 0
⊢ (!decide (n = 0)) ≤ !decide (0 = 0)
[PROOFSTEP]
have h := le_antisymm h (Nat.zero_le n)
[GOAL]
case isFalse.isTrue
n : ℕ
hn : ¬n = 0
h✝ : n ≤ 0
h : n = 0
⊢ (!decide (n = 0)) ≤ !decide (0 = 0)
[PROOFSTEP]
contradiction
[GOAL]
b₀ b₁ : Bool
h : b₀ ≤ b₁
⊢ toNat b₀ ≤ toNat b₁
[PROOFSTEP]
cases h with
| inl h => subst h; exact Nat.zero_le _
| inr h => subst h; cases b₀ <;> simp
[GOAL]
b₀ b₁ : Bool
h : b₀ ≤ b₁
⊢ toNat b₀ ≤ toNat b₁
[PROOFSTEP]
cases h with
| inl h => subst h; exact Nat.zero_le _
| inr h => subst h; cases b₀ <;> simp
[GOAL]
case inl
b₀ b₁ : Bool
h : b₀ = false
⊢ toNat b₀ ≤ toNat b₁
[PROOFSTEP]

| inl h => subst h; exact Nat.zero_le _
[GOAL]
case inl
b₀ b₁ : Bool
h : b₀ = false
⊢ toNat b₀ ≤ toNat b₁
[PROOFSTEP]
subst h
[GOAL]
case inl
b₁ : Bool
⊢ toNat false ≤ toNat b₁
[PROOFSTEP]
exact Nat.zero_le _
[GOAL]
case inr
b₀ b₁ : Bool
h : b₁ = true
⊢ toNat b₀ ≤ toNat b₁
[PROOFSTEP]

| inr h => subst h; cases b₀ <;> simp
[GOAL]
case inr
b₀ b₁ : Bool
h : b₁ = true
⊢ toNat b₀ ≤ toNat b₁
[PROOFSTEP]
subst h
[GOAL]
case inr
b₀ : Bool
⊢ toNat b₀ ≤ toNat true
[PROOFSTEP]
cases b₀
[GOAL]
case inr.false
⊢ toNat false ≤ toNat true
[PROOFSTEP]
simp
[GOAL]
case inr.true
⊢ toNat true ≤ toNat true
[PROOFSTEP]
simp
[GOAL]
b : Bool
⊢ ofNat (toNat b) = b
[PROOFSTEP]
cases b
[GOAL]
case false
⊢ ofNat (toNat false) = false
[PROOFSTEP]
rfl
[GOAL]
case true
⊢ ofNat (toNat true) = true
[PROOFSTEP]
rfl
[GOAL]
α : Sort u_1
f : Bool → α
H : f false ≠ f true
x y : Bool
hxy : f x = f y
⊢ x = y
[PROOFSTEP]
cases x
[GOAL]
case false
α : Sort u_1
f : Bool → α
H : f false ≠ f true
y : Bool
hxy : f false = f y
⊢ false = y
[PROOFSTEP]
cases y
[GOAL]
case true
α : Sort u_1
f : Bool → α
H : f false ≠ f true
y : Bool
hxy : f true = f y
⊢ true = y
[PROOFSTEP]
cases y
[GOAL]
case false.false
α : Sort u_1
f : Bool → α
H : f false ≠ f true
hxy : f false = f false
⊢ false = false
case false.true
α : Sort u_1
f : Bool → α
H : f false ≠ f true
hxy : f false = f true
⊢ false = true
case true.false
α : Sort u_1
f : Bool → α
H : f false ≠ f true
hxy : f true = f false
⊢ true = false
case true.true α : Sort u_1 f : Bool → α H : f false ≠ f true hxy : f true = f true ⊢ true = true
[PROOFSTEP]
exacts [rfl, (H hxy).elim, (H hxy.symm).elim, rfl]
[GOAL]
f : Bool → Bool
x : Bool
⊢ f (f (f x)) = f x
[PROOFSTEP]
cases x
[GOAL]
case false
f : Bool → Bool
⊢ f (f (f false)) = f false
[PROOFSTEP]
cases h₁ : f true
[GOAL]
case true
f : Bool → Bool
⊢ f (f (f true)) = f true
[PROOFSTEP]
cases h₁ : f true
[GOAL]
case false.false
f : Bool → Bool
h₁ : f true = false
⊢ f (f (f false)) = f false
[PROOFSTEP]
cases h₂ : f false
[GOAL]
case false.true
f : Bool → Bool
h₁ : f true = true
⊢ f (f (f false)) = f false
[PROOFSTEP]
cases h₂ : f false
[GOAL]
case true.false
f : Bool → Bool
h₁ : f true = false
⊢ f (f false) = false
[PROOFSTEP]
cases h₂ : f false
[GOAL]
case true.true
f : Bool → Bool
h₁ : f true = true
⊢ f (f true) = true
[PROOFSTEP]
cases h₂ : f false
[GOAL]
case false.false.false
f : Bool → Bool
h₁ : f true = false
h₂ : f false = false
⊢ f (f false) = false
[PROOFSTEP]
simp only [h₁, h₂]
[GOAL]
case false.false.true
f : Bool → Bool
h₁ : f true = false
h₂ : f false = true
⊢ f (f true) = true
[PROOFSTEP]
simp only [h₁, h₂]
[GOAL]
case false.true.false
f : Bool → Bool
h₁ : f true = true
h₂ : f false = false
⊢ f (f false) = false
[PROOFSTEP]
simp only [h₁, h₂]
[GOAL]
case false.true.true
f : Bool → Bool
h₁ : f true = true
h₂ : f false = true
⊢ f (f true) = true
[PROOFSTEP]
simp only [h₁, h₂]
[GOAL]
case true.false.false
f : Bool → Bool
h₁ : f true = false
h₂ : f false = false
⊢ f false = false
[PROOFSTEP]
simp only [h₁, h₂]
[GOAL]
case true.false.true
f : Bool → Bool
h₁ : f true = false
h₂ : f false = true
⊢ f true = false
[PROOFSTEP]
simp only [h₁, h₂]
[GOAL]
case true.true.false
f : Bool → Bool
h₁ : f true = true
h₂ : f false = false
⊢ f (f true) = true
[PROOFSTEP]
simp only [h₁, h₂]
[GOAL]
case true.true.true
f : Bool → Bool
h₁ : f true = true
h₂ : f false = true
⊢ f (f true) = true
[PROOFSTEP]
simp only [h₁, h₂]


[GOAL]
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ a = ↑u * (↑u⁻¹ * a)
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
x✝ : a ∣ b * ↑u
c : α
Eq : b * ↑u = a * c
⊢ b = a * (c * ↑u⁻¹)
[PROOFSTEP]
rw [← mul_assoc, ← Eq, Units.mul_inv_cancel_right]
[GOAL]
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
h : a ∣ b
⊢ a * ↑u * ↑u⁻¹ = a
[PROOFSTEP]
rw [mul_assoc, u.mul_inv, mul_one]
[GOAL]
α : Type u_1
inst✝ : CommMonoid α
a b : α
u : αˣ
⊢ a ∣ ↑u * b ↔ a ∣ b
[PROOFSTEP]
rw [mul_comm]
[GOAL]
α : Type u_1
inst✝ : CommMonoid α
a b : α
u : αˣ
⊢ a ∣ b * ↑u ↔ a ∣ b
[PROOFSTEP]
apply dvd_mul_right
[GOAL]
α : Type u_1
inst✝ : CommMonoid α
a b : α
u : αˣ
⊢ ↑u * a ∣ b ↔ a ∣ b
[PROOFSTEP]
rw [mul_comm]
[GOAL]
α : Type u_1
inst✝ : CommMonoid α
a b : α
u : αˣ
⊢ a * ↑u ∣ b ↔ a ∣ b
[PROOFSTEP]
apply mul_right_dvd
[GOAL]
α : Type u_1
inst✝ : Monoid α
a b u : α
hu : IsUnit u
⊢ u ∣ a
[PROOFSTEP]
rcases hu with ⟨u, rfl⟩
[GOAL]
case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ ↑u ∣ a
[PROOFSTEP]
apply Units.coe_dvd
[GOAL]
α : Type u_1
inst✝ : Monoid α
a b u : α
hu : IsUnit u
⊢ a ∣ b * u ↔ a ∣ b
[PROOFSTEP]
rcases hu with ⟨u, rfl⟩
[GOAL]
case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ a ∣ b * ↑u ↔ a ∣ b
[PROOFSTEP]
apply Units.dvd_mul_right
[GOAL]
α : Type u_1
inst✝ : Monoid α
a b u : α
hu : IsUnit u
⊢ a * u ∣ b ↔ a ∣ b
[PROOFSTEP]
rcases hu with ⟨u, rfl⟩
[GOAL]
case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ a * ↑u ∣ b ↔ a ∣ b
[PROOFSTEP]
apply Units.mul_right_dvd
[GOAL]
α : Type u_1
inst✝ : CommMonoid α
a b u : α
hu : IsUnit u
⊢ a ∣ u * b ↔ a ∣ b
[PROOFSTEP]
rcases hu with ⟨u, rfl⟩
[GOAL]
case intro
α : Type u_1
inst✝ : CommMonoid α
a b : α
u : αˣ
⊢ a ∣ ↑u * b ↔ a ∣ b
[PROOFSTEP]
apply Units.dvd_mul_left
[GOAL]
α : Type u_1
inst✝ : CommMonoid α
a b u : α
hu : IsUnit u
⊢ u * a ∣ b ↔ a ∣ b
[PROOFSTEP]
rcases hu with ⟨u, rfl⟩
[GOAL]
case intro
α : Type u_1
inst✝ : CommMonoid α
a b : α
u : αˣ
⊢ ↑u * a ∣ b ↔ a ∣ b
[PROOFSTEP]
apply Units.mul_left_dvd
[GOAL]
α : Type u_1
inst✝ : CommMonoid α
x : α
x✝ : x ∣ 1
y : α
h : 1 = x * y
⊢ y * x = 1
[PROOFSTEP]
rw [h, mul_comm]


[GOAL]
α β : DistLatCat
e : ↑α ≃o ↑β
⊢ { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
        map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) } ≫
      {
        toSupHom :=
          { toFun := ↑(OrderIso.symm e),
            map_sup' := (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
        map_inf' := (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) } =
    𝟙 α
[PROOFSTEP]
ext
[GOAL]
case w
α β : DistLatCat
e : ↑α ≃o ↑β
x✝ : (forget DistLatCat).obj α
⊢ ↑({ toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
            map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) } ≫
          {
            toSupHom :=
              { toFun := ↑(OrderIso.symm e),
                map_sup' :=
                  (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
            map_inf' := (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) })
      x✝ =
    ↑(𝟙 α) x✝
[PROOFSTEP]
exact e.symm_apply_apply _
[GOAL]
α β : DistLatCat
e : ↑α ≃o ↑β
⊢ {
        toSupHom :=
          { toFun := ↑(OrderIso.symm e),
            map_sup' := (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
        map_inf' := (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) } ≫
      { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
        map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) } =
    𝟙 β
[PROOFSTEP]
ext
[GOAL]
case w
α β : DistLatCat
e : ↑α ≃o ↑β
x✝ : (forget DistLatCat).obj β
⊢ ↑({
            toSupHom :=
              { toFun := ↑(OrderIso.symm e),
                map_sup' :=
                  (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊔ b) = ↑(OrderIso.symm e) a ⊔ ↑(OrderIso.symm e) b) },
            map_inf' := (_ : ∀ (a b : ↑β), ↑(OrderIso.symm e) (a ⊓ b) = ↑(OrderIso.symm e) a ⊓ ↑(OrderIso.symm e) b) } ≫
          { toSupHom := { toFun := ↑e, map_sup' := (_ : ∀ (a b : ↑α), ↑e (a ⊔ b) = ↑e a ⊔ ↑e b) },
            map_inf' := (_ : ∀ (a b : ↑α), ↑e (a ⊓ b) = ↑e a ⊓ ↑e b) })
      x✝ =
    ↑(𝟙 β) x✝
[PROOFSTEP]
exact e.apply_symm_apply _


[GOAL]
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
⊢ Continuous fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd))
[PROOFSTEP]
exact
  ((map_continuous HSpace.hmul).comp
        ((continuous_fst.comp continuous_fst).prod_mk (continuous_fst.comp continuous_snd))).prod_mk
    ((map_continuous HSpace.hmul).comp
      ((continuous_snd.comp continuous_fst).prod_mk (continuous_snd.comp continuous_snd)))
[GOAL]
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
⊢ ↑(ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd))) ((e, e), e, e) = (e, e)
[PROOFSTEP]
simp only [ContinuousMap.coe_mk, Prod.mk.inj_iff]
[GOAL]
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
⊢ ↑hmul (e, e) = e ∧ ↑hmul (e, e) = e
[PROOFSTEP]
exact ⟨HSpace.hmul_e_e, HSpace.hmul_e_e⟩
[GOAL]
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
⊢ HomotopyRel
    (comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
      (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
    (ContinuousMap.id (X × Y)) {(e, e)}
[PROOFSTEP]
let G : I × X × Y → X × Y := fun p => (HSpace.eHmul (p.1, p.2.1), HSpace.eHmul (p.1, p.2.2))
[GOAL]
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑eHmul (p.fst, p.snd.fst), ↑eHmul (p.fst, p.snd.snd))
⊢ HomotopyRel
    (comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
      (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
    (ContinuousMap.id (X × Y)) {(e, e)}
[PROOFSTEP]
have hG : Continuous G :=
  (Continuous.comp HSpace.eHmul.1.1.2 (continuous_fst.prod_mk (continuous_fst.comp continuous_snd))).prod_mk
    (Continuous.comp HSpace.eHmul.1.1.2 (continuous_fst.prod_mk (continuous_snd.comp continuous_snd)))
[GOAL]
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑eHmul (p.fst, p.snd.fst), ↑eHmul (p.fst, p.snd.snd))
hG : Continuous G
⊢ HomotopyRel
    (comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
      (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
    (ContinuousMap.id (X × Y)) {(e, e)}
[PROOFSTEP]
use!⟨G, hG⟩
[GOAL]
case map_zero_left
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑eHmul (p.fst, p.snd.fst), ↑eHmul (p.fst, p.snd.snd))
hG : Continuous G
⊢ ∀ (x : X × Y),
    ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
      ↑(comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
            (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
        x
[PROOFSTEP]
rintro ⟨x, y⟩
[GOAL]
case map_zero_left.mk
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑eHmul (p.fst, p.snd.fst), ↑eHmul (p.fst, p.snd.snd))
hG : Continuous G
x : X
y : Y
⊢ ContinuousMap.toFun (ContinuousMap.mk G) (0, x, y) =
    ↑(comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
          (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
      (x, y)
[PROOFSTEP]
exacts [Prod.mk.inj_iff.mpr ⟨HSpace.eHmul.1.2 x, HSpace.eHmul.1.2 y⟩]
[GOAL]
case map_one_left
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑eHmul (p.fst, p.snd.fst), ↑eHmul (p.fst, p.snd.snd))
hG : Continuous G
⊢ ∀ (x : X × Y), ContinuousMap.toFun (ContinuousMap.mk G) (1, x) = ↑(ContinuousMap.id (X × Y)) x
[PROOFSTEP]
rintro ⟨x, y⟩
[GOAL]
case map_one_left.mk
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑eHmul (p.fst, p.snd.fst), ↑eHmul (p.fst, p.snd.snd))
hG : Continuous G
x : X
y : Y
⊢ ContinuousMap.toFun (ContinuousMap.mk G) (1, x, y) = ↑(ContinuousMap.id (X × Y)) (x, y)
[PROOFSTEP]
exact Prod.mk.inj_iff.mpr ⟨HSpace.eHmul.1.3 x, HSpace.eHmul.1.3 y⟩
[GOAL]
case prop'
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑eHmul (p.fst, p.snd.fst), ↑eHmul (p.fst, p.snd.snd))
hG : Continuous G
⊢ ∀ (t : ↑I) (x : X × Y),
    x ∈ {(e, e)} →
      ↑(ContinuousMap.mk fun x =>
                ContinuousMap.toFun
                  { toContinuousMap := ContinuousMap.mk G,
                      map_zero_left :=
                        (_ :
                          ∀ (x : X × Y),
                            ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                              ↑(comp
                                    (ContinuousMap.mk fun p =>
                                      (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                    (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
                                x),
                      map_one_left :=
                        (_ :
                          ∀ (x : X × Y),
                            ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                              ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
                  (t, x))
            x =
          ↑(comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
            x ∧
        ↑(ContinuousMap.mk fun x =>
                ContinuousMap.toFun
                  { toContinuousMap := ContinuousMap.mk G,
                      map_zero_left :=
                        (_ :
                          ∀ (x : X × Y),
                            ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                              ↑(comp
                                    (ContinuousMap.mk fun p =>
                                      (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                    (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
                                x),
                      map_one_left :=
                        (_ :
                          ∀ (x : X × Y),
                            ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                              ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
                  (t, x))
            x =
          ↑(ContinuousMap.id (X × Y)) x
[PROOFSTEP]
rintro t ⟨x, y⟩ h
[GOAL]
case prop'.mk
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑eHmul (p.fst, p.snd.fst), ↑eHmul (p.fst, p.snd.snd))
hG : Continuous G
t : ↑I
x : X
y : Y
h : (x, y) ∈ {(e, e)}
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk G,
                  map_zero_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                          ↑(comp
                                (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
                            x),
                  map_one_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                          ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
              (t, x))
        (x, y) =
      ↑(comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
            (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
        (x, y) ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk G,
                  map_zero_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                          ↑(comp
                                (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
                            x),
                  map_one_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                          ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
              (t, x))
        (x, y) =
      ↑(ContinuousMap.id (X × Y)) (x, y)
[PROOFSTEP]
replace h := Prod.mk.inj_iff.mp (Set.mem_singleton_iff.mp h)
[GOAL]
case prop'.mk
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑eHmul (p.fst, p.snd.fst), ↑eHmul (p.fst, p.snd.snd))
hG : Continuous G
t : ↑I
x : X
y : Y
h : x = e ∧ y = e
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk G,
                  map_zero_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                          ↑(comp
                                (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
                            x),
                  map_one_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                          ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
              (t, x))
        (x, y) =
      ↑(comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
            (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
        (x, y) ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk G,
                  map_zero_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                          ↑(comp
                                (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                (prodMk (const (X × Y) (e, e)) (ContinuousMap.id (X × Y))))
                            x),
                  map_one_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                          ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
              (t, x))
        (x, y) =
      ↑(ContinuousMap.id (X × Y)) (x, y)
[PROOFSTEP]
exact
  ⟨Prod.mk.inj_iff.mpr
      ⟨HomotopyRel.eq_fst HSpace.eHmul t (Set.mem_singleton_iff.mpr h.1),
        HomotopyRel.eq_fst HSpace.eHmul t (Set.mem_singleton_iff.mpr h.2)⟩,
    Prod.mk.inj_iff.mpr ⟨(HSpace.eHmul.2 t x h.1).2, (HSpace.eHmul.2 t y h.2).2⟩⟩
[GOAL]
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
⊢ HomotopyRel
    (comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
      (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
    (ContinuousMap.id (X × Y)) {(e, e)}
[PROOFSTEP]
let G : I × X × Y → X × Y := fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2))
[GOAL]
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑hmulE (p.fst, p.snd.fst), ↑hmulE (p.fst, p.snd.snd))
⊢ HomotopyRel
    (comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
      (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
    (ContinuousMap.id (X × Y)) {(e, e)}
[PROOFSTEP]
have hG : Continuous G :=
  (Continuous.comp HSpace.hmulE.1.1.2 (continuous_fst.prod_mk (continuous_fst.comp continuous_snd))).prod_mk
    (Continuous.comp HSpace.hmulE.1.1.2 (continuous_fst.prod_mk (continuous_snd.comp continuous_snd)))
[GOAL]
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑hmulE (p.fst, p.snd.fst), ↑hmulE (p.fst, p.snd.snd))
hG : Continuous G
⊢ HomotopyRel
    (comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
      (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
    (ContinuousMap.id (X × Y)) {(e, e)}
[PROOFSTEP]
use!⟨G, hG⟩
[GOAL]
case map_zero_left
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑hmulE (p.fst, p.snd.fst), ↑hmulE (p.fst, p.snd.snd))
hG : Continuous G
⊢ ∀ (x : X × Y),
    ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
      ↑(comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
            (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
        x
[PROOFSTEP]
rintro ⟨x, y⟩
[GOAL]
case map_zero_left.mk
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑hmulE (p.fst, p.snd.fst), ↑hmulE (p.fst, p.snd.snd))
hG : Continuous G
x : X
y : Y
⊢ ContinuousMap.toFun (ContinuousMap.mk G) (0, x, y) =
    ↑(comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
          (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
      (x, y)
[PROOFSTEP]
exacts [Prod.mk.inj_iff.mpr ⟨HSpace.hmulE.1.2 x, HSpace.hmulE.1.2 y⟩]
[GOAL]
case map_one_left
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑hmulE (p.fst, p.snd.fst), ↑hmulE (p.fst, p.snd.snd))
hG : Continuous G
⊢ ∀ (x : X × Y), ContinuousMap.toFun (ContinuousMap.mk G) (1, x) = ↑(ContinuousMap.id (X × Y)) x
[PROOFSTEP]
rintro ⟨x, y⟩
[GOAL]
case map_one_left.mk
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑hmulE (p.fst, p.snd.fst), ↑hmulE (p.fst, p.snd.snd))
hG : Continuous G
x : X
y : Y
⊢ ContinuousMap.toFun (ContinuousMap.mk G) (1, x, y) = ↑(ContinuousMap.id (X × Y)) (x, y)
[PROOFSTEP]
exact Prod.mk.inj_iff.mpr ⟨HSpace.hmulE.1.3 x, HSpace.hmulE.1.3 y⟩
[GOAL]
case prop'
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑hmulE (p.fst, p.snd.fst), ↑hmulE (p.fst, p.snd.snd))
hG : Continuous G
⊢ ∀ (t : ↑I) (x : X × Y),
    x ∈ {(e, e)} →
      ↑(ContinuousMap.mk fun x =>
                ContinuousMap.toFun
                  { toContinuousMap := ContinuousMap.mk G,
                      map_zero_left :=
                        (_ :
                          ∀ (x : X × Y),
                            ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                              ↑(comp
                                    (ContinuousMap.mk fun p =>
                                      (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                    (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
                                x),
                      map_one_left :=
                        (_ :
                          ∀ (x : X × Y),
                            ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                              ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
                  (t, x))
            x =
          ↑(comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
            x ∧
        ↑(ContinuousMap.mk fun x =>
                ContinuousMap.toFun
                  { toContinuousMap := ContinuousMap.mk G,
                      map_zero_left :=
                        (_ :
                          ∀ (x : X × Y),
                            ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                              ↑(comp
                                    (ContinuousMap.mk fun p =>
                                      (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                    (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
                                x),
                      map_one_left :=
                        (_ :
                          ∀ (x : X × Y),
                            ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                              ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
                  (t, x))
            x =
          ↑(ContinuousMap.id (X × Y)) x
[PROOFSTEP]
rintro t ⟨x, y⟩ h
[GOAL]
case prop'.mk
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑hmulE (p.fst, p.snd.fst), ↑hmulE (p.fst, p.snd.snd))
hG : Continuous G
t : ↑I
x : X
y : Y
h : (x, y) ∈ {(e, e)}
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk G,
                  map_zero_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                          ↑(comp
                                (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
                            x),
                  map_one_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                          ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
              (t, x))
        (x, y) =
      ↑(comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
            (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
        (x, y) ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk G,
                  map_zero_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                          ↑(comp
                                (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
                            x),
                  map_one_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                          ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
              (t, x))
        (x, y) =
      ↑(ContinuousMap.id (X × Y)) (x, y)
[PROOFSTEP]
replace h := Prod.mk.inj_iff.mp (Set.mem_singleton_iff.mp h)
[GOAL]
case prop'.mk
X : Type u
Y : Type v
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : HSpace X
inst✝ : HSpace Y
G : ↑I × X × Y → X × Y := fun p => (↑hmulE (p.fst, p.snd.fst), ↑hmulE (p.fst, p.snd.snd))
hG : Continuous G
t : ↑I
x : X
y : Y
h : x = e ∧ y = e
⊢ ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk G,
                  map_zero_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                          ↑(comp
                                (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
                            x),
                  map_one_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                          ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
              (t, x))
        (x, y) =
      ↑(comp (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
            (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
        (x, y) ∧
    ↑(ContinuousMap.mk fun x =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk G,
                  map_zero_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (0, x) =
                          ↑(comp
                                (ContinuousMap.mk fun p => (↑hmul (p.fst.fst, p.snd.fst), ↑hmul (p.fst.snd, p.snd.snd)))
                                (prodMk (ContinuousMap.id (X × Y)) (const (X × Y) (e, e))))
                            x),
                  map_one_left :=
                    (_ :
                      ∀ (x : X × Y),
                        ContinuousMap.toFun (ContinuousMap.mk G) (1, x) =
                          ↑(ContinuousMap.id (X × Y)) x) }.toContinuousMap
              (t, x))
        (x, y) =
      ↑(ContinuousMap.id (X × Y)) (x, y)
[PROOFSTEP]
exact
  ⟨Prod.mk.inj_iff.mpr
      ⟨HomotopyRel.eq_fst HSpace.hmulE t (Set.mem_singleton_iff.mpr h.1),
        HomotopyRel.eq_fst HSpace.hmulE t (Set.mem_singleton_iff.mpr h.2)⟩,
    Prod.mk.inj_iff.mpr ⟨(HSpace.hmulE.2 t x h.1).2, (HSpace.hmulE.2 t y h.2).2⟩⟩
[GOAL]
M : Type u
inst✝² : MulOneClass M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
⊢ comp (ContinuousMap.mk (Function.uncurry Mul.mul)) (prodMk (const M 1) (ContinuousMap.id M)) = ContinuousMap.id M
[PROOFSTEP]
ext1
[GOAL]
case h
M : Type u
inst✝² : MulOneClass M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
a✝ : M
⊢ ↑(comp (ContinuousMap.mk (Function.uncurry Mul.mul)) (prodMk (const M 1) (ContinuousMap.id M))) a✝ =
    ↑(ContinuousMap.id M) a✝
[PROOFSTEP]
apply one_mul
[GOAL]
M : Type u
inst✝² : MulOneClass M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
⊢ comp (ContinuousMap.mk (Function.uncurry Mul.mul)) (prodMk (ContinuousMap.id M) (const M 1)) = ContinuousMap.id M
[PROOFSTEP]
ext1
[GOAL]
case h
M : Type u
inst✝² : MulOneClass M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
a✝ : M
⊢ ↑(comp (ContinuousMap.mk (Function.uncurry Mul.mul)) (prodMk (ContinuousMap.id M) (const M 1))) a✝ =
    ↑(ContinuousMap.id M) a✝
[PROOFSTEP]
apply mul_one
[GOAL]
G G' : Type u
inst✝⁵ : TopologicalSpace G
inst✝⁴ : Group G
inst✝³ : TopologicalGroup G
inst✝² : TopologicalSpace G'
inst✝¹ : Group G'
inst✝ : TopologicalGroup G'
⊢ hSpace (G × G') = HSpace.prod G G'
[PROOFSTEP]
simp only [HSpace.prod]
[GOAL]
G G' : Type u
inst✝⁵ : TopologicalSpace G
inst✝⁴ : Group G
inst✝³ : TopologicalGroup G
inst✝² : TopologicalSpace G'
inst✝¹ : Group G'
inst✝ : TopologicalGroup G'
⊢ hSpace (G × G') =
    { hmul := ContinuousMap.mk fun p => (↑HSpace.hmul (p.fst.fst, p.snd.fst), ↑HSpace.hmul (p.fst.snd, p.snd.snd)),
      e := (HSpace.e, HSpace.e),
      hmul_e_e :=
        (_ :
          ↑(ContinuousMap.mk fun p => (↑HSpace.hmul (p.fst.fst, p.snd.fst), ↑HSpace.hmul (p.fst.snd, p.snd.snd)))
              ((HSpace.e, HSpace.e), HSpace.e, HSpace.e) =
            (HSpace.e, HSpace.e)),
      eHmul :=
        {
          toHomotopy :=
            {
              toContinuousMap :=
                ContinuousMap.mk fun p => (↑HSpace.eHmul (p.fst, p.snd.fst), ↑HSpace.eHmul (p.fst, p.snd.snd)),
              map_zero_left :=
                (_ :
                  ∀ (x : G × G'),
                    ContinuousMap.toFun
                        (ContinuousMap.mk fun p => (↑HSpace.eHmul (p.fst, p.snd.fst), ↑HSpace.eHmul (p.fst, p.snd.snd)))
                        (0, x) =
                      ↑(comp
                            (ContinuousMap.mk fun p =>
                              (↑HSpace.hmul (p.fst.fst, p.snd.fst), ↑HSpace.hmul (p.fst.snd, p.snd.snd)))
                            (prodMk (const (G × G') (HSpace.e, HSpace.e)) (ContinuousMap.id (G × G'))))
                        x),
              map_one_left :=
                (_ :
                  ∀ (x : G × G'),
                    ContinuousMap.toFun
                        (ContinuousMap.mk fun p => (↑HSpace.eHmul (p.fst, p.snd.fst), ↑HSpace.eHmul (p.fst, p.snd.snd)))
                        (1, x) =
                      ↑(ContinuousMap.id (G × G')) x) },
          prop' :=
            (_ :
              ∀ (t : ↑I) (x : G × G'),
                x ∈ {(HSpace.e, HSpace.e)} →
                  ↑(ContinuousMap.mk fun x =>
                            ContinuousMap.toFun
                              {
                                  toContinuousMap :=
                                    ContinuousMap.mk fun p =>
                                      (↑HSpace.eHmul (p.fst, p.snd.fst), ↑HSpace.eHmul (p.fst, p.snd.snd)),
                                  map_zero_left :=
                                    (_ :
                                      ∀ (x : G × G'),
                                        ContinuousMap.toFun
                                            (ContinuousMap.mk fun p =>
                                              (↑HSpace.eHmul (p.fst, p.snd.fst), ↑HSpace.eHmul (p.fst, p.snd.snd)))
                                            (0, x) =
                                          ↑(comp
                                                (ContinuousMap.mk fun p =>
                                                  (↑HSpace.hmul (p.fst.fst, p.snd.fst),
                                                    ↑HSpace.hmul (p.fst.snd, p.snd.snd)))
                                                (prodMk (const (G × G') (HSpace.e, HSpace.e))
                                                  (ContinuousMap.id (G × G'))))
                                            x),
                                  map_one_left :=
                                    (_ :
                                      ∀ (x : G × G'),
                                        ContinuousMap.toFun
                                            (ContinuousMap.mk fun p =>
                                              (↑HSpace.eHmul (p.fst, p.snd.fst), ↑HSpace.eHmul (p.fst, p.snd.snd)))
                                            (1, x) =
                                          ↑(ContinuousMap.id (G × G')) x) }.toContinuousMap
                              (t, x))
                        x =
                      ↑(comp
                            (ContinuousMap.mk fun p =>
                              (↑HSpace.hmul (p.fst.fst, p.snd.fst), ↑HSpace.hmul (p.fst.snd, p.snd.snd)))
                            (prodMk (const (G × G') (HSpace.e, HSpace.e)) (ContinuousMap.id (G × G'))))
                        x ∧
                    ↑(ContinuousMap.mk fun x =>
                            ContinuousMap.toFun
                              {
                                  toContinuousMap :=
                                    ContinuousMap.mk fun p =>
                                      (↑HSpace.eHmul (p.fst, p.snd.fst), ↑HSpace.eHmul (p.fst, p.snd.snd)),
                                  map_zero_left :=
                                    (_ :
                                      ∀ (x : G × G'),
                                        ContinuousMap.toFun
                                            (ContinuousMap.mk fun p =>
                                              (↑HSpace.eHmul (p.fst, p.snd.fst), ↑HSpace.eHmul (p.fst, p.snd.snd)))
                                            (0, x) =
                                          ↑(comp
                                                (ContinuousMap.mk fun p =>
                                                  (↑HSpace.hmul (p.fst.fst, p.snd.fst),
                                                    ↑HSpace.hmul (p.fst.snd, p.snd.snd)))
                                                (prodMk (const (G × G') (HSpace.e, HSpace.e))
                                                  (ContinuousMap.id (G × G'))))
                                            x),
                                  map_one_left :=
                                    (_ :
                                      ∀ (x : G × G'),
                                        ContinuousMap.toFun
                                            (ContinuousMap.mk fun p =>
                                              (↑HSpace.eHmul (p.fst, p.snd.fst), ↑HSpace.eHmul (p.fst, p.snd.snd)))
                                            (1, x) =
                                          ↑(ContinuousMap.id (G × G')) x) }.toContinuousMap
                              (t, x))
                        x =
                      ↑(ContinuousMap.id (G × G')) x) },
      hmulE :=
        {
          toHomotopy :=
            {
              toContinuousMap :=
                ContinuousMap.mk fun p => (↑HSpace.hmulE (p.fst, p.snd.fst), ↑HSpace.hmulE (p.fst, p.snd.snd)),
              map_zero_left :=
                (_ :
                  ∀ (x : G × G'),
                    ContinuousMap.toFun
                        (ContinuousMap.mk fun p => (↑HSpace.hmulE (p.fst, p.snd.fst), ↑HSpace.hmulE (p.fst, p.snd.snd)))
                        (0, x) =
                      ↑(comp
                            (ContinuousMap.mk fun p =>
                              (↑HSpace.hmul (p.fst.fst, p.snd.fst), ↑HSpace.hmul (p.fst.snd, p.snd.snd)))
                            (prodMk (ContinuousMap.id (G × G')) (const (G × G') (HSpace.e, HSpace.e))))
                        x),
              map_one_left :=
                (_ :
                  ∀ (x : G × G'),
                    ContinuousMap.toFun
                        (ContinuousMap.mk fun p => (↑HSpace.hmulE (p.fst, p.snd.fst), ↑HSpace.hmulE (p.fst, p.snd.snd)))
                        (1, x) =
                      ↑(ContinuousMap.id (G × G')) x) },
          prop' :=
            (_ :
              ∀ (t : ↑I) (x : G × G'),
                x ∈ {(HSpace.e, HSpace.e)} →
                  ↑(ContinuousMap.mk fun x =>
                            ContinuousMap.toFun
                              {
                                  toContinuousMap :=
                                    ContinuousMap.mk fun p =>
                                      (↑HSpace.hmulE (p.fst, p.snd.fst), ↑HSpace.hmulE (p.fst, p.snd.snd)),
                                  map_zero_left :=
                                    (_ :
                                      ∀ (x : G × G'),
                                        ContinuousMap.toFun
                                            (ContinuousMap.mk fun p =>
                                              (↑HSpace.hmulE (p.fst, p.snd.fst), ↑HSpace.hmulE (p.fst, p.snd.snd)))
                                            (0, x) =
                                          ↑(comp
                                                (ContinuousMap.mk fun p =>
                                                  (↑HSpace.hmul (p.fst.fst, p.snd.fst),
                                                    ↑HSpace.hmul (p.fst.snd, p.snd.snd)))
                                                (prodMk (ContinuousMap.id (G × G'))
                                                  (const (G × G') (HSpace.e, HSpace.e))))
                                            x),
                                  map_one_left :=
                                    (_ :
                                      ∀ (x : G × G'),
                                        ContinuousMap.toFun
                                            (ContinuousMap.mk fun p =>
                                              (↑HSpace.hmulE (p.fst, p.snd.fst), ↑HSpace.hmulE (p.fst, p.snd.snd)))
                                            (1, x) =
                                          ↑(ContinuousMap.id (G × G')) x) }.toContinuousMap
                              (t, x))
                        x =
                      ↑(comp
                            (ContinuousMap.mk fun p =>
                              (↑HSpace.hmul (p.fst.fst, p.snd.fst), ↑HSpace.hmul (p.fst.snd, p.snd.snd)))
                            (prodMk (ContinuousMap.id (G × G')) (const (G × G') (HSpace.e, HSpace.e))))
                        x ∧
                    ↑(ContinuousMap.mk fun x =>
                            ContinuousMap.toFun
                              {
                                  toContinuousMap :=
                                    ContinuousMap.mk fun p =>
                                      (↑HSpace.hmulE (p.fst, p.snd.fst), ↑HSpace.hmulE (p.fst, p.snd.snd)),
                                  map_zero_left :=
                                    (_ :
                                      ∀ (x : G × G'),
                                        ContinuousMap.toFun
                                            (ContinuousMap.mk fun p =>
                                              (↑HSpace.hmulE (p.fst, p.snd.fst), ↑HSpace.hmulE (p.fst, p.snd.snd)))
                                            (0, x) =
                                          ↑(comp
                                                (ContinuousMap.mk fun p =>
                                                  (↑HSpace.hmul (p.fst.fst, p.snd.fst),
                                                    ↑HSpace.hmul (p.fst.snd, p.snd.snd)))
                                                (prodMk (ContinuousMap.id (G × G'))
                                                  (const (G × G') (HSpace.e, HSpace.e))))
                                            x),
                                  map_one_left :=
                                    (_ :
                                      ∀ (x : G × G'),
                                        ContinuousMap.toFun
                                            (ContinuousMap.mk fun p =>
                                              (↑HSpace.hmulE (p.fst, p.snd.fst), ↑HSpace.hmulE (p.fst, p.snd.snd)))
                                            (1, x) =
                                          ↑(ContinuousMap.id (G × G')) x) }.toContinuousMap
                              (t, x))
                        x =
                      ↑(ContinuousMap.id (G × G')) x) } }
[PROOFSTEP]
rfl
[GOAL]
⊢ Continuous fun p => 2 * ↑p.fst
[PROOFSTEP]
continuity
[GOAL]
⊢ Continuous fun p => 1 + ↑p.snd
[PROOFSTEP]
continuity
[GOAL]
θ : ↑I
⊢ 2 * ↑(0, θ).fst / (1 + ↑(0, θ).snd) ≤ 0
[PROOFSTEP]
simp only [coe_zero, mul_zero, zero_div, le_refl]
[GOAL]
θ : ↑I
⊢ 1 * (1 + ↑(1, θ).snd) ≤ 2 * ↑(1, θ).fst
[PROOFSTEP]
dsimp only
[GOAL]
θ : ↑I
⊢ 1 * (1 + ↑θ) ≤ 2 * ↑1
[PROOFSTEP]
rw [coe_one, one_mul, mul_one, add_comm, ← one_add_one_eq_two]
[GOAL]
θ : ↑I
⊢ ↑θ + 1 ≤ 1 + 1
[PROOFSTEP]
simp only [add_le_add_iff_right]
[GOAL]
θ : ↑I
⊢ ↑θ ≤ 1
[PROOFSTEP]
exact le_one _
[GOAL]
t : ↑I
⊢ ↑(qRight (t, 0)) = if ↑t ≤ 1 / 2 then 2 * ↑t else 1
[PROOFSTEP]
simp only [qRight, coe_zero, add_zero, div_one]
[GOAL]
t : ↑I
⊢ ↑(Set.projIcc 0 1 qRight.proof_1 (2 * ↑t)) = if ↑t ≤ 1 / 2 then 2 * ↑t else 1
[PROOFSTEP]
split_ifs
[GOAL]
case pos
t : ↑I
h✝ : ↑t ≤ 1 / 2
⊢ ↑(Set.projIcc 0 1 qRight.proof_1 (2 * ↑t)) = 2 * ↑t
[PROOFSTEP]
rw [Set.projIcc_of_mem _ ((mul_pos_mem_iff zero_lt_two).2 _)]
[GOAL]
t : ↑I
h✝ : ↑t ≤ 1 / 2
⊢ ↑t ∈ Set.Icc 0 (1 / 2)
[PROOFSTEP]
refine' ⟨t.2.1, _⟩
[GOAL]
t : ↑I
h✝ : ↑t ≤ 1 / 2
⊢ ↑t ≤ 1 / 2
[PROOFSTEP]
tauto
[GOAL]
case neg
t : ↑I
h✝ : ¬↑t ≤ 1 / 2
⊢ ↑(Set.projIcc 0 1 qRight.proof_1 (2 * ↑t)) = 1
[PROOFSTEP]
rw [(Set.projIcc_eq_right _).2]
[GOAL]
case neg
t : ↑I
h✝ : ¬↑t ≤ 1 / 2
⊢ 1 ≤ 2 * ↑t
[PROOFSTEP]
linarith
[GOAL]
t : ↑I
h✝ : ¬↑t ≤ 1 / 2
⊢ 0 < 1
[PROOFSTEP]
exact zero_lt_one
[GOAL]
t : ↑I
⊢ qRight (t, 1) = Set.projIcc 0 1 (_ : 0 ≤ 1) ↑t
[PROOFSTEP]
rw [qRight]
[GOAL]
t : ↑I
⊢ Set.projIcc 0 1 qRight.proof_1 (2 * ↑(t, 1).fst / (1 + ↑(t, 1).snd)) = Set.projIcc 0 1 (_ : 0 ≤ 1) ↑t
[PROOFSTEP]
congr
[GOAL]
case e_x
t : ↑I
⊢ 2 * ↑(t, 1).fst / (1 + ↑(t, 1).snd) = ↑t
[PROOFSTEP]
norm_num
[GOAL]
case e_x
t : ↑I
⊢ 2 * ↑t / 2 = ↑t
[PROOFSTEP]
apply mul_div_cancel_left
[GOAL]
case e_x.ha
t : ↑I
⊢ 2 ≠ 0
[PROOFSTEP]
exact two_ne_zero
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
θ : ↑I
γ : Path x y
⊢ ContinuousMap.toFun (ContinuousMap.mk fun t => ↑γ (qRight (t, θ))) 0 = x
[PROOFSTEP]
dsimp only
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
θ : ↑I
γ : Path x y
⊢ ↑γ (qRight (0, θ)) = x
[PROOFSTEP]
rw [qRight_zero_left, γ.source]
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
θ : ↑I
γ : Path x y
⊢ ContinuousMap.toFun (ContinuousMap.mk fun t => ↑γ (qRight (t, θ))) 1 = y
[PROOFSTEP]
dsimp only
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
θ : ↑I
γ : Path x y
⊢ ↑γ (qRight (1, θ)) = y
[PROOFSTEP]
rw [qRight_one_left, γ.target]
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
⊢ delayReflRight 0 γ = trans γ (refl y)
[PROOFSTEP]
ext t
[GOAL]
case a.h
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
⊢ ↑(delayReflRight 0 γ) t = ↑(trans γ (refl y)) t
[PROOFSTEP]
simp only [delayReflRight, trans_apply, refl_extend, Path.coe_mk_mk, Function.comp_apply, refl_apply]
[GOAL]
case a.h
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
⊢ ↑γ (qRight (t, 0)) = if h : ↑t ≤ 1 / 2 then ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) } else y
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
case neg X : Type u inst✝ : TopologicalSpace X x y : X γ : Path x y t : ↑I h : ¬↑t ≤ 1 / 2 ⊢ ↑γ (qRight (t, 0)) = y
[PROOFSTEP]
swap
[GOAL]
case neg
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = y
case pos
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
[PROOFSTEP]
conv_rhs => rw [← γ.target]
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
| y
[PROOFSTEP]
rw [← γ.target]
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
| y
[PROOFSTEP]
rw [← γ.target]
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
| y
[PROOFSTEP]
rw [← γ.target]
[GOAL]
case neg
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ 1
case pos
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
[PROOFSTEP]
all_goals apply congr_arg γ; ext1; rw [qRight_zero_right]
[GOAL]
case neg
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ 1
[PROOFSTEP]
apply congr_arg γ
[GOAL]
case neg
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
⊢ qRight (t, 0) = 1
[PROOFSTEP]
ext1
[GOAL]
case neg.a
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
⊢ ↑(qRight (t, 0)) = ↑1
[PROOFSTEP]
rw [qRight_zero_right]
[GOAL]
case pos
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ ↑γ (qRight (t, 0)) = ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
[PROOFSTEP]
apply congr_arg γ
[GOAL]
case pos
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ qRight (t, 0) = { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
[PROOFSTEP]
ext1
[GOAL]
case pos.a
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ ↑(qRight (t, 0)) = ↑{ val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
[PROOFSTEP]
rw [qRight_zero_right]
[GOAL]
case neg.a
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ¬↑t ≤ 1 / 2
⊢ (if ↑t ≤ 1 / 2 then 2 * ↑t else 1) = ↑1
case pos.a
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
h : ↑t ≤ 1 / 2
⊢ (if ↑t ≤ 1 / 2 then 2 * ↑t else 1) = ↑{ val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
[PROOFSTEP]
exacts [if_neg h, if_pos h]
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
⊢ delayReflRight 1 γ = γ
[PROOFSTEP]
ext t
[GOAL]
case a.h
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
⊢ ↑(delayReflRight 1 γ) t = ↑γ t
[PROOFSTEP]
exact congr_arg γ (qRight_one_right t)
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
⊢ delayReflLeft 0 γ = trans (refl x) γ
[PROOFSTEP]
simp only [delayReflLeft, delayReflRight_zero, trans_symm, refl_symm, Path.symm_symm]
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
⊢ delayReflLeft 1 γ = γ
[PROOFSTEP]
simp only [delayReflLeft, delayReflRight_one, Path.symm_symm]
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x✝ y x : X
⊢ ∀ (t : ↑I) (x_1 : Path x x),
    x_1 ∈ {refl x} →
      ↑(ContinuousMap.mk fun x_2 =>
                ContinuousMap.toFun
                  { toContinuousMap := ContinuousMap.mk fun p => delayReflLeft p.fst p.snd,
                      map_zero_left := (_ : ∀ (γ : Path x x), delayReflLeft 0 γ = trans (refl x) γ),
                      map_one_left := (_ : ∀ (γ : Path x x), delayReflLeft 1 γ = γ) }.toContinuousMap
                  (t, x_2))
            x_1 =
          ↑(comp (ContinuousMap.mk fun ρ => trans ρ.fst ρ.snd)
                (prodMk (const (Path x x) (refl x)) (ContinuousMap.id (Path x x))))
            x_1 ∧
        ↑(ContinuousMap.mk fun x_2 =>
                ContinuousMap.toFun
                  { toContinuousMap := ContinuousMap.mk fun p => delayReflLeft p.fst p.snd,
                      map_zero_left := (_ : ∀ (γ : Path x x), delayReflLeft 0 γ = trans (refl x) γ),
                      map_one_left := (_ : ∀ (γ : Path x x), delayReflLeft 1 γ = γ) }.toContinuousMap
                  (t, x_2))
            x_1 =
          ↑(ContinuousMap.id (Path x x)) x_1
[PROOFSTEP]
rintro t _ (rfl : _ = _)
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x✝ y x : X
t : ↑I
⊢ ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun p => delayReflLeft p.fst p.snd,
                  map_zero_left := (_ : ∀ (γ : Path x x), delayReflLeft 0 γ = trans (refl x) γ),
                  map_one_left := (_ : ∀ (γ : Path x x), delayReflLeft 1 γ = γ) }.toContinuousMap
              (t, x_1))
        (refl x) =
      ↑(comp (ContinuousMap.mk fun ρ => trans ρ.fst ρ.snd)
            (prodMk (const (Path x x) (refl x)) (ContinuousMap.id (Path x x))))
        (refl x) ∧
    ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun p => delayReflLeft p.fst p.snd,
                  map_zero_left := (_ : ∀ (γ : Path x x), delayReflLeft 0 γ = trans (refl x) γ),
                  map_one_left := (_ : ∀ (γ : Path x x), delayReflLeft 1 γ = γ) }.toContinuousMap
              (t, x_1))
        (refl x) =
      ↑(ContinuousMap.id (Path x x)) (refl x)
[PROOFSTEP]
exact ⟨refl_trans_refl.symm, rfl⟩
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x✝ y x : X
⊢ ∀ (t : ↑I) (x_1 : Path x x),
    x_1 ∈ {refl x} →
      ↑(ContinuousMap.mk fun x_2 =>
                ContinuousMap.toFun
                  { toContinuousMap := ContinuousMap.mk fun p => delayReflRight p.fst p.snd,
                      map_zero_left := (_ : ∀ (γ : Path x x), delayReflRight 0 γ = trans γ (refl x)),
                      map_one_left := (_ : ∀ (γ : Path x x), delayReflRight 1 γ = γ) }.toContinuousMap
                  (t, x_2))
            x_1 =
          ↑(comp (ContinuousMap.mk fun ρ => trans ρ.fst ρ.snd)
                (prodMk (ContinuousMap.id (Path x x)) (const (Path x x) (refl x))))
            x_1 ∧
        ↑(ContinuousMap.mk fun x_2 =>
                ContinuousMap.toFun
                  { toContinuousMap := ContinuousMap.mk fun p => delayReflRight p.fst p.snd,
                      map_zero_left := (_ : ∀ (γ : Path x x), delayReflRight 0 γ = trans γ (refl x)),
                      map_one_left := (_ : ∀ (γ : Path x x), delayReflRight 1 γ = γ) }.toContinuousMap
                  (t, x_2))
            x_1 =
          ↑(ContinuousMap.id (Path x x)) x_1
[PROOFSTEP]
rintro t _ (rfl : _ = _)
[GOAL]
X : Type u
inst✝ : TopologicalSpace X
x✝ y x : X
t : ↑I
⊢ ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun p => delayReflRight p.fst p.snd,
                  map_zero_left := (_ : ∀ (γ : Path x x), delayReflRight 0 γ = trans γ (refl x)),
                  map_one_left := (_ : ∀ (γ : Path x x), delayReflRight 1 γ = γ) }.toContinuousMap
              (t, x_1))
        (refl x) =
      ↑(comp (ContinuousMap.mk fun ρ => trans ρ.fst ρ.snd)
            (prodMk (ContinuousMap.id (Path x x)) (const (Path x x) (refl x))))
        (refl x) ∧
    ↑(ContinuousMap.mk fun x_1 =>
            ContinuousMap.toFun
              { toContinuousMap := ContinuousMap.mk fun p => delayReflRight p.fst p.snd,
                  map_zero_left := (_ : ∀ (γ : Path x x), delayReflRight 0 γ = trans γ (refl x)),
                  map_one_left := (_ : ∀ (γ : Path x x), delayReflRight 1 γ = γ) }.toContinuousMap
              (t, x_1))
        (refl x) =
      ↑(ContinuousMap.id (Path x x)) (refl x)
[PROOFSTEP]
exact ⟨refl_trans_refl.symm, rfl⟩