l3lab/ntp-mathlib huggingface dataset:
theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft := by
  dsimp; dsimp [hom, TensorBimod.actLeft, regular]
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
⊢ ((PreservesCoequalizer.iso (tensorLeft R.X) (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))).inv ≫
        colimMap
          (parallelPairHom (𝟙 R.X ⊗ P.actRight ⊗ 𝟙 S.X) (𝟙 R.X ⊗ (α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
            (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
            ((𝟙 R.X ⊗ (α_ P.X S.X S.X).hom) ≫
              (α_ R.X P.X (S.X ⊗ S.X)).inv ≫ (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 S.X) ≫ (α_ P.X S.X S.X).inv)
            ((α_ R.X P.X S.X).inv ≫ (P.actLeft ⊗ 𝟙 S.X))
            (_ :
              (tensorLeft R.X).map (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫
                  (α_ R.X P.X (mk S.X S.mul S.mul).X).inv ≫ (P.actLeft ⊗ 𝟙 (mk S.X S.mul S.mul).X) =
                ((𝟙 R.X ⊗ (α_ P.X S.X (mk S.X S.mul S.mul).X).hom) ≫
                    (α_ R.X P.X (S.X ⊗ (mk S.X S.mul S.mul).X)).inv ≫
                      (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                  (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X))
            (_ :
              (tensorLeft R.X).map ((α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)) ≫
                  (α_ R.X P.X (mk S.X S.mul S.mul).X).inv ≫ (P.actLeft ⊗ 𝟙 (mk S.X S.mul S.mul).X) =
                ((𝟙 R.X ⊗ (α_ P.X S.X (mk S.X S.mul S.mul).X).hom) ≫
                    (α_ R.X P.X (S.X ⊗ (mk S.X S.mul S.mul).X)).inv ≫
                      (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                  (α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)))) ≫
      coequalizer.desc P.actRight
        (_ :
          (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
            ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight) =
    (𝟙 R.X ⊗
        coequalizer.desc P.actRight
          (_ :
            (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
              ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight)) ≫
      P.actLeft

Next tactic:
refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft := by
  dsimp; dsimp [hom, TensorBimod.actLeft, regular]
  refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
⊢ (tensorLeft R.X).map
        (coequalizer.π (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X)
          ((α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft))) ≫
      ((PreservesCoequalizer.iso (tensorLeft R.X) (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))).inv ≫
          colimMap
            (parallelPairHom (𝟙 R.X ⊗ P.actRight ⊗ 𝟙 S.X) (𝟙 R.X ⊗ (α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
              (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
              ((𝟙 R.X ⊗ (α_ P.X S.X S.X).hom) ≫
                (α_ R.X P.X (S.X ⊗ S.X)).inv ≫ (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 S.X) ≫ (α_ P.X S.X S.X).inv)
              ((α_ R.X P.X S.X).inv ≫ (P.actLeft ⊗ 𝟙 S.X))
              (_ :
                (tensorLeft R.X).map (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫
                    (α_ R.X P.X (mk S.X S.mul S.mul).X).inv ≫ (P.actLeft ⊗ 𝟙 (mk S.X S.mul S.mul).X) =
                  ((𝟙 R.X ⊗ (α_ P.X S.X (mk S.X S.mul S.mul).X).hom) ≫
                      (α_ R.X P.X (S.X ⊗ (mk S.X S.mul S.mul).X)).inv ≫
                        (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                    (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X))
              (_ :
                (tensorLeft R.X).map
                      ((α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)) ≫
                    (α_ R.X P.X (mk S.X S.mul S.mul).X).inv ≫ (P.actLeft ⊗ 𝟙 (mk S.X S.mul S.mul).X) =
                  ((𝟙 R.X ⊗ (α_ P.X S.X (mk S.X S.mul S.mul).X).hom) ≫
                      (α_ R.X P.X (S.X ⊗ (mk S.X S.mul S.mul).X)).inv ≫
                        (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                    (α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)))) ≫
        coequalizer.desc P.actRight
          (_ :
            (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
              ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight) =
    (tensorLeft R.X).map
        (coequalizer.π (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X)
          ((α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft))) ≫
      (𝟙 R.X ⊗
          coequalizer.desc P.actRight
            (_ :
              (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
                ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight)) ≫
        P.actLeft

Next tactic:
dsimp
theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft := by
  dsimp; dsimp [hom, TensorBimod.actLeft, regular]
  refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
  dsimp
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
⊢ (𝟙 R.X ⊗ coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))) ≫
      ((PreservesCoequalizer.iso (tensorLeft R.X) (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))).inv ≫
          colimMap
            (parallelPairHom (𝟙 R.X ⊗ P.actRight ⊗ 𝟙 S.X) (𝟙 R.X ⊗ (α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
              (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
              ((𝟙 R.X ⊗ (α_ P.X S.X S.X).hom) ≫
                (α_ R.X P.X (S.X ⊗ S.X)).inv ≫ (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 S.X) ≫ (α_ P.X S.X S.X).inv)
              ((α_ R.X P.X S.X).inv ≫ (P.actLeft ⊗ 𝟙 S.X))
              (_ :
                (tensorLeft R.X).map (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫
                    (α_ R.X P.X (mk S.X S.mul S.mul).X).inv ≫ (P.actLeft ⊗ 𝟙 (mk S.X S.mul S.mul).X) =
                  ((𝟙 R.X ⊗ (α_ P.X S.X (mk S.X S.mul S.mul).X).hom) ≫
                      (α_ R.X P.X (S.X ⊗ (mk S.X S.mul S.mul).X)).inv ≫
                        (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                    (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X))
              (_ :
                (tensorLeft R.X).map
                      ((α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)) ≫
                    (α_ R.X P.X (mk S.X S.mul S.mul).X).inv ≫ (P.actLeft ⊗ 𝟙 (mk S.X S.mul S.mul).X) =
                  ((𝟙 R.X ⊗ (α_ P.X S.X (mk S.X S.mul S.mul).X).hom) ≫
                      (α_ R.X P.X (S.X ⊗ (mk S.X S.mul S.mul).X)).inv ≫
                        (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                    (α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)))) ≫
        coequalizer.desc P.actRight
          (_ :
            (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
              ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight) =
    (𝟙 R.X ⊗ coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))) ≫
      (𝟙 R.X ⊗
          coequalizer.desc P.actRight
            (_ :
              (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
                ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight)) ≫
        P.actLeft

Next tactic:
slice_lhs 1 4 => rw [id_tensor_π_preserves_coequalizer_inv_colimMap_desc]
theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft := by
  dsimp; dsimp [hom, TensorBimod.actLeft, regular]
  refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
  dsimp
  slice_lhs 1 4 => 

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
| (𝟙 R.X ⊗ coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))) ≫
    (PreservesCoequalizer.iso (tensorLeft R.X) (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))).inv ≫
      colimMap
          (parallelPairHom (𝟙 R.X ⊗ P.actRight ⊗ 𝟙 S.X) (𝟙 R.X ⊗ (α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
            (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
            ((𝟙 R.X ⊗ (α_ P.X S.X S.X).hom) ≫
              (α_ R.X P.X (S.X ⊗ S.X)).inv ≫ (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 S.X) ≫ (α_ P.X S.X S.X).inv)
            ((α_ R.X P.X S.X).inv ≫ (P.actLeft ⊗ 𝟙 S.X))
            (_ :
              (tensorLeft R.X).map (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫
                  (α_ R.X P.X (mk S.X S.mul S.mul).X).inv ≫ (P.actLeft ⊗ 𝟙 (mk S.X S.mul S.mul).X) =
                ((𝟙 R.X ⊗ (α_ P.X S.X (mk S.X S.mul S.mul).X).hom) ≫
                    (α_ R.X P.X (S.X ⊗ (mk S.X S.mul S.mul).X)).inv ≫
                      (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                  (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X))
            (_ :
              (tensorLeft R.X).map ((α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)) ≫
                  (α_ R.X P.X (mk S.X S.mul S.mul).X).inv ≫ (P.actLeft ⊗ 𝟙 (mk S.X S.mul S.mul).X) =
                ((𝟙 R.X ⊗ (α_ P.X S.X (mk S.X S.mul S.mul).X).hom) ≫
                    (α_ R.X P.X (S.X ⊗ (mk S.X S.mul S.mul).X)).inv ≫
                      (P.actLeft ⊗ 𝟙 S.X ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                  (α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft))) ≫
        coequalizer.desc P.actRight
          (_ :
            (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
              ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight)

Next tactic:
rw [id_tensor_π_preserves_coequalizer_inv_colimMap_desc]
theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft := by
  dsimp; dsimp [hom, TensorBimod.actLeft, regular]
  refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
  dsimp
  slice_lhs 1 4 => rw [id_tensor_π_preserves_coequalizer_inv_colimMap_desc]
  

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

Next tactic:
slice_lhs 2 3 => rw [middle_assoc]
theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft := by
  dsimp; dsimp [hom, TensorBimod.actLeft, regular]
  refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
  dsimp
  slice_lhs 1 4 => rw [id_tensor_π_preserves_coequalizer_inv_colimMap_desc]
  slice_lhs 2 3 => 

Proof state:
case a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
| (P.actLeft ⊗ 𝟙 S.X) ≫ P.actRight
case a
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
| (α_ R.X P.X S.X).inv

Next tactic:
rw [middle_assoc]
theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft := by
  dsimp; dsimp [hom, TensorBimod.actLeft, regular]
  refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
  dsimp
  slice_lhs 1 4 => rw [id_tensor_π_preserves_coequalizer_inv_colimMap_desc]
  slice_lhs 2 3 => rw [middle_assoc]
  

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

Next tactic:
slice_rhs 1 2 => rw [← id_tensor_comp, coequalizer.π_desc]
theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft := by
  dsimp; dsimp [hom, TensorBimod.actLeft, regular]
  refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
  dsimp
  slice_lhs 1 4 => rw [id_tensor_π_preserves_coequalizer_inv_colimMap_desc]
  slice_lhs 2 3 => rw [middle_assoc]
  slice_rhs 1 2 => 

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

Next tactic:
rw [← id_tensor_comp, coequalizer.π_desc]
theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft := by
  dsimp; dsimp [hom, TensorBimod.actLeft, regular]
  refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
  dsimp
  slice_lhs 1 4 => rw [id_tensor_π_preserves_coequalizer_inv_colimMap_desc]
  slice_lhs 2 3 => rw [middle_assoc]
  slice_rhs 1 2 => rw [← id_tensor_comp, coequalizer.π_desc]
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
⊢ (α_ R.X P.X S.X).inv ≫ (α_ R.X P.X S.X).hom ≫ (𝟙 R.X ⊗ P.actRight) ≫ P.actLeft = (𝟙 R.X ⊗ P.actRight) ≫ P.actLeft

Next tactic:
rw [Iso.inv_hom_id_assoc]
theorem hom_right_act_hom' :
    (P.tensorBimod (regular S)).actRight ≫ hom P = (hom P ⊗ 𝟙 S.X) ≫ P.actRight := by
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
⊢ (tensorBimod P (regular S)).actRight ≫ hom P = (hom P ⊗ 𝟙 S.X) ≫ P.actRight

Next tactic:
dsimp
theorem hom_right_act_hom' :
    (P.tensorBimod (regular S)).actRight ≫ hom P = (hom P ⊗ 𝟙 S.X) ≫ P.actRight := by
  dsimp; 

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
⊢ TensorBimod.actRight P (regular S) ≫ hom P = (hom P ⊗ 𝟙 S.X) ≫ P.actRight

Next tactic:
dsimp [hom, TensorBimod.actRight, regular]
theorem hom_right_act_hom' :
    (P.tensorBimod (regular S)).actRight ≫ hom P = (hom P ⊗ 𝟙 S.X) ≫ P.actRight := by
  dsimp; dsimp [hom, TensorBimod.actRight, regular]
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
⊢ ((PreservesCoequalizer.iso (tensorRight S.X) (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))).inv ≫
        colimMap
          (parallelPairHom ((P.actRight ⊗ 𝟙 S.X) ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul) ⊗ 𝟙 S.X)
            (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
            ((α_ (P.X ⊗ S.X) S.X S.X).hom ≫
              (α_ P.X S.X (S.X ⊗ S.X)).hom ≫ (𝟙 P.X ⊗ 𝟙 S.X ⊗ S.mul) ≫ (α_ P.X S.X S.X).inv)
            ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
            (_ :
              (tensorRight S.X).map (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫
                  (α_ P.X (mk S.X S.mul S.mul).X S.X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actRight) =
                ((α_ (P.X ⊗ S.X) (mk S.X S.mul S.mul).X S.X).hom ≫
                    (α_ P.X S.X ((mk S.X S.mul S.mul).X ⊗ S.X)).hom ≫
                      (𝟙 P.X ⊗ 𝟙 S.X ⊗ (mk S.X S.mul S.mul).actRight) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                  (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X))
            (_ :
              (tensorRight S.X).map ((α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)) ≫
                  (α_ P.X (mk S.X S.mul S.mul).X S.X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actRight) =
                ((α_ (P.X ⊗ S.X) (mk S.X S.mul S.mul).X S.X).hom ≫
                    (α_ P.X S.X ((mk S.X S.mul S.mul).X ⊗ S.X)).hom ≫
                      (𝟙 P.X ⊗ 𝟙 S.X ⊗ (mk S.X S.mul S.mul).actRight) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                  (α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)))) ≫
      coequalizer.desc P.actRight
        (_ :
          (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
            ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight) =
    (coequalizer.desc P.actRight
          (_ :
            (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
              ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight) ⊗
        𝟙 S.X) ≫
      P.actRight

Next tactic:
refine' (cancel_epi ((tensorRight _).map (coequalizer.π _ _))).1 _
theorem hom_right_act_hom' :
    (P.tensorBimod (regular S)).actRight ≫ hom P = (hom P ⊗ 𝟙 S.X) ≫ P.actRight := by
  dsimp; dsimp [hom, TensorBimod.actRight, regular]
  refine' (cancel_epi ((tensorRight _).map (coequalizer.π _ _))).1 _
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
A B : Mon_ C
M : Bimod A B
inst✝² : HasCoequalizers C
R S : Mon_ C
P : Bimod R S
inst✝¹ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorLeft X)
inst✝ : (X : C) → PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁} (tensorRight X)
⊢ (tensorRight S.X).map
        (coequalizer.π (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X)
          ((α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft))) ≫
      ((PreservesCoequalizer.iso (tensorRight S.X) (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))).inv ≫
          colimMap
            (parallelPairHom ((P.actRight ⊗ 𝟙 S.X) ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul) ⊗ 𝟙 S.X)
              (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
              ((α_ (P.X ⊗ S.X) S.X S.X).hom ≫
                (α_ P.X S.X (S.X ⊗ S.X)).hom ≫ (𝟙 P.X ⊗ 𝟙 S.X ⊗ S.mul) ≫ (α_ P.X S.X S.X).inv)
              ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))
              (_ :
                (tensorRight S.X).map (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X) ≫
                    (α_ P.X (mk S.X S.mul S.mul).X S.X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actRight) =
                  ((α_ (P.X ⊗ S.X) (mk S.X S.mul S.mul).X S.X).hom ≫
                      (α_ P.X S.X ((mk S.X S.mul S.mul).X ⊗ S.X)).hom ≫
                        (𝟙 P.X ⊗ 𝟙 S.X ⊗ (mk S.X S.mul S.mul).actRight) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                    (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X))
              (_ :
                (tensorRight S.X).map
                      ((α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)) ≫
                    (α_ P.X (mk S.X S.mul S.mul).X S.X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actRight) =
                  ((α_ (P.X ⊗ S.X) (mk S.X S.mul S.mul).X S.X).hom ≫
                      (α_ P.X S.X ((mk S.X S.mul S.mul).X ⊗ S.X)).hom ≫
                        (𝟙 P.X ⊗ 𝟙 S.X ⊗ (mk S.X S.mul S.mul).actRight) ≫ (α_ P.X S.X (mk S.X S.mul S.mul).X).inv) ≫
                    (α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft)))) ≫
        coequalizer.desc P.actRight
          (_ :
            (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
              ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight) =
    (tensorRight S.X).map
        (coequalizer.π (P.actRight ⊗ 𝟙 (mk S.X S.mul S.mul).X)
          ((α_ P.X S.X (mk S.X S.mul S.mul).X).hom ≫ (𝟙 P.X ⊗ (mk S.X S.mul S.mul).actLeft))) ≫
      (coequalizer.desc P.actRight
            (_ :
              (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
                ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight) ⊗
          𝟙 S.X) ≫
        P.actRight

Next tactic:
dsimp