l3lab/ntp-mathlib huggingface dataset:
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      

Proof state:
case x
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
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✝)).obj
    j

Next tactic:
refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _ <;> 

Proof state:
case x.refine'_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
j : J
⊢ 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✝

Next tactic:
simp
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _ <;> 

Proof state:
case x.refine'_2
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
j : 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✝)

Next tactic:
simp
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _ <;> simp
    · 

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
⊢ ∀ (j j' : J) (f_1 : 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
        f_1
        (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✝))

Next tactic:
intro j j' h
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _ <;> simp
    · intro j j' h
      

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ 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✝))

Next tactic:
dsimp
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _ <;> simp
    · intro j j' h
      dsimp
      

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ 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
          (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 ≫ (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✝)) =
    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✝))

Next tactic:
simp only [Category.assoc, Functor.map_comp, eqToHom_map, eqToHom_trans,
        eqToHom_trans_assoc, ← Functor.comp_map]
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _ <;> simp
    · intro j j' h
      dsimp
      simp only [Category.assoc, Functor.map_comp, eqToHom_map, eqToHom_trans,
        eqToHom_trans_assoc, ← Functor.comp_map]
      

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ 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✝) =
            (F.map h).obj ((s.π.app j).obj X✝)) ≫
      (s.π.app j ⋙ F.map h).map f ≫
        eqToHom
          (_ :
            (F.map h).obj ((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✝))

Next tactic:
have := (s.π.naturality h).symm
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _ <;> simp
    · intro j j' h
      dsimp
      simp only [Category.assoc, Functor.map_comp, eqToHom_map, eqToHom_trans,
        eqToHom_trans_assoc, ← Functor.comp_map]
      have := (s.π.naturality h).symm
      

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
j j' : J
h : j ⟶ j'
this : s.π.app j ≫ F.map h = ((Functor.const J).obj s.pt).map h ≫ s.π.app j'
⊢ eqToHom
        (_ :
          limit.π (F ⋙ objects) j'
              (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X✝) =
            (F.map h).obj ((s.π.app j).obj X✝)) ≫
      (s.π.app j ⋙ F.map h).map f ≫
        eqToHom
          (_ :
            (F.map h).obj ((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✝))

Next tactic:
dsimp at this
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _ <;> simp
    · intro j j' h
      dsimp
      simp only [Category.assoc, Functor.map_comp, eqToHom_map, eqToHom_trans,
        eqToHom_trans_assoc, ← Functor.comp_map]
      have := (s.π.naturality h).symm
      dsimp at this
      

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
j j' : J
h : j ⟶ j'
this : s.π.app j ≫ F.map h = 𝟙 s.pt ≫ s.π.app j'
⊢ eqToHom
        (_ :
          limit.π (F ⋙ objects) j'
              (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X✝) =
            (F.map h).obj ((s.π.app j).obj X✝)) ≫
      (s.π.app j ⋙ F.map h).map f ≫
        eqToHom
          (_ :
            (F.map h).obj ((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✝))

Next tactic:
rw [Category.id_comp] at this
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _ <;> simp
    · intro j j' h
      dsimp
      simp only [Category.assoc, Functor.map_comp, eqToHom_map, eqToHom_trans,
        eqToHom_trans_assoc, ← Functor.comp_map]
      have := (s.π.naturality h).symm
      dsimp at this
      rw [Category.id_comp] at this
      

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
j j' : J
h : j ⟶ j'
this : s.π.app j ≫ F.map h = s.π.app j'
⊢ eqToHom
        (_ :
          limit.π (F ⋙ objects) j'
              (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X✝) =
            (F.map h).obj ((s.π.app j).obj X✝)) ≫
      (s.π.app j ⋙ F.map h).map f ≫
        eqToHom
          (_ :
            (F.map h).obj ((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✝))

Next tactic:
erw [Functor.congr_hom this f]
/-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F where
  obj :=
    limit.lift (F ⋙ Cat.objects)
      { pt := s.pt
        π :=
          { app := fun j => (s.π.app j).obj
            naturality := fun _ _ f => Functor.congr_map objects (s.π.naturality f) } }
  map f := by
    fapply Types.Limit.mk.{v, v}
    · intro j
      refine' eqToHom _ ≫ (s.π.app j).map f ≫ eqToHom _ <;> simp
    · intro j j' h
      dsimp
      simp only [Category.assoc, Functor.map_comp, eqToHom_map, eqToHom_trans,
        eqToHom_trans_assoc, ← Functor.comp_map]
      have := (s.π.naturality h).symm
      dsimp at this
      rw [Category.id_comp] at this
      erw [Functor.congr_hom this f]
      

Proof state:
case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
X✝ Y✝ : ↑s.pt
f : X✝ ⟶ Y✝
j j' : J
h : j ⟶ j'
this : s.π.app j ≫ F.map h = s.π.app j'
⊢ eqToHom
        (_ :
          limit.π (F ⋙ objects) j'
              (limit.lift (F ⋙ objects) { pt := ↑s.pt, π := NatTrans.mk fun j => (s.π.app j).obj } X✝) =
            (F.map h).obj ((s.π.app j).obj X✝)) ≫
      (eqToHom (_ : (s.π.app j ≫ F.map h).obj X✝ = (s.π.app j').obj X✝) ≫
          (s.π.app j').map f ≫ eqToHom (_ : (s.π.app j').obj Y✝ = (s.π.app j ≫ F.map h).obj Y✝)) ≫
        eqToHom
          (_ :
            (F.map h).obj ((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✝))

Next tactic:
simp
@[simp]
theorem limit_π_homDiagram_eqToHom {F : J ⥤ Cat.{v, v}} (X Y : limit (F ⋙ Cat.objects.{v, v}))
    (j : J) (h : X = Y) :
    limit.π (homDiagram X Y) j (eqToHom h) =
      eqToHom (congr_arg (limit.π (F ⋙ Cat.objects.{v, v}) j) h) := by
  

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X Y : limit (F ⋙ objects)
j : J
h : X = Y
⊢ limit.π (homDiagram X Y) j (eqToHom h) = eqToHom (_ : limit.π (F ⋙ objects) j X = limit.π (F ⋙ objects) j Y)

Next tactic:
subst h
@[simp]
theorem limit_π_homDiagram_eqToHom {F : J ⥤ Cat.{v, v}} (X Y : limit (F ⋙ Cat.objects.{v, v}))
    (j : J) (h : X = Y) :
    limit.π (homDiagram X Y) j (eqToHom h) =
      eqToHom (congr_arg (limit.π (F ⋙ Cat.objects.{v, v}) j) h) := by
  subst h
  

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
X : limit (F ⋙ objects)
j : J
⊢ limit.π (homDiagram X X) j (eqToHom (_ : X = X)) = eqToHom (_ : limit.π (F ⋙ objects) j X = limit.π (F ⋙ objects) j X)

Next tactic:
simp
/-- 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 

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
j : J
⊢ ∀ (X : ↑s.pt), (limitConeLift F s ≫ (limitCone F).π.app j).obj X = (s.π.app j).obj X

Next tactic:
simp
/-- 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
    

Proof state:
J : Type v
inst✝ : SmallCategory J
F : J ⥤ Cat
s : Cone F
j : J
X Y : ↑s.pt
f : X ⟶ Y
⊢ (limitConeLift F s ≫ (limitCone F).π.app j).map f =
    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 = (limitConeLift F s ≫ (limitCone F).π.app j).obj Y)

Next tactic:
dsimp [limitConeLift]
/-- 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
    

Proof state:
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
⊢ m = limitConeLift F s

Next tactic:
symm
/-- 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
    

Proof state:
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
⊢ limitConeLift F s = m

Next tactic:
refine' CategoryTheory.Functor.ext _ _
/-- 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 _ _
    · 

Proof state:
case refine'_1
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 : ↑s.pt), (limitConeLift F s).obj X = m.obj X

Next tactic:
intro X
/-- 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
      

Proof state:
case refine'_1
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 : ↑s.pt
⊢ (limitConeLift F s).obj X = m.obj X

Next tactic:
apply Types.limit_ext.{v, v}
/-- 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}
      

Proof state:
case refine'_1.w
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 : ↑s.pt
⊢ ∀ (j : J), limit.π (F ⋙ objects) j ((limitConeLift F s).obj X) = limit.π (F ⋙ objects) j (m.obj X)

Next tactic:
intro j
/-- 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
      

Proof state:
case refine'_1.w
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 : ↑s.pt
j : J
⊢ limit.π (F ⋙ objects) j ((limitConeLift F s).obj X) = limit.π (F ⋙ objects) j (m.obj X)

Next tactic:
simp [Types.Limit.lift_π_apply', ← w j]