l3lab/ntp-mathlib huggingface dataset:
/-- Tensor product of two morphisms of bimodule objects. -/
@[simps]
noncomputable def tensorHom {X Y Z : Mon_ C} {M₁ M₂ : Bimod X Y} {N₁ N₂ : Bimod Y Z} (f : M₁ ⟶ M₂)
    (g : N₁ ⟶ N₂) : M₁.tensorBimod N₁ ⟶ M₂.tensorBimod N₂ where
  hom :=
    colimMap
      (parallelPairHom _ _ _ _ ((f.hom ⊗ 𝟙 Y.X) ⊗ g.hom) (f.hom ⊗ g.hom)
        (by
          rw [← tensor_comp, ← tensor_comp, Hom.right_act_hom, Category.id_comp, Category.comp_id])
        (by
          slice_lhs 2 3 => rw [← tensor_comp, Hom.left_act_hom, Category.id_comp]
          slice_rhs 1 2 => rw [associator_naturality]
          slice_rhs 2 3 => rw [← tensor_comp, Category.comp_id]))
  left_act_hom := by
    refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
    dsimp
    slice_lhs 1 2 => rw [TensorBimod.id_tensor_π_actLeft]
    slice_lhs 3 4 => rw [ι_colimMap, parallelPairHom_app_one]
    slice_lhs 2 3 => rw [← tensor_comp, Hom.left_act_hom, Category.id_comp]
    slice_rhs 1 2 => rw [← id_tensor_comp, ι_colimMap, parallelPairHom_app_one, id_tensor_comp]
    slice_rhs 2 3 => rw [TensorBimod.id_tensor_π_actLeft]
    slice_rhs 1 2 => rw [associator_inv_naturality]
    slice_rhs 2 3 => rw [← tensor_comp, Category.comp_id]
  right_act_hom := by
    refine' (cancel_epi ((tensorRight _).map (coequalizer.π _ _))).1 _
    dsimp
    slice_lhs 1 2 => rw [TensorBimod.π_tensor_id_actRight]
    slice_lhs 3 4 => rw [ι_colimMap, parallelPairHom_app_one]
    slice_lhs 2 3 => rw [← tensor_comp, Category.id_comp, Hom.right_act_hom]
    slice_rhs 1 2 => rw [← comp_tensor_id, ι_colimMap, parallelPairHom_app_one, comp_tensor_id]
    slice_rhs 2 3 => rw [TensorBimod.π_tensor_id_actRight]
    

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₁ M₂ : Bimod X Y
N₁ N₂ : Bimod Y Z
f : M₁ ⟶ M₂
g : N₁ ⟶ N₂
⊢ (α_ M₁.X N₁.X Z.X).hom ≫
      (f.hom ⊗ (g.hom ⊗ 𝟙 Z.X) ≫ N₂.actRight) ≫
        colimit.ι (parallelPair (M₂.actRight ⊗ 𝟙 N₂.X) ((α_ M₂.X Y.X N₂.X).hom ≫ (𝟙 M₂.X ⊗ N₂.actLeft)))
          WalkingParallelPair.one =
    ((f.hom ⊗ g.hom) ⊗ 𝟙 Z.X) ≫
      (α_ M₂.X N₂.X Z.X).hom ≫
        (𝟙 M₂.X ⊗ N₂.actRight) ≫ coequalizer.π (M₂.actRight ⊗ 𝟙 N₂.X) ((α_ M₂.X Y.X N₂.X).hom ≫ (𝟙 M₂.X ⊗ N₂.actLeft))

Next tactic:
slice_rhs 1 2 => rw [associator_naturality]
/-- Tensor product of two morphisms of bimodule objects. -/
@[simps]
noncomputable def tensorHom {X Y Z : Mon_ C} {M₁ M₂ : Bimod X Y} {N₁ N₂ : Bimod Y Z} (f : M₁ ⟶ M₂)
    (g : N₁ ⟶ N₂) : M₁.tensorBimod N₁ ⟶ M₂.tensorBimod N₂ where
  hom :=
    colimMap
      (parallelPairHom _ _ _ _ ((f.hom ⊗ 𝟙 Y.X) ⊗ g.hom) (f.hom ⊗ g.hom)
        (by
          rw [← tensor_comp, ← tensor_comp, Hom.right_act_hom, Category.id_comp, Category.comp_id])
        (by
          slice_lhs 2 3 => rw [← tensor_comp, Hom.left_act_hom, Category.id_comp]
          slice_rhs 1 2 => rw [associator_naturality]
          slice_rhs 2 3 => rw [← tensor_comp, Category.comp_id]))
  left_act_hom := by
    refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
    dsimp
    slice_lhs 1 2 => rw [TensorBimod.id_tensor_π_actLeft]
    slice_lhs 3 4 => rw [ι_colimMap, parallelPairHom_app_one]
    slice_lhs 2 3 => rw [← tensor_comp, Hom.left_act_hom, Category.id_comp]
    slice_rhs 1 2 => rw [← id_tensor_comp, ι_colimMap, parallelPairHom_app_one, id_tensor_comp]
    slice_rhs 2 3 => rw [TensorBimod.id_tensor_π_actLeft]
    slice_rhs 1 2 => rw [associator_inv_naturality]
    slice_rhs 2 3 => rw [← tensor_comp, Category.comp_id]
  right_act_hom := by
    refine' (cancel_epi ((tensorRight _).map (coequalizer.π _ _))).1 _
    dsimp
    slice_lhs 1 2 => rw [TensorBimod.π_tensor_id_actRight]
    slice_lhs 3 4 => rw [ι_colimMap, parallelPairHom_app_one]
    slice_lhs 2 3 => rw [← tensor_comp, Category.id_comp, Hom.right_act_hom]
    slice_rhs 1 2 => rw [← comp_tensor_id, ι_colimMap, parallelPairHom_app_one, comp_tensor_id]
    slice_rhs 2 3 => rw [TensorBimod.π_tensor_id_actRight]
    slice_rhs 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
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₁ M₂ : Bimod X Y
N₁ N₂ : Bimod Y Z
f : M₁ ⟶ M₂
g : N₁ ⟶ N₂
| ((f.hom ⊗ g.hom) ⊗ 𝟙 Z.X) ≫ (α_ M₂.X N₂.X Z.X).hom
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
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₁ M₂ : Bimod X Y
N₁ N₂ : Bimod Y Z
f : M₁ ⟶ M₂
g : N₁ ⟶ N₂
| 𝟙 M₂.X ⊗ N₂.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
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₁ M₂ : Bimod X Y
N₁ N₂ : Bimod Y Z
f : M₁ ⟶ M₂
g : N₁ ⟶ N₂
| coequalizer.π (M₂.actRight ⊗ 𝟙 N₂.X) ((α_ M₂.X Y.X N₂.X).hom ≫ (𝟙 M₂.X ⊗ N₂.actLeft))

Next tactic:
rw [associator_naturality]
/-- Tensor product of two morphisms of bimodule objects. -/
@[simps]
noncomputable def tensorHom {X Y Z : Mon_ C} {M₁ M₂ : Bimod X Y} {N₁ N₂ : Bimod Y Z} (f : M₁ ⟶ M₂)
    (g : N₁ ⟶ N₂) : M₁.tensorBimod N₁ ⟶ M₂.tensorBimod N₂ where
  hom :=
    colimMap
      (parallelPairHom _ _ _ _ ((f.hom ⊗ 𝟙 Y.X) ⊗ g.hom) (f.hom ⊗ g.hom)
        (by
          rw [← tensor_comp, ← tensor_comp, Hom.right_act_hom, Category.id_comp, Category.comp_id])
        (by
          slice_lhs 2 3 => rw [← tensor_comp, Hom.left_act_hom, Category.id_comp]
          slice_rhs 1 2 => rw [associator_naturality]
          slice_rhs 2 3 => rw [← tensor_comp, Category.comp_id]))
  left_act_hom := by
    refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
    dsimp
    slice_lhs 1 2 => rw [TensorBimod.id_tensor_π_actLeft]
    slice_lhs 3 4 => rw [ι_colimMap, parallelPairHom_app_one]
    slice_lhs 2 3 => rw [← tensor_comp, Hom.left_act_hom, Category.id_comp]
    slice_rhs 1 2 => rw [← id_tensor_comp, ι_colimMap, parallelPairHom_app_one, id_tensor_comp]
    slice_rhs 2 3 => rw [TensorBimod.id_tensor_π_actLeft]
    slice_rhs 1 2 => rw [associator_inv_naturality]
    slice_rhs 2 3 => rw [← tensor_comp, Category.comp_id]
  right_act_hom := by
    refine' (cancel_epi ((tensorRight _).map (coequalizer.π _ _))).1 _
    dsimp
    slice_lhs 1 2 => rw [TensorBimod.π_tensor_id_actRight]
    slice_lhs 3 4 => rw [ι_colimMap, parallelPairHom_app_one]
    slice_lhs 2 3 => rw [← tensor_comp, Category.id_comp, Hom.right_act_hom]
    slice_rhs 1 2 => rw [← comp_tensor_id, ι_colimMap, parallelPairHom_app_one, comp_tensor_id]
    slice_rhs 2 3 => rw [TensorBimod.π_tensor_id_actRight]
    slice_rhs 1 2 => rw [associator_naturality]
    

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₁ M₂ : Bimod X Y
N₁ N₂ : Bimod Y Z
f : M₁ ⟶ M₂
g : N₁ ⟶ N₂
⊢ (α_ M₁.X N₁.X Z.X).hom ≫
      (f.hom ⊗ (g.hom ⊗ 𝟙 Z.X) ≫ N₂.actRight) ≫
        colimit.ι (parallelPair (M₂.actRight ⊗ 𝟙 N₂.X) ((α_ M₂.X Y.X N₂.X).hom ≫ (𝟙 M₂.X ⊗ N₂.actLeft)))
          WalkingParallelPair.one =
    (((α_ M₁.X N₁.X Z.X).hom ≫ (f.hom ⊗ g.hom ⊗ 𝟙 Z.X)) ≫ (𝟙 M₂.X ⊗ N₂.actRight)) ≫
      coequalizer.π (M₂.actRight ⊗ 𝟙 N₂.X) ((α_ M₂.X Y.X N₂.X).hom ≫ (𝟙 M₂.X ⊗ N₂.actLeft))

Next tactic:
slice_rhs 2 3 => rw [← tensor_comp, Category.comp_id]
/-- Tensor product of two morphisms of bimodule objects. -/
@[simps]
noncomputable def tensorHom {X Y Z : Mon_ C} {M₁ M₂ : Bimod X Y} {N₁ N₂ : Bimod Y Z} (f : M₁ ⟶ M₂)
    (g : N₁ ⟶ N₂) : M₁.tensorBimod N₁ ⟶ M₂.tensorBimod N₂ where
  hom :=
    colimMap
      (parallelPairHom _ _ _ _ ((f.hom ⊗ 𝟙 Y.X) ⊗ g.hom) (f.hom ⊗ g.hom)
        (by
          rw [← tensor_comp, ← tensor_comp, Hom.right_act_hom, Category.id_comp, Category.comp_id])
        (by
          slice_lhs 2 3 => rw [← tensor_comp, Hom.left_act_hom, Category.id_comp]
          slice_rhs 1 2 => rw [associator_naturality]
          slice_rhs 2 3 => rw [← tensor_comp, Category.comp_id]))
  left_act_hom := by
    refine' (cancel_epi ((tensorLeft _).map (coequalizer.π _ _))).1 _
    dsimp
    slice_lhs 1 2 => rw [TensorBimod.id_tensor_π_actLeft]
    slice_lhs 3 4 => rw [ι_colimMap, parallelPairHom_app_one]
    slice_lhs 2 3 => rw [← tensor_comp, Hom.left_act_hom, Category.id_comp]
    slice_rhs 1 2 => rw [← id_tensor_comp, ι_colimMap, parallelPairHom_app_one, id_tensor_comp]
    slice_rhs 2 3 => rw [TensorBimod.id_tensor_π_actLeft]
    slice_rhs 1 2 => rw [associator_inv_naturality]
    slice_rhs 2 3 => rw [← tensor_comp, Category.comp_id]
  right_act_hom := by
    refine' (cancel_epi ((tensorRight _).map (coequalizer.π _ _))).1 _
    dsimp
    slice_lhs 1 2 => rw [TensorBimod.π_tensor_id_actRight]
    slice_lhs 3 4 => rw [ι_colimMap, parallelPairHom_app_one]
    slice_lhs 2 3 => rw [← tensor_comp, Category.id_comp, Hom.right_act_hom]
    slice_rhs 1 2 => rw [← comp_tensor_id, ι_colimMap, parallelPairHom_app_one, comp_tensor_id]
    slice_rhs 2 3 => rw [TensorBimod.π_tensor_id_actRight]
    slice_rhs 1 2 => rw [associator_naturality]
    slice_rhs 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
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₁ M₂ : Bimod X Y
N₁ N₂ : Bimod Y Z
f : M₁ ⟶ M₂
g : N₁ ⟶ N₂
| (f.hom ⊗ g.hom ⊗ 𝟙 Z.X) ≫ (𝟙 M₂.X ⊗ N₂.actRight)
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
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₁ M₂ : Bimod X Y
N₁ N₂ : Bimod Y Z
f : M₁ ⟶ M₂
g : N₁ ⟶ N₂
| coequalizer.π (M₂.actRight ⊗ 𝟙 N₂.X) ((α_ M₂.X Y.X N₂.X).hom ≫ (𝟙 M₂.X ⊗ N₂.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
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₁ M₂ : Bimod X Y
N₁ N₂ : Bimod Y Z
f : M₁ ⟶ M₂
g : N₁ ⟶ N₂
| (α_ M₁.X N₁.X Z.X).hom

Next tactic:
rw [← tensor_comp, Category.comp_id]
theorem tensor_id {X Y Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} :
    tensorHom (𝟙 M) (𝟙 N) = 𝟙 (M.tensorBimod N) := 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 : Bimod Y Z
⊢ tensorHom (𝟙 M) (𝟙 N) = 𝟙 (tensorBimod M N)

Next tactic:
ext
theorem tensor_id {X Y Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} :
    tensorHom (𝟙 M) (𝟙 N) = 𝟙 (M.tensorBimod N) := by
  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 Z : Mon_ C
M : Bimod X Y
N : Bimod Y Z
⊢ (tensorHom (𝟙 M) (𝟙 N)).hom = (𝟙 (tensorBimod M N)).hom

Next tactic:
apply Limits.coequalizer.hom_ext
theorem tensor_id {X Y Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} :
    tensorHom (𝟙 M) (𝟙 N) = 𝟙 (M.tensorBimod N) := by
  ext
  apply Limits.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 Z : Mon_ C
M : Bimod X Y
N : Bimod Y Z
⊢ coequalizer.π (M.actRight ⊗ 𝟙 N.X) ((α_ M.X Y.X N.X).hom ≫ (𝟙 M.X ⊗ N.actLeft)) ≫ (tensorHom (𝟙 M) (𝟙 N)).hom =
    coequalizer.π (M.actRight ⊗ 𝟙 N.X) ((α_ M.X Y.X N.X).hom ≫ (𝟙 M.X ⊗ N.actLeft)) ≫ (𝟙 (tensorBimod M N)).hom

Next tactic:
simp only [id_hom', MonoidalCategory.tensor_id, tensorHom_hom, ι_colimMap,
    parallelPairHom_app_one]
theorem tensor_id {X Y Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} :
    tensorHom (𝟙 M) (𝟙 N) = 𝟙 (M.tensorBimod N) := by
  ext
  apply Limits.coequalizer.hom_ext
  simp only [id_hom', MonoidalCategory.tensor_id, tensorHom_hom, ι_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 Z : Mon_ C
M : Bimod X Y
N : Bimod Y Z
⊢ 𝟙 (M.X ⊗ N.X) ≫
      colimit.ι (parallelPair (M.actRight ⊗ 𝟙 N.X) ((α_ M.X Y.X N.X).hom ≫ (𝟙 M.X ⊗ N.actLeft)))
        WalkingParallelPair.one =
    coequalizer.π (M.actRight ⊗ 𝟙 N.X) ((α_ M.X Y.X N.X).hom ≫ (𝟙 M.X ⊗ N.actLeft)) ≫ 𝟙 (tensorBimod M N).X

Next tactic:
dsimp
theorem tensor_id {X Y Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} :
    tensorHom (𝟙 M) (𝟙 N) = 𝟙 (M.tensorBimod N) := by
  ext
  apply Limits.coequalizer.hom_ext
  simp only [id_hom', MonoidalCategory.tensor_id, tensorHom_hom, ι_colimMap,
    parallelPairHom_app_one]
  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 Z : Mon_ C
M : Bimod X Y
N : Bimod Y Z
⊢ 𝟙 (M.X ⊗ N.X) ≫
      colimit.ι (parallelPair (M.actRight ⊗ 𝟙 N.X) ((α_ M.X Y.X N.X).hom ≫ (𝟙 M.X ⊗ N.actLeft)))
        WalkingParallelPair.one =
    coequalizer.π (M.actRight ⊗ 𝟙 N.X) ((α_ M.X Y.X N.X).hom ≫ (𝟙 M.X ⊗ N.actLeft)) ≫ 𝟙 (TensorBimod.X M N)

Next tactic:
dsimp only [TensorBimod.X]
theorem tensor_id {X Y Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} :
    tensorHom (𝟙 M) (𝟙 N) = 𝟙 (M.tensorBimod N) := by
  ext
  apply Limits.coequalizer.hom_ext
  simp only [id_hom', MonoidalCategory.tensor_id, tensorHom_hom, ι_colimMap,
    parallelPairHom_app_one]
  dsimp; dsimp only [TensorBimod.X]
  

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 Z : Mon_ C
M : Bimod X Y
N : Bimod Y Z
⊢ 𝟙 (M.X ⊗ N.X) ≫
      colimit.ι (parallelPair (M.actRight ⊗ 𝟙 N.X) ((α_ M.X Y.X N.X).hom ≫ (𝟙 M.X ⊗ N.actLeft)))
        WalkingParallelPair.one =
    coequalizer.π (M.actRight ⊗ 𝟙 N.X) ((α_ M.X Y.X N.X).hom ≫ (𝟙 M.X ⊗ N.actLeft)) ≫
      𝟙 (coequalizer (M.actRight ⊗ 𝟙 N.X) ((α_ M.X Y.X N.X).hom ≫ (𝟙 M.X ⊗ N.actLeft)))

Next tactic:
simp only [Category.id_comp, Category.comp_id]
theorem tensor_comp {X Y Z : Mon_ C} {M₁ M₂ M₃ : Bimod X Y} {N₁ N₂ N₃ : Bimod Y Z} (f₁ : M₁ ⟶ M₂)
    (f₂ : M₂ ⟶ M₃) (g₁ : N₁ ⟶ N₂) (g₂ : N₂ ⟶ N₃) :
    tensorHom (f₁ ≫ f₂) (g₁ ≫ g₂) = tensorHom f₁ g₁ ≫ tensorHom f₂ 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₁ M₂ M₃ : Bimod X Y
N₁ N₂ N₃ : Bimod Y Z
f₁ : M₁ ⟶ M₂
f₂ : M₂ ⟶ M₃
g₁ : N₁ ⟶ N₂
g₂ : N₂ ⟶ N₃
⊢ tensorHom (f₁ ≫ f₂) (g₁ ≫ g₂) = tensorHom f₁ g₁ ≫ tensorHom f₂ g₂

Next tactic:
ext
theorem tensor_comp {X Y Z : Mon_ C} {M₁ M₂ M₃ : Bimod X Y} {N₁ N₂ N₃ : Bimod Y Z} (f₁ : M₁ ⟶ M₂)
    (f₂ : M₂ ⟶ M₃) (g₁ : N₁ ⟶ N₂) (g₂ : N₂ ⟶ N₃) :
    tensorHom (f₁ ≫ f₂) (g₁ ≫ g₂) = tensorHom f₁ g₁ ≫ tensorHom f₂ g₂ := by
  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 Z : Mon_ C
M₁ M₂ M₃ : Bimod X Y
N₁ N₂ N₃ : Bimod Y Z
f₁ : M₁ ⟶ M₂
f₂ : M₂ ⟶ M₃
g₁ : N₁ ⟶ N₂
g₂ : N₂ ⟶ N₃
⊢ (tensorHom (f₁ ≫ f₂) (g₁ ≫ g₂)).hom = (tensorHom f₁ g₁ ≫ tensorHom f₂ g₂).hom

Next tactic:
apply Limits.coequalizer.hom_ext
theorem tensor_comp {X Y Z : Mon_ C} {M₁ M₂ M₃ : Bimod X Y} {N₁ N₂ N₃ : Bimod Y Z} (f₁ : M₁ ⟶ M₂)
    (f₂ : M₂ ⟶ M₃) (g₁ : N₁ ⟶ N₂) (g₂ : N₂ ⟶ N₃) :
    tensorHom (f₁ ≫ f₂) (g₁ ≫ g₂) = tensorHom f₁ g₁ ≫ tensorHom f₂ g₂ := by
  ext
  apply Limits.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 Z : Mon_ C
M₁ M₂ M₃ : Bimod X Y
N₁ N₂ N₃ : Bimod Y Z
f₁ : M₁ ⟶ M₂
f₂ : M₂ ⟶ M₃
g₁ : N₁ ⟶ N₂
g₂ : N₂ ⟶ N₃
⊢ coequalizer.π (M₁.actRight ⊗ 𝟙 N₁.X) ((α_ M₁.X Y.X N₁.X).hom ≫ (𝟙 M₁.X ⊗ N₁.actLeft)) ≫
      (tensorHom (f₁ ≫ f₂) (g₁ ≫ g₂)).hom =
    coequalizer.π (M₁.actRight ⊗ 𝟙 N₁.X) ((α_ M₁.X Y.X N₁.X).hom ≫ (𝟙 M₁.X ⊗ N₁.actLeft)) ≫
      (tensorHom f₁ g₁ ≫ tensorHom f₂ g₂).hom

Next tactic:
simp only [comp_hom', MonoidalCategory.tensor_comp, tensorHom_hom,
    ι_colimMap, parallelPairHom_app_one, Category.assoc, ι_colimMap_assoc]
/-- An auxiliary morphism for the definition of the underlying morphism of the forward component of
the associator isomorphism. -/
noncomputable def homAux : (P.tensorBimod Q).X ⊗ L.X ⟶ (P.tensorBimod (Q.tensorBimod L)).X :=
  (PreservesCoequalizer.iso (tensorRight L.X) _ _).inv ≫
    coequalizer.desc ((α_ _ _ _).hom ≫ (𝟙 P.X ⊗ coequalizer.π _ _) ≫ coequalizer.π _ _)
      (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)
R S T U : Mon_ C
P : Bimod R S
Q : Bimod S T
L : Bimod T U
⊢ (tensorRight L.X).map (P.actRight ⊗ 𝟙 Q.X) ≫
      (α_ P.X Q.X L.X).hom ≫
        (𝟙 P.X ⊗ coequalizer.π (Q.actRight ⊗ 𝟙 L.X) ((α_ Q.X T.X L.X).hom ≫ (𝟙 Q.X ⊗ L.actLeft))) ≫
          coequalizer.π (P.actRight ⊗ 𝟙 (tensorBimod Q L).X)
            ((α_ P.X S.X (tensorBimod Q L).X).hom ≫ (𝟙 P.X ⊗ (tensorBimod Q L).actLeft)) =
    (tensorRight L.X).map ((α_ P.X S.X Q.X).hom ≫ (𝟙 P.X ⊗ Q.actLeft)) ≫
      (α_ P.X Q.X L.X).hom ≫
        (𝟙 P.X ⊗ coequalizer.π (Q.actRight ⊗ 𝟙 L.X) ((α_ Q.X T.X L.X).hom ≫ (𝟙 Q.X ⊗ L.actLeft))) ≫
          coequalizer.π (P.actRight ⊗ 𝟙 (tensorBimod Q L).X)
            ((α_ P.X S.X (tensorBimod Q L).X).hom ≫ (𝟙 P.X ⊗ (tensorBimod Q L).actLeft))

Next tactic:
dsimp
/-- An auxiliary morphism for the definition of the underlying morphism of the forward component of
the associator isomorphism. -/
noncomputable def homAux : (P.tensorBimod Q).X ⊗ L.X ⟶ (P.tensorBimod (Q.tensorBimod L)).X :=
  (PreservesCoequalizer.iso (tensorRight L.X) _ _).inv ≫
    coequalizer.desc ((α_ _ _ _).hom ≫ (𝟙 P.X ⊗ coequalizer.π _ _) ≫ coequalizer.π _ _)
      (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
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 S T U : Mon_ C
P : Bimod R S
Q : Bimod S T
L : Bimod T U
⊢ ((P.actRight ⊗ 𝟙 Q.X) ⊗ 𝟙 L.X) ≫
      (α_ P.X Q.X L.X).hom ≫
        (𝟙 P.X ⊗ coequalizer.π (Q.actRight ⊗ 𝟙 L.X) ((α_ Q.X T.X L.X).hom ≫ (𝟙 Q.X ⊗ L.actLeft))) ≫
          coequalizer.π (P.actRight ⊗ 𝟙 (TensorBimod.X Q L))
            ((α_ P.X S.X (TensorBimod.X Q L)).hom ≫ (𝟙 P.X ⊗ TensorBimod.actLeft Q L)) =
    ((α_ P.X S.X Q.X).hom ≫ (𝟙 P.X ⊗ Q.actLeft) ⊗ 𝟙 L.X) ≫
      (α_ P.X Q.X L.X).hom ≫
        (𝟙 P.X ⊗ coequalizer.π (Q.actRight ⊗ 𝟙 L.X) ((α_ Q.X T.X L.X).hom ≫ (𝟙 Q.X ⊗ L.actLeft))) ≫
          coequalizer.π (P.actRight ⊗ 𝟙 (TensorBimod.X Q L))
            ((α_ P.X S.X (TensorBimod.X Q L)).hom ≫ (𝟙 P.X ⊗ TensorBimod.actLeft Q L))

Next tactic:
dsimp [TensorBimod.X]
/-- An auxiliary morphism for the definition of the underlying morphism of the forward component of
the associator isomorphism. -/
noncomputable def homAux : (P.tensorBimod Q).X ⊗ L.X ⟶ (P.tensorBimod (Q.tensorBimod L)).X :=
  (PreservesCoequalizer.iso (tensorRight L.X) _ _).inv ≫
    coequalizer.desc ((α_ _ _ _).hom ≫ (𝟙 P.X ⊗ coequalizer.π _ _) ≫ coequalizer.π _ _)
      (by
        dsimp; dsimp [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
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 S T U : Mon_ C
P : Bimod R S
Q : Bimod S T
L : Bimod T U
⊢ ((P.actRight ⊗ 𝟙 Q.X) ⊗ 𝟙 L.X) ≫
      (α_ P.X Q.X L.X).hom ≫
        (𝟙 P.X ⊗ coequalizer.π (Q.actRight ⊗ 𝟙 L.X) ((α_ Q.X T.X L.X).hom ≫ (𝟙 Q.X ⊗ L.actLeft))) ≫
          coequalizer.π (P.actRight ⊗ 𝟙 (coequalizer (Q.actRight ⊗ 𝟙 L.X) ((α_ Q.X T.X L.X).hom ≫ (𝟙 Q.X ⊗ L.actLeft))))
            ((α_ P.X S.X (coequalizer (Q.actRight ⊗ 𝟙 L.X) ((α_ Q.X T.X L.X).hom ≫ (𝟙 Q.X ⊗ L.actLeft)))).hom ≫
              (𝟙 P.X ⊗ TensorBimod.actLeft Q L)) =
    ((α_ P.X S.X Q.X).hom ≫ (𝟙 P.X ⊗ Q.actLeft) ⊗ 𝟙 L.X) ≫
      (α_ P.X Q.X L.X).hom ≫
        (𝟙 P.X ⊗ coequalizer.π (Q.actRight ⊗ 𝟙 L.X) ((α_ Q.X T.X L.X).hom ≫ (𝟙 Q.X ⊗ L.actLeft))) ≫
          coequalizer.π (P.actRight ⊗ 𝟙 (coequalizer (Q.actRight ⊗ 𝟙 L.X) ((α_ Q.X T.X L.X).hom ≫ (𝟙 Q.X ⊗ L.actLeft))))
            ((α_ P.X S.X (coequalizer (Q.actRight ⊗ 𝟙 L.X) ((α_ Q.X T.X L.X).hom ≫ (𝟙 Q.X ⊗ L.actLeft)))).hom ≫
              (𝟙 P.X ⊗ TensorBimod.actLeft Q L))

Next tactic:
slice_lhs 1 2 => rw [associator_naturality]