[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
⊢ (𝟙 (𝟙_ C) ⊗ 𝟙 (𝟙_ C)) ≫ (λ_ (𝟙_ C)).hom = (ρ_ (𝟙_ C)).hom
[PROOFSTEP]
coherence
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
⊢ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (𝟙_ C)) ≫ (λ_ (𝟙_ C)).hom =
    (α_ (𝟙_ C) (𝟙_ C) (𝟙_ C)).hom ≫ (𝟙 (𝟙_ C) ⊗ (λ_ (𝟙_ C)).hom) ≫ (λ_ (𝟙_ C)).hom
[PROOFSTEP]
coherence
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
Z : C
f : Z ⟶ M.X
⊢ (M.one ⊗ f) ≫ M.mul = (λ_ Z).hom ≫ f
[PROOFSTEP]
rw [← id_tensor_comp_tensor_id, Category.assoc, M.one_mul, leftUnitor_naturality]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
Z : C
f : Z ⟶ M.X
⊢ (f ⊗ M.one) ≫ M.mul = (ρ_ Z).hom ≫ f
[PROOFSTEP]
rw [← tensor_id_comp_id_tensor, Category.assoc, M.mul_one, rightUnitor_naturality]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
⊢ (𝟙 M.X ⊗ M.mul) ≫ M.mul = (α_ M.X M.X M.X).inv ≫ (M.mul ⊗ 𝟙 M.X) ≫ M.mul
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A✝ B✝ : Mon_ C
f : A✝ ⟶ B✝
e : IsIso ((forget C).map f)
⊢ B✝.mul ≫ inv f.hom = (inv f.hom ⊗ inv f.hom) ≫ A✝.mul
[PROOFSTEP]
simp only [IsIso.comp_inv_eq, Hom.mul_hom, Category.assoc, ← tensor_comp_assoc, IsIso.inv_hom_id, tensor_id,
  Category.id_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A✝ B✝ : Mon_ C
f : A✝ ⟶ B✝
e : IsIso ((forget C).map f)
⊢ f ≫ Hom.mk (inv f.hom) = 𝟙 A✝ ∧ Hom.mk (inv f.hom) ≫ f = 𝟙 B✝
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
⊢ N.one ≫ f.inv = M.one
[PROOFSTEP]
rw [← one_f]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
⊢ (M.one ≫ f.hom) ≫ f.inv = M.one
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
⊢ N.mul ≫ f.inv = (f.inv ⊗ f.inv) ≫ M.mul
[PROOFSTEP]
rw [← cancel_mono f.hom]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
⊢ (N.mul ≫ f.inv) ≫ f.hom = ((f.inv ⊗ f.inv) ≫ M.mul) ≫ f.hom
[PROOFSTEP]
slice_rhs 2 3 => rw [mul_f]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
| M.mul ≫ f.hom
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
| f.inv ⊗ f.inv
[PROOFSTEP]
rw [mul_f]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
| M.mul ≫ f.hom
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
| f.inv ⊗ f.inv
[PROOFSTEP]
rw [mul_f]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
| M.mul ≫ f.hom
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
| f.inv ⊗ f.inv
[PROOFSTEP]
rw [mul_f]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M✝ M N : Mon_ C
f : M.X ≅ N.X
one_f : M.one ≫ f.hom = N.one
mul_f : M.mul ≫ f.hom = (f.hom ⊗ f.hom) ≫ N.mul
⊢ (N.mul ≫ f.inv) ≫ f.hom = (f.inv ⊗ f.inv) ≫ (f.hom ⊗ f.hom) ≫ N.mul
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
⊢ (trivial C).one ≫ A.one = A.one
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
⊢ 𝟙 (𝟙_ C) ≫ A.one = A.one
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
⊢ (trivial C).mul ≫ A.one = (A.one ⊗ A.one) ≫ A.mul
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
⊢ (λ_ (𝟙_ C)).hom ≫ A.one = (A.one ⊗ A.one) ≫ A.mul
[PROOFSTEP]
simp [A.one_mul, unitors_equal]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
f : trivial C ⟶ A
⊢ f = default
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
f : trivial C ⟶ A
⊢ f.hom = default.hom
[PROOFSTEP]
simp
[GOAL]
case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
f : trivial C ⟶ A
⊢ f.hom = A.one
[PROOFSTEP]
rw [← Category.id_comp f.hom]
[GOAL]
case w
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Mon_ C
f : trivial C ⟶ A
⊢ 𝟙 (trivial C).X ≫ f.hom = A.one
[PROOFSTEP]
erw [f.one_hom]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (F.ε ≫ F.map A.one ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ F.map A.mul = (λ_ (F.obj A.X)).hom
[PROOFSTEP]
conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.ε ≫ F.map A.one ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [comp_tensor_id, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.ε ≫ F.map A.one ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [comp_tensor_id, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.ε ≫ F.map A.one ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [comp_tensor_id, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ ((F.ε ⊗ F.map (𝟙 A.X)) ≫ (F.map A.one ⊗ F.map (𝟙 A.X))) ≫ μ F A.X A.X ≫ F.map A.mul = (λ_ (F.obj A.X)).hom
[PROOFSTEP]
slice_lhs 2 3 => rw [F.μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map A.one ⊗ F.map (𝟙 A.X)) ≫ μ F A.X A.X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.ε ⊗ F.map (𝟙 A.X)
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map A.one ⊗ F.map (𝟙 A.X)) ≫ μ F A.X A.X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.ε ⊗ F.map (𝟙 A.X)
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map A.one ⊗ F.map (𝟙 A.X)) ≫ μ F A.X A.X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.ε ⊗ F.map (𝟙 A.X)
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (F.ε ⊗ F.map (𝟙 A.X)) ≫ (μ F (𝟙_ C) A.X ≫ F.map (A.one ⊗ 𝟙 A.X)) ≫ F.map A.mul = (λ_ (F.obj A.X)).hom
[PROOFSTEP]
slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.one_mul]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (A.one ⊗ 𝟙 A.X) ≫ F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.ε ⊗ F.map (𝟙 A.X)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F (𝟙_ C) A.X
[PROOFSTEP]
rw [← F.toFunctor.map_comp, A.one_mul]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (A.one ⊗ 𝟙 A.X) ≫ F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.ε ⊗ F.map (𝟙 A.X)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F (𝟙_ C) A.X
[PROOFSTEP]
rw [← F.toFunctor.map_comp, A.one_mul]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (A.one ⊗ 𝟙 A.X) ≫ F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.ε ⊗ F.map (𝟙 A.X)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F (𝟙_ C) A.X
[PROOFSTEP]
rw [← F.toFunctor.map_comp, A.one_mul]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (F.ε ⊗ F.map (𝟙 A.X)) ≫ μ F (𝟙_ C) A.X ≫ F.map (λ_ A.X).hom = (λ_ (F.obj A.X)).hom
[PROOFSTEP]
rw [F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (F.ε ⊗ 𝟙 (F.obj A.X)) ≫ μ F (𝟙_ C) A.X ≫ F.map (λ_ A.X).hom = (λ_ (F.obj A.X)).hom
[PROOFSTEP]
rw [F.left_unitality]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (𝟙 (F.obj A.X) ⊗ F.ε ≫ F.map A.one) ≫ μ F A.X A.X ≫ F.map A.mul = (ρ_ (F.obj A.X)).hom
[PROOFSTEP]
conv_lhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (𝟙 (F.obj A.X) ⊗ F.ε ≫ F.map A.one) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [id_tensor_comp, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (𝟙 (F.obj A.X) ⊗ F.ε ≫ F.map A.one) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [id_tensor_comp, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (𝟙 (F.obj A.X) ⊗ F.ε ≫ F.map A.one) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [id_tensor_comp, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ ((F.map (𝟙 A.X) ⊗ F.ε) ≫ (F.map (𝟙 A.X) ⊗ F.map A.one)) ≫ μ F A.X A.X ≫ F.map A.mul = (ρ_ (F.obj A.X)).hom
[PROOFSTEP]
slice_lhs 2 3 => rw [F.μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map (𝟙 A.X) ⊗ F.map A.one) ≫ μ F A.X A.X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X) ⊗ F.ε
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map (𝟙 A.X) ⊗ F.map A.one) ≫ μ F A.X A.X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X) ⊗ F.ε
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map (𝟙 A.X) ⊗ F.map A.one) ≫ μ F A.X A.X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X) ⊗ F.ε
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (F.map (𝟙 A.X) ⊗ F.ε) ≫ (μ F A.X (𝟙_ C) ≫ F.map (𝟙 A.X ⊗ A.one)) ≫ F.map A.mul = (ρ_ (F.obj A.X)).hom
[PROOFSTEP]
slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_one]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X ⊗ A.one) ≫ F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X) ⊗ F.ε
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F A.X (𝟙_ C)
[PROOFSTEP]
rw [← F.toFunctor.map_comp, A.mul_one]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X ⊗ A.one) ≫ F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X) ⊗ F.ε
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F A.X (𝟙_ C)
[PROOFSTEP]
rw [← F.toFunctor.map_comp, A.mul_one]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X ⊗ A.one) ≫ F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X) ⊗ F.ε
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F A.X (𝟙_ C)
[PROOFSTEP]
rw [← F.toFunctor.map_comp, A.mul_one]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (F.map (𝟙 A.X) ⊗ F.ε) ≫ μ F A.X (𝟙_ C) ≫ F.map (ρ_ A.X).hom = (ρ_ (F.obj A.X)).hom
[PROOFSTEP]
rw [F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (𝟙 (F.obj A.X) ⊗ F.ε) ≫ μ F A.X (𝟙_ C) ≫ F.map (ρ_ A.X).hom = (ρ_ (F.obj A.X)).hom
[PROOFSTEP]
rw [F.right_unitality]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ≫ F.map A.mul ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ F.map A.mul =
    (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
      (𝟙 (F.obj A.X) ⊗ μ F A.X A.X ≫ F.map A.mul) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
conv_lhs => rw [comp_tensor_id, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (μ F A.X A.X ≫ F.map A.mul ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [comp_tensor_id, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (μ F A.X A.X ≫ F.map A.mul ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [comp_tensor_id, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (μ F A.X A.X ≫ F.map A.mul ⊗ 𝟙 (F.obj A.X)) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [comp_tensor_id, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ ((μ F A.X A.X ⊗ F.map (𝟙 A.X)) ≫ (F.map A.mul ⊗ F.map (𝟙 A.X))) ≫ μ F A.X A.X ≫ F.map A.mul =
    (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
      (𝟙 (F.obj A.X) ⊗ μ F A.X A.X ≫ F.map A.mul) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
slice_lhs 2 3 => rw [F.μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map A.mul ⊗ F.map (𝟙 A.X)) ≫ μ F A.X A.X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F A.X A.X ⊗ F.map (𝟙 A.X)
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map A.mul ⊗ F.map (𝟙 A.X)) ≫ μ F A.X A.X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F A.X A.X ⊗ F.map (𝟙 A.X)
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map A.mul ⊗ F.map (𝟙 A.X)) ≫ μ F A.X A.X
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F A.X A.X ⊗ F.map (𝟙 A.X)
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ⊗ F.map (𝟙 A.X)) ≫ (μ F (A.X ⊗ A.X) A.X ≫ F.map (A.mul ⊗ 𝟙 A.X)) ≫ F.map A.mul =
    (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
      (𝟙 (F.obj A.X) ⊗ μ F A.X A.X ≫ F.map A.mul) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
slice_lhs 3 4 => rw [← F.toFunctor.map_comp, A.mul_assoc]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (A.mul ⊗ 𝟙 A.X) ≫ F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F A.X A.X ⊗ F.map (𝟙 A.X)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F (A.X ⊗ A.X) A.X
[PROOFSTEP]
rw [← F.toFunctor.map_comp, A.mul_assoc]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (A.mul ⊗ 𝟙 A.X) ≫ F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F A.X A.X ⊗ F.map (𝟙 A.X)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F (A.X ⊗ A.X) A.X
[PROOFSTEP]
rw [← F.toFunctor.map_comp, A.mul_assoc]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (A.mul ⊗ 𝟙 A.X) ≫ F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F A.X A.X ⊗ F.map (𝟙 A.X)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| μ F (A.X ⊗ A.X) A.X
[PROOFSTEP]
rw [← F.toFunctor.map_comp, A.mul_assoc]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ⊗ F.map (𝟙 A.X)) ≫ μ F (A.X ⊗ A.X) A.X ≫ F.map ((α_ A.X A.X A.X).hom ≫ (𝟙 A.X ⊗ A.mul) ≫ A.mul) =
    (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
      (𝟙 (F.obj A.X) ⊗ μ F A.X A.X ≫ F.map A.mul) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
conv_lhs => rw [F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (μ F A.X A.X ⊗ F.map (𝟙 A.X)) ≫ μ F (A.X ⊗ A.X) A.X ≫ F.map ((α_ A.X A.X A.X).hom ≫ (𝟙 A.X ⊗ A.mul) ≫ A.mul)
[PROOFSTEP]
rw [F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (μ F A.X A.X ⊗ F.map (𝟙 A.X)) ≫ μ F (A.X ⊗ A.X) A.X ≫ F.map ((α_ A.X A.X A.X).hom ≫ (𝟙 A.X ⊗ A.mul) ≫ A.mul)
[PROOFSTEP]
rw [F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (μ F A.X A.X ⊗ F.map (𝟙 A.X)) ≫ μ F (A.X ⊗ A.X) A.X ≫ F.map ((α_ A.X A.X A.X).hom ≫ (𝟙 A.X ⊗ A.mul) ≫ A.mul)
[PROOFSTEP]
rw [F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫ μ F (A.X ⊗ A.X) A.X ≫ F.map ((α_ A.X A.X A.X).hom ≫ (𝟙 A.X ⊗ A.mul) ≫ A.mul) =
    (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
      (𝟙 (F.obj A.X) ⊗ μ F A.X A.X ≫ F.map A.mul) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
conv_lhs => rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫ μ F (A.X ⊗ A.X) A.X ≫ F.map ((α_ A.X A.X A.X).hom ≫ (𝟙 A.X ⊗ A.mul) ≫ A.mul)
[PROOFSTEP]
rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫ μ F (A.X ⊗ A.X) A.X ≫ F.map ((α_ A.X A.X A.X).hom ≫ (𝟙 A.X ⊗ A.mul) ≫ A.mul)
[PROOFSTEP]
rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫ μ F (A.X ⊗ A.X) A.X ≫ F.map ((α_ A.X A.X A.X).hom ≫ (𝟙 A.X ⊗ A.mul) ≫ A.mul)
[PROOFSTEP]
rw [F.toFunctor.map_comp, F.toFunctor.map_comp]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫
      μ F (A.X ⊗ A.X) A.X ≫ F.map (α_ A.X A.X A.X).hom ≫ F.map (𝟙 A.X ⊗ A.mul) ≫ F.map A.mul =
    (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
      (𝟙 (F.obj A.X) ⊗ μ F A.X A.X ≫ F.map A.mul) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
conv_rhs => rw [id_tensor_comp, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫ (𝟙 (F.obj A.X) ⊗ μ F A.X A.X ≫ F.map A.mul) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [id_tensor_comp, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫ (𝟙 (F.obj A.X) ⊗ μ F A.X A.X ≫ F.map A.mul) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [id_tensor_comp, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫ (𝟙 (F.obj A.X) ⊗ μ F A.X A.X ≫ F.map A.mul) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
rw [id_tensor_comp, ← F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫
      μ F (A.X ⊗ A.X) A.X ≫ F.map (α_ A.X A.X A.X).hom ≫ F.map (𝟙 A.X ⊗ A.mul) ≫ F.map A.mul =
    (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
      ((F.map (𝟙 A.X) ⊗ μ F A.X A.X) ≫ (F.map (𝟙 A.X) ⊗ F.map A.mul)) ≫ μ F A.X A.X ≫ F.map A.mul
[PROOFSTEP]
slice_rhs 3 4 => rw [F.μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map (𝟙 A.X) ⊗ F.map A.mul) ≫ μ F A.X A.X
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X) ⊗ μ F A.X A.X
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map (𝟙 A.X) ⊗ F.map A.mul) ≫ μ F A.X A.X
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X) ⊗ μ F A.X A.X
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (F.map (𝟙 A.X) ⊗ F.map A.mul) ≫ μ F A.X A.X
case a.a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X) ⊗ μ F A.X A.X
[PROOFSTEP]
rw [F.μ_natural]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫
      μ F (A.X ⊗ A.X) A.X ≫ F.map (α_ A.X A.X A.X).hom ≫ F.map (𝟙 A.X ⊗ A.mul) ≫ F.map A.mul =
    (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
      (F.map (𝟙 A.X) ⊗ μ F A.X A.X) ≫ (μ F A.X (A.X ⊗ A.X) ≫ F.map (𝟙 A.X ⊗ A.mul)) ≫ F.map A.mul
[PROOFSTEP]
conv_rhs => rw [F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
    (F.map (𝟙 A.X) ⊗ μ F A.X A.X) ≫ (μ F A.X (A.X ⊗ A.X) ≫ F.map (𝟙 A.X ⊗ A.mul)) ≫ F.map A.mul
[PROOFSTEP]
rw [F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
    (F.map (𝟙 A.X) ⊗ μ F A.X A.X) ≫ (μ F A.X (A.X ⊗ A.X) ≫ F.map (𝟙 A.X ⊗ A.mul)) ≫ F.map A.mul
[PROOFSTEP]
rw [F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
    (F.map (𝟙 A.X) ⊗ μ F A.X A.X) ≫ (μ F A.X (A.X ⊗ A.X) ≫ F.map (𝟙 A.X ⊗ A.mul)) ≫ F.map A.mul
[PROOFSTEP]
rw [F.toFunctor.map_id]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫
      μ F (A.X ⊗ A.X) A.X ≫ F.map (α_ A.X A.X A.X).hom ≫ F.map (𝟙 A.X ⊗ A.mul) ≫ F.map A.mul =
    (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫
      (𝟙 (F.obj A.X) ⊗ μ F A.X A.X) ≫ (μ F A.X (A.X ⊗ A.X) ≫ F.map (𝟙 A.X ⊗ A.mul)) ≫ F.map A.mul
[PROOFSTEP]
slice_rhs 1 3 => rw [← F.associativity]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫ (𝟙 (F.obj A.X) ⊗ μ F A.X A.X) ≫ μ F A.X (A.X ⊗ A.X)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X ⊗ A.mul)
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
[PROOFSTEP]
rw [← F.associativity]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫ (𝟙 (F.obj A.X) ⊗ μ F A.X A.X) ≫ μ F A.X (A.X ⊗ A.X)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X ⊗ A.mul)
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
[PROOFSTEP]
rw [← F.associativity]
[GOAL]
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| (α_ (F.obj A.X) (F.obj A.X) (F.obj A.X)).hom ≫ (𝟙 (F.obj A.X) ⊗ μ F A.X A.X) ≫ μ F A.X (A.X ⊗ A.X)
case a.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map (𝟙 A.X ⊗ A.mul)
case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
| F.map A.mul
[PROOFSTEP]
rw [← F.associativity]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ (μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫
      μ F (A.X ⊗ A.X) A.X ≫ F.map (α_ A.X A.X A.X).hom ≫ F.map (𝟙 A.X ⊗ A.mul) ≫ F.map A.mul =
    (((μ F A.X A.X ⊗ 𝟙 (F.obj A.X)) ≫ μ F (A.X ⊗ A.X) A.X ≫ F.map (α_ A.X A.X A.X).hom) ≫ F.map (𝟙 A.X ⊗ A.mul)) ≫
      F.map A.mul
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
⊢ ((fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul)) X✝).one ≫ F.map f.hom =
    ((fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul)) Y✝).one
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
⊢ (F.ε ≫ F.map X✝.one) ≫ F.map f.hom = F.ε ≫ F.map Y✝.one
[PROOFSTEP]
rw [Category.assoc, ← F.toFunctor.map_comp, f.one_hom]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
⊢ ((fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul)) X✝).mul ≫ F.map f.hom =
    (F.map f.hom ⊗ F.map f.hom) ≫
      ((fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul)) Y✝).mul
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
⊢ (μ F X✝.X X✝.X ≫ F.map X✝.mul) ≫ F.map f.hom = (F.map f.hom ⊗ F.map f.hom) ≫ μ F Y✝.X Y✝.X ≫ F.map Y✝.mul
[PROOFSTEP]
rw [Category.assoc, F.μ_natural_assoc, ← F.toFunctor.map_comp, ← F.toFunctor.map_comp, f.mul_hom]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ { obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
          map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.map
      (𝟙 A) =
    𝟙
      ({ obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
            map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.obj
        A)
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
A : Mon_ C
⊢ ({ obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
            map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.map
        (𝟙 A)).hom =
    (𝟙
        ({ obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
              map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.obj
          A)).hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X✝ Y✝ Z✝ : Mon_ C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
          map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.map
      (f ≫ g) =
    { obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
            map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.map
        f ≫
      { obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
            map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.map
        g
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X✝ Y✝ Z✝ : Mon_ C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ ({ obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
            map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.map
        (f ≫ g)).hom =
    ({ obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
              map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.map
          f ≫
        { obj := fun A => Mon_.mk (F.obj A.X) (F.ε ≫ F.map A.one) (μ F A.X A.X ≫ F.map A.mul),
              map := fun {X Y} f => Mon_.Hom.mk (F.map f.hom) }.map
          g).hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
x✝² x✝¹ : Discrete PUnit
x✝ : x✝² ⟶ x✝¹
⊢ ((fun A =>
              LaxMonoidalFunctor.mk
                (CategoryTheory.Functor.mk { obj := fun x => A.X, map := fun {X Y} x => 𝟙 ((fun x => A.X) X) }) A.one
                fun x x => A.mul)
            X✝).map
        x✝ ≫
      (fun x => f.hom) x✝¹ =
    (fun x => f.hom) x✝² ≫
      ((fun A =>
              LaxMonoidalFunctor.mk
                (CategoryTheory.Functor.mk { obj := fun x => A.X, map := fun {X Y} x => 𝟙 ((fun x => A.X) X) }) A.one
                fun x x => A.mul)
            Y✝).map
        x✝
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X✝ Y✝ : Mon_ C
f : X✝ ⟶ Y✝
x✝² x✝¹ : Discrete PUnit
x✝ : x✝² ⟶ x✝¹
⊢ 𝟙 X✝.X ≫ f.hom = f.hom ≫ 𝟙 Y✝.X
[PROOFSTEP]
rw [Category.id_comp, Category.comp_id]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
F : LaxMonoidalFunctor (Discrete PUnit) C
x✝ : Discrete PUnit
⊢ x✝ = (trivial (Discrete PUnit)).X
[PROOFSTEP]
ext
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
F : LaxMonoidalFunctor (Discrete PUnit) C
⊢ ∀ {X Y : Discrete PUnit} (f : X ⟶ Y),
    ((𝟭 (LaxMonoidalFunctor (Discrete PUnit) C)).obj F).map f ≫
        ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) Y).hom =
      ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) X).hom ≫
        ((laxMonoidalToMon C ⋙ monToLaxMonoidal C).obj F).map f
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
F : LaxMonoidalFunctor (Discrete PUnit) C
⊢ ((𝟭 (LaxMonoidalFunctor (Discrete PUnit) C)).obj F).ε ≫
      ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) (𝟙_ (Discrete PUnit))).hom =
    ((laxMonoidalToMon C ⋙ monToLaxMonoidal C).obj F).ε
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
F : LaxMonoidalFunctor (Discrete PUnit) C
⊢ ∀ (X Y : Discrete PUnit),
    μ ((𝟭 (LaxMonoidalFunctor (Discrete PUnit) C)).obj F) X Y ≫
        ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) (X ⊗ Y)).hom =
      (((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) X).hom ⊗
          ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) Y).hom) ≫
        μ ((laxMonoidalToMon C ⋙ monToLaxMonoidal C).obj F) X Y
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
⊢ ∀ {X Y : LaxMonoidalFunctor (Discrete PUnit) C} (f : X ⟶ Y),
    (𝟭 (LaxMonoidalFunctor (Discrete PUnit) C)).map f ≫
        ((fun F =>
              MonoidalNatIso.ofComponents (fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X)))
                (_ :
                  ∀ {X Y : Discrete PUnit} (f : X ⟶ Y),
                    ((𝟭 (LaxMonoidalFunctor (Discrete PUnit) C)).obj F).map f ≫
                        ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) Y).hom =
                      ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) X).hom ≫
                        ((laxMonoidalToMon C ⋙ monToLaxMonoidal C).obj F).map f)
                (_ : F.ε ≫ (F.mapIso (Iso.refl (𝟙_ (Discrete PUnit)))).hom = F.ε ≫ F.map (𝟙 (𝟙_ (Discrete PUnit))))
                (_ :
                  ∀ (X Y : Discrete PUnit),
                    μ ((𝟭 (LaxMonoidalFunctor (Discrete PUnit) C)).obj F) X Y ≫
                        ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) (X ⊗ Y)).hom =
                      (((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) X).hom ⊗
                          ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) Y).hom) ≫
                        μ ((laxMonoidalToMon C ⋙ monToLaxMonoidal C).obj F) X Y))
            Y).hom =
      ((fun F =>
              MonoidalNatIso.ofComponents (fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X)))
                (_ :
                  ∀ {X Y : Discrete PUnit} (f : X ⟶ Y),
                    ((𝟭 (LaxMonoidalFunctor (Discrete PUnit) C)).obj F).map f ≫
                        ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) Y).hom =
                      ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) X).hom ≫
                        ((laxMonoidalToMon C ⋙ monToLaxMonoidal C).obj F).map f)
                (_ : F.ε ≫ (F.mapIso (Iso.refl (𝟙_ (Discrete PUnit)))).hom = F.ε ≫ F.map (𝟙 (𝟙_ (Discrete PUnit))))
                (_ :
                  ∀ (X Y : Discrete PUnit),
                    μ ((𝟭 (LaxMonoidalFunctor (Discrete PUnit) C)).obj F) X Y ≫
                        ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) (X ⊗ Y)).hom =
                      (((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) X).hom ⊗
                          ((fun x => F.mapIso (eqToIso (_ : x = (trivial (Discrete PUnit)).X))) Y).hom) ≫
                        μ ((laxMonoidalToMon C ⋙ monToLaxMonoidal C).obj F) X Y))
            X).hom ≫
        (laxMonoidalToMon C ⋙ monToLaxMonoidal C).map f
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
⊢ ∀ {X Y : Mon_ C} (f : X ⟶ Y),
    (monToLaxMonoidal C ⋙ laxMonoidalToMon C).map f ≫
        ((fun F =>
              Iso.mk (Hom.mk (𝟙 ((monToLaxMonoidal C ⋙ laxMonoidalToMon C).obj F).X))
                (Hom.mk (𝟙 ((𝟭 (Mon_ C)).obj F).X)))
            Y).hom =
      ((fun F =>
              Iso.mk (Hom.mk (𝟙 ((monToLaxMonoidal C ⋙ laxMonoidalToMon C).obj F).X))
                (Hom.mk (𝟙 ((𝟭 (Mon_ C)).obj F).X)))
            X).hom ≫
        (𝟭 (Mon_ C)).map f
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
⊢ ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
⊢ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one) ≫ (α_ M.X N.X P.X).hom = M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)
[PROOFSTEP]
slice_lhs 1 3 => rw [← Category.id_comp P.one, tensor_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one) ≫ (α_ M.X N.X P.X).hom
[PROOFSTEP]
rw [← Category.id_comp P.one, tensor_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one) ≫ (α_ M.X N.X P.X).hom
[PROOFSTEP]
rw [← Category.id_comp P.one, tensor_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one) ≫ (α_ M.X N.X P.X).hom
[PROOFSTEP]
rw [← Category.id_comp P.one, tensor_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
⊢ (((λ_ (𝟙_ C)).inv ⊗ 𝟙 (𝟙_ C)) ≫ ((M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
    M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)
[PROOFSTEP]
slice_lhs 2 3 => rw [associator_naturality]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| ((M.one ⊗ N.one) ⊗ P.one) ≫ (α_ M.X N.X P.X).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M N P : Mon_ C | (λ_ (𝟙_ C)).inv ⊗ 𝟙 (𝟙_ C)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| ((M.one ⊗ N.one) ⊗ P.one) ≫ (α_ M.X N.X P.X).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M N P : Mon_ C | (λ_ (𝟙_ C)).inv ⊗ 𝟙 (𝟙_ C)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| ((M.one ⊗ N.one) ⊗ P.one) ≫ (α_ M.X N.X P.X).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M N P : Mon_ C | (λ_ (𝟙_ C)).inv ⊗ 𝟙 (𝟙_ C)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
⊢ ((λ_ (𝟙_ C)).inv ⊗ 𝟙 (𝟙_ C)) ≫ (α_ tensorUnit' (𝟙_ C) (𝟙_ C)).hom ≫ (M.one ⊗ N.one ⊗ P.one) =
    M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)
[PROOFSTEP]
slice_rhs 1 2 => rw [← Category.id_comp M.one, tensor_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)
[PROOFSTEP]
rw [← Category.id_comp M.one, tensor_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)
[PROOFSTEP]
rw [← Category.id_comp M.one, tensor_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)
[PROOFSTEP]
rw [← Category.id_comp M.one, tensor_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
⊢ ((λ_ (𝟙_ C)).inv ⊗ 𝟙 (𝟙_ C)) ≫ (α_ tensorUnit' (𝟙_ C) (𝟙_ C)).hom ≫ (M.one ⊗ N.one ⊗ P.one) =
    (𝟙 (𝟙_ C) ⊗ (λ_ (𝟙_ C)).inv) ≫ (M.one ⊗ N.one ⊗ P.one)
[PROOFSTEP]
slice_lhs 1 2 => rw [← leftUnitor_tensor_inv]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| ((λ_ (𝟙_ C)).inv ⊗ 𝟙 (𝟙_ C)) ≫ (α_ tensorUnit' (𝟙_ C) (𝟙_ C)).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M N P : Mon_ C | M.one ⊗ N.one ⊗ P.one
[PROOFSTEP]
rw [← leftUnitor_tensor_inv]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| ((λ_ (𝟙_ C)).inv ⊗ 𝟙 (𝟙_ C)) ≫ (α_ tensorUnit' (𝟙_ C) (𝟙_ C)).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M N P : Mon_ C | M.one ⊗ N.one ⊗ P.one
[PROOFSTEP]
rw [← leftUnitor_tensor_inv]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| ((λ_ (𝟙_ C)).inv ⊗ 𝟙 (𝟙_ C)) ≫ (α_ tensorUnit' (𝟙_ C) (𝟙_ C)).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M N P : Mon_ C | M.one ⊗ N.one ⊗ P.one
[PROOFSTEP]
rw [← leftUnitor_tensor_inv]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
⊢ (λ_ (tensorUnit' ⊗ 𝟙_ C)).inv ≫ (M.one ⊗ N.one ⊗ P.one) = (𝟙 (𝟙_ C) ⊗ (λ_ (𝟙_ C)).inv) ≫ (M.one ⊗ N.one ⊗ P.one)
[PROOFSTEP]
rw [← cancel_epi (λ_ (𝟙_ C)).inv]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
⊢ (λ_ (𝟙_ C)).inv ≫ (λ_ (tensorUnit' ⊗ 𝟙_ C)).inv ≫ (M.one ⊗ N.one ⊗ P.one) =
    (λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ (λ_ (𝟙_ C)).inv) ≫ (M.one ⊗ N.one ⊗ P.one)
[PROOFSTEP]
slice_lhs 1 2 => rw [leftUnitor_inv_naturality]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| (λ_ (𝟙_ C)).inv ≫ (λ_ (tensorUnit' ⊗ 𝟙_ C)).inv
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M N P : Mon_ C | M.one ⊗ N.one ⊗ P.one
[PROOFSTEP]
rw [leftUnitor_inv_naturality]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| (λ_ (𝟙_ C)).inv ≫ (λ_ (tensorUnit' ⊗ 𝟙_ C)).inv
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M N P : Mon_ C | M.one ⊗ N.one ⊗ P.one
[PROOFSTEP]
rw [leftUnitor_inv_naturality]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
| (λ_ (𝟙_ C)).inv ≫ (λ_ (tensorUnit' ⊗ 𝟙_ C)).inv
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M N P : Mon_ C | M.one ⊗ N.one ⊗ P.one
[PROOFSTEP]
rw [leftUnitor_inv_naturality]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M N P : Mon_ C
⊢ ((λ_ (𝟙_ C)).inv ≫ (𝟙 tensorUnit' ⊗ (λ_ (𝟙_ C)).inv)) ≫ (M.one ⊗ N.one ⊗ P.one) =
    (λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ (λ_ (𝟙_ C)).inv) ≫ (M.one ⊗ N.one ⊗ P.one)
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
⊢ ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one
[PROOFSTEP]
slice_lhs 2 3 => rw [leftUnitor_naturality]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
| (𝟙 (𝟙_ C) ⊗ M.one) ≫ (λ_ M.X).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M : Mon_ C | (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [leftUnitor_naturality]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
| (𝟙 (𝟙_ C) ⊗ M.one) ≫ (λ_ M.X).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M : Mon_ C | (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [leftUnitor_naturality]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
| (𝟙 (𝟙_ C) ⊗ M.one) ≫ (λ_ M.X).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M : Mon_ C | (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [leftUnitor_naturality]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
⊢ (λ_ (𝟙_ C)).inv ≫ (λ_ (𝟙_ C)).hom ≫ M.one = M.one
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
⊢ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one
[PROOFSTEP]
slice_lhs 2 3 => rw [rightUnitor_naturality, ← unitors_equal]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
| (M.one ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ M.X).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M : Mon_ C | (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [rightUnitor_naturality, ← unitors_equal]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
| (M.one ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ M.X).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M : Mon_ C | (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [rightUnitor_naturality, ← unitors_equal]
[GOAL]
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
| (M.one ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ M.X).hom
case a C : Type u₁ inst✝¹ : Category.{v₁, u₁} C inst✝ : MonoidalCategory C M : Mon_ C | (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [rightUnitor_naturality, ← unitors_equal]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Mon_ C
⊢ (λ_ (𝟙_ C)).inv ≫ (λ_ (𝟙_ C)).hom ≫ M.one = M.one
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ 𝟙 (M.X ⊗ N.X)) ≫ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
    (λ_ (M.X ⊗ N.X)).hom
[PROOFSTEP]
rw [← Category.id_comp (𝟙 (M.X ⊗ N.X)), tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (((λ_ (𝟙_ C)).inv ⊗ 𝟙 (M.X ⊗ N.X)) ≫ ((M.one ⊗ N.one) ⊗ 𝟙 (M.X ⊗ N.X))) ≫
      tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
    (λ_ (M.X ⊗ N.X)).hom
[PROOFSTEP]
slice_lhs 2 3 => rw [← tensor_id, tensor_μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.one ⊗ N.one) ⊗ 𝟙 (M.X ⊗ N.X)) ≫ tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (λ_ (𝟙_ C)).inv ⊗ 𝟙 (M.X ⊗ N.X)
[PROOFSTEP]
rw [← tensor_id, tensor_μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.one ⊗ N.one) ⊗ 𝟙 (M.X ⊗ N.X)) ≫ tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (λ_ (𝟙_ C)).inv ⊗ 𝟙 (M.X ⊗ N.X)
[PROOFSTEP]
rw [← tensor_id, tensor_μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.one ⊗ N.one) ⊗ 𝟙 (M.X ⊗ N.X)) ≫ tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (λ_ (𝟙_ C)).inv ⊗ 𝟙 (M.X ⊗ N.X)
[PROOFSTEP]
rw [← tensor_id, tensor_μ_natural]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ ((λ_ (𝟙_ C)).inv ⊗ 𝟙 (M.X ⊗ N.X)) ≫
      (tensor_μ C (tensorUnit', 𝟙_ C) (M.X, N.X) ≫ ((M.one ⊗ 𝟙 M.X) ⊗ N.one ⊗ 𝟙 N.X)) ≫ (M.mul ⊗ N.mul) =
    (λ_ (M.X ⊗ N.X)).hom
[PROOFSTEP]
slice_lhs 3 4 => rw [← tensor_comp, one_mul M, one_mul N]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.one ⊗ 𝟙 M.X) ⊗ N.one ⊗ 𝟙 N.X) ≫ (M.mul ⊗ N.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (λ_ (𝟙_ C)).inv ⊗ 𝟙 (M.X ⊗ N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (tensorUnit', 𝟙_ C) (M.X, N.X)
[PROOFSTEP]
rw [← tensor_comp, one_mul M, one_mul N]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.one ⊗ 𝟙 M.X) ⊗ N.one ⊗ 𝟙 N.X) ≫ (M.mul ⊗ N.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (λ_ (𝟙_ C)).inv ⊗ 𝟙 (M.X ⊗ N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (tensorUnit', 𝟙_ C) (M.X, N.X)
[PROOFSTEP]
rw [← tensor_comp, one_mul M, one_mul N]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.one ⊗ 𝟙 M.X) ⊗ N.one ⊗ 𝟙 N.X) ≫ (M.mul ⊗ N.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (λ_ (𝟙_ C)).inv ⊗ 𝟙 (M.X ⊗ N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (tensorUnit', 𝟙_ C) (M.X, N.X)
[PROOFSTEP]
rw [← tensor_comp, one_mul M, one_mul N]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ ((λ_ (𝟙_ C)).inv ⊗ 𝟙 (M.X ⊗ N.X)) ≫ tensor_μ C (tensorUnit', 𝟙_ C) (M.X, N.X) ≫ ((λ_ M.X).hom ⊗ (λ_ N.X).hom) =
    (λ_ (M.X ⊗ N.X)).hom
[PROOFSTEP]
symm
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (λ_ (M.X ⊗ N.X)).hom =
    ((λ_ (𝟙_ C)).inv ⊗ 𝟙 (M.X ⊗ N.X)) ≫ tensor_μ C (tensorUnit', 𝟙_ C) (M.X, N.X) ≫ ((λ_ M.X).hom ⊗ (λ_ N.X).hom)
[PROOFSTEP]
exact tensor_left_unitality C M.X N.X
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) ≫ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
    (ρ_ (M.X ⊗ N.X)).hom
[PROOFSTEP]
rw [← Category.id_comp (𝟙 (M.X ⊗ N.X)), tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ ((𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv) ≫ (𝟙 (M.X ⊗ N.X) ⊗ M.one ⊗ N.one)) ≫
      tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
    (ρ_ (M.X ⊗ N.X)).hom
[PROOFSTEP]
slice_lhs 2 3 => rw [← tensor_id, tensor_μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (𝟙 (M.X ⊗ N.X) ⊗ M.one ⊗ N.one) ≫ tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| 𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [← tensor_id, tensor_μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (𝟙 (M.X ⊗ N.X) ⊗ M.one ⊗ N.one) ≫ tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| 𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [← tensor_id, tensor_μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (𝟙 (M.X ⊗ N.X) ⊗ M.one ⊗ N.one) ≫ tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| 𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [← tensor_id, tensor_μ_natural]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv) ≫
      (tensor_μ C (M.X, N.X) (tensorUnit', 𝟙_ C) ≫ ((𝟙 M.X ⊗ M.one) ⊗ 𝟙 N.X ⊗ N.one)) ≫ (M.mul ⊗ N.mul) =
    (ρ_ (M.X ⊗ N.X)).hom
[PROOFSTEP]
slice_lhs 3 4 => rw [← tensor_comp, mul_one M, mul_one N]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((𝟙 M.X ⊗ M.one) ⊗ 𝟙 N.X ⊗ N.one) ≫ (M.mul ⊗ N.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| 𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (tensorUnit', 𝟙_ C)
[PROOFSTEP]
rw [← tensor_comp, mul_one M, mul_one N]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((𝟙 M.X ⊗ M.one) ⊗ 𝟙 N.X ⊗ N.one) ≫ (M.mul ⊗ N.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| 𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (tensorUnit', 𝟙_ C)
[PROOFSTEP]
rw [← tensor_comp, mul_one M, mul_one N]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((𝟙 M.X ⊗ M.one) ⊗ 𝟙 N.X ⊗ N.one) ≫ (M.mul ⊗ N.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| 𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (tensorUnit', 𝟙_ C)
[PROOFSTEP]
rw [← tensor_comp, mul_one M, mul_one N]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv) ≫ tensor_μ C (M.X, N.X) (tensorUnit', 𝟙_ C) ≫ ((ρ_ M.X).hom ⊗ (ρ_ N.X).hom) =
    (ρ_ (M.X ⊗ N.X)).hom
[PROOFSTEP]
symm
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (ρ_ (M.X ⊗ N.X)).hom =
    (𝟙 (M.X ⊗ N.X) ⊗ (λ_ (𝟙_ C)).inv) ≫ tensor_μ C (M.X, N.X) (tensorUnit', 𝟙_ C) ≫ ((ρ_ M.X).hom ⊗ (ρ_ N.X).hom)
[PROOFSTEP]
exact tensor_right_unitality C M.X N.X
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ 𝟙 (M.X ⊗ N.X)) ≫
      tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
    (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
      (𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
[PROOFSTEP]
rw [← Category.id_comp (𝟙 (M.X ⊗ N.X)), tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ ((tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)) ≫ ((M.mul ⊗ N.mul) ⊗ 𝟙 (M.X ⊗ N.X))) ≫
      tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) =
    (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
      (𝟙 (M.X ⊗ N.X) ≫ 𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
[PROOFSTEP]
slice_lhs 2 3 => rw [← tensor_id, tensor_μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.mul ⊗ N.mul) ⊗ 𝟙 (M.X ⊗ N.X)) ≫ tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)
[PROOFSTEP]
rw [← tensor_id, tensor_μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.mul ⊗ N.mul) ⊗ 𝟙 (M.X ⊗ N.X)) ≫ tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)
[PROOFSTEP]
rw [← tensor_id, tensor_μ_natural]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.mul ⊗ N.mul) ⊗ 𝟙 (M.X ⊗ N.X)) ≫ tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)
[PROOFSTEP]
rw [← tensor_id, tensor_μ_natural]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)) ≫
      (tensor_μ C (((M.X, N.X) ⊗ (M.X, N.X)).fst, ((M.X, N.X) ⊗ (M.X, N.X)).snd) (M.X, N.X) ≫
          ((M.mul ⊗ 𝟙 M.X) ⊗ N.mul ⊗ 𝟙 N.X)) ≫
        (M.mul ⊗ N.mul) =
    (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
      (𝟙 (M.X ⊗ N.X) ≫ 𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
[PROOFSTEP]
slice_lhs 3 4 =>
  rw [← tensor_comp, mul_assoc M, mul_assoc N, tensor_comp, tensor_comp]
    -- Porting note: needed to add `dsimp` here.
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.mul ⊗ 𝟙 M.X) ⊗ N.mul ⊗ 𝟙 N.X) ≫ (M.mul ⊗ N.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (((M.X, N.X) ⊗ (M.X, N.X)).fst, ((M.X, N.X) ⊗ (M.X, N.X)).snd) (M.X, N.X)
[PROOFSTEP]
rw [← tensor_comp, mul_assoc M, mul_assoc N, tensor_comp, tensor_comp]
    -- Porting note: needed to add `dsimp` here.
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.mul ⊗ 𝟙 M.X) ⊗ N.mul ⊗ 𝟙 N.X) ≫ (M.mul ⊗ N.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (((M.X, N.X) ⊗ (M.X, N.X)).fst, ((M.X, N.X) ⊗ (M.X, N.X)).snd) (M.X, N.X)
[PROOFSTEP]
rw [← tensor_comp, mul_assoc M, mul_assoc N, tensor_comp, tensor_comp]
    -- Porting note: needed to add `dsimp` here.
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| ((M.mul ⊗ 𝟙 M.X) ⊗ N.mul ⊗ 𝟙 N.X) ≫ (M.mul ⊗ N.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (((M.X, N.X) ⊗ (M.X, N.X)).fst, ((M.X, N.X) ⊗ (M.X, N.X)).snd) (M.X, N.X)
[PROOFSTEP]
rw [← tensor_comp, mul_assoc M, mul_assoc N, tensor_comp, tensor_comp]
  -- Porting note: needed to add `dsimp` here.
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)) ≫
      tensor_μ C (((M.X, N.X) ⊗ (M.X, N.X)).fst, ((M.X, N.X) ⊗ (M.X, N.X)).snd) (M.X, N.X) ≫
        ((α_ M.X M.X M.X).hom ⊗ (α_ N.X N.X N.X).hom) ≫ ((𝟙 M.X ⊗ M.mul) ⊗ 𝟙 N.X ⊗ N.mul) ≫ (M.mul ⊗ N.mul) =
    (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
      (𝟙 (M.X ⊗ N.X) ≫ 𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
[PROOFSTEP]
slice_lhs 1 3 => dsimp; rw [tensor_associativity]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)) ≫
    tensor_μ C (((M.X, N.X) ⊗ (M.X, N.X)).fst, ((M.X, N.X) ⊗ (M.X, N.X)).snd) (M.X, N.X) ≫
      ((α_ M.X M.X M.X).hom ⊗ (α_ N.X N.X N.X).hom)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (𝟙 M.X ⊗ M.mul) ⊗ 𝟙 N.X ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
[PROOFSTEP]
dsimp; rw [tensor_associativity]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)) ≫
    tensor_μ C (((M.X, N.X) ⊗ (M.X, N.X)).fst, ((M.X, N.X) ⊗ (M.X, N.X)).snd) (M.X, N.X) ≫
      ((α_ M.X M.X M.X).hom ⊗ (α_ N.X N.X N.X).hom)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (𝟙 M.X ⊗ M.mul) ⊗ 𝟙 N.X ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
[PROOFSTEP]
dsimp; rw [tensor_associativity]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)) ≫
    tensor_μ C (((M.X, N.X) ⊗ (M.X, N.X)).fst, ((M.X, N.X) ⊗ (M.X, N.X)).snd) (M.X, N.X) ≫
      ((α_ M.X M.X M.X).hom ⊗ (α_ N.X N.X N.X).hom)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (𝟙 M.X ⊗ M.mul) ⊗ 𝟙 N.X ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
[PROOFSTEP]
dsimp
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (M.X ⊗ N.X)) ≫
    tensor_μ C (M.X ⊗ M.X, N.X ⊗ N.X) (M.X, N.X) ≫ ((α_ M.X M.X M.X).hom ⊗ (α_ N.X N.X N.X).hom)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (𝟙 M.X ⊗ M.mul) ⊗ 𝟙 N.X ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
[PROOFSTEP]
rw [tensor_associativity]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (((α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
          (𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X)) ≫ tensor_μ C (M.X, N.X) (M.X ⊗ M.X, N.X ⊗ N.X)) ≫
        ((𝟙 M.X ⊗ M.mul) ⊗ 𝟙 N.X ⊗ N.mul)) ≫
      (M.mul ⊗ N.mul) =
    (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
      (𝟙 (M.X ⊗ N.X) ≫ 𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
[PROOFSTEP]
slice_lhs 3 4 => rw [← tensor_μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X ⊗ M.X, N.X ⊗ N.X) ≫ ((𝟙 M.X ⊗ M.mul) ⊗ 𝟙 N.X ⊗ N.mul)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| 𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X)
[PROOFSTEP]
rw [← tensor_μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X ⊗ M.X, N.X ⊗ N.X) ≫ ((𝟙 M.X ⊗ M.mul) ⊗ 𝟙 N.X ⊗ N.mul)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| 𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X)
[PROOFSTEP]
rw [← tensor_μ_natural]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X ⊗ M.X, N.X ⊗ N.X) ≫ ((𝟙 M.X ⊗ M.mul) ⊗ 𝟙 N.X ⊗ N.mul)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| 𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X)
[PROOFSTEP]
rw [← tensor_μ_natural]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
      (𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X)) ≫
        (((𝟙 M.X ⊗ 𝟙 N.X) ⊗ M.mul ⊗ N.mul) ≫ tensor_μ C (M.X, N.X) (M.X, N.X)) ≫ (M.mul ⊗ N.mul) =
    (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
      (𝟙 (M.X ⊗ N.X) ≫ 𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
[PROOFSTEP]
slice_lhs 2 3 => rw [← tensor_comp, tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X)) ≫ ((𝟙 M.X ⊗ 𝟙 N.X) ⊗ M.mul ⊗ N.mul)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom
[PROOFSTEP]
rw [← tensor_comp, tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X)) ≫ ((𝟙 M.X ⊗ 𝟙 N.X) ⊗ M.mul ⊗ N.mul)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom
[PROOFSTEP]
rw [← tensor_comp, tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X)) ≫ ((𝟙 M.X ⊗ 𝟙 N.X) ⊗ M.mul ⊗ N.mul)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| M.mul ⊗ N.mul
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
| (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom
[PROOFSTEP]
rw [← tensor_comp, tensor_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N : Mon_ C
⊢ (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
      ((𝟙 (M.X ⊗ N.X) ≫ 𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ≫
          tensor_μ C (M.X, N.X) (M.X, N.X)) ≫
        (M.mul ⊗ N.mul) =
    (α_ (M.X ⊗ N.X) (M.X ⊗ N.X) (M.X ⊗ N.X)).hom ≫
      (𝟙 (M.X ⊗ N.X) ≫ 𝟙 (M.X ⊗ N.X) ⊗ tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)) ≫
        tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫ (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
      (α_ M.X N.X P.X).hom =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
      (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul) ≫ (α_ M.X N.X P.X).hom =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))
[PROOFSTEP]
slice_lhs 2 3 => rw [← Category.id_comp P.mul, tensor_comp]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul) ≫ (α_ M.X N.X P.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X)
[PROOFSTEP]
rw [← Category.id_comp P.mul, tensor_comp]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul) ≫ (α_ M.X N.X P.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X)
[PROOFSTEP]
rw [← Category.id_comp P.mul, tensor_comp]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul) ≫ (α_ M.X N.X P.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X)
[PROOFSTEP]
rw [← Category.id_comp P.mul, tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
      ((tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫ ((M.mul ⊗ N.mul) ⊗ P.mul)) ≫ (α_ M.X N.X P.X).hom =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))
[PROOFSTEP]
slice_lhs 3 4 => rw [associator_naturality]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| ((M.mul ⊗ N.mul) ⊗ P.mul) ≫ (α_ M.X N.X P.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| ((M.mul ⊗ N.mul) ⊗ P.mul) ≫ (α_ M.X N.X P.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| ((M.mul ⊗ N.mul) ⊗ P.mul) ≫ (α_ M.X N.X P.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
      (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫
        (α_ (M.X ⊗ M.X) (N.X ⊗ N.X) (P.X ⊗ P.X)).hom ≫ (M.mul ⊗ N.mul ⊗ P.mul) =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))
[PROOFSTEP]
slice_rhs 3 4 => rw [← Category.id_comp M.mul, tensor_comp]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| (α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X)
[PROOFSTEP]
rw [← Category.id_comp M.mul, tensor_comp]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| (α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X)
[PROOFSTEP]
rw [← Category.id_comp M.mul, tensor_comp]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| (α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X)
[PROOFSTEP]
rw [← Category.id_comp M.mul, tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
      (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫
        (α_ (M.X ⊗ M.X) (N.X ⊗ N.X) (P.X ⊗ P.X)).hom ≫ (M.mul ⊗ N.mul ⊗ P.mul) =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
        (𝟙 (M.X ⊗ M.X) ⊗ tensor_μ C (N.X, P.X) (N.X, P.X)) ≫ (M.mul ⊗ N.mul ⊗ P.mul)
[PROOFSTEP]
slice_lhs 1 3 => rw [associator_monoidal]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
    (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫ (α_ (M.X ⊗ M.X) (N.X ⊗ N.X) (P.X ⊗ P.X)).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| M.mul ⊗ N.mul ⊗ P.mul
[PROOFSTEP]
rw [associator_monoidal]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
    (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫ (α_ (M.X ⊗ M.X) (N.X ⊗ N.X) (P.X ⊗ P.X)).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| M.mul ⊗ N.mul ⊗ P.mul
[PROOFSTEP]
rw [associator_monoidal]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
    (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫ (α_ (M.X ⊗ M.X) (N.X ⊗ N.X) (P.X ⊗ P.X)).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| M.mul ⊗ N.mul ⊗ P.mul
[PROOFSTEP]
rw [associator_monoidal]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ (((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (𝟙 (M.X ⊗ M.X) ⊗ tensor_μ C (N.X, P.X) (N.X, P.X))) ≫
      (M.mul ⊗ N.mul ⊗ P.mul) =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
        (𝟙 (M.X ⊗ M.X) ⊗ tensor_μ C (N.X, P.X) (N.X, P.X)) ≫ (M.mul ⊗ N.mul ⊗ P.mul)
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul
[PROOFSTEP]
rw [← Category.comp_id (λ_ (𝟙_ C)).hom, ← Category.id_comp M.mul, tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)) ≫ (𝟙 (𝟙_ C) ⊗ M.mul)) ≫ (λ_ M.X).hom =
    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul
[PROOFSTEP]
slice_lhs 3 4 => rw [leftUnitor_naturality]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (𝟙 (𝟙_ C) ⊗ M.mul) ≫ (λ_ M.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)
[PROOFSTEP]
rw [leftUnitor_naturality]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (𝟙 (𝟙_ C) ⊗ M.mul) ≫ (λ_ M.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)
[PROOFSTEP]
rw [leftUnitor_naturality]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (𝟙 (𝟙_ C) ⊗ M.mul) ≫ (λ_ M.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)
[PROOFSTEP]
rw [leftUnitor_naturality]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)) ≫ (λ_ (M.X ⊗ M.X)).hom ≫ M.mul =
    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul
[PROOFSTEP]
slice_lhs 1 3 => rw [← leftUnitor_monoidal]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)) ≫ (λ_ (M.X ⊗ M.X)).hom
case a C : Type u₁ inst✝² : Category.{v₁, u₁} C inst✝¹ : MonoidalCategory C inst✝ : BraidedCategory C M : Mon_ C | M.mul
[PROOFSTEP]
rw [← leftUnitor_monoidal]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)) ≫ (λ_ (M.X ⊗ M.X)).hom
case a C : Type u₁ inst✝² : Category.{v₁, u₁} C inst✝¹ : MonoidalCategory C inst✝ : BraidedCategory C M : Mon_ C | M.mul
[PROOFSTEP]
rw [← leftUnitor_monoidal]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)) ≫ (λ_ (M.X ⊗ M.X)).hom
case a C : Type u₁ inst✝² : Category.{v₁, u₁} C inst✝¹ : MonoidalCategory C inst✝ : BraidedCategory C M : Mon_ C | M.mul
[PROOFSTEP]
rw [← leftUnitor_monoidal]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul = ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul
[PROOFSTEP]
simp only [Category.assoc, Category.id_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul
[PROOFSTEP]
rw [← Category.id_comp M.mul, ← Category.comp_id (λ_ (𝟙_ C)).hom, tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom) ≫ (M.mul ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom =
    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul
[PROOFSTEP]
slice_lhs 3 4 => rw [rightUnitor_naturality]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (M.mul ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ M.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| 𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom
[PROOFSTEP]
rw [rightUnitor_naturality]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (M.mul ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ M.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| 𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom
[PROOFSTEP]
rw [rightUnitor_naturality]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (M.mul ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ M.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| 𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom
[PROOFSTEP]
rw [rightUnitor_naturality]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom) ≫ (ρ_ (M.X ⊗ M.X)).hom ≫ M.mul =
    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul
[PROOFSTEP]
slice_lhs 1 3 => rw [← rightUnitor_monoidal]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom) ≫ (ρ_ (M.X ⊗ M.X)).hom
case a C : Type u₁ inst✝² : Category.{v₁, u₁} C inst✝¹ : MonoidalCategory C inst✝ : BraidedCategory C M : Mon_ C | M.mul
[PROOFSTEP]
rw [← rightUnitor_monoidal]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom) ≫ (ρ_ (M.X ⊗ M.X)).hom
case a C : Type u₁ inst✝² : Category.{v₁, u₁} C inst✝¹ : MonoidalCategory C inst✝ : BraidedCategory C M : Mon_ C | M.mul
[PROOFSTEP]
rw [← rightUnitor_monoidal]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom) ≫ (ρ_ (M.X ⊗ M.X)).hom
case a C : Type u₁ inst✝² : Category.{v₁, u₁} C inst✝¹ : MonoidalCategory C inst✝ : BraidedCategory C M : Mon_ C | M.mul
[PROOFSTEP]
rw [← rightUnitor_monoidal]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul = ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul
[PROOFSTEP]
simp only [Category.assoc, Category.id_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
⊢ ((fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
          X₁✝ X₂✝).one ≫
      (f.hom ⊗ g.hom) =
    ((fun M N =>
          mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
        Y₁✝ Y₂✝).one
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
⊢ ((λ_ (𝟙_ C)).inv ≫ (X₁✝.one ⊗ X₂✝.one)) ≫ (f.hom ⊗ g.hom) = (λ_ (𝟙_ C)).inv ≫ (Y₁✝.one ⊗ Y₂✝.one)
[PROOFSTEP]
slice_lhs 2 3 => rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| (X₁✝.one ⊗ X₂✝.one) ≫ (f.hom ⊗ g.hom)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| (X₁✝.one ⊗ X₂✝.one) ≫ (f.hom ⊗ g.hom)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| (X₁✝.one ⊗ X₂✝.one) ≫ (f.hom ⊗ g.hom)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| (λ_ (𝟙_ C)).inv
[PROOFSTEP]
rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
⊢ ((fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
          X₁✝ X₂✝).mul ≫
      (f.hom ⊗ g.hom) =
    ((f.hom ⊗ g.hom) ⊗ f.hom ⊗ g.hom) ≫
      ((fun M N =>
            mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
          Y₁✝ Y₂✝).mul
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
⊢ (tensor_μ C (X₁✝.X, X₂✝.X) (X₁✝.X, X₂✝.X) ≫ (X₁✝.mul ⊗ X₂✝.mul)) ≫ (f.hom ⊗ g.hom) =
    ((f.hom ⊗ g.hom) ⊗ f.hom ⊗ g.hom) ≫ tensor_μ C (Y₁✝.X, Y₂✝.X) (Y₁✝.X, Y₂✝.X) ≫ (Y₁✝.mul ⊗ Y₂✝.mul)
[PROOFSTEP]
slice_rhs 1 2 => rw [tensor_μ_natural]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| ((f.hom ⊗ g.hom) ⊗ f.hom ⊗ g.hom) ≫ tensor_μ C (Y₁✝.X, Y₂✝.X) (Y₁✝.X, Y₂✝.X)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| Y₁✝.mul ⊗ Y₂✝.mul
[PROOFSTEP]
rw [tensor_μ_natural]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| ((f.hom ⊗ g.hom) ⊗ f.hom ⊗ g.hom) ≫ tensor_μ C (Y₁✝.X, Y₂✝.X) (Y₁✝.X, Y₂✝.X)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| Y₁✝.mul ⊗ Y₂✝.mul
[PROOFSTEP]
rw [tensor_μ_natural]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| ((f.hom ⊗ g.hom) ⊗ f.hom ⊗ g.hom) ≫ tensor_μ C (Y₁✝.X, Y₂✝.X) (Y₁✝.X, Y₂✝.X)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| Y₁✝.mul ⊗ Y₂✝.mul
[PROOFSTEP]
rw [tensor_μ_natural]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
⊢ (tensor_μ C (X₁✝.X, X₂✝.X) (X₁✝.X, X₂✝.X) ≫ (X₁✝.mul ⊗ X₂✝.mul)) ≫ (f.hom ⊗ g.hom) =
    (tensor_μ C (X₁✝.X, X₂✝.X) (X₁✝.X, X₂✝.X) ≫ ((f.hom ⊗ f.hom) ⊗ g.hom ⊗ g.hom)) ≫ (Y₁✝.mul ⊗ Y₂✝.mul)
[PROOFSTEP]
slice_lhs 2 3 => rw [← tensor_comp, Hom.mul_hom f, Hom.mul_hom g, tensor_comp]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| (X₁✝.mul ⊗ X₂✝.mul) ≫ (f.hom ⊗ g.hom)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| tensor_μ C (X₁✝.X, X₂✝.X) (X₁✝.X, X₂✝.X)
[PROOFSTEP]
rw [← tensor_comp, Hom.mul_hom f, Hom.mul_hom g, tensor_comp]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| (X₁✝.mul ⊗ X₂✝.mul) ≫ (f.hom ⊗ g.hom)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| tensor_μ C (X₁✝.X, X₂✝.X) (X₁✝.X, X₂✝.X)
[PROOFSTEP]
rw [← tensor_comp, Hom.mul_hom f, Hom.mul_hom g, tensor_comp]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| (X₁✝.mul ⊗ X₂✝.mul) ≫ (f.hom ⊗ g.hom)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
| tensor_μ C (X₁✝.X, X₂✝.X) (X₁✝.X, X₂✝.X)
[PROOFSTEP]
rw [← tensor_comp, Hom.mul_hom f, Hom.mul_hom g, tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ X₂✝ Y₂✝ : Mon_ C
f : X₁✝ ⟶ Y₁✝
g : X₂✝ ⟶ Y₂✝
⊢ tensor_μ C (X₁✝.X, X₂✝.X) (X₁✝.X, X₂✝.X) ≫ ((f.hom ⊗ f.hom) ⊗ g.hom ⊗ g.hom) ≫ (Y₁✝.mul ⊗ Y₂✝.mul) =
    (tensor_μ C (X₁✝.X, X₂✝.X) (X₁✝.X, X₂✝.X) ≫ ((f.hom ⊗ f.hom) ⊗ g.hom ⊗ g.hom)) ≫ (Y₁✝.mul ⊗ Y₂✝.mul)
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ ∀ (X₁ X₂ : Mon_ C),
    (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 X₁) (𝟙 X₂) =
      𝟙
        ((fun M N =>
            mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
          X₁ X₂)
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ X₂✝ : Mon_ C
⊢ (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 X₁✝) (𝟙 X₂✝) =
    𝟙
      ((fun M N =>
          mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
        X₁✝ X₂✝)
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ X₂✝ : Mon_ C
⊢ ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 X₁✝) (𝟙 X₂✝)).hom =
    (𝟙
        ((fun M N =>
            mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
          X₁✝ X₂✝)).hom
[PROOFSTEP]
apply tensor_id
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ ∀ {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : Mon_ C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂),
    (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (f₁ ≫ g₁) (f₂ ≫ g₂) =
      (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₁ f₂ ≫ (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) g₁ g₂
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ Z₁✝ X₂✝ Y₂✝ Z₂✝ : Mon_ C
f₁✝ : X₁✝ ⟶ Y₁✝
f₂✝ : X₂✝ ⟶ Y₂✝
g₁✝ : Y₁✝ ⟶ Z₁✝
g₂✝ : Y₂✝ ⟶ Z₂✝
⊢ (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (f₁✝ ≫ g₁✝) (f₂✝ ≫ g₂✝) =
    (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₁✝ f₂✝ ≫
      (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) g₁✝ g₂✝
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ Y₁✝ Z₁✝ X₂✝ Y₂✝ Z₂✝ : Mon_ C
f₁✝ : X₁✝ ⟶ Y₁✝
f₂✝ : X₂✝ ⟶ Y₂✝
g₁✝ : Y₁✝ ⟶ Z₁✝
g₂✝ : Y₂✝ ⟶ Z₂✝
⊢ ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (f₁✝ ≫ g₁✝) (f₂✝ ≫ g₂✝)).hom =
    ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₁✝ f₂✝ ≫
        (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) g₁✝ g₂✝).hom
[PROOFSTEP]
apply tensor_comp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ ∀ {X₁ X₂ X₃ Y₁ Y₂ Y₃ : Mon_ C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃),
    (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₁ f₂) f₃ ≫
        ((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            Y₁ Y₂ Y₃).hom =
      ((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            X₁ X₂ X₃).hom ≫
        (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₁ ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₂ f₃)
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : Mon_ C
f₁✝ : X₁✝ ⟶ Y₁✝
f₂✝ : X₂✝ ⟶ Y₂✝
f₃✝ : X₃✝ ⟶ Y₃✝
⊢ (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₁✝ f₂✝) f₃✝ ≫
      ((fun M N P =>
            isoOfIso (α_ M.X N.X P.X)
              (_ :
                ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                  (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
              (_ :
                (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                      (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                    (α_ M.X N.X P.X).hom =
                  ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                    tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                      (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
          Y₁✝ Y₂✝ Y₃✝).hom =
    ((fun M N P =>
            isoOfIso (α_ M.X N.X P.X)
              (_ :
                ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                  (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
              (_ :
                (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                      (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                    (α_ M.X N.X P.X).hom =
                  ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                    tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                      (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
          X₁✝ X₂✝ X₃✝).hom ≫
      (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₁✝ ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₂✝ f₃✝)
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : Mon_ C
f₁✝ : X₁✝ ⟶ Y₁✝
f₂✝ : X₂✝ ⟶ Y₂✝
f₃✝ : X₃✝ ⟶ Y₃✝
⊢ ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₁✝ f₂✝) f₃✝ ≫
        ((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            Y₁✝ Y₂✝ Y₃✝).hom).hom =
    (((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            X₁✝ X₂✝ X₃✝).hom ≫
        (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₁✝
          ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f₂✝ f₃✝)).hom
[PROOFSTEP]
dsimp
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : Mon_ C
f₁✝ : X₁✝ ⟶ Y₁✝
f₂✝ : X₂✝ ⟶ Y₂✝
f₃✝ : X₃✝ ⟶ Y₃✝
⊢ ((f₁✝.hom ⊗ f₂✝.hom) ⊗ f₃✝.hom) ≫
      (isoOfIso (α_ Y₁✝.X Y₂✝.X Y₃✝.X)
            (_ :
              ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (Y₁✝.one ⊗ Y₂✝.one) ⊗ Y₃✝.one)) ≫ (α_ Y₁✝.X Y₂✝.X Y₃✝.X).hom =
                (λ_ (𝟙_ C)).inv ≫ (Y₁✝.one ⊗ (λ_ (𝟙_ C)).inv ≫ (Y₂✝.one ⊗ Y₃✝.one)))
            (_ :
              (tensor_μ C (Y₁✝.X ⊗ Y₂✝.X, Y₃✝.X) (Y₁✝.X ⊗ Y₂✝.X, Y₃✝.X) ≫
                    (tensor_μ C (Y₁✝.X, Y₂✝.X) (Y₁✝.X, Y₂✝.X) ≫ (Y₁✝.mul ⊗ Y₂✝.mul) ⊗ Y₃✝.mul)) ≫
                  (α_ Y₁✝.X Y₂✝.X Y₃✝.X).hom =
                ((α_ Y₁✝.X Y₂✝.X Y₃✝.X).hom ⊗ (α_ Y₁✝.X Y₂✝.X Y₃✝.X).hom) ≫
                  tensor_μ C (Y₁✝.X, Y₂✝.X ⊗ Y₃✝.X) (Y₁✝.X, Y₂✝.X ⊗ Y₃✝.X) ≫
                    (Y₁✝.mul ⊗ tensor_μ C (Y₂✝.X, Y₃✝.X) (Y₂✝.X, Y₃✝.X) ≫ (Y₂✝.mul ⊗ Y₃✝.mul)))).hom.hom =
    (isoOfIso (α_ X₁✝.X X₂✝.X X₃✝.X)
            (_ :
              ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (X₁✝.one ⊗ X₂✝.one) ⊗ X₃✝.one)) ≫ (α_ X₁✝.X X₂✝.X X₃✝.X).hom =
                (λ_ (𝟙_ C)).inv ≫ (X₁✝.one ⊗ (λ_ (𝟙_ C)).inv ≫ (X₂✝.one ⊗ X₃✝.one)))
            (_ :
              (tensor_μ C (X₁✝.X ⊗ X₂✝.X, X₃✝.X) (X₁✝.X ⊗ X₂✝.X, X₃✝.X) ≫
                    (tensor_μ C (X₁✝.X, X₂✝.X) (X₁✝.X, X₂✝.X) ≫ (X₁✝.mul ⊗ X₂✝.mul) ⊗ X₃✝.mul)) ≫
                  (α_ X₁✝.X X₂✝.X X₃✝.X).hom =
                ((α_ X₁✝.X X₂✝.X X₃✝.X).hom ⊗ (α_ X₁✝.X X₂✝.X X₃✝.X).hom) ≫
                  tensor_μ C (X₁✝.X, X₂✝.X ⊗ X₃✝.X) (X₁✝.X, X₂✝.X ⊗ X₃✝.X) ≫
                    (X₁✝.mul ⊗ tensor_μ C (X₂✝.X, X₃✝.X) (X₂✝.X, X₃✝.X) ≫ (X₂✝.mul ⊗ X₃✝.mul)))).hom.hom ≫
      (f₁✝.hom ⊗ f₂✝.hom ⊗ f₃✝.hom)
[PROOFSTEP]
apply associator_naturality
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ ∀ {X Y : Mon_ C} (f : X ⟶ Y),
    (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 (trivial C)) f ≫
        ((fun M =>
              isoOfIso (λ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
                    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul))
            Y).hom =
      ((fun M =>
              isoOfIso (λ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
                    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul))
            X).hom ≫
        f
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : Mon_ C
f✝ : X✝ ⟶ Y✝
⊢ (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 (trivial C)) f✝ ≫
      ((fun M =>
            isoOfIso (λ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one)
              (_ :
                (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
                  ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul))
          Y✝).hom =
    ((fun M =>
            isoOfIso (λ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one)
              (_ :
                (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
                  ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul))
          X✝).hom ≫
      f✝
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : Mon_ C
f✝ : X✝ ⟶ Y✝
⊢ ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 (trivial C)) f✝ ≫
        ((fun M =>
              isoOfIso (λ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
                    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul))
            Y✝).hom).hom =
    (((fun M =>
              isoOfIso (λ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
                    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul))
            X✝).hom ≫
        f✝).hom
[PROOFSTEP]
dsimp
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : Mon_ C
f✝ : X✝ ⟶ Y✝
⊢ (𝟙 (𝟙_ C) ⊗ f✝.hom) ≫
      (isoOfIso (λ_ Y✝.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ Y✝.one)) ≫ (λ_ Y✝.X).hom = Y✝.one)
            (_ :
              (tensor_μ C (𝟙_ C, Y✝.X) (𝟙_ C, Y✝.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ Y✝.mul)) ≫ (λ_ Y✝.X).hom =
                ((λ_ Y✝.X).hom ⊗ (λ_ Y✝.X).hom) ≫ Y✝.mul)).hom.hom =
    (isoOfIso (λ_ X✝.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ X✝.one)) ≫ (λ_ X✝.X).hom = X✝.one)
            (_ :
              (tensor_μ C (𝟙_ C, X✝.X) (𝟙_ C, X✝.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ X✝.mul)) ≫ (λ_ X✝.X).hom =
                ((λ_ X✝.X).hom ⊗ (λ_ X✝.X).hom) ≫ X✝.mul)).hom.hom ≫
      f✝.hom
[PROOFSTEP]
apply leftUnitor_naturality
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ ∀ {X Y : Mon_ C} (f : X ⟶ Y),
    (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f (𝟙 (trivial C)) ≫
        ((fun M =>
              isoOfIso (ρ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
                    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul))
            Y).hom =
      ((fun M =>
              isoOfIso (ρ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
                    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul))
            X).hom ≫
        f
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : Mon_ C
f✝ : X✝ ⟶ Y✝
⊢ (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f✝ (𝟙 (trivial C)) ≫
      ((fun M =>
            isoOfIso (ρ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one)
              (_ :
                (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
                  ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul))
          Y✝).hom =
    ((fun M =>
            isoOfIso (ρ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one)
              (_ :
                (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
                  ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul))
          X✝).hom ≫
      f✝
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : Mon_ C
f✝ : X✝ ⟶ Y✝
⊢ ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) f✝ (𝟙 (trivial C)) ≫
        ((fun M =>
              isoOfIso (ρ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
                    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul))
            Y✝).hom).hom =
    (((fun M =>
              isoOfIso (ρ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
                    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul))
            X✝).hom ≫
        f✝).hom
[PROOFSTEP]
dsimp
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : Mon_ C
f✝ : X✝ ⟶ Y✝
⊢ (f✝.hom ⊗ 𝟙 (𝟙_ C)) ≫
      (isoOfIso (ρ_ Y✝.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ Y✝.X).hom = Y✝.one)
            (_ :
              (tensor_μ C (Y✝.X, 𝟙_ C) (Y✝.X, 𝟙_ C) ≫ (Y✝.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ Y✝.X).hom =
                ((ρ_ Y✝.X).hom ⊗ (ρ_ Y✝.X).hom) ≫ Y✝.mul)).hom.hom =
    (isoOfIso (ρ_ X✝.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ X✝.X).hom = X✝.one)
            (_ :
              (tensor_μ C (X✝.X, 𝟙_ C) (X✝.X, 𝟙_ C) ≫ (X✝.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ X✝.X).hom =
                ((ρ_ X✝.X).hom ⊗ (ρ_ X✝.X).hom) ≫ X✝.mul)).hom.hom ≫
      f✝.hom
[PROOFSTEP]
apply rightUnitor_naturality
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ ∀ (W X Y Z : Mon_ C),
    (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom))
          ((fun M N P =>
                isoOfIso (α_ M.X N.X P.X)
                  (_ :
                    ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                      (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                  (_ :
                    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                        (α_ M.X N.X P.X).hom =
                      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
              W X Y).hom
          (𝟙 Z) ≫
        ((fun M N P =>
                isoOfIso (α_ M.X N.X P.X)
                  (_ :
                    ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                      (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                  (_ :
                    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                        (α_ M.X N.X P.X).hom =
                      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
              W
              ((fun M N =>
                  mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one))
                    (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
                X Y)
              Z).hom ≫
          (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 W)
            ((fun M N P =>
                  isoOfIso (α_ M.X N.X P.X)
                    (_ :
                      ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                        (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                    (_ :
                      (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                            (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                          (α_ M.X N.X P.X).hom =
                        ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                          tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                            (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
                X Y Z).hom =
      ((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            ((fun M N =>
                mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
              W X)
            Y Z).hom ≫
        ((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            W X
            ((fun M N =>
                mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
              Y Z)).hom
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
W✝ X✝ Y✝ Z✝ : Mon_ C
⊢ (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom))
        ((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            W✝ X✝ Y✝).hom
        (𝟙 Z✝) ≫
      ((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            W✝
            ((fun M N =>
                mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
              X✝ Y✝)
            Z✝).hom ≫
        (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 W✝)
          ((fun M N P =>
                isoOfIso (α_ M.X N.X P.X)
                  (_ :
                    ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                      (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                  (_ :
                    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                        (α_ M.X N.X P.X).hom =
                      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
              X✝ Y✝ Z✝).hom =
    ((fun M N P =>
            isoOfIso (α_ M.X N.X P.X)
              (_ :
                ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                  (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
              (_ :
                (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                      (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                    (α_ M.X N.X P.X).hom =
                  ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                    tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                      (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
          ((fun M N =>
              mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
            W✝ X✝)
          Y✝ Z✝).hom ≫
      ((fun M N P =>
            isoOfIso (α_ M.X N.X P.X)
              (_ :
                ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                  (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
              (_ :
                (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                      (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                    (α_ M.X N.X P.X).hom =
                  ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                    tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                      (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
          W✝ X✝
          ((fun M N =>
              mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
            Y✝ Z✝)).hom
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
W✝ X✝ Y✝ Z✝ : Mon_ C
⊢ ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom))
          ((fun M N P =>
                isoOfIso (α_ M.X N.X P.X)
                  (_ :
                    ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                      (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                  (_ :
                    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                        (α_ M.X N.X P.X).hom =
                      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
              W✝ X✝ Y✝).hom
          (𝟙 Z✝) ≫
        ((fun M N P =>
                isoOfIso (α_ M.X N.X P.X)
                  (_ :
                    ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                      (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                  (_ :
                    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                        (α_ M.X N.X P.X).hom =
                      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
              W✝
              ((fun M N =>
                  mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one))
                    (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
                X✝ Y✝)
              Z✝).hom ≫
          (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 W✝)
            ((fun M N P =>
                  isoOfIso (α_ M.X N.X P.X)
                    (_ :
                      ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                        (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                    (_ :
                      (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                            (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                          (α_ M.X N.X P.X).hom =
                        ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                          tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                            (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
                X✝ Y✝ Z✝).hom).hom =
    (((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            ((fun M N =>
                mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
              W✝ X✝)
            Y✝ Z✝).hom ≫
        ((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            W✝ X✝
            ((fun M N =>
                mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)))
              Y✝ Z✝)).hom).hom
[PROOFSTEP]
dsimp
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
W✝ X✝ Y✝ Z✝ : Mon_ C
⊢ ((isoOfIso (α_ W✝.X X✝.X Y✝.X)
              (_ :
                ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one) ⊗ Y✝.one)) ≫ (α_ W✝.X X✝.X Y✝.X).hom =
                  (λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ (λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one)))
              (_ :
                (tensor_μ C (W✝.X ⊗ X✝.X, Y✝.X) (W✝.X ⊗ X✝.X, Y✝.X) ≫
                      (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul) ⊗ Y✝.mul)) ≫
                    (α_ W✝.X X✝.X Y✝.X).hom =
                  ((α_ W✝.X X✝.X Y✝.X).hom ⊗ (α_ W✝.X X✝.X Y✝.X).hom) ≫
                    tensor_μ C (W✝.X, X✝.X ⊗ Y✝.X) (W✝.X, X✝.X ⊗ Y✝.X) ≫
                      (W✝.mul ⊗ tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul)))).hom.hom ⊗
        𝟙 Z✝.X) ≫
      (isoOfIso (α_ W✝.X (X✝.X ⊗ Y✝.X) Z✝.X)
              (_ :
                ((λ_ (𝟙_ C)).inv ≫
                      ((λ_ (𝟙_ C)).inv ≫
                          (W✝.one ⊗
                            (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).one) ⊗
                        Z✝.one)) ≫
                    (α_ W✝.X
                        (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                            (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X
                        Z✝.X).hom =
                  (λ_ (𝟙_ C)).inv ≫
                    (W✝.one ⊗
                      (λ_ (𝟙_ C)).inv ≫
                        ((mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                              (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).one ⊗
                          Z✝.one)))
              (_ :
                (tensor_μ C
                        (W✝.X ⊗
                            (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X,
                          Z✝.X)
                        (W✝.X ⊗
                            (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X,
                          Z✝.X) ≫
                      (tensor_μ C
                            (W✝.X,
                              (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                  (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X)
                            (W✝.X,
                              (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                  (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X) ≫
                          (W✝.mul ⊗
                            (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).mul) ⊗
                        Z✝.mul)) ≫
                    (α_ W✝.X
                        (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                            (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X
                        Z✝.X).hom =
                  ((α_ W✝.X
                          (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                              (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X
                          Z✝.X).hom ⊗
                      (α_ W✝.X
                          (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                              (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X
                          Z✝.X).hom) ≫
                    tensor_μ C
                        (W✝.X,
                          (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X ⊗
                            Z✝.X)
                        (W✝.X,
                          (mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X ⊗
                            Z✝.X) ≫
                      (W✝.mul ⊗
                        tensor_μ C
                            ((mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                  (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X,
                              Z✝.X)
                            ((mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                  (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).X,
                              Z✝.X) ≫
                          ((mk (X✝.X ⊗ Y✝.X) ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one))
                                (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul))).mul ⊗
                            Z✝.mul)))).hom.hom ≫
        (𝟙 W✝.X ⊗
          (isoOfIso (α_ X✝.X Y✝.X Z✝.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ Y✝.one) ⊗ Z✝.one)) ≫ (α_ X✝.X Y✝.X Z✝.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ (λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one)))
                (_ :
                  (tensor_μ C (X✝.X ⊗ Y✝.X, Z✝.X) (X✝.X ⊗ Y✝.X, Z✝.X) ≫
                        (tensor_μ C (X✝.X, Y✝.X) (X✝.X, Y✝.X) ≫ (X✝.mul ⊗ Y✝.mul) ⊗ Z✝.mul)) ≫
                      (α_ X✝.X Y✝.X Z✝.X).hom =
                    ((α_ X✝.X Y✝.X Z✝.X).hom ⊗ (α_ X✝.X Y✝.X Z✝.X).hom) ≫
                      tensor_μ C (X✝.X, Y✝.X ⊗ Z✝.X) (X✝.X, Y✝.X ⊗ Z✝.X) ≫
                        (X✝.mul ⊗ tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul)))).hom.hom) =
    (isoOfIso (α_ (W✝.X ⊗ X✝.X) Y✝.X Z✝.X)
            (_ :
              ((λ_ (𝟙_ C)).inv ≫
                    ((λ_ (𝟙_ C)).inv ≫
                        ((mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                              (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).one ⊗
                          Y✝.one) ⊗
                      Z✝.one)) ≫
                  (α_
                      (mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                          (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).X
                      Y✝.X Z✝.X).hom =
                (λ_ (𝟙_ C)).inv ≫
                  ((mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                        (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).one ⊗
                    (λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one)))
            (_ :
              (tensor_μ C
                      ((mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                              (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).X ⊗
                          Y✝.X,
                        Z✝.X)
                      ((mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                              (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).X ⊗
                          Y✝.X,
                        Z✝.X) ≫
                    (tensor_μ C
                          ((mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                                (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).X,
                            Y✝.X)
                          ((mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                                (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).X,
                            Y✝.X) ≫
                        ((mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                              (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).mul ⊗
                          Y✝.mul) ⊗
                      Z✝.mul)) ≫
                  (α_
                      (mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                          (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).X
                      Y✝.X Z✝.X).hom =
                ((α_
                        (mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                            (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).X
                        Y✝.X Z✝.X).hom ⊗
                    (α_
                        (mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                            (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).X
                        Y✝.X Z✝.X).hom) ≫
                  tensor_μ C
                      ((mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                            (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).X,
                        Y✝.X ⊗ Z✝.X)
                      ((mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                            (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).X,
                        Y✝.X ⊗ Z✝.X) ≫
                    ((mk (W✝.X ⊗ X✝.X) ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one))
                          (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul))).mul ⊗
                      tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul)))).hom.hom ≫
      (isoOfIso (α_ W✝.X X✝.X (Y✝.X ⊗ Z✝.X))
            (_ :
              ((λ_ (𝟙_ C)).inv ≫
                    ((λ_ (𝟙_ C)).inv ≫ (W✝.one ⊗ X✝.one) ⊗
                      (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                          (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).one)) ≫
                  (α_ W✝.X X✝.X
                      (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                          (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).X).hom =
                (λ_ (𝟙_ C)).inv ≫
                  (W✝.one ⊗
                    (λ_ (𝟙_ C)).inv ≫
                      (X✝.one ⊗
                        (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                            (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).one)))
            (_ :
              (tensor_μ C
                      (W✝.X ⊗ X✝.X,
                        (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                            (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).X)
                      (W✝.X ⊗ X✝.X,
                        (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                            (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).X) ≫
                    (tensor_μ C (W✝.X, X✝.X) (W✝.X, X✝.X) ≫ (W✝.mul ⊗ X✝.mul) ⊗
                      (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                          (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).mul)) ≫
                  (α_ W✝.X X✝.X
                      (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                          (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).X).hom =
                ((α_ W✝.X X✝.X
                        (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                            (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).X).hom ⊗
                    (α_ W✝.X X✝.X
                        (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                            (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).X).hom) ≫
                  tensor_μ C
                      (W✝.X,
                        X✝.X ⊗
                          (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                              (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).X)
                      (W✝.X,
                        X✝.X ⊗
                          (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                              (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).X) ≫
                    (W✝.mul ⊗
                      tensor_μ C
                          (X✝.X,
                            (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                                (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).X)
                          (X✝.X,
                            (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                                (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).X) ≫
                        (X✝.mul ⊗
                          (mk (Y✝.X ⊗ Z✝.X) ((λ_ (𝟙_ C)).inv ≫ (Y✝.one ⊗ Z✝.one))
                              (tensor_μ C (Y✝.X, Z✝.X) (Y✝.X, Z✝.X) ≫ (Y✝.mul ⊗ Z✝.mul))).mul)))).hom.hom
[PROOFSTEP]
apply pentagon
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ ∀ (X Y : Mon_ C),
    ((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            X (trivial C) Y).hom ≫
        (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 X)
          ((fun M =>
                isoOfIso (λ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one)
                  (_ :
                    (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
                      ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul))
              Y).hom =
      (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom))
        ((fun M =>
              isoOfIso (ρ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
                    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul))
            X).hom
        (𝟙 Y)
[PROOFSTEP]
intros
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : Mon_ C
⊢ ((fun M N P =>
            isoOfIso (α_ M.X N.X P.X)
              (_ :
                ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                  (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
              (_ :
                (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                      (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                    (α_ M.X N.X P.X).hom =
                  ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                    tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                      (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
          X✝ (trivial C) Y✝).hom ≫
      (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 X✝)
        ((fun M =>
              isoOfIso (λ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
                    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul))
            Y✝).hom =
    (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom))
      ((fun M =>
            isoOfIso (ρ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one)
              (_ :
                (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
                  ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul))
          X✝).hom
      (𝟙 Y✝)
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : Mon_ C
⊢ (((fun M N P =>
              isoOfIso (α_ M.X N.X P.X)
                (_ :
                  ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one) ⊗ P.one)) ≫ (α_ M.X N.X P.X).hom =
                    (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ (λ_ (𝟙_ C)).inv ≫ (N.one ⊗ P.one)))
                (_ :
                  (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
                        (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
                      (α_ M.X N.X P.X).hom =
                    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
                      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
                        (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul))))
            X✝ (trivial C) Y✝).hom ≫
        (fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom)) (𝟙 X✝)
          ((fun M =>
                isoOfIso (λ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ M.one)) ≫ (λ_ M.X).hom = M.one)
                  (_ :
                    (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
                      ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul))
              Y✝).hom).hom =
    ((fun {X₁ Y₁ X₂ Y₂} f g => Hom.mk (f.hom ⊗ g.hom))
        ((fun M =>
              isoOfIso (ρ_ M.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom = M.one)
                (_ :
                  (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
                    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul))
            X✝).hom
        (𝟙 Y✝)).hom
[PROOFSTEP]
dsimp
[GOAL]
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : Mon_ C
⊢ (isoOfIso (α_ X✝.X (𝟙_ C) Y✝.X)
            (_ :
              ((λ_ (𝟙_ C)).inv ≫ ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ (trivial C).one) ⊗ Y✝.one)) ≫
                  (α_ X✝.X (trivial C).X Y✝.X).hom =
                (λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ (λ_ (𝟙_ C)).inv ≫ ((trivial C).one ⊗ Y✝.one)))
            (_ :
              (tensor_μ C (X✝.X ⊗ (trivial C).X, Y✝.X) (X✝.X ⊗ (trivial C).X, Y✝.X) ≫
                    (tensor_μ C (X✝.X, (trivial C).X) (X✝.X, (trivial C).X) ≫ (X✝.mul ⊗ (trivial C).mul) ⊗ Y✝.mul)) ≫
                  (α_ X✝.X (trivial C).X Y✝.X).hom =
                ((α_ X✝.X (trivial C).X Y✝.X).hom ⊗ (α_ X✝.X (trivial C).X Y✝.X).hom) ≫
                  tensor_μ C (X✝.X, (trivial C).X ⊗ Y✝.X) (X✝.X, (trivial C).X ⊗ Y✝.X) ≫
                    (X✝.mul ⊗
                      tensor_μ C ((trivial C).X, Y✝.X) ((trivial C).X, Y✝.X) ≫ ((trivial C).mul ⊗ Y✝.mul)))).hom.hom ≫
      (𝟙 X✝.X ⊗
        (isoOfIso (λ_ Y✝.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (𝟙 (𝟙_ C) ⊗ Y✝.one)) ≫ (λ_ Y✝.X).hom = Y✝.one)
              (_ :
                (tensor_μ C (𝟙_ C, Y✝.X) (𝟙_ C, Y✝.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ Y✝.mul)) ≫ (λ_ Y✝.X).hom =
                  ((λ_ Y✝.X).hom ⊗ (λ_ Y✝.X).hom) ≫ Y✝.mul)).hom.hom) =
    (isoOfIso (ρ_ X✝.X) (_ : ((λ_ (𝟙_ C)).inv ≫ (X✝.one ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ X✝.X).hom = X✝.one)
            (_ :
              (tensor_μ C (X✝.X, 𝟙_ C) (X✝.X, 𝟙_ C) ≫ (X✝.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ X✝.X).hom =
                ((ρ_ X✝.X).hom ⊗ (ρ_ X✝.X).hom) ≫ X✝.mul)).hom.hom ⊗
      𝟙 Y✝.X
[PROOFSTEP]
apply triangle