l3lab/ntp-mathlib huggingface dataset:
theorem hom_right_act_hom' :
    ((regular R).tensorBimod P).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_rhs 1 2 => rw [← comp_tensor_id, coequalizer.π_desc]
  slice_rhs 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
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

Next tactic:
rw [middle_assoc]
theorem hom_right_act_hom' :
    ((regular R).tensorBimod P).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_rhs 1 2 => rw [← comp_tensor_id, coequalizer.π_desc]
  slice_rhs 1 2 => 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).hom ≫ (𝟙 R.X ⊗ P.actRight)) ≫ P.actLeft = (α_ R.X P.X S.X).hom ≫ (𝟙 R.X ⊗ P.actRight) ≫ P.actLeft

Next tactic:
simp only [Category.assoc]
/-- The underlying morphism of the forward component of the right unitor isomorphism. -/
noncomputable def hom : TensorBimod.X P (regular S) ⟶ P.X :=
  coequalizer.desc 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
⊢ (P.actRight ⊗ 𝟙 (regular S).X) ≫ P.actRight =
    ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫ P.actRight

Next tactic:
dsimp
/-- The underlying morphism of the forward component of the right unitor isomorphism. -/
noncomputable def hom : TensorBimod.X P (regular S) ⟶ P.X :=
  coequalizer.desc 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
⊢ (P.actRight ⊗ 𝟙 S.X) ≫ P.actRight = ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫ P.actRight

Next tactic:
rw [Category.assoc, right_assoc, Iso.hom_inv_id_assoc]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := 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
⊢ hom P ≫ inv P = 𝟙 (TensorBimod.X P (regular S))

Next tactic:
dsimp only [hom, inv, TensorBimod.X]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  

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
⊢ 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.X).inv ≫
        (𝟙 P.X ⊗ S.one) ≫
          coequalizer.π (P.actRight ⊗ 𝟙 (regular S).X)
            ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) =
    𝟙 (coequalizer (P.actRight ⊗ 𝟙 (regular S).X) ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)))

Next tactic:
ext
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  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
R S : Mon_ C
P : Bimod R S
⊢ coequalizer.π (P.actRight ⊗ 𝟙 (regular S).X) ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).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) ≫
        (ρ_ P.X).inv ≫
          (𝟙 P.X ⊗ S.one) ≫
            coequalizer.π (P.actRight ⊗ 𝟙 (regular S).X)
              ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) =
    coequalizer.π (P.actRight ⊗ 𝟙 (regular S).X) ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)) ≫
      𝟙 (coequalizer (P.actRight ⊗ 𝟙 (regular S).X) ((α_ P.X S.X (regular S).X).hom ≫ (𝟙 P.X ⊗ (regular S).actLeft)))

Next tactic:
dsimp
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  

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
R S : Mon_ C
P : Bimod R S
⊢ coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
      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.X).inv ≫ (𝟙 P.X ⊗ S.one) ≫ coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) =
    coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
      𝟙 (coequalizer (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)))

Next tactic:
slice_lhs 1 2 => rw [coequalizer.π_desc]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 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
R S : Mon_ C
P : Bimod R S
| coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
    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.a.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
| (ρ_ P.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
R S : Mon_ C
P : Bimod R S
| 𝟙 P.X ⊗ S.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
R S : Mon_ C
P : Bimod R S
| coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))

Next tactic:
rw [coequalizer.π_desc]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  

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
R S : Mon_ C
P : Bimod R S
⊢ ((P.actRight ≫ (ρ_ P.X).inv) ≫ (𝟙 P.X ⊗ S.one)) ≫
      coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) =
    coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
      𝟙 (coequalizer (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)))

Next tactic:
slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 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
R S : Mon_ C
P : Bimod R S
| P.actRight ≫ (ρ_ P.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
R S : Mon_ C
P : Bimod R S
| 𝟙 P.X ⊗ S.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
R S : Mon_ C
P : Bimod R S
| coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))

Next tactic:
rw [rightUnitor_inv_naturality]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  

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
R S : Mon_ C
P : Bimod R S
⊢ (((ρ_ (P.X ⊗ S.X)).inv ≫ (P.actRight ⊗ 𝟙 (𝟙_ C))) ≫ (𝟙 P.X ⊗ S.one)) ≫
      coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) =
    coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
      𝟙 (coequalizer (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)))

Next tactic:
slice_lhs 2 3 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  slice_lhs 2 3 => 

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
R S : Mon_ C
P : Bimod R S
| (P.actRight ⊗ 𝟙 (𝟙_ C)) ≫ (𝟙 P.X ⊗ S.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
R S : Mon_ C
P : Bimod R S
| coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.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
R S : Mon_ C
P : Bimod R S
| (ρ_ (P.X ⊗ S.X)).inv

Next tactic:
rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  slice_lhs 2 3 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  

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
R S : Mon_ C
P : Bimod R S
⊢ (ρ_ (P.X ⊗ S.X)).inv ≫
      ((𝟙 (P.X ⊗ S.X) ⊗ S.one) ≫ (P.actRight ⊗ 𝟙 S.X)) ≫
        coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) =
    coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
      𝟙 (coequalizer (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)))

Next tactic:
slice_lhs 3 4 => rw [coequalizer.condition]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  slice_lhs 2 3 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  slice_lhs 3 4 => 

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
R S : Mon_ C
P : Bimod R S
| (P.actRight ⊗ 𝟙 S.X) ≫ coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.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
R S : Mon_ C
P : Bimod R S
| (ρ_ (P.X ⊗ S.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
R S : Mon_ C
P : Bimod R S
| 𝟙 (P.X ⊗ S.X) ⊗ S.one

Next tactic:
rw [coequalizer.condition]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  slice_lhs 2 3 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  slice_lhs 3 4 => rw [coequalizer.condition]
  

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
R S : Mon_ C
P : Bimod R S
⊢ (ρ_ (P.X ⊗ S.X)).inv ≫
      (𝟙 (P.X ⊗ S.X) ⊗ S.one) ≫
        ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
          coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) =
    coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
      𝟙 (coequalizer (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)))

Next tactic:
slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_naturality]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  slice_lhs 2 3 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  slice_lhs 3 4 => rw [coequalizer.condition]
  slice_lhs 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
R S : Mon_ C
P : Bimod R S
| (𝟙 (P.X ⊗ S.X) ⊗ S.one) ≫ (α_ P.X S.X S.X).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
R S : Mon_ C
P : Bimod R S
| 𝟙 P.X ⊗ S.mul
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
R S : Mon_ C
P : Bimod R S
| coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.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
R S : Mon_ C
P : Bimod R S
| (ρ_ (P.X ⊗ S.X)).inv

Next tactic:
rw [← MonoidalCategory.tensor_id, associator_naturality]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  slice_lhs 2 3 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  slice_lhs 3 4 => rw [coequalizer.condition]
  slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_naturality]
  

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
R S : Mon_ C
P : Bimod R S
⊢ (ρ_ (P.X ⊗ S.X)).inv ≫
      (((α_ P.X S.X (𝟙_ C)).hom ≫ (𝟙 P.X ⊗ 𝟙 S.X ⊗ S.one)) ≫ (𝟙 P.X ⊗ S.mul)) ≫
        coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) =
    coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
      𝟙 (coequalizer (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)))

Next tactic:
slice_lhs 3 4 => rw [← id_tensor_comp, Mon_.mul_one]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  slice_lhs 2 3 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  slice_lhs 3 4 => rw [coequalizer.condition]
  slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_naturality]
  slice_lhs 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
R S : Mon_ C
P : Bimod R S
| (𝟙 P.X ⊗ 𝟙 S.X ⊗ S.one) ≫ (𝟙 P.X ⊗ S.mul)
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
R S : Mon_ C
P : Bimod R S
| coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.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
R S : Mon_ C
P : Bimod R S
| (ρ_ (P.X ⊗ S.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
R S : Mon_ C
P : Bimod R S
| (α_ P.X S.X (𝟙_ C)).hom

Next tactic:
rw [← id_tensor_comp, Mon_.mul_one]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  slice_lhs 2 3 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  slice_lhs 3 4 => rw [coequalizer.condition]
  slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_naturality]
  slice_lhs 3 4 => rw [← id_tensor_comp, Mon_.mul_one]
  

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
R S : Mon_ C
P : Bimod R S
⊢ (ρ_ (P.X ⊗ S.X)).inv ≫
      (α_ P.X S.X (𝟙_ C)).hom ≫
        (𝟙 P.X ⊗ (ρ_ S.X).hom) ≫ coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) =
    coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
      𝟙 (coequalizer (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)))

Next tactic:
slice_rhs 1 2 => rw [Category.comp_id]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  slice_lhs 2 3 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  slice_lhs 3 4 => rw [coequalizer.condition]
  slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_naturality]
  slice_lhs 3 4 => rw [← id_tensor_comp, Mon_.mul_one]
  slice_rhs 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
R S : Mon_ C
P : Bimod R S
| coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
    𝟙 (coequalizer (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)))

Next tactic:
rw [Category.comp_id]
theorem hom_inv_id : hom P ≫ inv P = 𝟙 _ := by
  dsimp only [hom, inv, TensorBimod.X]
  ext; dsimp
  slice_lhs 1 2 => rw [coequalizer.π_desc]
  slice_lhs 1 2 => rw [rightUnitor_inv_naturality]
  slice_lhs 2 3 => rw [tensor_id_comp_id_tensor, ← id_tensor_comp_tensor_id]
  slice_lhs 3 4 => rw [coequalizer.condition]
  slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_naturality]
  slice_lhs 3 4 => rw [← id_tensor_comp, Mon_.mul_one]
  slice_rhs 1 2 => rw [Category.comp_id]
  

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
R S : Mon_ C
P : Bimod R S
⊢ (ρ_ (P.X ⊗ S.X)).inv ≫
      (α_ P.X S.X (𝟙_ C)).hom ≫
        (𝟙 P.X ⊗ (ρ_ S.X).hom) ≫ coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) =
    coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))

Next tactic:
coherence
theorem inv_hom_id : inv P ≫ hom P = 𝟙 _ := by
  dsimp [hom, inv]
  

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
⊢ ((ρ_ P.X).inv ≫ (𝟙 P.X ⊗ S.one) ≫ coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul))) ≫
      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.X

Next tactic:
slice_lhs 3 4 => rw [coequalizer.π_desc]
theorem inv_hom_id : inv P ≫ hom P = 𝟙 _ := by
  dsimp [hom, inv]
  slice_lhs 3 4 => 

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
R S : Mon_ C
P : Bimod R S
| coequalizer.π (P.actRight ⊗ 𝟙 S.X) ((α_ P.X S.X S.X).hom ≫ (𝟙 P.X ⊗ S.mul)) ≫
    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
| (ρ_ P.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
R S : Mon_ C
P : Bimod R S
| 𝟙 P.X ⊗ S.one

Next tactic:
rw [coequalizer.π_desc]
theorem inv_hom_id : inv P ≫ hom P = 𝟙 _ := by
  dsimp [hom, inv]
  slice_lhs 3 4 => rw [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
⊢ (ρ_ P.X).inv ≫ (𝟙 P.X ⊗ S.one) ≫ P.actRight = 𝟙 P.X

Next tactic:
rw [actRight_one, Iso.inv_hom_id]
theorem hom_left_act_hom' :
    (P.tensorBimod (regular S)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft := 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)).actLeft ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ 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; 

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.actLeft P (regular S) ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft

Next tactic:
dsimp [hom, TensorBimod.actLeft, regular]