-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
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

Proof state:
case h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
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.X, actLeft := X.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := X.mul, actRight_one := ⋯,
            right_assoc := ⋯, middle_assoc := ⋯ }.whiskerLeft
        f).hom =
    ((isoOfIso { hom := LeftUnitorBimod.hom M, inv := LeftUnitorBimod.inv M, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯
            ⋯).hom ≫
        f ≫
          (isoOfIso { hom := LeftUnitorBimod.hom N, inv := LeftUnitorBimod.inv N, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯
              ⋯).inv).hom

Tactic:
apply coequalizer.hom_ext

Result:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
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 := X.X, actLeft := X.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := X.mul, actRight_one := ⋯,
              right_assoc := ⋯, middle_assoc := ⋯ }.actRight ▷
          M.X)
        ((α_
              { X := X.X, actLeft := X.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := X.mul, actRight_one := ⋯,
                  right_assoc := ⋯, middle_assoc := ⋯ }.X
              X.X M.X).hom ≫
          { X := X.X, actLeft := X.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := X.mul, actRight_one := ⋯,
                right_assoc := ⋯, middle_assoc := ⋯ }.X ◁
            M.actLeft) ≫
      ({ X := X.X, actLeft := X.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := X.mul, actRight_one := ⋯,
              right_assoc := ⋯, middle_assoc := ⋯ }.whiskerLeft
          f).hom =
    coequalizer.π
        ({ X := X.X, actLeft := X.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := X.mul, actRight_one := ⋯,
              right_assoc := ⋯, middle_assoc := ⋯ }.actRight ▷
          M.X)
        ((α_
              { X := X.X, actLeft := X.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := X.mul, actRight_one := ⋯,
                  right_assoc := ⋯, middle_assoc := ⋯ }.X
              X.X M.X).hom ≫
          { X := X.X, actLeft := X.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := X.mul, actRight_one := ⋯,
                right_assoc := ⋯, middle_assoc := ⋯ }.X ◁
            M.actLeft) ≫
      ((isoOfIso { hom := LeftUnitorBimod.hom M, inv := LeftUnitorBimod.inv M, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯
              ⋯).hom ≫
          f ≫
            (isoOfIso { hom := LeftUnitorBimod.hom N, inv := LeftUnitorBimod.inv N, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯
                ⋯).inv).hom

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
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.X, actLeft := X.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := X.mul, actRight_one := ⋯,
          right_assoc := ⋯, middle_assoc := ⋯ }.whiskerLeft
      f =
    (isoOfIso { hom := LeftUnitorBimod.hom M, inv := LeftUnitorBimod.inv M, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯
          ⋯).hom ≫
      f ≫
        (isoOfIso { hom := LeftUnitorBimod.hom N, inv := LeftUnitorBimod.inv N, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯
            ⋯).inv

Tactic:
ext

Result:
case h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
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.X, actLeft := X.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := X.mul, actRight_one := ⋯,
            right_assoc := ⋯, middle_assoc := ⋯ }.whiskerLeft
        f).hom =
    ((isoOfIso { hom := LeftUnitorBimod.hom M, inv := LeftUnitorBimod.inv M, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯
            ⋯).hom ≫
        f ≫
          (isoOfIso { hom := LeftUnitorBimod.hom N, inv := LeftUnitorBimod.inv N, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯
              ⋯).inv).hom

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
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

Tactic:
dsimp [LeftUnitorBimod.hom]

Result:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
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) ≫
      coequalizer.desc M.actLeft ⋯ ≫ f.hom ≫ LeftUnitorBimod.inv N

Proof state:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
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 =
    (M.actLeft ≫ f.hom) ≫
      (λ_ N.X).inv ≫ X.one ▷ N.X ≫ coequalizer.π (X.mul ▷ N.X) ((α_ X.X X.X N.X).hom ≫ X.X ◁ N.actLeft)

Tactic:
slice_rhs 1 2 => rw [Hom.left_act_hom]

Result:
case h.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
inst✝³ : MonoidalCategory C
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 =
    (((X.X ◁ f.hom ≫ N.actLeft) ≫ (λ_ N.X).inv) ≫ X.one ▷ N.X) ≫
      coequalizer.π (X.mul ▷ N.X) ((α_ X.X X.X N.X).hom ≫ X.X ◁ N.actLeft)