Braided and symmetric monoidal categories

The basic definitions of braided monoidal categories, and symmetric monoidal categories, as well as braided functors.

Implementation note

We make BraidedCategory another typeclass, but then have SymmetricCategory extend this. The rationale is that we are not carrying any additional data, just requiring a property.

Future work

• Construct the Drinfeld center of a monoidal category as a braided monoidal category.
• Say something about pseudo-natural transformations.

References

• Pavel Etingof, Shlomo Gelaki, Dmitri Nikshych, Victor Ostrik, Tensor categories

class CategoryTheory.BraidedCategory (C : Type u) [Category.{v, u} C] [MonoidalCategory C] : Type (max u v)

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.

• braiding (X Y : C) : MonoidalCategoryStruct.tensorObj X Y ≅ MonoidalCategoryStruct.tensorObj Y X

  The braiding natural isomorphism.

• braiding_naturality_right (X : C) {Y Z : C} (f : Y ⟶ Z) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X f) (β_ X Z).hom = CategoryStruct.comp (β_ X Y).hom (MonoidalCategoryStruct.whiskerRight f X)
• braiding_naturality_left {X Y : C} (f : X ⟶ Y) (Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight f Z) (β_ Y Z).hom = CategoryStruct.comp (β_ X Z).hom (MonoidalCategoryStruct.whiskerLeft Z f)
• hexagon_forward (X Y Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).hom (CategoryStruct.comp (β_ X (MonoidalCategoryStruct.tensorObj Y Z)).hom (MonoidalCategoryStruct.associator Y Z X).hom) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Y).hom Z) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).hom (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).hom))

  The first hexagon identity.

• hexagon_reverse (X Y Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).inv (CategoryStruct.comp (β_ (MonoidalCategoryStruct.tensorObj X Y) Z).hom (MonoidalCategoryStruct.associator Z X Y).inv) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).hom) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).inv (MonoidalCategoryStruct.whiskerRight (β_ X Z).hom Y))

  The second hexagon identity.

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_naturality_right_assoc {C : Type u} {inst✝ : Category.{v, u} C} {inst✝¹ : MonoidalCategory C} [self : BraidedCategory C] (X : C) {Y Z : C} (f : Y ⟶ Z) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj Z X ⟶ Z✝) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X f) (CategoryStruct.comp (β_ X Z).hom h) = CategoryStruct.comp (β_ X Y).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight f X) h)

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_naturality_left_assoc {C : Type u} {inst✝ : Category.{v, u} C} {inst✝¹ : MonoidalCategory C} [self : BraidedCategory C] {X Y : C} (f : X ⟶ Y) (Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj Z Y ⟶ Z✝) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight f Z) (CategoryStruct.comp (β_ Y Z).hom h) = CategoryStruct.comp (β_ X Z).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Z f) h)

theorem CategoryTheory.BraidedCategory.hexagon_reverse_assoc {C : Type u} {inst✝ : Category.{v, u} C} {inst✝¹ : MonoidalCategory C} [self : BraidedCategory C] (X Y Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj (MonoidalCategoryStruct.tensorObj Z X) Y ⟶ Z✝) : CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).inv (CategoryStruct.comp (β_ (MonoidalCategoryStruct.tensorObj X Y) Z).hom (CategoryStruct.comp (MonoidalCategoryStruct.associator Z X Y).inv h)) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).hom) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Z).hom Y) h))

theorem CategoryTheory.BraidedCategory.hexagon_forward_assoc {C : Type u} {inst✝ : Category.{v, u} C} {inst✝¹ : MonoidalCategory C} [self : BraidedCategory C] (X Y Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj Y (MonoidalCategoryStruct.tensorObj Z X) ⟶ Z✝) : CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).hom (CategoryStruct.comp (β_ X (MonoidalCategoryStruct.tensorObj Y Z)).hom (CategoryStruct.comp (MonoidalCategoryStruct.associator Y Z X).hom h)) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Y).hom Z) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).hom) h))

def CategoryTheory.termβ_ : Lean.ParserDescr

The braiding natural isomorphism.

Equations

• CategoryTheory.termβ_ = Lean.ParserDescr.node `CategoryTheory.termβ_ 1024 (Lean.ParserDescr.symbol "β_")

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_tensor_left {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : (β_ (MonoidalCategoryStruct.tensorObj X Y) Z).hom = CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).hom) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Z).hom Y) (MonoidalCategoryStruct.associator Z X Y).hom)))

theorem CategoryTheory.BraidedCategory.braiding_tensor_left_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj Z (MonoidalCategoryStruct.tensorObj X Y) ⟶ Z✝) : CategoryStruct.comp (β_ (MonoidalCategoryStruct.tensorObj X Y) Z).hom h = CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).hom) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Z).hom Y) (CategoryStruct.comp (MonoidalCategoryStruct.associator Z X Y).hom h))))

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_tensor_right {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : (β_ X (MonoidalCategoryStruct.tensorObj Y Z)).hom = CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Y).hom Z) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).hom) (MonoidalCategoryStruct.associator Y Z X).inv)))

theorem CategoryTheory.BraidedCategory.braiding_tensor_right_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj (MonoidalCategoryStruct.tensorObj Y Z) X ⟶ Z✝) : CategoryStruct.comp (β_ X (MonoidalCategoryStruct.tensorObj Y Z)).hom h = CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Y).hom Z) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).hom) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y Z X).inv h))))

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_inv_tensor_left {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : (β_ (MonoidalCategoryStruct.tensorObj X Y) Z).inv = CategoryStruct.comp (MonoidalCategoryStruct.associator Z X Y).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Z).inv Y) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).inv) (MonoidalCategoryStruct.associator X Y Z).inv)))

theorem CategoryTheory.BraidedCategory.braiding_inv_tensor_left_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj (MonoidalCategoryStruct.tensorObj X Y) Z ⟶ Z✝) : CategoryStruct.comp (β_ (MonoidalCategoryStruct.tensorObj X Y) Z).inv h = CategoryStruct.comp (MonoidalCategoryStruct.associator Z X Y).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Z).inv Y) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).inv) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).inv h))))

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_inv_tensor_right {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : (β_ X (MonoidalCategoryStruct.tensorObj Y Z)).inv = CategoryStruct.comp (MonoidalCategoryStruct.associator Y Z X).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).inv) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Y).inv Z) (MonoidalCategoryStruct.associator X Y Z).hom)))

theorem CategoryTheory.BraidedCategory.braiding_inv_tensor_right_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj X (MonoidalCategoryStruct.tensorObj Y Z) ⟶ Z✝) : CategoryStruct.comp (β_ X (MonoidalCategoryStruct.tensorObj Y Z)).inv h = CategoryStruct.comp (MonoidalCategoryStruct.associator Y Z X).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).inv) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Y).inv Z) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).hom h))))

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_naturality {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] {X X' Y Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y') : CategoryStruct.comp (MonoidalCategoryStruct.tensorHom f g) (β_ Y Y').hom = CategoryStruct.comp (β_ X X').hom (MonoidalCategoryStruct.tensorHom g f)

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_naturality_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] {X X' Y Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y') {Z : C} (h : MonoidalCategoryStruct.tensorObj Y' Y ⟶ Z) : CategoryStruct.comp (MonoidalCategoryStruct.tensorHom f g) (CategoryStruct.comp (β_ Y Y').hom h) = CategoryStruct.comp (β_ X X').hom (CategoryStruct.comp (MonoidalCategoryStruct.tensorHom g f) h)

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_inv_naturality_right {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X : C) {Y Z : C} (f : Y ⟶ Z) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X f) (β_ Z X).inv = CategoryStruct.comp (β_ Y X).inv (MonoidalCategoryStruct.whiskerRight f X)

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_inv_naturality_right_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X : C) {Y Z : C} (f : Y ⟶ Z) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj Z X ⟶ Z✝) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X f) (CategoryStruct.comp (β_ Z X).inv h) = CategoryStruct.comp (β_ Y X).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight f X) h)

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_inv_naturality_left {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] {X Y : C} (f : X ⟶ Y) (Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight f Z) (β_ Z Y).inv = CategoryStruct.comp (β_ Z X).inv (MonoidalCategoryStruct.whiskerLeft Z f)

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_inv_naturality_left_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] {X Y : C} (f : X ⟶ Y) (Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj Z Y ⟶ Z✝) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight f Z) (CategoryStruct.comp (β_ Z Y).inv h) = CategoryStruct.comp (β_ Z X).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Z f) h)

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_inv_naturality {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] {X X' Y Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y') : CategoryStruct.comp (MonoidalCategoryStruct.tensorHom f g) (β_ Y' Y).inv = CategoryStruct.comp (β_ X' X).inv (MonoidalCategoryStruct.tensorHom g f)

@[simp]

theorem CategoryTheory.BraidedCategory.braiding_inv_naturality_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] {X X' Y Y' : C} (f : X ⟶ Y) (g : X' ⟶ Y') {Z : C} (h : MonoidalCategoryStruct.tensorObj Y' Y ⟶ Z) : CategoryStruct.comp (MonoidalCategoryStruct.tensorHom f g) (CategoryStruct.comp (β_ Y' Y).inv h) = CategoryStruct.comp (β_ X' X).inv (CategoryStruct.comp (MonoidalCategoryStruct.tensorHom g f) h)

theorem CategoryTheory.BraidedCategory.yang_baxter {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Y).hom Z) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).hom) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y Z X).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ Y Z).hom X) (MonoidalCategoryStruct.associator Z Y X).hom))))) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).hom) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Z).hom Y) (CategoryStruct.comp (MonoidalCategoryStruct.associator Z X Y).hom (MonoidalCategoryStruct.whiskerLeft Z (β_ X Y).hom))))

theorem CategoryTheory.BraidedCategory.yang_baxter_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj Z (MonoidalCategoryStruct.tensorObj Y X) ⟶ Z✝) : CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Y).hom Z) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).hom) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y Z X).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ Y Z).hom X) (CategoryStruct.comp (MonoidalCategoryStruct.associator Z Y X).hom h)))))) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).hom) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Z).hom Y) (CategoryStruct.comp (MonoidalCategoryStruct.associator Z X Y).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Z (β_ X Y).hom) h))))

theorem CategoryTheory.BraidedCategory.yang_baxter' {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : monoidalComp (MonoidalCategoryStruct.whiskerRight (β_ X Y).hom Z) (monoidalComp (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).hom) (MonoidalCategoryStruct.whiskerRight (β_ Y Z).hom X)) = monoidalComp (CategoryStruct.id (MonoidalCategoryStruct.tensorObj (MonoidalCategoryStruct.tensorObj X Y) Z)) (monoidalComp (monoidalComp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).hom) (monoidalComp (MonoidalCategoryStruct.whiskerRight (β_ X Z).hom Y) (MonoidalCategoryStruct.whiskerLeft Z (β_ X Y).hom))) (CategoryStruct.id (MonoidalCategoryStruct.tensorObj (MonoidalCategoryStruct.tensorObj Z Y) X)))

theorem CategoryTheory.BraidedCategory.yang_baxter_iso {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : (MonoidalCategoryStruct.associator X Y Z).symm ≪≫ MonoidalCategory.whiskerRightIso (β_ X Y) Z ≪≫ MonoidalCategoryStruct.associator Y X Z ≪≫ MonoidalCategory.whiskerLeftIso Y (β_ X Z) ≪≫ (MonoidalCategoryStruct.associator Y Z X).symm ≪≫ MonoidalCategory.whiskerRightIso (β_ Y Z) X ≪≫ MonoidalCategoryStruct.associator Z Y X = MonoidalCategory.whiskerLeftIso X (β_ Y Z) ≪≫ (MonoidalCategoryStruct.associator X Z Y).symm ≪≫ MonoidalCategory.whiskerRightIso (β_ X Z) Y ≪≫ MonoidalCategoryStruct.associator Z X Y ≪≫ MonoidalCategory.whiskerLeftIso Z (β_ X Y)

theorem CategoryTheory.BraidedCategory.hexagon_forward_iso {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : MonoidalCategoryStruct.associator X Y Z ≪≫ β_ X (MonoidalCategoryStruct.tensorObj Y Z) ≪≫ MonoidalCategoryStruct.associator Y Z X = MonoidalCategory.whiskerRightIso (β_ X Y) Z ≪≫ MonoidalCategoryStruct.associator Y X Z ≪≫ MonoidalCategory.whiskerLeftIso Y (β_ X Z)

theorem CategoryTheory.BraidedCategory.hexagon_reverse_iso {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : (MonoidalCategoryStruct.associator X Y Z).symm ≪≫ β_ (MonoidalCategoryStruct.tensorObj X Y) Z ≪≫ (MonoidalCategoryStruct.associator Z X Y).symm = MonoidalCategory.whiskerLeftIso X (β_ Y Z) ≪≫ (MonoidalCategoryStruct.associator X Z Y).symm ≪≫ MonoidalCategory.whiskerRightIso (β_ X Z) Y

theorem CategoryTheory.BraidedCategory.hexagon_forward_inv {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.associator Y Z X).inv (CategoryStruct.comp (β_ X (MonoidalCategoryStruct.tensorObj Y Z)).inv (MonoidalCategoryStruct.associator X Y Z).inv) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).inv) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).inv (MonoidalCategoryStruct.whiskerRight (β_ X Y).inv Z))

theorem CategoryTheory.BraidedCategory.hexagon_forward_inv_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj (MonoidalCategoryStruct.tensorObj X Y) Z ⟶ Z✝) : CategoryStruct.comp (MonoidalCategoryStruct.associator Y Z X).inv (CategoryStruct.comp (β_ X (MonoidalCategoryStruct.tensorObj Y Z)).inv (CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).inv h)) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).inv) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Y).inv Z) h))

theorem CategoryTheory.BraidedCategory.hexagon_reverse_inv {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.associator Z X Y).hom (CategoryStruct.comp (β_ (MonoidalCategoryStruct.tensorObj X Y) Z).inv (MonoidalCategoryStruct.associator X Y Z).hom) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Z).inv Y) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).hom (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).inv))

theorem CategoryTheory.BraidedCategory.hexagon_reverse_inv_assoc {C : Type u} [Category.{v, u} C] [MonoidalCategory C] [BraidedCategory C] (X Y Z : C) {Z✝ : C} (h : MonoidalCategoryStruct.tensorObj X (MonoidalCategoryStruct.tensorObj Y Z) ⟶ Z✝) : CategoryStruct.comp (MonoidalCategoryStruct.associator Z X Y).hom (CategoryStruct.comp (β_ (MonoidalCategoryStruct.tensorObj X Y) Z).inv (CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).hom h)) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Z).inv Y) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).inv) h))

def CategoryTheory.braidedCategoryOfFaithful {C : Type u_1} {D : Type u_2} [Category.{u_3, u_1} C] [Category.{u_4, u_2} D] [MonoidalCategory C] [MonoidalCategory D] (F : Functor C D) [F.Monoidal] [F.Faithful] [BraidedCategory D] (β : (X Y : C) → MonoidalCategoryStruct.tensorObj X Y ≅ MonoidalCategoryStruct.tensorObj Y X) (w : ∀ (X Y : C), CategoryStruct.comp (Functor.LaxMonoidal.μ F X Y) (F.map (β X Y).hom) = CategoryStruct.comp (β_ (F.obj X) (F.obj Y)).hom (Functor.LaxMonoidal.μ F Y X)) : BraidedCategory C

Verifying the axioms for a braiding by checking that the candidate braiding is sent to a braiding by a faithful monoidal functor.

Equations

• CategoryTheory.braidedCategoryOfFaithful F β w = { braiding := β, braiding_naturality_right := ⋯, braiding_naturality_left := ⋯, hexagon_forward := ⋯, hexagon_reverse := ⋯ }

noncomputable def CategoryTheory.braidedCategoryOfFullyFaithful {C : Type u_1} {D : Type u_2} [Category.{u_3, u_1} C] [Category.{u_4, u_2} D] [MonoidalCategory C] [MonoidalCategory D] (F : Functor C D) [F.Monoidal] [F.Full] [F.Faithful] [BraidedCategory D] : BraidedCategory C

Pull back a braiding along a fully faithful monoidal functor.

Equations

• One or more equations did not get rendered due to their size.

We now establish how the braiding interacts with the unitors.

I couldn't find a detailed proof in print, but this is discussed in:

• Proposition 1 of André Joyal and Ross Street, "Braided monoidal categories", Macquarie Math Reports 860081 (1986).
• Proposition 2.1 of André Joyal and Ross Street, "Braided tensor categories" , Adv. Math. 102 (1993), 20–78.
• Exercise 8.1.6 of Etingof, Gelaki, Nikshych, Ostrik, "Tensor categories", vol 25, Mathematical Surveys and Monographs (2015), AMS.

theorem CategoryTheory.braiding_leftUnitor_aux₁ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : CategoryStruct.comp (MonoidalCategoryStruct.associator (𝟙_ C) (𝟙_ C) X).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft (𝟙_ C) (β_ X (𝟙_ C)).inv) (CategoryStruct.comp (MonoidalCategoryStruct.associator (𝟙_ C) X (𝟙_ C)).inv (MonoidalCategoryStruct.whiskerRight (MonoidalCategoryStruct.leftUnitor X).hom (𝟙_ C)))) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (MonoidalCategoryStruct.leftUnitor (𝟙_ C)).hom X) (β_ X (𝟙_ C)).inv

theorem CategoryTheory.braiding_leftUnitor_aux₂ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X (𝟙_ C)).hom (𝟙_ C)) (MonoidalCategoryStruct.whiskerRight (MonoidalCategoryStruct.leftUnitor X).hom (𝟙_ C)) = MonoidalCategoryStruct.whiskerRight (MonoidalCategoryStruct.rightUnitor X).hom (𝟙_ C)

theorem CategoryTheory.braiding_leftUnitor {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : CategoryStruct.comp (β_ X (𝟙_ C)).hom (MonoidalCategoryStruct.leftUnitor X).hom = (MonoidalCategoryStruct.rightUnitor X).hom

theorem CategoryTheory.braiding_leftUnitor_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) {Z : C} (h : X ⟶ Z) : CategoryStruct.comp (β_ X (𝟙_ C)).hom (CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).hom h) = CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).hom h

theorem CategoryTheory.braiding_rightUnitor_aux₁ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : CategoryStruct.comp (MonoidalCategoryStruct.associator X (𝟙_ C) (𝟙_ C)).inv (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ (𝟙_ C) X).inv (𝟙_ C)) (CategoryStruct.comp (MonoidalCategoryStruct.associator (𝟙_ C) X (𝟙_ C)).hom (MonoidalCategoryStruct.whiskerLeft (𝟙_ C) (MonoidalCategoryStruct.rightUnitor X).hom))) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (MonoidalCategoryStruct.rightUnitor (𝟙_ C)).hom) (β_ (𝟙_ C) X).inv

theorem CategoryTheory.braiding_rightUnitor_aux₂ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft (𝟙_ C) (β_ (𝟙_ C) X).hom) (MonoidalCategoryStruct.whiskerLeft (𝟙_ C) (MonoidalCategoryStruct.rightUnitor X).hom) = MonoidalCategoryStruct.whiskerLeft (𝟙_ C) (MonoidalCategoryStruct.leftUnitor X).hom

theorem CategoryTheory.braiding_rightUnitor {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : CategoryStruct.comp (β_ (𝟙_ C) X).hom (MonoidalCategoryStruct.rightUnitor X).hom = (MonoidalCategoryStruct.leftUnitor X).hom

theorem CategoryTheory.braiding_rightUnitor_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) {Z : C} (h : X ⟶ Z) : CategoryStruct.comp (β_ (𝟙_ C) X).hom (CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).hom h) = CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).hom h

@[simp]

theorem CategoryTheory.braiding_tensorUnit_left {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : (β_ (𝟙_ C) X).hom = CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).hom (MonoidalCategoryStruct.rightUnitor X).inv

theorem CategoryTheory.braiding_tensorUnit_left_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) {Z : C} (h : MonoidalCategoryStruct.tensorObj X (𝟙_ C) ⟶ Z) : CategoryStruct.comp (β_ (𝟙_ C) X).hom h = CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).hom (CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).inv h)

@[simp]

theorem CategoryTheory.braiding_inv_tensorUnit_left {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : (β_ (𝟙_ C) X).inv = CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).hom (MonoidalCategoryStruct.leftUnitor X).inv

theorem CategoryTheory.braiding_inv_tensorUnit_left_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) {Z : C} (h : MonoidalCategoryStruct.tensorObj (𝟙_ C) X ⟶ Z) : CategoryStruct.comp (β_ (𝟙_ C) X).inv h = CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).hom (CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).inv h)

theorem CategoryTheory.leftUnitor_inv_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).inv (β_ (𝟙_ C) X).hom = (MonoidalCategoryStruct.rightUnitor X).inv

theorem CategoryTheory.leftUnitor_inv_braiding_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) {Z : C} (h : MonoidalCategoryStruct.tensorObj X (𝟙_ C) ⟶ Z) : CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).inv (CategoryStruct.comp (β_ (𝟙_ C) X).hom h) = CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).inv h

theorem CategoryTheory.rightUnitor_inv_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).inv (β_ X (𝟙_ C)).hom = (MonoidalCategoryStruct.leftUnitor X).inv

theorem CategoryTheory.rightUnitor_inv_braiding_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) {Z : C} (h : MonoidalCategoryStruct.tensorObj (𝟙_ C) X ⟶ Z) : CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).inv (CategoryStruct.comp (β_ X (𝟙_ C)).hom h) = CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).inv h

@[simp]

theorem CategoryTheory.braiding_tensorUnit_right {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : (β_ X (𝟙_ C)).hom = CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).hom (MonoidalCategoryStruct.leftUnitor X).inv

theorem CategoryTheory.braiding_tensorUnit_right_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) {Z : C} (h : MonoidalCategoryStruct.tensorObj (𝟙_ C) X ⟶ Z) : CategoryStruct.comp (β_ X (𝟙_ C)).hom h = CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).hom (CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).inv h)

@[simp]

theorem CategoryTheory.braiding_inv_tensorUnit_right {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) : (β_ X (𝟙_ C)).inv = CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).hom (MonoidalCategoryStruct.rightUnitor X).inv

theorem CategoryTheory.braiding_inv_tensorUnit_right_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X : C) {Z : C} (h : MonoidalCategoryStruct.tensorObj X (𝟙_ C) ⟶ Z) : CategoryStruct.comp (β_ X (𝟙_ C)).inv h = CategoryStruct.comp (MonoidalCategoryStruct.leftUnitor X).hom (CategoryStruct.comp (MonoidalCategoryStruct.rightUnitor X).inv h)

class CategoryTheory.SymmetricCategory (C : Type u) [Category.{v, u} C] [MonoidalCategory C] extends CategoryTheory.BraidedCategory C : Type (max u v)

A symmetric monoidal category is a braided monoidal category for which the braiding is symmetric.

See https://stacks.math.columbia.edu/tag/0FFW.

• braiding (X Y : C) : MonoidalCategoryStruct.tensorObj X Y ≅ MonoidalCategoryStruct.tensorObj Y X
• braiding_naturality_right (X : C) {Y Z : C} (f : Y ⟶ Z) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X f) (β_ X Z).hom = CategoryStruct.comp (β_ X Y).hom (MonoidalCategoryStruct.whiskerRight f X)
• braiding_naturality_left {X Y : C} (f : X ⟶ Y) (Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight f Z) (β_ Y Z).hom = CategoryStruct.comp (β_ X Z).hom (MonoidalCategoryStruct.whiskerLeft Z f)
• hexagon_forward (X Y Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).hom (CategoryStruct.comp (β_ X (MonoidalCategoryStruct.tensorObj Y Z)).hom (MonoidalCategoryStruct.associator Y Z X).hom) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (β_ X Y).hom Z) (CategoryStruct.comp (MonoidalCategoryStruct.associator Y X Z).hom (MonoidalCategoryStruct.whiskerLeft Y (β_ X Z).hom))
• hexagon_reverse (X Y Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.associator X Y Z).inv (CategoryStruct.comp (β_ (MonoidalCategoryStruct.tensorObj X Y) Z).hom (MonoidalCategoryStruct.associator Z X Y).inv) = CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft X (β_ Y Z).hom) (CategoryStruct.comp (MonoidalCategoryStruct.associator X Z Y).inv (MonoidalCategoryStruct.whiskerRight (β_ X Z).hom Y))
• symmetry (X Y : C) : CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom = CategoryStruct.id (MonoidalCategoryStruct.tensorObj X Y)

@[simp]

theorem CategoryTheory.SymmetricCategory.symmetry_assoc {C : Type u} {inst✝ : Category.{v, u} C} {inst✝¹ : MonoidalCategory C} [self : SymmetricCategory C] (X Y : C) {Z : C} (h : MonoidalCategoryStruct.tensorObj X Y ⟶ Z) : CategoryStruct.comp (β_ X Y).hom (CategoryStruct.comp (β_ Y X).hom h) = h

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

class CategoryTheory.Functor.LaxBraided {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] (F : Functor C D) extends F.LaxMonoidal : Type (max u₁ v₂)

A lax braided functor between braided monoidal categories is a lax monoidal functor which preserves the braiding.

• ε' : 𝟙_ D ⟶ F.obj (𝟙_ C)
• μ' (X Y : C) : MonoidalCategoryStruct.tensorObj (F.obj X) (F.obj Y) ⟶ F.obj (MonoidalCategoryStruct.tensorObj X Y)
• μ'_natural_left {X Y : C} (f : X ⟶ Y) (X' : C) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (F.map f) (F.obj X')) (μ' Y X') = CategoryStruct.comp (μ' X X') (F.map (MonoidalCategoryStruct.whiskerRight f X'))
• μ'_natural_right {X Y : C} (X' : C) (f : X ⟶ Y) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft (F.obj X') (F.map f)) (μ' X' Y) = CategoryStruct.comp (μ' X' X) (F.map (MonoidalCategoryStruct.whiskerLeft X' f))
• associativity' (X Y Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (μ' X Y) (F.obj Z)) (CategoryStruct.comp (μ' (MonoidalCategoryStruct.tensorObj X Y) Z) (F.map (MonoidalCategoryStruct.associator X Y Z).hom)) = CategoryStruct.comp (MonoidalCategoryStruct.associator (F.obj X) (F.obj Y) (F.obj Z)).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft (F.obj X) (μ' Y Z)) (μ' X (MonoidalCategoryStruct.tensorObj Y Z)))
• left_unitality' (X : C) : (MonoidalCategoryStruct.leftUnitor (F.obj X)).hom = CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight ε' (F.obj X)) (CategoryStruct.comp (μ' (𝟙_ C) X) (F.map (MonoidalCategoryStruct.leftUnitor X).hom))
• right_unitality' (X : C) : (MonoidalCategoryStruct.rightUnitor (F.obj X)).hom = CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft (F.obj X) ε') (CategoryStruct.comp (μ' X (𝟙_ C)) (F.map (MonoidalCategoryStruct.rightUnitor X).hom))
• braided (X Y : C) : CategoryStruct.comp (LaxMonoidal.μ F X Y) (F.map (β_ X Y).hom) = CategoryStruct.comp (β_ (F.obj X) (F.obj Y)).hom (LaxMonoidal.μ F Y X)

theorem CategoryTheory.Functor.LaxBraided.braided_assoc {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} {F : Functor C D} [self : F.LaxBraided] (X Y : C) {Z : D} (h : F.obj (MonoidalCategoryStruct.tensorObj Y X) ⟶ Z) : CategoryStruct.comp (LaxMonoidal.μ F X Y) (CategoryStruct.comp (F.map (β_ X Y).hom) h) = CategoryStruct.comp (β_ (F.obj X) (F.obj Y)).hom (CategoryStruct.comp (LaxMonoidal.μ F Y X) h)

instance CategoryTheory.Functor.LaxBraided.id {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : (Functor.id C).LaxBraided

Equations

• CategoryTheory.Functor.LaxBraided.id = CategoryTheory.Functor.LaxBraided.mk ⋯

instance CategoryTheory.Functor.LaxBraided.instComp {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {E : Type u₃} [Category.{v₃, u₃} E] [MonoidalCategory E] [BraidedCategory E] (F : Functor C D) (G : Functor D E) [F.LaxBraided] [G.LaxBraided] : (F.comp G).LaxBraided

Equations

• CategoryTheory.Functor.LaxBraided.instComp F G = CategoryTheory.Functor.LaxBraided.mk ⋯

structure CategoryTheory.LaxBraidedFunctor (C : Type u₁) [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (D : Type u₂) [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] extends CategoryTheory.Functor C D : Type (max (max (max u₁ u₂) v₁) v₂)

Bundled version of lax braided functors.

• obj : C → D
• map {X Y : C} : (X ⟶ Y) → (self.obj X ⟶ self.obj Y)
• map_id (X : C) : self.map (CategoryStruct.id X) = CategoryStruct.id (self.obj X)
• map_comp {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) : self.map (CategoryStruct.comp f g) = CategoryStruct.comp (self.map f) (self.map g)
• laxBraided : self.LaxBraided

def CategoryTheory.LaxBraidedFunctor.of {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] (F : Functor C D) [F.LaxBraided] : LaxBraidedFunctor C D

Constructor for LaxBraidedFunctor C D.

Equations

• CategoryTheory.LaxBraidedFunctor.of F = { toFunctor := F, laxBraided := inferInstance }

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.of_toFunctor {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] (F : Functor C D) [F.LaxBraided] : (of F).toFunctor = F

def CategoryTheory.LaxBraidedFunctor.toLaxMonoidalFunctor {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] (F : LaxBraidedFunctor C D) : LaxMonoidalFunctor C D

The lax monoidal functor induced by a lax braided functor.

Equations

• F.toLaxMonoidalFunctor = { toFunctor := F.toFunctor, laxMonoidal := inferInstance }

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.toLaxMonoidalFunctor_toFunctor {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] (F : LaxBraidedFunctor C D) : F.toLaxMonoidalFunctor.toFunctor = F.toFunctor

instance CategoryTheory.LaxBraidedFunctor.instCategory {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] : Category.{max u₁ v₂, max (max (max u₂ u₁) v₂) v₁} (LaxBraidedFunctor C D)

Equations

• CategoryTheory.LaxBraidedFunctor.instCategory = CategoryTheory.InducedCategory.category CategoryTheory.LaxBraidedFunctor.toLaxMonoidalFunctor

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.id_hom {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] (F : LaxBraidedFunctor C D) : (CategoryStruct.id F).hom = CategoryStruct.id F.toLaxMonoidalFunctor.toFunctor

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.comp_hom {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G H : LaxBraidedFunctor C D} (α : F ⟶ G) (β : G ⟶ H) : (CategoryStruct.comp α β).hom = CategoryStruct.comp α.hom β.hom

theorem CategoryTheory.LaxBraidedFunctor.comp_hom_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G H : LaxBraidedFunctor C D} (α : F ⟶ G) (β : G ⟶ H) {Z : Functor C D} (h : H.toLaxMonoidalFunctor.toFunctor ⟶ Z) : CategoryStruct.comp (CategoryStruct.comp α β).hom h = CategoryStruct.comp α.hom (CategoryStruct.comp β.hom h)

theorem CategoryTheory.LaxBraidedFunctor.hom_ext {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G : LaxBraidedFunctor C D} {α β : F ⟶ G} (h : α.hom = β.hom) : α = β

def CategoryTheory.LaxBraidedFunctor.homMk {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G : LaxBraidedFunctor C D} (f : F.toFunctor ⟶ G.toFunctor) [NatTrans.IsMonoidal f] : F ⟶ G

Constructor for morphisms in the category LaxBraiededFunctor C D.

Equations

• CategoryTheory.LaxBraidedFunctor.homMk f = { hom := f, isMonoidal := ⋯ }

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.homMk_hom {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G : LaxBraidedFunctor C D} (f : F.toFunctor ⟶ G.toFunctor) [NatTrans.IsMonoidal f] : (homMk f).hom = f

def CategoryTheory.LaxBraidedFunctor.isoMk {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G : LaxBraidedFunctor C D} (e : F.toFunctor ≅ G.toFunctor) [NatTrans.IsMonoidal e.hom] : F ≅ G

Constructor for isomorphisms in the category LaxBraidedFunctor C D.

Equations

• CategoryTheory.LaxBraidedFunctor.isoMk e = { hom := CategoryTheory.LaxBraidedFunctor.homMk e.hom, inv := CategoryTheory.LaxBraidedFunctor.homMk e.inv, hom_inv_id := ⋯, inv_hom_id := ⋯ }

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.isoMk_hom {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G : LaxBraidedFunctor C D} (e : F.toFunctor ≅ G.toFunctor) [NatTrans.IsMonoidal e.hom] : (isoMk e).hom = homMk e.hom

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.isoMk_inv {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G : LaxBraidedFunctor C D} (e : F.toFunctor ≅ G.toFunctor) [NatTrans.IsMonoidal e.hom] : (isoMk e).inv = homMk e.inv

def CategoryTheory.LaxBraidedFunctor.forget {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] : Functor (LaxBraidedFunctor C D) (LaxMonoidalFunctor C D)

The forgetful functor from lax braided functors to lax monoidal functors.

Equations

• CategoryTheory.LaxBraidedFunctor.forget = CategoryTheory.inducedFunctor CategoryTheory.LaxBraidedFunctor.toLaxMonoidalFunctor

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.forget_map {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {X✝ Y✝ : InducedCategory (LaxMonoidalFunctor C D) toLaxMonoidalFunctor} (f : X✝ ⟶ Y✝) : forget.map f = f

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.forget_obj {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] (F : LaxBraidedFunctor C D) : forget.obj F = F.toLaxMonoidalFunctor

def CategoryTheory.LaxBraidedFunctor.fullyFaithfulForget {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] : forget.FullyFaithful

The forgetful functor from lax braided functors to lax monoidal functors is fully faithful.

Equations

• CategoryTheory.LaxBraidedFunctor.fullyFaithfulForget = CategoryTheory.fullyFaithfulInducedFunctor CategoryTheory.LaxBraidedFunctor.toLaxMonoidalFunctor

def CategoryTheory.LaxBraidedFunctor.isoOfComponents {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G : LaxBraidedFunctor C D} (e : (X : C) → F.obj X ≅ G.obj X) (naturality : ∀ {X Y : C} (f : X ⟶ Y), CategoryStruct.comp (F.map f) (e Y).hom = CategoryStruct.comp (e X).hom (G.map f) := by aesop_cat) (unit : CategoryStruct.comp (Functor.LaxMonoidal.ε F.toFunctor) (e (𝟙_ C)).hom = Functor.LaxMonoidal.ε G.toFunctor := by aesop_cat) (tensor : ∀ (X Y : C), CategoryStruct.comp (Functor.LaxMonoidal.μ F.toFunctor X Y) (e (MonoidalCategoryStruct.tensorObj X Y)).hom = CategoryStruct.comp (MonoidalCategoryStruct.tensorHom (e X).hom (e Y).hom) (Functor.LaxMonoidal.μ G.toFunctor X Y) := by aesop_cat) : F ≅ G

Constructor for isomorphisms between lax braided functors.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.isoOfComponents_hom_hom_app {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G : LaxBraidedFunctor C D} (e : (X : C) → F.obj X ≅ G.obj X) (naturality : ∀ {X Y : C} (f : X ⟶ Y), CategoryStruct.comp (F.map f) (e Y).hom = CategoryStruct.comp (e X).hom (G.map f) := by aesop_cat) (unit : CategoryStruct.comp (Functor.LaxMonoidal.ε F.toFunctor) (e (𝟙_ C)).hom = Functor.LaxMonoidal.ε G.toFunctor := by aesop_cat) (tensor : ∀ (X Y : C), CategoryStruct.comp (Functor.LaxMonoidal.μ F.toFunctor X Y) (e (MonoidalCategoryStruct.tensorObj X Y)).hom = CategoryStruct.comp (MonoidalCategoryStruct.tensorHom (e X).hom (e Y).hom) (Functor.LaxMonoidal.μ G.toFunctor X Y) := by aesop_cat) (X : C) : (isoOfComponents e ⋯ unit tensor).hom.hom.app X = (e X).hom

@[simp]

theorem CategoryTheory.LaxBraidedFunctor.isoOfComponents_inv_hom_app {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {F G : LaxBraidedFunctor C D} (e : (X : C) → F.obj X ≅ G.obj X) (naturality : ∀ {X Y : C} (f : X ⟶ Y), CategoryStruct.comp (F.map f) (e Y).hom = CategoryStruct.comp (e X).hom (G.map f) := by aesop_cat) (unit : CategoryStruct.comp (Functor.LaxMonoidal.ε F.toFunctor) (e (𝟙_ C)).hom = Functor.LaxMonoidal.ε G.toFunctor := by aesop_cat) (tensor : ∀ (X Y : C), CategoryStruct.comp (Functor.LaxMonoidal.μ F.toFunctor X Y) (e (MonoidalCategoryStruct.tensorObj X Y)).hom = CategoryStruct.comp (MonoidalCategoryStruct.tensorHom (e X).hom (e Y).hom) (Functor.LaxMonoidal.μ G.toFunctor X Y) := by aesop_cat) (X : C) : (isoOfComponents e ⋯ unit tensor).inv.hom.app X = (e X).inv

class CategoryTheory.Functor.Braided {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] (F : Functor C D) extends F.Monoidal, F.LaxBraided : Type (max u₁ v₂)

A braided functor between braided monoidal categories is a monoidal functor which preserves the braiding.

• ε' : 𝟙_ D ⟶ F.obj (𝟙_ C)
• μ' (X Y : C) : MonoidalCategoryStruct.tensorObj (F.obj X) (F.obj Y) ⟶ F.obj (MonoidalCategoryStruct.tensorObj X Y)
• μ'_natural_left {X Y : C} (f : X ⟶ Y) (X' : C) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (F.map f) (F.obj X')) (μ' Y X') = CategoryStruct.comp (μ' X X') (F.map (MonoidalCategoryStruct.whiskerRight f X'))
• μ'_natural_right {X Y : C} (X' : C) (f : X ⟶ Y) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft (F.obj X') (F.map f)) (μ' X' Y) = CategoryStruct.comp (μ' X' X) (F.map (MonoidalCategoryStruct.whiskerLeft X' f))
• associativity' (X Y Z : C) : CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (μ' X Y) (F.obj Z)) (CategoryStruct.comp (μ' (MonoidalCategoryStruct.tensorObj X Y) Z) (F.map (MonoidalCategoryStruct.associator X Y Z).hom)) = CategoryStruct.comp (MonoidalCategoryStruct.associator (F.obj X) (F.obj Y) (F.obj Z)).hom (CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft (F.obj X) (μ' Y Z)) (μ' X (MonoidalCategoryStruct.tensorObj Y Z)))
• left_unitality' (X : C) : (MonoidalCategoryStruct.leftUnitor (F.obj X)).hom = CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight ε' (F.obj X)) (CategoryStruct.comp (μ' (𝟙_ C) X) (F.map (MonoidalCategoryStruct.leftUnitor X).hom))
• right_unitality' (X : C) : (MonoidalCategoryStruct.rightUnitor (F.obj X)).hom = CategoryStruct.comp (MonoidalCategoryStruct.whiskerLeft (F.obj X) ε') (CategoryStruct.comp (μ' X (𝟙_ C)) (F.map (MonoidalCategoryStruct.rightUnitor X).hom))
• η' : F.obj (𝟙_ C) ⟶ 𝟙_ D
• δ' (X Y : C) : F.obj (MonoidalCategoryStruct.tensorObj X Y) ⟶ MonoidalCategoryStruct.tensorObj (F.obj X) (F.obj Y)
• δ'_natural_left {X Y : C} (f : X ⟶ Y) (X' : C) : CategoryStruct.comp (δ' X X') (MonoidalCategoryStruct.whiskerRight (F.map f) (F.obj X')) = CategoryStruct.comp (F.map (MonoidalCategoryStruct.whiskerRight f X')) (δ' Y X')
• δ'_natural_right {X Y : C} (X' : C) (f : X ⟶ Y) : CategoryStruct.comp (δ' X' X) (MonoidalCategoryStruct.whiskerLeft (F.obj X') (F.map f)) = CategoryStruct.comp (F.map (MonoidalCategoryStruct.whiskerLeft X' f)) (δ' X' Y)
• oplax_associativity' (X Y Z : C) : CategoryStruct.comp (δ' (MonoidalCategoryStruct.tensorObj X Y) Z) (CategoryStruct.comp (MonoidalCategoryStruct.whiskerRight (δ' X Y) (F.obj Z)) (MonoidalCategoryStruct.associator (F.obj X) (F.obj Y) (F.obj Z)).hom) = CategoryStruct.comp (F.map (MonoidalCategoryStruct.associator X Y Z).hom) (CategoryStruct.comp (δ' X (MonoidalCategoryStruct.tensorObj Y Z)) (MonoidalCategoryStruct.whiskerLeft (F.obj X) (δ' Y Z)))
• oplax_left_unitality' (X : C) : (MonoidalCategoryStruct.leftUnitor (F.obj X)).inv = CategoryStruct.comp (F.map (MonoidalCategoryStruct.leftUnitor X).inv) (CategoryStruct.comp (δ' (𝟙_ C) X) (MonoidalCategoryStruct.whiskerRight η' (F.obj X)))
• oplax_right_unitality' (X : C) : (MonoidalCategoryStruct.rightUnitor (F.obj X)).inv = CategoryStruct.comp (F.map (MonoidalCategoryStruct.rightUnitor X).inv) (CategoryStruct.comp (δ' X (𝟙_ C)) (MonoidalCategoryStruct.whiskerLeft (F.obj X) η'))
• ε_η : CategoryStruct.comp (LaxMonoidal.ε F) (OplaxMonoidal.η F) = CategoryStruct.id (𝟙_ D)
• η_ε : CategoryStruct.comp (OplaxMonoidal.η F) (LaxMonoidal.ε F) = CategoryStruct.id (F.obj (𝟙_ C))
• μ_δ (X Y : C) : CategoryStruct.comp (LaxMonoidal.μ F X Y) (OplaxMonoidal.δ F X Y) = CategoryStruct.id (MonoidalCategoryStruct.tensorObj (F.obj X) (F.obj Y))
• δ_μ (X Y : C) : CategoryStruct.comp (OplaxMonoidal.δ F X Y) (LaxMonoidal.μ F X Y) = CategoryStruct.id (F.obj (MonoidalCategoryStruct.tensorObj X Y))
• braided (X Y : C) : CategoryStruct.comp (LaxMonoidal.μ F X Y) (F.map (β_ X Y).hom) = CategoryStruct.comp (β_ (F.obj X) (F.obj Y)).hom (LaxMonoidal.μ F Y X)

@[simp]

theorem CategoryTheory.Functor.map_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] (F : Functor C D) (X Y : C) [F.Braided] : F.map (β_ X Y).hom = CategoryStruct.comp (OplaxMonoidal.δ F X Y) (CategoryStruct.comp (β_ (F.obj X) (F.obj Y)).hom (LaxMonoidal.μ F Y X))

theorem CategoryTheory.Functor.map_braiding_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] (F : Functor C D) (X Y : C) [F.Braided] {Z : D} (h : F.obj (MonoidalCategoryStruct.tensorObj Y X) ⟶ Z) : CategoryStruct.comp (F.map (β_ X Y).hom) h = CategoryStruct.comp (OplaxMonoidal.δ F X Y) (CategoryStruct.comp (β_ (F.obj X) (F.obj Y)).hom (CategoryStruct.comp (LaxMonoidal.μ F Y X) h))

def CategoryTheory.symmetricCategoryOfFaithful {C : Type u_1} {D : Type u_2} [Category.{u_3, u_1} C] [Category.{u_4, u_2} D] [MonoidalCategory C] [MonoidalCategory D] [BraidedCategory C] [SymmetricCategory D] (F : Functor C D) [F.Braided] [F.Faithful] : SymmetricCategory C

A braided category with a faithful braided functor to a symmetric category is itself symmetric.

Equations

• CategoryTheory.symmetricCategoryOfFaithful F = CategoryTheory.SymmetricCategory.mk ⋯

instance CategoryTheory.Functor.Braided.instId {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : (Functor.id C).Braided

Equations

• CategoryTheory.Functor.Braided.instId = CategoryTheory.Functor.Braided.mk ⋯

instance CategoryTheory.Functor.Braided.instComp {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {D : Type u₂} [Category.{v₂, u₂} D] [MonoidalCategory D] [BraidedCategory D] {E : Type u₃} [Category.{v₃, u₃} E] [MonoidalCategory E] [BraidedCategory E] (F : Functor C D) (G : Functor D E) [F.Braided] [G.Braided] : (F.comp G).Braided

Equations

• CategoryTheory.Functor.Braided.instComp F G = CategoryTheory.Functor.Braided.mk ⋯

instance CategoryTheory.instBraidedCategoryDiscrete (M : Type u) [CommMonoid M] : BraidedCategory (Discrete M)

Equations

• One or more equations did not get rendered due to their size.

instance CategoryTheory.Discrete.monoidalFunctorBraided {M : Type u} [CommMonoid M] {N : Type u} [CommMonoid N] (F : M →* N) : (monoidalFunctor F).Braided

A multiplicative morphism between commutative monoids gives a braided functor between the corresponding discrete braided monoidal categories.

Equations

• CategoryTheory.Discrete.monoidalFunctorBraided F = CategoryTheory.Functor.Braided.mk ⋯

def CategoryTheory.MonoidalCategory.tensorμ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ Y₁ Y₂ : C) : tensorObj (tensorObj X₁ X₂) (tensorObj Y₁ Y₂) ⟶ tensorObj (tensorObj X₁ Y₁) (tensorObj X₂ Y₂)

Swap the second and third objects in (X₁ ⊗ X₂) ⊗ (Y₁ ⊗ Y₂). This is used to strength the tensor product functor from C × C to C as a monoidal functor.

Equations

• One or more equations did not get rendered due to their size.

def CategoryTheory.MonoidalCategory.tensorδ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ Y₁ Y₂ : C) : tensorObj (tensorObj X₁ Y₁) (tensorObj X₂ Y₂) ⟶ tensorObj (tensorObj X₁ X₂) (tensorObj Y₁ Y₂)

The inverse of tensorμ.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.MonoidalCategory.tensorμ_tensorδ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ Y₁ Y₂ : C) : CategoryStruct.comp (tensorμ X₁ X₂ Y₁ Y₂) (tensorδ X₁ X₂ Y₁ Y₂) = CategoryStruct.id (tensorObj (tensorObj X₁ X₂) (tensorObj Y₁ Y₂))

@[simp]

theorem CategoryTheory.MonoidalCategory.tensorμ_tensorδ_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ Y₁ Y₂ : C) {Z : C} (h : tensorObj (tensorObj X₁ X₂) (tensorObj Y₁ Y₂) ⟶ Z) : CategoryStruct.comp (tensorμ X₁ X₂ Y₁ Y₂) (CategoryStruct.comp (tensorδ X₁ X₂ Y₁ Y₂) h) = h

@[simp]

theorem CategoryTheory.MonoidalCategory.tensorδ_tensorμ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ Y₁ Y₂ : C) : CategoryStruct.comp (tensorδ X₁ X₂ Y₁ Y₂) (tensorμ X₁ X₂ Y₁ Y₂) = CategoryStruct.id (tensorObj (tensorObj X₁ Y₁) (tensorObj X₂ Y₂))

@[simp]

theorem CategoryTheory.MonoidalCategory.tensorδ_tensorμ_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ Y₁ Y₂ : C) {Z : C} (h : tensorObj (tensorObj X₁ Y₁) (tensorObj X₂ Y₂) ⟶ Z) : CategoryStruct.comp (tensorδ X₁ X₂ Y₁ Y₂) (CategoryStruct.comp (tensorμ X₁ X₂ Y₁ Y₂) h) = h

theorem CategoryTheory.MonoidalCategory.tensorμ_natural {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {X₁ X₂ Y₁ Y₂ U₁ U₂ V₁ V₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : U₁ ⟶ V₁) (g₂ : U₂ ⟶ V₂) : CategoryStruct.comp (tensorHom (tensorHom f₁ f₂) (tensorHom g₁ g₂)) (tensorμ Y₁ Y₂ V₁ V₂) = CategoryStruct.comp (tensorμ X₁ X₂ U₁ U₂) (tensorHom (tensorHom f₁ g₁) (tensorHom f₂ g₂))

theorem CategoryTheory.MonoidalCategory.tensorμ_natural_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {X₁ X₂ Y₁ Y₂ U₁ U₂ V₁ V₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : U₁ ⟶ V₁) (g₂ : U₂ ⟶ V₂) {Z : C} (h : tensorObj (tensorObj Y₁ V₁) (tensorObj Y₂ V₂) ⟶ Z) : CategoryStruct.comp (tensorHom (tensorHom f₁ f₂) (tensorHom g₁ g₂)) (CategoryStruct.comp (tensorμ Y₁ Y₂ V₁ V₂) h) = CategoryStruct.comp (tensorμ X₁ X₂ U₁ U₂) (CategoryStruct.comp (tensorHom (tensorHom f₁ g₁) (tensorHom f₂ g₂)) h)

theorem CategoryTheory.MonoidalCategory.tensorμ_natural_left {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {X₁ X₂ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (Z₁ Z₂ : C) : CategoryStruct.comp (whiskerRight (tensorHom f₁ f₂) (tensorObj Z₁ Z₂)) (tensorμ Y₁ Y₂ Z₁ Z₂) = CategoryStruct.comp (tensorμ X₁ X₂ Z₁ Z₂) (tensorHom (whiskerRight f₁ Z₁) (whiskerRight f₂ Z₂))

theorem CategoryTheory.MonoidalCategory.tensorμ_natural_left_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] {X₁ X₂ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (Z₁ Z₂ : C) {Z : C} (h : tensorObj (tensorObj Y₁ Z₁) (tensorObj Y₂ Z₂) ⟶ Z) : CategoryStruct.comp (whiskerRight (tensorHom f₁ f₂) (tensorObj Z₁ Z₂)) (CategoryStruct.comp (tensorμ Y₁ Y₂ Z₁ Z₂) h) = CategoryStruct.comp (tensorμ X₁ X₂ Z₁ Z₂) (CategoryStruct.comp (tensorHom (whiskerRight f₁ Z₁) (whiskerRight f₂ Z₂)) h)

theorem CategoryTheory.MonoidalCategory.tensorμ_natural_right {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (Z₁ Z₂ : C) {X₁ X₂ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) : CategoryStruct.comp (whiskerLeft (tensorObj Z₁ Z₂) (tensorHom f₁ f₂)) (tensorμ Z₁ Z₂ Y₁ Y₂) = CategoryStruct.comp (tensorμ Z₁ Z₂ X₁ X₂) (tensorHom (whiskerLeft Z₁ f₁) (whiskerLeft Z₂ f₂))

theorem CategoryTheory.MonoidalCategory.tensorμ_natural_right_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (Z₁ Z₂ : C) {X₁ X₂ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) {Z : C} (h : tensorObj (tensorObj Z₁ Y₁) (tensorObj Z₂ Y₂) ⟶ Z) : CategoryStruct.comp (whiskerLeft (tensorObj Z₁ Z₂) (tensorHom f₁ f₂)) (CategoryStruct.comp (tensorμ Z₁ Z₂ Y₁ Y₂) h) = CategoryStruct.comp (tensorμ Z₁ Z₂ X₁ X₂) (CategoryStruct.comp (tensorHom (whiskerLeft Z₁ f₁) (whiskerLeft Z₂ f₂)) h)

theorem CategoryTheory.MonoidalCategory.tensor_left_unitality {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ : C) : (leftUnitor (tensorObj X₁ X₂)).hom = CategoryStruct.comp (whiskerRight (leftUnitor (𝟙_ C)).inv (tensorObj X₁ X₂)) (CategoryStruct.comp (tensorμ (𝟙_ C) (𝟙_ C) X₁ X₂) (tensorHom (leftUnitor X₁).hom (leftUnitor X₂).hom))

theorem CategoryTheory.MonoidalCategory.tensor_left_unitality_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ : C) {Z : C} (h : tensorObj X₁ X₂ ⟶ Z) : CategoryStruct.comp (leftUnitor (tensorObj X₁ X₂)).hom h = CategoryStruct.comp (whiskerRight (leftUnitor (𝟙_ C)).inv (tensorObj X₁ X₂)) (CategoryStruct.comp (tensorμ (𝟙_ C) (𝟙_ C) X₁ X₂) (CategoryStruct.comp (tensorHom (leftUnitor X₁).hom (leftUnitor X₂).hom) h))

theorem CategoryTheory.MonoidalCategory.tensor_right_unitality {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ : C) : (rightUnitor (tensorObj X₁ X₂)).hom = CategoryStruct.comp (whiskerLeft (tensorObj X₁ X₂) (leftUnitor (𝟙_ C)).inv) (CategoryStruct.comp (tensorμ X₁ X₂ (𝟙_ C) (𝟙_ C)) (tensorHom (rightUnitor X₁).hom (rightUnitor X₂).hom))

theorem CategoryTheory.MonoidalCategory.tensor_right_unitality_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ : C) {Z : C} (h : tensorObj X₁ X₂ ⟶ Z) : CategoryStruct.comp (rightUnitor (tensorObj X₁ X₂)).hom h = CategoryStruct.comp (whiskerLeft (tensorObj X₁ X₂) (leftUnitor (𝟙_ C)).inv) (CategoryStruct.comp (tensorμ X₁ X₂ (𝟙_ C) (𝟙_ C)) (CategoryStruct.comp (tensorHom (rightUnitor X₁).hom (rightUnitor X₂).hom) h))

theorem CategoryTheory.MonoidalCategory.tensor_associativity {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C) : CategoryStruct.comp (whiskerRight (tensorμ X₁ X₂ Y₁ Y₂) (tensorObj Z₁ Z₂)) (CategoryStruct.comp (tensorμ (tensorObj X₁ Y₁) (tensorObj X₂ Y₂) Z₁ Z₂) (tensorHom (associator X₁ Y₁ Z₁).hom (associator X₂ Y₂ Z₂).hom)) = CategoryStruct.comp (associator (tensorObj X₁ X₂) (tensorObj Y₁ Y₂) (tensorObj Z₁ Z₂)).hom (CategoryStruct.comp (whiskerLeft (tensorObj X₁ X₂) (tensorμ Y₁ Y₂ Z₁ Z₂)) (tensorμ X₁ X₂ (tensorObj Y₁ Z₁) (tensorObj Y₂ Z₂)))

theorem CategoryTheory.MonoidalCategory.tensor_associativity_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ Y₁ Y₂ Z₁ Z₂ : C) {Z : C} (h : tensorObj (tensorObj X₁ (tensorObj Y₁ Z₁)) (tensorObj X₂ (tensorObj Y₂ Z₂)) ⟶ Z) : CategoryStruct.comp (whiskerRight (tensorμ X₁ X₂ Y₁ Y₂) (tensorObj Z₁ Z₂)) (CategoryStruct.comp (tensorμ (tensorObj X₁ Y₁) (tensorObj X₂ Y₂) Z₁ Z₂) (CategoryStruct.comp (tensorHom (associator X₁ Y₁ Z₁).hom (associator X₂ Y₂ Z₂).hom) h)) = CategoryStruct.comp (associator (tensorObj X₁ X₂) (tensorObj Y₁ Y₂) (tensorObj Z₁ Z₂)).hom (CategoryStruct.comp (whiskerLeft (tensorObj X₁ X₂) (tensorμ Y₁ Y₂ Z₁ Z₂)) (CategoryStruct.comp (tensorμ X₁ X₂ (tensorObj Y₁ Z₁) (tensorObj Y₂ Z₂)) h))

instance CategoryTheory.MonoidalCategory.tensorMonoidal {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : (tensor C).Monoidal

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.MonoidalCategory.tensor_ε {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : Functor.LaxMonoidal.ε (tensor C) = (leftUnitor (𝟙_ C)).inv

@[simp]

theorem CategoryTheory.MonoidalCategory.tensor_η {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : Functor.OplaxMonoidal.η (tensor C) = (leftUnitor (𝟙_ C)).hom

@[simp]

theorem CategoryTheory.MonoidalCategory.tensor_μ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : C × C) : Functor.LaxMonoidal.μ (tensor C) X Y = tensorμ X.1 X.2 Y.1 Y.2

@[simp]

theorem CategoryTheory.MonoidalCategory.tensor_δ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : C × C) : Functor.OplaxMonoidal.δ (tensor C) X Y = tensorδ X.1 X.2 Y.1 Y.2

theorem CategoryTheory.MonoidalCategory.leftUnitor_monoidal {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ : C) : tensorHom (leftUnitor X₁).hom (leftUnitor X₂).hom = CategoryStruct.comp (tensorμ (𝟙_ C) X₁ (𝟙_ C) X₂) (CategoryStruct.comp (whiskerRight (leftUnitor (𝟙_ C)).hom (tensorObj X₁ X₂)) (leftUnitor (tensorObj X₁ X₂)).hom)

theorem CategoryTheory.MonoidalCategory.leftUnitor_monoidal_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ : C) {Z : C} (h : tensorObj X₁ X₂ ⟶ Z) : CategoryStruct.comp (tensorHom (leftUnitor X₁).hom (leftUnitor X₂).hom) h = CategoryStruct.comp (tensorμ (𝟙_ C) X₁ (𝟙_ C) X₂) (CategoryStruct.comp (whiskerRight (leftUnitor (𝟙_ C)).hom (tensorObj X₁ X₂)) (CategoryStruct.comp (leftUnitor (tensorObj X₁ X₂)).hom h))

theorem CategoryTheory.MonoidalCategory.rightUnitor_monoidal {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ : C) : tensorHom (rightUnitor X₁).hom (rightUnitor X₂).hom = CategoryStruct.comp (tensorμ X₁ (𝟙_ C) X₂ (𝟙_ C)) (CategoryStruct.comp (whiskerLeft (tensorObj X₁ X₂) (leftUnitor (𝟙_ C)).hom) (rightUnitor (tensorObj X₁ X₂)).hom)

theorem CategoryTheory.MonoidalCategory.rightUnitor_monoidal_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ : C) {Z : C} (h : tensorObj X₁ X₂ ⟶ Z) : CategoryStruct.comp (tensorHom (rightUnitor X₁).hom (rightUnitor X₂).hom) h = CategoryStruct.comp (tensorμ X₁ (𝟙_ C) X₂ (𝟙_ C)) (CategoryStruct.comp (whiskerLeft (tensorObj X₁ X₂) (leftUnitor (𝟙_ C)).hom) (CategoryStruct.comp (rightUnitor (tensorObj X₁ X₂)).hom h))

theorem CategoryTheory.MonoidalCategory.associator_monoidal {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ X₃ Y₁ Y₂ Y₃ : C) : CategoryStruct.comp (tensorμ (tensorObj X₁ X₂) X₃ (tensorObj Y₁ Y₂) Y₃) (CategoryStruct.comp (whiskerRight (tensorμ X₁ X₂ Y₁ Y₂) (tensorObj X₃ Y₃)) (associator (tensorObj X₁ Y₁) (tensorObj X₂ Y₂) (tensorObj X₃ Y₃)).hom) = CategoryStruct.comp (tensorHom (associator X₁ X₂ X₃).hom (associator Y₁ Y₂ Y₃).hom) (CategoryStruct.comp (tensorμ X₁ (tensorObj X₂ X₃) Y₁ (tensorObj Y₂ Y₃)) (whiskerLeft (tensorObj X₁ Y₁) (tensorμ X₂ X₃ Y₂ Y₃)))

theorem CategoryTheory.MonoidalCategory.associator_monoidal_assoc {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X₁ X₂ X₃ Y₁ Y₂ Y₃ : C) {Z : C} (h : tensorObj (tensorObj X₁ Y₁) (tensorObj (tensorObj X₂ Y₂) (tensorObj X₃ Y₃)) ⟶ Z) : CategoryStruct.comp (tensorμ (tensorObj X₁ X₂) X₃ (tensorObj Y₁ Y₂) Y₃) (CategoryStruct.comp (whiskerRight (tensorμ X₁ X₂ Y₁ Y₂) (tensorObj X₃ Y₃)) (CategoryStruct.comp (associator (tensorObj X₁ Y₁) (tensorObj X₂ Y₂) (tensorObj X₃ Y₃)).hom h)) = CategoryStruct.comp (tensorHom (associator X₁ X₂ X₃).hom (associator Y₁ Y₂ Y₃).hom) (CategoryStruct.comp (tensorμ X₁ (tensorObj X₂ X₃) Y₁ (tensorObj Y₂ Y₃)) (CategoryStruct.comp (whiskerLeft (tensorObj X₁ Y₁) (tensorμ X₂ X₃ Y₂ Y₃)) h))

instance CategoryTheory.instBraidedCategoryOpposite {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : BraidedCategory Cᵒᵖ

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.op_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : C) : (β_ X Y).op = β_ (Opposite.op Y) (Opposite.op X)

@[simp]

theorem CategoryTheory.unop_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : Cᵒᵖ) : (β_ X Y).unop = β_ (Opposite.unop Y) (Opposite.unop X)

@[simp]

theorem CategoryTheory.op_hom_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : C) : (β_ X Y).hom.op = (β_ (Opposite.op Y) (Opposite.op X)).hom

@[simp]

theorem CategoryTheory.unop_hom_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : Cᵒᵖ) : (β_ X Y).hom.unop = (β_ (Opposite.unop Y) (Opposite.unop X)).hom

@[simp]

theorem CategoryTheory.op_inv_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : C) : (β_ X Y).inv.op = (β_ (Opposite.op Y) (Opposite.op X)).inv

@[simp]

theorem CategoryTheory.unop_inv_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : Cᵒᵖ) : (β_ X Y).inv.unop = (β_ (Opposite.unop Y) (Opposite.unop X)).inv

instance CategoryTheory.MonoidalOpposite.instBraiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : BraidedCategory Cᴹᵒᵖ

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.MonoidalOpposite.mop_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : C) : (β_ X Y).mop = β_ { unmop := Y } { unmop := X }

@[simp]

theorem CategoryTheory.MonoidalOpposite.unmop_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : Cᴹᵒᵖ) : (β_ X Y).unmop = β_ Y.unmop X.unmop

@[simp]

theorem CategoryTheory.MonoidalOpposite.mop_hom_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : C) : (β_ X Y).hom.mop = (β_ { unmop := Y } { unmop := X }).hom

@[simp]

theorem CategoryTheory.MonoidalOpposite.unmop_hom_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : Cᴹᵒᵖ) : (β_ X Y).hom.unmop = (β_ Y.unmop X.unmop).hom

@[simp]

theorem CategoryTheory.MonoidalOpposite.mop_inv_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : C) : (β_ X Y).inv.mop = (β_ { unmop := Y } { unmop := X }).inv

@[simp]

theorem CategoryTheory.MonoidalOpposite.unmop_inv_braiding {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : Cᴹᵒᵖ) : (β_ X Y).inv.unmop = (β_ Y.unmop X.unmop).inv

instance CategoryTheory.MonoidalOpposite.instMonoidalMopFunctor {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : (mopFunctor C).Monoidal

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.MonoidalOpposite.mopFunctor_ε {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : Functor.LaxMonoidal.ε (mopFunctor C) = CategoryStruct.id (𝟙_ Cᴹᵒᵖ)

@[simp]

theorem CategoryTheory.MonoidalOpposite.mopFunctor_η {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : Functor.OplaxMonoidal.η (mopFunctor C) = CategoryStruct.id ((mopFunctor C).obj (𝟙_ C))

@[simp]

theorem CategoryTheory.MonoidalOpposite.mopFunctor_μ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : C) : Functor.LaxMonoidal.μ (mopFunctor C) X Y = (β_ { unmop := X } { unmop := Y }).hom

@[simp]

theorem CategoryTheory.MonoidalOpposite.mopFunctor_δ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : C) : Functor.OplaxMonoidal.δ (mopFunctor C) X Y = (β_ { unmop := X } { unmop := Y }).inv

instance CategoryTheory.MonoidalOpposite.instMonoidalUnmopFunctor {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : (unmopFunctor C).Monoidal

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.MonoidalOpposite.unmopFunctor_ε {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : Functor.LaxMonoidal.ε (unmopFunctor C) = CategoryStruct.id (𝟙_ C)

@[simp]

theorem CategoryTheory.MonoidalOpposite.unmopFunctor_η {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : Functor.OplaxMonoidal.η (unmopFunctor C) = CategoryStruct.id ((unmopFunctor C).obj (𝟙_ Cᴹᵒᵖ))

@[simp]

theorem CategoryTheory.MonoidalOpposite.unmopFunctor_μ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : Cᴹᵒᵖ) : Functor.LaxMonoidal.μ (unmopFunctor C) X Y = (β_ X.unmop Y.unmop).hom

@[simp]

theorem CategoryTheory.MonoidalOpposite.unmopFunctor_δ {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] (X Y : Cᴹᵒᵖ) : Functor.OplaxMonoidal.δ (unmopFunctor C) X Y = (β_ X.unmop Y.unmop).inv

instance CategoryTheory.MonoidalOpposite.instBraidedMopFunctor {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : (mopFunctor C).Braided

The identity functor on C, viewed as a functor from C to its monoidal opposite, upgraded to a braided functor.

Equations

• CategoryTheory.MonoidalOpposite.instBraidedMopFunctor = CategoryTheory.Functor.Braided.mk ⋯

instance CategoryTheory.MonoidalOpposite.instBraidedUnmopFunctor {C : Type u₁} [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : (unmopFunctor C).Braided

The identity functor on C, viewed as a functor from the monoidal opposite of C to C, upgraded to a braided functor.

Equations

• CategoryTheory.MonoidalOpposite.instBraidedUnmopFunctor = CategoryTheory.Functor.Braided.mk ⋯

@[reducible, inline]

abbrev CategoryTheory.reverseBraiding (C : Type u₁) [Category.{v₁, u₁} C] [MonoidalCategory C] [BraidedCategory C] : BraidedCategory C

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.

Equations

• CategoryTheory.reverseBraiding C = { braiding := fun (X Y : C) => (β_ Y X).symm, braiding_naturality_right := ⋯, braiding_naturality_left := ⋯, hexagon_forward := ⋯, hexagon_reverse := ⋯ }

theorem CategoryTheory.SymmetricCategory.reverseBraiding_eq (C : Type u₁) [Category.{v₁, u₁} C] [MonoidalCategory C] [i : SymmetricCategory C] : reverseBraiding C = toBraidedCategory

def CategoryTheory.SymmetricCategory.equivReverseBraiding (C : Type u₁) [Category.{v₁, u₁} C] [MonoidalCategory C] [SymmetricCategory C] : (Functor.id C).Braided

The identity functor from C to C, where the codomain is given the reversed braiding, upgraded to a braided functor.

Equations

• CategoryTheory.SymmetricCategory.equivReverseBraiding C = CategoryTheory.Functor.Braided.mk ⋯