The category of bimodule objects over a pair of monoid objects.

theorem id_tensor_π_preserves_coequalizer_inv_desc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] {W : C} {X : C} {Y : C} {Z : C} (f : X ⟶ Y) (g : X ⟶ Y) (h : CategoryTheory.MonoidalCategory.tensorObj Z Y ⟶ W) (wh : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft Z f) h = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft Z g) h) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft Z (CategoryTheory.Limits.coequalizer.π f g)) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorLeft Z) f g).inv (CategoryTheory.Limits.coequalizer.desc h wh)) = h

theorem id_tensor_π_preserves_coequalizer_inv_colimMap_desc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] {X : C} {Y : C} {Z : C} {X' : C} {Y' : C} {Z' : C} (f : X ⟶ Y) (g : X ⟶ Y) (f' : X' ⟶ Y') (g' : X' ⟶ Y') (p : CategoryTheory.MonoidalCategory.tensorObj Z X ⟶ X') (q : CategoryTheory.MonoidalCategory.tensorObj Z Y ⟶ Y') (wf : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft Z f) q = CategoryTheory.CategoryStruct.comp p f') (wg : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft Z g) q = CategoryTheory.CategoryStruct.comp p g') (h : Y' ⟶ Z') (wh : CategoryTheory.CategoryStruct.comp f' h = CategoryTheory.CategoryStruct.comp g' h) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft Z (CategoryTheory.Limits.coequalizer.π f g)) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorLeft Z) f g).inv (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimMap (CategoryTheory.Limits.parallelPairHom (CategoryTheory.MonoidalCategory.whiskerLeft Z f) (CategoryTheory.MonoidalCategory.whiskerLeft Z g) f' g' p q wf wg)) (CategoryTheory.Limits.coequalizer.desc h wh))) = CategoryTheory.CategoryStruct.comp q h

theorem π_tensor_id_preserves_coequalizer_inv_desc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {W : C} {X : C} {Y : C} {Z : C} (f : X ⟶ Y) (g : X ⟶ Y) (h : CategoryTheory.MonoidalCategory.tensorObj Y Z ⟶ W) (wh : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f Z) h = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight g Z) h) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.Limits.coequalizer.π f g) Z) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorRight Z) f g).inv (CategoryTheory.Limits.coequalizer.desc h wh)) = h

theorem π_tensor_id_preserves_coequalizer_inv_colimMap_desc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : C} {Y : C} {Z : C} {X' : C} {Y' : C} {Z' : C} (f : X ⟶ Y) (g : X ⟶ Y) (f' : X' ⟶ Y') (g' : X' ⟶ Y') (p : CategoryTheory.MonoidalCategory.tensorObj X Z ⟶ X') (q : CategoryTheory.MonoidalCategory.tensorObj Y Z ⟶ Y') (wf : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f Z) q = CategoryTheory.CategoryStruct.comp p f') (wg : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight g Z) q = CategoryTheory.CategoryStruct.comp p g') (h : Y' ⟶ Z') (wh : CategoryTheory.CategoryStruct.comp f' h = CategoryTheory.CategoryStruct.comp g' h) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.Limits.coequalizer.π f g) Z) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorRight Z) f g).inv (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimMap (CategoryTheory.Limits.parallelPairHom (CategoryTheory.MonoidalCategory.whiskerRight f Z) (CategoryTheory.MonoidalCategory.whiskerRight g Z) f' g' p q wf wg)) (CategoryTheory.Limits.coequalizer.desc h wh))) = CategoryTheory.CategoryStruct.comp q h

structure Bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] (A : Mon_ C) (B : Mon_ C) : Type (max u₁ v₁)

A bimodule object for a pair of monoid objects, all internal to some monoidal category.

• X : C
• actLeft : CategoryTheory.MonoidalCategory.tensorObj A.X self.X ⟶ self.X
• one_actLeft : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight A.one self.X) self.actLeft = (CategoryTheory.MonoidalCategory.leftUnitor self.X).hom
• left_assoc : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight A.mul self.X) self.actLeft = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator A.X A.X self.X).hom (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A.X self.actLeft) self.actLeft)
• actRight : CategoryTheory.MonoidalCategory.tensorObj self.X B.X ⟶ self.X
• actRight_one : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft self.X B.one) self.actRight = (CategoryTheory.MonoidalCategory.rightUnitor self.X).hom
• right_assoc : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft self.X B.mul) self.actRight = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator self.X B.X B.X).inv (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight self.actRight B.X) self.actRight)
• middle_assoc : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight self.actLeft B.X) self.actRight = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator A.X self.X B.X).hom (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A.X self.actRight) self.actLeft)

@[simp]

theorem Bimod.one_actLeft {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (self : Bimod A B) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight A.one self.X) self.actLeft = (CategoryTheory.MonoidalCategory.leftUnitor self.X).hom

@[simp]

theorem Bimod.left_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (self : Bimod A B) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight A.mul self.X) self.actLeft = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator A.X A.X self.X).hom (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A.X self.actLeft) self.actLeft)

@[simp]

theorem Bimod.actRight_one {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (self : Bimod A B) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft self.X B.one) self.actRight = (CategoryTheory.MonoidalCategory.rightUnitor self.X).hom

@[simp]

theorem Bimod.right_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (self : Bimod A B) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft self.X B.mul) self.actRight = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator self.X B.X B.X).inv (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight self.actRight B.X) self.actRight)

@[simp]

theorem Bimod.middle_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (self : Bimod A B) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight self.actLeft B.X) self.actRight = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator A.X self.X B.X).hom (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A.X self.actRight) self.actLeft)

@[simp]

theorem Bimod.right_assoc_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (self : Bimod A B) {Z : C} (h : self.X ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft self.X B.mul) (CategoryTheory.CategoryStruct.comp self.actRight h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator self.X B.X B.X).inv (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight self.actRight B.X) (CategoryTheory.CategoryStruct.comp self.actRight h))

@[simp]

theorem Bimod.actRight_one_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (self : Bimod A B) {Z : C} (h : self.X ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft self.X B.one) (CategoryTheory.CategoryStruct.comp self.actRight h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.rightUnitor self.X).hom h

@[simp]

theorem Bimod.one_actLeft_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (self : Bimod A B) {Z : C} (h : self.X ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight A.one self.X) (CategoryTheory.CategoryStruct.comp self.actLeft h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.leftUnitor self.X).hom h

@[simp]

theorem Bimod.middle_assoc_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (self : Bimod A B) {Z : C} (h : self.X ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight self.actLeft B.X) (CategoryTheory.CategoryStruct.comp self.actRight h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator A.X self.X B.X).hom (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A.X self.actRight) (CategoryTheory.CategoryStruct.comp self.actLeft h))

@[simp]

theorem Bimod.left_assoc_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (self : Bimod A B) {Z : C} (h : self.X ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight A.mul self.X) (CategoryTheory.CategoryStruct.comp self.actLeft h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator A.X A.X self.X).hom (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A.X self.actLeft) (CategoryTheory.CategoryStruct.comp self.actLeft h))

structure Bimod.Hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (M : Bimod A B) (N : Bimod A B) : Type v₁

A morphism of bimodule objects.

• hom : M.X ⟶ N.X
• left_act_hom : CategoryTheory.CategoryStruct.comp M.actLeft self.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A.X self.hom) N.actLeft
• right_act_hom : CategoryTheory.CategoryStruct.comp M.actRight self.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight self.hom B.X) N.actRight

theorem Bimod.Hom.ext {C : Type u₁} : ∀ {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {A B : Mon_ C} {M N : Bimod A B} {x y : M.Hom N}, x.hom = y.hom → x = y

@[simp]

theorem Bimod.Hom.left_act_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} {M : Bimod A B} {N : Bimod A B} (self : M.Hom N) : CategoryTheory.CategoryStruct.comp M.actLeft self.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A.X self.hom) N.actLeft

@[simp]

theorem Bimod.Hom.right_act_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} {M : Bimod A B} {N : Bimod A B} (self : M.Hom N) : CategoryTheory.CategoryStruct.comp M.actRight self.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight self.hom B.X) N.actRight

@[simp]

theorem Bimod.Hom.left_act_hom_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} {M : Bimod A B} {N : Bimod A B} (self : M.Hom N) {Z : C} (h : N.X ⟶ Z) : CategoryTheory.CategoryStruct.comp M.actLeft (CategoryTheory.CategoryStruct.comp self.hom h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A.X self.hom) (CategoryTheory.CategoryStruct.comp N.actLeft h)

@[simp]

theorem Bimod.Hom.right_act_hom_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} {M : Bimod A B} {N : Bimod A B} (self : M.Hom N) {Z : C} (h : N.X ⟶ Z) : CategoryTheory.CategoryStruct.comp M.actRight (CategoryTheory.CategoryStruct.comp self.hom h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight self.hom B.X) (CategoryTheory.CategoryStruct.comp N.actRight h)

def Bimod.id' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (M : Bimod A B) : M.Hom M

The identity morphism on a bimodule object.

Equations

• M.id' = { hom := CategoryTheory.CategoryStruct.id M.X, left_act_hom := ⋯, right_act_hom := ⋯ }

@[simp]

theorem Bimod.id'_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (M : Bimod A B) : M.id'.hom = CategoryTheory.CategoryStruct.id M.X

instance Bimod.homInhabited {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (M : Bimod A B) : Inhabited (M.Hom M)

Equations

• M.homInhabited = { default := M.id' }

def Bimod.comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} {M : Bimod A B} {N : Bimod A B} {O : Bimod A B} (f : M.Hom N) (g : N.Hom O) : M.Hom O

Composition of bimodule object morphisms.

Equations

• Bimod.comp f g = { hom := CategoryTheory.CategoryStruct.comp f.hom g.hom, left_act_hom := ⋯, right_act_hom := ⋯ }

@[simp]

theorem Bimod.comp_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} {M : Bimod A B} {N : Bimod A B} {O : Bimod A B} (f : M.Hom N) (g : N.Hom O) : (Bimod.comp f g).hom = CategoryTheory.CategoryStruct.comp f.hom g.hom

instance Bimod.instCategory {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} : CategoryTheory.Category.{v₁, max u₁ v₁} (Bimod A B)

Equations

• Bimod.instCategory = CategoryTheory.Category.mk ⋯ ⋯ ⋯

theorem Bimod.hom_ext {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} {M : Bimod A B} {N : Bimod A B} (f : M ⟶ N) (g : M ⟶ N) (h : f.hom = g.hom) : f = g

@[simp]

theorem Bimod.id_hom' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} (M : Bimod A B) : (CategoryTheory.CategoryStruct.id M).hom = CategoryTheory.CategoryStruct.id M.X

@[simp]

theorem Bimod.comp_hom' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {A : Mon_ C} {B : Mon_ C} {M : Bimod A B} {N : Bimod A B} {K : Bimod A B} (f : M ⟶ N) (g : N ⟶ K) : (CategoryTheory.CategoryStruct.comp f g).hom = CategoryTheory.CategoryStruct.comp f.hom g.hom

def Bimod.isoOfIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X : Mon_ C} {Y : Mon_ C} {P : Bimod X Y} {Q : Bimod X Y} (f : P.X ≅ Q.X) (f_left_act_hom : CategoryTheory.CategoryStruct.comp P.actLeft f.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft X.X f.hom) Q.actLeft) (f_right_act_hom : CategoryTheory.CategoryStruct.comp P.actRight f.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f.hom Y.X) Q.actRight) : P ≅ Q

Construct an isomorphism of bimodules by giving an isomorphism between the underlying objects and checking compatibility with left and right actions only in the forward direction.

Equations

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

@[simp]

theorem Bimod.isoOfIso_inv_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X : Mon_ C} {Y : Mon_ C} {P : Bimod X Y} {Q : Bimod X Y} (f : P.X ≅ Q.X) (f_left_act_hom : CategoryTheory.CategoryStruct.comp P.actLeft f.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft X.X f.hom) Q.actLeft) (f_right_act_hom : CategoryTheory.CategoryStruct.comp P.actRight f.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f.hom Y.X) Q.actRight) : (Bimod.isoOfIso f f_left_act_hom f_right_act_hom).inv.hom = f.inv

@[simp]

theorem Bimod.isoOfIso_hom_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] {X : Mon_ C} {Y : Mon_ C} {P : Bimod X Y} {Q : Bimod X Y} (f : P.X ≅ Q.X) (f_left_act_hom : CategoryTheory.CategoryStruct.comp P.actLeft f.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft X.X f.hom) Q.actLeft) (f_right_act_hom : CategoryTheory.CategoryStruct.comp P.actRight f.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f.hom Y.X) Q.actRight) : (Bimod.isoOfIso f f_left_act_hom f_right_act_hom).hom.hom = f.hom

def Bimod.regular {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] (A : Mon_ C) : Bimod A A

A monoid object as a bimodule over itself.

Equations

• Bimod.regular A = { X := A.X, actLeft := A.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := A.mul, actRight_one := ⋯, right_assoc := ⋯, middle_assoc := ⋯ }

@[simp]

theorem Bimod.regular_X {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] (A : Mon_ C) : (Bimod.regular A).X = A.X

@[simp]

theorem Bimod.regular_actLeft {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] (A : Mon_ C) : (Bimod.regular A).actLeft = A.mul

@[simp]

theorem Bimod.regular_actRight {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] (A : Mon_ C) : (Bimod.regular A).actRight = A.mul

instance Bimod.instInhabited {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] (A : Mon_ C) : Inhabited (Bimod A A)

Equations

• Bimod.instInhabited A = { default := Bimod.regular A }

def Bimod.forget {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] (A : Mon_ C) {B : Mon_ C} : CategoryTheory.Functor (Bimod A B) C

The forgetful functor from bimodule objects to the ambient category.

Equations

• Bimod.forget A = { obj := fun (A_1 : Bimod A B) => A_1.X, map := fun {X Y : Bimod A B} (f : X ⟶ Y) => f.hom, map_id := ⋯, map_comp := ⋯ }

noncomputable def Bimod.TensorBimod.X {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} (P : Bimod R S) (Q : Bimod S T) : C

The underlying object of the tensor product of two bimodules.

Equations

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

noncomputable def Bimod.TensorBimod.actLeft {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} (P : Bimod R S) (Q : Bimod S T) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] : CategoryTheory.MonoidalCategory.tensorObj R.X (Bimod.TensorBimod.X P Q) ⟶ Bimod.TensorBimod.X P Q

Left action for the tensor product of two bimodules.

Equations

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

theorem Bimod.TensorBimod.whiskerLeft_π_actLeft {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} (P : Bimod R S) (Q : Bimod S T) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft R.X (CategoryTheory.Limits.coequalizer.π (CategoryTheory.MonoidalCategory.whiskerRight P.actRight Q.X) (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator P.X S.X Q.X).hom (CategoryTheory.MonoidalCategory.whiskerLeft P.X Q.actLeft)))) (Bimod.TensorBimod.actLeft P Q) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator R.X P.X Q.X).inv (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight P.actLeft Q.X) (CategoryTheory.Limits.coequalizer.π (CategoryTheory.MonoidalCategory.whiskerRight P.actRight Q.X) (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator P.X S.X Q.X).hom (CategoryTheory.MonoidalCategory.whiskerLeft P.X Q.actLeft))))

theorem Bimod.TensorBimod.one_act_left' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} (P : Bimod R S) (Q : Bimod S T) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight R.one (Bimod.TensorBimod.X P Q)) (Bimod.TensorBimod.actLeft P Q) = (CategoryTheory.MonoidalCategory.leftUnitor (Bimod.TensorBimod.X P Q)).hom

theorem Bimod.TensorBimod.left_assoc' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} (P : Bimod R S) (Q : Bimod S T) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight R.mul (Bimod.TensorBimod.X P Q)) (Bimod.TensorBimod.actLeft P Q) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator R.X R.X (Bimod.TensorBimod.X P Q)).hom (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft R.X (Bimod.TensorBimod.actLeft P Q)) (Bimod.TensorBimod.actLeft P Q))

noncomputable def Bimod.TensorBimod.actRight {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} (P : Bimod R S) (Q : Bimod S T) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] : CategoryTheory.MonoidalCategory.tensorObj (Bimod.TensorBimod.X P Q) T.X ⟶ Bimod.TensorBimod.X P Q

Right action for the tensor product of two bimodules.

Equations

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

theorem Bimod.TensorBimod.π_tensor_id_actRight {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} (P : Bimod R S) (Q : Bimod S T) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.Limits.coequalizer.π (CategoryTheory.MonoidalCategory.whiskerRight P.actRight Q.X) (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator P.X S.X Q.X).hom (CategoryTheory.MonoidalCategory.whiskerLeft P.X Q.actLeft))) T.X) (Bimod.TensorBimod.actRight P Q) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator P.X Q.X T.X).hom (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft P.X Q.actRight) (CategoryTheory.Limits.coequalizer.π (CategoryTheory.MonoidalCategory.whiskerRight P.actRight Q.X) (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator P.X S.X Q.X).hom (CategoryTheory.MonoidalCategory.whiskerLeft P.X Q.actLeft))))

theorem Bimod.TensorBimod.actRight_one' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} (P : Bimod R S) (Q : Bimod S T) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft (Bimod.TensorBimod.X P Q) T.one) (Bimod.TensorBimod.actRight P Q) = (CategoryTheory.MonoidalCategory.rightUnitor (Bimod.TensorBimod.X P Q)).hom

theorem Bimod.TensorBimod.right_assoc' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} (P : Bimod R S) (Q : Bimod S T) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft (Bimod.TensorBimod.X P Q) T.mul) (Bimod.TensorBimod.actRight P Q) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator (Bimod.TensorBimod.X P Q) T.X T.X).inv (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight (Bimod.TensorBimod.actRight P Q) T.X) (Bimod.TensorBimod.actRight P Q))

theorem Bimod.TensorBimod.middle_assoc' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} (P : Bimod R S) (Q : Bimod S T) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] : CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight (Bimod.TensorBimod.actLeft P Q) T.X) (Bimod.TensorBimod.actRight P Q) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator R.X (Bimod.TensorBimod.X P Q) T.X).hom (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft R.X (Bimod.TensorBimod.actRight P Q)) (Bimod.TensorBimod.actLeft P Q))

noncomputable def Bimod.tensorBimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) : Bimod X Z

Tensor product of two bimodule objects as a bimodule object.

Equations

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

@[simp]

theorem Bimod.tensorBimod_actLeft {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) : (M.tensorBimod N).actLeft = Bimod.TensorBimod.actLeft M N

@[simp]

theorem Bimod.tensorBimod_X {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) : (M.tensorBimod N).X = Bimod.TensorBimod.X M N

@[simp]

theorem Bimod.tensorBimod_actRight {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) : (M.tensorBimod N).actRight = Bimod.TensorBimod.actRight M N

noncomputable def Bimod.whiskerLeft {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod X Y) {N₁ : Bimod Y Z} {N₂ : Bimod Y Z} (f : N₁ ⟶ N₂) : M.tensorBimod N₁ ⟶ M.tensorBimod N₂

Left whiskering for morphisms of bimodule objects.

Equations

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

@[simp]

theorem Bimod.whiskerLeft_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod X Y) {N₁ : Bimod Y Z} {N₂ : Bimod Y Z} (f : N₁ ⟶ N₂) : (M.whiskerLeft f).hom = CategoryTheory.Limits.colimMap (CategoryTheory.Limits.parallelPairHom (CategoryTheory.MonoidalCategory.whiskerRight M.actRight N₁.X) (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator M.X Y.X N₁.X).hom (CategoryTheory.MonoidalCategory.whiskerLeft M.X N₁.actLeft)) (CategoryTheory.MonoidalCategory.whiskerRight M.actRight N₂.X) (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator M.X Y.X N₂.X).hom (CategoryTheory.MonoidalCategory.whiskerLeft M.X N₂.actLeft)) (CategoryTheory.MonoidalCategory.whiskerLeft (CategoryTheory.MonoidalCategory.tensorObj M.X Y.X) f.hom) (CategoryTheory.MonoidalCategory.whiskerLeft M.X f.hom) ⋯ ⋯)

noncomputable def Bimod.whiskerRight {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} {M₁ : Bimod X Y} {M₂ : Bimod X Y} (f : M₁ ⟶ M₂) (N : Bimod Y Z) : M₁.tensorBimod N ⟶ M₂.tensorBimod N

Right whiskering for morphisms of bimodule objects.

Equations

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

@[simp]

theorem Bimod.whiskerRight_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} {M₁ : Bimod X Y} {M₂ : Bimod X Y} (f : M₁ ⟶ M₂) (N : Bimod Y Z) : (Bimod.whiskerRight f N).hom = CategoryTheory.Limits.colimMap (CategoryTheory.Limits.parallelPairHom (CategoryTheory.MonoidalCategory.whiskerRight M₁.actRight N.X) (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator M₁.X Y.X N.X).hom (CategoryTheory.MonoidalCategory.whiskerLeft M₁.X N.actLeft)) (CategoryTheory.MonoidalCategory.whiskerRight M₂.actRight N.X) (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.associator M₂.X Y.X N.X).hom (CategoryTheory.MonoidalCategory.whiskerLeft M₂.X N.actLeft)) (CategoryTheory.MonoidalCategory.whiskerRight (CategoryTheory.MonoidalCategory.whiskerRight f.hom Y.X) N.X) (CategoryTheory.MonoidalCategory.whiskerRight f.hom N.X) ⋯ ⋯)

noncomputable def Bimod.AssociatorBimod.homAux {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} {U : Mon_ C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U) : CategoryTheory.MonoidalCategory.tensorObj (P.tensorBimod Q).X L.X ⟶ (P.tensorBimod (Q.tensorBimod L)).X

An auxiliary morphism for the definition of the underlying morphism of the forward component of the associator isomorphism.

Equations

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

noncomputable def Bimod.AssociatorBimod.hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} {U : Mon_ C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U) : ((P.tensorBimod Q).tensorBimod L).X ⟶ (P.tensorBimod (Q.tensorBimod L)).X

The underlying morphism of the forward component of the associator isomorphism.

Equations

• Bimod.AssociatorBimod.hom P Q L = CategoryTheory.Limits.coequalizer.desc (Bimod.AssociatorBimod.homAux P Q L) ⋯

theorem Bimod.AssociatorBimod.hom_left_act_hom' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} {U : Mon_ C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U) : CategoryTheory.CategoryStruct.comp ((P.tensorBimod Q).tensorBimod L).actLeft (Bimod.AssociatorBimod.hom P Q L) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft R.X (Bimod.AssociatorBimod.hom P Q L)) (P.tensorBimod (Q.tensorBimod L)).actLeft

theorem Bimod.AssociatorBimod.hom_right_act_hom' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} {U : Mon_ C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U) : CategoryTheory.CategoryStruct.comp ((P.tensorBimod Q).tensorBimod L).actRight (Bimod.AssociatorBimod.hom P Q L) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight (Bimod.AssociatorBimod.hom P Q L) U.X) (P.tensorBimod (Q.tensorBimod L)).actRight

noncomputable def Bimod.AssociatorBimod.invAux {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} {U : Mon_ C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U) : CategoryTheory.MonoidalCategory.tensorObj P.X (Q.tensorBimod L).X ⟶ ((P.tensorBimod Q).tensorBimod L).X

An auxiliary morphism for the definition of the underlying morphism of the inverse component of the associator isomorphism.

Equations

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

noncomputable def Bimod.AssociatorBimod.inv {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} {U : Mon_ C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U) : (P.tensorBimod (Q.tensorBimod L)).X ⟶ ((P.tensorBimod Q).tensorBimod L).X

The underlying morphism of the inverse component of the associator isomorphism.

Equations

• Bimod.AssociatorBimod.inv P Q L = CategoryTheory.Limits.coequalizer.desc (Bimod.AssociatorBimod.invAux P Q L) ⋯

theorem Bimod.AssociatorBimod.hom_inv_id {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} {U : Mon_ C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U) : CategoryTheory.CategoryStruct.comp (Bimod.AssociatorBimod.hom P Q L) (Bimod.AssociatorBimod.inv P Q L) = CategoryTheory.CategoryStruct.id ((P.tensorBimod Q).tensorBimod L).X

theorem Bimod.AssociatorBimod.inv_hom_id {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {R : Mon_ C} {S : Mon_ C} {T : Mon_ C} {U : Mon_ C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U) : CategoryTheory.CategoryStruct.comp (Bimod.AssociatorBimod.inv P Q L) (Bimod.AssociatorBimod.hom P Q L) = CategoryTheory.CategoryStruct.id (P.tensorBimod (Q.tensorBimod L)).X

noncomputable def Bimod.LeftUnitorBimod.hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) : Bimod.TensorBimod.X (Bimod.regular R) P ⟶ P.X

The underlying morphism of the forward component of the left unitor isomorphism.

Equations

• Bimod.LeftUnitorBimod.hom P = CategoryTheory.Limits.coequalizer.desc P.actLeft ⋯

noncomputable def Bimod.LeftUnitorBimod.inv {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) : P.X ⟶ Bimod.TensorBimod.X (Bimod.regular R) P

The underlying morphism of the inverse component of the left unitor isomorphism.

Equations

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

theorem Bimod.LeftUnitorBimod.hom_inv_id {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) : CategoryTheory.CategoryStruct.comp (Bimod.LeftUnitorBimod.hom P) (Bimod.LeftUnitorBimod.inv P) = CategoryTheory.CategoryStruct.id (Bimod.TensorBimod.X (Bimod.regular R) P)

theorem Bimod.LeftUnitorBimod.inv_hom_id {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) : CategoryTheory.CategoryStruct.comp (Bimod.LeftUnitorBimod.inv P) (Bimod.LeftUnitorBimod.hom P) = CategoryTheory.CategoryStruct.id P.X

theorem Bimod.LeftUnitorBimod.hom_left_act_hom' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] : CategoryTheory.CategoryStruct.comp ((Bimod.regular R).tensorBimod P).actLeft (Bimod.LeftUnitorBimod.hom P) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft R.X (Bimod.LeftUnitorBimod.hom P)) P.actLeft

theorem Bimod.LeftUnitorBimod.hom_right_act_hom' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] : CategoryTheory.CategoryStruct.comp ((Bimod.regular R).tensorBimod P).actRight (Bimod.LeftUnitorBimod.hom P) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight (Bimod.LeftUnitorBimod.hom P) S.X) P.actRight

noncomputable def Bimod.RightUnitorBimod.hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) : Bimod.TensorBimod.X P (Bimod.regular S) ⟶ P.X

The underlying morphism of the forward component of the right unitor isomorphism.

Equations

• Bimod.RightUnitorBimod.hom P = CategoryTheory.Limits.coequalizer.desc P.actRight ⋯

noncomputable def Bimod.RightUnitorBimod.inv {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) : P.X ⟶ Bimod.TensorBimod.X P (Bimod.regular S)

The underlying morphism of the inverse component of the right unitor isomorphism.

Equations

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

theorem Bimod.RightUnitorBimod.hom_inv_id {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) : CategoryTheory.CategoryStruct.comp (Bimod.RightUnitorBimod.hom P) (Bimod.RightUnitorBimod.inv P) = CategoryTheory.CategoryStruct.id (Bimod.TensorBimod.X P (Bimod.regular S))

theorem Bimod.RightUnitorBimod.inv_hom_id {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) : CategoryTheory.CategoryStruct.comp (Bimod.RightUnitorBimod.inv P) (Bimod.RightUnitorBimod.hom P) = CategoryTheory.CategoryStruct.id P.X

theorem Bimod.RightUnitorBimod.hom_left_act_hom' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] : CategoryTheory.CategoryStruct.comp (P.tensorBimod (Bimod.regular S)).actLeft (Bimod.RightUnitorBimod.hom P) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft R.X (Bimod.RightUnitorBimod.hom P)) P.actLeft

theorem Bimod.RightUnitorBimod.hom_right_act_hom' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] {R : Mon_ C} {S : Mon_ C} (P : Bimod R S) [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] : CategoryTheory.CategoryStruct.comp (P.tensorBimod (Bimod.regular S)).actRight (Bimod.RightUnitorBimod.hom P) = CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight (Bimod.RightUnitorBimod.hom P) S.X) P.actRight

noncomputable def Bimod.associatorBimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {W : Mon_ C} {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (L : Bimod W X) (M : Bimod X Y) (N : Bimod Y Z) : (L.tensorBimod M).tensorBimod N ≅ L.tensorBimod (M.tensorBimod N)

The associator as a bimodule isomorphism.

Equations

• L.associatorBimod M N = Bimod.isoOfIso { hom := Bimod.AssociatorBimod.hom L M N, inv := Bimod.AssociatorBimod.inv L M N, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯ ⋯

noncomputable def Bimod.leftUnitorBimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} (M : Bimod X Y) : (Bimod.regular X).tensorBimod M ≅ M

The left unitor as a bimodule isomorphism.

Equations

• M.leftUnitorBimod = Bimod.isoOfIso { hom := Bimod.LeftUnitorBimod.hom M, inv := Bimod.LeftUnitorBimod.inv M, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯ ⋯

noncomputable def Bimod.rightUnitorBimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} (M : Bimod X Y) : M.tensorBimod (Bimod.regular Y) ≅ M

The right unitor as a bimodule isomorphism.

Equations

• M.rightUnitorBimod = Bimod.isoOfIso { hom := Bimod.RightUnitorBimod.hom M, inv := Bimod.RightUnitorBimod.inv M, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯ ⋯

theorem Bimod.whiskerLeft_id_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} : M.whiskerLeft (CategoryTheory.CategoryStruct.id N) = CategoryTheory.CategoryStruct.id (M.tensorBimod N)

theorem Bimod.id_whiskerRight_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} : Bimod.whiskerRight (CategoryTheory.CategoryStruct.id M) N = CategoryTheory.CategoryStruct.id (M.tensorBimod N)

theorem Bimod.whiskerLeft_comp_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod X Y) {N : Bimod Y Z} {P : Bimod Y Z} {Q : Bimod Y Z} (f : N ⟶ P) (g : P ⟶ Q) : M.whiskerLeft (CategoryTheory.CategoryStruct.comp f g) = CategoryTheory.CategoryStruct.comp (M.whiskerLeft f) (M.whiskerLeft g)

theorem Bimod.id_whiskerLeft_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {M : Bimod X Y} {N : Bimod X Y} (f : M ⟶ N) : (Bimod.regular X).whiskerLeft f = CategoryTheory.CategoryStruct.comp M.leftUnitorBimod.hom (CategoryTheory.CategoryStruct.comp f N.leftUnitorBimod.inv)

theorem Bimod.comp_whiskerLeft_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {W : Mon_ C} {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod W X) (N : Bimod X Y) {P : Bimod Y Z} {P' : Bimod Y Z} (f : P ⟶ P') : (M.tensorBimod N).whiskerLeft f = CategoryTheory.CategoryStruct.comp (M.associatorBimod N P).hom (CategoryTheory.CategoryStruct.comp (M.whiskerLeft (N.whiskerLeft f)) (M.associatorBimod N P').inv)

theorem Bimod.comp_whiskerRight_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} {M : Bimod X Y} {N : Bimod X Y} {P : Bimod X Y} (f : M ⟶ N) (g : N ⟶ P) (Q : Bimod Y Z) : Bimod.whiskerRight (CategoryTheory.CategoryStruct.comp f g) Q = CategoryTheory.CategoryStruct.comp (Bimod.whiskerRight f Q) (Bimod.whiskerRight g Q)

theorem Bimod.whiskerRight_id_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {M : Bimod X Y} {N : Bimod X Y} (f : M ⟶ N) : Bimod.whiskerRight f (Bimod.regular Y) = CategoryTheory.CategoryStruct.comp M.rightUnitorBimod.hom (CategoryTheory.CategoryStruct.comp f N.rightUnitorBimod.inv)

theorem Bimod.whiskerRight_comp_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {W : Mon_ C} {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} {M : Bimod W X} {M' : Bimod W X} (f : M ⟶ M') (N : Bimod X Y) (P : Bimod Y Z) : Bimod.whiskerRight f (N.tensorBimod P) = CategoryTheory.CategoryStruct.comp (M.associatorBimod N P).inv (CategoryTheory.CategoryStruct.comp (Bimod.whiskerRight (Bimod.whiskerRight f N) P) (M'.associatorBimod N P).hom)

theorem Bimod.whisker_assoc_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {W : Mon_ C} {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod W X) {N : Bimod X Y} {N' : Bimod X Y} (f : N ⟶ N') (P : Bimod Y Z) : Bimod.whiskerRight (M.whiskerLeft f) P = CategoryTheory.CategoryStruct.comp (M.associatorBimod N P).hom (CategoryTheory.CategoryStruct.comp (M.whiskerLeft (Bimod.whiskerRight f P)) (M.associatorBimod N' P).inv)

theorem Bimod.whisker_exchange_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} {M : Bimod X Y} {N : Bimod X Y} {P : Bimod Y Z} {Q : Bimod Y Z} (f : M ⟶ N) (g : P ⟶ Q) : CategoryTheory.CategoryStruct.comp (M.whiskerLeft g) (Bimod.whiskerRight f Q) = CategoryTheory.CategoryStruct.comp (Bimod.whiskerRight f P) (N.whiskerLeft g)

theorem Bimod.pentagon_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {V : Mon_ C} {W : Mon_ C} {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod V W) (N : Bimod W X) (P : Bimod X Y) (Q : Bimod Y Z) : CategoryTheory.CategoryStruct.comp (Bimod.whiskerRight (M.associatorBimod N P).hom Q) (CategoryTheory.CategoryStruct.comp (M.associatorBimod (N.tensorBimod P) Q).hom (M.whiskerLeft (N.associatorBimod P Q).hom)) = CategoryTheory.CategoryStruct.comp ((M.tensorBimod N).associatorBimod P Q).hom (M.associatorBimod N (P.tensorBimod Q)).hom

theorem Bimod.triangle_bimod {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] {X : Mon_ C} {Y : Mon_ C} {Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) : CategoryTheory.CategoryStruct.comp (M.associatorBimod (Bimod.regular Y) N).hom (M.whiskerLeft N.leftUnitorBimod.hom) = Bimod.whiskerRight M.rightUnitorBimod.hom N

noncomputable def Bimod.monBicategory {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasCoequalizers C] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorLeft X)] [(X : C) → CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (CategoryTheory.MonoidalCategory.tensorRight X)] : CategoryTheory.Bicategory (Mon_ C)

The bicategory of algebras (monoids) and bimodules, all internal to some monoidal category.

Equations

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