[GOAL]
S : Type u_1
inst✝ : UnitalShelf S
x y : S
⊢ (x ◃ y) ◃ x = x ◃ y
[PROOFSTEP]
have h : (x ◃ y) ◃ x = (x ◃ y) ◃ (x ◃ 1) := by rw [act_one]
[GOAL]
S : Type u_1
inst✝ : UnitalShelf S
x y : S
⊢ (x ◃ y) ◃ x = (x ◃ y) ◃ x ◃ 1
[PROOFSTEP]
rw [act_one]
[GOAL]
S : Type u_1
inst✝ : UnitalShelf S
x y : S
h : (x ◃ y) ◃ x = (x ◃ y) ◃ x ◃ 1
⊢ (x ◃ y) ◃ x = x ◃ y
[PROOFSTEP]
rw [h, ← Shelf.self_distrib, act_one]
[GOAL]
S : Type u_1
inst✝ : UnitalShelf S
x : S
⊢ x ◃ x = x
[PROOFSTEP]
rw [← act_one x, ← Shelf.self_distrib, act_one, act_one]
[GOAL]
S : Type u_1
inst✝ : UnitalShelf S
x y : S
⊢ x ◃ x ◃ y = x ◃ y
[PROOFSTEP]
have h : x ◃ (x ◃ y) = (x ◃ 1) ◃ (x ◃ y) := by rw [act_one]
[GOAL]
S : Type u_1
inst✝ : UnitalShelf S
x y : S
⊢ x ◃ x ◃ y = (x ◃ 1) ◃ x ◃ y
[PROOFSTEP]
rw [act_one]
[GOAL]
S : Type u_1
inst✝ : UnitalShelf S
x y : S
h : x ◃ x ◃ y = (x ◃ 1) ◃ x ◃ y
⊢ x ◃ x ◃ y = x ◃ y
[PROOFSTEP]
rw [h, ← Shelf.self_distrib, one_act]
[GOAL]
S : Type u_1
inst✝ : UnitalShelf S
x y z : S
⊢ (x ◃ y) ◃ z = x ◃ y ◃ z
[PROOFSTEP]
rw [self_distrib, self_distrib, act_act_self_eq, act_self_act_eq]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ x ◃ y = x ◃ y' ↔ y = y'
[PROOFSTEP]
constructor
[GOAL]
case mp
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ x ◃ y = x ◃ y' → y = y'
case mpr R : Type u_1 inst✝ : Rack R x y y' : R ⊢ y = y' → x ◃ y = x ◃ y'
[PROOFSTEP]
apply (act' x).injective
[GOAL]
case mpr
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ y = y' → x ◃ y = x ◃ y'
[PROOFSTEP]
rintro rfl
[GOAL]
case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ y = x ◃ y
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y'
[PROOFSTEP]
constructor
[GOAL]
case mp
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ x ◃⁻¹ y = x ◃⁻¹ y' → y = y'
case mpr R : Type u_1 inst✝ : Rack R x y y' : R ⊢ y = y' → x ◃⁻¹ y = x ◃⁻¹ y'
[PROOFSTEP]
apply (act' x).symm.injective
[GOAL]
case mpr
R : Type u_1
inst✝ : Rack R
x y y' : R
⊢ y = y' → x ◃⁻¹ y = x ◃⁻¹ y'
[PROOFSTEP]
rintro rfl
[GOAL]
case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃⁻¹ y = x ◃⁻¹ y
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
inst✝ : Rack R
x y z : R
⊢ x ◃⁻¹ y ◃⁻¹ z = (x ◃⁻¹ y) ◃⁻¹ x ◃⁻¹ z
[PROOFSTEP]
rw [← left_cancel (x ◃⁻¹ y), right_inv, ← left_cancel x, right_inv, self_distrib]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y z : R
⊢ (x ◃ x ◃⁻¹ y) ◃ x ◃ x ◃⁻¹ y ◃⁻¹ z = z
[PROOFSTEP]
repeat' rw [right_inv]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y z : R
⊢ (x ◃ x ◃⁻¹ y) ◃ x ◃ x ◃⁻¹ y ◃⁻¹ z = z
[PROOFSTEP]
rw [right_inv]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y z : R
⊢ y ◃ x ◃ x ◃⁻¹ y ◃⁻¹ z = z
[PROOFSTEP]
rw [right_inv]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y z : R
⊢ y ◃ y ◃⁻¹ z = z
[PROOFSTEP]
rw [right_inv]
[GOAL]
R✝ : Type u_1
inst✝¹ : Rack R✝
R : Type u_2
inst✝ : Rack R
x y : R
⊢ act' (x ◃ y) = act' x * act' y * (act' x)⁻¹
[PROOFSTEP]
rw [eq_mul_inv_iff_mul_eq]
[GOAL]
R✝ : Type u_1
inst✝¹ : Rack R✝
R : Type u_2
inst✝ : Rack R
x y : R
⊢ act' (x ◃ y) * act' x = act' x * act' y
[PROOFSTEP]
ext z
[GOAL]
case H
R✝ : Type u_1
inst✝¹ : Rack R✝
R : Type u_2
inst✝ : Rack R
x y z : R
⊢ ↑(act' (x ◃ y) * act' x) z = ↑(act' x * act' y) z
[PROOFSTEP]
apply self_distrib.symm
[GOAL]
R : Type u_1
inst✝ : Rack R
⊢ ∀ {x y z : Rᵐᵒᵖ},
    (fun x y => op (unop x ◃⁻¹ unop y)) x ((fun x y => op (unop x ◃⁻¹ unop y)) y z) =
      (fun x y => op (unop x ◃⁻¹ unop y)) ((fun x y => op (unop x ◃⁻¹ unop y)) x y)
        ((fun x y => op (unop x ◃⁻¹ unop y)) x z)
[PROOFSTEP]
intro x y z
[GOAL]
R : Type u_1
inst✝ : Rack R
x y z : Rᵐᵒᵖ
⊢ (fun x y => op (unop x ◃⁻¹ unop y)) x ((fun x y => op (unop x ◃⁻¹ unop y)) y z) =
    (fun x y => op (unop x ◃⁻¹ unop y)) ((fun x y => op (unop x ◃⁻¹ unop y)) x y)
      ((fun x y => op (unop x ◃⁻¹ unop y)) x z)
[PROOFSTEP]
induction x using MulOpposite.rec'
[GOAL]
case h
R : Type u_1
inst✝ : Rack R
y z : Rᵐᵒᵖ
X✝ : R
⊢ (fun x y => op (unop x ◃⁻¹ unop y)) (op X✝) ((fun x y => op (unop x ◃⁻¹ unop y)) y z) =
    (fun x y => op (unop x ◃⁻¹ unop y)) ((fun x y => op (unop x ◃⁻¹ unop y)) (op X✝) y)
      ((fun x y => op (unop x ◃⁻¹ unop y)) (op X✝) z)
[PROOFSTEP]
induction y using MulOpposite.rec'
[GOAL]
case h.h
R : Type u_1
inst✝ : Rack R
z : Rᵐᵒᵖ
X✝¹ X✝ : R
⊢ (fun x y => op (unop x ◃⁻¹ unop y)) (op X✝¹) ((fun x y => op (unop x ◃⁻¹ unop y)) (op X✝) z) =
    (fun x y => op (unop x ◃⁻¹ unop y)) ((fun x y => op (unop x ◃⁻¹ unop y)) (op X✝¹) (op X✝))
      ((fun x y => op (unop x ◃⁻¹ unop y)) (op X✝¹) z)
[PROOFSTEP]
induction z using MulOpposite.rec'
[GOAL]
case h.h.h
R : Type u_1
inst✝ : Rack R
X✝² X✝¹ X✝ : R
⊢ (fun x y => op (unop x ◃⁻¹ unop y)) (op X✝²) ((fun x y => op (unop x ◃⁻¹ unop y)) (op X✝¹) (op X✝)) =
    (fun x y => op (unop x ◃⁻¹ unop y)) ((fun x y => op (unop x ◃⁻¹ unop y)) (op X✝²) (op X✝¹))
      ((fun x y => op (unop x ◃⁻¹ unop y)) (op X✝²) (op X✝))
[PROOFSTEP]
simp only [op_inj, unop_op, op_unop]
[GOAL]
case h.h.h
R : Type u_1
inst✝ : Rack R
X✝² X✝¹ X✝ : R
⊢ X✝² ◃⁻¹ X✝¹ ◃⁻¹ X✝ = (X✝² ◃⁻¹ X✝¹) ◃⁻¹ X✝² ◃⁻¹ X✝
[PROOFSTEP]
rw [self_distrib_inv]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ (fun x y => op (unop x ◃ unop y)) (op x) (op x ◃ op y) = op y
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ op x ◃ (fun x y => op (unop x ◃ unop y)) (op x) (op y) = op y
[PROOFSTEP]
simp
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃ x) ◃ y = x ◃ y
[PROOFSTEP]
rw [← right_inv x y, ← self_distrib]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃⁻¹ x) ◃⁻¹ y = x ◃⁻¹ y
[PROOFSTEP]
have h := @self_act_act_eq _ _ (op x) (op y)
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
h : (op x ◃ op x) ◃ op y = op x ◃ op y
⊢ (x ◃⁻¹ x) ◃⁻¹ y = x ◃⁻¹ y
[PROOFSTEP]
simpa using h
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃ x) ◃⁻¹ y = x ◃⁻¹ y
[PROOFSTEP]
rw [← left_cancel (x ◃ x)]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃ x) ◃ (x ◃ x) ◃⁻¹ y = (x ◃ x) ◃ x ◃⁻¹ y
[PROOFSTEP]
rw [right_inv]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ y = (x ◃ x) ◃ x ◃⁻¹ y
[PROOFSTEP]
rw [self_act_act_eq]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ y = x ◃ x ◃⁻¹ y
[PROOFSTEP]
rw [right_inv]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃⁻¹ x) ◃ y = x ◃ y
[PROOFSTEP]
have h := @self_act_invAct_eq _ _ (op x) (op y)
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
h : (op x ◃ op x) ◃⁻¹ op y = op x ◃⁻¹ op y
⊢ (x ◃⁻¹ x) ◃ y = x ◃ y
[PROOFSTEP]
simpa using h
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y ↔ x = y
[PROOFSTEP]
constructor
[GOAL]
case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y
case mpr R : Type u_1 inst✝ : Rack R x y : R ⊢ x = y → x ◃ x = y ◃ y
[PROOFSTEP]
swap
[GOAL]
case mpr
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x = y → x ◃ x = y ◃ y
case mp R : Type u_1 inst✝ : Rack R x y : R ⊢ x ◃ x = y ◃ y → x = y
[PROOFSTEP]
rintro rfl
[GOAL]
case mpr
R : Type u_1
inst✝ : Rack R
x : R
⊢ x ◃ x = x ◃ x
case mp R : Type u_1 inst✝ : Rack R x y : R ⊢ x ◃ x = y ◃ y → x = y
[PROOFSTEP]
rfl
[GOAL]
case mp
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃ x = y ◃ y → x = y
[PROOFSTEP]
intro h
[GOAL]
case mp
R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ x = y
[PROOFSTEP]
trans (x ◃ x) ◃⁻¹ x ◃ x
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ x = (x ◃ x) ◃⁻¹ x ◃ x
R : Type u_1 inst✝ : Rack R x y : R h : x ◃ x = y ◃ y ⊢ (x ◃ x) ◃⁻¹ x ◃ x = y
[PROOFSTEP]
rw [← left_cancel (x ◃ x), right_inv, self_act_act_eq]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
h : x ◃ x = y ◃ y
⊢ (x ◃ x) ◃⁻¹ x ◃ x = y
[PROOFSTEP]
rw [h, ← left_cancel (y ◃ y), right_inv, self_act_act_eq]
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y
[PROOFSTEP]
have h := @self_act_eq_iff_eq _ _ (op x) (op y)
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
h : op x ◃ op x = op y ◃ op y ↔ op x = op y
⊢ x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y
[PROOFSTEP]
simpa using h
[GOAL]
R✝ : Type u_1
inst✝¹ : Rack R✝
R : Type u_2
inst✝ : Rack R
x : R
⊢ (fun x => x ◃⁻¹ x) ((fun x => x ◃ x) x) = x
[PROOFSTEP]
simp
[GOAL]
R✝ : Type u_1
inst✝¹ : Rack R✝
R : Type u_2
inst✝ : Rack R
x : R
⊢ (fun x => x ◃ x) ((fun x => x ◃⁻¹ x) x) = x
[PROOFSTEP]
simp
[GOAL]
R✝ : Type u_1
inst✝¹ : Rack R✝
R : Type u_2
inst✝ : Rack R
h : IsInvolutory R
x y : R
⊢ x ◃⁻¹ y = x ◃ y
[PROOFSTEP]
rw [← left_cancel x, right_inv, h x]
[GOAL]
R✝ : Type u_1
inst✝¹ : Rack R✝
R : Type u_2
inst✝ : Rack R
x y z : R
⊢ x ◃ y ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z
[PROOFSTEP]
rw [self_distrib]
[GOAL]
R✝ : Type u_1
inst✝¹ : Rack R✝
R : Type u_2
inst✝ : Rack R
x y z : R
⊢ (x ◃ y) ◃ x ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z
[PROOFSTEP]
rw [left_cancel]
[GOAL]
S₁ : Type u_1
S₂ : Type u_2
S₃ : Type u_3
inst✝³ : Shelf S₁
inst✝² : Shelf S₂
inst✝¹ : Shelf S₃
S : Type u_4
inst✝ : Shelf S
⊢ ∀ {x y : S}, (fun x => x) (x ◃ y) = (fun x => x) x ◃ (fun x => x) y
[PROOFSTEP]
simp
[GOAL]
S₁ : Type u_1
S₂ : Type u_2
S₃ : Type u_3
inst✝² : Shelf S₁
inst✝¹ : Shelf S₂
inst✝ : Shelf S₃
g : S₂ →◃ S₃
f : S₁ →◃ S₂
⊢ ∀ {x y : S₁}, (g.toFun ∘ f.toFun) (x ◃ y) = (g.toFun ∘ f.toFun) x ◃ (g.toFun ∘ f.toFun) y
[PROOFSTEP]
simp
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
x : Q
⊢ x ◃⁻¹ x = x
[PROOFSTEP]
rw [← left_cancel x]
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
x : Q
⊢ x ◃ x ◃⁻¹ x = x ◃ x
[PROOFSTEP]
simp
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
⊢ ∀ {x : Qᵐᵒᵖ}, x ◃ x = x
[PROOFSTEP]
intro x
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
x : Qᵐᵒᵖ
⊢ x ◃ x = x
[PROOFSTEP]
induction' x using MulOpposite.rec'
[GOAL]
case h
Q : Type u_1
inst✝ : Quandle Q
X✝ : Q
⊢ op X✝ ◃ op X✝ = op X✝
[PROOFSTEP]
simp
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
⊢ ∀ {x y z : Conj G},
    (fun x => ↑(↑MulAut.conj x)) x ((fun x => ↑(↑MulAut.conj x)) y z) =
      (fun x => ↑(↑MulAut.conj x)) ((fun x => ↑(↑MulAut.conj x)) x y) ((fun x => ↑(↑MulAut.conj x)) x z)
[PROOFSTEP]
intro x y z
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y z : Conj G
⊢ (fun x => ↑(↑MulAut.conj x)) x ((fun x => ↑(↑MulAut.conj x)) y z) =
    (fun x => ↑(↑MulAut.conj x)) ((fun x => ↑(↑MulAut.conj x)) x y) ((fun x => ↑(↑MulAut.conj x)) x z)
[PROOFSTEP]
dsimp only [MulAut.conj_apply]
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y z : Conj G
⊢ x * (y * z * y⁻¹) * x⁻¹ = x * y * x⁻¹ * (x * z * x⁻¹) * (x * y * x⁻¹)⁻¹
[PROOFSTEP]
simp [mul_assoc]
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ (fun x => ↑(MulEquiv.symm (↑MulAut.conj x))) x (x ◃ y) = y
[PROOFSTEP]
simp [act', mul_assoc]
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ x ◃ (fun x => ↑(MulEquiv.symm (↑MulAut.conj x))) x y = y
[PROOFSTEP]
simp [act', mul_assoc]
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
⊢ ∀ {x : Conj G}, x ◃ x = x
[PROOFSTEP]
simp
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ x ◃ y = y ↔ y ◃ x = x
[PROOFSTEP]
dsimp [Conj] at *
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ x * y * x⁻¹ = y ↔ y * x * y⁻¹ = x
[PROOFSTEP]
constructor
[GOAL]
case mp
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ x * y * x⁻¹ = y → y * x * y⁻¹ = x
case mpr Q : Type u_1 inst✝¹ : Quandle Q G : Type u_2 inst✝ : Group G x y : Conj G ⊢ y * x * y⁻¹ = x → x * y * x⁻¹ = y
[PROOFSTEP]
repeat' intro h; conv_rhs => rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
[GOAL]
case mp
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ x * y * x⁻¹ = y → y * x * y⁻¹ = x
[PROOFSTEP]
intro h
[GOAL]
case mp
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : x * y * x⁻¹ = y
⊢ y * x * y⁻¹ = x
[PROOFSTEP]
conv_rhs => rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : x * y * x⁻¹ = y
| x
[PROOFSTEP]
rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : x * y * x⁻¹ = y
| x
[PROOFSTEP]
rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : x * y * x⁻¹ = y
| x
[PROOFSTEP]
rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : x * y * x⁻¹ = y
| y * x⁻¹⁻¹ * y⁻¹
[PROOFSTEP]
simp
[GOAL]
case mpr
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
⊢ y * x * y⁻¹ = x → x * y * x⁻¹ = y
[PROOFSTEP]
intro h
[GOAL]
case mpr
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : y * x * y⁻¹ = x
⊢ x * y * x⁻¹ = y
[PROOFSTEP]
conv_rhs => rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : y * x * y⁻¹ = x
| y
[PROOFSTEP]
rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : y * x * y⁻¹ = x
| y
[PROOFSTEP]
rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]; simp
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : y * x * y⁻¹ = x
| y
[PROOFSTEP]
rw [eq_mul_inv_of_mul_eq (eq_mul_inv_of_mul_eq h)]
[GOAL]
Q : Type u_1
inst✝¹ : Quandle Q
G : Type u_2
inst✝ : Group G
x y : Conj G
h : y * x * y⁻¹ = x
| x * y⁻¹⁻¹ * x⁻¹
[PROOFSTEP]
simp
[GOAL]
Q : Type u_1
inst✝² : Quandle Q
G : Type u_2
H : Type u_3
inst✝¹ : Group G
inst✝ : Group H
f : G →* H
⊢ ∀ {x y : Conj G}, ↑f (x ◃ y) = ↑f x ◃ ↑f y
[PROOFSTEP]
simp
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
n : ℕ
a : ZMod n
⊢ Function.Involutive (dihedralAct n a)
[PROOFSTEP]
intro b
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
n : ℕ
a b : ZMod n
⊢ dihedralAct n a (dihedralAct n a b) = b
[PROOFSTEP]
dsimp only [dihedralAct]
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
n : ℕ
a b : ZMod n
⊢ 2 * a - (2 * a - b) = b
[PROOFSTEP]
simp
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
n : ℕ
⊢ ∀ {x y z : Dihedral n}, dihedralAct n x (dihedralAct n y z) = dihedralAct n (dihedralAct n x y) (dihedralAct n x z)
[PROOFSTEP]
intro x y z
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
n : ℕ
x y z : Dihedral n
⊢ dihedralAct n x (dihedralAct n y z) = dihedralAct n (dihedralAct n x y) (dihedralAct n x z)
[PROOFSTEP]
simp only [dihedralAct]
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
n : ℕ
x y z : Dihedral n
⊢ 2 * x - (2 * y - z) = 2 * (2 * x - y) - (2 * x - z)
[PROOFSTEP]
ring_nf
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
n : ℕ
⊢ ∀ {x : Dihedral n}, x ◃ x = x
[PROOFSTEP]
intro x
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
n : ℕ
x : Dihedral n
⊢ x ◃ x = x
[PROOFSTEP]
simp only [dihedralAct]
[GOAL]
Q : Type u_1
inst✝ : Quandle Q
n : ℕ
x : Dihedral n
⊢ 2 * x - x = x
[PROOFSTEP]
ring_nf
[GOAL]
R : Type u_1
inst✝ : Rack R
⊢ ∀ {x y : R}, act' (x ◃ y) = act' x ◃ act' y
[PROOFSTEP]
intro x y
[GOAL]
R : Type u_1
inst✝ : Rack R
x y : R
⊢ act' (x ◃ y) = act' x ◃ act' y
[PROOFSTEP]
exact ad_conj x y
[GOAL]
R : Type u_1
inst✝ : Rack R
⊢ Equivalence (PreEnvelGroupRel R)
[PROOFSTEP]
constructor
[GOAL]
case refl
R : Type u_1
inst✝ : Rack R
⊢ ∀ (x : PreEnvelGroup R), PreEnvelGroupRel R x x
[PROOFSTEP]
apply PreEnvelGroupRel.refl
[GOAL]
case symm
R : Type u_1
inst✝ : Rack R
⊢ ∀ {x y : PreEnvelGroup R}, PreEnvelGroupRel R x y → PreEnvelGroupRel R y x
[PROOFSTEP]
apply PreEnvelGroupRel.symm
[GOAL]
case trans
R : Type u_1
inst✝ : Rack R
⊢ ∀ {x y z : PreEnvelGroup R}, PreEnvelGroupRel R x y → PreEnvelGroupRel R y z → PreEnvelGroupRel R x z
[PROOFSTEP]
apply PreEnvelGroupRel.trans
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a✝ b✝ a'✝ b'✝ : PreEnvelGroup R
ha : PreEnvelGroupRel' R a✝ a'✝
hb : PreEnvelGroupRel' R b✝ b'✝
⊢ mapAux f (PreEnvelGroup.mul a✝ b✝) = mapAux f (PreEnvelGroup.mul a'✝ b'✝)
[PROOFSTEP]
simp [toEnvelGroup.mapAux, well_def f ha, well_def f hb]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a✝ a'✝ : PreEnvelGroup R
ha : PreEnvelGroupRel' R a✝ a'✝
⊢ mapAux f (PreEnvelGroup.inv a✝) = mapAux f (PreEnvelGroup.inv a'✝)
[PROOFSTEP]
simp [toEnvelGroup.mapAux, well_def f ha]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a b c : PreEnvelGroup R
⊢ mapAux f (PreEnvelGroup.mul (PreEnvelGroup.mul a b) c) = mapAux f (PreEnvelGroup.mul a (PreEnvelGroup.mul b c))
[PROOFSTEP]
apply mul_assoc
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a : PreEnvelGroup R
⊢ mapAux f (PreEnvelGroup.mul unit a) = mapAux f a
[PROOFSTEP]
simp [toEnvelGroup.mapAux]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a : PreEnvelGroup R
⊢ mapAux f (PreEnvelGroup.mul a unit) = mapAux f a
[PROOFSTEP]
simp [toEnvelGroup.mapAux]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
a : PreEnvelGroup R
⊢ mapAux f (PreEnvelGroup.mul (PreEnvelGroup.inv a) a) = mapAux f unit
[PROOFSTEP]
simp [toEnvelGroup.mapAux]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
x y : R
⊢ mapAux f (PreEnvelGroup.mul (PreEnvelGroup.mul (incl x) (incl y)) (PreEnvelGroup.inv (incl x))) =
    mapAux f (incl (x ◃ y))
[PROOFSTEP]
simp [toEnvelGroup.mapAux]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
⊢ (fun x => Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b)) 1 = 1
[PROOFSTEP]
change Quotient.liftOn ⟦Rack.PreEnvelGroup.unit⟧ (toEnvelGroup.mapAux f) _ = 1
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
⊢ Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
      (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
    1
[PROOFSTEP]
simp only [Quotient.lift_mk, mapAux]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
x✝ y✝ : EnvelGroup R
x y : PreEnvelGroup R
⊢ OneHom.toFun
      { toFun := fun x => Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
        map_one' :=
          (_ :
            Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
              1) }
      (Quotient.mk (setoid R) x * Quotient.mk (setoid R) y) =
    OneHom.toFun
        {
          toFun := fun x =>
            Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
          map_one' :=
            (_ :
              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                1) }
        (Quotient.mk (setoid R) x) *
      OneHom.toFun
        {
          toFun := fun x =>
            Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
          map_one' :=
            (_ :
              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                1) }
        (Quotient.mk (setoid R) y)
[PROOFSTEP]
simp only [toEnvelGroup.mapAux]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
x✝ y✝ : EnvelGroup R
x y : PreEnvelGroup R
⊢ Quotient.liftOn (Quotient.mk (setoid R) x * Quotient.mk (setoid R) y) (mapAux f)
      (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
    Quotient.liftOn (Quotient.mk (setoid R) x) (mapAux f)
        (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) *
      Quotient.liftOn (Quotient.mk (setoid R) y) (mapAux f)
        (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b)
[PROOFSTEP]
change Quotient.liftOn ⟦mul x y⟧ (toEnvelGroup.mapAux f) _ = _
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
x✝ y✝ : EnvelGroup R
x y : PreEnvelGroup R
⊢ Quotient.liftOn (Quotient.mk (setoid R) (PreEnvelGroup.mul x y)) (mapAux f)
      (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
    Quotient.liftOn (Quotient.mk (setoid R) x) (mapAux f)
        (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) *
      Quotient.liftOn (Quotient.mk (setoid R) y) (mapAux f)
        (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b)
[PROOFSTEP]
simp [toEnvelGroup.mapAux]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
⊢ (fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R))
      ((fun f =>
          {
            toOneHom :=
              {
                toFun := fun x =>
                  Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                map_one' :=
                  (_ :
                    Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                        (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                      1) },
            map_mul' :=
              (_ :
                ∀ (x y : EnvelGroup R),
                  OneHom.toFun
                      {
                        toFun := fun x =>
                          Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                        map_one' :=
                          (_ :
                            Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                              1) }
                      (x * y) =
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        x *
                      OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        y) })
        f) =
    f
[PROOFSTEP]
ext
[GOAL]
case toFun.h
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
f : R →◃ Quandle.Conj G
x✝ : R
⊢ ShelfHom.toFun
      ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R))
        ((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          f))
      x✝ =
    ShelfHom.toFun f x✝
[PROOFSTEP]
rfl
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x✝ : EnvelGroup R
x : PreEnvelGroup R
⊢ ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) x) =
    ↑F (Quotient.mk (setoid R) x)
[PROOFSTEP]
induction' x with _ x y ih_x ih_y x ih_x
[GOAL]
case unit
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x : EnvelGroup R
⊢ ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) unit) =
    ↑F (Quotient.mk (setoid R) unit)
[PROOFSTEP]
exact F.map_one.symm
[GOAL]
case incl
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x : EnvelGroup R
x✝ : R
⊢ ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) (incl x✝)) =
    ↑F (Quotient.mk (setoid R) (incl x✝))
[PROOFSTEP]
rfl
[GOAL]
case mul
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x✝ : EnvelGroup R
x y : PreEnvelGroup R
ih_x :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) x) =
    ↑F (Quotient.mk (setoid R) x)
ih_y :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) y) =
    ↑F (Quotient.mk (setoid R) y)
⊢ ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) (PreEnvelGroup.mul x y)) =
    ↑F (Quotient.mk (setoid R) (PreEnvelGroup.mul x y))
[PROOFSTEP]
have hm : ⟦x.mul y⟧ = @Mul.mul (EnvelGroup R) _ ⟦x⟧ ⟦y⟧ := rfl
[GOAL]
case mul
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x✝ : EnvelGroup R
x y : PreEnvelGroup R
ih_x :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) x) =
    ↑F (Quotient.mk (setoid R) x)
ih_y :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) y) =
    ↑F (Quotient.mk (setoid R) y)
hm : Quotient.mk (setoid R) (PreEnvelGroup.mul x y) = Mul.mul (Quotient.mk (setoid R) x) (Quotient.mk (setoid R) y)
⊢ ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) (PreEnvelGroup.mul x y)) =
    ↑F (Quotient.mk (setoid R) (PreEnvelGroup.mul x y))
[PROOFSTEP]
simp only [MonoidHom.coe_mk, OneHom.coe_mk, Quotient.lift_mk]
[GOAL]
case mul
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x✝ : EnvelGroup R
x y : PreEnvelGroup R
ih_x :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) x) =
    ↑F (Quotient.mk (setoid R) x)
ih_y :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) y) =
    ↑F (Quotient.mk (setoid R) y)
hm : Quotient.mk (setoid R) (PreEnvelGroup.mul x y) = Mul.mul (Quotient.mk (setoid R) x) (Quotient.mk (setoid R) y)
⊢ mapAux (ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) (PreEnvelGroup.mul x y) =
    ↑F (Quotient.mk (setoid R) (PreEnvelGroup.mul x y))
[PROOFSTEP]
suffices ∀ x y, F (Mul.mul x y) = F (x) * F (y)
  by
  simp_all only [MonoidHom.coe_mk, OneHom.coe_mk, Quotient.lift_mk, hm]
  rw [← ih_x, ← ih_y, mapAux]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x✝ : EnvelGroup R
x y : PreEnvelGroup R
ih_x :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) x) =
    ↑F (Quotient.mk (setoid R) x)
ih_y :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) y) =
    ↑F (Quotient.mk (setoid R) y)
hm : Quotient.mk (setoid R) (PreEnvelGroup.mul x y) = Mul.mul (Quotient.mk (setoid R) x) (Quotient.mk (setoid R) y)
this : ∀ (x y : EnvelGroup R), ↑F (Mul.mul x y) = ↑F x * ↑F y
⊢ mapAux (ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) (PreEnvelGroup.mul x y) =
    ↑F (Quotient.mk (setoid R) (PreEnvelGroup.mul x y))
[PROOFSTEP]
simp_all only [MonoidHom.coe_mk, OneHom.coe_mk, Quotient.lift_mk, hm]
[GOAL]
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x✝ : EnvelGroup R
x y : PreEnvelGroup R
ih_x : mapAux (ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) x = ↑F (Quotient.mk (setoid R) x)
ih_y : mapAux (ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) y = ↑F (Quotient.mk (setoid R) y)
hm : Quotient.mk (setoid R) (PreEnvelGroup.mul x y) = Mul.mul (Quotient.mk (setoid R) x) (Quotient.mk (setoid R) y)
this : ∀ (x y : EnvelGroup R), ↑F (Mul.mul x y) = ↑F x * ↑F y
⊢ mapAux (ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) (PreEnvelGroup.mul x y) =
    ↑F (Quotient.mk (setoid R) x) * ↑F (Quotient.mk (setoid R) y)
[PROOFSTEP]
rw [← ih_x, ← ih_y, mapAux]
[GOAL]
case mul
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x✝ : EnvelGroup R
x y : PreEnvelGroup R
ih_x :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) x) =
    ↑F (Quotient.mk (setoid R) x)
ih_y :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) y) =
    ↑F (Quotient.mk (setoid R) y)
hm : Quotient.mk (setoid R) (PreEnvelGroup.mul x y) = Mul.mul (Quotient.mk (setoid R) x) (Quotient.mk (setoid R) y)
⊢ ∀ (x y : EnvelGroup R), ↑F (Mul.mul x y) = ↑F x * ↑F y
[PROOFSTEP]
exact F.map_mul
[GOAL]
case inv
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x✝ : EnvelGroup R
x : PreEnvelGroup R
ih_x :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) x) =
    ↑F (Quotient.mk (setoid R) x)
⊢ ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) (PreEnvelGroup.inv x)) =
    ↑F (Quotient.mk (setoid R) (PreEnvelGroup.inv x))
[PROOFSTEP]
have hm : ⟦x.inv⟧ = @Inv.inv (EnvelGroup R) _ ⟦x⟧ := rfl
[GOAL]
case inv
R : Type u_1
inst✝¹ : Rack R
G : Type u_2
inst✝ : Group G
F : EnvelGroup R →* G
x✝ : EnvelGroup R
x : PreEnvelGroup R
ih_x :
  ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) x) =
    ↑F (Quotient.mk (setoid R) x)
hm : Quotient.mk (setoid R) (PreEnvelGroup.inv x) = (Quotient.mk (setoid R) x)⁻¹
⊢ ↑((fun f =>
            {
              toOneHom :=
                {
                  toFun := fun x =>
                    Quotient.liftOn x (mapAux f) (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                  map_one' :=
                    (_ :
                      Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                          (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                        1) },
              map_mul' :=
                (_ :
                  ∀ (x y : EnvelGroup R),
                    OneHom.toFun
                        {
                          toFun := fun x =>
                            Quotient.liftOn x (mapAux f)
                              (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                          map_one' :=
                            (_ :
                              Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                  (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                1) }
                        (x * y) =
                      OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          x *
                        OneHom.toFun
                          {
                            toFun := fun x =>
                              Quotient.liftOn x (mapAux f)
                                (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b),
                            map_one' :=
                              (_ :
                                Quotient.liftOn (Quotient.mk (setoid R) unit) (mapAux f)
                                    (_ : ∀ (a b : PreEnvelGroup R), a ≈ b → mapAux f a = mapAux f b) =
                                  1) }
                          y) })
          ((fun F => ShelfHom.comp (Quandle.Conj.map F) (toEnvelGroup R)) F))
      (Quotient.mk (setoid R) (PreEnvelGroup.inv x)) =
    ↑F (Quotient.mk (setoid R) (PreEnvelGroup.inv x))
[PROOFSTEP]
rw [hm, F.map_inv, MonoidHom.map_inv, ih_x]


[GOAL]
C : Type ?u.30361
inst✝ : Category.{?u.30362, ?u.30361} C
X Y : C
f : X ⟶ Y
⊢ 𝟙 X ≫ f = f
[PROOFSTEP]
simp
[GOAL]
C : Type ?u.30529
inst✝ : Category.{?u.30530, ?u.30529} C
X Y : C
f : X ⟶ Y
⊢ f ≫ 𝟙 Y = f
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
w : f = g
h : Y ⟶ Z
⊢ f ≫ h = g ≫ h
[PROOFSTEP]
rw [w]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
g h : Y ⟶ Z
w : g = h
⊢ f ≫ g = f ≫ h
[PROOFSTEP]
rw [w]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
w : ∀ {Z : C} (h : Y ⟶ Z), f ≫ h = g ≫ h
⊢ f = g
[PROOFSTEP]
convert w (𝟙 Y)
[GOAL]
case h.e'_2
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
w : ∀ {Z : C} (h : Y ⟶ Z), f ≫ h = g ≫ h
⊢ f = f ≫ 𝟙 Y
[PROOFSTEP]
aesop
[GOAL]
case h.e'_3
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
w : ∀ {Z : C} (h : Y ⟶ Z), f ≫ h = g ≫ h
⊢ g = g ≫ 𝟙 Y
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f g : Y ⟶ Z
w : ∀ {X : C} (h : X ⟶ Y), h ≫ f = h ≫ g
⊢ f = g
[PROOFSTEP]
convert w (𝟙 Y)
[GOAL]
case h.e'_2
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f g : Y ⟶ Z
w : ∀ {X : C} (h : X ⟶ Y), h ≫ f = h ≫ g
⊢ f = 𝟙 Y ≫ f
[PROOFSTEP]
aesop
[GOAL]
case h.e'_3
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f g : Y ⟶ Z
w : ∀ {X : C} (h : X ⟶ Y), h ≫ f = h ≫ g
⊢ g = 𝟙 Y ≫ g
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X Y Z✝ : C
f g : X ⟶ Y
w : (fun {Z} h => f ≫ h) = fun {Z} h => g ≫ h
Z : C
h : Y ⟶ Z
⊢ f ≫ h = g ≫ h
[PROOFSTEP]
convert congr_fun (congr_fun w Z) h
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ Y Z : C
f g : Y ⟶ Z
w : (fun {X} h => h ≫ f) = fun {X} h => h ≫ g
X : C
h : X ⟶ Y
⊢ h ≫ f = h ≫ g
[PROOFSTEP]
convert congr_fun (congr_fun w X) h
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : X ⟶ Y), f ≫ g = g
⊢ f = 𝟙 X
[PROOFSTEP]
convert w (𝟙 X)
[GOAL]
case h.e'_2
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : X ⟶ Y), f ≫ g = g
⊢ f = f ≫ 𝟙 X
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : Y ⟶ X), g ≫ f = g
⊢ f = 𝟙 X
[PROOFSTEP]
convert w (𝟙 X)
[GOAL]
case h.e'_2
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f : X ⟶ X
w : ∀ {Y : C} (g : Y ⟶ X), g ≫ f = g
⊢ f = 𝟙 X ≫ f
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
X Y Z : C
f : X ⟶ Y
g g' : Y ⟶ Z
⊢ (f ≫ if P then g else g') = if P then f ≫ g else f ≫ g'
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
X Y Z : C
f f' : X ⟶ Y
g : Y ⟶ Z
⊢ (if P then f else f') ≫ g = if P then f ≫ g else f' ≫ g
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
X Y Z : C
f : X ⟶ Y
g : P → (Y ⟶ Z)
g' : ¬P → (Y ⟶ Z)
⊢ (f ≫ if h : P then g h else g' h) = if h : P then f ≫ g h else f ≫ g' h
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
X Y Z : C
f : P → (X ⟶ Y)
f' : ¬P → (X ⟶ Y)
g : Y ⟶ Z
⊢ (if h : P then f h else f' h) ≫ g = if h : P then f h ≫ g else f' h ≫ g
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ Y Z X Z✝ : C
g h : X ⟶ Z✝
w : 𝟙 X ≫ g = 𝟙 X ≫ h
⊢ g = h
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ Y Z X Z✝ : C
g h : Z✝ ⟶ X
w : g ≫ 𝟙 X = h ≫ 𝟙 X
⊢ g = h
[PROOFSTEP]
aesop
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
h : Y ⟶ Y
⊢ f ≫ h = f ↔ h = 𝟙 Y
[PROOFSTEP]
convert cancel_epi f
[GOAL]
case h.e'_1.h.e'_3.h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : Epi f
h : Y ⟶ Y
⊢ f = f ≫ 𝟙 Y
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
g : X ⟶ X
⊢ g ≫ f = f ↔ g = 𝟙 X
[PROOFSTEP]
convert cancel_mono f
[GOAL]
case h.e'_1.h.e'_3.h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
g : X ⟶ X
⊢ f = 𝟙 X ≫ f
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
inst✝¹ : Epi f
g : Y ⟶ Z
inst✝ : Epi g
⊢ Epi (f ≫ g)
[PROOFSTEP]
constructor
[GOAL]
case left_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
inst✝¹ : Epi f
g : Y ⟶ Z
inst✝ : Epi g
⊢ ∀ {Z_1 : C} (g_1 h : Z ⟶ Z_1), (f ≫ g) ≫ g_1 = (f ≫ g) ≫ h → g_1 = h
[PROOFSTEP]
intro Z a b w
[GOAL]
case left_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Epi f
g : Y ⟶ Z✝
inst✝ : Epi g
Z : C
a b : Z✝ ⟶ Z
w : (f ≫ g) ≫ a = (f ≫ g) ≫ b
⊢ a = b
[PROOFSTEP]
apply (cancel_epi g).1
[GOAL]
case left_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Epi f
g : Y ⟶ Z✝
inst✝ : Epi g
Z : C
a b : Z✝ ⟶ Z
w : (f ≫ g) ≫ a = (f ≫ g) ≫ b
⊢ g ≫ a = g ≫ b
[PROOFSTEP]
apply (cancel_epi f).1
[GOAL]
case left_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Epi f
g : Y ⟶ Z✝
inst✝ : Epi g
Z : C
a b : Z✝ ⟶ Z
w : (f ≫ g) ≫ a = (f ≫ g) ≫ b
⊢ f ≫ g ≫ a = f ≫ g ≫ b
[PROOFSTEP]
simpa using w
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z
inst✝ : Mono g
⊢ Mono (f ≫ g)
[PROOFSTEP]
constructor
[GOAL]
case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z
inst✝ : Mono g
⊢ ∀ {Z_1 : C} (g_1 h : Z_1 ⟶ X), g_1 ≫ f ≫ g = h ≫ f ≫ g → g_1 = h
[PROOFSTEP]
intro Z a b w
[GOAL]
case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z✝
inst✝ : Mono g
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ a = b
[PROOFSTEP]
apply (cancel_mono f).1
[GOAL]
case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z✝
inst✝ : Mono g
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ a ≫ f = b ≫ f
[PROOFSTEP]
apply (cancel_mono g).1
[GOAL]
case right_cancellation
C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
inst✝¹ : Mono f
g : Y ⟶ Z✝
inst✝ : Mono g
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ (a ≫ f) ≫ g = (b ≫ f) ≫ g
[PROOFSTEP]
simpa using w
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono (f ≫ g)
⊢ Mono f
[PROOFSTEP]
constructor
[GOAL]
case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono (f ≫ g)
⊢ ∀ {Z : C} (g h : Z ⟶ X), g ≫ f = h ≫ f → g = h
[PROOFSTEP]
intro Z a b w
[GOAL]
case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : a ≫ f = b ≫ f
⊢ a = b
[PROOFSTEP]
replace w := congr_arg (fun k => k ≫ g) w
[GOAL]
case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : (fun k => k ≫ g) (a ≫ f) = (fun k => k ≫ g) (b ≫ f)
⊢ a = b
[PROOFSTEP]
dsimp at w
[GOAL]
case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : (a ≫ f) ≫ g = (b ≫ f) ≫ g
⊢ a = b
[PROOFSTEP]
rw [Category.assoc, Category.assoc] at w
[GOAL]
case right_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ a = b
[PROOFSTEP]
exact (cancel_mono _).1 w
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : Mono h
w : f ≫ g = h
⊢ Mono f
[PROOFSTEP]
subst h
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono (f ≫ g)
⊢ Mono f
[PROOFSTEP]
exact mono_of_mono f g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Epi (f ≫ g)
⊢ Epi g
[PROOFSTEP]
constructor
[GOAL]
case left_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Epi (f ≫ g)
⊢ ∀ {Z_1 : C} (g_1 h : Z ⟶ Z_1), g ≫ g_1 = g ≫ h → g_1 = h
[PROOFSTEP]
intro Z a b w
[GOAL]
case left_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Epi (f ≫ g)
Z : C
a b : Z✝ ⟶ Z
w : g ≫ a = g ≫ b
⊢ a = b
[PROOFSTEP]
replace w := congr_arg (fun k => f ≫ k) w
[GOAL]
case left_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Epi (f ≫ g)
Z : C
a b : Z✝ ⟶ Z
w : (fun k => f ≫ k) (g ≫ a) = (fun k => f ≫ k) (g ≫ b)
⊢ a = b
[PROOFSTEP]
dsimp at w
[GOAL]
case left_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Epi (f ≫ g)
Z : C
a b : Z✝ ⟶ Z
w : f ≫ g ≫ a = f ≫ g ≫ b
⊢ a = b
[PROOFSTEP]
rw [← Category.assoc, ← Category.assoc] at w
[GOAL]
case left_cancellation
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Epi (f ≫ g)
Z : C
a b : Z✝ ⟶ Z
w : (f ≫ g) ≫ a = (f ≫ g) ≫ b
⊢ a = b
[PROOFSTEP]
exact (cancel_epi _).1 w
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : Epi h
w : f ≫ g = h
⊢ Epi g
[PROOFSTEP]
subst h
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Epi (f ≫ g)
⊢ Epi g
[PROOFSTEP]
exact epi_of_epi f g
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u
inst✝ : SmallCategory D
⊢ LargeCategory (ULift D)
[PROOFSTEP]
infer_instance