l3lab/ntp-mathlib huggingface dataset:
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  

Proof state:
case h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
⊢ (Hom.mk
        (colimMap
          (parallelPairHom (M.actRight ⊗ 𝟙 Y.X) ((α_ M.X Y.X Y.X).hom ≫ (𝟙 M.X ⊗ Y.mul)) (N.actRight ⊗ 𝟙 Y.X)
            ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul)) ((f.hom ⊗ 𝟙 Y.X) ⊗ 𝟙 Y.X) (f.hom ⊗ 𝟙 Y.X)
            (_ :
              (M.actRight ⊗ 𝟙 (mk Y.X Y.mul Y.mul).X) ≫ (f.hom ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) =
                ((f.hom ⊗ 𝟙 Y.X) ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) ≫ (N.actRight ⊗ 𝟙 (mk Y.X Y.mul Y.mul).X))
            (_ :
              ((α_ M.X Y.X (mk Y.X Y.mul Y.mul).X).hom ≫ (𝟙 M.X ⊗ (mk Y.X Y.mul Y.mul).actLeft)) ≫
                  (f.hom ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) =
                ((f.hom ⊗ 𝟙 Y.X) ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) ≫
                  (α_ N.X Y.X (mk Y.X Y.mul Y.mul).X).hom ≫ (𝟙 N.X ⊗ (mk Y.X Y.mul Y.mul).actLeft))))).hom =
    ((isoOfIso (Iso.mk (RightUnitorBimod.hom M) (RightUnitorBimod.inv M))
            (_ :
              (tensorBimod M (regular Y)).actLeft ≫ RightUnitorBimod.hom M =
                (𝟙 X.X ⊗ RightUnitorBimod.hom M) ≫ M.actLeft)
            (_ :
              (tensorBimod M (regular Y)).actRight ≫ RightUnitorBimod.hom M =
                (RightUnitorBimod.hom M ⊗ 𝟙 Y.X) ≫ M.actRight)).hom ≫
        f ≫
          (isoOfIso (Iso.mk (RightUnitorBimod.hom N) (RightUnitorBimod.inv N))
              (_ :
                (tensorBimod N (regular Y)).actLeft ≫ RightUnitorBimod.hom N =
                  (𝟙 X.X ⊗ RightUnitorBimod.hom N) ≫ N.actLeft)
              (_ :
                (tensorBimod N (regular Y)).actRight ≫ RightUnitorBimod.hom N =
                  (RightUnitorBimod.hom N ⊗ 𝟙 Y.X) ≫ N.actRight)).inv).hom

Next tactic:
apply coequalizer.hom_ext
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
⊢ coequalizer.π (M.actRight ⊗ 𝟙 (mk Y.X Y.mul Y.mul).X)
        ((α_ M.X Y.X (mk Y.X Y.mul Y.mul).X).hom ≫ (𝟙 M.X ⊗ (mk Y.X Y.mul Y.mul).actLeft)) ≫
      (Hom.mk
          (colimMap
            (parallelPairHom (M.actRight ⊗ 𝟙 Y.X) ((α_ M.X Y.X Y.X).hom ≫ (𝟙 M.X ⊗ Y.mul)) (N.actRight ⊗ 𝟙 Y.X)
              ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul)) ((f.hom ⊗ 𝟙 Y.X) ⊗ 𝟙 Y.X) (f.hom ⊗ 𝟙 Y.X)
              (_ :
                (M.actRight ⊗ 𝟙 (mk Y.X Y.mul Y.mul).X) ≫ (f.hom ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) =
                  ((f.hom ⊗ 𝟙 Y.X) ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) ≫ (N.actRight ⊗ 𝟙 (mk Y.X Y.mul Y.mul).X))
              (_ :
                ((α_ M.X Y.X (mk Y.X Y.mul Y.mul).X).hom ≫ (𝟙 M.X ⊗ (mk Y.X Y.mul Y.mul).actLeft)) ≫
                    (f.hom ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) =
                  ((f.hom ⊗ 𝟙 Y.X) ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) ≫
                    (α_ N.X Y.X (mk Y.X Y.mul Y.mul).X).hom ≫ (𝟙 N.X ⊗ (mk Y.X Y.mul Y.mul).actLeft))))).hom =
    coequalizer.π (M.actRight ⊗ 𝟙 (mk Y.X Y.mul Y.mul).X)
        ((α_ M.X Y.X (mk Y.X Y.mul Y.mul).X).hom ≫ (𝟙 M.X ⊗ (mk Y.X Y.mul Y.mul).actLeft)) ≫
      ((isoOfIso (Iso.mk (RightUnitorBimod.hom M) (RightUnitorBimod.inv M))
              (_ :
                (tensorBimod M (regular Y)).actLeft ≫ RightUnitorBimod.hom M =
                  (𝟙 X.X ⊗ RightUnitorBimod.hom M) ≫ M.actLeft)
              (_ :
                (tensorBimod M (regular Y)).actRight ≫ RightUnitorBimod.hom M =
                  (RightUnitorBimod.hom M ⊗ 𝟙 Y.X) ≫ M.actRight)).hom ≫
          f ≫
            (isoOfIso (Iso.mk (RightUnitorBimod.hom N) (RightUnitorBimod.inv N))
                (_ :
                  (tensorBimod N (regular Y)).actLeft ≫ RightUnitorBimod.hom N =
                    (𝟙 X.X ⊗ RightUnitorBimod.hom N) ≫ N.actLeft)
                (_ :
                  (tensorBimod N (regular Y)).actRight ≫ RightUnitorBimod.hom N =
                    (RightUnitorBimod.hom N ⊗ 𝟙 Y.X) ≫ N.actRight)).inv).hom

Next tactic:
dsimp
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
⊢ coequalizer.π (M.actRight ⊗ 𝟙 Y.X) ((α_ M.X Y.X Y.X).hom ≫ (𝟙 M.X ⊗ Y.mul)) ≫
      colimMap
        (parallelPairHom (M.actRight ⊗ 𝟙 Y.X) ((α_ M.X Y.X Y.X).hom ≫ (𝟙 M.X ⊗ Y.mul)) (N.actRight ⊗ 𝟙 Y.X)
          ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul)) ((f.hom ⊗ 𝟙 Y.X) ⊗ 𝟙 Y.X) (f.hom ⊗ 𝟙 Y.X)
          (_ :
            (M.actRight ⊗ 𝟙 (mk Y.X Y.mul Y.mul).X) ≫ (f.hom ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) =
              ((f.hom ⊗ 𝟙 Y.X) ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) ≫ (N.actRight ⊗ 𝟙 (mk Y.X Y.mul Y.mul).X))
          (_ :
            ((α_ M.X Y.X (mk Y.X Y.mul Y.mul).X).hom ≫ (𝟙 M.X ⊗ (mk Y.X Y.mul Y.mul).actLeft)) ≫
                (f.hom ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) =
              ((f.hom ⊗ 𝟙 Y.X) ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) ≫
                (α_ N.X Y.X (mk Y.X Y.mul Y.mul).X).hom ≫ (𝟙 N.X ⊗ (mk Y.X Y.mul Y.mul).actLeft))) =
    coequalizer.π (M.actRight ⊗ 𝟙 Y.X) ((α_ M.X Y.X Y.X).hom ≫ (𝟙 M.X ⊗ Y.mul)) ≫
      RightUnitorBimod.hom M ≫ f.hom ≫ RightUnitorBimod.inv N

Next tactic:
slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => 

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| coequalizer.π (M.actRight ⊗ 𝟙 Y.X) ((α_ M.X Y.X Y.X).hom ≫ (𝟙 M.X ⊗ Y.mul)) ≫
    colimMap
      (parallelPairHom (M.actRight ⊗ 𝟙 Y.X) ((α_ M.X Y.X Y.X).hom ≫ (𝟙 M.X ⊗ Y.mul)) (N.actRight ⊗ 𝟙 Y.X)
        ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul)) ((f.hom ⊗ 𝟙 Y.X) ⊗ 𝟙 Y.X) (f.hom ⊗ 𝟙 Y.X)
        (_ :
          (M.actRight ⊗ 𝟙 (mk Y.X Y.mul Y.mul).X) ≫ (f.hom ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) =
            ((f.hom ⊗ 𝟙 Y.X) ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) ≫ (N.actRight ⊗ 𝟙 (mk Y.X Y.mul Y.mul).X))
        (_ :
          ((α_ M.X Y.X (mk Y.X Y.mul Y.mul).X).hom ≫ (𝟙 M.X ⊗ (mk Y.X Y.mul Y.mul).actLeft)) ≫
              (f.hom ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) =
            ((f.hom ⊗ 𝟙 Y.X) ⊗ (𝟙 (mk Y.X Y.mul Y.mul)).hom) ≫
              (α_ N.X Y.X (mk Y.X Y.mul Y.mul).X).hom ≫ (𝟙 N.X ⊗ (mk Y.X Y.mul Y.mul).actLeft)))

Next tactic:
rw [ι_colimMap, parallelPairHom_app_one]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
⊢ (f.hom ⊗ 𝟙 Y.X) ≫
      colimit.ι (parallelPair (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))) WalkingParallelPair.one =
    coequalizer.π (M.actRight ⊗ 𝟙 Y.X) ((α_ M.X Y.X Y.X).hom ≫ (𝟙 M.X ⊗ Y.mul)) ≫
      RightUnitorBimod.hom M ≫ f.hom ≫ RightUnitorBimod.inv N

Next tactic:
dsimp [RightUnitorBimod.hom]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  dsimp [RightUnitorBimod.hom]
  

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
⊢ (f.hom ⊗ 𝟙 Y.X) ≫
      colimit.ι (parallelPair (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))) WalkingParallelPair.one =
    coequalizer.π (M.actRight ⊗ 𝟙 Y.X) ((α_ M.X Y.X Y.X).hom ≫ (𝟙 M.X ⊗ Y.mul)) ≫
      coequalizer.desc M.actRight
          (_ :
            (M.actRight ⊗ 𝟙 (regular Y).X) ≫ M.actRight =
              ((α_ M.X Y.X (regular Y).X).hom ≫ (𝟙 M.X ⊗ (regular Y).actLeft)) ≫ M.actRight) ≫
        f.hom ≫ RightUnitorBimod.inv N

Next tactic:
slice_rhs 1 2 => rw [coequalizer.π_desc]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  dsimp [RightUnitorBimod.hom]
  slice_rhs 1 2 => 

Proof state:
case a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| coequalizer.π (M.actRight ⊗ 𝟙 Y.X) ((α_ M.X Y.X Y.X).hom ≫ (𝟙 M.X ⊗ Y.mul)) ≫
    coequalizer.desc M.actRight
      (_ :
        (M.actRight ⊗ 𝟙 (regular Y).X) ≫ M.actRight =
          ((α_ M.X Y.X (regular Y).X).hom ≫ (𝟙 M.X ⊗ (regular Y).actLeft)) ≫ M.actRight)
case a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| f.hom
case a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| RightUnitorBimod.inv N

Next tactic:
rw [coequalizer.π_desc]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  dsimp [RightUnitorBimod.hom]
  slice_rhs 1 2 => rw [coequalizer.π_desc]
  

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
⊢ (f.hom ⊗ 𝟙 Y.X) ≫
      colimit.ι (parallelPair (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))) WalkingParallelPair.one =
    (M.actRight ≫ f.hom) ≫ RightUnitorBimod.inv N

Next tactic:
dsimp [RightUnitorBimod.inv]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  dsimp [RightUnitorBimod.hom]
  slice_rhs 1 2 => rw [coequalizer.π_desc]
  dsimp [RightUnitorBimod.inv]
  

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
⊢ (f.hom ⊗ 𝟙 Y.X) ≫
      colimit.ι (parallelPair (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))) WalkingParallelPair.one =
    (M.actRight ≫ f.hom) ≫
      (ρ_ N.X).inv ≫ (𝟙 N.X ⊗ Y.one) ≫ coequalizer.π (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))

Next tactic:
slice_rhs 1 2 => rw [Hom.right_act_hom]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  dsimp [RightUnitorBimod.hom]
  slice_rhs 1 2 => rw [coequalizer.π_desc]
  dsimp [RightUnitorBimod.inv]
  slice_rhs 1 2 => 

Proof state:
case a.a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| M.actRight ≫ f.hom
case a.a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| (ρ_ N.X).inv
case a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| 𝟙 N.X ⊗ Y.one
case a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| coequalizer.π (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))

Next tactic:
rw [Hom.right_act_hom]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  dsimp [RightUnitorBimod.hom]
  slice_rhs 1 2 => rw [coequalizer.π_desc]
  dsimp [RightUnitorBimod.inv]
  slice_rhs 1 2 => rw [Hom.right_act_hom]
  

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
⊢ (f.hom ⊗ 𝟙 Y.X) ≫
      colimit.ι (parallelPair (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))) WalkingParallelPair.one =
    ((((f.hom ⊗ 𝟙 Y.X) ≫ N.actRight) ≫ (ρ_ N.X).inv) ≫ (𝟙 N.X ⊗ Y.one)) ≫
      coequalizer.π (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))

Next tactic:
slice_rhs 2 3 => rw [rightUnitor_inv_naturality]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  dsimp [RightUnitorBimod.hom]
  slice_rhs 1 2 => rw [coequalizer.π_desc]
  dsimp [RightUnitorBimod.inv]
  slice_rhs 1 2 => rw [Hom.right_act_hom]
  slice_rhs 2 3 => 

Proof state:
case a.a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| N.actRight ≫ (ρ_ N.X).inv
case a.a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| 𝟙 N.X ⊗ Y.one
case a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| coequalizer.π (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))
case a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| f.hom ⊗ 𝟙 Y.X

Next tactic:
rw [rightUnitor_inv_naturality]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  dsimp [RightUnitorBimod.hom]
  slice_rhs 1 2 => rw [coequalizer.π_desc]
  dsimp [RightUnitorBimod.inv]
  slice_rhs 1 2 => rw [Hom.right_act_hom]
  slice_rhs 2 3 => rw [rightUnitor_inv_naturality]
  

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
⊢ (f.hom ⊗ 𝟙 Y.X) ≫
      colimit.ι (parallelPair (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))) WalkingParallelPair.one =
    (f.hom ⊗ 𝟙 Y.X) ≫
      (((ρ_ (N.X ⊗ Y.X)).inv ≫ (N.actRight ⊗ 𝟙 (𝟙_ C))) ≫ (𝟙 N.X ⊗ Y.one)) ≫
        coequalizer.π (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))

Next tactic:
slice_rhs 3 4 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  dsimp [RightUnitorBimod.hom]
  slice_rhs 1 2 => rw [coequalizer.π_desc]
  dsimp [RightUnitorBimod.inv]
  slice_rhs 1 2 => rw [Hom.right_act_hom]
  slice_rhs 2 3 => rw [rightUnitor_inv_naturality]
  slice_rhs 3 4 => 

Proof state:
case a.a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| (N.actRight ⊗ 𝟙 (𝟙_ C)) ≫ (𝟙 N.X ⊗ Y.one)
case a.a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| coequalizer.π (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))
case a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| f.hom ⊗ 𝟙 Y.X
case a.a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
| (ρ_ (N.X ⊗ Y.X)).inv

Next tactic:
rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
theorem whisker_right_id_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom f (𝟙 (regular Y)) = (rightUnitorBimod M).hom ≫ f ≫ (rightUnitorBimod N).inv := by
  dsimp [tensorHom, regular, rightUnitorBimod]
  ext
  apply coequalizer.hom_ext
  dsimp
  slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
  dsimp [RightUnitorBimod.hom]
  slice_rhs 1 2 => rw [coequalizer.π_desc]
  dsimp [RightUnitorBimod.inv]
  slice_rhs 1 2 => rw [Hom.right_act_hom]
  slice_rhs 2 3 => rw [rightUnitor_inv_naturality]
  slice_rhs 3 4 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M✝ : Bimod A B
inst✝² : HasCoequalizers C
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
X Y : Mon_ C
M N : Bimod X Y
f : M ⟶ N
⊢ (f.hom ⊗ 𝟙 Y.X) ≫
      colimit.ι (parallelPair (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))) WalkingParallelPair.one =
    (f.hom ⊗ 𝟙 Y.X) ≫
      (ρ_ (N.X ⊗ Y.X)).inv ≫
        ((𝟙 (N.X ⊗ Y.X) ⊗ Y.one) ≫ (N.actRight ⊗ 𝟙 Y.X)) ≫
          coequalizer.π (N.actRight ⊗ 𝟙 Y.X) ((α_ N.X Y.X Y.X).hom ≫ (𝟙 N.X ⊗ Y.mul))

Next tactic:
slice_rhs 4 5 => rw [coequalizer.condition]