Theorem: CategoryTheory.tensor_associativity
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

tactic: dsimp only [tensor_obj, prodMonoidal_tensorObj, tensor_μ]
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C
⊢ tensor_μ C (X₁, X₂) (Y₁, Y₂) ▷ (Z₁ ⊗ Z₂) ≫
      tensor_μ C (X₁ ⊗ Y₁, X₂ ⊗ Y₂) (Z₁, Z₂) ≫ ((α_ X₁ Y₁ Z₁).hom ⊗ (α_ X₂ Y₂ Z₂).hom) =
    (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
      (X₁ ⊗ X₂) ◁ tensor_μ C (Y₁, Y₂) (Z₁, Z₂) ≫ tensor_μ C (X₁, X₂) (Y₁ ⊗ Z₁, Y₂ ⊗ Z₂)
state_after: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C
⊢ ((α_ X₁ X₂ (Y₁ ⊗ Y₂)).hom ≫
          X₁ ◁ (α_ X₂ Y₁ Y₂).inv ≫ X₁ ◁ (β_ X₂ Y₁).hom ▷ Y₂ ≫ X₁ ◁ (α_ Y₁ X₂ Y₂).hom ≫ (α_ X₁ Y₁ (X₂ ⊗ Y₂)).inv) ▷
        (Z₁ ⊗ Z₂) ≫
      ((α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
          (X₁ ⊗ Y₁) ◁ (α_ (X₂ ⊗ Y₂) Z₁ Z₂).inv ≫
            (X₁ ⊗ Y₁) ◁ (β_ (X₂ ⊗ Y₂) Z₁).hom ▷ Z₂ ≫
              (X₁ ⊗ Y₁) ◁ (α_ Z₁ (X₂ ⊗ Y₂) Z₂).hom ≫ (α_ (X₁ ⊗ Y₁) Z₁ ((X₂ ⊗ Y₂) ⊗ Z₂)).inv) ≫
        ((α_ X₁ Y₁ Z₁).hom ⊗ (α_ X₂ Y₂ Z₂).hom) =
    (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
      (X₁ ⊗ X₂) ◁
          ((α_ Y₁ Y₂ (Z₁ ⊗ Z₂)).hom ≫
            Y₁ ◁ (α_ Y₂ Z₁ Z₂).inv ≫ Y₁ ◁ (β_ Y₂ Z₁).hom ▷ Z₂ ≫ Y₁ ◁ (α_ Z₁ Y₂ Z₂).hom ≫ (α_ Y₁ Z₁ (Y₂ ⊗ Z₂)).inv) ≫
        (α_ X₁ X₂ ((Y₁ ⊗ Z₁) ⊗ Y₂ ⊗ Z₂)).hom ≫
          X₁ ◁ (α_ X₂ (Y₁ ⊗ Z₁) (Y₂ ⊗ Z₂)).inv ≫
            X₁ ◁ (β_ X₂ (Y₁ ⊗ Z₁)).hom ▷ (Y₂ ⊗ Z₂) ≫
              X₁ ◁ (α_ (Y₁ ⊗ Z₁) X₂ (Y₂ ⊗ Z₂)).hom ≫ (α_ X₁ (Y₁ ⊗ Z₁) (X₂ ⊗ Y₂ ⊗ Z₂)).inv

tactic: simp only [whiskerRight_tensor, comp_whiskerRight, whisker_assoc, assoc, Iso.inv_hom_id_assoc,
  tensor_whiskerLeft, braiding_tensor_left, MonoidalCategory.whiskerLeft_comp,
  braiding_tensor_right]
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C
⊢ ((α_ X₁ X₂ (Y₁ ⊗ Y₂)).hom ≫
          X₁ ◁ (α_ X₂ Y₁ Y₂).inv ≫ X₁ ◁ (β_ X₂ Y₁).hom ▷ Y₂ ≫ X₁ ◁ (α_ Y₁ X₂ Y₂).hom ≫ (α_ X₁ Y₁ (X₂ ⊗ Y₂)).inv) ▷
        (Z₁ ⊗ Z₂) ≫
      ((α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
          (X₁ ⊗ Y₁) ◁ (α_ (X₂ ⊗ Y₂) Z₁ Z₂).inv ≫
            (X₁ ⊗ Y₁) ◁ (β_ (X₂ ⊗ Y₂) Z₁).hom ▷ Z₂ ≫
              (X₁ ⊗ Y₁) ◁ (α_ Z₁ (X₂ ⊗ Y₂) Z₂).hom ≫ (α_ (X₁ ⊗ Y₁) Z₁ ((X₂ ⊗ Y₂) ⊗ Z₂)).inv) ≫
        ((α_ X₁ Y₁ Z₁).hom ⊗ (α_ X₂ Y₂ Z₂).hom) =
    (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
      (X₁ ⊗ X₂) ◁
          ((α_ Y₁ Y₂ (Z₁ ⊗ Z₂)).hom ≫
            Y₁ ◁ (α_ Y₂ Z₁ Z₂).inv ≫ Y₁ ◁ (β_ Y₂ Z₁).hom ▷ Z₂ ≫ Y₁ ◁ (α_ Z₁ Y₂ Z₂).hom ≫ (α_ Y₁ Z₁ (Y₂ ⊗ Z₂)).inv) ≫
        (α_ X₁ X₂ ((Y₁ ⊗ Z₁) ⊗ Y₂ ⊗ Z₂)).hom ≫
          X₁ ◁ (α_ X₂ (Y₁ ⊗ Z₁) (Y₂ ⊗ Z₂)).inv ≫
            X₁ ◁ (β_ X₂ (Y₁ ⊗ Z₁)).hom ▷ (Y₂ ⊗ Z₂) ≫
              X₁ ◁ (α_ (Y₁ ⊗ Z₁) X₂ (Y₂ ⊗ Z₂)).hom ≫ (α_ X₁ (Y₁ ⊗ Z₁) (X₂ ⊗ Y₂ ⊗ Z₂)).inv
state_after: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C
⊢ (α_ ((X₁ ⊗ X₂) ⊗ Y₁ ⊗ Y₂) Z₁ Z₂).inv ≫
      (α_ X₁ X₂ (Y₁ ⊗ Y₂)).hom ▷ Z₁ ▷ Z₂ ≫
        (α_ X₁ (X₂ ⊗ Y₁ ⊗ Y₂) Z₁).hom ▷ Z₂ ≫
          (α_ X₁ ((X₂ ⊗ Y₁ ⊗ Y₂) ⊗ Z₁) Z₂).hom ≫
            X₁ ◁ (α_ X₂ Y₁ Y₂).inv ▷ Z₁ ▷ Z₂ ≫
              X₁ ◁ (β_ X₂ Y₁).hom ▷ Y₂ ▷ Z₁ ▷ Z₂ ≫
                X₁ ◁ (α_ Y₁ X₂ Y₂).hom ▷ Z₁ ▷ Z₂ ≫
                  (α_ X₁ ((Y₁ ⊗ X₂ ⊗ Y₂) ⊗ Z₁) Z₂).inv ≫
                    (α_ X₁ (Y₁ ⊗ X₂ ⊗ Y₂) Z₁).inv ▷ Z₂ ≫
                      (α_ X₁ Y₁ (X₂ ⊗ Y₂)).inv ▷ Z₁ ▷ Z₂ ≫
                        (α_ ((X₁ ⊗ Y₁) ⊗ X₂ ⊗ Y₂) Z₁ Z₂).hom ≫
                          (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
                            (α_ X₁ Y₁ ((X₂ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂)).hom ≫
                              X₁ ◁ Y₁ ◁ (α_ (X₂ ⊗ Y₂) Z₁ Z₂).inv ≫
                                X₁ ◁ Y₁ ◁ (α_ X₂ Y₂ Z₁).hom ▷ Z₂ ≫
                                  X₁ ◁ Y₁ ◁ (α_ X₂ (Y₂ ⊗ Z₁) Z₂).hom ≫
                                    X₁ ◁ Y₁ ◁ X₂ ◁ (β_ Y₂ Z₁).hom ▷ Z₂ ≫
                                      X₁ ◁ Y₁ ◁ (α_ X₂ (Z₁ ⊗ Y₂) Z₂).inv ≫
                                        X₁ ◁ Y₁ ◁ (α_ X₂ Z₁ Y₂).inv ▷ Z₂ ≫
                                          X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                                            X₁ ◁ Y₁ ◁ (α_ Z₁ X₂ Y₂).hom ▷ Z₂ ≫
                                              X₁ ◁ Y₁ ◁ (α_ Z₁ (X₂ ⊗ Y₂) Z₂).hom ≫
                                                (α_ X₁ Y₁ (Z₁ ⊗ (X₂ ⊗ Y₂) ⊗ Z₂)).inv ≫
                                                  (α_ (X₁ ⊗ Y₁) Z₁ ((X₂ ⊗ Y₂) ⊗ Z₂)).inv ≫
                                                    ((α_ X₁ Y₁ Z₁).hom ⊗ (α_ X₂ Y₂ Z₂).hom) =
    (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
      (α_ X₁ X₂ ((Y₁ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂)).hom ≫
        X₁ ◁ X₂ ◁ (α_ Y₁ Y₂ (Z₁ ⊗ Z₂)).hom ≫
          X₁ ◁ X₂ ◁ Y₁ ◁ (α_ Y₂ Z₁ Z₂).inv ≫
            X₁ ◁ X₂ ◁ Y₁ ◁ (β_ Y₂ Z₁).hom ▷ Z₂ ≫
              X₁ ◁ X₂ ◁ Y₁ ◁ (α_ Z₁ Y₂ Z₂).hom ≫
                X₁ ◁ X₂ ◁ (α_ Y₁ Z₁ (Y₂ ⊗ Z₂)).inv ≫
                  X₁ ◁ (α_ X₂ (Y₁ ⊗ Z₁) (Y₂ ⊗ Z₂)).inv ≫
                    X₁ ◁ (α_ (X₂ ⊗ Y₁ ⊗ Z₁) Y₂ Z₂).inv ≫
                      X₁ ◁ (α_ X₂ Y₁ Z₁).inv ▷ Y₂ ▷ Z₂ ≫
                        X₁ ◁ (β_ X₂ Y₁).hom ▷ Z₁ ▷ Y₂ ▷ Z₂ ≫
                          X₁ ◁ (α_ Y₁ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                            X₁ ◁ (α_ Y₁ (X₂ ⊗ Z₁) Y₂).hom ▷ Z₂ ≫
                              X₁ ◁ (α_ Y₁ ((X₂ ⊗ Z₁) ⊗ Y₂) Z₂).hom ≫
                                X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                                  X₁ ◁ (α_ Y₁ ((Z₁ ⊗ X₂) ⊗ Y₂) Z₂).inv ≫
                                    X₁ ◁ (α_ Y₁ (Z₁ ⊗ X₂) Y₂).inv ▷ Z₂ ≫
                                      X₁ ◁ (α_ Y₁ Z₁ X₂).inv ▷ Y₂ ▷ Z₂ ≫
                                        X₁ ◁ (α_ ((Y₁ ⊗ Z₁) ⊗ X₂) Y₂ Z₂).hom ≫
                                          X₁ ◁ (α_ (Y₁ ⊗ Z₁) X₂ (Y₂ ⊗ Z₂)).hom ≫ (α_ X₁ (Y₁ ⊗ Z₁) (X₂ ⊗ Y₂ ⊗ Z₂)).inv

tactic: calc
  _ = 𝟙 _ ⊗≫
    X₁ ◁ ((β_ X₂ Y₁).hom ▷ (Y₂ ⊗ Z₁) ≫ (Y₁ ⊗ X₂) ◁ (β_ Y₂ Z₁).hom) ▷ Z₂ ⊗≫
      X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ⊗≫ 𝟙 _ := by coherence
  _ = _ := by rw [← whisker_exchange]; coherence
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C
⊢ (α_ ((X₁ ⊗ X₂) ⊗ Y₁ ⊗ Y₂) Z₁ Z₂).inv ≫
      (α_ X₁ X₂ (Y₁ ⊗ Y₂)).hom ▷ Z₁ ▷ Z₂ ≫
        (α_ X₁ (X₂ ⊗ Y₁ ⊗ Y₂) Z₁).hom ▷ Z₂ ≫
          (α_ X₁ ((X₂ ⊗ Y₁ ⊗ Y₂) ⊗ Z₁) Z₂).hom ≫
            X₁ ◁ (α_ X₂ Y₁ Y₂).inv ▷ Z₁ ▷ Z₂ ≫
              X₁ ◁ (β_ X₂ Y₁).hom ▷ Y₂ ▷ Z₁ ▷ Z₂ ≫
                X₁ ◁ (α_ Y₁ X₂ Y₂).hom ▷ Z₁ ▷ Z₂ ≫
                  (α_ X₁ ((Y₁ ⊗ X₂ ⊗ Y₂) ⊗ Z₁) Z₂).inv ≫
                    (α_ X₁ (Y₁ ⊗ X₂ ⊗ Y₂) Z₁).inv ▷ Z₂ ≫
                      (α_ X₁ Y₁ (X₂ ⊗ Y₂)).inv ▷ Z₁ ▷ Z₂ ≫
                        (α_ ((X₁ ⊗ Y₁) ⊗ X₂ ⊗ Y₂) Z₁ Z₂).hom ≫
                          (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
                            (α_ X₁ Y₁ ((X₂ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂)).hom ≫
                              X₁ ◁ Y₁ ◁ (α_ (X₂ ⊗ Y₂) Z₁ Z₂).inv ≫
                                X₁ ◁ Y₁ ◁ (α_ X₂ Y₂ Z₁).hom ▷ Z₂ ≫
                                  X₁ ◁ Y₁ ◁ (α_ X₂ (Y₂ ⊗ Z₁) Z₂).hom ≫
                                    X₁ ◁ Y₁ ◁ X₂ ◁ (β_ Y₂ Z₁).hom ▷ Z₂ ≫
                                      X₁ ◁ Y₁ ◁ (α_ X₂ (Z₁ ⊗ Y₂) Z₂).inv ≫
                                        X₁ ◁ Y₁ ◁ (α_ X₂ Z₁ Y₂).inv ▷ Z₂ ≫
                                          X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                                            X₁ ◁ Y₁ ◁ (α_ Z₁ X₂ Y₂).hom ▷ Z₂ ≫
                                              X₁ ◁ Y₁ ◁ (α_ Z₁ (X₂ ⊗ Y₂) Z₂).hom ≫
                                                (α_ X₁ Y₁ (Z₁ ⊗ (X₂ ⊗ Y₂) ⊗ Z₂)).inv ≫
                                                  (α_ (X₁ ⊗ Y₁) Z₁ ((X₂ ⊗ Y₂) ⊗ Z₂)).inv ≫
                                                    ((α_ X₁ Y₁ Z₁).hom ⊗ (α_ X₂ Y₂ Z₂).hom) =
    (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
      (α_ X₁ X₂ ((Y₁ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂)).hom ≫
        X₁ ◁ X₂ ◁ (α_ Y₁ Y₂ (Z₁ ⊗ Z₂)).hom ≫
          X₁ ◁ X₂ ◁ Y₁ ◁ (α_ Y₂ Z₁ Z₂).inv ≫
            X₁ ◁ X₂ ◁ Y₁ ◁ (β_ Y₂ Z₁).hom ▷ Z₂ ≫
              X₁ ◁ X₂ ◁ Y₁ ◁ (α_ Z₁ Y₂ Z₂).hom ≫
                X₁ ◁ X₂ ◁ (α_ Y₁ Z₁ (Y₂ ⊗ Z₂)).inv ≫
                  X₁ ◁ (α_ X₂ (Y₁ ⊗ Z₁) (Y₂ ⊗ Z₂)).inv ≫
                    X₁ ◁ (α_ (X₂ ⊗ Y₁ ⊗ Z₁) Y₂ Z₂).inv ≫
                      X₁ ◁ (α_ X₂ Y₁ Z₁).inv ▷ Y₂ ▷ Z₂ ≫
                        X₁ ◁ (β_ X₂ Y₁).hom ▷ Z₁ ▷ Y₂ ▷ Z₂ ≫
                          X₁ ◁ (α_ Y₁ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                            X₁ ◁ (α_ Y₁ (X₂ ⊗ Z₁) Y₂).hom ▷ Z₂ ≫
                              X₁ ◁ (α_ Y₁ ((X₂ ⊗ Z₁) ⊗ Y₂) Z₂).hom ≫
                                X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                                  X₁ ◁ (α_ Y₁ ((Z₁ ⊗ X₂) ⊗ Y₂) Z₂).inv ≫
                                    X₁ ◁ (α_ Y₁ (Z₁ ⊗ X₂) Y₂).inv ▷ Z₂ ≫
                                      X₁ ◁ (α_ Y₁ Z₁ X₂).inv ▷ Y₂ ▷ Z₂ ≫
                                        X₁ ◁ (α_ ((Y₁ ⊗ Z₁) ⊗ X₂) Y₂ Z₂).hom ≫
                                          X₁ ◁ (α_ (Y₁ ⊗ Z₁) X₂ (Y₂ ⊗ Z₂)).hom ≫ (α_ X₁ (Y₁ ⊗ Z₁) (X₂ ⊗ Y₂ ⊗ Z₂)).inv
state_after: no goals

tactic: coherence
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C
⊢ (α_ ((X₁ ⊗ X₂) ⊗ Y₁ ⊗ Y₂) Z₁ Z₂).inv ≫
      (α_ X₁ X₂ (Y₁ ⊗ Y₂)).hom ▷ Z₁ ▷ Z₂ ≫
        (α_ X₁ (X₂ ⊗ Y₁ ⊗ Y₂) Z₁).hom ▷ Z₂ ≫
          (α_ X₁ ((X₂ ⊗ Y₁ ⊗ Y₂) ⊗ Z₁) Z₂).hom ≫
            X₁ ◁ (α_ X₂ Y₁ Y₂).inv ▷ Z₁ ▷ Z₂ ≫
              X₁ ◁ (β_ X₂ Y₁).hom ▷ Y₂ ▷ Z₁ ▷ Z₂ ≫
                X₁ ◁ (α_ Y₁ X₂ Y₂).hom ▷ Z₁ ▷ Z₂ ≫
                  (α_ X₁ ((Y₁ ⊗ X₂ ⊗ Y₂) ⊗ Z₁) Z₂).inv ≫
                    (α_ X₁ (Y₁ ⊗ X₂ ⊗ Y₂) Z₁).inv ▷ Z₂ ≫
                      (α_ X₁ Y₁ (X₂ ⊗ Y₂)).inv ▷ Z₁ ▷ Z₂ ≫
                        (α_ ((X₁ ⊗ Y₁) ⊗ X₂ ⊗ Y₂) Z₁ Z₂).hom ≫
                          (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
                            (α_ X₁ Y₁ ((X₂ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂)).hom ≫
                              X₁ ◁ Y₁ ◁ (α_ (X₂ ⊗ Y₂) Z₁ Z₂).inv ≫
                                X₁ ◁ Y₁ ◁ (α_ X₂ Y₂ Z₁).hom ▷ Z₂ ≫
                                  X₁ ◁ Y₁ ◁ (α_ X₂ (Y₂ ⊗ Z₁) Z₂).hom ≫
                                    X₁ ◁ Y₁ ◁ X₂ ◁ (β_ Y₂ Z₁).hom ▷ Z₂ ≫
                                      X₁ ◁ Y₁ ◁ (α_ X₂ (Z₁ ⊗ Y₂) Z₂).inv ≫
                                        X₁ ◁ Y₁ ◁ (α_ X₂ Z₁ Y₂).inv ▷ Z₂ ≫
                                          X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                                            X₁ ◁ Y₁ ◁ (α_ Z₁ X₂ Y₂).hom ▷ Z₂ ≫
                                              X₁ ◁ Y₁ ◁ (α_ Z₁ (X₂ ⊗ Y₂) Z₂).hom ≫
                                                (α_ X₁ Y₁ (Z₁ ⊗ (X₂ ⊗ Y₂) ⊗ Z₂)).inv ≫
                                                  (α_ (X₁ ⊗ Y₁) Z₁ ((X₂ ⊗ Y₂) ⊗ Z₂)).inv ≫
                                                    ((α_ X₁ Y₁ Z₁).hom ⊗ (α_ X₂ Y₂ Z₂).hom) =
    𝟙 (((X₁ ⊗ X₂) ⊗ Y₁ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂) ⊗≫
      X₁ ◁ ((β_ X₂ Y₁).hom ▷ (Y₂ ⊗ Z₁) ≫ (Y₁ ⊗ X₂) ◁ (β_ Y₂ Z₁).hom) ▷ Z₂ ⊗≫
        X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ⊗≫ 𝟙 ((X₁ ⊗ Y₁ ⊗ Z₁) ⊗ X₂ ⊗ Y₂ ⊗ Z₂)
state_after: no goals

tactic: rw [← whisker_exchange]
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C
⊢ 𝟙 (((X₁ ⊗ X₂) ⊗ Y₁ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂) ⊗≫
      X₁ ◁ ((β_ X₂ Y₁).hom ▷ (Y₂ ⊗ Z₁) ≫ (Y₁ ⊗ X₂) ◁ (β_ Y₂ Z₁).hom) ▷ Z₂ ⊗≫
        X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ⊗≫ 𝟙 ((X₁ ⊗ Y₁ ⊗ Z₁) ⊗ X₂ ⊗ Y₂ ⊗ Z₂) =
    (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
      (α_ X₁ X₂ ((Y₁ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂)).hom ≫
        X₁ ◁ X₂ ◁ (α_ Y₁ Y₂ (Z₁ ⊗ Z₂)).hom ≫
          X₁ ◁ X₂ ◁ Y₁ ◁ (α_ Y₂ Z₁ Z₂).inv ≫
            X₁ ◁ X₂ ◁ Y₁ ◁ (β_ Y₂ Z₁).hom ▷ Z₂ ≫
              X₁ ◁ X₂ ◁ Y₁ ◁ (α_ Z₁ Y₂ Z₂).hom ≫
                X₁ ◁ X₂ ◁ (α_ Y₁ Z₁ (Y₂ ⊗ Z₂)).inv ≫
                  X₁ ◁ (α_ X₂ (Y₁ ⊗ Z₁) (Y₂ ⊗ Z₂)).inv ≫
                    X₁ ◁ (α_ (X₂ ⊗ Y₁ ⊗ Z₁) Y₂ Z₂).inv ≫
                      X₁ ◁ (α_ X₂ Y₁ Z₁).inv ▷ Y₂ ▷ Z₂ ≫
                        X₁ ◁ (β_ X₂ Y₁).hom ▷ Z₁ ▷ Y₂ ▷ Z₂ ≫
                          X₁ ◁ (α_ Y₁ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                            X₁ ◁ (α_ Y₁ (X₂ ⊗ Z₁) Y₂).hom ▷ Z₂ ≫
                              X₁ ◁ (α_ Y₁ ((X₂ ⊗ Z₁) ⊗ Y₂) Z₂).hom ≫
                                X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                                  X₁ ◁ (α_ Y₁ ((Z₁ ⊗ X₂) ⊗ Y₂) Z₂).inv ≫
                                    X₁ ◁ (α_ Y₁ (Z₁ ⊗ X₂) Y₂).inv ▷ Z₂ ≫
                                      X₁ ◁ (α_ Y₁ Z₁ X₂).inv ▷ Y₂ ▷ Z₂ ≫
                                        X₁ ◁ (α_ ((Y₁ ⊗ Z₁) ⊗ X₂) Y₂ Z₂).hom ≫
                                          X₁ ◁ (α_ (Y₁ ⊗ Z₁) X₂ (Y₂ ⊗ Z₂)).hom ≫ (α_ X₁ (Y₁ ⊗ Z₁) (X₂ ⊗ Y₂ ⊗ Z₂)).inv
state_after: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C
⊢ 𝟙 (((X₁ ⊗ X₂) ⊗ Y₁ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂) ⊗≫
      X₁ ◁ ((X₂ ⊗ Y₁) ◁ (β_ Y₂ Z₁).hom ≫ (β_ X₂ Y₁).hom ▷ (Z₁ ⊗ Y₂)) ▷ Z₂ ⊗≫
        X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ⊗≫ 𝟙 ((X₁ ⊗ Y₁ ⊗ Z₁) ⊗ X₂ ⊗ Y₂ ⊗ Z₂) =
    (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
      (α_ X₁ X₂ ((Y₁ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂)).hom ≫
        X₁ ◁ X₂ ◁ (α_ Y₁ Y₂ (Z₁ ⊗ Z₂)).hom ≫
          X₁ ◁ X₂ ◁ Y₁ ◁ (α_ Y₂ Z₁ Z₂).inv ≫
            X₁ ◁ X₂ ◁ Y₁ ◁ (β_ Y₂ Z₁).hom ▷ Z₂ ≫
              X₁ ◁ X₂ ◁ Y₁ ◁ (α_ Z₁ Y₂ Z₂).hom ≫
                X₁ ◁ X₂ ◁ (α_ Y₁ Z₁ (Y₂ ⊗ Z₂)).inv ≫
                  X₁ ◁ (α_ X₂ (Y₁ ⊗ Z₁) (Y₂ ⊗ Z₂)).inv ≫
                    X₁ ◁ (α_ (X₂ ⊗ Y₁ ⊗ Z₁) Y₂ Z₂).inv ≫
                      X₁ ◁ (α_ X₂ Y₁ Z₁).inv ▷ Y₂ ▷ Z₂ ≫
                        X₁ ◁ (β_ X₂ Y₁).hom ▷ Z₁ ▷ Y₂ ▷ Z₂ ≫
                          X₁ ◁ (α_ Y₁ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                            X₁ ◁ (α_ Y₁ (X₂ ⊗ Z₁) Y₂).hom ▷ Z₂ ≫
                              X₁ ◁ (α_ Y₁ ((X₂ ⊗ Z₁) ⊗ Y₂) Z₂).hom ≫
                                X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                                  X₁ ◁ (α_ Y₁ ((Z₁ ⊗ X₂) ⊗ Y₂) Z₂).inv ≫
                                    X₁ ◁ (α_ Y₁ (Z₁ ⊗ X₂) Y₂).inv ▷ Z₂ ≫
                                      X₁ ◁ (α_ Y₁ Z₁ X₂).inv ▷ Y₂ ▷ Z₂ ≫
                                        X₁ ◁ (α_ ((Y₁ ⊗ Z₁) ⊗ X₂) Y₂ Z₂).hom ≫
                                          X₁ ◁ (α_ (Y₁ ⊗ Z₁) X₂ (Y₂ ⊗ Z₂)).hom ≫ (α_ X₁ (Y₁ ⊗ Z₁) (X₂ ⊗ Y₂ ⊗ Z₂)).inv

tactic: coherence
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C
⊢ 𝟙 (((X₁ ⊗ X₂) ⊗ Y₁ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂) ⊗≫
      X₁ ◁ ((X₂ ⊗ Y₁) ◁ (β_ Y₂ Z₁).hom ≫ (β_ X₂ Y₁).hom ▷ (Z₁ ⊗ Y₂)) ▷ Z₂ ⊗≫
        X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ⊗≫ 𝟙 ((X₁ ⊗ Y₁ ⊗ Z₁) ⊗ X₂ ⊗ Y₂ ⊗ Z₂) =
    (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (Z₁ ⊗ Z₂)).hom ≫
      (α_ X₁ X₂ ((Y₁ ⊗ Y₂) ⊗ Z₁ ⊗ Z₂)).hom ≫
        X₁ ◁ X₂ ◁ (α_ Y₁ Y₂ (Z₁ ⊗ Z₂)).hom ≫
          X₁ ◁ X₂ ◁ Y₁ ◁ (α_ Y₂ Z₁ Z₂).inv ≫
            X₁ ◁ X₂ ◁ Y₁ ◁ (β_ Y₂ Z₁).hom ▷ Z₂ ≫
              X₁ ◁ X₂ ◁ Y₁ ◁ (α_ Z₁ Y₂ Z₂).hom ≫
                X₁ ◁ X₂ ◁ (α_ Y₁ Z₁ (Y₂ ⊗ Z₂)).inv ≫
                  X₁ ◁ (α_ X₂ (Y₁ ⊗ Z₁) (Y₂ ⊗ Z₂)).inv ≫
                    X₁ ◁ (α_ (X₂ ⊗ Y₁ ⊗ Z₁) Y₂ Z₂).inv ≫
                      X₁ ◁ (α_ X₂ Y₁ Z₁).inv ▷ Y₂ ▷ Z₂ ≫
                        X₁ ◁ (β_ X₂ Y₁).hom ▷ Z₁ ▷ Y₂ ▷ Z₂ ≫
                          X₁ ◁ (α_ Y₁ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                            X₁ ◁ (α_ Y₁ (X₂ ⊗ Z₁) Y₂).hom ▷ Z₂ ≫
                              X₁ ◁ (α_ Y₁ ((X₂ ⊗ Z₁) ⊗ Y₂) Z₂).hom ≫
                                X₁ ◁ Y₁ ◁ (β_ X₂ Z₁).hom ▷ Y₂ ▷ Z₂ ≫
                                  X₁ ◁ (α_ Y₁ ((Z₁ ⊗ X₂) ⊗ Y₂) Z₂).inv ≫
                                    X₁ ◁ (α_ Y₁ (Z₁ ⊗ X₂) Y₂).inv ▷ Z₂ ≫
                                      X₁ ◁ (α_ Y₁ Z₁ X₂).inv ▷ Y₂ ▷ Z₂ ≫
                                        X₁ ◁ (α_ ((Y₁ ⊗ Z₁) ⊗ X₂) Y₂ Z₂).hom ≫
                                          X₁ ◁ (α_ (Y₁ ⊗ Z₁) X₂ (Y₂ ⊗ Z₂)).hom ≫ (α_ X₁ (Y₁ ⊗ Z₁) (X₂ ⊗ Y₂ ⊗ Z₂)).inv
state_after: no goals