l3lab/ntp-mathlib huggingface dataset:
theorem mul_associator {M N P : Mon_ C} :
    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
        (α_ M.X N.X P.X).hom =
      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul)) := by
  simp only [tensor_obj, prodMonoidal_tensorObj, Category.assoc]
  slice_lhs 2 3 => rw [← Category.id_comp P.mul, tensor_comp]
  slice_lhs 3 4 => rw [associator_naturality]
  slice_rhs 3 4 => 

Proof state:
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| (α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X)

Next tactic:
rw [← Category.id_comp M.mul, tensor_comp]
theorem mul_associator {M N P : Mon_ C} :
    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
        (α_ M.X N.X P.X).hom =
      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul)) := by
  simp only [tensor_obj, prodMonoidal_tensorObj, Category.assoc]
  slice_lhs 2 3 => rw [← Category.id_comp P.mul, tensor_comp]
  slice_lhs 3 4 => rw [associator_naturality]
  slice_rhs 3 4 => rw [← Category.id_comp M.mul, tensor_comp]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
      (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫
        (α_ (M.X ⊗ M.X) (N.X ⊗ N.X) (P.X ⊗ P.X)).hom ≫ (M.mul ⊗ N.mul ⊗ P.mul) =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
        (𝟙 (M.X ⊗ M.X) ⊗ tensor_μ C (N.X, P.X) (N.X, P.X)) ≫ (M.mul ⊗ N.mul ⊗ P.mul)

Next tactic:
slice_lhs 1 3 => rw [associator_monoidal]
theorem mul_associator {M N P : Mon_ C} :
    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
        (α_ M.X N.X P.X).hom =
      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul)) := by
  simp only [tensor_obj, prodMonoidal_tensorObj, Category.assoc]
  slice_lhs 2 3 => rw [← Category.id_comp P.mul, tensor_comp]
  slice_lhs 3 4 => rw [associator_naturality]
  slice_rhs 3 4 => rw [← Category.id_comp M.mul, tensor_comp]
  slice_lhs 1 3 => 

Proof state:
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
    (tensor_μ C (M.X, N.X) (M.X, N.X) ⊗ 𝟙 (P.X ⊗ P.X)) ≫ (α_ (M.X ⊗ M.X) (N.X ⊗ N.X) (P.X ⊗ P.X)).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
| M.mul ⊗ N.mul ⊗ P.mul

Next tactic:
rw [associator_monoidal]
theorem mul_associator {M N P : Mon_ C} :
    (tensor_μ C (M.X ⊗ N.X, P.X) (M.X ⊗ N.X, P.X) ≫
          (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul) ⊗ P.mul)) ≫
        (α_ M.X N.X P.X).hom =
      ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
          (M.mul ⊗ tensor_μ C (N.X, P.X) (N.X, P.X) ≫ (N.mul ⊗ P.mul)) := by
  simp only [tensor_obj, prodMonoidal_tensorObj, Category.assoc]
  slice_lhs 2 3 => rw [← Category.id_comp P.mul, tensor_comp]
  slice_lhs 3 4 => rw [associator_naturality]
  slice_rhs 3 4 => rw [← Category.id_comp M.mul, tensor_comp]
  slice_lhs 1 3 => rw [associator_monoidal]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M N P : Mon_ C
⊢ (((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
        tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫ (𝟙 (M.X ⊗ M.X) ⊗ tensor_μ C (N.X, P.X) (N.X, P.X))) ≫
      (M.mul ⊗ N.mul ⊗ P.mul) =
    ((α_ M.X N.X P.X).hom ⊗ (α_ M.X N.X P.X).hom) ≫
      tensor_μ C (M.X, N.X ⊗ P.X) (M.X, N.X ⊗ P.X) ≫
        (𝟙 (M.X ⊗ M.X) ⊗ tensor_μ C (N.X, P.X) (N.X, P.X)) ≫ (M.mul ⊗ N.mul ⊗ P.mul)

Next tactic:
simp only [Category.assoc]
theorem mul_leftUnitor {M : Mon_ C} :
    (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
      ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul := by
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul

Next tactic:
rw [← Category.comp_id (λ_ (𝟙_ C)).hom, ← Category.id_comp M.mul, tensor_comp]
theorem mul_leftUnitor {M : Mon_ C} :
    (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
      ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul := by
  rw [← Category.comp_id (λ_ (𝟙_ C)).hom, ← Category.id_comp M.mul, tensor_comp]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)) ≫ (𝟙 (𝟙_ C) ⊗ M.mul)) ≫ (λ_ M.X).hom =
    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul

Next tactic:
slice_lhs 3 4 => rw [leftUnitor_naturality]
theorem mul_leftUnitor {M : Mon_ C} :
    (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
      ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul := by
  rw [← Category.comp_id (λ_ (𝟙_ C)).hom, ← Category.id_comp M.mul, tensor_comp]
  slice_lhs 3 4 => 

Proof state:
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (𝟙 (𝟙_ C) ⊗ M.mul) ≫ (λ_ M.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)

Next tactic:
rw [leftUnitor_naturality]
theorem mul_leftUnitor {M : Mon_ C} :
    (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
      ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul := by
  rw [← Category.comp_id (λ_ (𝟙_ C)).hom, ← Category.id_comp M.mul, tensor_comp]
  slice_lhs 3 4 => rw [leftUnitor_naturality]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)) ≫ (λ_ (M.X ⊗ M.X)).hom ≫ M.mul =
    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul

Next tactic:
slice_lhs 1 3 => rw [← leftUnitor_monoidal]
theorem mul_leftUnitor {M : Mon_ C} :
    (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
      ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul := by
  rw [← Category.comp_id (λ_ (𝟙_ C)).hom, ← Category.id_comp M.mul, tensor_comp]
  slice_lhs 3 4 => rw [leftUnitor_naturality]
  slice_lhs 1 3 => 

Proof state:
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)) ≫ (λ_ (M.X ⊗ M.X)).hom
case a C : Type u₁ inst✝² : Category.{v₁, u₁} C inst✝¹ : MonoidalCategory C inst✝ : BraidedCategory C M : Mon_ C | M.mul

Next tactic:
rw [← leftUnitor_monoidal]
theorem mul_leftUnitor {M : Mon_ C} :
    (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
      ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul := by
  rw [← Category.comp_id (λ_ (𝟙_ C)).hom, ← Category.id_comp M.mul, tensor_comp]
  slice_lhs 3 4 => rw [leftUnitor_naturality]
  slice_lhs 1 3 => rw [← leftUnitor_monoidal]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul = ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul

Next tactic:
simp only [Category.assoc, Category.id_comp]
theorem mul_rightUnitor {M : Mon_ C} :
    (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
      ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul := by
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul

Next tactic:
rw [← Category.id_comp M.mul, ← Category.comp_id (λ_ (𝟙_ C)).hom, tensor_comp]
theorem mul_rightUnitor {M : Mon_ C} :
    (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
      ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul := by
  rw [← Category.id_comp M.mul, ← Category.comp_id (λ_ (𝟙_ C)).hom, tensor_comp]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom) ≫ (M.mul ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ M.X).hom =
    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul

Next tactic:
slice_lhs 3 4 => rw [rightUnitor_naturality]
theorem mul_rightUnitor {M : Mon_ C} :
    (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
      ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul := by
  rw [← Category.id_comp M.mul, ← Category.comp_id (λ_ (𝟙_ C)).hom, tensor_comp]
  slice_lhs 3 4 => 

Proof state:
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| (M.mul ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ M.X).hom
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C)
case a.a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| 𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom

Next tactic:
rw [rightUnitor_naturality]
theorem mul_rightUnitor {M : Mon_ C} :
    (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
      ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul := by
  rw [← Category.id_comp M.mul, ← Category.comp_id (λ_ (𝟙_ C)).hom, tensor_comp]
  slice_lhs 3 4 => rw [rightUnitor_naturality]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom) ≫ (ρ_ (M.X ⊗ M.X)).hom ≫ M.mul =
    ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul

Next tactic:
slice_lhs 1 3 => rw [← rightUnitor_monoidal]
theorem mul_rightUnitor {M : Mon_ C} :
    (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
      ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul := by
  rw [← Category.id_comp M.mul, ← Category.comp_id (λ_ (𝟙_ C)).hom, tensor_comp]
  slice_lhs 3 4 => rw [rightUnitor_naturality]
  slice_lhs 1 3 => 

Proof state:
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
| tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (𝟙 (M.X ⊗ M.X) ⊗ (λ_ (𝟙_ C)).hom) ≫ (ρ_ (M.X ⊗ M.X)).hom
case a C : Type u₁ inst✝² : Category.{v₁, u₁} C inst✝¹ : MonoidalCategory C inst✝ : BraidedCategory C M : Mon_ C | M.mul

Next tactic:
rw [← rightUnitor_monoidal]
theorem mul_rightUnitor {M : Mon_ C} :
    (tensor_μ C (M.X, 𝟙_ C) (M.X, 𝟙_ C) ≫ (M.mul ⊗ (λ_ (𝟙_ C)).hom)) ≫ (ρ_ M.X).hom =
      ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul := by
  rw [← Category.id_comp M.mul, ← Category.comp_id (λ_ (𝟙_ C)).hom, tensor_comp]
  slice_lhs 3 4 => rw [rightUnitor_naturality]
  slice_lhs 1 3 => rw [← rightUnitor_monoidal]
  

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ M.mul = ((ρ_ M.X).hom ⊗ (ρ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul

Next tactic:
simp only [Category.assoc, Category.id_comp]
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) :=
  let tensorObj (M N : Mon_ C) : Mon_ C :=
    { X := M.X ⊗ N.X
      one := (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)
      mul := tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
      one_mul := Mon_tensor_one_mul M N
      mul_one := Mon_tensor_mul_one M N
      mul_assoc := Mon_tensor_mul_assoc M N }
  let tensorHom {X₁ Y₁ X₂ Y₂ : Mon_ C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
      tensorObj _ _ ⟶ tensorObj _ _ :=
    { hom := f.hom ⊗ g.hom
      one_hom := by
        

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
⊢ (tensorObj X₁ X₂).one ≫ (f.hom ⊗ g.hom) = (tensorObj Y₁ Y₂).one

Next tactic:
dsimp
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) :=
  let tensorObj (M N : Mon_ C) : Mon_ C :=
    { X := M.X ⊗ N.X
      one := (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)
      mul := tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
      one_mul := Mon_tensor_one_mul M N
      mul_one := Mon_tensor_mul_one M N
      mul_assoc := Mon_tensor_mul_assoc M N }
  let tensorHom {X₁ Y₁ X₂ Y₂ : Mon_ C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
      tensorObj _ _ ⟶ tensorObj _ _ :=
    { hom := f.hom ⊗ g.hom
      one_hom := by
        dsimp
        

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
⊢ ((λ_ (𝟙_ C)).inv ≫ (X₁.one ⊗ X₂.one)) ≫ (f.hom ⊗ g.hom) = (λ_ (𝟙_ C)).inv ≫ (Y₁.one ⊗ Y₂.one)

Next tactic:
slice_lhs 2 3 => rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) :=
  let tensorObj (M N : Mon_ C) : Mon_ C :=
    { X := M.X ⊗ N.X
      one := (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)
      mul := tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
      one_mul := Mon_tensor_one_mul M N
      mul_one := Mon_tensor_mul_one M N
      mul_assoc := Mon_tensor_mul_assoc M N }
  let tensorHom {X₁ Y₁ X₂ Y₂ : Mon_ C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
      tensorObj _ _ ⟶ tensorObj _ _ :=
    { hom := f.hom ⊗ g.hom
      one_hom := by
        dsimp
        slice_lhs 2 3 => 

Proof state:
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
| (X₁.one ⊗ X₂.one) ≫ (f.hom ⊗ g.hom)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
| (λ_ (𝟙_ C)).inv

Next tactic:
rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) :=
  let tensorObj (M N : Mon_ C) : Mon_ C :=
    { X := M.X ⊗ N.X
      one := (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)
      mul := tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
      one_mul := Mon_tensor_one_mul M N
      mul_one := Mon_tensor_mul_one M N
      mul_assoc := Mon_tensor_mul_assoc M N }
  let tensorHom {X₁ Y₁ X₂ Y₂ : Mon_ C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
      tensorObj _ _ ⟶ tensorObj _ _ :=
    { hom := f.hom ⊗ g.hom
      one_hom := by
        dsimp
        slice_lhs 2 3 => rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
      mul_hom := by
        

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
⊢ (tensorObj X₁ X₂).mul ≫ (f.hom ⊗ g.hom) = ((f.hom ⊗ g.hom) ⊗ f.hom ⊗ g.hom) ≫ (tensorObj Y₁ Y₂).mul

Next tactic:
dsimp
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) :=
  let tensorObj (M N : Mon_ C) : Mon_ C :=
    { X := M.X ⊗ N.X
      one := (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)
      mul := tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
      one_mul := Mon_tensor_one_mul M N
      mul_one := Mon_tensor_mul_one M N
      mul_assoc := Mon_tensor_mul_assoc M N }
  let tensorHom {X₁ Y₁ X₂ Y₂ : Mon_ C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
      tensorObj _ _ ⟶ tensorObj _ _ :=
    { hom := f.hom ⊗ g.hom
      one_hom := by
        dsimp
        slice_lhs 2 3 => rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
      mul_hom := by
        dsimp
        

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
⊢ (tensor_μ C (X₁.X, X₂.X) (X₁.X, X₂.X) ≫ (X₁.mul ⊗ X₂.mul)) ≫ (f.hom ⊗ g.hom) =
    ((f.hom ⊗ g.hom) ⊗ f.hom ⊗ g.hom) ≫ tensor_μ C (Y₁.X, Y₂.X) (Y₁.X, Y₂.X) ≫ (Y₁.mul ⊗ Y₂.mul)

Next tactic:
slice_rhs 1 2 => rw [tensor_μ_natural]
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) :=
  let tensorObj (M N : Mon_ C) : Mon_ C :=
    { X := M.X ⊗ N.X
      one := (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)
      mul := tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
      one_mul := Mon_tensor_one_mul M N
      mul_one := Mon_tensor_mul_one M N
      mul_assoc := Mon_tensor_mul_assoc M N }
  let tensorHom {X₁ Y₁ X₂ Y₂ : Mon_ C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
      tensorObj _ _ ⟶ tensorObj _ _ :=
    { hom := f.hom ⊗ g.hom
      one_hom := by
        dsimp
        slice_lhs 2 3 => rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
      mul_hom := by
        dsimp
        slice_rhs 1 2 => 

Proof state:
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
| ((f.hom ⊗ g.hom) ⊗ f.hom ⊗ g.hom) ≫ tensor_μ C (Y₁.X, Y₂.X) (Y₁.X, Y₂.X)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
| Y₁.mul ⊗ Y₂.mul

Next tactic:
rw [tensor_μ_natural]
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) :=
  let tensorObj (M N : Mon_ C) : Mon_ C :=
    { X := M.X ⊗ N.X
      one := (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)
      mul := tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
      one_mul := Mon_tensor_one_mul M N
      mul_one := Mon_tensor_mul_one M N
      mul_assoc := Mon_tensor_mul_assoc M N }
  let tensorHom {X₁ Y₁ X₂ Y₂ : Mon_ C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
      tensorObj _ _ ⟶ tensorObj _ _ :=
    { hom := f.hom ⊗ g.hom
      one_hom := by
        dsimp
        slice_lhs 2 3 => rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
      mul_hom := by
        dsimp
        slice_rhs 1 2 => rw [tensor_μ_natural]
        

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
⊢ (tensor_μ C (X₁.X, X₂.X) (X₁.X, X₂.X) ≫ (X₁.mul ⊗ X₂.mul)) ≫ (f.hom ⊗ g.hom) =
    (tensor_μ C (X₁.X, X₂.X) (X₁.X, X₂.X) ≫ ((f.hom ⊗ f.hom) ⊗ g.hom ⊗ g.hom)) ≫ (Y₁.mul ⊗ Y₂.mul)

Next tactic:
slice_lhs 2 3 => rw [← tensor_comp, Hom.mul_hom f, Hom.mul_hom g, tensor_comp]
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) :=
  let tensorObj (M N : Mon_ C) : Mon_ C :=
    { X := M.X ⊗ N.X
      one := (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)
      mul := tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
      one_mul := Mon_tensor_one_mul M N
      mul_one := Mon_tensor_mul_one M N
      mul_assoc := Mon_tensor_mul_assoc M N }
  let tensorHom {X₁ Y₁ X₂ Y₂ : Mon_ C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
      tensorObj _ _ ⟶ tensorObj _ _ :=
    { hom := f.hom ⊗ g.hom
      one_hom := by
        dsimp
        slice_lhs 2 3 => rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
      mul_hom := by
        dsimp
        slice_rhs 1 2 => rw [tensor_μ_natural]
        slice_lhs 2 3 => 

Proof state:
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
| (X₁.mul ⊗ X₂.mul) ≫ (f.hom ⊗ g.hom)
case a
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
| tensor_μ C (X₁.X, X₂.X) (X₁.X, X₂.X)

Next tactic:
rw [← tensor_comp, Hom.mul_hom f, Hom.mul_hom g, tensor_comp]
instance monMonoidalStruct : MonoidalCategoryStruct (Mon_ C) :=
  let tensorObj (M N : Mon_ C) : Mon_ C :=
    { X := M.X ⊗ N.X
      one := (λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)
      mul := tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul)
      one_mul := Mon_tensor_one_mul M N
      mul_one := Mon_tensor_mul_one M N
      mul_assoc := Mon_tensor_mul_assoc M N }
  let tensorHom {X₁ Y₁ X₂ Y₂ : Mon_ C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) :
      tensorObj _ _ ⟶ tensorObj _ _ :=
    { hom := f.hom ⊗ g.hom
      one_hom := by
        dsimp
        slice_lhs 2 3 => rw [← tensor_comp, Hom.one_hom f, Hom.one_hom g]
      mul_hom := by
        dsimp
        slice_rhs 1 2 => rw [tensor_μ_natural]
        slice_lhs 2 3 => rw [← tensor_comp, Hom.mul_hom f, Hom.mul_hom g, tensor_comp]
        

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
tensorObj : Mon_ C → Mon_ C → Mon_ C :=
  fun M N => mk (M.X ⊗ N.X) ((λ_ (𝟙_ C)).inv ≫ (M.one ⊗ N.one)) (tensor_μ C (M.X, N.X) (M.X, N.X) ≫ (M.mul ⊗ N.mul))
X₁ Y₁ X₂ Y₂ : Mon_ C
f : X₁ ⟶ Y₁
g : X₂ ⟶ Y₂
⊢ tensor_μ C (X₁.X, X₂.X) (X₁.X, X₂.X) ≫ ((f.hom ⊗ f.hom) ⊗ g.hom ⊗ g.hom) ≫ (Y₁.mul ⊗ Y₂.mul) =
    (tensor_μ C (X₁.X, X₂.X) (X₁.X, X₂.X) ≫ ((f.hom ⊗ f.hom) ⊗ g.hom ⊗ g.hom)) ≫ (Y₁.mul ⊗ Y₂.mul)

Next tactic:
simp only [Category.assoc]
instance monMonoidal : MonoidalCategory (Mon_ C) := .ofTensorHom
  (tensor_id := by 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
⊢ ∀ (X₁ X₂ : Mon_ C), 𝟙 X₁ ⊗ 𝟙 X₂ = 𝟙 (X₁ ⊗ X₂)

Next tactic:
intros
instance monMonoidal : MonoidalCategory (Mon_ C) := .ofTensorHom
  (tensor_id := by intros; 

Proof state:
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ X₂✝ : Mon_ C
⊢ 𝟙 X₁✝ ⊗ 𝟙 X₂✝ = 𝟙 (X₁✝ ⊗ X₂✝)

Next tactic:
ext
instance monMonoidal : MonoidalCategory (Mon_ C) := .ofTensorHom
  (tensor_id := by intros; ext; 

Proof state:
case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X₁✝ X₂✝ : Mon_ C
⊢ (𝟙 X₁✝ ⊗ 𝟙 X₂✝).hom = (𝟙 (X₁✝ ⊗ X₂✝)).hom

Next tactic:
apply tensor_id