[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
⊢ ∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
    (fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g)) f g =
      (fun {X₁ X₂} f X => e.functor.map (e.inverse.map f ▷ e.inverse.obj X)) f X₂ ≫
        (fun X x x_1 f => e.functor.map (e.inverse.obj X ◁ e.inverse.map f)) Y₁ X₂ Y₂ g
[PROOFSTEP]
simp [tensorHom_def]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g))
        ((fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g)) f₁ f₂) f₃ ≫
      ((fun X Y Z =>
            e.functor.mapIso
              (((e.unitIso.app (e.inverse.obj X ⊗ e.inverse.obj Y)).symm ⊗ Iso.refl (e.inverse.obj Z)) ≪≫
                α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z) ≪≫
                  (Iso.refl (e.inverse.obj X) ⊗ e.unitIso.app (e.inverse.obj Y ⊗ e.inverse.obj Z))))
          Y₁✝ Y₂✝ Y₃✝).hom =
    ((fun X Y Z =>
            e.functor.mapIso
              (((e.unitIso.app (e.inverse.obj X ⊗ e.inverse.obj Y)).symm ⊗ Iso.refl (e.inverse.obj Z)) ≪≫
                α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z) ≪≫
                  (Iso.refl (e.inverse.obj X) ⊗ e.unitIso.app (e.inverse.obj Y ⊗ e.inverse.obj Z))))
          X₁✝ X₂✝ X₃✝).hom ≫
      (fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g)) f₁
        ((fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g)) f₂ f₃)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ e.functor.map (e.inverse.map (e.functor.map (e.inverse.map f₁ ⊗ e.inverse.map f₂)) ⊗ e.inverse.map f₃) ≫
      e.functor.map
        ((NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝)) ≫
          (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom ≫
            (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))) =
    e.functor.map
        ((NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
          (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
            (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝))) ≫
      e.functor.map (e.inverse.map f₁ ⊗ e.inverse.map (e.functor.map (e.inverse.map f₂ ⊗ e.inverse.map f₃)))
[PROOFSTEP]
simp only [Equivalence.inv_fun_map, Functor.map_comp, Category.assoc]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ e.functor.map
        (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
            (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
              NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
          e.inverse.map f₃) ≫
      e.functor.map (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝)) ≫
        e.functor.map (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom ≫
          e.functor.map (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    e.functor.map (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      e.functor.map (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        e.functor.map (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          e.functor.map
            (e.inverse.map f₁ ⊗
              NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
                (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                  NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
simp only [← e.functor.map_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ e.functor.map
      ((NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
            (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
              NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
          e.inverse.map f₃) ≫
        (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝)) ≫
          (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom ≫
            (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))) =
    e.functor.map
      ((NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
        (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
          (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
            (e.inverse.map f₁ ⊗
              NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
                (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                  NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)))
[PROOFSTEP]
congr 1
[GOAL]
case e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
          (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
            NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
        e.inverse.map f₃) ≫
      (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝)) ≫
        (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (e.inverse.map f₁ ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
              (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
conv_lhs => rw [← tensor_id_comp_id_tensor]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
        (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
          NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
      e.inverse.map f₃) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝)) ≫
      (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
rw [← tensor_id_comp_id_tensor]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
        (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
          NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
      e.inverse.map f₃) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝)) ≫
      (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
rw [← tensor_id_comp_id_tensor]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
        (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
          NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
      e.inverse.map f₃) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝)) ≫
      (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
rw [← tensor_id_comp_id_tensor]
[GOAL]
case e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ ((NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
            (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
              NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
          𝟙 (e.inverse.obj X₃✝)) ≫
        (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝))) ⊗ e.inverse.map f₃)) ≫
      (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝)) ≫
        (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (e.inverse.map f₁ ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
              (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor, ← tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝))) ⊗ e.inverse.map f₃) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
      (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
        NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
    𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor, ← tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝))) ⊗ e.inverse.map f₃) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
      (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
        NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
    𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor, ← tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝))) ⊗ e.inverse.map f₃) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj Y₃✝))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
      (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
        NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
    𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor, ← tensor_id]
[GOAL]
case e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
          (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
            NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
        𝟙 (e.inverse.obj X₃✝)) ≫
      (((NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
            ((𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝)) ⊗ e.inverse.map f₃)) ≫
          (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom) ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (e.inverse.map f₁ ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
              (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
case e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
          (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
            NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
        𝟙 (e.inverse.obj X₃✝)) ≫
      (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
        ((𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝)) ⊗ e.inverse.map f₃) ≫
          (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom ≫
            (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (e.inverse.map f₁ ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
              (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
slice_lhs 3 4 => rw [associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| ((𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝)) ⊗ e.inverse.map f₃) ≫
    (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
      (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
        NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
    𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| ((𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝)) ⊗ e.inverse.map f₃) ≫
    (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
      (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
        NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
    𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| ((𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝)) ⊗ e.inverse.map f₃) ≫
    (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj Y₃✝)).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
      (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
        NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
    𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
          (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
            NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
        𝟙 (e.inverse.obj X₃✝)) ≫
      (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
        ((α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom ≫
            (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)) ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (e.inverse.map f₁ ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
              (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
conv_lhs => simp only [comp_tensor_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
        (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
          NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
      𝟙 (e.inverse.obj X₃✝)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      ((α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)) ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
simp only [comp_tensor_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
        (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
          NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
      𝟙 (e.inverse.obj X₃✝)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      ((α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)) ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
simp only [comp_tensor_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ≫
        (e.inverse.map f₁ ⊗ e.inverse.map f₂) ≫
          NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗
      𝟙 (e.inverse.obj X₃✝)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      ((α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)) ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
simp only [comp_tensor_id]
[GOAL]
case e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ ((NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
        ((e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
          (NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝))) ≫
      (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
        ((α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom ≫
            (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)) ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (e.inverse.map f₁ ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
              (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
slice_lhs 3 4 =>
  rw [← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝))
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
  rw [← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝))
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
  rw [← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝))
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [← comp_tensor_id, Iso.hom_inv_id_app]
[GOAL]
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 ((𝟭 C).obj (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝)) ⊗ 𝟙 (e.inverse.obj X₃✝)
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
dsimp
[GOAL]
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [tensor_id]
[GOAL]
case e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      ((e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
        ((𝟙 ((e.inverse.obj Y₁✝ ⊗ e.inverse.obj Y₂✝) ⊗ e.inverse.obj X₃✝) ≫
              (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom) ≫
            (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)) ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (e.inverse.map f₁ ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
              (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
simp only [Category.id_comp, Category.assoc]
[GOAL]
case e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      ((e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
        (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃) ≫
            (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (e.inverse.map f₁ ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
              (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
slice_lhs 2 3 => rw [associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| ((e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
    (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| ((e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
    (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| ((e.inverse.map f₁ ⊗ e.inverse.map f₂) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
    (α_ (e.inverse.obj Y₁✝) (e.inverse.obj Y₂✝) (e.inverse.obj X₃✝)).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (((α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
            (e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ 𝟙 (e.inverse.obj X₃✝))) ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)) ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (e.inverse.map f₁ ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
              (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
case e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃) ≫
            (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (NatTrans.app e.unitIso.inv (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝) ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (α_ (e.inverse.obj X₁✝) (e.inverse.obj X₂✝) (e.inverse.obj X₃✝)).hom ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (e.inverse.map f₁ ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
              (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
                NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
congr 2
[GOAL]
case e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
      (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃) ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
      (e.inverse.map f₁ ⊗
        NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
          (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
            NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
slice_lhs 1 1 => rw [← tensor_id_comp_id_tensor]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ 𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [← tensor_id_comp_id_tensor]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ 𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [← tensor_id_comp_id_tensor]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ 𝟙 (e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [← tensor_id_comp_id_tensor]
[GOAL]
case e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (((e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (𝟙 (e.inverse.obj Y₁✝) ⊗ e.inverse.map f₂ ⊗ 𝟙 (e.inverse.obj X₃✝))) ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)) ≫
      (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
      (e.inverse.map f₁ ⊗
        NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
          (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
            NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
slice_lhs 2 3 => rw [← id_tensor_comp, tensor_id_comp_id_tensor]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj Y₁✝) ⊗ e.inverse.map f₂ ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
    (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)
[PROOFSTEP]
rw [← id_tensor_comp, tensor_id_comp_id_tensor]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj Y₁✝) ⊗ e.inverse.map f₂ ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
    (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)
[PROOFSTEP]
rw [← id_tensor_comp, tensor_id_comp_id_tensor]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj Y₁✝) ⊗ e.inverse.map f₂ ⊗ 𝟙 (e.inverse.obj X₃✝)) ≫
    (𝟙 (e.inverse.obj Y₁✝) ⊗ 𝟙 (e.inverse.obj Y₂✝) ⊗ e.inverse.map f₃)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)
[PROOFSTEP]
rw [← id_tensor_comp, tensor_id_comp_id_tensor]
[GOAL]
case e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
      (𝟙 (e.inverse.obj Y₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
      (e.inverse.map f₁ ⊗
        NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
          (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
            NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
slice_lhs 1 2 => rw [tensor_id_comp_id_tensor]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
    (𝟙 (e.inverse.obj Y₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [tensor_id_comp_id_tensor]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
    (𝟙 (e.inverse.obj Y₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [tensor_id_comp_id_tensor]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
    (𝟙 (e.inverse.obj Y₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [tensor_id_comp_id_tensor]
[GOAL]
case e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
      (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
      (e.inverse.map f₁ ⊗
        NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
          (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
            NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
conv_rhs =>
  congr
  ·skip
  ·rw [← id_tensor_comp_tensor_id, id_tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
    (e.inverse.map f₁ ⊗
      NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
        (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
          NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
  congr
  ·skip
  ·rw [← id_tensor_comp_tensor_id, id_tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
    (e.inverse.map f₁ ⊗
      NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
        (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
          NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
  congr
  ·skip
  ·rw [← id_tensor_comp_tensor_id, id_tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
    (e.inverse.map f₁ ⊗
      NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
        (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
          NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
congr
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗
    NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
      (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
·skip
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)
[PROOFSTEP]
skip
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)
[PROOFSTEP]
skip
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)
[PROOFSTEP]
skip
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗
    NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
      (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
·rw [← id_tensor_comp_tensor_id, id_tensor_comp]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗
    NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
      (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [← id_tensor_comp_tensor_id, id_tensor_comp]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗
    NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
      (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [← id_tensor_comp_tensor_id, id_tensor_comp]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗
    NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
      (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [← id_tensor_comp_tensor_id, id_tensor_comp]
[GOAL]
case e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
      (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
      ((𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
          (𝟙 (e.inverse.obj X₁✝) ⊗
            (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
              NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))) ≫
        (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
case e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
      (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
      (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗
            (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
              NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) ≫
          (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
[PROOFSTEP]
slice_rhs 1 2 =>
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
    (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝))
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗
    (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)))
[PROOFSTEP]
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
    (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝))
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗
    (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)))
[PROOFSTEP]
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)) ≫
    (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝))
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗
    (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)))
[PROOFSTEP]
rw [← id_tensor_comp, Iso.hom_inv_id_app]
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗ 𝟙 ((𝟭 C).obj (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝))
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗
    (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)))
[PROOFSTEP]
dsimp
[GOAL]
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗ 𝟙 (e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗
    (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)))
[PROOFSTEP]
rw [tensor_id]
[GOAL]
case e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
      (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (𝟙 (e.inverse.obj X₁✝ ⊗ e.inverse.obj X₂✝ ⊗ e.inverse.obj X₃✝) ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗
          (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
            NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))) ≫
      (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
[PROOFSTEP]
simp only [Category.id_comp, Category.assoc]
[GOAL]
case e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
      (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (𝟙 (e.inverse.obj X₁✝) ⊗
        (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
          NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) ≫
      (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
[PROOFSTEP]
conv_rhs => rw [id_tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗
      (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
        NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) ≫
    (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
[PROOFSTEP]
rw [id_tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗
      (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
        NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) ≫
    (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
[PROOFSTEP]
rw [id_tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗
      (e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
        NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) ≫
    (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
[PROOFSTEP]
rw [id_tensor_comp]
[GOAL]
case e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
      (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    ((𝟙 (e.inverse.obj X₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
        (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))) ≫
      (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
[PROOFSTEP]
slice_rhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) ≫
    (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃
[PROOFSTEP]
rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) ≫
    (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃
[PROOFSTEP]
rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) ≫
    (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj X₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃
[PROOFSTEP]
rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
[GOAL]
case e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
⊢ (e.inverse.map f₁ ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
      (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) =
    (𝟙 (e.inverse.obj X₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
      (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)) ≫
        (𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
[PROOFSTEP]
slice_rhs 1 2 => rw [id_tensor_comp_tensor_id]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
    (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [id_tensor_comp_tensor_id]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
    (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [id_tensor_comp_tensor_id]
[GOAL]
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| (𝟙 (e.inverse.obj X₁✝) ⊗ e.inverse.map f₂ ⊗ e.inverse.map f₃) ≫
    (e.inverse.map f₁ ⊗ 𝟙 (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X₁✝ X₂✝ X₃✝ Y₁✝ Y₂✝ Y₃✝ : D
f₁ : X₁✝ ⟶ Y₁✝
f₂ : X₂✝ ⟶ Y₂✝
f₃ : X₃✝ ⟶ Y₃✝
| 𝟙 (e.inverse.obj Y₁✝) ⊗ NatTrans.app (Equivalence.unit e) (e.inverse.obj Y₂✝ ⊗ e.inverse.obj Y₃✝)
[PROOFSTEP]
rw [id_tensor_comp_tensor_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ (fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g)) (𝟙 (e.functor.obj (𝟙_ C))) f ≫
      ((fun X =>
            e.functor.mapIso (((e.unitIso.app (𝟙_ C)).symm ⊗ Iso.refl (e.inverse.obj X)) ≪≫ λ_ (e.inverse.obj X)) ≪≫
              e.counitIso.app X)
          Y✝).hom =
    ((fun X =>
            e.functor.mapIso (((e.unitIso.app (𝟙_ C)).symm ⊗ Iso.refl (e.inverse.obj X)) ≪≫ λ_ (e.inverse.obj X)) ≪≫
              e.counitIso.app X)
          X✝).hom ≫
      f
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ e.functor.map (e.inverse.map (𝟙 (e.functor.obj (𝟙_ C))) ⊗ e.inverse.map f) ≫
      e.functor.map ((NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y✝)) ≫ (λ_ (e.inverse.obj Y✝)).hom) ≫
        NatTrans.app e.counitIso.hom Y✝ =
    (e.functor.map ((NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj X✝)) ≫ (λ_ (e.inverse.obj X✝)).hom) ≫
        NatTrans.app e.counitIso.hom X✝) ≫
      f
[PROOFSTEP]
simp only [Functor.map_comp, Functor.map_id, Category.assoc]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ e.functor.map (𝟙 (e.inverse.obj (e.functor.obj (𝟙_ C))) ⊗ e.inverse.map f) ≫
      e.functor.map (NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y✝)) ≫
        e.functor.map (λ_ (e.inverse.obj Y✝)).hom ≫ NatTrans.app e.counitIso.hom Y✝ =
    e.functor.map (NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj X✝)) ≫
      e.functor.map (λ_ (e.inverse.obj X✝)).hom ≫ NatTrans.app e.counitIso.hom X✝ ≫ f
[PROOFSTEP]
erw [← e.counitIso.hom.naturality]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ e.functor.map (𝟙 (e.inverse.obj (e.functor.obj (𝟙_ C))) ⊗ e.inverse.map f) ≫
      e.functor.map (NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y✝)) ≫
        e.functor.map (λ_ (e.inverse.obj Y✝)).hom ≫ NatTrans.app e.counitIso.hom Y✝ =
    e.functor.map (NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj X✝)) ≫
      e.functor.map (λ_ (e.inverse.obj X✝)).hom ≫ (e.inverse ⋙ e.functor).map f ≫ NatTrans.app e.counitIso.hom Y✝
[PROOFSTEP]
simp only [Functor.comp_map, ← e.functor.map_comp_assoc]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ e.functor.map
        ((𝟙 (e.inverse.obj (e.functor.obj (𝟙_ C))) ⊗ e.inverse.map f) ≫
          (NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y✝)) ≫ (λ_ (e.inverse.obj Y✝)).hom) ≫
      NatTrans.app e.counitIso.hom Y✝ =
    e.functor.map
        ((NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj X✝)) ≫ (λ_ (e.inverse.obj X✝)).hom ≫ e.inverse.map f) ≫
      NatTrans.app e.counitIso.hom Y✝
[PROOFSTEP]
congr 2
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ (𝟙 (e.inverse.obj (e.functor.obj (𝟙_ C))) ⊗ e.inverse.map f) ≫
      (NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y✝)) ≫ (λ_ (e.inverse.obj Y✝)).hom =
    (NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj X✝)) ≫ (λ_ (e.inverse.obj X✝)).hom ≫ e.inverse.map f
[PROOFSTEP]
rw [id_tensor_comp_tensor_id_assoc, ← tensor_id_comp_id_tensor_assoc, leftUnitor_naturality]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ (fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g)) f (𝟙 (e.functor.obj (𝟙_ C))) ≫
      ((fun X =>
            e.functor.mapIso ((Iso.refl (e.inverse.obj X) ⊗ (e.unitIso.app (𝟙_ C)).symm) ≪≫ ρ_ (e.inverse.obj X)) ≪≫
              e.counitIso.app X)
          Y✝).hom =
    ((fun X =>
            e.functor.mapIso ((Iso.refl (e.inverse.obj X) ⊗ (e.unitIso.app (𝟙_ C)).symm) ≪≫ ρ_ (e.inverse.obj X)) ≪≫
              e.counitIso.app X)
          X✝).hom ≫
      f
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ e.functor.map (e.inverse.map f ⊗ e.inverse.map (𝟙 (e.functor.obj (𝟙_ C)))) ≫
      e.functor.map ((𝟙 (e.inverse.obj Y✝) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫ (ρ_ (e.inverse.obj Y✝)).hom) ≫
        NatTrans.app e.counitIso.hom Y✝ =
    (e.functor.map ((𝟙 (e.inverse.obj X✝) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫ (ρ_ (e.inverse.obj X✝)).hom) ≫
        NatTrans.app e.counitIso.hom X✝) ≫
      f
[PROOFSTEP]
simp only [Functor.map_comp, Functor.map_id, Category.assoc]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ e.functor.map (e.inverse.map f ⊗ 𝟙 (e.inverse.obj (e.functor.obj (𝟙_ C)))) ≫
      e.functor.map (𝟙 (e.inverse.obj Y✝) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫
        e.functor.map (ρ_ (e.inverse.obj Y✝)).hom ≫ NatTrans.app e.counitIso.hom Y✝ =
    e.functor.map (𝟙 (e.inverse.obj X✝) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫
      e.functor.map (ρ_ (e.inverse.obj X✝)).hom ≫ NatTrans.app e.counitIso.hom X✝ ≫ f
[PROOFSTEP]
erw [← e.counitIso.hom.naturality]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ e.functor.map (e.inverse.map f ⊗ 𝟙 (e.inverse.obj (e.functor.obj (𝟙_ C)))) ≫
      e.functor.map (𝟙 (e.inverse.obj Y✝) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫
        e.functor.map (ρ_ (e.inverse.obj Y✝)).hom ≫ NatTrans.app e.counitIso.hom Y✝ =
    e.functor.map (𝟙 (e.inverse.obj X✝) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫
      e.functor.map (ρ_ (e.inverse.obj X✝)).hom ≫ (e.inverse ⋙ e.functor).map f ≫ NatTrans.app e.counitIso.hom Y✝
[PROOFSTEP]
simp only [Functor.comp_map, ← e.functor.map_comp_assoc]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ e.functor.map
        ((e.inverse.map f ⊗ 𝟙 (e.inverse.obj (e.functor.obj (𝟙_ C)))) ≫
          (𝟙 (e.inverse.obj Y✝) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫ (ρ_ (e.inverse.obj Y✝)).hom) ≫
      NatTrans.app e.counitIso.hom Y✝ =
    e.functor.map
        ((𝟙 (e.inverse.obj X✝) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫ (ρ_ (e.inverse.obj X✝)).hom ≫ e.inverse.map f) ≫
      NatTrans.app e.counitIso.hom Y✝
[PROOFSTEP]
congr 2
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ : D
f : X✝ ⟶ Y✝
⊢ (e.inverse.map f ⊗ 𝟙 (e.inverse.obj (e.functor.obj (𝟙_ C)))) ≫
      (𝟙 (e.inverse.obj Y✝) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫ (ρ_ (e.inverse.obj Y✝)).hom =
    (𝟙 (e.inverse.obj X✝) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫ (ρ_ (e.inverse.obj X✝)).hom ≫ e.inverse.map f
[PROOFSTEP]
erw [tensor_id_comp_id_tensor_assoc, ← id_tensor_comp_tensor_id_assoc, rightUnitor_naturality]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ (fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g))
        ((fun X Y Z =>
              e.functor.mapIso
                (((e.unitIso.app (e.inverse.obj X ⊗ e.inverse.obj Y)).symm ⊗ Iso.refl (e.inverse.obj Z)) ≪≫
                  α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z) ≪≫
                    (Iso.refl (e.inverse.obj X) ⊗ e.unitIso.app (e.inverse.obj Y ⊗ e.inverse.obj Z))))
            W X Y).hom
        (𝟙 Z) ≫
      ((fun X Y Z =>
              e.functor.mapIso
                (((e.unitIso.app (e.inverse.obj X ⊗ e.inverse.obj Y)).symm ⊗ Iso.refl (e.inverse.obj Z)) ≪≫
                  α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z) ≪≫
                    (Iso.refl (e.inverse.obj X) ⊗ e.unitIso.app (e.inverse.obj Y ⊗ e.inverse.obj Z))))
            W ((fun X Y => e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) X Y) Z).hom ≫
        (fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g)) (𝟙 W)
          ((fun X Y Z =>
                e.functor.mapIso
                  (((e.unitIso.app (e.inverse.obj X ⊗ e.inverse.obj Y)).symm ⊗ Iso.refl (e.inverse.obj Z)) ≪≫
                    α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z) ≪≫
                      (Iso.refl (e.inverse.obj X) ⊗ e.unitIso.app (e.inverse.obj Y ⊗ e.inverse.obj Z))))
              X Y Z).hom =
    ((fun X Y Z =>
            e.functor.mapIso
              (((e.unitIso.app (e.inverse.obj X ⊗ e.inverse.obj Y)).symm ⊗ Iso.refl (e.inverse.obj Z)) ≪≫
                α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z) ≪≫
                  (Iso.refl (e.inverse.obj X) ⊗ e.unitIso.app (e.inverse.obj Y ⊗ e.inverse.obj Z))))
          ((fun X Y => e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) W X) Y Z).hom ≫
      ((fun X Y Z =>
            e.functor.mapIso
              (((e.unitIso.app (e.inverse.obj X ⊗ e.inverse.obj Y)).symm ⊗ Iso.refl (e.inverse.obj Z)) ≪≫
                α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z) ≪≫
                  (Iso.refl (e.inverse.obj X) ⊗ e.unitIso.app (e.inverse.obj Y ⊗ e.inverse.obj Z))))
          W X ((fun X Y => e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) Y Z)).hom
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ e.functor.map
        (e.inverse.map
            (e.functor.map
              ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ≫
                (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ≫
                  (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)))) ⊗
          e.inverse.map (𝟙 Z)) ≫
      e.functor.map
          ((NatTrans.app e.unitIso.inv
                (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
              𝟙 (e.inverse.obj Z)) ≫
            (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                  (e.inverse.obj Z)).hom ≫
              (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app e.unitIso.hom
                  (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z))) ≫
        e.functor.map
          (e.inverse.map (𝟙 W) ⊗
            e.inverse.map
              (e.functor.map
                ((NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
                  (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
                    (𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z))))) =
    e.functor.map
        ((NatTrans.app e.unitIso.inv
              (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X)) ⊗ e.inverse.obj Y) ⊗
            𝟙 (e.inverse.obj Z)) ≫
          (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y)
                (e.inverse.obj Z)).hom ≫
            (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
              NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z))) ≫
      e.functor.map
        ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
            𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj X)
                (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
              NatTrans.app e.unitIso.hom
                (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))))
[PROOFSTEP]
simp only [Iso.hom_inv_id_app_assoc, comp_tensor_id, assoc, Equivalence.inv_fun_map, Functor.map_comp, id_tensor_comp,
  e.inverse.map_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ e.functor.map
        (NatTrans.app (Equivalence.unitInv e)
            (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X)) ⊗ e.inverse.obj Y) ⊗
          𝟙 (e.inverse.obj Z)) ≫
      e.functor.map
          ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗
            𝟙 (e.inverse.obj Z)) ≫
        e.functor.map ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
          e.functor.map
              ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗
                𝟙 (e.inverse.obj Z)) ≫
            e.functor.map
                (NatTrans.app (Equivalence.unit e)
                    (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
                  𝟙 (e.inverse.obj Z)) ≫
              e.functor.map
                  (NatTrans.app e.unitIso.inv
                      (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
                    𝟙 (e.inverse.obj Z)) ≫
                e.functor.map
                    (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                        (e.inverse.obj Z)).hom ≫
                  e.functor.map
                      (𝟙 (e.inverse.obj W) ⊗
                        NatTrans.app e.unitIso.hom
                          (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
                    e.functor.map
                        (𝟙 (e.inverse.obj W) ⊗
                          NatTrans.app (Equivalence.unitInv e)
                            (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
                      e.functor.map
                          (𝟙 (e.inverse.obj W) ⊗
                            NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
                        e.functor.map
                            (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
                          e.functor.map
                              (𝟙 (e.inverse.obj W) ⊗
                                𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
                            e.functor.map
                              (𝟙 (e.inverse.obj W) ⊗
                                NatTrans.app (Equivalence.unit e)
                                  (e.inverse.obj X ⊗
                                    e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    e.functor.map
        (NatTrans.app e.unitIso.inv
            (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X)) ⊗ e.inverse.obj Y) ⊗
          𝟙 (e.inverse.obj Z)) ≫
      e.functor.map
          (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y)
              (e.inverse.obj Z)).hom ≫
        e.functor.map
            (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
              NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
          e.functor.map
              (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
                𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) ≫
            e.functor.map
                (α_ (e.inverse.obj W) (e.inverse.obj X)
                    (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom ≫
              e.functor.map
                (𝟙 (e.inverse.obj W) ⊗
                  NatTrans.app e.unitIso.hom
                    (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
simp only [← e.functor.map_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ e.functor.map
      ((NatTrans.app (Equivalence.unitInv e)
            (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X)) ⊗ e.inverse.obj Y) ⊗
          𝟙 (e.inverse.obj Z)) ≫
        ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
            ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗
                𝟙 (e.inverse.obj Z)) ≫
              (NatTrans.app (Equivalence.unit e)
                    (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
                  𝟙 (e.inverse.obj Z)) ≫
                (NatTrans.app e.unitIso.inv
                      (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
                    𝟙 (e.inverse.obj Z)) ≫
                  (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                        (e.inverse.obj Z)).hom ≫
                    (𝟙 (e.inverse.obj W) ⊗
                        NatTrans.app e.unitIso.hom
                          (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
                      (𝟙 (e.inverse.obj W) ⊗
                          NatTrans.app (Equivalence.unitInv e)
                            (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
                        (𝟙 (e.inverse.obj W) ⊗
                            NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
                          (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
                            (𝟙 (e.inverse.obj W) ⊗
                                𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
                              (𝟙 (e.inverse.obj W) ⊗
                                NatTrans.app (Equivalence.unit e)
                                  (e.inverse.obj X ⊗
                                    e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))) =
    e.functor.map
      ((NatTrans.app e.unitIso.inv
            (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X)) ⊗ e.inverse.obj Y) ⊗
          𝟙 (e.inverse.obj Z)) ≫
        (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y)
              (e.inverse.obj Z)).hom ≫
          (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
              NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
            (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
                𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) ≫
              (α_ (e.inverse.obj W) (e.inverse.obj X)
                    (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom ≫
                (𝟙 (e.inverse.obj W) ⊗
                  NatTrans.app e.unitIso.hom
                    (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))))
[PROOFSTEP]
congr 2
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (NatTrans.app (Equivalence.unit e)
                (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
              𝟙 (e.inverse.obj Z)) ≫
            (NatTrans.app e.unitIso.inv
                  (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
                𝟙 (e.inverse.obj Z)) ≫
              (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                    (e.inverse.obj Z)).hom ≫
                (𝟙 (e.inverse.obj W) ⊗
                    NatTrans.app e.unitIso.hom
                      (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
                  (𝟙 (e.inverse.obj W) ⊗
                      NatTrans.app (Equivalence.unitInv e)
                        (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
                    (𝟙 (e.inverse.obj W) ⊗
                        NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
                      (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
                        (𝟙 (e.inverse.obj W) ⊗
                            𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
                          (𝟙 (e.inverse.obj W) ⊗
                            NatTrans.app (Equivalence.unit e)
                              (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
      (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
          NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
        (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
            𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj X)
                (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
              NatTrans.app e.unitIso.hom
                (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
slice_lhs 4 5 =>
  rw [← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app (Equivalence.unit e)
        (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
      𝟙 (e.inverse.obj Z)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
      𝟙 (e.inverse.obj Z))
case a.a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
case a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unitInv e)
      (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
[PROOFSTEP]
  rw [← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app (Equivalence.unit e)
        (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
      𝟙 (e.inverse.obj Z)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
      𝟙 (e.inverse.obj Z))
case a.a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
case a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unitInv e)
      (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
[PROOFSTEP]
  rw [← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app (Equivalence.unit e)
        (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
      𝟙 (e.inverse.obj Z)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
      𝟙 (e.inverse.obj Z))
case a.a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
case a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unitInv e)
      (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
[PROOFSTEP]
rw [← comp_tensor_id, Iso.hom_inv_id_app]
[GOAL]
case a.a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 ((𝟭 C).obj (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))) ⊗
    𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
case a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unitInv e)
      (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
[PROOFSTEP]
dsimp
[GOAL]
case a.a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
case a.a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unitInv e)
      (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
[PROOFSTEP]
rw [tensor_id]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          ((((((𝟙
                          ((e.inverse.obj W ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) ⊗
                            e.inverse.obj Z) ≫
                        (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                            (e.inverse.obj Z)).hom) ≫
                      (𝟙 (e.inverse.obj W) ⊗
                        NatTrans.app e.unitIso.hom
                          (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z))) ≫
                    (𝟙 (e.inverse.obj W) ⊗
                      NatTrans.app (Equivalence.unitInv e)
                        (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z))) ≫
                  (𝟙 (e.inverse.obj W) ⊗
                    NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z))) ≫
                (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom)) ≫
              (𝟙 (e.inverse.obj W) ⊗
                𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z))) ≫
            (𝟙 (e.inverse.obj W) ⊗
              NatTrans.app (Equivalence.unit e)
                (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
      (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
          NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
        (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
            𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj X)
                (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
              NatTrans.app e.unitIso.hom
                (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
simp only [Category.id_comp, Category.assoc]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                (e.inverse.obj Z)).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app e.unitIso.hom
                  (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
              (𝟙 (e.inverse.obj W) ⊗
                  NatTrans.app (Equivalence.unitInv e)
                    (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
                (𝟙 (e.inverse.obj W) ⊗
                    NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
                  (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
                    (𝟙 (e.inverse.obj W) ⊗
                        𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
                      (𝟙 (e.inverse.obj W) ⊗
                        NatTrans.app (Equivalence.unit e)
                          (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
      (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
          NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
        (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
            𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj X)
                (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
              NatTrans.app e.unitIso.hom
                (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
slice_lhs 5 6 =>
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗
      NatTrans.app e.unitIso.hom
        (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
    (𝟙 (e.inverse.obj W) ⊗
      NatTrans.app (Equivalence.unitInv e)
        (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z))
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
[PROOFSTEP]
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗
      NatTrans.app e.unitIso.hom
        (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
    (𝟙 (e.inverse.obj W) ⊗
      NatTrans.app (Equivalence.unitInv e)
        (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z))
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
[PROOFSTEP]
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗
      NatTrans.app e.unitIso.hom
        (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)) ≫
    (𝟙 (e.inverse.obj W) ⊗
      NatTrans.app (Equivalence.unitInv e)
        (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z))
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
[PROOFSTEP]
rw [← id_tensor_comp, Iso.hom_inv_id_app]
[GOAL]
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    𝟙 ((𝟭 C).obj (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z))
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
[PROOFSTEP]
dsimp
[GOAL]
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z)
case a.a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
[PROOFSTEP]
rw [tensor_id]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                (e.inverse.obj Z)).hom ≫
            (((𝟙
                      (e.inverse.obj W ⊗
                        e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ e.inverse.obj Z) ≫
                    (𝟙 (e.inverse.obj W) ⊗
                      NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z))) ≫
                  (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom)) ≫
                (𝟙 (e.inverse.obj W) ⊗
                  𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z))) ≫
              (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app (Equivalence.unit e)
                  (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
      (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
          NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
        (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
            𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj X)
                (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
              NatTrans.app e.unitIso.hom
                (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
simp only [Category.id_comp, Category.assoc]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                (e.inverse.obj Z)).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
              (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
                (𝟙 (e.inverse.obj W) ⊗
                    𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
                  (𝟙 (e.inverse.obj W) ⊗
                    NatTrans.app (Equivalence.unit e)
                      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
      (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
          NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
        (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
            𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj X)
                (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
              NatTrans.app e.unitIso.hom
                (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
slice_rhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
      NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
      𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom
[PROOFSTEP]
rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
      NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
      𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom
[PROOFSTEP]
rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) ⊗
      NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗
      𝟙 (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom
[PROOFSTEP]
rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                (e.inverse.obj Z)).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
              (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
                (𝟙 (e.inverse.obj W) ⊗
                    𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
                  (𝟙 (e.inverse.obj W) ⊗
                    NatTrans.app (Equivalence.unit e)
                      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
      (((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
            (𝟙 (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z))) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj X)
              (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom) ≫
        (𝟙 (e.inverse.obj W) ⊗
          NatTrans.app e.unitIso.hom
            (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
slice_rhs 1 2 => rw [← tensor_id, ← associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y ⊗ e.inverse.obj Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
rw [← tensor_id, ← associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y ⊗ e.inverse.obj Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
rw [← tensor_id, ← associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj (e.functor.obj (e.inverse.obj W ⊗ e.inverse.obj X))) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
    (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y ⊗ e.inverse.obj Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
rw [← tensor_id, ← associator_naturality]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                (e.inverse.obj Z)).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
              (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
                (𝟙 (e.inverse.obj W) ⊗
                    𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
                  (𝟙 (e.inverse.obj W) ⊗
                    NatTrans.app (Equivalence.unit e)
                      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (((((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
            (α_ (e.inverse.obj W ⊗ e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
          (𝟙 (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z))) ≫
        (α_ (e.inverse.obj W) (e.inverse.obj X)
            (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom) ≫
      (𝟙 (e.inverse.obj W) ⊗
        NatTrans.app e.unitIso.hom
          (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
slice_rhs 3 4 => rw [← tensor_id, associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
    (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W ⊗ e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
[PROOFSTEP]
rw [← tensor_id, associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
    (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W ⊗ e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
[PROOFSTEP]
rw [← tensor_id, associator_naturality]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
    (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W ⊗ e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
[PROOFSTEP]
rw [← tensor_id, associator_naturality]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                (e.inverse.obj Z)).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
              (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
                (𝟙 (e.inverse.obj W) ⊗
                    𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
                  (𝟙 (e.inverse.obj W) ⊗
                    NatTrans.app (Equivalence.unit e)
                      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      (α_ (e.inverse.obj W ⊗ e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
        ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y ⊗ e.inverse.obj Z)).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
              𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z))) ≫
          (𝟙 (e.inverse.obj W) ⊗
            NatTrans.app e.unitIso.hom
              (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
slice_rhs 2 3 => rw [← pentagon]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W ⊗ e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
    (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y ⊗ e.inverse.obj Z)).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
[PROOFSTEP]
rw [← pentagon]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W ⊗ e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
    (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y ⊗ e.inverse.obj Z)).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
[PROOFSTEP]
rw [← pentagon]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (α_ (e.inverse.obj W ⊗ e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
    (α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y ⊗ e.inverse.obj Z)).hom
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
[PROOFSTEP]
rw [← pentagon]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                (e.inverse.obj Z)).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
              (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
                (𝟙 (e.inverse.obj W) ⊗
                    𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
                  (𝟙 (e.inverse.obj W) ⊗
                    NatTrans.app (Equivalence.unit e)
                      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
            (α_ (e.inverse.obj W) (e.inverse.obj X ⊗ e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
              (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom)) ≫
          (𝟙 (e.inverse.obj W) ⊗
            𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z))) ≫
        (𝟙 (e.inverse.obj W) ⊗
          NatTrans.app e.unitIso.hom
            (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y)))
                (e.inverse.obj Z)).hom ≫
            (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
              (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
                (𝟙 (e.inverse.obj W) ⊗
                    𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
                  (𝟙 (e.inverse.obj W) ⊗
                    NatTrans.app (Equivalence.unit e)
                      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    ((NatTrans.app e.unitIso.inv (e.inverse.obj W ⊗ e.inverse.obj X) ⊗ 𝟙 (e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      ((α_ (e.inverse.obj W) (e.inverse.obj X) (e.inverse.obj Y)).hom ⊗ 𝟙 (e.inverse.obj Z)) ≫
        (α_ (e.inverse.obj W) (e.inverse.obj X ⊗ e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
          (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
            (𝟙 (e.inverse.obj W) ⊗
                𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
              (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app e.unitIso.hom
                  (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
congr 2
[GOAL]
case e_a.e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom ≫
        (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
            (𝟙 (e.inverse.obj W) ⊗
                𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
              (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app (Equivalence.unit e)
                  (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (α_ (e.inverse.obj W) (e.inverse.obj X ⊗ e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
      (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
        (𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
          (𝟙 (e.inverse.obj W) ⊗
            NatTrans.app e.unitIso.hom
              (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
slice_lhs 1 2 => rw [associator_naturality]
[GOAL]
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
    (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
    (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| ((𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)) ≫
    (α_ (e.inverse.obj W) (e.inverse.obj (e.functor.obj (e.inverse.obj X ⊗ e.inverse.obj Y))) (e.inverse.obj Z)).hom
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
rw [associator_naturality]
[GOAL]
case e_a.e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ (((((α_ (e.inverse.obj W) (e.inverse.obj X ⊗ e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
              (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z))) ≫
            (𝟙 (e.inverse.obj W) ⊗
              NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z))) ≫
          (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom)) ≫
        (𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z))) ≫
      (𝟙 (e.inverse.obj W) ⊗
        NatTrans.app (Equivalence.unit e)
          (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (α_ (e.inverse.obj W) (e.inverse.obj X ⊗ e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
      (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
        (𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
          (𝟙 (e.inverse.obj W) ⊗
            NatTrans.app e.unitIso.hom
              (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
simp only [Category.assoc]
[GOAL]
case e_a.e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ (α_ (e.inverse.obj W) (e.inverse.obj X ⊗ e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
      (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
        (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
          (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
            (𝟙 (e.inverse.obj W) ⊗
                𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
              (𝟙 (e.inverse.obj W) ⊗
                NatTrans.app (Equivalence.unit e)
                  (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (α_ (e.inverse.obj W) (e.inverse.obj X ⊗ e.inverse.obj Y) (e.inverse.obj Z)).hom ≫
      (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
        (𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
          (𝟙 (e.inverse.obj W) ⊗
            NatTrans.app e.unitIso.hom
              (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
congr 1
[GOAL]
case e_a.e_a.e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
      (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
        (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
          (𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
            (𝟙 (e.inverse.obj W) ⊗
              NatTrans.app (Equivalence.unit e)
                (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
      (𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
        (𝟙 (e.inverse.obj W) ⊗
          NatTrans.app e.unitIso.hom
            (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
slice_lhs 1 2 =>
  rw [← id_tensor_comp, ← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id, tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
    (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
  rw [← id_tensor_comp, ← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id, tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
    (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
  rw [← id_tensor_comp, ← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id, tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)) ≫
    (𝟙 (e.inverse.obj W) ⊗ NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
rw [← id_tensor_comp, ← comp_tensor_id, Iso.hom_inv_id_app]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 ((𝟭 C).obj (e.inverse.obj X ⊗ e.inverse.obj Y)) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
dsimp
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ 𝟙 (e.inverse.obj Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
| 𝟙 (e.inverse.obj W) ⊗
    NatTrans.app (Equivalence.unit e)
      (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))
[PROOFSTEP]
rw [tensor_id, tensor_id]
[GOAL]
case e_a.e_a.e_a.e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
W X Y Z : D
⊢ ((𝟙 (e.inverse.obj W ⊗ (e.inverse.obj X ⊗ e.inverse.obj Y) ⊗ e.inverse.obj Z) ≫
          (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom)) ≫
        (𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z))) ≫
      (𝟙 (e.inverse.obj W) ⊗
        NatTrans.app (Equivalence.unit e)
          (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z)))) =
    (𝟙 (e.inverse.obj W) ⊗ (α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z)).hom) ≫
      (𝟙 (e.inverse.obj W) ⊗ 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj Y ⊗ e.inverse.obj Z)) ≫
        (𝟙 (e.inverse.obj W) ⊗
          NatTrans.app e.unitIso.hom
            (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (e.inverse.obj Y ⊗ e.inverse.obj Z))))
[PROOFSTEP]
simp only [Category.id_comp, Category.assoc]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
⊢ ((fun X Y Z =>
            e.functor.mapIso
              (((e.unitIso.app (e.inverse.obj X ⊗ e.inverse.obj Y)).symm ⊗ Iso.refl (e.inverse.obj Z)) ≪≫
                α_ (e.inverse.obj X) (e.inverse.obj Y) (e.inverse.obj Z) ≪≫
                  (Iso.refl (e.inverse.obj X) ⊗ e.unitIso.app (e.inverse.obj Y ⊗ e.inverse.obj Z))))
          X (e.functor.obj (𝟙_ C)) Y).hom ≫
      (fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g)) (𝟙 X)
        ((fun X =>
              e.functor.mapIso (((e.unitIso.app (𝟙_ C)).symm ⊗ Iso.refl (e.inverse.obj X)) ≪≫ λ_ (e.inverse.obj X)) ≪≫
                e.counitIso.app X)
            Y).hom =
    (fun {X₁ Y₁ X₂ Y₂} f g => e.functor.map (e.inverse.map f ⊗ e.inverse.map g))
      ((fun X =>
            e.functor.mapIso ((Iso.refl (e.inverse.obj X) ⊗ (e.unitIso.app (𝟙_ C)).symm) ≪≫ ρ_ (e.inverse.obj X)) ≪≫
              e.counitIso.app X)
          X).hom
      (𝟙 Y)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
⊢ e.functor.map
        ((NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (𝟙_ C))) ⊗ 𝟙 (e.inverse.obj Y)) ≫
          (α_ (e.inverse.obj X) (e.inverse.obj (e.functor.obj (𝟙_ C))) (e.inverse.obj Y)).hom ≫
            (𝟙 (e.inverse.obj X) ⊗
              NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y))) ≫
      e.functor.map
        (e.inverse.map (𝟙 X) ⊗
          e.inverse.map
            (e.functor.map ((NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y)) ≫ (λ_ (e.inverse.obj Y)).hom) ≫
              NatTrans.app e.counitIso.hom Y)) =
    e.functor.map
      (e.inverse.map
          (e.functor.map ((𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫ (ρ_ (e.inverse.obj X)).hom) ≫
            NatTrans.app e.counitIso.hom X) ⊗
        e.inverse.map (𝟙 Y))
[PROOFSTEP]
simp only [Iso.hom_inv_id_app_assoc, comp_tensor_id, Equivalence.unit_inverse_comp, assoc, Equivalence.inv_fun_map,
  comp_id, Functor.map_comp, id_tensor_comp, e.inverse.map_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
⊢ e.functor.map
        (NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (𝟙_ C))) ⊗ 𝟙 (e.inverse.obj Y)) ≫
      e.functor.map (α_ (e.inverse.obj X) (e.inverse.obj (e.functor.obj (𝟙_ C))) (e.inverse.obj Y)).hom ≫
        e.functor.map
            (𝟙 (e.inverse.obj X) ⊗
              NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y)) ≫
          e.functor.map
              (𝟙 (e.inverse.obj X) ⊗
                NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y)) ≫
            e.functor.map (𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y)) ≫
              e.functor.map (𝟙 (e.inverse.obj X) ⊗ (λ_ (e.inverse.obj Y)).hom) =
    e.functor.map
        (NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (𝟙_ C))) ⊗
          𝟙 (e.inverse.obj Y)) ≫
      e.functor.map ((𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ⊗ 𝟙 (e.inverse.obj Y)) ≫
        e.functor.map ((ρ_ (e.inverse.obj X)).hom ⊗ 𝟙 (e.inverse.obj Y))
[PROOFSTEP]
simp only [← e.functor.map_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
⊢ e.functor.map
      ((NatTrans.app e.unitIso.inv (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (𝟙_ C))) ⊗ 𝟙 (e.inverse.obj Y)) ≫
        (α_ (e.inverse.obj X) (e.inverse.obj (e.functor.obj (𝟙_ C))) (e.inverse.obj Y)).hom ≫
          (𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y)) ≫
            (𝟙 (e.inverse.obj X) ⊗
                NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y)) ≫
              (𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y)) ≫
                (𝟙 (e.inverse.obj X) ⊗ (λ_ (e.inverse.obj Y)).hom)) =
    e.functor.map
      ((NatTrans.app (Equivalence.unitInv e) (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (𝟙_ C))) ⊗
          𝟙 (e.inverse.obj Y)) ≫
        ((𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ⊗ 𝟙 (e.inverse.obj Y)) ≫
          ((ρ_ (e.inverse.obj X)).hom ⊗ 𝟙 (e.inverse.obj Y)))
[PROOFSTEP]
congr 2
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
⊢ (α_ (e.inverse.obj X) (e.inverse.obj (e.functor.obj (𝟙_ C))) (e.inverse.obj Y)).hom ≫
      (𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y)) ≫
        (𝟙 (e.inverse.obj X) ⊗
            NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y)) ≫
          (𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y)) ≫
            (𝟙 (e.inverse.obj X) ⊗ (λ_ (e.inverse.obj Y)).hom) =
    ((𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ⊗ 𝟙 (e.inverse.obj Y)) ≫
      ((ρ_ (e.inverse.obj X)).hom ⊗ 𝟙 (e.inverse.obj Y))
[PROOFSTEP]
slice_lhs 2 3 =>
  rw [← id_tensor_comp]
  simp
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| (𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y)) ≫
    (𝟙 (e.inverse.obj X) ⊗
      NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| 𝟙 (e.inverse.obj X) ⊗ (λ_ (e.inverse.obj Y)).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| (α_ (e.inverse.obj X) (e.inverse.obj (e.functor.obj (𝟙_ C))) (e.inverse.obj Y)).hom
[PROOFSTEP]
  rw [← id_tensor_comp]
  simp
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| (𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y)) ≫
    (𝟙 (e.inverse.obj X) ⊗
      NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| 𝟙 (e.inverse.obj X) ⊗ (λ_ (e.inverse.obj Y)).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| (α_ (e.inverse.obj X) (e.inverse.obj (e.functor.obj (𝟙_ C))) (e.inverse.obj Y)).hom
[PROOFSTEP]
  rw [← id_tensor_comp]
  simp
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| (𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y)) ≫
    (𝟙 (e.inverse.obj X) ⊗
      NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| 𝟙 (e.inverse.obj X) ⊗ (λ_ (e.inverse.obj Y)).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| (α_ (e.inverse.obj X) (e.inverse.obj (e.functor.obj (𝟙_ C))) (e.inverse.obj Y)).hom
[PROOFSTEP]
rw [← id_tensor_comp]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| 𝟙 (e.inverse.obj X) ⊗
    NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y) ≫
      NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| 𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| 𝟙 (e.inverse.obj X) ⊗ (λ_ (e.inverse.obj Y)).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
| (α_ (e.inverse.obj X) (e.inverse.obj (e.functor.obj (𝟙_ C))) (e.inverse.obj Y)).hom
[PROOFSTEP]
simp
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : D
⊢ (α_ (e.inverse.obj X) (e.inverse.obj (e.functor.obj (𝟙_ C))) (e.inverse.obj Y)).hom ≫
      (𝟙 (e.inverse.obj X ⊗ e.inverse.obj (e.functor.obj (𝟙_ C)) ⊗ e.inverse.obj Y) ≫
          (𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj Y))) ≫
        (𝟙 (e.inverse.obj X) ⊗ (λ_ (e.inverse.obj Y)).hom) =
    ((𝟙 (e.inverse.obj X) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ⊗ 𝟙 (e.inverse.obj Y)) ≫
      ((ρ_ (e.inverse.obj X)).hom ⊗ 𝟙 (e.inverse.obj Y))
[PROOFSTEP]
rw [Category.id_comp, ← associator_naturality_assoc, triangle]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ X'✝ Y'✝ : C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
⊢ (e.functor.map f ⊗ e.functor.map g) ≫
      (fun X Y => e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y)) Y✝
        Y'✝ =
    (fun X Y => e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y)) X✝
        X'✝ ≫
      e.functor.map (f ⊗ g)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ X'✝ Y'✝ : C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
⊢ e.functor.map (e.inverse.map (e.functor.map f) ⊗ e.inverse.map (e.functor.map g)) ≫
      e.functor.map (NatTrans.app (Equivalence.unitInv e) Y✝ ⊗ NatTrans.app (Equivalence.unitInv e) Y'✝) =
    e.functor.map (NatTrans.app (Equivalence.unitInv e) X✝ ⊗ NatTrans.app (Equivalence.unitInv e) X'✝) ≫
      e.functor.map (f ⊗ g)
[PROOFSTEP]
rw [Equivalence.inv_fun_map, Equivalence.inv_fun_map, tensor_comp, Functor.map_comp, tensor_comp, ← e.functor.map_comp,
  ← e.functor.map_comp, ← e.functor.map_comp, assoc, assoc, ← tensor_comp, Iso.hom_inv_id_app, Iso.hom_inv_id_app, ←
  tensor_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ X'✝ Y'✝ : C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
⊢ e.functor.map
      ((NatTrans.app (Equivalence.unitInv e) X✝ ⊗ NatTrans.app (Equivalence.unitInv e) X'✝) ≫
        (f ≫ 𝟙 ((𝟭 C).obj Y✝) ⊗ g ≫ 𝟙 ((𝟭 C).obj Y'✝))) =
    e.functor.map ((NatTrans.app (Equivalence.unitInv e) X✝ ⊗ NatTrans.app (Equivalence.unitInv e) X'✝) ≫ (f ⊗ g))
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X✝ Y✝ X'✝ Y'✝ : C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
⊢ e.functor.map
      ((NatTrans.app (Equivalence.unitInv e) X✝ ⊗ NatTrans.app (Equivalence.unitInv e) X'✝) ≫ (f ≫ 𝟙 Y✝ ⊗ g ≫ 𝟙 Y'✝)) =
    e.functor.map ((NatTrans.app (Equivalence.unitInv e) X✝ ⊗ NatTrans.app (Equivalence.unitInv e) X'✝) ≫ (f ⊗ g))
[PROOFSTEP]
rw [comp_id, comp_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ ((fun X Y => e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y)) X Y ⊗
        𝟙 (e.functor.obj Z)) ≫
      (fun X Y => e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y))
          (X ⊗ Y) Z ≫
        e.functor.map (α_ X Y Z).hom =
    (α_ (e.functor.obj X) (e.functor.obj Y) (e.functor.obj Z)).hom ≫
      (𝟙 (e.functor.obj X) ⊗
          (fun X Y => e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y)) Y
            Z) ≫
        (fun X Y => e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y)) X
          (Y ⊗ Z)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ e.functor.map
        (e.inverse.map
            (e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y)) ⊗
          e.inverse.map (𝟙 (e.functor.obj Z))) ≫
      e.functor.map (NatTrans.app (Equivalence.unitInv e) (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
        e.functor.map (α_ X Y Z).hom =
    e.functor.map
        ((NatTrans.app e.unitIso.inv (e.inverse.obj (e.functor.obj X) ⊗ e.inverse.obj (e.functor.obj Y)) ⊗
            𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
          (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y))
                (e.inverse.obj (e.functor.obj Z))).hom ≫
            (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
              NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z)))) ≫
      e.functor.map
          (e.inverse.map (𝟙 (e.functor.obj X)) ⊗
            e.inverse.map
              (e.functor.map (NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z))) ≫
        e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
[PROOFSTEP]
rw [Equivalence.inv_fun_map, Equivalence.inv_fun_map, Functor.map_comp, Functor.map_comp, assoc, assoc,
  e.inverse.map_id, e.inverse.map_id, comp_tensor_id, id_tensor_comp, Functor.map_comp, assoc, id_tensor_comp,
  comp_tensor_id, ← e.functor.map_comp, ← e.functor.map_comp, ← e.functor.map_comp, ← e.functor.map_comp, ←
  e.functor.map_comp, ← e.functor.map_comp, ← e.functor.map_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ e.functor.map
      ((NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj X) ⊗ e.inverse.obj (e.functor.obj Y)) ⊗
          𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
        (((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
              𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
            (NatTrans.app (Equivalence.unit e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z)))) ≫
          (NatTrans.app (Equivalence.unitInv e) (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫ (α_ X Y Z).hom) =
    e.functor.map
      ((NatTrans.app e.unitIso.inv (e.inverse.obj (e.functor.obj X) ⊗ e.inverse.obj (e.functor.obj Y)) ⊗
          𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
        (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
          (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
              NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
            ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
                  NatTrans.app (Equivalence.unitInv e)
                    (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
                (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
                    NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
                  (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
              (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z)))
[PROOFSTEP]
congr 2
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ (((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
          𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
        (NatTrans.app (Equivalence.unit e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z)))) ≫
      (NatTrans.app (Equivalence.unitInv e) (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫ (α_ X Y Z).hom =
    (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
      (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
          NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
        ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
              NatTrans.app (Equivalence.unitInv e)
                (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
            (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
                NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
              (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
          (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
[PROOFSTEP]
slice_lhs 3 3 => rw [← tensor_id_comp_id_tensor]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ X Y Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
    𝟙 (e.inverse.obj (e.functor.obj Z))
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unit e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z))
[PROOFSTEP]
rw [← tensor_id_comp_id_tensor]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ X Y Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
    𝟙 (e.inverse.obj (e.functor.obj Z))
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unit e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z))
[PROOFSTEP]
rw [← tensor_id_comp_id_tensor]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ X Y Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
    𝟙 (e.inverse.obj (e.functor.obj Z))
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unit e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z))
[PROOFSTEP]
rw [← tensor_id_comp_id_tensor]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ ((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
        𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
      (NatTrans.app (Equivalence.unit e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
        ((NatTrans.app (Equivalence.unitInv e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
            (𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z)) ≫
          (α_ X Y Z).hom =
    (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
      (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
          NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
        ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
              NatTrans.app (Equivalence.unitInv e)
                (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
            (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
                NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
              (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
          (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
[PROOFSTEP]
slice_lhs 2 3 =>
  rw [← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unit e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
    (NatTrans.app (Equivalence.unitInv e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z)))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ X Y Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
    𝟙 (e.inverse.obj (e.functor.obj Z))
[PROOFSTEP]
  rw [← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unit e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
    (NatTrans.app (Equivalence.unitInv e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z)))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ X Y Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
    𝟙 (e.inverse.obj (e.functor.obj Z))
[PROOFSTEP]
  rw [← comp_tensor_id, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unit e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
    (NatTrans.app (Equivalence.unitInv e) (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z)))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ X Y Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
    𝟙 (e.inverse.obj (e.functor.obj Z))
[PROOFSTEP]
rw [← comp_tensor_id, Iso.hom_inv_id_app]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 ((𝟭 C).obj (X ⊗ Y)) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ X Y Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
    𝟙 (e.inverse.obj (e.functor.obj Z))
[PROOFSTEP]
dsimp
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (X ⊗ Y) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ X Y Z).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
    𝟙 (e.inverse.obj (e.functor.obj Z))
[PROOFSTEP]
rw [tensor_id]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ ((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
        𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
      (𝟙 ((X ⊗ Y) ⊗ e.inverse.obj (e.functor.obj Z)) ≫ (𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z)) ≫
        (α_ X Y Z).hom =
    (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
      (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
          NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
        ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
              NatTrans.app (Equivalence.unitInv e)
                (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
            (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
                NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
              (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
          (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
[PROOFSTEP]
rw [id_comp]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ ((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
        𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
      (𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫ (α_ X Y Z).hom =
    (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
      (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
          NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
        ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
              NatTrans.app (Equivalence.unitInv e)
                (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
            (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
                NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
              (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
          (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
[PROOFSTEP]
slice_rhs 2 3 =>
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
      NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
    (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
      NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z)))
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom
[PROOFSTEP]
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
      NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
    (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
      NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z)))
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom
[PROOFSTEP]
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
      NatTrans.app e.unitIso.hom (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))) ≫
    (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
      NatTrans.app (Equivalence.unitInv e) (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z)))
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom
[PROOFSTEP]
rw [← id_tensor_comp, Iso.hom_inv_id_app]
[GOAL]
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
    𝟙 ((𝟭 C).obj (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z)))
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom
[PROOFSTEP]
dsimp
[GOAL]
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ 𝟙 (e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z))
case a.a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom
[PROOFSTEP]
rw [tensor_id]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ ((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
        𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
      (𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫ (α_ X Y Z).hom =
    (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
      ((𝟙 (e.inverse.obj (e.functor.obj X) ⊗ e.inverse.obj (e.functor.obj Y) ⊗ e.inverse.obj (e.functor.obj Z)) ≫
            (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
              NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z)) ≫
          (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
        (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
[PROOFSTEP]
rw [id_comp]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ ((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
        𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
      (𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫ (α_ X Y Z).hom =
    (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
      ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
            NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
          (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
        (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
[PROOFSTEP]
conv_rhs => rw [← id_tensor_comp_tensor_id _ (e.unitInv.app X)]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
    ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
          NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
        (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
      (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
[PROOFSTEP]
rw [← id_tensor_comp_tensor_id _ (e.unitInv.app X)]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
    ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
          NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
        (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
      (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
[PROOFSTEP]
rw [← id_tensor_comp_tensor_id _ (e.unitInv.app X)]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
    ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
          NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
        (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
      (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
[PROOFSTEP]
rw [← id_tensor_comp_tensor_id _ (e.unitInv.app X)]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ ((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
        𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
      (𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫ (α_ X Y Z).hom =
    (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
      ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
            NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
          (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
        (𝟙 ((e.functor ⋙ e.inverse).obj X) ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z)) ≫
          (NatTrans.app (Equivalence.unitInv e) X ⊗ 𝟙 (Y ⊗ Z))
[PROOFSTEP]
dsimp only [Functor.comp_obj]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ ((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
        𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
      (𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫ (α_ X Y Z).hom =
    (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
      ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
            NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
          (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z))) ≫
        (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z)) ≫
          (NatTrans.app (Equivalence.unitInv e) X ⊗ 𝟙 (Y ⊗ Z))
[PROOFSTEP]
slice_rhs 3 4 =>
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z)) ≫
    (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) X ⊗ 𝟙 (Y ⊗ Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z
[PROOFSTEP]
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z)) ≫
    (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) X ⊗ 𝟙 (Y ⊗ Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z
[PROOFSTEP]
  rw [← id_tensor_comp, Iso.hom_inv_id_app]
  dsimp
  rw [tensor_id]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unit e) (Y ⊗ Z)) ≫
    (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) (Y ⊗ Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) X ⊗ 𝟙 (Y ⊗ Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z
[PROOFSTEP]
rw [← id_tensor_comp, Iso.hom_inv_id_app]
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ 𝟙 ((𝟭 C).obj (Y ⊗ Z))
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) X ⊗ 𝟙 (Y ⊗ Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z
[PROOFSTEP]
dsimp
[GOAL]
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ 𝟙 (Y ⊗ Z)
case a.a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| NatTrans.app (Equivalence.unitInv e) X ⊗ 𝟙 (Y ⊗ Z)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
| 𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z
[PROOFSTEP]
rw [tensor_id]
[GOAL]
case e_a.e_a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y Z : C
⊢ ((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y) ⊗
        𝟙 (e.inverse.obj (e.functor.obj Z))) ≫
      (𝟙 (X ⊗ Y) ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫ (α_ X Y Z).hom =
    (α_ (e.inverse.obj (e.functor.obj X)) (e.inverse.obj (e.functor.obj Y)) (e.inverse.obj (e.functor.obj Z))).hom ≫
      (𝟙 (e.inverse.obj (e.functor.obj X)) ⊗
          NatTrans.app (Equivalence.unitInv e) Y ⊗ NatTrans.app (Equivalence.unitInv e) Z) ≫
        𝟙 (e.inverse.obj (e.functor.obj X) ⊗ Y ⊗ Z) ≫ (NatTrans.app (Equivalence.unitInv e) X ⊗ 𝟙 (Y ⊗ Z))
[PROOFSTEP]
simp only [associator_conjugation, ← tensor_id, ← tensor_comp, Iso.inv_hom_id, Iso.inv_hom_id_assoc, assoc, id_comp,
  comp_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ (λ_ (e.functor.obj X)).hom =
    (𝟙 (e.functor.obj (𝟙_ C)) ⊗ 𝟙 (e.functor.obj X)) ≫
      (fun X Y => e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y))
          (𝟙_ C) X ≫
        e.functor.map (λ_ X).hom
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ e.functor.map
        ((NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ 𝟙 (e.inverse.obj (e.functor.obj X))) ≫
          (λ_ (e.inverse.obj (e.functor.obj X))).hom) ≫
      NatTrans.app e.counitIso.hom (e.functor.obj X) =
    e.functor.map (e.inverse.map (𝟙 (e.functor.obj (𝟙_ C))) ⊗ e.inverse.map (𝟙 (e.functor.obj X))) ≫
      e.functor.map (NatTrans.app (Equivalence.unitInv e) (𝟙_ C) ⊗ NatTrans.app (Equivalence.unitInv e) X) ≫
        e.functor.map (λ_ X).hom
[PROOFSTEP]
rw [e.inverse.map_id, e.inverse.map_id, tensor_id, Functor.map_comp, assoc, Equivalence.counit_app_functor, ←
  e.functor.map_comp, ← e.functor.map_comp, ← e.functor.map_comp, ← e.functor.map_comp, ← leftUnitor_naturality, ←
  tensor_comp_assoc, comp_id, id_comp, id_comp]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ e.functor.map
      ((NatTrans.app e.unitIso.inv (𝟙_ C) ⊗ NatTrans.app (Equivalence.unitInv e) X) ≫ (λ_ ((𝟭 C).obj X)).hom) =
    e.functor.map ((NatTrans.app (Equivalence.unitInv e) (𝟙_ C) ⊗ NatTrans.app (Equivalence.unitInv e) X) ≫ (λ_ X).hom)
[PROOFSTEP]
rfl
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ (ρ_ (e.functor.obj X)).hom =
    (𝟙 (e.functor.obj X) ⊗ 𝟙 (e.functor.obj (𝟙_ C))) ≫
      (fun X Y => e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y)) X
          (𝟙_ C) ≫
        e.functor.map (ρ_ X).hom
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ e.functor.map
        ((𝟙 (e.inverse.obj (e.functor.obj X)) ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫
          (ρ_ (e.inverse.obj (e.functor.obj X))).hom) ≫
      NatTrans.app e.counitIso.hom (e.functor.obj X) =
    e.functor.map (e.inverse.map (𝟙 (e.functor.obj X)) ⊗ e.inverse.map (𝟙 (e.functor.obj (𝟙_ C)))) ≫
      e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (𝟙_ C)) ≫
        e.functor.map (ρ_ X).hom
[PROOFSTEP]
rw [Functor.map_comp, assoc, e.inverse.map_id, e.inverse.map_id, tensor_id, Functor.map_id, id_comp,
  Equivalence.counit_app_functor, ← e.functor.map_comp, ← e.functor.map_comp, ← e.functor.map_comp, ←
  rightUnitor_naturality, ← tensor_comp_assoc, id_comp, comp_id]
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : C
⊢ e.functor.map
      ((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app e.unitIso.inv (𝟙_ C)) ≫ (ρ_ ((𝟭 C).obj X)).hom) =
    e.functor.map ((NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) (𝟙_ C)) ≫ (ρ_ X).hom)
[PROOFSTEP]
rfl
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
⊢ IsIso (laxToTransported e).ε
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
⊢ IsIso (𝟙 (e.functor.obj (𝟙_ C)))
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : C
⊢ IsIso (LaxMonoidalFunctor.μ (laxToTransported e) X Y)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X Y : C
⊢ IsIso (e.functor.map (NatTrans.app (Equivalence.unitInv e) X ⊗ NatTrans.app (Equivalence.unitInv e) Y))
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
⊢ IsEquivalence (toTransported e).toLaxMonoidalFunctor.toFunctor
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
⊢ IsEquivalence e.functor
[PROOFSTEP]
infer_instance
