l3lab/ntp-mathlib huggingface dataset:
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => 

Proof state:
case a.a
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
| (DiagramOfCones.obj D j).π.app k ≫ (F.obj j).map fk
case a.a
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
| (F.map fj).app k'
case a
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
| s.π.app j

Next tactic:
rw [← (D.obj j).π.naturality]
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              

Proof state:
case mk.mk.mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
⊢ s.π.app j' ≫ (DiagramOfCones.obj D j').π.app k' =
    s.π.app j ≫
      (((Functor.const K).obj (DiagramOfCones.obj D j).pt).map fk ≫ (DiagramOfCones.obj D j).π.app k') ≫
        (F.map fj).app k'

Next tactic:
simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              

Proof state:
case mk.mk.mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
⊢ s.π.app j' ≫ (DiagramOfCones.obj D j').π.app k' = s.π.app j ≫ (DiagramOfCones.obj D j).π.app k' ≫ (F.map fj).app k'

Next tactic:
have w := (D.map fj).w k'
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              

Proof state:
case mk.mk.mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D (j', k').1).π.app k' =
    ((Cones.postcompose (F.map fj)).obj (DiagramOfCones.obj D (j, k).1)).π.app k'
⊢ s.π.app j' ≫ (DiagramOfCones.obj D j').π.app k' = s.π.app j ≫ (DiagramOfCones.obj D j).π.app k' ≫ (F.map fj).app k'

Next tactic:
dsimp at w
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              dsimp at w
              

Proof state:
case mk.mk.mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k' =
    (DiagramOfCones.obj D j).π.app k' ≫ (F.map fj).app k'
⊢ s.π.app j' ≫ (DiagramOfCones.obj D j').π.app k' = s.π.app j ≫ (DiagramOfCones.obj D j).π.app k' ≫ (F.map fj).app k'

Next tactic:
rw [← w]
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              dsimp at w
              rw [← w]
              

Proof state:
case mk.mk.mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k' =
    (DiagramOfCones.obj D j).π.app k' ≫ (F.map fj).app k'
⊢ s.π.app j' ≫ (DiagramOfCones.obj D j').π.app k' =
    s.π.app j ≫ (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k'

Next tactic:
have n := s.π.naturality fj
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              dsimp at w
              rw [← w]
              have n := s.π.naturality fj
              

Proof state:
case mk.mk.mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k' =
    (DiagramOfCones.obj D j).π.app k' ≫ (F.map fj).app k'
n : ((Functor.const J).obj s.pt).map fj ≫ s.π.app (j', k').1 = s.π.app (j, k).1 ≫ (DiagramOfCones.conePoints D).map fj
⊢ s.π.app j' ≫ (DiagramOfCones.obj D j').π.app k' =
    s.π.app j ≫ (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k'

Next tactic:
dsimp at n
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              dsimp at w
              rw [← w]
              have n := s.π.naturality fj
              dsimp at n
              

Proof state:
case mk.mk.mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k' =
    (DiagramOfCones.obj D j).π.app k' ≫ (F.map fj).app k'
n : 𝟙 s.pt ≫ s.π.app j' = s.π.app j ≫ (DiagramOfCones.map D fj).hom
⊢ s.π.app j' ≫ (DiagramOfCones.obj D j').π.app k' =
    s.π.app j ≫ (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k'

Next tactic:
simp only [Category.id_comp] at n
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              dsimp at w
              rw [← w]
              have n := s.π.naturality fj
              dsimp at n
              simp only [Category.id_comp] at n
              

Proof state:
case mk.mk.mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k' =
    (DiagramOfCones.obj D j).π.app k' ≫ (F.map fj).app k'
n : s.π.app j' = s.π.app j ≫ (DiagramOfCones.map D fj).hom
⊢ s.π.app j' ≫ (DiagramOfCones.obj D j').π.app k' =
    s.π.app j ≫ (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k'

Next tactic:
rw [n]
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              dsimp at w
              rw [← w]
              have n := s.π.naturality fj
              dsimp at n
              simp only [Category.id_comp] at n
              rw [n]
              

Proof state:
case mk.mk.mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k' =
    (DiagramOfCones.obj D j).π.app k' ≫ (F.map fj).app k'
n : s.π.app j' = s.π.app j ≫ (DiagramOfCones.map D fj).hom
⊢ (s.π.app j ≫ (DiagramOfCones.map D fj).hom) ≫ (DiagramOfCones.obj D j').π.app k' =
    s.π.app j ≫ (DiagramOfCones.map D fj).hom ≫ (DiagramOfCones.obj D j').π.app k'

Next tactic:
simp
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              dsimp at w
              rw [← w]
              have n := s.π.naturality fj
              dsimp at n
              simp only [Category.id_comp] at n
              rw [n]
              simp } }
  fac s j := by
    

Proof state:
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
⊢ (fun s => IsLimit.lift P { pt := s.pt, π := NatTrans.mk fun p => s.π.app p.1 ≫ (DiagramOfCones.obj D p.1).π.app p.2 })
        s ≫
      (coneOfConeUncurry Q c).π.app j =
    s.π.app j

Next tactic:
apply (Q j).hom_ext
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              dsimp at w
              rw [← w]
              have n := s.π.naturality fj
              dsimp at n
              simp only [Category.id_comp] at n
              rw [n]
              simp } }
  fac s j := by
    apply (Q j).hom_ext
    

Proof state:
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
⊢ ∀ (j_1 : K),
    ((fun s =>
              IsLimit.lift P
                { pt := s.pt, π := NatTrans.mk fun p => s.π.app p.1 ≫ (DiagramOfCones.obj D p.1).π.app p.2 })
            s ≫
          (coneOfConeUncurry Q c).π.app j) ≫
        (DiagramOfCones.obj D j).π.app j_1 =
      s.π.app j ≫ (DiagramOfCones.obj D j).π.app j_1

Next tactic:
intro k
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              dsimp at w
              rw [← w]
              have n := s.π.naturality fj
              dsimp at n
              simp only [Category.id_comp] at n
              rw [n]
              simp } }
  fac s j := by
    apply (Q j).hom_ext
    intro k
    

Proof state:
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
j : J
k : K
⊢ ((fun s =>
            IsLimit.lift P { pt := s.pt, π := NatTrans.mk fun p => s.π.app p.1 ≫ (DiagramOfCones.obj D p.1).π.app p.2 })
          s ≫
        (coneOfConeUncurry Q c).π.app j) ≫
      (DiagramOfCones.obj D j).π.app k =
    s.π.app j ≫ (DiagramOfCones.obj D j).π.app k

Next tactic:
simp
/-- `coneOfConeUncurry Q c` is a limit cone when `c` is a limit cone.
-/
def coneOfConeUncurryIsLimit {D : DiagramOfCones F} (Q : ∀ j, IsLimit (D.obj j))
    {c : Cone (uncurry.obj F)} (P : IsLimit c) : IsLimit (coneOfConeUncurry Q c) where
  lift s :=
    P.lift
      { pt := s.pt
        π :=
          { app := fun p => s.π.app p.1 ≫ (D.obj p.1).π.app p.2
            naturality := fun p p' f => by
              dsimp; simp only [Category.id_comp, Category.assoc]
              rcases p with ⟨j, k⟩
              rcases p' with ⟨j', k'⟩
              rcases f with ⟨fj, fk⟩
              dsimp
              slice_rhs 3 4 => rw [← NatTrans.naturality]
              slice_rhs 2 3 => rw [← (D.obj j).π.naturality]
              simp only [Functor.const_obj_map, Category.id_comp, Category.assoc]
              have w := (D.map fj).w k'
              dsimp at w
              rw [← w]
              have n := s.π.naturality fj
              dsimp at n
              simp only [Category.id_comp] at n
              rw [n]
              simp } }
  fac s j := by
    apply (Q j).hom_ext
    intro k
    simp
  uniq s m w := by
    

Proof state:
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCones F
Q : (j : J) → IsLimit (DiagramOfCones.obj D j)
c : Cone (uncurry.obj F)
P : IsLimit c
s : Cone (DiagramOfCones.conePoints D)
m : s.pt ⟶ (coneOfConeUncurry Q c).pt
w : ∀ (j : J), m ≫ (coneOfConeUncurry Q c).π.app j = s.π.app j
⊢ m =
    (fun s =>
        IsLimit.lift P { pt := s.pt, π := NatTrans.mk fun p => s.π.app p.1 ≫ (DiagramOfCones.obj D p.1).π.app p.2 })
      s

Next tactic:
refine' P.uniq
      { pt := s.pt
        π := _ } m _