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

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
⊢ 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)

Tactic:
slice_rhs 3 4 => rw [← whisker_exchange]

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
⊢ 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)

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
⊢ coequalizer.π
        (M.actRight ▷
          { X := Y.X, actLeft := Y.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := Y.mul, actRight_one := ⋯,
              right_assoc := ⋯, middle_assoc := ⋯ }.X)
        ((α_ M.X Y.X
              { X := Y.X, actLeft := Y.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := Y.mul, actRight_one := ⋯,
                  right_assoc := ⋯, middle_assoc := ⋯ }.X).hom ≫
          M.X ◁
            { X := Y.X, actLeft := Y.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := Y.mul, actRight_one := ⋯,
                right_assoc := ⋯, middle_assoc := ⋯ }.actLeft) ≫
      (whiskerRight f
          { X := Y.X, actLeft := Y.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := Y.mul, actRight_one := ⋯,
            right_assoc := ⋯, middle_assoc := ⋯ }).hom =
    coequalizer.π
        (M.actRight ▷
          { X := Y.X, actLeft := Y.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := Y.mul, actRight_one := ⋯,
              right_assoc := ⋯, middle_assoc := ⋯ }.X)
        ((α_ M.X Y.X
              { X := Y.X, actLeft := Y.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := Y.mul, actRight_one := ⋯,
                  right_assoc := ⋯, middle_assoc := ⋯ }.X).hom ≫
          M.X ◁
            { X := Y.X, actLeft := Y.mul, one_actLeft := ⋯, left_assoc := ⋯, actRight := Y.mul, actRight_one := ⋯,
                right_assoc := ⋯, middle_assoc := ⋯ }.actLeft) ≫
      ((isoOfIso { hom := RightUnitorBimod.hom M, inv := RightUnitorBimod.inv M, hom_inv_id := ⋯, inv_hom_id := ⋯ } ⋯
              ⋯).hom ≫
          f ≫
            (isoOfIso { hom := RightUnitorBimod.hom N, inv := RightUnitorBimod.inv N, hom_inv_id := ⋯, inv_hom_id := ⋯ }
                ⋯ ⋯).inv).hom

Tactic:
dsimp

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.π (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) ⋯ ⋯) =
    coequalizer.π (M.actRight ▷ Y.X) ((α_ M.X Y.X Y.X).hom ≫ M.X ◁ Y.mul) ≫
      RightUnitorBimod.hom M ≫ f.hom ≫ RightUnitorBimod.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
⊢ 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

Tactic:
dsimp [RightUnitorBimod.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
⊢ 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 ⋯ ≫ f.hom ≫ RightUnitorBimod.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
⊢ 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)

Tactic:
slice_rhs 1 2 => rw [Hom.right_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
⊢ 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)

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
⊢ 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

Tactic:
dsimp [RightUnitorBimod.inv]

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
⊢ 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)