Theorem: CategoryTheory.Limits.limitLaxMonoidal_μ
File: Mathlib/CategoryTheory/Monoidal/Limits.lean

Proof steps:
state_before: J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
F G : J ⥤ C
j j' : J
f : j ⟶ j'
⊢ ((Functor.const J).obj (limit F ⊗ limit G)).map f ≫ (fun j => limit.π F j ⊗ limit.π G j) j' =
    (fun j => limit.π F j ⊗ limit.π G j) j ≫ (F ⊗ G).map f
state_after: J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
F G : J ⥤ C
j j' : J
f : j ⟶ j'
⊢ 𝟙 (limit F ⊗ limit G) ≫ (limit.π F j' ⊗ limit.π G j') = (limit.π F j ⊗ limit.π G j) ≫ (F.map f ⊗ G.map f)
tactic: dsimp
state_before: J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
F G : J ⥤ C
j j' : J
f : j ⟶ j'
⊢ 𝟙 (limit F ⊗ limit G) ≫ (limit.π F j' ⊗ limit.π G j') = (limit.π F j ⊗ limit.π G j) ≫ (F.map f ⊗ G.map f)
state_after: no goals
tactic: simp only [Category.id_comp, ← tensor_comp, limit.w]
state_before: J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X✝ Y✝ X'✝ Y'✝ : J ⥤ C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
⊢ (map (fun F => limit F) f ⊗ map (fun F => limit F) g) ≫
      (fun F G =>
          limit.lift (F ⊗ G)
            { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
        Y✝ Y'✝ =
    (fun F G =>
          limit.lift (F ⊗ G)
            { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
        X✝ X'✝ ≫
      map (fun F => limit F) (f ⊗ g)
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X✝ Y✝ X'✝ Y'✝ : J ⥤ C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
j✝ : J
⊢ ((map (fun F => limit F) f ⊗ map (fun F => limit F) g) ≫
        (fun F G =>
            limit.lift (F ⊗ G)
              { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
          Y✝ Y'✝) ≫
      limit.π (Y✝ ⊗ Y'✝) j✝ =
    ((fun F G =>
            limit.lift (F ⊗ G)
              { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
          X✝ X'✝ ≫
        map (fun F => limit F) (f ⊗ g)) ≫
      limit.π (Y✝ ⊗ Y'✝) j✝
tactic: ext
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X✝ Y✝ X'✝ Y'✝ : J ⥤ C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
j✝ : J
⊢ ((map (fun F => limit F) f ⊗ map (fun F => limit F) g) ≫
        (fun F G =>
            limit.lift (F ⊗ G)
              { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
          Y✝ Y'✝) ≫
      limit.π (Y✝ ⊗ Y'✝) j✝ =
    ((fun F G =>
            limit.lift (F ⊗ G)
              { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
          X✝ X'✝ ≫
        map (fun F => limit F) (f ⊗ g)) ≫
      limit.π (Y✝ ⊗ Y'✝) j✝
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X✝ Y✝ X'✝ Y'✝ : J ⥤ C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
j✝ : J
⊢ ((limMap f ⊗ limMap g) ≫
        limit.lift (Y✝ ⊗ Y'✝)
          { pt := limit Y✝ ⊗ limit Y'✝, π := { app := fun j => limit.π Y✝ j ⊗ limit.π Y'✝ j, naturality := ⋯ } }) ≫
      limit.π (Y✝ ⊗ Y'✝) j✝ =
    (limit.lift (X✝ ⊗ X'✝)
          { pt := limit X✝ ⊗ limit X'✝, π := { app := fun j => limit.π X✝ j ⊗ limit.π X'✝ j, naturality := ⋯ } } ≫
        limMap (f ⊗ g)) ≫
      limit.π (Y✝ ⊗ Y'✝) j✝
tactic: dsimp
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X✝ Y✝ X'✝ Y'✝ : J ⥤ C
f : X✝ ⟶ Y✝
g : X'✝ ⟶ Y'✝
j✝ : J
⊢ ((limMap f ⊗ limMap g) ≫
        limit.lift (Y✝ ⊗ Y'✝)
          { pt := limit Y✝ ⊗ limit Y'✝, π := { app := fun j => limit.π Y✝ j ⊗ limit.π Y'✝ j, naturality := ⋯ } }) ≫
      limit.π (Y✝ ⊗ Y'✝) j✝ =
    (limit.lift (X✝ ⊗ X'✝)
          { pt := limit X✝ ⊗ limit X'✝, π := { app := fun j => limit.π X✝ j ⊗ limit.π X'✝ j, naturality := ⋯ } } ≫
        limMap (f ⊗ g)) ≫
      limit.π (Y✝ ⊗ Y'✝) j✝
state_after: no goals
tactic: simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.tensorHom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc, ← tensor_comp, limMap_π]
state_before: J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
⊢ ((fun F G =>
            limit.lift (F ⊗ G)
              { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
          X Y ⊗
        𝟙 (limit Z)) ≫
      (fun F G =>
            limit.lift (F ⊗ G)
              { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
          (X ⊗ Y) Z ≫
        map (fun F => limit F) (α_ X Y Z).hom =
    (α_ (limit X) (limit Y) (limit Z)).hom ≫
      (𝟙 (limit X) ⊗
          (fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            Y Z) ≫
        (fun F G =>
            limit.lift (F ⊗ G)
              { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
          X (Y ⊗ Z)
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (((fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            X Y ⊗
          𝟙 (limit Z)) ≫
        (fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            (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, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
              Y Z) ≫
          (fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            X (Y ⊗ Z)) ≫
      limit.π (X ⊗ Y ⊗ Z) j
tactic: ext j
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (((fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            X Y ⊗
          𝟙 (limit Z)) ≫
        (fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            (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, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
              Y Z) ≫
          (fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            X (Y ⊗ Z)) ≫
      limit.π (X ⊗ Y ⊗ Z) j
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ ((limit.lift (X ⊗ Y)
            { pt := limit X ⊗ limit Y, π := { app := fun j => limit.π X j ⊗ limit.π Y j, naturality := ⋯ } } ⊗
          𝟙 (limit Z)) ≫
        limit.lift ((X ⊗ Y) ⊗ Z)
            { pt := limit (X ⊗ Y) ⊗ limit Z,
              π := { app := fun j => limit.π (X ⊗ Y) j ⊗ limit.π Z j, naturality := ⋯ } } ≫
          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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
          limit.lift (X ⊗ Y ⊗ Z)
            { pt := limit X ⊗ limit (Y ⊗ Z),
              π := { app := fun j => limit.π X j ⊗ limit.π (Y ⊗ Z) j, naturality := ⋯ } }) ≫
      limit.π (X ⊗ Y ⊗ Z) j
tactic: dsimp
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ ((limit.lift (X ⊗ Y)
            { pt := limit X ⊗ limit Y, π := { app := fun j => limit.π X j ⊗ limit.π Y j, naturality := ⋯ } } ⊗
          𝟙 (limit Z)) ≫
        limit.lift ((X ⊗ Y) ⊗ Z)
            { pt := limit (X ⊗ Y) ⊗ limit Z,
              π := { app := fun j => limit.π (X ⊗ Y) j ⊗ limit.π Z j, naturality := ⋯ } } ≫
          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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
          limit.lift (X ⊗ Y ⊗ Z)
            { pt := limit X ⊗ limit (Y ⊗ Z),
              π := { app := fun j => limit.π X j ⊗ limit.π (Y ⊗ Z) j, naturality := ⋯ } }) ≫
      limit.π (X ⊗ Y ⊗ Z) j
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (limit.lift (X ⊗ Y) { pt := limit X ⊗ limit Y, π := { app := fun j => limit.π X j ⊗ limit.π Y j, naturality := ⋯ } } ⊗
        𝟙 (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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)
tactic: simp only [limit.lift_π, Cones.postcompose_obj_π, Monoidal.associator_hom_app, limit.lift_map,
      NatTrans.comp_app, Category.assoc]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (limit.lift (X ⊗ Y) { pt := limit X ⊗ limit Y, π := { app := fun j => limit.π X j ⊗ limit.π Y j, naturality := ⋯ } } ⊗
        𝟙 (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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (limit.lift (X ⊗ Y) { pt := limit X ⊗ limit Y, π := { app := fun j => limit.π X j ⊗ limit.π Y j, naturality := ⋯ } } ⊗
        𝟙 (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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)
tactic: slice_lhs 2 2 => rw [← tensor_id_comp_id_tensor]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X Y Z : J ⥤ C
j : J
⊢ (limit.lift (X ⊗ Y) { pt := limit X ⊗ limit Y, π := { app := fun j => limit.π X j ⊗ limit.π Y j, naturality := ⋯ } } ⊗
        𝟙 (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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)
tactic: slice_lhs 1 2 =>
      rw [← comp_tensor_id, limit.lift_π]
      dsimp
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)
tactic: slice_lhs 1 2 => rw [tensor_id_comp_id_tensor]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)
tactic: conv_lhs => rw [associator_naturality]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (limit.π X j ⊗ limit.π (Y ⊗ Z) j)
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (𝟙 (limit X) ⊗ limit.π (Y ⊗ Z) j) ≫ (limit.π X j ⊗ 𝟙 ((Y ⊗ Z).obj j))
tactic: conv_rhs => rw [← id_tensor_comp_tensor_id (limit.π (Y ⊗ Z) j)]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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, π := { app := fun j => limit.π Y j ⊗ limit.π Z j, naturality := ⋯ } }) ≫
        (𝟙 (limit X) ⊗ limit.π (Y ⊗ Z) j) ≫ (limit.π X j ⊗ 𝟙 ((Y ⊗ Z).obj j))
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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.π Y j ⊗ limit.π Z j) ≫ (limit.π X j ⊗ 𝟙 ((Y ⊗ Z).obj j))
tactic: slice_rhs 2 3 =>
      rw [← id_tensor_comp, limit.lift_π]
      dsimp
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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.π Y j ⊗ limit.π Z j) ≫ (limit.π X j ⊗ 𝟙 ((Y ⊗ Z).obj j))
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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.π Y j ⊗ limit.π Z j) ≫ (limit.π X j ⊗ 𝟙 (Y.obj j ⊗ Z.obj j))
tactic: dsimp
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J 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.π Y j ⊗ limit.π Z j) ≫ (limit.π X j ⊗ 𝟙 (Y.obj j ⊗ Z.obj j))
state_after: no goals
tactic: rw [id_tensor_comp_tensor_id]
state_before: J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
⊢ (λ_ (limit X)).hom =
    (limit.lift ((Functor.const J).obj (𝟙_ C))
          { pt := 𝟙_ C, π := { app := fun j => 𝟙 (((Functor.const J).obj (𝟙_ C)).obj j), naturality := ⋯ } } ⊗
        𝟙 (limit X)) ≫
      (fun F G =>
            limit.lift (F ⊗ G)
              { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
          (𝟙_ (J ⥤ C)) X ≫
        map (fun F => limit F) (λ_ X).hom
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j =
    ((limit.lift ((Functor.const J).obj (𝟙_ C))
            { pt := 𝟙_ C, π := { app := fun j => 𝟙 (((Functor.const J).obj (𝟙_ C)).obj j), naturality := ⋯ } } ⊗
          𝟙 (limit X)) ≫
        (fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            (𝟙_ (J ⥤ C)) X ≫
          map (fun F => limit F) (λ_ X).hom) ≫
      limit.π X j
tactic: ext j
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j =
    ((limit.lift ((Functor.const J).obj (𝟙_ C))
            { pt := 𝟙_ C, π := { app := fun j => 𝟙 (((Functor.const J).obj (𝟙_ C)).obj j), naturality := ⋯ } } ⊗
          𝟙 (limit X)) ≫
        (fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            (𝟙_ (J ⥤ C)) X ≫
          map (fun F => limit F) (λ_ X).hom) ≫
      limit.π X j
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j =
    ((limit.lift ((Functor.const J).obj (𝟙_ C)) { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } } ⊗
          𝟙 (limit X)) ≫
        limit.lift (𝟙_ (J ⥤ C) ⊗ X)
            { pt := limit (𝟙_ (J ⥤ C)) ⊗ limit X,
              π := { app := fun j => limit.π (𝟙_ (J ⥤ C)) j ⊗ limit.π X j, naturality := ⋯ } } ≫
          limMap (λ_ X).hom) ≫
      limit.π X j
tactic: dsimp
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j =
    ((limit.lift ((Functor.const J).obj (𝟙_ C)) { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } } ⊗
          𝟙 (limit X)) ≫
        limit.lift (𝟙_ (J ⥤ C) ⊗ X)
            { pt := limit (𝟙_ (J ⥤ C)) ⊗ limit X,
              π := { app := fun j => limit.π (𝟙_ (J ⥤ C)) j ⊗ limit.π X j, naturality := ⋯ } } ≫
          limMap (λ_ X).hom) ≫
      limit.π X j
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j =
    (limit.lift ((Functor.const J).obj (𝟙_ C)) { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } } ⊗
        𝟙 (limit X)) ≫
      (limit.π (𝟙_ (J ⥤ C)) j ⊗ limit.π X j) ≫ (λ_ (X.obj j)).hom
tactic: simp only [limit.lift_map, Category.assoc, limit.lift_π, Cones.postcompose_obj_pt,
      Cones.postcompose_obj_π, NatTrans.comp_app, Functor.const_obj_obj, Monoidal.tensorObj_obj,
      Monoidal.tensorUnit_obj, Monoidal.leftUnitor_hom_app]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j =
    (limit.lift ((Functor.const J).obj (𝟙_ C)) { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } } ⊗
        𝟙 (limit X)) ≫
      (limit.π (𝟙_ (J ⥤ C)) j ⊗ limit.π X j) ≫ (λ_ (X.obj j)).hom
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j =
    (limit.lift ((Functor.const J).obj (𝟙_ C)) { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } } ⊗
        𝟙 (limit X)) ≫
      ((limit.π (𝟙_ (J ⥤ C)) j ⊗ 𝟙 (limit X)) ≫ (𝟙 (𝟙_ C) ⊗ limit.π X j)) ≫ (λ_ (X.obj j)).hom
tactic: conv_rhs => rw [← tensor_id_comp_id_tensor (limit.π X j)]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j =
    (limit.lift ((Functor.const J).obj (𝟙_ C)) { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } } ⊗
        𝟙 (limit X)) ≫
      ((limit.π (𝟙_ (J ⥤ C)) j ⊗ 𝟙 (limit X)) ≫ (𝟙 (𝟙_ C) ⊗ limit.π X j)) ≫ (λ_ (X.obj j)).hom
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j = ((𝟙 (𝟙_ C) ⊗ 𝟙 (limit X)) ≫ (𝟙 (𝟙_ C) ⊗ limit.π X j)) ≫ (λ_ (X.obj j)).hom
tactic: slice_rhs 1 2 =>
      rw [← comp_tensor_id]
      erw [limit.lift_π]
      dsimp
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j = ((𝟙 (𝟙_ C) ⊗ 𝟙 (limit X)) ≫ (𝟙 (𝟙_ C) ⊗ limit.π X j)) ≫ (λ_ (X.obj j)).hom
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j = (𝟙 (𝟙_ C) ⊗ 𝟙 (limit X)) ≫ (λ_ (limit X)).hom ≫ limit.π X j
tactic: slice_rhs 2 3 => rw [id_tensorHom, leftUnitor_naturality]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (λ_ (limit X)).hom ≫ limit.π X j = (𝟙 (𝟙_ C) ⊗ 𝟙 (limit X)) ≫ (λ_ (limit X)).hom ≫ limit.π X j
state_after: no goals
tactic: simp
state_before: J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
⊢ (ρ_ (limit X)).hom =
    (𝟙 (limit X) ⊗
        limit.lift ((Functor.const J).obj (𝟙_ C))
          { pt := 𝟙_ C, π := { app := fun j => 𝟙 (((Functor.const J).obj (𝟙_ C)).obj j), naturality := ⋯ } }) ≫
      (fun F G =>
            limit.lift (F ⊗ G)
              { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
          X (𝟙_ (J ⥤ C)) ≫
        map (fun F => limit F) (ρ_ X).hom
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j =
    ((𝟙 (limit X) ⊗
          limit.lift ((Functor.const J).obj (𝟙_ C))
            { pt := 𝟙_ C, π := { app := fun j => 𝟙 (((Functor.const J).obj (𝟙_ C)).obj j), naturality := ⋯ } }) ≫
        (fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            X (𝟙_ (J ⥤ C)) ≫
          map (fun F => limit F) (ρ_ X).hom) ≫
      limit.π X j
tactic: ext j
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j =
    ((𝟙 (limit X) ⊗
          limit.lift ((Functor.const J).obj (𝟙_ C))
            { pt := 𝟙_ C, π := { app := fun j => 𝟙 (((Functor.const J).obj (𝟙_ C)).obj j), naturality := ⋯ } }) ≫
        (fun F G =>
              limit.lift (F ⊗ G)
                { pt := limit F ⊗ limit G, π := { app := fun j => limit.π F j ⊗ limit.π G j, naturality := ⋯ } })
            X (𝟙_ (J ⥤ C)) ≫
          map (fun F => limit F) (ρ_ X).hom) ≫
      limit.π X j
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j =
    ((𝟙 (limit X) ⊗
          limit.lift ((Functor.const J).obj (𝟙_ C))
            { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } }) ≫
        limit.lift (X ⊗ 𝟙_ (J ⥤ C))
            { pt := limit X ⊗ limit (𝟙_ (J ⥤ C)),
              π := { app := fun j => limit.π X j ⊗ limit.π (𝟙_ (J ⥤ C)) j, naturality := ⋯ } } ≫
          limMap (ρ_ X).hom) ≫
      limit.π X j
tactic: dsimp
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j =
    ((𝟙 (limit X) ⊗
          limit.lift ((Functor.const J).obj (𝟙_ C))
            { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } }) ≫
        limit.lift (X ⊗ 𝟙_ (J ⥤ C))
            { pt := limit X ⊗ limit (𝟙_ (J ⥤ C)),
              π := { app := fun j => limit.π X j ⊗ limit.π (𝟙_ (J ⥤ C)) j, naturality := ⋯ } } ≫
          limMap (ρ_ X).hom) ≫
      limit.π X j
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j =
    (𝟙 (limit X) ⊗
        limit.lift ((Functor.const J).obj (𝟙_ C)) { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } }) ≫
      (limit.π X j ⊗ limit.π (𝟙_ (J ⥤ C)) j) ≫ (ρ_ (X.obj j)).hom
tactic: simp only [limit.lift_map, Category.assoc, limit.lift_π, Cones.postcompose_obj_pt,
      Cones.postcompose_obj_π, NatTrans.comp_app, Functor.const_obj_obj, Monoidal.tensorObj_obj,
      Monoidal.tensorUnit_obj, Monoidal.rightUnitor_hom_app]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j =
    (𝟙 (limit X) ⊗
        limit.lift ((Functor.const J).obj (𝟙_ C)) { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } }) ≫
      (limit.π X j ⊗ limit.π (𝟙_ (J ⥤ C)) j) ≫ (ρ_ (X.obj j)).hom
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j =
    (𝟙 (limit X) ⊗
        limit.lift ((Functor.const J).obj (𝟙_ C)) { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } }) ≫
      ((𝟙 (limit X) ⊗ limit.π (𝟙_ (J ⥤ C)) j) ≫ (limit.π X j ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ (X.obj j)).hom
tactic: conv_rhs => rw [← id_tensor_comp_tensor_id _ (limit.π X j)]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j =
    (𝟙 (limit X) ⊗
        limit.lift ((Functor.const J).obj (𝟙_ C)) { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } }) ≫
      ((𝟙 (limit X) ⊗ limit.π (𝟙_ (J ⥤ C)) j) ≫ (limit.π X j ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ (X.obj j)).hom
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j = ((𝟙 (limit X) ⊗ 𝟙 (𝟙_ C)) ≫ (limit.π X j ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ (X.obj j)).hom
tactic: slice_rhs 1 2 =>
      rw [← id_tensor_comp]
      erw [limit.lift_π]
      dsimp
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j = ((𝟙 (limit X) ⊗ 𝟙 (𝟙_ C)) ≫ (limit.π X j ⊗ 𝟙 (𝟙_ C))) ≫ (ρ_ (X.obj j)).hom
state_after: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j = (𝟙 (limit X) ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ (limit X)).hom ≫ limit.π X j
tactic: slice_rhs 2 3 => rw [tensorHom_id, rightUnitor_naturality]
state_before: case w
J : Type w
inst✝³ : SmallCategory J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasLimitsOfShape J C
inst✝ : MonoidalCategory C
X : J ⥤ C
j : J
⊢ (ρ_ (limit X)).hom ≫ limit.π X j = (𝟙 (limit X) ⊗ 𝟙 (𝟙_ C)) ≫ (ρ_ (limit X)).hom ≫ limit.π X j
state_after: no goals
tactic: simp