l3lab/ntp-mathlib huggingface dataset:
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 _
  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)
⊢ (coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ⊗ 𝟙 S.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.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ⊗ 𝟙 S.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) ⊗
          𝟙 S.X) ≫
        P.actRight

Next tactic:
slice_lhs 1 4 => rw [π_tensor_id_preserves_coequalizer_inv_colimMap_desc]
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 _
  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)
| (coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ⊗ 𝟙 S.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)

Next tactic:
rw [π_tensor_id_preserves_coequalizer_inv_colimMap_desc]
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 _
  dsimp
  slice_lhs 1 4 => rw [π_tensor_id_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)
⊢ ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫ P.actRight =
    (coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ⊗ 𝟙 S.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) ⊗
          𝟙 S.X) ≫
        P.actRight

Next tactic:
slice_lhs 2 3 => rw [right_assoc]
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 _
  dsimp
  slice_lhs 1 4 => rw [π_tensor_id_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.X ⊗ S.mul) ≫ 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.X S.X S.X).hom

Next tactic:
rw [right_assoc]
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 _
  dsimp
  slice_lhs 1 4 => rw [π_tensor_id_preserves_coequalizer_inv_colimMap_desc]
  slice_lhs 2 3 => rw [right_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)
⊢ (α_ P.X S.X S.X).hom ≫ (α_ P.X S.X S.X).inv ≫ (P.actRight ⊗ 𝟙 S.X) ≫ P.actRight =
    (coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ⊗ 𝟙 S.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) ⊗
          𝟙 S.X) ≫
        P.actRight

Next tactic:
slice_rhs 1 2 => rw [← comp_tensor_id, coequalizer.π_desc]
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 _
  dsimp
  slice_lhs 1 4 => rw [π_tensor_id_preserves_coequalizer_inv_colimMap_desc]
  slice_lhs 2 3 => rw [right_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)
| (coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ⊗ 𝟙 S.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) ⊗
      𝟙 S.X)
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.actRight

Next tactic:
rw [← comp_tensor_id, coequalizer.π_desc]
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 _
  dsimp
  slice_lhs 1 4 => rw [π_tensor_id_preserves_coequalizer_inv_colimMap_desc]
  slice_lhs 2 3 => rw [right_assoc]
  slice_rhs 1 2 => rw [← comp_tensor_id, 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)
⊢ (α_ P.X S.X S.X).hom ≫ (α_ P.X S.X S.X).inv ≫ (P.actRight ⊗ 𝟙 S.X) ≫ P.actRight = (P.actRight ⊗ 𝟙 S.X) ≫ P.actRight

Next tactic:
rw [Iso.hom_inv_id_assoc]
theorem whisker_left_comp_bimod {X Y Z : Mon_ C} (M : Bimod X Y) {N P Q : Bimod Y Z} (f : N ⟶ P)
    (g : P ⟶ Q) : tensorHom (𝟙 M) (f ≫ g) = tensorHom (𝟙 M) f ≫ tensorHom (𝟙 M) g := 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
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 Z : Mon_ C
M : Bimod X Y
N P Q : Bimod Y Z
f : N ⟶ P
g : P ⟶ Q
⊢ tensorHom (𝟙 M) (f ≫ g) = tensorHom (𝟙 M) f ≫ tensorHom (𝟙 M) g

Next tactic:
rw [← tensor_comp, Category.comp_id]
theorem id_whisker_left_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom (𝟙 (regular X)) f = (leftUnitorBimod M).hom ≫ f ≫ (leftUnitorBimod N).inv := 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
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
⊢ tensorHom (𝟙 (regular X)) f = (leftUnitorBimod M).hom ≫ f ≫ (leftUnitorBimod N).inv

Next tactic:
dsimp [tensorHom, regular, leftUnitorBimod]
theorem id_whisker_left_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom (𝟙 (regular X)) f = (leftUnitorBimod M).hom ≫ f ≫ (leftUnitorBimod N).inv := by
  dsimp [tensorHom, regular, leftUnitorBimod]
  

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
⊢ Hom.mk
      (colimMap
        (parallelPairHom (X.mul ⊗ 𝟙 M.X) ((α_ X.X X.X M.X).hom ≫ (𝟙 X.X ⊗ M.actLeft)) (X.mul ⊗ 𝟙 N.X)
          ((α_ X.X X.X N.X).hom ≫ (𝟙 X.X ⊗ N.actLeft)) ((𝟙 X.X ⊗ 𝟙 X.X) ⊗ f.hom) (𝟙 X.X ⊗ f.hom)
          (_ :
            ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 M.X) ≫ ((𝟙 (mk X.X X.mul X.mul)).hom ⊗ f.hom) =
              (((𝟙 (mk X.X X.mul X.mul)).hom ⊗ 𝟙 X.X) ⊗ f.hom) ≫ ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 N.X))
          (_ :
            ((α_ (mk X.X X.mul X.mul).X X.X M.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ M.actLeft)) ≫
                ((𝟙 (mk X.X X.mul X.mul)).hom ⊗ f.hom) =
              (((𝟙 (mk X.X X.mul X.mul)).hom ⊗ 𝟙 X.X) ⊗ f.hom) ≫
                (α_ (mk X.X X.mul X.mul).X X.X N.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ N.actLeft)))) =
    (isoOfIso (Iso.mk (LeftUnitorBimod.hom M) (LeftUnitorBimod.inv M))
          (_ :
            (tensorBimod (regular X) M).actLeft ≫ LeftUnitorBimod.hom M = (𝟙 X.X ⊗ LeftUnitorBimod.hom M) ≫ M.actLeft)
          (_ :
            (tensorBimod (regular X) M).actRight ≫ LeftUnitorBimod.hom M =
              (LeftUnitorBimod.hom M ⊗ 𝟙 Y.X) ≫ M.actRight)).hom ≫
      f ≫
        (isoOfIso (Iso.mk (LeftUnitorBimod.hom N) (LeftUnitorBimod.inv N))
            (_ :
              (tensorBimod (regular X) N).actLeft ≫ LeftUnitorBimod.hom N = (𝟙 X.X ⊗ LeftUnitorBimod.hom N) ≫ N.actLeft)
            (_ :
              (tensorBimod (regular X) N).actRight ≫ LeftUnitorBimod.hom N =
                (LeftUnitorBimod.hom N ⊗ 𝟙 Y.X) ≫ N.actRight)).inv

Next tactic:
ext
theorem id_whisker_left_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom (𝟙 (regular X)) f = (leftUnitorBimod M).hom ≫ f ≫ (leftUnitorBimod N).inv := by
  dsimp [tensorHom, regular, leftUnitorBimod]
  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 (X.mul ⊗ 𝟙 M.X) ((α_ X.X X.X M.X).hom ≫ (𝟙 X.X ⊗ M.actLeft)) (X.mul ⊗ 𝟙 N.X)
            ((α_ X.X X.X N.X).hom ≫ (𝟙 X.X ⊗ N.actLeft)) ((𝟙 X.X ⊗ 𝟙 X.X) ⊗ f.hom) (𝟙 X.X ⊗ f.hom)
            (_ :
              ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 M.X) ≫ ((𝟙 (mk X.X X.mul X.mul)).hom ⊗ f.hom) =
                (((𝟙 (mk X.X X.mul X.mul)).hom ⊗ 𝟙 X.X) ⊗ f.hom) ≫ ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 N.X))
            (_ :
              ((α_ (mk X.X X.mul X.mul).X X.X M.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ M.actLeft)) ≫
                  ((𝟙 (mk X.X X.mul X.mul)).hom ⊗ f.hom) =
                (((𝟙 (mk X.X X.mul X.mul)).hom ⊗ 𝟙 X.X) ⊗ f.hom) ≫
                  (α_ (mk X.X X.mul X.mul).X X.X N.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ N.actLeft))))).hom =
    ((isoOfIso (Iso.mk (LeftUnitorBimod.hom M) (LeftUnitorBimod.inv M))
            (_ :
              (tensorBimod (regular X) M).actLeft ≫ LeftUnitorBimod.hom M = (𝟙 X.X ⊗ LeftUnitorBimod.hom M) ≫ M.actLeft)
            (_ :
              (tensorBimod (regular X) M).actRight ≫ LeftUnitorBimod.hom M =
                (LeftUnitorBimod.hom M ⊗ 𝟙 Y.X) ≫ M.actRight)).hom ≫
        f ≫
          (isoOfIso (Iso.mk (LeftUnitorBimod.hom N) (LeftUnitorBimod.inv N))
              (_ :
                (tensorBimod (regular X) N).actLeft ≫ LeftUnitorBimod.hom N =
                  (𝟙 X.X ⊗ LeftUnitorBimod.hom N) ≫ N.actLeft)
              (_ :
                (tensorBimod (regular X) N).actRight ≫ LeftUnitorBimod.hom N =
                  (LeftUnitorBimod.hom N ⊗ 𝟙 Y.X) ≫ N.actRight)).inv).hom

Next tactic:
apply coequalizer.hom_ext
theorem id_whisker_left_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom (𝟙 (regular X)) f = (leftUnitorBimod M).hom ≫ f ≫ (leftUnitorBimod N).inv := by
  dsimp [tensorHom, regular, leftUnitorBimod]
  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.π ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 M.X)
        ((α_ (mk X.X X.mul X.mul).X X.X M.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ M.actLeft)) ≫
      (Hom.mk
          (colimMap
            (parallelPairHom (X.mul ⊗ 𝟙 M.X) ((α_ X.X X.X M.X).hom ≫ (𝟙 X.X ⊗ M.actLeft)) (X.mul ⊗ 𝟙 N.X)
              ((α_ X.X X.X N.X).hom ≫ (𝟙 X.X ⊗ N.actLeft)) ((𝟙 X.X ⊗ 𝟙 X.X) ⊗ f.hom) (𝟙 X.X ⊗ f.hom)
              (_ :
                ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 M.X) ≫ ((𝟙 (mk X.X X.mul X.mul)).hom ⊗ f.hom) =
                  (((𝟙 (mk X.X X.mul X.mul)).hom ⊗ 𝟙 X.X) ⊗ f.hom) ≫ ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 N.X))
              (_ :
                ((α_ (mk X.X X.mul X.mul).X X.X M.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ M.actLeft)) ≫
                    ((𝟙 (mk X.X X.mul X.mul)).hom ⊗ f.hom) =
                  (((𝟙 (mk X.X X.mul X.mul)).hom ⊗ 𝟙 X.X) ⊗ f.hom) ≫
                    (α_ (mk X.X X.mul X.mul).X X.X N.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ N.actLeft))))).hom =
    coequalizer.π ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 M.X)
        ((α_ (mk X.X X.mul X.mul).X X.X M.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ M.actLeft)) ≫
      ((isoOfIso (Iso.mk (LeftUnitorBimod.hom M) (LeftUnitorBimod.inv M))
              (_ :
                (tensorBimod (regular X) M).actLeft ≫ LeftUnitorBimod.hom M =
                  (𝟙 X.X ⊗ LeftUnitorBimod.hom M) ≫ M.actLeft)
              (_ :
                (tensorBimod (regular X) M).actRight ≫ LeftUnitorBimod.hom M =
                  (LeftUnitorBimod.hom M ⊗ 𝟙 Y.X) ≫ M.actRight)).hom ≫
          f ≫
            (isoOfIso (Iso.mk (LeftUnitorBimod.hom N) (LeftUnitorBimod.inv N))
                (_ :
                  (tensorBimod (regular X) N).actLeft ≫ LeftUnitorBimod.hom N =
                    (𝟙 X.X ⊗ LeftUnitorBimod.hom N) ≫ N.actLeft)
                (_ :
                  (tensorBimod (regular X) N).actRight ≫ LeftUnitorBimod.hom N =
                    (LeftUnitorBimod.hom N ⊗ 𝟙 Y.X) ≫ N.actRight)).inv).hom

Next tactic:
dsimp
theorem id_whisker_left_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom (𝟙 (regular X)) f = (leftUnitorBimod M).hom ≫ f ≫ (leftUnitorBimod N).inv := by
  dsimp [tensorHom, regular, leftUnitorBimod]
  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.π (X.mul ⊗ 𝟙 M.X) ((α_ X.X X.X M.X).hom ≫ (𝟙 X.X ⊗ M.actLeft)) ≫
      colimMap
        (parallelPairHom (X.mul ⊗ 𝟙 M.X) ((α_ X.X X.X M.X).hom ≫ (𝟙 X.X ⊗ M.actLeft)) (X.mul ⊗ 𝟙 N.X)
          ((α_ X.X X.X N.X).hom ≫ (𝟙 X.X ⊗ N.actLeft)) ((𝟙 X.X ⊗ 𝟙 X.X) ⊗ f.hom) (𝟙 X.X ⊗ f.hom)
          (_ :
            ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 M.X) ≫ ((𝟙 (mk X.X X.mul X.mul)).hom ⊗ f.hom) =
              (((𝟙 (mk X.X X.mul X.mul)).hom ⊗ 𝟙 X.X) ⊗ f.hom) ≫ ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 N.X))
          (_ :
            ((α_ (mk X.X X.mul X.mul).X X.X M.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ M.actLeft)) ≫
                ((𝟙 (mk X.X X.mul X.mul)).hom ⊗ f.hom) =
              (((𝟙 (mk X.X X.mul X.mul)).hom ⊗ 𝟙 X.X) ⊗ f.hom) ≫
                (α_ (mk X.X X.mul X.mul).X X.X N.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ N.actLeft))) =
    coequalizer.π (X.mul ⊗ 𝟙 M.X) ((α_ X.X X.X M.X).hom ≫ (𝟙 X.X ⊗ M.actLeft)) ≫
      LeftUnitorBimod.hom M ≫ f.hom ≫ LeftUnitorBimod.inv N

Next tactic:
slice_lhs 1 2 => rw [ι_colimMap, parallelPairHom_app_one]
theorem id_whisker_left_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom (𝟙 (regular X)) f = (leftUnitorBimod M).hom ≫ f ≫ (leftUnitorBimod N).inv := by
  dsimp [tensorHom, regular, leftUnitorBimod]
  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.π (X.mul ⊗ 𝟙 M.X) ((α_ X.X X.X M.X).hom ≫ (𝟙 X.X ⊗ M.actLeft)) ≫
    colimMap
      (parallelPairHom (X.mul ⊗ 𝟙 M.X) ((α_ X.X X.X M.X).hom ≫ (𝟙 X.X ⊗ M.actLeft)) (X.mul ⊗ 𝟙 N.X)
        ((α_ X.X X.X N.X).hom ≫ (𝟙 X.X ⊗ N.actLeft)) ((𝟙 X.X ⊗ 𝟙 X.X) ⊗ f.hom) (𝟙 X.X ⊗ f.hom)
        (_ :
          ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 M.X) ≫ ((𝟙 (mk X.X X.mul X.mul)).hom ⊗ f.hom) =
            (((𝟙 (mk X.X X.mul X.mul)).hom ⊗ 𝟙 X.X) ⊗ f.hom) ≫ ((mk X.X X.mul X.mul).actRight ⊗ 𝟙 N.X))
        (_ :
          ((α_ (mk X.X X.mul X.mul).X X.X M.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ M.actLeft)) ≫
              ((𝟙 (mk X.X X.mul X.mul)).hom ⊗ f.hom) =
            (((𝟙 (mk X.X X.mul X.mul)).hom ⊗ 𝟙 X.X) ⊗ f.hom) ≫
              (α_ (mk X.X X.mul X.mul).X X.X N.X).hom ≫ (𝟙 (mk X.X X.mul X.mul).X ⊗ N.actLeft)))

Next tactic:
rw [ι_colimMap, parallelPairHom_app_one]
theorem id_whisker_left_bimod {X Y : Mon_ C} {M N : Bimod X Y} (f : M ⟶ N) :
    tensorHom (𝟙 (regular X)) f = (leftUnitorBimod M).hom ≫ f ≫ (leftUnitorBimod N).inv := by
  dsimp [tensorHom, regular, leftUnitorBimod]
  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
⊢ (𝟙 X.X ⊗ f.hom) ≫
      colimit.ι (parallelPair (X.mul ⊗ 𝟙 N.X) ((α_ X.X X.X N.X).hom ≫ (𝟙 X.X ⊗ N.actLeft))) WalkingParallelPair.one =
    coequalizer.π (X.mul ⊗ 𝟙 M.X) ((α_ X.X X.X M.X).hom ≫ (𝟙 X.X ⊗ M.actLeft)) ≫
      LeftUnitorBimod.hom M ≫ f.hom ≫ LeftUnitorBimod.inv N

Next tactic:
dsimp [LeftUnitorBimod.hom]