File: Mathlib/CategoryTheory/Monoidal/Bimod.lean

full_name: id_tensor_π_preserves_coequalizer_inv_desc
code: theorem id_tensor_π_preserves_coequalizer_inv_desc {W X Y Z : C} (f g : X ⟶ Y) (h : Z ⊗ Y ⟶ W)
    (wh : (Z ◁ f) ≫ h = (Z ◁ g) ≫ h) :
    (Z ◁ coequalizer.π f g) ≫
        (PreservesCoequalizer.iso (tensorLeft Z) f g).inv ≫ coequalizer.desc h wh =
      h 
goal: Z ◁ CategoryTheory.Limits.coequalizer.π f g ≫
    (CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorLeft Z) f g).inv ≫
      CategoryTheory.Limits.coequalizer.desc h wh =
  h

full_name: id_tensor_π_preserves_coequalizer_inv_colimMap_desc
code: theorem id_tensor_π_preserves_coequalizer_inv_colimMap_desc {X Y Z X' Y' Z' : C} (f g : X ⟶ Y)
    (f' g' : X' ⟶ Y') (p : Z ⊗ X ⟶ X') (q : Z ⊗ Y ⟶ Y') (wf : (Z ◁ f) ≫ q = p ≫ f')
    (wg : (Z ◁ g) ≫ q = p ≫ g') (h : Y' ⟶ Z') (wh : f' ≫ h = g' ≫ h) :
    (Z ◁ coequalizer.π f g) ≫
        (PreservesCoequalizer.iso (tensorLeft Z) f g).inv ≫
          colimMap (parallelPairHom (Z ◁ f) (Z ◁ g) f' g' p q wf wg) ≫ coequalizer.desc h wh =
      q ≫ h 
goal: Z ◁ CategoryTheory.Limits.coequalizer.π f g ≫
    (CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorLeft Z) f g).inv ≫
      CategoryTheory.Limits.colimMap (CategoryTheory.Limits.parallelPairHom (Z ◁ f) (Z ◁ g) f' g' p q wf wg) ≫
        CategoryTheory.Limits.coequalizer.desc h wh =
  q ≫ h

full_name: π_tensor_id_preserves_coequalizer_inv_desc
code: theorem π_tensor_id_preserves_coequalizer_inv_desc {W X Y Z : C} (f g : X ⟶ Y) (h : Y ⊗ Z ⟶ W)
    (wh : (f ▷ Z) ≫ h = (g ▷ Z) ≫ h) :
    (coequalizer.π f g ▷ Z) ≫
        (PreservesCoequalizer.iso (tensorRight Z) f g).inv ≫ coequalizer.desc h wh =
      h 
goal: CategoryTheory.Limits.coequalizer.π f g ▷ Z ≫
    (CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorRight Z) f g).inv ≫
      CategoryTheory.Limits.coequalizer.desc h wh =
  h

full_name: π_tensor_id_preserves_coequalizer_inv_colimMap_desc
code: theorem π_tensor_id_preserves_coequalizer_inv_colimMap_desc {X Y Z X' Y' Z' : C} (f g : X ⟶ Y)
    (f' g' : X' ⟶ Y') (p : X ⊗ Z ⟶ X') (q : Y ⊗ Z ⟶ Y') (wf : (f ▷ Z) ≫ q = p ≫ f')
    (wg : (g ▷ Z) ≫ q = p ≫ g') (h : Y' ⟶ Z') (wh : f' ≫ h = g' ≫ h) :
    (coequalizer.π f g ▷ Z) ≫
        (PreservesCoequalizer.iso (tensorRight Z) f g).inv ≫
          colimMap (parallelPairHom (f ▷ Z) (g ▷ Z) f' g' p q wf wg) ≫ coequalizer.desc h wh =
      q ≫ h 
goal: CategoryTheory.Limits.coequalizer.π f g ▷ Z ≫
    (CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorRight Z) f g).inv ≫
      CategoryTheory.Limits.colimMap (CategoryTheory.Limits.parallelPairHom (f ▷ Z) (g ▷ Z) f' g' p q wf wg) ≫
        CategoryTheory.Limits.coequalizer.desc h wh =
  q ≫ h

full_name: Bimod.right_assoc
code: /-- A bimodule object for a pair of monoid objects, all internal to some monoidal category. -/
structure Bimod (A B : Mon_ C) where
  X : C
  actLeft : A.X ⊗ X ⟶ X
  one_actLeft : (A.one ▷ X) ≫ actLeft = (λ_ X).hom := by aesop_cat
  left_assoc :
    (A.mul ▷ X) ≫ actLeft = (α_ A.X A.X X).hom ≫ (A.X ◁ actLeft) ≫ actLeft := by aesop_cat
  actRight : X ⊗ B.X ⟶ X
  actRight_one : (X ◁ B.one) ≫ actRight = (ρ_ X).hom := by aesop_cat
  right_assoc :
    (X ◁ B.mul) ≫ actRight = (α_ X B.X B.X).inv ≫ (actRight ▷ B.X) ≫ actRight := by
    aesop_cat
  middle_assoc :
    (actLeft ▷ B.X) ≫ actRight = (α_ A.X X B.X).hom ≫ (A.X ◁ actRight) ≫ actLeft := by
    aesop_cat
goal: self.X ◁ B.mul ≫ self.actRight = (α_ self.X B.X B.X).inv ≫ self.actRight ▷ B.X ≫ self.actRight

full_name: Bimod
code: /-- A bimodule object for a pair of monoid objects, all internal to some monoidal category. -/
structure Bimod (A B : Mon_ C) where
  X : C
  actLeft : A.X ⊗ X ⟶ X
  one_actLeft : (A.one ▷ X) ≫ actLeft = (λ_ X).hom := by aesop_cat
  left_assoc :
    (A.mul ▷ X) ≫ actLeft = (α_ A.X A.X X).hom ≫ (A.X ◁ actLeft) ≫ actLeft := by aesop_cat
  actRight : X ⊗ B.X ⟶ X
  actRight_one : (X ◁ B.one) ≫ actRight = (ρ_ X).hom := by aesop_cat
  right_assoc :
    (X ◁ B.mul) ≫ actRight = (α_ X B.X B.X).inv ≫ (actRight ▷ B.X) ≫ actRight := by
    aesop_cat
  middle_assoc :
    (actLeft ▷ B.X) ≫ actRight = (α_ A.X X B.X).hom ≫ (A.X ◁ actRight) ≫ actLeft := by
    aesop_cat
goal: Type (max u₁ v₁)

full_name: Bimod.one_actLeft
code: /-- A bimodule object for a pair of monoid objects, all internal to some monoidal category. -/
structure Bimod (A B : Mon_ C) where
  X : C
  actLeft : A.X ⊗ X ⟶ X
  one_actLeft : (A.one ▷ X) ≫ actLeft = (λ_ X).hom := by aesop_cat
  left_assoc :
    (A.mul ▷ X) ≫ actLeft = (α_ A.X A.X X).hom ≫ (A.X ◁ actLeft) ≫ actLeft := by aesop_cat
  actRight : X ⊗ B.X ⟶ X
  actRight_one : (X ◁ B.one) ≫ actRight = (ρ_ X).hom := by aesop_cat
  right_assoc :
    (X ◁ B.mul) ≫ actRight = (α_ X B.X B.X).inv ≫ (actRight ▷ B.X) ≫ actRight := by
    aesop_cat
  middle_assoc :
    (actLeft ▷ B.X) ≫ actRight = (α_ A.X X B.X).hom ≫ (A.X ◁ actRight) ≫ actLeft := by
    aesop_cat
goal: A.one ▷ self.X ≫ self.actLeft = (λ_ self.X).hom

full_name: Bimod.left_assoc
code: /-- A bimodule object for a pair of monoid objects, all internal to some monoidal category. -/
structure Bimod (A B : Mon_ C) where
  X : C
  actLeft : A.X ⊗ X ⟶ X
  one_actLeft : (A.one ▷ X) ≫ actLeft = (λ_ X).hom := by aesop_cat
  left_assoc :
    (A.mul ▷ X) ≫ actLeft = (α_ A.X A.X X).hom ≫ (A.X ◁ actLeft) ≫ actLeft := by aesop_cat
  actRight : X ⊗ B.X ⟶ X
  actRight_one : (X ◁ B.one) ≫ actRight = (ρ_ X).hom := by aesop_cat
  right_assoc :
    (X ◁ B.mul) ≫ actRight = (α_ X B.X B.X).inv ≫ (actRight ▷ B.X) ≫ actRight := by
    aesop_cat
  middle_assoc :
    (actLeft ▷ B.X) ≫ actRight = (α_ A.X X B.X).hom ≫ (A.X ◁ actRight) ≫ actLeft := by
    aesop_cat
goal: A.mul ▷ self.X ≫ self.actLeft = (α_ A.X A.X self.X).hom ≫ A.X ◁ self.actLeft ≫ self.actLeft

full_name: Bimod.actRight_one
code: /-- A bimodule object for a pair of monoid objects, all internal to some monoidal category. -/
structure Bimod (A B : Mon_ C) where
  X : C
  actLeft : A.X ⊗ X ⟶ X
  one_actLeft : (A.one ▷ X) ≫ actLeft = (λ_ X).hom := by aesop_cat
  left_assoc :
    (A.mul ▷ X) ≫ actLeft = (α_ A.X A.X X).hom ≫ (A.X ◁ actLeft) ≫ actLeft := by aesop_cat
  actRight : X ⊗ B.X ⟶ X
  actRight_one : (X ◁ B.one) ≫ actRight = (ρ_ X).hom := by aesop_cat
  right_assoc :
    (X ◁ B.mul) ≫ actRight = (α_ X B.X B.X).inv ≫ (actRight ▷ B.X) ≫ actRight := by
    aesop_cat
  middle_assoc :
    (actLeft ▷ B.X) ≫ actRight = (α_ A.X X B.X).hom ≫ (A.X ◁ actRight) ≫ actLeft := by
    aesop_cat
goal: self.X ◁ B.one ≫ self.actRight = (ρ_ self.X).hom

full_name: Bimod.middle_assoc
code: /-- A bimodule object for a pair of monoid objects, all internal to some monoidal category. -/
structure Bimod (A B : Mon_ C) where
  X : C
  actLeft : A.X ⊗ X ⟶ X
  one_actLeft : (A.one ▷ X) ≫ actLeft = (λ_ X).hom := by aesop_cat
  left_assoc :
    (A.mul ▷ X) ≫ actLeft = (α_ A.X A.X X).hom ≫ (A.X ◁ actLeft) ≫ actLeft := by aesop_cat
  actRight : X ⊗ B.X ⟶ X
  actRight_one : (X ◁ B.one) ≫ actRight = (ρ_ X).hom := by aesop_cat
  right_assoc :
    (X ◁ B.mul) ≫ actRight = (α_ X B.X B.X).inv ≫ (actRight ▷ B.X) ≫ actRight := by
    aesop_cat
  middle_assoc :
    (actLeft ▷ B.X) ≫ actRight = (α_ A.X X B.X).hom ≫ (A.X ◁ actRight) ≫ actLeft := by
    aesop_cat
goal: self.actLeft ▷ B.X ≫ self.actRight = (α_ A.X self.X B.X).hom ≫ A.X ◁ self.actRight ≫ self.actLeft

full_name: Bimod.actRight
code: /-- A bimodule object for a pair of monoid objects, all internal to some monoidal category. -/
structure Bimod (A B : Mon_ C) where
  X : C
  actLeft : A.X ⊗ X ⟶ X
  one_actLeft : (A.one ▷ X) ≫ actLeft = (λ_ X).hom := by aesop_cat
  left_assoc :
    (A.mul ▷ X) ≫ actLeft = (α_ A.X A.X X).hom ≫ (A.X ◁ actLeft) ≫ actLeft := by aesop_cat
  actRight : X ⊗ B.X ⟶ X
  actRight_one : (X ◁ B.one) ≫ actRight = (ρ_ X).hom := by aesop_cat
  right_assoc :
    (X ◁ B.mul) ≫ actRight = (α_ X B.X B.X).inv ≫ (actRight ▷ B.X) ≫ actRight := by
    aesop_cat
  middle_assoc :
    (actLeft ▷ B.X) ≫ actRight = (α_ A.X X B.X).hom ≫ (A.X ◁ actRight) ≫ actLeft := by
    aesop_cat
goal: self.X ⊗ B.X ⟶ self.X

full_name: Bimod.X
code: /-- A bimodule object for a pair of monoid objects, all internal to some monoidal category. -/
structure Bimod (A B : Mon_ C) where
  X : C
  actLeft : A.X ⊗ X ⟶ X
  one_actLeft : (A.one ▷ X) ≫ actLeft = (λ_ X).hom := by aesop_cat
  left_assoc :
    (A.mul ▷ X) ≫ actLeft = (α_ A.X A.X X).hom ≫ (A.X ◁ actLeft) ≫ actLeft := by aesop_cat
  actRight : X ⊗ B.X ⟶ X
  actRight_one : (X ◁ B.one) ≫ actRight = (ρ_ X).hom := by aesop_cat
  right_assoc :
    (X ◁ B.mul) ≫ actRight = (α_ X B.X B.X).inv ≫ (actRight ▷ B.X) ≫ actRight := by
    aesop_cat
  middle_assoc :
    (actLeft ▷ B.X) ≫ actRight = (α_ A.X X B.X).hom ≫ (A.X ◁ actRight) ≫ actLeft := by
    aesop_cat
goal: C

full_name: Bimod.actLeft
code: /-- A bimodule object for a pair of monoid objects, all internal to some monoidal category. -/
structure Bimod (A B : Mon_ C) where
  X : C
  actLeft : A.X ⊗ X ⟶ X
  one_actLeft : (A.one ▷ X) ≫ actLeft = (λ_ X).hom := by aesop_cat
  left_assoc :
    (A.mul ▷ X) ≫ actLeft = (α_ A.X A.X X).hom ≫ (A.X ◁ actLeft) ≫ actLeft := by aesop_cat
  actRight : X ⊗ B.X ⟶ X
  actRight_one : (X ◁ B.one) ≫ actRight = (ρ_ X).hom := by aesop_cat
  right_assoc :
    (X ◁ B.mul) ≫ actRight = (α_ X B.X B.X).inv ≫ (actRight ▷ B.X) ≫ actRight := by
    aesop_cat
  middle_assoc :
    (actLeft ▷ B.X) ≫ actRight = (α_ A.X X B.X).hom ≫ (A.X ◁ actRight) ≫ actLeft := by
    aesop_cat
goal: A.X ⊗ self.X ⟶ self.X

full_name: Bimod.Hom
code: /-- A morphism of bimodule objects. -/
@[ext]
structure Hom (M N : Bimod A B) where
  hom : M.X ⟶ N.X
  left_act_hom : M.actLeft ≫ hom = (A.X ◁ hom) ≫ N.actLeft := by aesop_cat
  right_act_hom : M.actRight ≫ hom = (hom ▷ B.X) ≫ N.actRight := by aesop_cat
goal: Type v₁

full_name: Bimod.Hom.hom
code: /-- A morphism of bimodule objects. -/
@[ext]
structure Hom (M N : Bimod A B) where
  hom : M.X ⟶ N.X
  left_act_hom : M.actLeft ≫ hom = (A.X ◁ hom) ≫ N.actLeft := by aesop_cat
  right_act_hom : M.actRight ≫ hom = (hom ▷ B.X) ≫ N.actRight := by aesop_cat
goal: M.X ⟶ N.X

full_name: Bimod.Hom.left_act_hom
code: /-- A morphism of bimodule objects. -/
@[ext]
structure Hom (M N : Bimod A B) where
  hom : M.X ⟶ N.X
  left_act_hom : M.actLeft ≫ hom = (A.X ◁ hom) ≫ N.actLeft := by aesop_cat
  right_act_hom : M.actRight ≫ hom = (hom ▷ B.X) ≫ N.actRight := by aesop_cat
goal: M.actLeft ≫ self.hom = A.X ◁ self.hom ≫ N.actLeft

full_name: Bimod.Hom.right_act_hom
code: /-- A morphism of bimodule objects. -/
@[ext]
structure Hom (M N : Bimod A B) where
  hom : M.X ⟶ N.X
  left_act_hom : M.actLeft ≫ hom = (A.X ◁ hom) ≫ N.actLeft := by aesop_cat
  right_act_hom : M.actRight ≫ hom = (hom ▷ B.X) ≫ N.actRight := by aesop_cat
goal: M.actRight ≫ self.hom = self.hom ▷ B.X ≫ N.actRight

full_name: Bimod.id'
code: /-- The identity morphism on a bimodule object. -/
@[simps]
def id' (M : Bimod A B) : Hom M M 
goal: M.Hom M

full_name: Bimod.id'_hom
code: /-- The identity morphism on a bimodule object. -/
@[simps]
def id' (M : Bimod A B) : Hom M M 
goal: M.id'.hom = 𝟙 M.X

full_name: Bimod.homInhabited
code: instance homInhabited (M : Bimod A B) : Inhabited (Hom M M) 
goal: Inhabited (M.Hom M)

full_name: Bimod.comp_hom
code: /-- Composition of bimodule object morphisms. -/
@[simps]
def comp {M N O : Bimod A B} (f : Hom M N) (g : Hom N O) : Hom M O 
goal: (Bimod.comp f g).hom = f.hom ≫ g.hom

full_name: Bimod.comp
code: /-- Composition of bimodule object morphisms. -/
@[simps]
def comp {M N O : Bimod A B} (f : Hom M N) (g : Hom N O) : Hom M O 
goal: M.Hom O

full_name: Bimod.instCategory
code: instance : Category (Bimod A B) 
goal: CategoryTheory.Category.{v₁, max u₁ v₁} (Bimod A B)

full_name: Bimod.hom_ext
code: @[ext]
lemma hom_ext {M N : Bimod A B} (f g : M ⟶ N) (h : f.hom = g.hom) : f = g 
goal: f = g

full_name: Bimod.id_hom'
code: @[simp]
theorem id_hom' (M : Bimod A B) : (𝟙 M : Hom M M).hom = 𝟙 M.X 
goal: (𝟙 M).hom = 𝟙 M.X

full_name: Bimod.comp_hom'
code: @[simp]
theorem comp_hom' {M N K : Bimod A B} (f : M ⟶ N) (g : N ⟶ K) :
    (f ≫ g : Hom M K).hom = f.hom ≫ g.hom 
goal: (f ≫ g).hom = f.hom ≫ g.hom

full_name: Bimod.isoOfIso_inv_hom
code: /-- 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.
-/
@[simps]
def isoOfIso {X Y : Mon_ C} {P Q : Bimod X Y} (f : P.X ≅ Q.X)
    (f_left_act_hom : P.actLeft ≫ f.hom = (X.X ◁ f.hom) ≫ Q.actLeft)
    (f_right_act_hom : P.actRight ≫ f.hom = (f.hom ▷ Y.X) ≫ Q.actRight) : P ≅ Q 
goal: (Bimod.isoOfIso f f_left_act_hom f_right_act_hom).inv.hom = f.inv

full_name: Bimod.isoOfIso_hom_hom
code: /-- 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.
-/
@[simps]
def isoOfIso {X Y : Mon_ C} {P Q : Bimod X Y} (f : P.X ≅ Q.X)
    (f_left_act_hom : P.actLeft ≫ f.hom = (X.X ◁ f.hom) ≫ Q.actLeft)
    (f_right_act_hom : P.actRight ≫ f.hom = (f.hom ▷ Y.X) ≫ Q.actRight) : P ≅ Q 
goal: (Bimod.isoOfIso f f_left_act_hom f_right_act_hom).hom.hom = f.hom

full_name: Bimod.isoOfIso
code: /-- 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.
-/
@[simps]
def isoOfIso {X Y : Mon_ C} {P Q : Bimod X Y} (f : P.X ≅ Q.X)
    (f_left_act_hom : P.actLeft ≫ f.hom = (X.X ◁ f.hom) ≫ Q.actLeft)
    (f_right_act_hom : P.actRight ≫ f.hom = (f.hom ▷ Y.X) ≫ Q.actRight) : P ≅ Q 
goal: P ≅ Q

full_name: Bimod.regular
code: /-- A monoid object as a bimodule over itself. -/
@[simps]
def regular : Bimod A A 
goal: Bimod A A

full_name: Bimod.regular_X
code: /-- A monoid object as a bimodule over itself. -/
@[simps]
def regular : Bimod A A 
goal: (Bimod.regular A).X = A.X

full_name: Bimod.regular_actRight
code: /-- A monoid object as a bimodule over itself. -/
@[simps]
def regular : Bimod A A 
goal: (Bimod.regular A).actRight = A.mul

full_name: Bimod.regular_actLeft
code: /-- A monoid object as a bimodule over itself. -/
@[simps]
def regular : Bimod A A 
goal: (Bimod.regular A).actLeft = A.mul

full_name: Bimod.instInhabited
code: instance : Inhabited (Bimod A A) 
goal: Inhabited (Bimod A A)

full_name: Bimod.forget
code: /-- The forgetful functor from bimodule objects to the ambient category. -/
def forget : Bimod A B ⥤ C 
goal: Bimod A B ⥤ C

full_name: Bimod.TensorBimod.X
code: /-- The underlying object of the tensor product of two bimodules. -/
noncomputable def X : C 
goal: C

full_name: Bimod.TensorBimod.actLeft
code: /-- Left action for the tensor product of two bimodules. -/
noncomputable def actLeft : R.X ⊗ X P Q ⟶ X P Q 
goal: R.X ⊗ Bimod.TensorBimod.X P Q ⟶ Bimod.TensorBimod.X P Q

full_name: Bimod.TensorBimod.whiskerLeft_π_actLeft
code: theorem whiskerLeft_π_actLeft :
    (R.X ◁ coequalizer.π _ _) ≫ actLeft P Q =
      (α_ _ _ _).inv ≫ (P.actLeft ▷ Q.X) ≫ coequalizer.π _ _ 
goal: R.X ◁ CategoryTheory.Limits.coequalizer.π (P.actRight ▷ Q.X) ((α_ P.X S.X Q.X).hom ≫ P.X ◁ Q.actLeft) ≫
    Bimod.TensorBimod.actLeft P Q =
  (α_ R.X P.X Q.X).inv ≫
    P.actLeft ▷ Q.X ≫ CategoryTheory.Limits.coequalizer.π (P.actRight ▷ Q.X) ((α_ P.X S.X Q.X).hom ≫ P.X ◁ Q.actLeft)

full_name: Bimod.TensorBimod.one_act_left'
code: theorem one_act_left' : (R.one ▷ _) ≫ actLeft P Q = (λ_ _).hom 
goal: R.one ▷ Bimod.TensorBimod.X P Q ≫ Bimod.TensorBimod.actLeft P Q = (λ_ (Bimod.TensorBimod.X P Q)).hom

full_name: Bimod.TensorBimod.left_assoc'
code: theorem left_assoc' :
    (R.mul ▷ _) ≫ actLeft P Q = (α_ R.X R.X _).hom ≫ (R.X ◁ actLeft P Q) ≫ actLeft P Q 
goal: R.mul ▷ Bimod.TensorBimod.X P Q ≫ Bimod.TensorBimod.actLeft P Q =
  (α_ R.X R.X (Bimod.TensorBimod.X P Q)).hom ≫ R.X ◁ Bimod.TensorBimod.actLeft P Q ≫ Bimod.TensorBimod.actLeft P Q

full_name: Bimod.TensorBimod.actRight
code: /-- Right action for the tensor product of two bimodules. -/
noncomputable def actRight : X P Q ⊗ T.X ⟶ X P Q 
goal: Bimod.TensorBimod.X P Q ⊗ T.X ⟶ Bimod.TensorBimod.X P Q

full_name: Bimod.TensorBimod.π_tensor_id_actRight
code: theorem π_tensor_id_actRight :
    (coequalizer.π _ _ ▷ T.X) ≫ actRight P Q =
      (α_ _ _ _).hom ≫ (P.X ◁ Q.actRight) ≫ coequalizer.π _ _ 
goal: CategoryTheory.Limits.coequalizer.π (P.actRight ▷ Q.X) ((α_ P.X S.X Q.X).hom ≫ P.X ◁ Q.actLeft) ▷ T.X ≫
    Bimod.TensorBimod.actRight P Q =
  (α_ P.X Q.X T.X).hom ≫
    P.X ◁ Q.actRight ≫ CategoryTheory.Limits.coequalizer.π (P.actRight ▷ Q.X) ((α_ P.X S.X Q.X).hom ≫ P.X ◁ Q.actLeft)

full_name: Bimod.TensorBimod.actRight_one'
code: theorem actRight_one' : (_ ◁ T.one) ≫ actRight P Q = (ρ_ _).hom 
goal: Bimod.TensorBimod.X P Q ◁ T.one ≫ Bimod.TensorBimod.actRight P Q = (ρ_ (Bimod.TensorBimod.X P Q)).hom

full_name: Bimod.TensorBimod.right_assoc'
code: theorem right_assoc' :
    (_ ◁ T.mul) ≫ actRight P Q =
      (α_ _ T.X T.X).inv ≫ (actRight P Q ▷ T.X) ≫ actRight P Q 
goal: Bimod.TensorBimod.X P Q ◁ T.mul ≫ Bimod.TensorBimod.actRight P Q =
  (α_ (Bimod.TensorBimod.X P Q) T.X T.X).inv ≫ Bimod.TensorBimod.actRight P Q ▷ T.X ≫ Bimod.TensorBimod.actRight P Q

full_name: Bimod.TensorBimod.middle_assoc'
code: theorem middle_assoc' :
    (actLeft P Q ▷ T.X) ≫ actRight P Q =
      (α_ R.X _ T.X).hom ≫ (R.X ◁ actRight P Q) ≫ actLeft P Q 
goal: Bimod.TensorBimod.actLeft P Q ▷ T.X ≫ Bimod.TensorBimod.actRight P Q =
  (α_ R.X (Bimod.TensorBimod.X P Q) T.X).hom ≫ R.X ◁ Bimod.TensorBimod.actRight P Q ≫ Bimod.TensorBimod.actLeft P Q

full_name: Bimod.tensorBimod
code: /-- Tensor product of two bimodule objects as a bimodule object. -/
@[simps]
noncomputable def tensorBimod {X Y Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) : Bimod X Z 
goal: Bimod X Z

full_name: Bimod.tensorBimod_actRight
code: /-- Tensor product of two bimodule objects as a bimodule object. -/
@[simps]
noncomputable def tensorBimod {X Y Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) : Bimod X Z 
goal: (M.tensorBimod N).actRight = Bimod.TensorBimod.actRight M N

full_name: Bimod.tensorBimod_X
code: /-- Tensor product of two bimodule objects as a bimodule object. -/
@[simps]
noncomputable def tensorBimod {X Y Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) : Bimod X Z 
goal: (M.tensorBimod N).X = Bimod.TensorBimod.X M N

full_name: Bimod.tensorBimod_actLeft
code: /-- Tensor product of two bimodule objects as a bimodule object. -/
@[simps]
noncomputable def tensorBimod {X Y Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) : Bimod X Z 
goal: (M.tensorBimod N).actLeft = Bimod.TensorBimod.actLeft M N

full_name: Bimod.whiskerLeft_hom
code: /-- Left whiskering for morphisms of bimodule objects. -/
@[simps]
noncomputable def whiskerLeft {X Y Z : Mon_ C} (M : Bimod X Y) {N₁ N₂ : Bimod Y Z} (f : N₁ ⟶ N₂) :
    M.tensorBimod N₁ ⟶ M.tensorBimod N₂ 
goal: (M.whiskerLeft f).hom =
  CategoryTheory.Limits.colimMap
    (CategoryTheory.Limits.parallelPairHom (M.actRight ▷ N₁.X) ((α_ M.X Y.X N₁.X).hom ≫ M.X ◁ N₁.actLeft)
      (M.actRight ▷ N₂.X) ((α_ M.X Y.X N₂.X).hom ≫ M.X ◁ N₂.actLeft) ((M.X ⊗ Y.X) ◁ f.hom) (M.X ◁ f.hom) ⋯ ⋯)

full_name: Bimod.whiskerLeft
code: /-- Left whiskering for morphisms of bimodule objects. -/
@[simps]
noncomputable def whiskerLeft {X Y Z : Mon_ C} (M : Bimod X Y) {N₁ N₂ : Bimod Y Z} (f : N₁ ⟶ N₂) :
    M.tensorBimod N₁ ⟶ M.tensorBimod N₂ 
goal: M.tensorBimod N₁ ⟶ M.tensorBimod N₂

full_name: Bimod.whiskerRight
code: /-- Right whiskering for morphisms of bimodule objects. -/
@[simps]
noncomputable def whiskerRight {X Y Z : Mon_ C} {M₁ M₂ : Bimod X Y} (f : M₁ ⟶ M₂) (N : Bimod Y Z) :
    M₁.tensorBimod N ⟶ M₂.tensorBimod N 
goal: M₁.tensorBimod N ⟶ M₂.tensorBimod N

full_name: Bimod.whiskerRight_hom
code: /-- Right whiskering for morphisms of bimodule objects. -/
@[simps]
noncomputable def whiskerRight {X Y Z : Mon_ C} {M₁ M₂ : Bimod X Y} (f : M₁ ⟶ M₂) (N : Bimod Y Z) :
    M₁.tensorBimod N ⟶ M₂.tensorBimod N 
goal: (Bimod.whiskerRight f N).hom =
  CategoryTheory.Limits.colimMap
    (CategoryTheory.Limits.parallelPairHom (M₁.actRight ▷ N.X) ((α_ M₁.X Y.X N.X).hom ≫ M₁.X ◁ N.actLeft)
      (M₂.actRight ▷ N.X) ((α_ M₂.X Y.X N.X).hom ≫ M₂.X ◁ N.actLeft) (f.hom ▷ Y.X ▷ N.X) (f.hom ▷ N.X) ⋯ ⋯)

full_name: Bimod.AssociatorBimod.homAux
code: /-- An auxiliary morphism for the definition of the underlying morphism of the forward component of
the associator isomorphism. -/
noncomputable def homAux : (P.tensorBimod Q).X ⊗ L.X ⟶ (P.tensorBimod (Q.tensorBimod L)).X 
goal: (P.tensorBimod Q).X ⊗ L.X ⟶ (P.tensorBimod (Q.tensorBimod L)).X

full_name: Bimod.AssociatorBimod.hom
code: /-- The underlying morphism of the forward component of the associator isomorphism. -/
noncomputable def hom :
    ((P.tensorBimod Q).tensorBimod L).X ⟶ (P.tensorBimod (Q.tensorBimod L)).X 
goal: ((P.tensorBimod Q).tensorBimod L).X ⟶ (P.tensorBimod (Q.tensorBimod L)).X

full_name: Bimod.AssociatorBimod.hom_left_act_hom'
code: theorem hom_left_act_hom' :
    ((P.tensorBimod Q).tensorBimod L).actLeft ≫ hom P Q L =
      (R.X ◁ hom P Q L) ≫ (P.tensorBimod (Q.tensorBimod L)).actLeft 
goal: ((P.tensorBimod Q).tensorBimod L).actLeft ≫ Bimod.AssociatorBimod.hom P Q L =
  R.X ◁ Bimod.AssociatorBimod.hom P Q L ≫ (P.tensorBimod (Q.tensorBimod L)).actLeft

full_name: Bimod.AssociatorBimod.hom_right_act_hom'
code: theorem hom_right_act_hom' :
    ((P.tensorBimod Q).tensorBimod L).actRight ≫ hom P Q L =
      (hom P Q L ▷ U.X) ≫ (P.tensorBimod (Q.tensorBimod L)).actRight 
goal: ((P.tensorBimod Q).tensorBimod L).actRight ≫ Bimod.AssociatorBimod.hom P Q L =
  Bimod.AssociatorBimod.hom P Q L ▷ U.X ≫ (P.tensorBimod (Q.tensorBimod L)).actRight

full_name: Bimod.AssociatorBimod.invAux
code: /-- An auxiliary morphism for the definition of the underlying morphism of the inverse component of
the associator isomorphism. -/
noncomputable def invAux : P.X ⊗ (Q.tensorBimod L).X ⟶ ((P.tensorBimod Q).tensorBimod L).X 
goal: P.X ⊗ (Q.tensorBimod L).X ⟶ ((P.tensorBimod Q).tensorBimod L).X

full_name: Bimod.AssociatorBimod.inv
code: /-- The underlying morphism of the inverse component of the associator isomorphism. -/
noncomputable def inv :
    (P.tensorBimod (Q.tensorBimod L)).X ⟶ ((P.tensorBimod Q).tensorBimod L).X 
goal: (P.tensorBimod (Q.tensorBimod L)).X ⟶ ((P.tensorBimod Q).tensorBimod L).X

full_name: Bimod.AssociatorBimod.hom_inv_id
code: theorem hom_inv_id : hom P Q L ≫ inv P Q L = 𝟙 _ 
goal: Bimod.AssociatorBimod.hom P Q L ≫ Bimod.AssociatorBimod.inv P Q L = 𝟙 ((P.tensorBimod Q).tensorBimod L).X

full_name: Bimod.AssociatorBimod.inv_hom_id
code: theorem inv_hom_id : inv P Q L ≫ hom P Q L = 𝟙 _ 
goal: Bimod.AssociatorBimod.inv P Q L ≫ Bimod.AssociatorBimod.hom P Q L = 𝟙 (P.tensorBimod (Q.tensorBimod L)).X

full_name: Bimod.LeftUnitorBimod.hom
code: /-- The underlying morphism of the forward component of the left unitor isomorphism. -/
noncomputable def hom : TensorBimod.X (regular R) P ⟶ P.X 
goal: Bimod.TensorBimod.X (Bimod.regular R) P ⟶ P.X

full_name: Bimod.LeftUnitorBimod.inv
code: /-- The underlying morphism of the inverse component of the left unitor isomorphism. -/
noncomputable def inv : P.X ⟶ TensorBimod.X (regular R) P 
goal: P.X ⟶ Bimod.TensorBimod.X (Bimod.regular R) P

full_name: Bimod.LeftUnitorBimod.hom_inv_id
code: theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ 
goal: Bimod.LeftUnitorBimod.hom P ≫ Bimod.LeftUnitorBimod.inv P = 𝟙 (Bimod.TensorBimod.X (Bimod.regular R) P)

full_name: Bimod.LeftUnitorBimod.inv_hom_id
code: theorem inv_hom_id : inv P ≫ hom P = 𝟙 _ 
goal: Bimod.LeftUnitorBimod.inv P ≫ Bimod.LeftUnitorBimod.hom P = 𝟙 P.X

full_name: Bimod.LeftUnitorBimod.hom_left_act_hom'
code: theorem hom_left_act_hom' :
    ((regular R).tensorBimod P).actLeft ≫ hom P = (R.X ◁ hom P) ≫ P.actLeft 
goal: ((Bimod.regular R).tensorBimod P).actLeft ≫ Bimod.LeftUnitorBimod.hom P = R.X ◁ Bimod.LeftUnitorBimod.hom P ≫ P.actLeft

full_name: Bimod.LeftUnitorBimod.hom_right_act_hom'
code: theorem hom_right_act_hom' :
    ((regular R).tensorBimod P).actRight ≫ hom P = (hom P ▷ S.X) ≫ P.actRight 
goal: ((Bimod.regular R).tensorBimod P).actRight ≫ Bimod.LeftUnitorBimod.hom P =
  Bimod.LeftUnitorBimod.hom P ▷ S.X ≫ P.actRight

full_name: Bimod.RightUnitorBimod.hom
code: /-- The underlying morphism of the forward component of the right unitor isomorphism. -/
noncomputable def hom : TensorBimod.X P (regular S) ⟶ P.X 
goal: Bimod.TensorBimod.X P (Bimod.regular S) ⟶ P.X

full_name: Bimod.RightUnitorBimod.inv
code: /-- The underlying morphism of the inverse component of the right unitor isomorphism. -/
noncomputable def inv : P.X ⟶ TensorBimod.X P (regular S) 
goal: P.X ⟶ Bimod.TensorBimod.X P (Bimod.regular S)

full_name: Bimod.RightUnitorBimod.hom_inv_id
code: theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ 
goal: Bimod.RightUnitorBimod.hom P ≫ Bimod.RightUnitorBimod.inv P = 𝟙 (Bimod.TensorBimod.X P (Bimod.regular S))

full_name: Bimod.RightUnitorBimod.inv_hom_id
code: theorem inv_hom_id : inv P ≫ hom P = 𝟙 _ 
goal: Bimod.RightUnitorBimod.inv P ≫ Bimod.RightUnitorBimod.hom P = 𝟙 P.X

full_name: Bimod.RightUnitorBimod.hom_left_act_hom'
code: theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (R.X ◁ hom P) ≫ P.actLeft 
goal: (P.tensorBimod (Bimod.regular S)).actLeft ≫ Bimod.RightUnitorBimod.hom P =
  R.X ◁ Bimod.RightUnitorBimod.hom P ≫ P.actLeft

full_name: Bimod.RightUnitorBimod.hom_right_act_hom'
code: theorem hom_right_act_hom' :
    (P.tensorBimod (regular S)).actRight ≫ hom P = (hom P ▷ S.X) ≫ P.actRight 
goal: (P.tensorBimod (Bimod.regular S)).actRight ≫ Bimod.RightUnitorBimod.hom P =
  Bimod.RightUnitorBimod.hom P ▷ S.X ≫ P.actRight

full_name: Bimod.associatorBimod
code: /-- The associator as a bimodule isomorphism. -/
noncomputable def associatorBimod {W X Y 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) 
goal: (L.tensorBimod M).tensorBimod N ≅ L.tensorBimod (M.tensorBimod N)

full_name: Bimod.leftUnitorBimod
code: /-- The left unitor as a bimodule isomorphism. -/
noncomputable def leftUnitorBimod {X Y : Mon_ C} (M : Bimod X Y) : (regular X).tensorBimod M ≅ M 
goal: (Bimod.regular X).tensorBimod M ≅ M

full_name: Bimod.rightUnitorBimod
code: /-- The right unitor as a bimodule isomorphism. -/
noncomputable def rightUnitorBimod {X Y : Mon_ C} (M : Bimod X Y) : M.tensorBimod (regular Y) ≅ M 
goal: M.tensorBimod (Bimod.regular Y) ≅ M

full_name: Bimod.whiskerLeft_id_bimod
code: theorem whiskerLeft_id_bimod {X Y Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} :
    whiskerLeft M (𝟙 N) = 𝟙 (M.tensorBimod N) 
goal: M.whiskerLeft (𝟙 N) = 𝟙 (M.tensorBimod N)

full_name: Bimod.id_whiskerRight_bimod
code: theorem id_whiskerRight_bimod {X Y Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} :
    whiskerRight (𝟙 M) N = 𝟙 (M.tensorBimod N) 
goal: Bimod.whiskerRight (𝟙 M) N = 𝟙 (M.tensorBimod N)

full_name: Bimod.whiskerLeft_comp_bimod
code: theorem whiskerLeft_comp_bimod {X Y Z : Mon_ C} (M : Bimod X Y) {N P Q : Bimod Y Z} (f : N ⟶ P)
    (g : P ⟶ Q) : whiskerLeft M (f ≫ g) = whiskerLeft M f ≫ whiskerLeft M g 
goal: M.whiskerLeft (f ≫ g) = M.whiskerLeft f ≫ M.whiskerLeft g

full_name: Bimod.id_whiskerLeft_bimod
code: theorem id_whiskerLeft_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    whiskerLeft (regular X) f = (leftUnitorBimod M).hom ≫ f ≫ (leftUnitorBimod N).inv 
goal: (Bimod.regular X).whiskerLeft f = M.leftUnitorBimod.hom ≫ f ≫ N.leftUnitorBimod.inv

full_name: Bimod.comp_whiskerLeft_bimod
code: theorem comp_whiskerLeft_bimod {W X Y Z : Mon_ C} (M : Bimod W X) (N : Bimod X Y)
    {P P' : Bimod Y Z} (f : P ⟶ P') :
    whiskerLeft (M.tensorBimod N) f =
      (associatorBimod M N P).hom ≫
        whiskerLeft M (whiskerLeft N f) ≫ (associatorBimod M N P').inv 
goal: (M.tensorBimod N).whiskerLeft f =
  (M.associatorBimod N P).hom ≫ M.whiskerLeft (N.whiskerLeft f) ≫ (M.associatorBimod N P').inv

full_name: Bimod.comp_whiskerRight_bimod
code: theorem comp_whiskerRight_bimod {X Y Z : Mon_ C} {M N P : Bimod X Y} (f : M ⟶ N) (g : N ⟶ P)
    (Q : Bimod Y Z) : whiskerRight (f ≫ g) Q = whiskerRight f Q ≫ whiskerRight g Q 
goal: Bimod.whiskerRight (f ≫ g) Q = Bimod.whiskerRight f Q ≫ Bimod.whiskerRight g Q

full_name: Bimod.whiskerRight_id_bimod
code: theorem whiskerRight_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    whiskerRight f (regular Y) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv 
goal: Bimod.whiskerRight f (Bimod.regular Y) = M.rightUnitorBimod.hom ≫ f ≫ N.rightUnitorBimod.inv

full_name: Bimod.whiskerRight_comp_bimod
code: theorem whiskerRight_comp_bimod {W X Y Z : Mon_ C} {M M' : Bimod W X} (f : M ⟶ M') (N : Bimod X Y)
    (P : Bimod Y Z) :
    whiskerRight f (N.tensorBimod P) =
      (associatorBimod M N P).inv ≫
        whiskerRight (whiskerRight f N) P ≫ (associatorBimod M' N P).hom 
goal: Bimod.whiskerRight f (N.tensorBimod P) =
  (M.associatorBimod N P).inv ≫ Bimod.whiskerRight (Bimod.whiskerRight f N) P ≫ (M'.associatorBimod N P).hom

full_name: Bimod.whisker_assoc_bimod
code: theorem whisker_assoc_bimod {W X Y Z : Mon_ C} (M : Bimod W X) {N N' : Bimod X Y} (f : N ⟶ N')
    (P : Bimod Y Z) :
    whiskerRight (whiskerLeft M f) P =
      (associatorBimod M N P).hom ≫
        whiskerLeft M (whiskerRight f P) ≫ (associatorBimod M N' P).inv 
goal: Bimod.whiskerRight (M.whiskerLeft f) P =
  (M.associatorBimod N P).hom ≫ M.whiskerLeft (Bimod.whiskerRight f P) ≫ (M.associatorBimod N' P).inv

full_name: Bimod.whisker_exchange_bimod
code: theorem whisker_exchange_bimod {X Y Z : Mon_ C} {M N : Bimod X Y} {P Q : Bimod Y Z} (f : M ⟶ N)
    (g : P ⟶ Q) : whiskerLeft M g ≫ whiskerRight f Q =
      whiskerRight f P ≫ whiskerLeft N g 
goal: M.whiskerLeft g ≫ Bimod.whiskerRight f Q = Bimod.whiskerRight f P ≫ N.whiskerLeft g

full_name: Bimod.pentagon_bimod
code: theorem pentagon_bimod {V W X Y Z : Mon_ C} (M : Bimod V W) (N : Bimod W X) (P : Bimod X Y)
    (Q : Bimod Y Z) :
    whiskerRight (associatorBimod M N P).hom Q ≫
      (associatorBimod M (N.tensorBimod P) Q).hom ≫
        whiskerLeft M (associatorBimod N P Q).hom =
      (associatorBimod (M.tensorBimod N) P Q).hom ≫
        (associatorBimod M N (P.tensorBimod Q)).hom 
goal: Bimod.whiskerRight (M.associatorBimod N P).hom Q ≫
    (M.associatorBimod (N.tensorBimod P) Q).hom ≫ M.whiskerLeft (N.associatorBimod P Q).hom =
  ((M.tensorBimod N).associatorBimod P Q).hom ≫ (M.associatorBimod N (P.tensorBimod Q)).hom

full_name: Bimod.triangle_bimod
code: theorem triangle_bimod {X Y Z : Mon_ C} (M : Bimod X Y) (N : Bimod Y Z) :
    (associatorBimod M (regular Y) N).hom ≫ whiskerLeft M (leftUnitorBimod N).hom =
      whiskerRight (rightUnitorBimod M).hom N 
goal: (M.associatorBimod (Bimod.regular Y) N).hom ≫ M.whiskerLeft N.leftUnitorBimod.hom =
  Bimod.whiskerRight M.rightUnitorBimod.hom N

full_name: Bimod.monBicategory
code: /-- The bicategory of algebras (monoids) and bimodules, all internal to some monoidal category. -/
noncomputable def monBicategory : Bicategory (Mon_ C) 
goal: CategoryTheory.Bicategory (Mon_ C)