l3lab/ntp-mathlib huggingface dataset:
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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  

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

Next tactic:
slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 3 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
| 𝟙 R.X ⊗ P.actLeft
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.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))
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
| (λ_ (R.X ⊗ 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
| R.one ⊗ 𝟙 (R.X ⊗ P.X)

Next tactic:
rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
  

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

Next tactic:
slice_lhs 4 6 => rw [← Category.assoc, ← 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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
  slice_lhs 4 6 => 

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
| (α_ R.X R.X P.X).hom ≫
    (𝟙 R.X ⊗ P.actLeft) ≫ coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))
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
| (λ_ (R.X ⊗ 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
| R.one ⊗ 𝟙 (R.X ⊗ P.X)
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
| (α_ R.X R.X P.X).inv

Next tactic:
rw [← Category.assoc, ← 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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
  slice_lhs 4 6 => rw [← Category.assoc, ← 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
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (R.one ⊗ 𝟙 (R.X ⊗ P.X)) ≫
        (α_ R.X R.X P.X).inv ≫
          (R.mul ⊗ 𝟙 P.X) ≫ coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)) =
    coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)) ≫
      𝟙 (coequalizer (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)))

Next tactic:
slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
  slice_lhs 4 6 => rw [← Category.assoc, ← 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
| (R.one ⊗ 𝟙 (R.X ⊗ P.X)) ≫ (α_ R.X R.X P.X).inv
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
| R.mul ⊗ 𝟙 P.X
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.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))
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
| (λ_ (R.X ⊗ P.X)).inv

Next tactic:
rw [← MonoidalCategory.tensor_id, associator_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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
  slice_lhs 4 6 => rw [← Category.assoc, ← coequalizer.condition]
  slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_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
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (((α_ (𝟙_ C) R.X P.X).inv ≫ ((R.one ⊗ 𝟙 R.X) ⊗ 𝟙 P.X)) ≫ (R.mul ⊗ 𝟙 P.X)) ≫
        coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)) =
    coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)) ≫
      𝟙 (coequalizer (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)))

Next tactic:
slice_lhs 3 4 => rw [← comp_tensor_id, Mon_.one_mul]
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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
  slice_lhs 4 6 => rw [← Category.assoc, ← coequalizer.condition]
  slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_inv_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
| ((R.one ⊗ 𝟙 R.X) ⊗ 𝟙 P.X) ≫ (R.mul ⊗ 𝟙 P.X)
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.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))
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
| (λ_ (R.X ⊗ 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
| (α_ (𝟙_ C) R.X P.X).inv

Next tactic:
rw [← comp_tensor_id, Mon_.one_mul]
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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
  slice_lhs 4 6 => rw [← Category.assoc, ← coequalizer.condition]
  slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_inv_naturality]
  slice_lhs 3 4 => rw [← comp_tensor_id, Mon_.one_mul]
  

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
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (α_ (𝟙_ C) R.X P.X).inv ≫
        ((λ_ R.X).hom ⊗ 𝟙 P.X) ≫ coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)) =
    coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)) ≫
      𝟙 (coequalizer (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)))

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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
  slice_lhs 4 6 => rw [← Category.assoc, ← coequalizer.condition]
  slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_inv_naturality]
  slice_lhs 3 4 => rw [← comp_tensor_id, Mon_.one_mul]
  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.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)) ≫
    𝟙 (coequalizer (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)))

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 [leftUnitor_inv_naturality]
  slice_lhs 2 3 => rw [id_tensor_comp_tensor_id, ← tensor_id_comp_id_tensor]
  slice_lhs 3 3 => rw [← Iso.inv_hom_id_assoc (α_ R.X R.X P.X) (𝟙 R.X ⊗ P.actLeft)]
  slice_lhs 4 6 => rw [← Category.assoc, ← coequalizer.condition]
  slice_lhs 2 3 => rw [← MonoidalCategory.tensor_id, associator_inv_naturality]
  slice_lhs 3 4 => rw [← comp_tensor_id, Mon_.one_mul]
  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
⊢ (λ_ (R.X ⊗ P.X)).inv ≫
      (α_ (𝟙_ C) R.X P.X).inv ≫
        ((λ_ R.X).hom ⊗ 𝟙 P.X) ≫ coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)) =
    coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))

Next tactic:
coherence
theorem inv_hom_id : inv P ≫ hom 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
⊢ inv P ≫ hom P = 𝟙 P.X

Next tactic:
dsimp [hom, inv]
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 ≫ (R.one ⊗ 𝟙 P.X) ≫ coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))) ≫
      coequalizer.desc P.actLeft
        (_ :
          ((regular R).actRight ⊗ 𝟙 P.X) ≫ P.actLeft =
            ((α_ (regular R).X R.X P.X).hom ≫ (𝟙 (regular R).X ⊗ P.actLeft)) ≫ P.actLeft) =
    𝟙 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.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)) ≫
    coequalizer.desc P.actLeft
      (_ :
        ((regular R).actRight ⊗ 𝟙 P.X) ≫ P.actLeft =
          ((α_ (regular R).X R.X P.X).hom ≫ (𝟙 (regular R).X ⊗ P.actLeft)) ≫ P.actLeft)
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
| R.one ⊗ 𝟙 P.X

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

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

Next tactic:
dsimp
theorem hom_left_act_hom' :
    ((regular R).tensorBimod P).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 (regular R) P ≫ hom P = (𝟙 R.X ⊗ hom P) ≫ P.actLeft

Next tactic:
dsimp [hom, TensorBimod.actLeft, regular]
theorem hom_left_act_hom' :
    ((regular R).tensorBimod P).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) (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))).inv ≫
        colimMap
          (parallelPairHom (𝟙 R.X ⊗ R.mul ⊗ 𝟙 P.X) (𝟙 R.X ⊗ (α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft)) (R.mul ⊗ 𝟙 P.X)
            ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))
            ((𝟙 R.X ⊗ (α_ R.X R.X P.X).hom) ≫
              (α_ R.X R.X (R.X ⊗ P.X)).inv ≫ (R.mul ⊗ 𝟙 R.X ⊗ 𝟙 P.X) ≫ (α_ R.X R.X P.X).inv)
            ((α_ R.X R.X P.X).inv ≫ (R.mul ⊗ 𝟙 P.X))
            (_ :
              (tensorLeft R.X).map ((mk R.X R.mul R.mul).actRight ⊗ 𝟙 P.X) ≫
                  (α_ R.X (mk R.X R.mul R.mul).X P.X).inv ≫ ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 P.X) =
                ((𝟙 R.X ⊗ (α_ (mk R.X R.mul R.mul).X R.X P.X).hom) ≫
                    (α_ R.X (mk R.X R.mul R.mul).X (R.X ⊗ P.X)).inv ≫
                      ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 R.X ⊗ 𝟙 P.X) ≫ (α_ (mk R.X R.mul R.mul).X R.X P.X).inv) ≫
                  ((mk R.X R.mul R.mul).actRight ⊗ 𝟙 P.X))
            (_ :
              (tensorLeft R.X).map ((α_ (mk R.X R.mul R.mul).X R.X P.X).hom ≫ (𝟙 (mk R.X R.mul R.mul).X ⊗ P.actLeft)) ≫
                  (α_ R.X (mk R.X R.mul R.mul).X P.X).inv ≫ ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 P.X) =
                ((𝟙 R.X ⊗ (α_ (mk R.X R.mul R.mul).X R.X P.X).hom) ≫
                    (α_ R.X (mk R.X R.mul R.mul).X (R.X ⊗ P.X)).inv ≫
                      ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 R.X ⊗ 𝟙 P.X) ≫ (α_ (mk R.X R.mul R.mul).X R.X P.X).inv) ≫
                  (α_ (mk R.X R.mul R.mul).X R.X P.X).hom ≫ (𝟙 (mk R.X R.mul R.mul).X ⊗ P.actLeft)))) ≫
      coequalizer.desc P.actLeft
        (_ :
          ((regular R).actRight ⊗ 𝟙 P.X) ≫ P.actLeft =
            ((α_ (regular R).X R.X P.X).hom ≫ (𝟙 (regular R).X ⊗ P.actLeft)) ≫ P.actLeft) =
    (𝟙 R.X ⊗
        coequalizer.desc P.actLeft
          (_ :
            ((regular R).actRight ⊗ 𝟙 P.X) ≫ P.actLeft =
              ((α_ (regular R).X R.X P.X).hom ≫ (𝟙 (regular R).X ⊗ P.actLeft)) ≫ P.actLeft)) ≫
      P.actLeft

Next tactic:
refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
theorem hom_left_act_hom' :
    ((regular R).tensorBimod P).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.π ((mk R.X R.mul R.mul).actRight ⊗ 𝟙 P.X)
          ((α_ (mk R.X R.mul R.mul).X R.X P.X).hom ≫ (𝟙 (mk R.X R.mul R.mul).X ⊗ P.actLeft))) ≫
      ((PreservesCoequalizer.iso (tensorLeft R.X) (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))).inv ≫
          colimMap
            (parallelPairHom (𝟙 R.X ⊗ R.mul ⊗ 𝟙 P.X) (𝟙 R.X ⊗ (α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))
              (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))
              ((𝟙 R.X ⊗ (α_ R.X R.X P.X).hom) ≫
                (α_ R.X R.X (R.X ⊗ P.X)).inv ≫ (R.mul ⊗ 𝟙 R.X ⊗ 𝟙 P.X) ≫ (α_ R.X R.X P.X).inv)
              ((α_ R.X R.X P.X).inv ≫ (R.mul ⊗ 𝟙 P.X))
              (_ :
                (tensorLeft R.X).map ((mk R.X R.mul R.mul).actRight ⊗ 𝟙 P.X) ≫
                    (α_ R.X (mk R.X R.mul R.mul).X P.X).inv ≫ ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 P.X) =
                  ((𝟙 R.X ⊗ (α_ (mk R.X R.mul R.mul).X R.X P.X).hom) ≫
                      (α_ R.X (mk R.X R.mul R.mul).X (R.X ⊗ P.X)).inv ≫
                        ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 R.X ⊗ 𝟙 P.X) ≫ (α_ (mk R.X R.mul R.mul).X R.X P.X).inv) ≫
                    ((mk R.X R.mul R.mul).actRight ⊗ 𝟙 P.X))
              (_ :
                (tensorLeft R.X).map
                      ((α_ (mk R.X R.mul R.mul).X R.X P.X).hom ≫ (𝟙 (mk R.X R.mul R.mul).X ⊗ P.actLeft)) ≫
                    (α_ R.X (mk R.X R.mul R.mul).X P.X).inv ≫ ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 P.X) =
                  ((𝟙 R.X ⊗ (α_ (mk R.X R.mul R.mul).X R.X P.X).hom) ≫
                      (α_ R.X (mk R.X R.mul R.mul).X (R.X ⊗ P.X)).inv ≫
                        ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 R.X ⊗ 𝟙 P.X) ≫ (α_ (mk R.X R.mul R.mul).X R.X P.X).inv) ≫
                    (α_ (mk R.X R.mul R.mul).X R.X P.X).hom ≫ (𝟙 (mk R.X R.mul R.mul).X ⊗ P.actLeft)))) ≫
        coequalizer.desc P.actLeft
          (_ :
            ((regular R).actRight ⊗ 𝟙 P.X) ≫ P.actLeft =
              ((α_ (regular R).X R.X P.X).hom ≫ (𝟙 (regular R).X ⊗ P.actLeft)) ≫ P.actLeft) =
    (tensorLeft R.X).map
        (coequalizer.π ((mk R.X R.mul R.mul).actRight ⊗ 𝟙 P.X)
          ((α_ (mk R.X R.mul R.mul).X R.X P.X).hom ≫ (𝟙 (mk R.X R.mul R.mul).X ⊗ P.actLeft))) ≫
      (𝟙 R.X ⊗
          coequalizer.desc P.actLeft
            (_ :
              ((regular R).actRight ⊗ 𝟙 P.X) ≫ P.actLeft =
                ((α_ (regular R).X R.X P.X).hom ≫ (𝟙 (regular R).X ⊗ P.actLeft)) ≫ P.actLeft)) ≫
        P.actLeft

Next tactic:
dsimp
theorem hom_left_act_hom' :
    ((regular R).tensorBimod P).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.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))) ≫
      ((PreservesCoequalizer.iso (tensorLeft R.X) (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))).inv ≫
          colimMap
            (parallelPairHom (𝟙 R.X ⊗ R.mul ⊗ 𝟙 P.X) (𝟙 R.X ⊗ (α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))
              (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))
              ((𝟙 R.X ⊗ (α_ R.X R.X P.X).hom) ≫
                (α_ R.X R.X (R.X ⊗ P.X)).inv ≫ (R.mul ⊗ 𝟙 R.X ⊗ 𝟙 P.X) ≫ (α_ R.X R.X P.X).inv)
              ((α_ R.X R.X P.X).inv ≫ (R.mul ⊗ 𝟙 P.X))
              (_ :
                (tensorLeft R.X).map ((mk R.X R.mul R.mul).actRight ⊗ 𝟙 P.X) ≫
                    (α_ R.X (mk R.X R.mul R.mul).X P.X).inv ≫ ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 P.X) =
                  ((𝟙 R.X ⊗ (α_ (mk R.X R.mul R.mul).X R.X P.X).hom) ≫
                      (α_ R.X (mk R.X R.mul R.mul).X (R.X ⊗ P.X)).inv ≫
                        ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 R.X ⊗ 𝟙 P.X) ≫ (α_ (mk R.X R.mul R.mul).X R.X P.X).inv) ≫
                    ((mk R.X R.mul R.mul).actRight ⊗ 𝟙 P.X))
              (_ :
                (tensorLeft R.X).map
                      ((α_ (mk R.X R.mul R.mul).X R.X P.X).hom ≫ (𝟙 (mk R.X R.mul R.mul).X ⊗ P.actLeft)) ≫
                    (α_ R.X (mk R.X R.mul R.mul).X P.X).inv ≫ ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 P.X) =
                  ((𝟙 R.X ⊗ (α_ (mk R.X R.mul R.mul).X R.X P.X).hom) ≫
                      (α_ R.X (mk R.X R.mul R.mul).X (R.X ⊗ P.X)).inv ≫
                        ((mk R.X R.mul R.mul).actLeft ⊗ 𝟙 R.X ⊗ 𝟙 P.X) ≫ (α_ (mk R.X R.mul R.mul).X R.X P.X).inv) ≫
                    (α_ (mk R.X R.mul R.mul).X R.X P.X).hom ≫ (𝟙 (mk R.X R.mul R.mul).X ⊗ P.actLeft)))) ≫
        coequalizer.desc P.actLeft
          (_ :
            ((regular R).actRight ⊗ 𝟙 P.X) ≫ P.actLeft =
              ((α_ (regular R).X R.X P.X).hom ≫ (𝟙 (regular R).X ⊗ P.actLeft)) ≫ P.actLeft) =
    (𝟙 R.X ⊗ coequalizer.π (R.mul ⊗ 𝟙 P.X) ((α_ R.X R.X P.X).hom ≫ (𝟙 R.X ⊗ P.actLeft))) ≫
      (𝟙 R.X ⊗
          coequalizer.desc P.actLeft
            (_ :
              ((regular R).actRight ⊗ 𝟙 P.X) ≫ P.actLeft =
                ((α_ (regular R).X R.X P.X).hom ≫ (𝟙 (regular R).X ⊗ P.actLeft)) ≫ P.actLeft)) ≫
        P.actLeft

Next tactic:
slice_lhs 1 4 => rw [id_tensor_π_preserves_coequalizer_inv_colimMap_desc]