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

full_name: CategoryTheory.BraidedCategory
code: /-- A braided monoidal category is a monoidal category equipped with a braiding isomorphism
`β_ X Y : X ⊗ Y ≅ Y ⊗ X`
which is natural in both arguments,
and also satisfies the two hexagon identities.
-/
class BraidedCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] where
  /-- The braiding natural isomorphism. -/
  braiding : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X
  braiding_naturality_right :
    ∀ (X : C) {Y Z : C} (f : Y ⟶ Z),
      X ◁ f ≫ (braiding X Z).hom = (braiding X Y).hom ≫ f ▷ X := by
    aesop_cat
  braiding_naturality_left :
    ∀ {X Y : C} (f : X ⟶ Y) (Z : C),
      f ▷ Z ≫ (braiding Y Z).hom = (braiding X Z).hom ≫ Z ◁ f := by
    aesop_cat
  /-- The first hexagon identity. -/
  hexagon_forward :
    ∀ X Y Z : C,
      (α_ X Y Z).hom ≫ (braiding X (Y ⊗ Z)).hom ≫ (α_ Y Z X).hom =
        ((braiding X Y).hom ▷ Z) ≫ (α_ Y X Z).hom ≫ (Y ◁ (braiding X Z).hom) := by
    aesop_cat
  /-- The second hexagon identity. -/
  hexagon_reverse :
    ∀ X Y Z : C,
      (α_ X Y Z).inv ≫ (braiding (X ⊗ Y) Z).hom ≫ (α_ Z X Y).inv =
        (X ◁ (braiding Y Z).hom) ≫ (α_ X Z Y).inv ≫ ((braiding X Z).hom ▷ Y) := by
    aesop_cat
goal: Type (max u v)

full_name: CategoryTheory.BraidedCategory.hexagon_reverse
code: /-- A braided monoidal category is a monoidal category equipped with a braiding isomorphism
`β_ X Y : X ⊗ Y ≅ Y ⊗ X`
which is natural in both arguments,
and also satisfies the two hexagon identities.
-/
class BraidedCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] where
  /-- The braiding natural isomorphism. -/
  braiding : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X
  braiding_naturality_right :
    ∀ (X : C) {Y Z : C} (f : Y ⟶ Z),
      X ◁ f ≫ (braiding X Z).hom = (braiding X Y).hom ≫ f ▷ X := by
    aesop_cat
  braiding_naturality_left :
    ∀ {X Y : C} (f : X ⟶ Y) (Z : C),
      f ▷ Z ≫ (braiding Y Z).hom = (braiding X Z).hom ≫ Z ◁ f := by
    aesop_cat
  /-- The first hexagon identity. -/
  hexagon_forward :
    ∀ X Y Z : C,
      (α_ X Y Z).hom ≫ (braiding X (Y ⊗ Z)).hom ≫ (α_ Y Z X).hom =
        ((braiding X Y).hom ▷ Z) ≫ (α_ Y X Z).hom ≫ (Y ◁ (braiding X Z).hom) := by
    aesop_cat
  /-- The second hexagon identity. -/
  hexagon_reverse :
    ∀ X Y Z : C,
      (α_ X Y Z).inv ≫ (braiding (X ⊗ Y) Z).hom ≫ (α_ Z X Y).inv =
        (X ◁ (braiding Y Z).hom) ≫ (α_ X Z Y).inv ≫ ((braiding X Z).hom ▷ Y) := by
    aesop_cat
goal: (α_ X Y Z).inv ≫ (β_ (X ⊗ Y) Z).hom ≫ (α_ Z X Y).inv = X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫ (β_ X Z).hom ▷ Y

full_name: CategoryTheory.BraidedCategory.hexagon_forward
code: /-- A braided monoidal category is a monoidal category equipped with a braiding isomorphism
`β_ X Y : X ⊗ Y ≅ Y ⊗ X`
which is natural in both arguments,
and also satisfies the two hexagon identities.
-/
class BraidedCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] where
  /-- The braiding natural isomorphism. -/
  braiding : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X
  braiding_naturality_right :
    ∀ (X : C) {Y Z : C} (f : Y ⟶ Z),
      X ◁ f ≫ (braiding X Z).hom = (braiding X Y).hom ≫ f ▷ X := by
    aesop_cat
  braiding_naturality_left :
    ∀ {X Y : C} (f : X ⟶ Y) (Z : C),
      f ▷ Z ≫ (braiding Y Z).hom = (braiding X Z).hom ≫ Z ◁ f := by
    aesop_cat
  /-- The first hexagon identity. -/
  hexagon_forward :
    ∀ X Y Z : C,
      (α_ X Y Z).hom ≫ (braiding X (Y ⊗ Z)).hom ≫ (α_ Y Z X).hom =
        ((braiding X Y).hom ▷ Z) ≫ (α_ Y X Z).hom ≫ (Y ◁ (braiding X Z).hom) := by
    aesop_cat
  /-- The second hexagon identity. -/
  hexagon_reverse :
    ∀ X Y Z : C,
      (α_ X Y Z).inv ≫ (braiding (X ⊗ Y) Z).hom ≫ (α_ Z X Y).inv =
        (X ◁ (braiding Y Z).hom) ≫ (α_ X Z Y).inv ≫ ((braiding X Z).hom ▷ Y) := by
    aesop_cat
goal: (α_ X Y Z).hom ≫ (β_ X (Y ⊗ Z)).hom ≫ (α_ Y Z X).hom = (β_ X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (β_ X Z).hom

full_name: CategoryTheory.BraidedCategory.braiding
code: /-- A braided monoidal category is a monoidal category equipped with a braiding isomorphism
`β_ X Y : X ⊗ Y ≅ Y ⊗ X`
which is natural in both arguments,
and also satisfies the two hexagon identities.
-/
class BraidedCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] where
  /-- The braiding natural isomorphism. -/
  braiding : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X
  braiding_naturality_right :
    ∀ (X : C) {Y Z : C} (f : Y ⟶ Z),
      X ◁ f ≫ (braiding X Z).hom = (braiding X Y).hom ≫ f ▷ X := by
    aesop_cat
  braiding_naturality_left :
    ∀ {X Y : C} (f : X ⟶ Y) (Z : C),
      f ▷ Z ≫ (braiding Y Z).hom = (braiding X Z).hom ≫ Z ◁ f := by
    aesop_cat
  /-- The first hexagon identity. -/
  hexagon_forward :
    ∀ X Y Z : C,
      (α_ X Y Z).hom ≫ (braiding X (Y ⊗ Z)).hom ≫ (α_ Y Z X).hom =
        ((braiding X Y).hom ▷ Z) ≫ (α_ Y X Z).hom ≫ (Y ◁ (braiding X Z).hom) := by
    aesop_cat
  /-- The second hexagon identity. -/
  hexagon_reverse :
    ∀ X Y Z : C,
      (α_ X Y Z).inv ≫ (braiding (X ⊗ Y) Z).hom ≫ (α_ Z X Y).inv =
        (X ◁ (braiding Y Z).hom) ≫ (α_ X Z Y).inv ≫ ((braiding X Z).hom ▷ Y) := by
    aesop_cat
goal: X ⊗ Y ≅ Y ⊗ X

full_name: CategoryTheory.BraidedCategory.braiding_naturality_left
code: /-- A braided monoidal category is a monoidal category equipped with a braiding isomorphism
`β_ X Y : X ⊗ Y ≅ Y ⊗ X`
which is natural in both arguments,
and also satisfies the two hexagon identities.
-/
class BraidedCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] where
  /-- The braiding natural isomorphism. -/
  braiding : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X
  braiding_naturality_right :
    ∀ (X : C) {Y Z : C} (f : Y ⟶ Z),
      X ◁ f ≫ (braiding X Z).hom = (braiding X Y).hom ≫ f ▷ X := by
    aesop_cat
  braiding_naturality_left :
    ∀ {X Y : C} (f : X ⟶ Y) (Z : C),
      f ▷ Z ≫ (braiding Y Z).hom = (braiding X Z).hom ≫ Z ◁ f := by
    aesop_cat
  /-- The first hexagon identity. -/
  hexagon_forward :
    ∀ X Y Z : C,
      (α_ X Y Z).hom ≫ (braiding X (Y ⊗ Z)).hom ≫ (α_ Y Z X).hom =
        ((braiding X Y).hom ▷ Z) ≫ (α_ Y X Z).hom ≫ (Y ◁ (braiding X Z).hom) := by
    aesop_cat
  /-- The second hexagon identity. -/
  hexagon_reverse :
    ∀ X Y Z : C,
      (α_ X Y Z).inv ≫ (braiding (X ⊗ Y) Z).hom ≫ (α_ Z X Y).inv =
        (X ◁ (braiding Y Z).hom) ≫ (α_ X Z Y).inv ≫ ((braiding X Z).hom ▷ Y) := by
    aesop_cat
goal: f ▷ Z ≫ (β_ Y Z).hom = (β_ X Z).hom ≫ Z ◁ f

full_name: CategoryTheory.BraidedCategory.braiding_naturality_right
code: /-- A braided monoidal category is a monoidal category equipped with a braiding isomorphism
`β_ X Y : X ⊗ Y ≅ Y ⊗ X`
which is natural in both arguments,
and also satisfies the two hexagon identities.
-/
class BraidedCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] where
  /-- The braiding natural isomorphism. -/
  braiding : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X
  braiding_naturality_right :
    ∀ (X : C) {Y Z : C} (f : Y ⟶ Z),
      X ◁ f ≫ (braiding X Z).hom = (braiding X Y).hom ≫ f ▷ X := by
    aesop_cat
  braiding_naturality_left :
    ∀ {X Y : C} (f : X ⟶ Y) (Z : C),
      f ▷ Z ≫ (braiding Y Z).hom = (braiding X Z).hom ≫ Z ◁ f := by
    aesop_cat
  /-- The first hexagon identity. -/
  hexagon_forward :
    ∀ X Y Z : C,
      (α_ X Y Z).hom ≫ (braiding X (Y ⊗ Z)).hom ≫ (α_ Y Z X).hom =
        ((braiding X Y).hom ▷ Z) ≫ (α_ Y X Z).hom ≫ (Y ◁ (braiding X Z).hom) := by
    aesop_cat
  /-- The second hexagon identity. -/
  hexagon_reverse :
    ∀ X Y Z : C,
      (α_ X Y Z).inv ≫ (braiding (X ⊗ Y) Z).hom ≫ (α_ Z X Y).inv =
        (X ◁ (braiding Y Z).hom) ≫ (α_ X Z Y).inv ≫ ((braiding X Z).hom ▷ Y) := by
    aesop_cat
goal: X ◁ f ≫ (β_ X Z).hom = (β_ X Y).hom ≫ f ▷ X

full_name: CategoryTheory._aux_Mathlib_CategoryTheory_Monoidal_Braided_Basic___macroRules_CategoryTheory_termβ__1
code: @[inherit_doc]
notation "β_" => BraidedCategory.braiding
goal: Lean.Macro

full_name: CategoryTheory._aux_Mathlib_CategoryTheory_Monoidal_Braided_Basic___unexpand_CategoryTheory_BraidedCategory_braiding_1
code: @[inherit_doc]
notation "β_" => BraidedCategory.braiding
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.BraidedCategory.braiding_tensor_left
code: @[simp, reassoc]
theorem braiding_tensor_left (X Y Z : C) :
    (β_ (X ⊗ Y) Z).hom  =
      (α_ X Y Z).hom ≫ X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫
        (β_ X Z).hom ▷ Y ≫ (α_ Z X Y).hom 
goal: (β_ (X ⊗ Y) Z).hom = (α_ X Y Z).hom ≫ X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫ (β_ X Z).hom ▷ Y ≫ (α_ Z X Y).hom

full_name: CategoryTheory.BraidedCategory.braiding_tensor_right
code: @[simp, reassoc]
theorem braiding_tensor_right (X Y Z : C) :
    (β_ X (Y ⊗ Z)).hom  =
      (α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫
        Y ◁ (β_ X Z).hom ≫ (α_ Y Z X).inv 
goal: (β_ X (Y ⊗ Z)).hom = (α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (β_ X Z).hom ≫ (α_ Y Z X).inv

full_name: CategoryTheory.BraidedCategory.braiding_inv_tensor_left
code: @[simp, reassoc]
theorem braiding_inv_tensor_left (X Y Z : C) :
    (β_ (X ⊗ Y) Z).inv  =
      (α_ Z X Y).inv ≫ (β_ X Z).inv ▷ Y ≫ (α_ X Z Y).hom ≫
        X ◁ (β_ Y Z).inv ≫ (α_ X Y Z).inv 
goal: (β_ (X ⊗ Y) Z).inv = (α_ Z X Y).inv ≫ (β_ X Z).inv ▷ Y ≫ (α_ X Z Y).hom ≫ X ◁ (β_ Y Z).inv ≫ (α_ X Y Z).inv

full_name: CategoryTheory.BraidedCategory.braiding_inv_tensor_right
code: @[simp, reassoc]
theorem braiding_inv_tensor_right (X Y Z : C) :
    (β_ X (Y ⊗ Z)).inv  =
      (α_ Y Z X).hom ≫ Y ◁ (β_ X Z).inv ≫ (α_ Y X Z).inv ≫
        (β_ X Y).inv ▷ Z ≫ (α_ X Y Z).hom 
goal: (β_ X (Y ⊗ Z)).inv = (α_ Y Z X).hom ≫ Y ◁ (β_ X Z).inv ≫ (α_ Y X Z).inv ≫ (β_ X Y).inv ▷ Z ≫ (α_ X Y Z).hom

full_name: CategoryTheory.BraidedCategory.braiding_naturality
code: @[reassoc (attr := simp)]
theorem braiding_naturality {X X' Y Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y') :
    (f ⊗ g) ≫ (braiding Y Y').hom = (braiding X X').hom ≫ (g ⊗ f) 
goal: (f ⊗ g) ≫ (β_ Y Y').hom = (β_ X X').hom ≫ (g ⊗ f)

full_name: CategoryTheory.BraidedCategory.braiding_inv_naturality_right
code: @[reassoc (attr := simp)]
theorem braiding_inv_naturality_right (X : C) {Y Z : C} (f : Y ⟶ Z) :
    X ◁ f ≫ (β_ Z X).inv = (β_ Y X).inv ≫ f ▷ X 
goal: X ◁ f ≫ (β_ Z X).inv = (β_ Y X).inv ≫ f ▷ X

full_name: CategoryTheory.BraidedCategory.braiding_inv_naturality_left
code: @[reassoc (attr := simp)]
theorem braiding_inv_naturality_left {X Y : C} (f : X ⟶ Y) (Z : C) :
    f ▷ Z ≫ (β_ Z Y).inv = (β_ Z X).inv ≫ Z ◁ f 
goal: f ▷ Z ≫ (β_ Z Y).inv = (β_ Z X).inv ≫ Z ◁ f

full_name: CategoryTheory.BraidedCategory.braiding_inv_naturality
code: @[reassoc (attr := simp)]
theorem braiding_inv_naturality {X X' Y Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y') :
    (f ⊗ g) ≫ (β_ Y' Y).inv = (β_ X' X).inv ≫ (g ⊗ f) 
goal: (f ⊗ g) ≫ (β_ Y' Y).inv = (β_ X' X).inv ≫ (g ⊗ f)

full_name: CategoryTheory.BraidedCategory.yang_baxter
code: @[reassoc]
theorem yang_baxter (X Y Z : C) :
    (α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫
    Y ◁ (β_ X Z).hom ≫ (α_ Y Z X).inv ≫ (β_ Y Z).hom ▷ X ≫ (α_ Z Y X).hom =
      X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫ (β_ X Z).hom ▷ Y ≫
      (α_ Z X Y).hom ≫ Z ◁ (β_ X Y).hom 
goal: (α_ X Y Z).inv ≫
    (β_ X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (β_ X Z).hom ≫ (α_ Y Z X).inv ≫ (β_ Y Z).hom ▷ X ≫ (α_ Z Y X).hom =
  X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫ (β_ X Z).hom ▷ Y ≫ (α_ Z X Y).hom ≫ Z ◁ (β_ X Y).hom

full_name: CategoryTheory.BraidedCategory.yang_baxter'
code: theorem yang_baxter' (X Y Z : C) :
    (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X =
      𝟙 _ ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 _ 
goal: (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X =
  𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)

full_name: CategoryTheory.BraidedCategory.yang_baxter_iso
code: theorem yang_baxter_iso (X Y Z : C) :
    (α_ X Y Z).symm ≪≫ whiskerRightIso (β_ X Y) Z ≪≫ α_ Y X Z ≪≫
    whiskerLeftIso Y (β_ X Z) ≪≫ (α_ Y Z X).symm ≪≫
    whiskerRightIso (β_ Y Z) X ≪≫ (α_ Z Y X) =
      whiskerLeftIso X (β_ Y Z) ≪≫ (α_ X Z Y).symm ≪≫
      whiskerRightIso (β_ X Z) Y ≪≫ α_ Z X Y ≪≫
      whiskerLeftIso Z (β_ X Y) 
goal: (α_ X Y Z).symm ≪≫
    CategoryTheory.MonoidalCategory.whiskerRightIso (β_ X Y) Z ≪≫
      α_ Y X Z ≪≫
        CategoryTheory.MonoidalCategory.whiskerLeftIso Y (β_ X Z) ≪≫
          (α_ Y Z X).symm ≪≫ CategoryTheory.MonoidalCategory.whiskerRightIso (β_ Y Z) X ≪≫ α_ Z Y X =
  CategoryTheory.MonoidalCategory.whiskerLeftIso X (β_ Y Z) ≪≫
    (α_ X Z Y).symm ≪≫
      CategoryTheory.MonoidalCategory.whiskerRightIso (β_ X Z) Y ≪≫
        α_ Z X Y ≪≫ CategoryTheory.MonoidalCategory.whiskerLeftIso Z (β_ X Y)

full_name: CategoryTheory.BraidedCategory.hexagon_forward_iso
code: theorem hexagon_forward_iso (X Y Z : C) :
    α_ X Y Z ≪≫ β_ X (Y ⊗ Z) ≪≫ α_ Y Z X =
      whiskerRightIso (β_ X Y) Z ≪≫ α_ Y X Z ≪≫ whiskerLeftIso Y (β_ X Z) 
goal: α_ X Y Z ≪≫ β_ X (Y ⊗ Z) ≪≫ α_ Y Z X =
  CategoryTheory.MonoidalCategory.whiskerRightIso (β_ X Y) Z ≪≫
    α_ Y X Z ≪≫ CategoryTheory.MonoidalCategory.whiskerLeftIso Y (β_ X Z)

full_name: CategoryTheory.BraidedCategory.hexagon_reverse_iso
code: theorem hexagon_reverse_iso (X Y Z : C) :
    (α_ X Y Z).symm ≪≫ β_ (X ⊗ Y) Z ≪≫ (α_ Z X Y).symm =
      whiskerLeftIso X (β_ Y Z) ≪≫ (α_ X Z Y).symm ≪≫ whiskerRightIso (β_ X Z) Y 
goal: (α_ X Y Z).symm ≪≫ β_ (X ⊗ Y) Z ≪≫ (α_ Z X Y).symm =
  CategoryTheory.MonoidalCategory.whiskerLeftIso X (β_ Y Z) ≪≫
    (α_ X Z Y).symm ≪≫ CategoryTheory.MonoidalCategory.whiskerRightIso (β_ X Z) Y

full_name: CategoryTheory.BraidedCategory.hexagon_forward_inv
code: @[reassoc]
theorem hexagon_forward_inv (X Y Z : C) :
    (α_ Y Z X).inv ≫ (β_ X (Y ⊗ Z)).inv ≫ (α_ X Y Z).inv =
      Y ◁ (β_ X Z).inv ≫ (α_ Y X Z).inv ≫ (β_ X Y).inv ▷ Z 
goal: (α_ Y Z X).inv ≫ (β_ X (Y ⊗ Z)).inv ≫ (α_ X Y Z).inv = Y ◁ (β_ X Z).inv ≫ (α_ Y X Z).inv ≫ (β_ X Y).inv ▷ Z

full_name: CategoryTheory.BraidedCategory.hexagon_reverse_inv
code: @[reassoc]
theorem hexagon_reverse_inv (X Y Z : C) :
    (α_ Z X Y).hom ≫ (β_ (X ⊗ Y) Z).inv ≫ (α_ X Y Z).hom =
      (β_ X Z).inv ▷ Y ≫ (α_ X Z Y).hom ≫ X ◁ (β_ Y Z).inv 
goal: (α_ Z X Y).hom ≫ (β_ (X ⊗ Y) Z).inv ≫ (α_ X Y Z).hom = (β_ X Z).inv ▷ Y ≫ (α_ X Z Y).hom ≫ X ◁ (β_ Y Z).inv

full_name: CategoryTheory.braidedCategoryOfFaithful
code: /--
Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding
by a faithful monoidal functor.
-/
def braidedCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] (F : MonoidalFunctor C D) [F.Faithful] [BraidedCategory D]
    (β : ∀ X Y : C, X ⊗ Y ≅ Y ⊗ X)
    (w : ∀ X Y, F.μ _ _ ≫ F.map (β X Y).hom = (β_ _ _).hom ≫ F.μ _ _) : BraidedCategory C 
goal: CategoryTheory.BraidedCategory C

full_name: CategoryTheory.braidedCategoryOfFullyFaithful
code: /-- Pull back a braiding along a fully faithful monoidal functor. -/
noncomputable def braidedCategoryOfFullyFaithful {C D : Type*} [Category C] [Category D]
    [MonoidalCategory C] [MonoidalCategory D] (F : MonoidalFunctor C D) [F.Full]
    [F.Faithful] [BraidedCategory D] : BraidedCategory C 
goal: CategoryTheory.BraidedCategory C

full_name: CategoryTheory.braiding_leftUnitor_aux₁
code: theorem braiding_leftUnitor_aux₁ (X : C) :
    (α_ (𝟙_ C) (𝟙_ C) X).hom ≫
        (𝟙_ C ◁ (β_ X (𝟙_ C)).inv) ≫ (α_ _ X _).inv ≫ ((λ_ X).hom ▷ _) =
      ((λ_ _).hom ▷ X) ≫ (β_ X (𝟙_ C)).inv 
goal: (α_ (𝟙_ C) (𝟙_ C) X).hom ≫ 𝟙_ C ◁ (β_ X (𝟙_ C)).inv ≫ (α_ (𝟙_ C) X (𝟙_ C)).inv ≫ (λ_ X).hom ▷ 𝟙_ C =
  (λ_ (𝟙_ C)).hom ▷ X ≫ (β_ X (𝟙_ C)).inv

full_name: CategoryTheory.braiding_leftUnitor_aux₂
code: theorem braiding_leftUnitor_aux₂ (X : C) :
    ((β_ X (𝟙_ C)).hom ▷ 𝟙_ C) ≫ ((λ_ X).hom ▷ 𝟙_ C) = (ρ_ X).hom ▷ 𝟙_ C 
goal: (β_ X (𝟙_ C)).hom ▷ 𝟙_ C ≫ (λ_ X).hom ▷ 𝟙_ C = (ρ_ X).hom ▷ 𝟙_ C

full_name: CategoryTheory.braiding_leftUnitor
code: @[reassoc]
theorem braiding_leftUnitor (X : C) : (β_ X (𝟙_ C)).hom ≫ (λ_ X).hom = (ρ_ X).hom 
goal: (β_ X (𝟙_ C)).hom ≫ (λ_ X).hom = (ρ_ X).hom

full_name: CategoryTheory.braiding_rightUnitor_aux₁
code: theorem braiding_rightUnitor_aux₁ (X : C) :
    (α_ X (𝟙_ C) (𝟙_ C)).inv ≫
        ((β_ (𝟙_ C) X).inv ▷ 𝟙_ C) ≫ (α_ _ X _).hom ≫ (_ ◁ (ρ_ X).hom) =
      (X ◁ (ρ_ _).hom) ≫ (β_ (𝟙_ C) X).inv 
goal: (α_ X (𝟙_ C) (𝟙_ C)).inv ≫ (β_ (𝟙_ C) X).inv ▷ 𝟙_ C ≫ (α_ (𝟙_ C) X (𝟙_ C)).hom ≫ 𝟙_ C ◁ (ρ_ X).hom =
  X ◁ (ρ_ (𝟙_ C)).hom ≫ (β_ (𝟙_ C) X).inv

full_name: CategoryTheory.braiding_rightUnitor_aux₂
code: theorem braiding_rightUnitor_aux₂ (X : C) :
    (𝟙_ C ◁ (β_ (𝟙_ C) X).hom) ≫ (𝟙_ C ◁ (ρ_ X).hom) = 𝟙_ C ◁ (λ_ X).hom 
goal: 𝟙_ C ◁ (β_ (𝟙_ C) X).hom ≫ 𝟙_ C ◁ (ρ_ X).hom = 𝟙_ C ◁ (λ_ X).hom

full_name: CategoryTheory.braiding_rightUnitor
code: @[reassoc]
theorem braiding_rightUnitor (X : C) : (β_ (𝟙_ C) X).hom ≫ (ρ_ X).hom = (λ_ X).hom 
goal: (β_ (𝟙_ C) X).hom ≫ (ρ_ X).hom = (λ_ X).hom

full_name: CategoryTheory.braiding_tensorUnit_left
code: @[reassoc, simp]
theorem braiding_tensorUnit_left (X : C) : (β_ (𝟙_ C) X).hom = (λ_ X).hom ≫ (ρ_ X).inv 
goal: (β_ (𝟙_ C) X).hom = (λ_ X).hom ≫ (ρ_ X).inv

full_name: CategoryTheory.braiding_inv_tensorUnit_left
code: @[reassoc, simp]
theorem braiding_inv_tensorUnit_left (X : C) : (β_ (𝟙_ C) X).inv = (ρ_ X).hom ≫ (λ_ X).inv 
goal: (β_ (𝟙_ C) X).inv = (ρ_ X).hom ≫ (λ_ X).inv

full_name: CategoryTheory.leftUnitor_inv_braiding
code: @[reassoc]
theorem leftUnitor_inv_braiding (X : C) : (λ_ X).inv ≫ (β_ (𝟙_ C) X).hom = (ρ_ X).inv 
goal: (λ_ X).inv ≫ (β_ (𝟙_ C) X).hom = (ρ_ X).inv

full_name: CategoryTheory.rightUnitor_inv_braiding
code: @[reassoc]
theorem rightUnitor_inv_braiding (X : C) : (ρ_ X).inv ≫ (β_ X (𝟙_ C)).hom = (λ_ X).inv 
goal: (ρ_ X).inv ≫ (β_ X (𝟙_ C)).hom = (λ_ X).inv

full_name: CategoryTheory.braiding_tensorUnit_right
code: @[reassoc, simp]
theorem braiding_tensorUnit_right (X : C) : (β_ X (𝟙_ C)).hom = (ρ_ X).hom ≫ (λ_ X).inv 
goal: (β_ X (𝟙_ C)).hom = (ρ_ X).hom ≫ (λ_ X).inv

full_name: CategoryTheory.braiding_inv_tensorUnit_right
code: @[reassoc, simp]
theorem braiding_inv_tensorUnit_right (X : C) : (β_ X (𝟙_ C)).inv = (λ_ X).hom ≫ (ρ_ X).inv 
goal: (β_ X (𝟙_ C)).inv = (λ_ X).hom ≫ (ρ_ X).inv

full_name: CategoryTheory.SymmetricCategory.symmetry
code: /--
A symmetric monoidal category is a braided monoidal category for which the braiding is symmetric.

See <https://stacks.math.columbia.edu/tag/0FFW>.
-/
class SymmetricCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] extends
    BraidedCategory.{v} C where
  -- braiding symmetric:
  symmetry : ∀ X Y : C, (β_ X Y).hom ≫ (β_ Y X).hom = 𝟙 (X ⊗ Y) := by aesop_cat
goal: (β_ X Y).hom ≫ (β_ Y X).hom = 𝟙 (X ⊗ Y)

full_name: CategoryTheory.SymmetricCategory
code: /--
A symmetric monoidal category is a braided monoidal category for which the braiding is symmetric.

See <https://stacks.math.columbia.edu/tag/0FFW>.
-/
class SymmetricCategory (C : Type u) [Category.{v} C] [MonoidalCategory.{v} C] extends
    BraidedCategory.{v} C where
  -- braiding symmetric:
  symmetry : ∀ X Y : C, (β_ X Y).hom ≫ (β_ Y X).hom = 𝟙 (X ⊗ Y) := by aesop_cat
goal: Type (max u v)

full_name: CategoryTheory.SymmetricCategory.braiding_swap_eq_inv_braiding
code: lemma SymmetricCategory.braiding_swap_eq_inv_braiding {C : Type u₁}
    [Category.{v₁} C] [MonoidalCategory C] [SymmetricCategory C] (X Y : C) :
    (β_ Y X).hom = (β_ X Y).inv 
goal: (β_ Y X).hom = (β_ X Y).inv

full_name: CategoryTheory.LaxBraidedFunctor.braided
code: /-- A lax braided functor between braided monoidal categories is a lax monoidal functor
which preserves the braiding.
-/
structure LaxBraidedFunctor extends LaxMonoidalFunctor C D where
  braided : ∀ X Y : C, μ X Y ≫ map (β_ X Y).hom = (β_ (obj X) (obj Y)).hom ≫ μ Y X := by aesop_cat
goal: self.μ X Y ≫ self.map (β_ X Y).hom = (β_ (self.obj X) (self.obj Y)).hom ≫ self.μ Y X

full_name: CategoryTheory.LaxBraidedFunctor
code: /-- A lax braided functor between braided monoidal categories is a lax monoidal functor
which preserves the braiding.
-/
structure LaxBraidedFunctor extends LaxMonoidalFunctor C D where
  braided : ∀ X Y : C, μ X Y ≫ map (β_ X Y).hom = (β_ (obj X) (obj Y)).hom ≫ μ Y X := by aesop_cat
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.LaxBraidedFunctor.id_obj
code: /-- The identity lax braided monoidal functor. -/
@[simps!]
def id : LaxBraidedFunctor C C 
goal: (CategoryTheory.LaxBraidedFunctor.id C).obj X = X

full_name: CategoryTheory.LaxBraidedFunctor.id
code: /-- The identity lax braided monoidal functor. -/
@[simps!]
def id : LaxBraidedFunctor C C 
goal: CategoryTheory.LaxBraidedFunctor C C

full_name: CategoryTheory.LaxBraidedFunctor.id_μ
code: /-- The identity lax braided monoidal functor. -/
@[simps!]
def id : LaxBraidedFunctor C C 
goal: (CategoryTheory.LaxBraidedFunctor.id C).μ X Y = 𝟙 (X ⊗ Y)

full_name: CategoryTheory.LaxBraidedFunctor.id_map
code: /-- The identity lax braided monoidal functor. -/
@[simps!]
def id : LaxBraidedFunctor C C 
goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.LaxBraidedFunctor.id C).map f = f

full_name: CategoryTheory.LaxBraidedFunctor.id_ε
code: /-- The identity lax braided monoidal functor. -/
@[simps!]
def id : LaxBraidedFunctor C C 
goal: (CategoryTheory.LaxBraidedFunctor.id C).ε = 𝟙 (𝟙_ C)

full_name: CategoryTheory.LaxBraidedFunctor.instInhabited
code: instance : Inhabited (LaxBraidedFunctor C C) 
goal: Inhabited (CategoryTheory.LaxBraidedFunctor C C)

full_name: CategoryTheory.LaxBraidedFunctor.comp_ε
code: /-- The composition of lax braided monoidal functors. -/
@[simps!]
def comp (F : LaxBraidedFunctor C D) (G : LaxBraidedFunctor D E) : LaxBraidedFunctor C E 
goal: (F.comp G).ε = G.ε ≫ G.map F.ε

full_name: CategoryTheory.LaxBraidedFunctor.comp
code: /-- The composition of lax braided monoidal functors. -/
@[simps!]
def comp (F : LaxBraidedFunctor C D) (G : LaxBraidedFunctor D E) : LaxBraidedFunctor C E 
goal: CategoryTheory.LaxBraidedFunctor C E

full_name: CategoryTheory.LaxBraidedFunctor.comp_map
code: /-- The composition of lax braided monoidal functors. -/
@[simps!]
def comp (F : LaxBraidedFunctor C D) (G : LaxBraidedFunctor D E) : LaxBraidedFunctor C E 
goal: ∀ {X Y : C} (f : X ⟶ Y), (F.comp G).map f = G.map (F.map f)

full_name: CategoryTheory.LaxBraidedFunctor.comp_obj
code: /-- The composition of lax braided monoidal functors. -/
@[simps!]
def comp (F : LaxBraidedFunctor C D) (G : LaxBraidedFunctor D E) : LaxBraidedFunctor C E 
goal: (F.comp G).obj X = G.obj (F.obj X)

full_name: CategoryTheory.LaxBraidedFunctor.comp_μ
code: /-- The composition of lax braided monoidal functors. -/
@[simps!]
def comp (F : LaxBraidedFunctor C D) (G : LaxBraidedFunctor D E) : LaxBraidedFunctor C E 
goal: (F.comp G).μ X Y = G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)

full_name: CategoryTheory.LaxBraidedFunctor.categoryLaxBraidedFunctor
code: instance categoryLaxBraidedFunctor : Category (LaxBraidedFunctor C D) 
goal: CategoryTheory.Category.{max u₁ v₂, max (max (max u₂ u₁) v₂) v₁} (CategoryTheory.LaxBraidedFunctor C D)

full_name: CategoryTheory.LaxBraidedFunctor.ext'
code: @[ext]
lemma ext' {F G : LaxBraidedFunctor C D} {α β : F ⟶ G} (w : ∀ X : C, α.app X = β.app X) : α = β 
goal: α = β

full_name: CategoryTheory.LaxBraidedFunctor.comp_toNatTrans
code: @[simp]
theorem comp_toNatTrans {F G H : LaxBraidedFunctor C D} {α : F ⟶ G} {β : G ⟶ H} :
    (α ≫ β).toNatTrans = @CategoryStruct.comp (C ⥤ D) _ _ _ _ α.toNatTrans β.toNatTrans 
goal: (α ≫ β).toNatTrans = α.toNatTrans ≫ β.toNatTrans

full_name: CategoryTheory.LaxBraidedFunctor.mkIso_hom
code: /-- Interpret a natural isomorphism of the underlying lax monoidal functors as an
isomorphism of the lax braided monoidal functors.
-/
@[simps]
def mkIso {F G : LaxBraidedFunctor C D} (i : F.toLaxMonoidalFunctor ≅ G.toLaxMonoidalFunctor) :
    F ≅ G 
goal: (CategoryTheory.LaxBraidedFunctor.mkIso i).hom = i.hom

full_name: CategoryTheory.LaxBraidedFunctor.mkIso_inv
code: /-- Interpret a natural isomorphism of the underlying lax monoidal functors as an
isomorphism of the lax braided monoidal functors.
-/
@[simps]
def mkIso {F G : LaxBraidedFunctor C D} (i : F.toLaxMonoidalFunctor ≅ G.toLaxMonoidalFunctor) :
    F ≅ G 
goal: (CategoryTheory.LaxBraidedFunctor.mkIso i).inv = i.inv

full_name: CategoryTheory.LaxBraidedFunctor.mkIso
code: /-- Interpret a natural isomorphism of the underlying lax monoidal functors as an
isomorphism of the lax braided monoidal functors.
-/
@[simps]
def mkIso {F G : LaxBraidedFunctor C D} (i : F.toLaxMonoidalFunctor ≅ G.toLaxMonoidalFunctor) :
    F ≅ G 
goal: F ≅ G

full_name: CategoryTheory.BraidedFunctor.braided
code: /-- A braided functor between braided monoidal categories is a monoidal functor
which preserves the braiding.
-/
structure BraidedFunctor extends MonoidalFunctor C D where
  -- Note this is stated differently than for `LaxBraidedFunctor`.
  -- We move the `μ X Y` to the right hand side,
  -- so that this makes a good `@[simp]` lemma.
  braided : ∀ X Y : C, map (β_ X Y).hom = inv (μ X Y) ≫ (β_ (obj X) (obj Y)).hom ≫ μ Y X := by
    aesop_cat
goal: self.map (β_ X Y).hom = CategoryTheory.inv (self.μ X Y) ≫ (β_ (self.obj X) (self.obj Y)).hom ≫ self.μ Y X

full_name: CategoryTheory.BraidedFunctor
code: /-- A braided functor between braided monoidal categories is a monoidal functor
which preserves the braiding.
-/
structure BraidedFunctor extends MonoidalFunctor C D where
  -- Note this is stated differently than for `LaxBraidedFunctor`.
  -- We move the `μ X Y` to the right hand side,
  -- so that this makes a good `@[simp]` lemma.
  braided : ∀ X Y : C, map (β_ X Y).hom = inv (μ X Y) ≫ (β_ (obj X) (obj Y)).hom ≫ μ Y X := by
    aesop_cat
goal: Type (max (max (max u₁ u₂) v₁) v₂)

full_name: CategoryTheory.symmetricCategoryOfFaithful
code: /--
A braided category with a faithful braided functor to a symmetric category is itself symmetric.
-/
def symmetricCategoryOfFaithful {C D : Type*} [Category C] [Category D] [MonoidalCategory C]
    [MonoidalCategory D] [BraidedCategory C] [SymmetricCategory D] (F : BraidedFunctor C D)
    [F.Faithful] : SymmetricCategory C 
goal: CategoryTheory.SymmetricCategory C

full_name: CategoryTheory.BraidedFunctor.toLaxBraidedFunctor
code: /-- Turn a braided functor into a lax braided functor. -/
@[simps toLaxMonoidalFunctor]
def toLaxBraidedFunctor (F : BraidedFunctor C D) : LaxBraidedFunctor C D 
goal: CategoryTheory.LaxBraidedFunctor C D

full_name: CategoryTheory.BraidedFunctor.toLaxBraidedFunctor_toLaxMonoidalFunctor
code: /-- Turn a braided functor into a lax braided functor. -/
@[simps toLaxMonoidalFunctor]
def toLaxBraidedFunctor (F : BraidedFunctor C D) : LaxBraidedFunctor C D 
goal: (CategoryTheory.BraidedFunctor.toLaxBraidedFunctor C D F).toLaxMonoidalFunctor = F.toLaxMonoidalFunctor

full_name: CategoryTheory.BraidedFunctor.id_map
code: /-- The identity braided monoidal functor. -/
@[simps!]
def id : BraidedFunctor C C 
goal: ∀ {X Y : C} (f : X ⟶ Y), (CategoryTheory.BraidedFunctor.id C).map f = f

full_name: CategoryTheory.BraidedFunctor.id_μ
code: /-- The identity braided monoidal functor. -/
@[simps!]
def id : BraidedFunctor C C 
goal: (CategoryTheory.BraidedFunctor.id C).μ X Y = 𝟙 (X ⊗ Y)

full_name: CategoryTheory.BraidedFunctor.id_obj
code: /-- The identity braided monoidal functor. -/
@[simps!]
def id : BraidedFunctor C C 
goal: (CategoryTheory.BraidedFunctor.id C).obj X = X

full_name: CategoryTheory.BraidedFunctor.id
code: /-- The identity braided monoidal functor. -/
@[simps!]
def id : BraidedFunctor C C 
goal: CategoryTheory.BraidedFunctor C C

full_name: CategoryTheory.BraidedFunctor.id_ε
code: /-- The identity braided monoidal functor. -/
@[simps!]
def id : BraidedFunctor C C 
goal: (CategoryTheory.BraidedFunctor.id C).ε = 𝟙 (𝟙_ C)

full_name: CategoryTheory.BraidedFunctor.instInhabited
code: instance : Inhabited (BraidedFunctor C C) 
goal: Inhabited (CategoryTheory.BraidedFunctor C C)

full_name: CategoryTheory.BraidedFunctor.comp_ε
code: /-- The composition of braided monoidal functors. -/
@[simps!]
def comp (F : BraidedFunctor C D) (G : BraidedFunctor D E) : BraidedFunctor C E 
goal: (F.comp G).ε = G.ε ≫ G.map F.ε

full_name: CategoryTheory.BraidedFunctor.comp
code: /-- The composition of braided monoidal functors. -/
@[simps!]
def comp (F : BraidedFunctor C D) (G : BraidedFunctor D E) : BraidedFunctor C E 
goal: CategoryTheory.BraidedFunctor C E

full_name: CategoryTheory.BraidedFunctor.comp_μ
code: /-- The composition of braided monoidal functors. -/
@[simps!]
def comp (F : BraidedFunctor C D) (G : BraidedFunctor D E) : BraidedFunctor C E 
goal: (F.comp G).μ X Y = G.μ (F.obj X) (F.obj Y) ≫ G.map (F.μ X Y)

full_name: CategoryTheory.BraidedFunctor.comp_map
code: /-- The composition of braided monoidal functors. -/
@[simps!]
def comp (F : BraidedFunctor C D) (G : BraidedFunctor D E) : BraidedFunctor C E 
goal: ∀ {X Y : C} (f : X ⟶ Y), (F.comp G).map f = G.map (F.map f)

full_name: CategoryTheory.BraidedFunctor.comp_obj
code: /-- The composition of braided monoidal functors. -/
@[simps!]
def comp (F : BraidedFunctor C D) (G : BraidedFunctor D E) : BraidedFunctor C E 
goal: (F.comp G).obj X = G.obj (F.obj X)

full_name: CategoryTheory.BraidedFunctor.categoryBraidedFunctor
code: instance categoryBraidedFunctor : Category (BraidedFunctor C D) 
goal: CategoryTheory.Category.{max u₁ v₂, max (max (max u₂ u₁) v₂) v₁} (CategoryTheory.BraidedFunctor C D)

full_name: CategoryTheory.BraidedFunctor.ext'
code: @[ext]
lemma ext' {F G : BraidedFunctor C D} {α β : F ⟶ G} (w : ∀ X : C, α.app X = β.app X) : α = β 
goal: α = β

full_name: CategoryTheory.BraidedFunctor.comp_toNatTrans
code: @[simp]
theorem comp_toNatTrans {F G H : BraidedFunctor C D} {α : F ⟶ G} {β : G ⟶ H} :
    (α ≫ β).toNatTrans = @CategoryStruct.comp (C ⥤ D) _ _ _ _ α.toNatTrans β.toNatTrans 
goal: (α ≫ β).toNatTrans = α.toNatTrans ≫ β.toNatTrans

full_name: CategoryTheory.BraidedFunctor.mkIso_inv
code: /-- Interpret a natural isomorphism of the underlying monoidal functors as an
isomorphism of the braided monoidal functors.
-/
@[simps]
def mkIso {F G : BraidedFunctor C D} (i : F.toMonoidalFunctor ≅ G.toMonoidalFunctor) : F ≅ G 
goal: (CategoryTheory.BraidedFunctor.mkIso i).inv = i.inv

full_name: CategoryTheory.BraidedFunctor.mkIso_hom
code: /-- Interpret a natural isomorphism of the underlying monoidal functors as an
isomorphism of the braided monoidal functors.
-/
@[simps]
def mkIso {F G : BraidedFunctor C D} (i : F.toMonoidalFunctor ≅ G.toMonoidalFunctor) : F ≅ G 
goal: (CategoryTheory.BraidedFunctor.mkIso i).hom = i.hom

full_name: CategoryTheory.BraidedFunctor.mkIso
code: /-- Interpret a natural isomorphism of the underlying monoidal functors as an
isomorphism of the braided monoidal functors.
-/
@[simps]
def mkIso {F G : BraidedFunctor C D} (i : F.toMonoidalFunctor ≅ G.toMonoidalFunctor) : F ≅ G 
goal: F ≅ G

full_name: CategoryTheory.instBraidedCategoryDiscrete
code: instance : BraidedCategory (Discrete M) 
goal: CategoryTheory.BraidedCategory (CategoryTheory.Discrete M)

full_name: CategoryTheory.Discrete.braidedFunctor_μ
code: /-- A multiplicative morphism between commutative monoids gives a braided functor between
the corresponding discrete braided monoidal categories.
-/
@[simps!]
def Discrete.braidedFunctor (F : M →* N) : BraidedFunctor (Discrete M) (Discrete N) 
goal: (CategoryTheory.Discrete.braidedFunctor F).μ X Y = CategoryTheory.Discrete.eqToHom ⋯

full_name: CategoryTheory.Discrete.braidedFunctor_obj_as
code: /-- A multiplicative morphism between commutative monoids gives a braided functor between
the corresponding discrete braided monoidal categories.
-/
@[simps!]
def Discrete.braidedFunctor (F : M →* N) : BraidedFunctor (Discrete M) (Discrete N) 
goal: ((CategoryTheory.Discrete.braidedFunctor F).obj X).as = F X.as

full_name: CategoryTheory.Discrete.braidedFunctor_ε
code: /-- A multiplicative morphism between commutative monoids gives a braided functor between
the corresponding discrete braided monoidal categories.
-/
@[simps!]
def Discrete.braidedFunctor (F : M →* N) : BraidedFunctor (Discrete M) (Discrete N) 
goal: (CategoryTheory.Discrete.braidedFunctor F).ε = CategoryTheory.Discrete.eqToHom ⋯

full_name: CategoryTheory.Discrete.braidedFunctor
code: /-- A multiplicative morphism between commutative monoids gives a braided functor between
the corresponding discrete braided monoidal categories.
-/
@[simps!]
def Discrete.braidedFunctor (F : M →* N) : BraidedFunctor (Discrete M) (Discrete N) 
goal: CategoryTheory.BraidedFunctor (CategoryTheory.Discrete M) (CategoryTheory.Discrete N)

full_name: CategoryTheory.Discrete.braidedFunctor_map
code: /-- A multiplicative morphism between commutative monoids gives a braided functor between
the corresponding discrete braided monoidal categories.
-/
@[simps!]
def Discrete.braidedFunctor (F : M →* N) : BraidedFunctor (Discrete M) (Discrete N) 
goal: ∀ {X Y : CategoryTheory.Discrete M} (f : X ⟶ Y),
  (CategoryTheory.Discrete.braidedFunctor F).map f = CategoryTheory.Discrete.eqToHom ⋯

full_name: CategoryTheory.tensor_μ
code: /-- The strength of the tensor product functor from `C × C` to `C`. -/
def tensor_μ (X Y : C × C) : (X.1 ⊗ X.2) ⊗ Y.1 ⊗ Y.2 ⟶ (X.1 ⊗ Y.1) ⊗ X.2 ⊗ Y.2 
goal: (X.1 ⊗ X.2) ⊗ Y.1 ⊗ Y.2 ⟶ (X.1 ⊗ Y.1) ⊗ X.2 ⊗ Y.2

full_name: CategoryTheory.tensor_μ_natural
code: @[reassoc]
theorem tensor_μ_natural {X₁ X₂ Y₁ Y₂ U₁ U₂ V₁ V₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : U₁ ⟶ V₁)
    (g₂ : U₂ ⟶ V₂) :
    ((f₁ ⊗ f₂) ⊗ g₁ ⊗ g₂) ≫ tensor_μ C (Y₁, Y₂) (V₁, V₂) =
      tensor_μ C (X₁, X₂) (U₁, U₂) ≫ ((f₁ ⊗ g₁) ⊗ f₂ ⊗ g₂) 
goal: ((f₁ ⊗ f₂) ⊗ g₁ ⊗ g₂) ≫ CategoryTheory.tensor_μ C (Y₁, Y₂) (V₁, V₂) =
  CategoryTheory.tensor_μ C (X₁, X₂) (U₁, U₂) ≫ ((f₁ ⊗ g₁) ⊗ f₂ ⊗ g₂)

full_name: CategoryTheory.tensor_μ_natural_left
code: @[reassoc]
theorem tensor_μ_natural_left {X₁ X₂ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (Z₁ Z₂ : C) :
    (f₁ ⊗ f₂) ▷ (Z₁ ⊗ Z₂) ≫ tensor_μ C (Y₁, Y₂) (Z₁, Z₂) =
      tensor_μ C (X₁, X₂) (Z₁, Z₂) ≫ (f₁ ▷ Z₁ ⊗ f₂ ▷ Z₂) 
goal: (f₁ ⊗ f₂) ▷ (Z₁ ⊗ Z₂) ≫ CategoryTheory.tensor_μ C (Y₁, Y₂) (Z₁, Z₂) =
  CategoryTheory.tensor_μ C (X₁, X₂) (Z₁, Z₂) ≫ (f₁ ▷ Z₁ ⊗ f₂ ▷ Z₂)

full_name: CategoryTheory.tensor_μ_natural_right
code: @[reassoc]
theorem tensor_μ_natural_right (Z₁ Z₂ : C) {X₁ X₂ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) :
    (Z₁ ⊗ Z₂) ◁ (f₁ ⊗ f₂) ≫ tensor_μ C (Z₁, Z₂) (Y₁, Y₂) =
      tensor_μ C (Z₁, Z₂) (X₁, X₂) ≫ (Z₁ ◁ f₁ ⊗ Z₂ ◁ f₂) 
goal: (Z₁ ⊗ Z₂) ◁ (f₁ ⊗ f₂) ≫ CategoryTheory.tensor_μ C (Z₁, Z₂) (Y₁, Y₂) =
  CategoryTheory.tensor_μ C (Z₁, Z₂) (X₁, X₂) ≫ (Z₁ ◁ f₁ ⊗ Z₂ ◁ f₂)

full_name: CategoryTheory.tensor_left_unitality
code: @[reassoc]
theorem tensor_left_unitality (X₁ X₂ : C) :
    (λ_ (X₁ ⊗ X₂)).hom =
      ((λ_ (𝟙_ C)).inv ▷ (X₁ ⊗ X₂)) ≫
        tensor_μ C (𝟙_ C, 𝟙_ C) (X₁, X₂) ≫ ((λ_ X₁).hom ⊗ (λ_ X₂).hom) 
goal: (λ_ (X₁ ⊗ X₂)).hom =
  (λ_ (𝟙_ C)).inv ▷ (X₁ ⊗ X₂) ≫ CategoryTheory.tensor_μ C (𝟙_ C, 𝟙_ C) (X₁, X₂) ≫ ((λ_ X₁).hom ⊗ (λ_ X₂).hom)

full_name: CategoryTheory.tensor_right_unitality
code: @[reassoc]
theorem tensor_right_unitality (X₁ X₂ : C) :
    (ρ_ (X₁ ⊗ X₂)).hom =
      ((X₁ ⊗ X₂) ◁ (λ_ (𝟙_ C)).inv) ≫
        tensor_μ C (X₁, X₂) (𝟙_ C, 𝟙_ C) ≫ ((ρ_ X₁).hom ⊗ (ρ_ X₂).hom) 
goal: (ρ_ (X₁ ⊗ X₂)).hom =
  (X₁ ⊗ X₂) ◁ (λ_ (𝟙_ C)).inv ≫ CategoryTheory.tensor_μ C (X₁, X₂) (𝟙_ C, 𝟙_ C) ≫ ((ρ_ X₁).hom ⊗ (ρ_ X₂).hom)

full_name: CategoryTheory.tensor_associativity
code: theorem tensor_associativity (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₂) 
goal: CategoryTheory.tensor_μ C (X₁, X₂) (Y₁, Y₂) ▷ (Z₁ ⊗ Z₂) ≫
    CategoryTheory.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₂) ◁ CategoryTheory.tensor_μ C (Y₁, Y₂) (Z₁, Z₂) ≫ CategoryTheory.tensor_μ C (X₁, X₂) (Y₁ ⊗ Z₁, Y₂ ⊗ Z₂)

full_name: CategoryTheory.tensorMonoidal_toLaxMonoidalFunctor_μ
code: /-- The tensor product functor from `C × C` to `C` as a monoidal functor. -/
@[simps!]
def tensorMonoidal : MonoidalFunctor (C × C) C 
goal: (CategoryTheory.tensorMonoidal C).μ X Y = CategoryTheory.tensor_μ C X Y

full_name: CategoryTheory.tensorMonoidal_toLaxMonoidalFunctor_toFunctor_map
code: /-- The tensor product functor from `C × C` to `C` as a monoidal functor. -/
@[simps!]
def tensorMonoidal : MonoidalFunctor (C × C) C 
goal: (CategoryTheory.tensorMonoidal C).map f = f.1 ⊗ f.2

full_name: CategoryTheory.tensorMonoidal_toLaxMonoidalFunctor_toFunctor_obj
code: /-- The tensor product functor from `C × C` to `C` as a monoidal functor. -/
@[simps!]
def tensorMonoidal : MonoidalFunctor (C × C) C 
goal: (CategoryTheory.tensorMonoidal C).obj X = X.1 ⊗ X.2

full_name: CategoryTheory.tensorMonoidal
code: /-- The tensor product functor from `C × C` to `C` as a monoidal functor. -/
@[simps!]
def tensorMonoidal : MonoidalFunctor (C × C) C 
goal: CategoryTheory.MonoidalFunctor (C × C) C

full_name: CategoryTheory.tensorMonoidal_toLaxMonoidalFunctor_ε
code: /-- The tensor product functor from `C × C` to `C` as a monoidal functor. -/
@[simps!]
def tensorMonoidal : MonoidalFunctor (C × C) C 
goal: (CategoryTheory.tensorMonoidal C).ε = (λ_ (𝟙_ C)).inv

full_name: CategoryTheory.leftUnitor_monoidal
code: @[reassoc]
theorem leftUnitor_monoidal (X₁ X₂ : C) :
    (λ_ X₁).hom ⊗ (λ_ X₂).hom =
      tensor_μ C (𝟙_ C, X₁) (𝟙_ C, X₂) ≫ ((λ_ (𝟙_ C)).hom ▷ (X₁ ⊗ X₂)) ≫ (λ_ (X₁ ⊗ X₂)).hom 
goal: (λ_ X₁).hom ⊗ (λ_ X₂).hom =
  CategoryTheory.tensor_μ C (𝟙_ C, X₁) (𝟙_ C, X₂) ≫ (λ_ (𝟙_ C)).hom ▷ (X₁ ⊗ X₂) ≫ (λ_ (X₁ ⊗ X₂)).hom

full_name: CategoryTheory.rightUnitor_monoidal
code: @[reassoc]
theorem rightUnitor_monoidal (X₁ X₂ : C) :
    (ρ_ X₁).hom ⊗ (ρ_ X₂).hom =
      tensor_μ C (X₁, 𝟙_ C) (X₂, 𝟙_ C) ≫ ((X₁ ⊗ X₂) ◁ (λ_ (𝟙_ C)).hom) ≫ (ρ_ (X₁ ⊗ X₂)).hom 
goal: (ρ_ X₁).hom ⊗ (ρ_ X₂).hom =
  CategoryTheory.tensor_μ C (X₁, 𝟙_ C) (X₂, 𝟙_ C) ≫ (X₁ ⊗ X₂) ◁ (λ_ (𝟙_ C)).hom ≫ (ρ_ (X₁ ⊗ X₂)).hom

full_name: CategoryTheory.associator_monoidal
code: theorem associator_monoidal (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₃)) 
goal: CategoryTheory.tensor_μ C (X₁ ⊗ X₂, X₃) (Y₁ ⊗ Y₂, Y₃) ≫
    CategoryTheory.tensor_μ C (X₁, X₂) (Y₁, Y₂) ▷ (X₃ ⊗ Y₃) ≫ (α_ (X₁ ⊗ Y₁) (X₂ ⊗ Y₂) (X₃ ⊗ Y₃)).hom =
  ((α_ X₁ X₂ X₃).hom ⊗ (α_ Y₁ Y₂ Y₃).hom) ≫
    CategoryTheory.tensor_μ C (X₁, X₂ ⊗ X₃) (Y₁, Y₂ ⊗ Y₃) ≫ (X₁ ⊗ Y₁) ◁ CategoryTheory.tensor_μ C (X₂, X₃) (Y₂, Y₃)

full_name: CategoryTheory.instBraidedCategoryOpposite
code: instance : BraidedCategory Cᵒᵖ 
goal: CategoryTheory.BraidedCategory Cᵒᵖ

full_name: CategoryTheory.op_braiding
code: @[simp] lemma op_braiding (X Y : C) : (β_ X Y).op = β_ (op Y) (op X) 
goal: (β_ X Y).op = β_ (Opposite.op Y) (Opposite.op X)

full_name: CategoryTheory.unop_braiding
code: @[simp] lemma unop_braiding (X Y : Cᵒᵖ) : (β_ X Y).unop = β_ (unop Y) (unop X) 
goal: (β_ X Y).unop = β_ (Opposite.unop Y) (Opposite.unop X)

full_name: CategoryTheory.op_hom_braiding
code: @[simp] lemma op_hom_braiding (X Y : C) : (β_ X Y).hom.op = (β_ (op Y) (op X)).hom 
goal: (β_ X Y).hom.op = (β_ (Opposite.op Y) (Opposite.op X)).hom

full_name: CategoryTheory.unop_hom_braiding
code: @[simp] lemma unop_hom_braiding (X Y : Cᵒᵖ) : (β_ X Y).hom.unop = (β_ (unop Y) (unop X)).hom 
goal: (β_ X Y).hom.unop = (β_ (Opposite.unop Y) (Opposite.unop X)).hom

full_name: CategoryTheory.op_inv_braiding
code: @[simp] lemma op_inv_braiding (X Y : C) : (β_ X Y).inv.op = (β_ (op Y) (op X)).inv 
goal: (β_ X Y).inv.op = (β_ (Opposite.op Y) (Opposite.op X)).inv

full_name: CategoryTheory.unop_inv_braiding
code: @[simp] lemma unop_inv_braiding (X Y : Cᵒᵖ) : (β_ X Y).inv.unop = (β_ (unop Y) (unop X)).inv 
goal: (β_ X Y).inv.unop = (β_ (Opposite.unop Y) (Opposite.unop X)).inv

full_name: CategoryTheory.MonoidalOpposite.instBraiding
code: instance instBraiding : BraidedCategory Cᴹᵒᵖ 
goal: CategoryTheory.BraidedCategory Cᴹᵒᵖ

full_name: CategoryTheory.MonoidalOpposite.mop_braiding
code: @[simp] lemma mop_braiding (X Y : C) : (β_ X Y).mop = β_ (mop Y) (mop X) 
goal: (β_ X Y).mop = β_ { unmop := Y } { unmop := X }

full_name: CategoryTheory.MonoidalOpposite.unmop_braiding
code: @[simp] lemma unmop_braiding (X Y : Cᴹᵒᵖ) : (β_ X Y).unmop = β_ (unmop Y) (unmop X) 
goal: (β_ X Y).unmop = β_ Y.unmop X.unmop

full_name: CategoryTheory.MonoidalOpposite.mop_hom_braiding
code: @[simp] lemma mop_hom_braiding (X Y : C) : (β_ X Y).hom.mop = (β_ (mop Y) (mop X)).hom 
goal: (β_ X Y).hom.mop = (β_ { unmop := Y } { unmop := X }).hom

full_name: CategoryTheory.MonoidalOpposite.unmop_hom_braiding
code: @[simp]
lemma unmop_hom_braiding (X Y : Cᴹᵒᵖ) : (β_ X Y).hom.unmop = (β_ (unmop Y) (unmop X)).hom 
goal: (β_ X Y).hom.unmop = (β_ Y.unmop X.unmop).hom

full_name: CategoryTheory.MonoidalOpposite.mop_inv_braiding
code: @[simp] lemma mop_inv_braiding (X Y : C) : (β_ X Y).inv.mop = (β_ (mop Y) (mop X)).inv 
goal: (β_ X Y).inv.mop = (β_ { unmop := Y } { unmop := X }).inv

full_name: CategoryTheory.MonoidalOpposite.unmop_inv_braiding
code: @[simp]
lemma unmop_inv_braiding (X Y : Cᴹᵒᵖ) : (β_ X Y).inv.unmop = (β_ (unmop Y) (unmop X)).inv 
goal: (β_ X Y).inv.unmop = (β_ Y.unmop X.unmop).inv

full_name: CategoryTheory.MonoidalOpposite.mopBraidedFunctor_obj_unmop
code: /-- The identity functor on `C`, viewed as a functor from `C` to its
monoidal opposite, upgraded to a braided functor. -/
@[simps!] def mopBraidedFunctor : BraidedFunctor C Cᴹᵒᵖ 
goal: ((CategoryTheory.MonoidalOpposite.mopBraidedFunctor C).obj unmop).unmop = unmop

full_name: CategoryTheory.MonoidalOpposite.mopBraidedFunctor_map_unmop
code: /-- The identity functor on `C`, viewed as a functor from `C` to its
monoidal opposite, upgraded to a braided functor. -/
@[simps!] def mopBraidedFunctor : BraidedFunctor C Cᴹᵒᵖ 
goal: ∀ {X Y : C} (f : X ⟶ Y), ((CategoryTheory.MonoidalOpposite.mopBraidedFunctor C).map f).unmop = f

full_name: CategoryTheory.MonoidalOpposite.mopBraidedFunctor
code: /-- The identity functor on `C`, viewed as a functor from `C` to its
monoidal opposite, upgraded to a braided functor. -/
@[simps!] def mopBraidedFunctor : BraidedFunctor C Cᴹᵒᵖ 
goal: CategoryTheory.BraidedFunctor C Cᴹᵒᵖ

full_name: CategoryTheory.MonoidalOpposite.mopBraidedFunctor_μ_unmop
code: /-- The identity functor on `C`, viewed as a functor from `C` to its
monoidal opposite, upgraded to a braided functor. -/
@[simps!] def mopBraidedFunctor : BraidedFunctor C Cᴹᵒᵖ 
goal: ((CategoryTheory.MonoidalOpposite.mopBraidedFunctor C).μ X Y).unmop = (β_ Y X).hom

full_name: CategoryTheory.MonoidalOpposite.mopBraidedFunctor_ε_unmop
code: /-- The identity functor on `C`, viewed as a functor from `C` to its
monoidal opposite, upgraded to a braided functor. -/
@[simps!] def mopBraidedFunctor : BraidedFunctor C Cᴹᵒᵖ 
goal: (CategoryTheory.MonoidalOpposite.mopBraidedFunctor C).ε.unmop = 𝟙 (𝟙_ C)

full_name: CategoryTheory.MonoidalOpposite.unmopBraidedFunctor_ε
code: /-- The identity functor on `C`, viewed as a functor from the
monoidal opposite of `C` to `C`, upgraded to a braided functor. -/
@[simps!] def unmopBraidedFunctor : BraidedFunctor Cᴹᵒᵖ C 
goal: (CategoryTheory.MonoidalOpposite.unmopBraidedFunctor C).ε = 𝟙 (𝟙_ C)

full_name: CategoryTheory.MonoidalOpposite.unmopBraidedFunctor_obj
code: /-- The identity functor on `C`, viewed as a functor from the
monoidal opposite of `C` to `C`, upgraded to a braided functor. -/
@[simps!] def unmopBraidedFunctor : BraidedFunctor Cᴹᵒᵖ C 
goal: (CategoryTheory.MonoidalOpposite.unmopBraidedFunctor C).obj self = self.unmop

full_name: CategoryTheory.MonoidalOpposite.unmopBraidedFunctor_map
code: /-- The identity functor on `C`, viewed as a functor from the
monoidal opposite of `C` to `C`, upgraded to a braided functor. -/
@[simps!] def unmopBraidedFunctor : BraidedFunctor Cᴹᵒᵖ C 
goal: ∀ {X Y : Cᴹᵒᵖ} (f : X ⟶ Y), (CategoryTheory.MonoidalOpposite.unmopBraidedFunctor C).map f = f.unmop

full_name: CategoryTheory.MonoidalOpposite.unmopBraidedFunctor
code: /-- The identity functor on `C`, viewed as a functor from the
monoidal opposite of `C` to `C`, upgraded to a braided functor. -/
@[simps!] def unmopBraidedFunctor : BraidedFunctor Cᴹᵒᵖ C 
goal: CategoryTheory.BraidedFunctor Cᴹᵒᵖ C

full_name: CategoryTheory.MonoidalOpposite.unmopBraidedFunctor_μ
code: /-- The identity functor on `C`, viewed as a functor from the
monoidal opposite of `C` to `C`, upgraded to a braided functor. -/
@[simps!] def unmopBraidedFunctor : BraidedFunctor Cᴹᵒᵖ C 
goal: (CategoryTheory.MonoidalOpposite.unmopBraidedFunctor C).μ X Y = (β_ X.unmop Y.unmop).hom

full_name: CategoryTheory.reverseBraiding
code: /-- The braided monoidal category obtained from `C` by replacing its braiding
`β_ X Y : X ⊗ Y ≅ Y ⊗ X` with the inverse `(β_ Y X)⁻¹ : X ⊗ Y ≅ Y ⊗ X`.
This corresponds to the automorphism of the braid group swapping
over-crossings and under-crossings. -/
abbrev reverseBraiding : BraidedCategory C 
goal: CategoryTheory.BraidedCategory C

full_name: CategoryTheory.SymmetricCategory.reverseBraiding_eq
code: lemma SymmetricCategory.reverseBraiding_eq (C : Type u₁) [Category.{v₁} C]
    [MonoidalCategory C] [i : SymmetricCategory C] :
    reverseBraiding C = i.toBraidedCategory 
goal: CategoryTheory.reverseBraiding C = CategoryTheory.SymmetricCategory.toBraidedCategory

full_name: CategoryTheory.SymmetricCategory.equivReverseBraiding
code: /-- The identity functor from `C` to `C`, where the codomain is given the
reversed braiding, upgraded to a braided functor. -/
def SymmetricCategory.equivReverseBraiding (C : Type u₁) [Category.{v₁} C]
    [MonoidalCategory C] [SymmetricCategory C] 
goal: CategoryTheory.BraidedFunctor C C