Theorem: Comon_.tensorObj_comul
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

tactic: rw [tensorObj_comul']
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ (A ⊗ B).comul = (A.comul ⊗ B.comul) ≫ tensor_μ C (A.X, A.X) (B.X, B.X)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ (A.comul ⊗ B.comul) ≫ (tensor_μ Cᵒᵖ ({ unop := A.X }, { unop := B.X }) ({ unop := A.X }, { unop := B.X })).unop =
    (A.comul ⊗ B.comul) ≫ tensor_μ C (A.X, A.X) (B.X, B.X)

tactic: congr
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ (A.comul ⊗ B.comul) ≫ (tensor_μ Cᵒᵖ ({ unop := A.X }, { unop := B.X }) ({ unop := A.X }, { unop := B.X })).unop =
    (A.comul ⊗ B.comul) ≫ tensor_μ C (A.X, A.X) (B.X, B.X)
state_after: case e_a.e_f
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ tensor_μ Cᵒᵖ ({ unop := A.X }, { unop := B.X }) ({ unop := A.X }, { unop := B.X }) =
    {
      unop :=
        (α_ (A.X, A.X).1 (A.X, A.X).2 ((B.X, B.X).1 ⊗ (B.X, B.X).2)).hom ≫
          (A.X, A.X).1 ◁ (α_ (A.X, A.X).2 (B.X, B.X).1 (B.X, B.X).2).inv ≫
            (A.X, A.X).1 ◁ (β_ (A.X, A.X).2 (B.X, B.X).1).hom ▷ (B.X, B.X).2 ≫
              (A.X, A.X).1 ◁ (α_ (B.X, B.X).1 (A.X, A.X).2 (B.X, B.X).2).hom ≫
                (α_ (A.X, A.X).1 (B.X, B.X).1 ((A.X, A.X).2 ⊗ (B.X, B.X).2)).inv }

tactic: simp only [tensor_μ, unop_tensorObj, unop_op]
state_before: case e_a.e_f
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ tensor_μ Cᵒᵖ ({ unop := A.X }, { unop := B.X }) ({ unop := A.X }, { unop := B.X }) =
    {
      unop :=
        (α_ (A.X, A.X).1 (A.X, A.X).2 ((B.X, B.X).1 ⊗ (B.X, B.X).2)).hom ≫
          (A.X, A.X).1 ◁ (α_ (A.X, A.X).2 (B.X, B.X).1 (B.X, B.X).2).inv ≫
            (A.X, A.X).1 ◁ (β_ (A.X, A.X).2 (B.X, B.X).1).hom ▷ (B.X, B.X).2 ≫
              (A.X, A.X).1 ◁ (α_ (B.X, B.X).1 (A.X, A.X).2 (B.X, B.X).2).hom ≫
                (α_ (A.X, A.X).1 (B.X, B.X).1 ((A.X, A.X).2 ⊗ (B.X, B.X).2)).inv }
state_after: case e_a.e_f
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ (α_ { unop := A.X } { unop := B.X } ({ unop := A.X } ⊗ { unop := B.X })).hom ≫
      { unop := A.X } ◁ (α_ { unop := B.X } { unop := A.X } { unop := B.X }).inv ≫
        { unop := A.X } ◁ (β_ { unop := B.X } { unop := A.X }).hom ▷ { unop := B.X } ≫
          { unop := A.X } ◁ (α_ { unop := A.X } { unop := B.X } { unop := B.X }).hom ≫
            (α_ { unop := A.X } { unop := A.X } ({ unop := B.X } ⊗ { unop := B.X })).inv =
    {
      unop :=
        (α_ A.X A.X (B.X ⊗ B.X)).hom ≫
          A.X ◁ (α_ A.X B.X B.X).inv ≫
            A.X ◁ (β_ A.X B.X).hom ▷ B.X ≫ A.X ◁ (α_ B.X A.X B.X).hom ≫ (α_ A.X B.X (A.X ⊗ B.X)).inv }

tactic: apply Quiver.Hom.unop_inj
state_before: case e_a.e_f
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ (α_ { unop := A.X } { unop := B.X } ({ unop := A.X } ⊗ { unop := B.X })).hom ≫
      { unop := A.X } ◁ (α_ { unop := B.X } { unop := A.X } { unop := B.X }).inv ≫
        { unop := A.X } ◁ (β_ { unop := B.X } { unop := A.X }).hom ▷ { unop := B.X } ≫
          { unop := A.X } ◁ (α_ { unop := A.X } { unop := B.X } { unop := B.X }).hom ≫
            (α_ { unop := A.X } { unop := A.X } ({ unop := B.X } ⊗ { unop := B.X })).inv =
    {
      unop :=
        (α_ A.X A.X (B.X ⊗ B.X)).hom ≫
          A.X ◁ (α_ A.X B.X B.X).inv ≫
            A.X ◁ (β_ A.X B.X).hom ▷ B.X ≫ A.X ◁ (α_ B.X A.X B.X).hom ≫ (α_ A.X B.X (A.X ⊗ B.X)).inv }
state_after: case e_a.e_f.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ ((α_ { unop := A.X } { unop := B.X } ({ unop := A.X } ⊗ { unop := B.X })).hom ≫
        { unop := A.X } ◁ (α_ { unop := B.X } { unop := A.X } { unop := B.X }).inv ≫
          { unop := A.X } ◁ (β_ { unop := B.X } { unop := A.X }).hom ▷ { unop := B.X } ≫
            { unop := A.X } ◁ (α_ { unop := A.X } { unop := B.X } { unop := B.X }).hom ≫
              (α_ { unop := A.X } { unop := A.X } ({ unop := B.X } ⊗ { unop := B.X })).inv).unop =
    Quiver.Hom.unop
      {
        unop :=
          (α_ A.X A.X (B.X ⊗ B.X)).hom ≫
            A.X ◁ (α_ A.X B.X B.X).inv ≫
              A.X ◁ (β_ A.X B.X).hom ▷ B.X ≫ A.X ◁ (α_ B.X A.X B.X).hom ≫ (α_ A.X B.X (A.X ⊗ B.X)).inv }

tactic: dsimp [op_tensorObj, op_associator]
state_before: case e_a.e_f.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ ((α_ { unop := A.X } { unop := B.X } ({ unop := A.X } ⊗ { unop := B.X })).hom ≫
        { unop := A.X } ◁ (α_ { unop := B.X } { unop := A.X } { unop := B.X }).inv ≫
          { unop := A.X } ◁ (β_ { unop := B.X } { unop := A.X }).hom ▷ { unop := B.X } ≫
            { unop := A.X } ◁ (α_ { unop := A.X } { unop := B.X } { unop := B.X }).hom ≫
              (α_ { unop := A.X } { unop := A.X } ({ unop := B.X } ⊗ { unop := B.X })).inv).unop =
    Quiver.Hom.unop
      {
        unop :=
          (α_ A.X A.X (B.X ⊗ B.X)).hom ≫
            A.X ◁ (α_ A.X B.X B.X).inv ≫
              A.X ◁ (β_ A.X B.X).hom ▷ B.X ≫ A.X ◁ (α_ B.X A.X B.X).hom ≫ (α_ A.X B.X (A.X ⊗ B.X)).inv }
state_after: case e_a.e_f.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ ((((α_ A.X A.X (B.X ⊗ B.X)).hom ≫ A.X ◁ (α_ A.X B.X B.X).inv) ≫ A.X ◁ (β_ A.X B.X).hom ▷ B.X) ≫
        A.X ◁ (α_ B.X A.X B.X).hom) ≫
      (α_ A.X B.X (A.X ⊗ B.X)).inv =
    (α_ A.X A.X (B.X ⊗ B.X)).hom ≫
      A.X ◁ (α_ A.X B.X B.X).inv ≫
        A.X ◁ (β_ A.X B.X).hom ▷ B.X ≫ A.X ◁ (α_ B.X A.X B.X).hom ≫ (α_ A.X B.X (A.X ⊗ B.X)).inv

tactic: rw [Category.assoc, Category.assoc, Category.assoc]
state_before: case e_a.e_f.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ ((((α_ A.X A.X (B.X ⊗ B.X)).hom ≫ A.X ◁ (α_ A.X B.X B.X).inv) ≫ A.X ◁ (β_ A.X B.X).hom ▷ B.X) ≫
        A.X ◁ (α_ B.X A.X B.X).hom) ≫
      (α_ A.X B.X (A.X ⊗ B.X)).inv =
    (α_ A.X A.X (B.X ⊗ B.X)).hom ≫
      A.X ◁ (α_ A.X B.X B.X).inv ≫
        A.X ◁ (β_ A.X B.X).hom ▷ B.X ≫ A.X ◁ (α_ B.X A.X B.X).hom ≫ (α_ A.X B.X (A.X ⊗ B.X)).inv
state_after: no goals