/-- Auxiliary definition: the proposed cone is a limit cone. -/
def limitConeIsLimit (F : J ⥤ Cat.{v, v}) : IsLimit (limitCone F) where
  lift := limitConeLift F
  fac s j := CategoryTheory.Functor.ext (by simp) fun X Y f => by
    dsimp [limitConeLift]
    exact Types.Limit.π_mk.{v, v} _ _ _ _
  uniq s m w := by
    symm
    refine' CategoryTheory.Functor.ext _ _
    · intro X
      apply Types.limit_ext.{v, v}
      intro j
      simp [Types.Limit.lift_π_apply', ← w j]
    · intro X Y f
      dsimp
      

Proof state:
case refine'_2
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
m : s.pt ⟶ (limitCone F).pt
w : ∀ (j : J), m ≫ (limitCone F).π.app j = s.π.app j
X Y : ↑s.pt
f : X ⟶ Y
⊢ Types.Limit.mk
      (homDiagram (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X)
        (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
      (fun j =>
        eqToHom
            (_ :
              limit.π (F ⋙ objects) j
                  (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X) =
                (s.π.app j).obj X) ≫
          (s.π.app j).map f ≫
            eqToHom
              (_ :
                (s.π.app j).obj Y =
                  limit.π (F ⋙ objects) j
                    (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y)))
      (_ :
        ∀ (j j' : J) (h : j ⟶ j'),
          (homDiagram (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X)
                  (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y)).map
              h
              (eqToHom
                  (_ :
                    limit.π (F ⋙ objects) j
                        (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X) =
                      (s.π.app j).obj X) ≫
                (s.π.app j).map f ≫
                  eqToHom
                    (_ :
                      (s.π.app j).obj Y =
                        limit.π (F ⋙ objects) j
                          (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))) =
            eqToHom
                (_ :
                  limit.π (F ⋙ objects) j'
                      (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X) =
                    (s.π.app j').obj X) ≫
              (s.π.app j').map f ≫
                eqToHom
                  (_ :
                    (s.π.app j').obj Y =
                      limit.π (F ⋙ objects) j'
                        (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))) =
    Types.Limit.mk
      (homDiagram (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X)
        (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
      (fun j =>
        limit.π
            (homDiagram (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X)
              (m.obj X))
            j
            (eqToHom
              (_ : limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X = m.obj X)) ≫
          limit.π
            (homDiagram (m.obj X)
              (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
            j
            (Types.Limit.mk
              (homDiagram (m.obj X)
                (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
              (fun j =>
                limit.π (homDiagram (m.obj X) (m.obj Y)) j (m.map f) ≫
                  limit.π
                    (homDiagram (m.obj Y)
                      (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                    j
                    (eqToHom
                      (_ :
                        m.obj Y =
                          limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y)))
              (_ :
                ∀ (j j' : J) (h : j ⟶ j'),
                  eqToHom
                        (_ :
                          limit.π (F ⋙ objects) j' (m.obj X) =
                            (limit.π (F ⋙ objects) j ≫ (F ⋙ objects).map h) (m.obj X)) ≫
                      (F.map h).map
                          (limit.π (homDiagram (m.obj X) (m.obj Y)) j (m.map f) ≫
                            limit.π
                              (homDiagram (m.obj Y)
                                (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                              j
                              (eqToHom
                                (_ :
                                  m.obj Y =
                                    limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj }
                                      Y))) ≫
                        eqToHom
                          (_ :
                            (limit.π (F ⋙ objects) j ≫ (F ⋙ objects).map h)
                                (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj }
                                  Y) =
                              limit.π (F ⋙ objects) j'
                                (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj }
                                  Y)) =
                    limit.π (homDiagram (m.obj X) (m.obj Y)) j' (m.map f) ≫
                      limit.π
                        (homDiagram (m.obj Y)
                          (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                        j'
                        (eqToHom
                          (_ :
                            m.obj Y =
                              limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y)))))
      (_ :
        ∀ (j j' : J) (h : j ⟶ j'),
          eqToHom
                (_ :
                  limit.π (F ⋙ objects) j'
                      (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X) =
                    (limit.π (F ⋙ objects) j ≫ (F ⋙ objects).map h)
                      (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X)) ≫
              (F.map h).map
                  (limit.π
                      (homDiagram
                        (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X)
                        (m.obj X))
                      j
                      (eqToHom
                        (_ :
                          limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X =
                            m.obj X)) ≫
                    limit.π
                      (homDiagram (m.obj X)
                        (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                      j
                      (Types.Limit.mk
                        (homDiagram (m.obj X)
                          (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                        (fun j =>
                          limit.π (homDiagram (m.obj X) (m.obj Y)) j (m.map f) ≫
                            limit.π
                              (homDiagram (m.obj Y)
                                (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                              j
                              (eqToHom
                                (_ :
                                  m.obj Y =
                                    limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj }
                                      Y)))
                        (_ :
                          ∀ (j j' : J) (h : j ⟶ j'),
                            eqToHom
                                  (_ :
                                    limit.π (F ⋙ objects) j' (m.obj X) =
                                      (limit.π (F ⋙ objects) j ≫ (F ⋙ objects).map h) (m.obj X)) ≫
                                (F.map h).map
                                    (limit.π (homDiagram (m.obj X) (m.obj Y)) j (m.map f) ≫
                                      limit.π
                                        (homDiagram (m.obj Y)
                                          (limit.lift (F ⋙ objects)
                                            { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                                        j
                                        (eqToHom
                                          (_ :
                                            m.obj Y =
                                              limit.lift (F ⋙ objects)
                                                { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))) ≫
                                  eqToHom
                                    (_ :
                                      (limit.π (F ⋙ objects) j ≫ (F ⋙ objects).map h)
                                          (limit.lift (F ⋙ objects)
                                            { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y) =
                                        limit.π (F ⋙ objects) j'
                                          (limit.lift (F ⋙ objects)
                                            { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y)) =
                              limit.π (homDiagram (m.obj X) (m.obj Y)) j' (m.map f) ≫
                                limit.π
                                  (homDiagram (m.obj Y)
                                    (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj }
                                      Y))
                                  j'
                                  (eqToHom
                                    (_ :
                                      m.obj Y =
                                        limit.lift (F ⋙ objects)
                                          { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))))) ≫
                eqToHom
                  (_ :
                    (limit.π (F ⋙ objects) j ≫ (F ⋙ objects).map h)
                        (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y) =
                      limit.π (F ⋙ objects) j'
                        (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y)) =
            limit.π
                (homDiagram (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X)
                  (m.obj X))
                j'
                (eqToHom
                  (_ :
                    limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X = m.obj X)) ≫
              limit.π
                (homDiagram (m.obj X)
                  (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                j'
                (Types.Limit.mk
                  (homDiagram (m.obj X)
                    (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                  (fun j =>
                    limit.π (homDiagram (m.obj X) (m.obj Y)) j (m.map f) ≫
                      limit.π
                        (homDiagram (m.obj Y)
                          (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                        j
                        (eqToHom
                          (_ :
                            m.obj Y =
                              limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y)))
                  (_ :
                    ∀ (j j' : J) (h : j ⟶ j'),
                      eqToHom
                            (_ :
                              limit.π (F ⋙ objects) j' (m.obj X) =
                                (limit.π (F ⋙ objects) j ≫ (F ⋙ objects).map h) (m.obj X)) ≫
                          (F.map h).map
                              (limit.π (homDiagram (m.obj X) (m.obj Y)) j (m.map f) ≫
                                limit.π
                                  (homDiagram (m.obj Y)
                                    (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj }
                                      Y))
                                  j
                                  (eqToHom
                                    (_ :
                                      m.obj Y =
                                        limit.lift (F ⋙ objects)
                                          { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))) ≫
                            eqToHom
                              (_ :
                                (limit.π (F ⋙ objects) j ≫ (F ⋙ objects).map h)
                                    (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj }
                                      Y) =
                                  limit.π (F ⋙ objects) j'
                                    (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj }
                                      Y)) =
                        limit.π (homDiagram (m.obj X) (m.obj Y)) j' (m.map f) ≫
                          limit.π
                            (homDiagram (m.obj Y)
                              (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } Y))
                            j'
                            (eqToHom
                              (_ :
                                m.obj Y =
                                  limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj }
                                    Y)))))

Next tactic:
simp [fun j => Functor.congr_hom (w j).symm f]