l3lab/ntp-mathlib huggingface dataset:
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; 

Proof state:
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (((fun F G => limit.lift (F ⊗ G) { pt := limit F ⊗ limit G, π := NatTrans.mk fun j => limit.π F j ⊗ limit.π G j }) X
            Y ⊗
          𝟙 (limit Z)) ≫
        (fun F G => limit.lift (F ⊗ G) { pt := limit F ⊗ limit G, π := NatTrans.mk fun j => limit.π F j ⊗ limit.π G j })
            (X ⊗ Y) Z ≫
          map (fun F => limit F) (α_ X Y Z).hom) ≫
      limit.π (X ⊗ Y ⊗ Z) j =
    ((α_ (limit X) (limit Y) (limit Z)).hom ≫
        (𝟙 (limit X) ⊗
            (fun F G =>
                limit.lift (F ⊗ G) { pt := limit F ⊗ limit G, π := NatTrans.mk fun j => limit.π F j ⊗ limit.π G j })
              Y Z) ≫
          (fun F G =>
              limit.lift (F ⊗ G) { pt := limit F ⊗ limit G, π := NatTrans.mk fun j => limit.π F j ⊗ limit.π G j })
            X (Y ⊗ Z)) ≫
      limit.π (X ⊗ Y ⊗ Z) j

Next tactic:
dsimp
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    

Proof state:
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ ((limit.lift (X ⊗ Y) { pt := limit X ⊗ limit Y, π := NatTrans.mk fun j => limit.π X j ⊗ limit.π Y j } ⊗ 𝟙 (limit Z)) ≫
        limit.lift ((X ⊗ Y) ⊗ Z)
            { pt := limit (X ⊗ Y) ⊗ limit Z, π := NatTrans.mk fun j => limit.π (X ⊗ Y) j ⊗ limit.π Z j } ≫
          limMap (α_ X Y Z).hom) ≫
      limit.π (X ⊗ Y ⊗ Z) j =
    ((α_ (limit X) (limit Y) (limit Z)).hom ≫
        (𝟙 (limit X) ⊗
            limit.lift (Y ⊗ Z) { pt := limit Y ⊗ limit Z, π := NatTrans.mk fun j => limit.π Y j ⊗ limit.π Z j }) ≫
          limit.lift (X ⊗ Y ⊗ Z)
            { pt := limit X ⊗ limit (Y ⊗ Z), π := NatTrans.mk fun j => limit.π X j ⊗ limit.π (Y ⊗ Z) j }) ≫
      limit.π (X ⊗ Y ⊗ Z) j

Next tactic:
simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    

Proof state:
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (limit.lift (X ⊗ Y) { pt := limit X ⊗ limit Y, π := NatTrans.mk fun j => limit.π X j ⊗ limit.π Y j } ⊗ 𝟙 (limit Z)) ≫
      (limit.π (X ⊗ Y) j ⊗ limit.π Z j) ≫ (α_ (X.obj j) (Y.obj j) (Z.obj j)).hom =
    (α_ (limit X) (limit Y) (limit Z)).hom ≫
      (𝟙 (limit X) ⊗
          limit.lift (Y ⊗ Z) { pt := limit Y ⊗ limit Z, π := NatTrans.mk fun j => limit.π Y j ⊗ limit.π Z j }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)

Next tactic:
slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => 

Proof state:
case a.a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| limit.π (X ⊗ Y) j ⊗ limit.π Z j
case a.a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| (α_ (X.obj j) (Y.obj j) (Z.obj j)).hom
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| limit.lift (X ⊗ Y) { pt := limit X ⊗ limit Y, π := NatTrans.mk fun j => limit.π X j ⊗ limit.π Y j } ⊗ 𝟙 (limit Z)

Next tactic:
rw [← tensor_id_comp_id_tensor]
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    

Proof state:
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (limit.lift (X ⊗ Y) { pt := limit X ⊗ limit Y, π := NatTrans.mk fun j => limit.π X j ⊗ limit.π Y j } ⊗ 𝟙 (limit Z)) ≫
      ((limit.π (X ⊗ Y) j ⊗ 𝟙 (limit Z)) ≫ (𝟙 (X.obj j ⊗ Y.obj j) ⊗ limit.π Z j)) ≫
        (α_ (X.obj j) (Y.obj j) (Z.obj j)).hom =
    (α_ (limit X) (limit Y) (limit Z)).hom ≫
      (𝟙 (limit X) ⊗
          limit.lift (Y ⊗ Z) { pt := limit Y ⊗ limit Z, π := NatTrans.mk fun j => limit.π Y j ⊗ limit.π Z j }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)

Next tactic:
slice_lhs 1 2 =>
      rw [← comp_tensor_id, limit.lift_π]
      dsimp
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    slice_lhs 1 2 =>
      

Proof state:
case a.a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| (limit.lift (X ⊗ Y) { pt := limit X ⊗ limit Y, π := NatTrans.mk fun j => limit.π X j ⊗ limit.π Y j } ⊗ 𝟙 (limit Z)) ≫
    (limit.π (X ⊗ Y) j ⊗ 𝟙 (limit Z))
case a.a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| 𝟙 (X.obj j ⊗ Y.obj j) ⊗ limit.π Z j
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| (α_ (X.obj j) (Y.obj j) (Z.obj j)).hom

Next tactic:
rw [← comp_tensor_id, limit.lift_π]
      dsimp
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    slice_lhs 1 2 =>
      

Proof state:
case a.a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| (limit.lift (X ⊗ Y) { pt := limit X ⊗ limit Y, π := NatTrans.mk fun j => limit.π X j ⊗ limit.π Y j } ⊗ 𝟙 (limit Z)) ≫
    (limit.π (X ⊗ Y) j ⊗ 𝟙 (limit Z))
case a.a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| 𝟙 (X.obj j ⊗ Y.obj j) ⊗ limit.π Z j
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| (α_ (X.obj j) (Y.obj j) (Z.obj j)).hom

Next tactic:
rw [← comp_tensor_id, limit.lift_π]
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    slice_lhs 1 2 =>
      rw [← comp_tensor_id, limit.lift_π]
      

Proof state:
case a.a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| { pt := limit X ⊗ limit Y, π := NatTrans.mk fun j => limit.π X j ⊗ limit.π Y j }.π.app j ⊗ 𝟙 (limit Z)
case a.a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| 𝟙 (X.obj j ⊗ Y.obj j) ⊗ limit.π Z j
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| (α_ (X.obj j) (Y.obj j) (Z.obj j)).hom

Next tactic:
dsimp
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    slice_lhs 1 2 =>
      rw [← comp_tensor_id, limit.lift_π]
      dsimp
    

Proof state:
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (((limit.π X j ⊗ limit.π Y j) ⊗ 𝟙 (limit Z)) ≫ (𝟙 (X.obj j ⊗ Y.obj j) ⊗ limit.π Z j)) ≫
      (α_ (X.obj j) (Y.obj j) (Z.obj j)).hom =
    (α_ (limit X) (limit Y) (limit Z)).hom ≫
      (𝟙 (limit X) ⊗
          limit.lift (Y ⊗ Z) { pt := limit Y ⊗ limit Z, π := NatTrans.mk fun j => limit.π Y j ⊗ limit.π Z j }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)

Next tactic:
slice_lhs 1 2 => rw [tensor_id_comp_id_tensor]
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    slice_lhs 1 2 =>
      rw [← comp_tensor_id, limit.lift_π]
      dsimp
    slice_lhs 1 2 => 

Proof state:
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| ((limit.π X j ⊗ limit.π Y j) ⊗ 𝟙 (limit Z)) ≫ (𝟙 (X.obj j ⊗ Y.obj j) ⊗ limit.π Z j)
case a
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| (α_ (X.obj j) (Y.obj j) (Z.obj j)).hom

Next tactic:
rw [tensor_id_comp_id_tensor]
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    slice_lhs 1 2 =>
      rw [← comp_tensor_id, limit.lift_π]
      dsimp
    slice_lhs 1 2 => rw [tensor_id_comp_id_tensor]
    

Proof state:
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ ((limit.π X j ⊗ limit.π Y j) ⊗ limit.π Z j) ≫ (α_ (X.obj j) (Y.obj j) (Z.obj j)).hom =
    (α_ (limit X) (limit Y) (limit Z)).hom ≫
      (𝟙 (limit X) ⊗
          limit.lift (Y ⊗ Z) { pt := limit Y ⊗ limit Z, π := NatTrans.mk fun j => limit.π Y j ⊗ limit.π Z j }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)

Next tactic:
conv_lhs => rw [associator_naturality]
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    slice_lhs 1 2 =>
      rw [← comp_tensor_id, limit.lift_π]
      dsimp
    slice_lhs 1 2 => rw [tensor_id_comp_id_tensor]
    conv_lhs => 

Proof state:
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| ((limit.π X j ⊗ limit.π Y j) ⊗ limit.π Z j) ≫ (α_ (X.obj j) (Y.obj j) (Z.obj j)).hom

Next tactic:
rw [associator_naturality]
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    slice_lhs 1 2 =>
      rw [← comp_tensor_id, limit.lift_π]
      dsimp
    slice_lhs 1 2 => rw [tensor_id_comp_id_tensor]
    conv_lhs => rw [associator_naturality]
    

Proof state:
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (α_ (limit X) (limit Y) (limit Z)).hom ≫ (limit.π X j ⊗ limit.π Y j ⊗ limit.π Z j) =
    (α_ (limit X) (limit Y) (limit Z)).hom ≫
      (𝟙 (limit X) ⊗
          limit.lift (Y ⊗ Z) { pt := limit Y ⊗ limit Z, π := NatTrans.mk fun j => limit.π Y j ⊗ limit.π Z j }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)

Next tactic:
conv_rhs => rw [← id_tensor_comp_tensor_id (limit.π (Y ⊗ Z) j)]
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    slice_lhs 1 2 =>
      rw [← comp_tensor_id, limit.lift_π]
      dsimp
    slice_lhs 1 2 => rw [tensor_id_comp_id_tensor]
    conv_lhs => rw [associator_naturality]
    conv_rhs => 

Proof state:
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
| (α_ (limit X) (limit Y) (limit Z)).hom ≫
    (𝟙 (limit X) ⊗
        limit.lift (Y ⊗ Z) { pt := limit Y ⊗ limit Z, π := NatTrans.mk fun j => limit.π Y j ⊗ limit.π Z j }) ≫
      (limit.π X j ⊗ limit.π (Y ⊗ Z) j)

Next tactic:
rw [← id_tensor_comp_tensor_id (limit.π (Y ⊗ Z) j)]
@[simps]
instance limitLaxMonoidal : LaxMonoidal fun F : J ⥤ C => limit F where
  ε :=
    limit.lift _
      { pt := _
        π := { app := fun j => 𝟙 _ } }
  μ F G :=
    limit.lift (F ⊗ G)
      { pt := limit F ⊗ limit G
        π :=
          { app := fun j => limit.π F j ⊗ limit.π G j
            naturality := fun j j' f => by
              dsimp
              simp only [Category.id_comp, ← tensor_comp, limit.w] } }
  μ_natural f g := by
    ext; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
  associativity X Y Z := by
    ext j; dsimp
    simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
    slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
    slice_lhs 1 2 =>
      rw [← comp_tensor_id, limit.lift_π]
      dsimp
    slice_lhs 1 2 => rw [tensor_id_comp_id_tensor]
    conv_lhs => rw [associator_naturality]
    conv_rhs => rw [← id_tensor_comp_tensor_id (limit.π (Y ⊗ Z) j)]
    

Proof state:
case w
J : Type v
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimits C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (α_ (limit X) (limit Y) (limit Z)).hom ≫ (limit.π X j ⊗ limit.π Y j ⊗ limit.π Z j) =
    (α_ (limit X) (limit Y) (limit Z)).hom ≫
      (𝟙 (limit X) ⊗
          limit.lift (Y ⊗ Z) { pt := limit Y ⊗ limit Z, π := NatTrans.mk fun j => limit.π Y j ⊗ limit.π Z j }) ≫
        (𝟙 (limit X) ⊗ limit.π (Y ⊗ Z) j) ≫ (limit.π X j ⊗ 𝟙 ((Y ⊗ Z).obj j))

Next tactic:
slice_rhs 2 3 =>
      rw [← id_tensor_comp, limit.lift_π]
      dsimp