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

tactic: dsimp only [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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ tensor_μ C (X₁ ⊗ X₂, X₃) (Y₁ ⊗ Y₂, Y₃) ≫
      tensor_μ C (X₁, X₂) (Y₁, Y₂) ▷ (X₃ ⊗ Y₃) ≫ (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (X₃ ⊗ Y₃)).hom =
    ((α_ X₁ X₂ X₃).hom ⊗ (α_ Y₁ Y₂ Y₃).hom) ≫
      tensor_μ C (X₁, X₂ ⊗ X₃) (Y₁, Y₂ ⊗ Y₃) ≫ (X₁ ⊗ Y₁) ◁ tensor_μ C (X₂, X₃) (Y₂, Y₃)
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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ ((α_ (X₁ ⊗ X₂) X₃ ((Y₁ ⊗ Y₂) ⊗ Y₃)).hom ≫
        (X₁ ⊗ X₂) ◁ (α_ X₃ (Y₁ ⊗ Y₂) Y₃).inv ≫
          (X₁ ⊗ X₂) ◁ (β_ X₃ (Y₁ ⊗ Y₂)).hom ▷ Y₃ ≫
            (X₁ ⊗ X₂) ◁ (α_ (Y₁ ⊗ Y₂) X₃ Y₃).hom ≫ (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (X₃ ⊗ Y₃)).inv) ≫
      ((α_ 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) ▷
          (X₃ ⊗ Y₃) ≫
        (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (X₃ ⊗ Y₃)).hom =
    ((α_ X₁ X₂ X₃).hom ⊗ (α_ Y₁ Y₂ Y₃).hom) ≫
      ((α_ X₁ (X₂ ⊗ X₃) (Y₁ ⊗ Y₂ ⊗ Y₃)).hom ≫
          X₁ ◁ (α_ (X₂ ⊗ X₃) Y₁ (Y₂ ⊗ Y₃)).inv ≫
            X₁ ◁ (β_ (X₂ ⊗ X₃) Y₁).hom ▷ (Y₂ ⊗ Y₃) ≫
              X₁ ◁ (α_ Y₁ (X₂ ⊗ X₃) (Y₂ ⊗ Y₃)).hom ≫ (α_ X₁ Y₁ ((X₂ ⊗ X₃) ⊗ Y₂ ⊗ Y₃)).inv) ≫
        (X₁ ⊗ Y₁) ◁
          ((α_ 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)

tactic: calc
  _ = 𝟙 _ ⊗≫ X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ⊗≫
    X₁ ◁ ((X₂ ⊗ Y₁) ◁ (β_ X₃ Y₂).hom ≫
      (β_ X₂ Y₁).hom ▷ (Y₂ ⊗ X₃)) ▷ Y₃ ⊗≫ 𝟙 _ := by simp; coherence
  _ = _ := by rw [whisker_exchange]; simp; 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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ ((α_ (X₁ ⊗ X₂) X₃ ((Y₁ ⊗ Y₂) ⊗ Y₃)).hom ≫
        (X₁ ⊗ X₂) ◁ (α_ X₃ (Y₁ ⊗ Y₂) Y₃).inv ≫
          (X₁ ⊗ X₂) ◁ (β_ X₃ (Y₁ ⊗ Y₂)).hom ▷ Y₃ ≫
            (X₁ ⊗ X₂) ◁ (α_ (Y₁ ⊗ Y₂) X₃ Y₃).hom ≫ (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (X₃ ⊗ Y₃)).inv) ≫
      ((α_ 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) ▷
          (X₃ ⊗ Y₃) ≫
        (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (X₃ ⊗ Y₃)).hom =
    ((α_ X₁ X₂ X₃).hom ⊗ (α_ Y₁ Y₂ Y₃).hom) ≫
      ((α_ X₁ (X₂ ⊗ X₃) (Y₁ ⊗ Y₂ ⊗ Y₃)).hom ≫
          X₁ ◁ (α_ (X₂ ⊗ X₃) Y₁ (Y₂ ⊗ Y₃)).inv ≫
            X₁ ◁ (β_ (X₂ ⊗ X₃) Y₁).hom ▷ (Y₂ ⊗ Y₃) ≫
              X₁ ◁ (α_ Y₁ (X₂ ⊗ X₃) (Y₂ ⊗ Y₃)).hom ≫ (α_ X₁ Y₁ ((X₂ ⊗ X₃) ⊗ Y₂ ⊗ Y₃)).inv) ≫
        (X₁ ⊗ Y₁) ◁
          ((α_ 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)
state_after: no goals

tactic: simp
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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ ((α_ (X₁ ⊗ X₂) X₃ ((Y₁ ⊗ Y₂) ⊗ Y₃)).hom ≫
        (X₁ ⊗ X₂) ◁ (α_ X₃ (Y₁ ⊗ Y₂) Y₃).inv ≫
          (X₁ ⊗ X₂) ◁ (β_ X₃ (Y₁ ⊗ Y₂)).hom ▷ Y₃ ≫
            (X₁ ⊗ X₂) ◁ (α_ (Y₁ ⊗ Y₂) X₃ Y₃).hom ≫ (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (X₃ ⊗ Y₃)).inv) ≫
      ((α_ 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) ▷
          (X₃ ⊗ Y₃) ≫
        (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (X₃ ⊗ Y₃)).hom =
    𝟙 (((X₁ ⊗ X₂) ⊗ X₃) ⊗ (Y₁ ⊗ Y₂) ⊗ Y₃) ⊗≫
      X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ⊗≫
        X₁ ◁ ((X₂ ⊗ Y₁) ◁ (β_ X₃ Y₂).hom ≫ (β_ X₂ Y₁).hom ▷ (Y₂ ⊗ X₃)) ▷ Y₃ ⊗≫ 𝟙 ((X₁ ⊗ Y₁) ⊗ (X₂ ⊗ Y₂) ⊗ X₃ ⊗ Y₃)
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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ (α_ (X₁ ⊗ X₂) X₃ ((Y₁ ⊗ Y₂) ⊗ Y₃)).hom ≫
      (α_ X₁ X₂ (X₃ ⊗ (Y₁ ⊗ Y₂) ⊗ Y₃)).hom ≫
        X₁ ◁ X₂ ◁ (α_ X₃ (Y₁ ⊗ Y₂) Y₃).inv ≫
          X₁ ◁ X₂ ◁ (α_ X₃ Y₁ Y₂).inv ▷ Y₃ ≫
            X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ≫
              X₁ ◁ X₂ ◁ (α_ Y₁ X₃ Y₂).hom ▷ Y₃ ≫
                X₁ ◁ X₂ ◁ (α_ Y₁ (X₃ ⊗ Y₂) Y₃).hom ≫
                  X₁ ◁ X₂ ◁ Y₁ ◁ (β_ X₃ Y₂).hom ▷ Y₃ ≫
                    X₁ ◁ X₂ ◁ (α_ Y₁ (Y₂ ⊗ X₃) Y₃).inv ≫
                      X₁ ◁ X₂ ◁ (α_ Y₁ Y₂ X₃).inv ▷ Y₃ ≫
                        X₁ ◁ X₂ ◁ (α_ (Y₁ ⊗ Y₂) X₃ Y₃).hom ≫
                          (α_ X₁ X₂ ((Y₁ ⊗ Y₂) ⊗ X₃ ⊗ Y₃)).inv ≫
                            (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (X₃ ⊗ Y₃)).inv ≫
                              (α_ ((X₁ ⊗ X₂) ⊗ Y₁ ⊗ Y₂) X₃ Y₃).inv ≫
                                (α_ X₁ X₂ (Y₁ ⊗ Y₂)).hom ▷ X₃ ▷ Y₃ ≫
                                  (α_ X₁ (X₂ ⊗ Y₁ ⊗ Y₂) X₃).hom ▷ Y₃ ≫
                                    (α_ X₁ ((X₂ ⊗ Y₁ ⊗ Y₂) ⊗ X₃) Y₃).hom ≫
                                      X₁ ◁ (α_ X₂ Y₁ Y₂).inv ▷ X₃ ▷ Y₃ ≫
                                        X₁ ◁ (β_ X₂ Y₁).hom ▷ Y₂ ▷ X₃ ▷ Y₃ ≫
                                          X₁ ◁ (α_ Y₁ X₂ Y₂).hom ▷ X₃ ▷ Y₃ ≫
                                            (α_ X₁ ((Y₁ ⊗ X₂ ⊗ Y₂) ⊗ X₃) Y₃).inv ≫
                                              (α_ X₁ (Y₁ ⊗ X₂ ⊗ Y₂) X₃).inv ▷ Y₃ ≫
                                                (α_ X₁ Y₁ (X₂ ⊗ Y₂)).inv ▷ X₃ ▷ Y₃ ≫
                                                  (α_ ((X₁ ⊗ Y₁) ⊗ X₂ ⊗ Y₂) X₃ Y₃).hom ≫
                                                    (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (X₃ ⊗ Y₃)).hom =
    𝟙 (((X₁ ⊗ X₂) ⊗ X₃) ⊗ (Y₁ ⊗ Y₂) ⊗ Y₃) ⊗≫
      X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ⊗≫
        (X₁ ◁ (α_ (X₂ ⊗ Y₁) (X₃ ⊗ Y₂) Y₃).hom ≫
            X₁ ◁ (α_ X₂ Y₁ ((X₃ ⊗ Y₂) ⊗ Y₃)).hom ≫
              X₁ ◁ X₂ ◁ Y₁ ◁ (β_ X₃ Y₂).hom ▷ Y₃ ≫
                X₁ ◁ (α_ X₂ Y₁ ((Y₂ ⊗ X₃) ⊗ Y₃)).inv ≫
                  X₁ ◁ (α_ (X₂ ⊗ Y₁) (Y₂ ⊗ X₃) Y₃).inv ≫
                    X₁ ◁ (α_ (X₂ ⊗ Y₁) Y₂ X₃).inv ▷ Y₃ ≫
                      X₁ ◁ (β_ X₂ Y₁).hom ▷ Y₂ ▷ X₃ ▷ Y₃ ≫ X₁ ◁ (α_ (Y₁ ⊗ X₂) Y₂ X₃).hom ▷ Y₃) ⊗≫
          𝟙 ((X₁ ⊗ Y₁) ⊗ (X₂ ⊗ Y₂) ⊗ X₃ ⊗ Y₃)

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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ (α_ (X₁ ⊗ X₂) X₃ ((Y₁ ⊗ Y₂) ⊗ Y₃)).hom ≫
      (α_ X₁ X₂ (X₃ ⊗ (Y₁ ⊗ Y₂) ⊗ Y₃)).hom ≫
        X₁ ◁ X₂ ◁ (α_ X₃ (Y₁ ⊗ Y₂) Y₃).inv ≫
          X₁ ◁ X₂ ◁ (α_ X₃ Y₁ Y₂).inv ▷ Y₃ ≫
            X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ≫
              X₁ ◁ X₂ ◁ (α_ Y₁ X₃ Y₂).hom ▷ Y₃ ≫
                X₁ ◁ X₂ ◁ (α_ Y₁ (X₃ ⊗ Y₂) Y₃).hom ≫
                  X₁ ◁ X₂ ◁ Y₁ ◁ (β_ X₃ Y₂).hom ▷ Y₃ ≫
                    X₁ ◁ X₂ ◁ (α_ Y₁ (Y₂ ⊗ X₃) Y₃).inv ≫
                      X₁ ◁ X₂ ◁ (α_ Y₁ Y₂ X₃).inv ▷ Y₃ ≫
                        X₁ ◁ X₂ ◁ (α_ (Y₁ ⊗ Y₂) X₃ Y₃).hom ≫
                          (α_ X₁ X₂ ((Y₁ ⊗ Y₂) ⊗ X₃ ⊗ Y₃)).inv ≫
                            (α_ (X₁ ⊗ X₂) (Y₁ ⊗ Y₂) (X₃ ⊗ Y₃)).inv ≫
                              (α_ ((X₁ ⊗ X₂) ⊗ Y₁ ⊗ Y₂) X₃ Y₃).inv ≫
                                (α_ X₁ X₂ (Y₁ ⊗ Y₂)).hom ▷ X₃ ▷ Y₃ ≫
                                  (α_ X₁ (X₂ ⊗ Y₁ ⊗ Y₂) X₃).hom ▷ Y₃ ≫
                                    (α_ X₁ ((X₂ ⊗ Y₁ ⊗ Y₂) ⊗ X₃) Y₃).hom ≫
                                      X₁ ◁ (α_ X₂ Y₁ Y₂).inv ▷ X₃ ▷ Y₃ ≫
                                        X₁ ◁ (β_ X₂ Y₁).hom ▷ Y₂ ▷ X₃ ▷ Y₃ ≫
                                          X₁ ◁ (α_ Y₁ X₂ Y₂).hom ▷ X₃ ▷ Y₃ ≫
                                            (α_ X₁ ((Y₁ ⊗ X₂ ⊗ Y₂) ⊗ X₃) Y₃).inv ≫
                                              (α_ X₁ (Y₁ ⊗ X₂ ⊗ Y₂) X₃).inv ▷ Y₃ ≫
                                                (α_ X₁ Y₁ (X₂ ⊗ Y₂)).inv ▷ X₃ ▷ Y₃ ≫
                                                  (α_ ((X₁ ⊗ Y₁) ⊗ X₂ ⊗ Y₂) X₃ Y₃).hom ≫
                                                    (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (X₃ ⊗ Y₃)).hom =
    𝟙 (((X₁ ⊗ X₂) ⊗ X₃) ⊗ (Y₁ ⊗ Y₂) ⊗ Y₃) ⊗≫
      X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ⊗≫
        (X₁ ◁ (α_ (X₂ ⊗ Y₁) (X₃ ⊗ Y₂) Y₃).hom ≫
            X₁ ◁ (α_ X₂ Y₁ ((X₃ ⊗ Y₂) ⊗ Y₃)).hom ≫
              X₁ ◁ X₂ ◁ Y₁ ◁ (β_ X₃ Y₂).hom ▷ Y₃ ≫
                X₁ ◁ (α_ X₂ Y₁ ((Y₂ ⊗ X₃) ⊗ Y₃)).inv ≫
                  X₁ ◁ (α_ (X₂ ⊗ Y₁) (Y₂ ⊗ X₃) Y₃).inv ≫
                    X₁ ◁ (α_ (X₂ ⊗ Y₁) Y₂ X₃).inv ▷ Y₃ ≫
                      X₁ ◁ (β_ X₂ Y₁).hom ▷ Y₂ ▷ X₃ ▷ Y₃ ≫ X₁ ◁ (α_ (Y₁ ⊗ X₂) Y₂ X₃).hom ▷ Y₃) ⊗≫
          𝟙 ((X₁ ⊗ Y₁) ⊗ (X₂ ⊗ Y₂) ⊗ X₃ ⊗ Y₃)
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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ 𝟙 (((X₁ ⊗ X₂) ⊗ X₃) ⊗ (Y₁ ⊗ Y₂) ⊗ Y₃) ⊗≫
      X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ⊗≫
        X₁ ◁ ((X₂ ⊗ Y₁) ◁ (β_ X₃ Y₂).hom ≫ (β_ X₂ Y₁).hom ▷ (Y₂ ⊗ X₃)) ▷ Y₃ ⊗≫ 𝟙 ((X₁ ⊗ Y₁) ⊗ (X₂ ⊗ Y₂) ⊗ X₃ ⊗ Y₃) =
    ((α_ X₁ X₂ X₃).hom ⊗ (α_ Y₁ Y₂ Y₃).hom) ≫
      ((α_ X₁ (X₂ ⊗ X₃) (Y₁ ⊗ Y₂ ⊗ Y₃)).hom ≫
          X₁ ◁ (α_ (X₂ ⊗ X₃) Y₁ (Y₂ ⊗ Y₃)).inv ≫
            X₁ ◁ (β_ (X₂ ⊗ X₃) Y₁).hom ▷ (Y₂ ⊗ Y₃) ≫
              X₁ ◁ (α_ Y₁ (X₂ ⊗ X₃) (Y₂ ⊗ Y₃)).hom ≫ (α_ X₁ Y₁ ((X₂ ⊗ X₃) ⊗ Y₂ ⊗ Y₃)).inv) ≫
        (X₁ ⊗ Y₁) ◁
          ((α_ 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)
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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ 𝟙 (((X₁ ⊗ X₂) ⊗ X₃) ⊗ (Y₁ ⊗ Y₂) ⊗ Y₃) ⊗≫
      X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ⊗≫
        X₁ ◁ ((β_ X₂ Y₁).hom ▷ (X₃ ⊗ Y₂) ≫ (Y₁ ⊗ X₂) ◁ (β_ X₃ Y₂).hom) ▷ Y₃ ⊗≫ 𝟙 ((X₁ ⊗ Y₁) ⊗ (X₂ ⊗ Y₂) ⊗ X₃ ⊗ Y₃) =
    ((α_ X₁ X₂ X₃).hom ⊗ (α_ Y₁ Y₂ Y₃).hom) ≫
      ((α_ X₁ (X₂ ⊗ X₃) (Y₁ ⊗ Y₂ ⊗ Y₃)).hom ≫
          X₁ ◁ (α_ (X₂ ⊗ X₃) Y₁ (Y₂ ⊗ Y₃)).inv ≫
            X₁ ◁ (β_ (X₂ ⊗ X₃) Y₁).hom ▷ (Y₂ ⊗ Y₃) ≫
              X₁ ◁ (α_ Y₁ (X₂ ⊗ X₃) (Y₂ ⊗ Y₃)).hom ≫ (α_ X₁ Y₁ ((X₂ ⊗ X₃) ⊗ Y₂ ⊗ Y₃)).inv) ≫
        (X₁ ⊗ Y₁) ◁
          ((α_ 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)

tactic: simp
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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ 𝟙 (((X₁ ⊗ X₂) ⊗ X₃) ⊗ (Y₁ ⊗ Y₂) ⊗ Y₃) ⊗≫
      X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ⊗≫
        X₁ ◁ ((β_ X₂ Y₁).hom ▷ (X₃ ⊗ Y₂) ≫ (Y₁ ⊗ X₂) ◁ (β_ X₃ Y₂).hom) ▷ Y₃ ⊗≫ 𝟙 ((X₁ ⊗ Y₁) ⊗ (X₂ ⊗ Y₂) ⊗ X₃ ⊗ Y₃) =
    ((α_ X₁ X₂ X₃).hom ⊗ (α_ Y₁ Y₂ Y₃).hom) ≫
      ((α_ X₁ (X₂ ⊗ X₃) (Y₁ ⊗ Y₂ ⊗ Y₃)).hom ≫
          X₁ ◁ (α_ (X₂ ⊗ X₃) Y₁ (Y₂ ⊗ Y₃)).inv ≫
            X₁ ◁ (β_ (X₂ ⊗ X₃) Y₁).hom ▷ (Y₂ ⊗ Y₃) ≫
              X₁ ◁ (α_ Y₁ (X₂ ⊗ X₃) (Y₂ ⊗ Y₃)).hom ≫ (α_ X₁ Y₁ ((X₂ ⊗ X₃) ⊗ Y₂ ⊗ Y₃)).inv) ≫
        (X₁ ⊗ Y₁) ◁
          ((α_ 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)
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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ 𝟙 (((X₁ ⊗ X₂) ⊗ X₃) ⊗ (Y₁ ⊗ Y₂) ⊗ Y₃) ⊗≫
      X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ⊗≫
        (X₁ ◁ (α_ (X₂ ⊗ Y₁) X₃ Y₂).inv ▷ Y₃ ≫
            X₁ ◁ (β_ X₂ Y₁).hom ▷ X₃ ▷ Y₂ ▷ Y₃ ≫
              X₁ ◁ (α_ (Y₁ ⊗ X₂) X₃ Y₂).hom ▷ Y₃ ≫
                X₁ ◁ (α_ (Y₁ ⊗ X₂) (X₃ ⊗ Y₂) Y₃).hom ≫
                  X₁ ◁ (α_ Y₁ X₂ ((X₃ ⊗ Y₂) ⊗ Y₃)).hom ≫
                    X₁ ◁ Y₁ ◁ X₂ ◁ (β_ X₃ Y₂).hom ▷ Y₃ ≫
                      X₁ ◁ (α_ Y₁ X₂ ((Y₂ ⊗ X₃) ⊗ Y₃)).inv ≫ X₁ ◁ (α_ (Y₁ ⊗ X₂) (Y₂ ⊗ X₃) Y₃).inv) ⊗≫
          𝟙 ((X₁ ⊗ Y₁) ⊗ (X₂ ⊗ Y₂) ⊗ X₃ ⊗ Y₃) =
    ((α_ X₁ X₂ X₃).hom ⊗ (α_ Y₁ Y₂ Y₃).hom) ≫
      (α_ X₁ (X₂ ⊗ X₃) (Y₁ ⊗ Y₂ ⊗ Y₃)).hom ≫
        X₁ ◁ (α_ (X₂ ⊗ X₃) Y₁ (Y₂ ⊗ Y₃)).inv ≫
          X₁ ◁ (α_ ((X₂ ⊗ X₃) ⊗ Y₁) Y₂ Y₃).inv ≫
            X₁ ◁ (α_ X₂ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ≫
              X₁ ◁ (α_ X₂ (X₃ ⊗ Y₁) Y₂).hom ▷ Y₃ ≫
                X₁ ◁ (α_ X₂ ((X₃ ⊗ Y₁) ⊗ Y₂) Y₃).hom ≫
                  X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ≫
                    X₁ ◁ (α_ X₂ ((Y₁ ⊗ X₃) ⊗ Y₂) Y₃).inv ≫
                      X₁ ◁ (α_ X₂ (Y₁ ⊗ X₃) Y₂).inv ▷ Y₃ ≫
                        X₁ ◁ (α_ X₂ Y₁ X₃).inv ▷ Y₂ ▷ Y₃ ≫
                          X₁ ◁ (β_ X₂ Y₁).hom ▷ X₃ ▷ Y₂ ▷ Y₃ ≫
                            X₁ ◁ (α_ Y₁ X₂ X₃).hom ▷ Y₂ ▷ Y₃ ≫
                              X₁ ◁ (α_ (Y₁ ⊗ X₂ ⊗ X₃) Y₂ Y₃).hom ≫
                                X₁ ◁ (α_ Y₁ (X₂ ⊗ X₃) (Y₂ ⊗ Y₃)).hom ≫
                                  X₁ ◁ Y₁ ◁ (α_ X₂ X₃ (Y₂ ⊗ Y₃)).hom ≫
                                    X₁ ◁ Y₁ ◁ X₂ ◁ (α_ X₃ Y₂ Y₃).inv ≫
                                      X₁ ◁ Y₁ ◁ X₂ ◁ (β_ X₃ Y₂).hom ▷ Y₃ ≫
                                        X₁ ◁ Y₁ ◁ X₂ ◁ (α_ Y₂ X₃ Y₃).hom ≫
                                          X₁ ◁ Y₁ ◁ (α_ X₂ Y₂ (X₃ ⊗ Y₃)).inv ≫ (α_ X₁ Y₁ ((X₂ ⊗ Y₂) ⊗ X₃ ⊗ Y₃)).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₂ X₃ Y₁ Y₂ Y₃ : C
⊢ 𝟙 (((X₁ ⊗ X₂) ⊗ X₃) ⊗ (Y₁ ⊗ Y₂) ⊗ Y₃) ⊗≫
      X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ⊗≫
        (X₁ ◁ (α_ (X₂ ⊗ Y₁) X₃ Y₂).inv ▷ Y₃ ≫
            X₁ ◁ (β_ X₂ Y₁).hom ▷ X₃ ▷ Y₂ ▷ Y₃ ≫
              X₁ ◁ (α_ (Y₁ ⊗ X₂) X₃ Y₂).hom ▷ Y₃ ≫
                X₁ ◁ (α_ (Y₁ ⊗ X₂) (X₃ ⊗ Y₂) Y₃).hom ≫
                  X₁ ◁ (α_ Y₁ X₂ ((X₃ ⊗ Y₂) ⊗ Y₃)).hom ≫
                    X₁ ◁ Y₁ ◁ X₂ ◁ (β_ X₃ Y₂).hom ▷ Y₃ ≫
                      X₁ ◁ (α_ Y₁ X₂ ((Y₂ ⊗ X₃) ⊗ Y₃)).inv ≫ X₁ ◁ (α_ (Y₁ ⊗ X₂) (Y₂ ⊗ X₃) Y₃).inv) ⊗≫
          𝟙 ((X₁ ⊗ Y₁) ⊗ (X₂ ⊗ Y₂) ⊗ X₃ ⊗ Y₃) =
    ((α_ X₁ X₂ X₃).hom ⊗ (α_ Y₁ Y₂ Y₃).hom) ≫
      (α_ X₁ (X₂ ⊗ X₃) (Y₁ ⊗ Y₂ ⊗ Y₃)).hom ≫
        X₁ ◁ (α_ (X₂ ⊗ X₃) Y₁ (Y₂ ⊗ Y₃)).inv ≫
          X₁ ◁ (α_ ((X₂ ⊗ X₃) ⊗ Y₁) Y₂ Y₃).inv ≫
            X₁ ◁ (α_ X₂ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ≫
              X₁ ◁ (α_ X₂ (X₃ ⊗ Y₁) Y₂).hom ▷ Y₃ ≫
                X₁ ◁ (α_ X₂ ((X₃ ⊗ Y₁) ⊗ Y₂) Y₃).hom ≫
                  X₁ ◁ X₂ ◁ (β_ X₃ Y₁).hom ▷ Y₂ ▷ Y₃ ≫
                    X₁ ◁ (α_ X₂ ((Y₁ ⊗ X₃) ⊗ Y₂) Y₃).inv ≫
                      X₁ ◁ (α_ X₂ (Y₁ ⊗ X₃) Y₂).inv ▷ Y₃ ≫
                        X₁ ◁ (α_ X₂ Y₁ X₃).inv ▷ Y₂ ▷ Y₃ ≫
                          X₁ ◁ (β_ X₂ Y₁).hom ▷ X₃ ▷ Y₂ ▷ Y₃ ≫
                            X₁ ◁ (α_ Y₁ X₂ X₃).hom ▷ Y₂ ▷ Y₃ ≫
                              X₁ ◁ (α_ (Y₁ ⊗ X₂ ⊗ X₃) Y₂ Y₃).hom ≫
                                X₁ ◁ (α_ Y₁ (X₂ ⊗ X₃) (Y₂ ⊗ Y₃)).hom ≫
                                  X₁ ◁ Y₁ ◁ (α_ X₂ X₃ (Y₂ ⊗ Y₃)).hom ≫
                                    X₁ ◁ Y₁ ◁ X₂ ◁ (α_ X₃ Y₂ Y₃).inv ≫
                                      X₁ ◁ Y₁ ◁ X₂ ◁ (β_ X₃ Y₂).hom ▷ Y₃ ≫
                                        X₁ ◁ Y₁ ◁ X₂ ◁ (α_ Y₂ X₃ Y₃).hom ≫
                                          X₁ ◁ Y₁ ◁ (α_ X₂ Y₂ (X₃ ⊗ Y₃)).inv ≫ (α_ X₁ Y₁ ((X₂ ⊗ Y₂) ⊗ X₃ ⊗ Y₃)).inv
state_after: no goals