l3lab/ntp-mathlib huggingface dataset:
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => 

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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom =
    (F.map fj).app k ≫ (DiagramOfCocones.obj D j').ι.app k
| (F.map fj).app k ≫ (DiagramOfCocones.obj D j').ι.app k
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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom =
    (F.map fj).app k ≫ (DiagramOfCocones.obj D j').ι.app k
| 𝟙 (DiagramOfCocones.obj D j').pt
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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom =
    (F.map fj).app k ≫ (DiagramOfCocones.obj D j').ι.app k
| s.ι.app j'

Next tactic:
rw [← w]
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => 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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom =
    (F.map fj).app k ≫ (DiagramOfCocones.obj D j').ι.app k
⊢ (((DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom) ≫ 𝟙 (DiagramOfCocones.obj D j').pt) ≫
      s.ι.app j' =
    (DiagramOfCocones.obj D j).ι.app k ≫ s.ι.app j ≫ 𝟙 s.pt

Next tactic:
have n := s.ι.naturality fj
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => 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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom =
    (F.map fj).app k ≫ (DiagramOfCocones.obj D j').ι.app k
n :
  (DiagramOfCocones.coconePoints D).map fj ≫ s.ι.app (j', k').1 = s.ι.app (j, k).1 ≫ ((Functor.const J).obj s.pt).map fj
⊢ (((DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom) ≫ 𝟙 (DiagramOfCocones.obj D j').pt) ≫
      s.ι.app j' =
    (DiagramOfCocones.obj D j).ι.app k ≫ s.ι.app j ≫ 𝟙 s.pt

Next tactic:
dsimp at n
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => 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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom =
    (F.map fj).app k ≫ (DiagramOfCocones.obj D j').ι.app k
n : (DiagramOfCocones.map D fj).hom ≫ s.ι.app j' = s.ι.app j ≫ 𝟙 s.pt
⊢ (((DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom) ≫ 𝟙 (DiagramOfCocones.obj D j').pt) ≫
      s.ι.app j' =
    (DiagramOfCocones.obj D j).ι.app k ≫ s.ι.app j ≫ 𝟙 s.pt

Next tactic:
simp only [Category.comp_id] at n
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => rw [← w]
              have n := s.ι.naturality fj
              dsimp at n
              simp only [Category.comp_id] 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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom =
    (F.map fj).app k ≫ (DiagramOfCocones.obj D j').ι.app k
n : (DiagramOfCocones.map D fj).hom ≫ s.ι.app j' = s.ι.app j
⊢ (((DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom) ≫ 𝟙 (DiagramOfCocones.obj D j').pt) ≫
      s.ι.app j' =
    (DiagramOfCocones.obj D j).ι.app k ≫ s.ι.app j ≫ 𝟙 s.pt

Next tactic:
rw [← n]
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => rw [← w]
              have n := s.ι.naturality fj
              dsimp at n
              simp only [Category.comp_id] 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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
k : K
j' : J
k' : K
fj : (j, k).1 ⟶ (j', k').1
fk : (j, k).2 ⟶ (j', k').2
w :
  (DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom =
    (F.map fj).app k ≫ (DiagramOfCocones.obj D j').ι.app k
n : (DiagramOfCocones.map D fj).hom ≫ s.ι.app j' = s.ι.app j
⊢ (((DiagramOfCocones.obj D j).ι.app k ≫ (DiagramOfCocones.map D fj).hom) ≫ 𝟙 (DiagramOfCocones.obj D j').pt) ≫
      s.ι.app j' =
    (DiagramOfCocones.obj D j).ι.app k ≫ ((DiagramOfCocones.map D fj).hom ≫ s.ι.app j') ≫ 𝟙 s.pt

Next tactic:
simp
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => rw [← w]
              have n := s.ι.naturality fj
              dsimp at n
              simp only [Category.comp_id] 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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
⊢ (coconeOfCoconeUncurry Q c).ι.app j ≫
      (fun s =>
          IsColimit.desc P
            { pt := s.pt, ι := NatTrans.mk fun p => (DiagramOfCocones.obj D p.1).ι.app p.2 ≫ s.ι.app p.1 })
        s =
    s.ι.app j

Next tactic:
apply (Q j).hom_ext
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => rw [← w]
              have n := s.ι.naturality fj
              dsimp at n
              simp only [Category.comp_id] 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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
⊢ ∀ (j_1 : K),
    (DiagramOfCocones.obj D j).ι.app j_1 ≫
        (coconeOfCoconeUncurry Q c).ι.app j ≫
          (fun s =>
              IsColimit.desc P
                { pt := s.pt, ι := NatTrans.mk fun p => (DiagramOfCocones.obj D p.1).ι.app p.2 ≫ s.ι.app p.1 })
            s =
      (DiagramOfCocones.obj D j).ι.app j_1 ≫ s.ι.app j

Next tactic:
intro k
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => rw [← w]
              have n := s.ι.naturality fj
              dsimp at n
              simp only [Category.comp_id] 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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
j : J
k : K
⊢ (DiagramOfCocones.obj D j).ι.app k ≫
      (coconeOfCoconeUncurry Q c).ι.app j ≫
        (fun s =>
            IsColimit.desc P
              { pt := s.pt, ι := NatTrans.mk fun p => (DiagramOfCocones.obj D p.1).ι.app p.2 ≫ s.ι.app p.1 })
          s =
    (DiagramOfCocones.obj D j).ι.app k ≫ s.ι.app j

Next tactic:
simp
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => rw [← w]
              have n := s.ι.naturality fj
              dsimp at n
              simp only [Category.comp_id] 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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
m : (coconeOfCoconeUncurry Q c).pt ⟶ s.pt
w : ∀ (j : J), (coconeOfCoconeUncurry Q c).ι.app j ≫ m = s.ι.app j
⊢ m =
    (fun s =>
        IsColimit.desc P { pt := s.pt, ι := NatTrans.mk fun p => (DiagramOfCocones.obj D p.1).ι.app p.2 ≫ s.ι.app p.1 })
      s

Next tactic:
refine' P.uniq
      { pt := s.pt
        ι := _ } m _
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => rw [← w]
              have n := s.ι.naturality fj
              dsimp at n
              simp only [Category.comp_id] at n
              rw [← n]
              simp } }
  fac s j := by
    apply (Q j).hom_ext
    intro k
    simp
  uniq s m w := by
    refine' P.uniq
      { pt := s.pt
        ι := _ } m _
    

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 : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
m : (coconeOfCoconeUncurry Q c).pt ⟶ s.pt
w : ∀ (j : J), (coconeOfCoconeUncurry Q c).ι.app j ≫ m = s.ι.app j
⊢ ∀ (j : J × K),
    c.ι.app j ≫ m =
      { pt := s.pt, ι := NatTrans.mk fun p => (DiagramOfCocones.obj D p.1).ι.app p.2 ≫ s.ι.app p.1 }.ι.app j

Next tactic:
rintro ⟨j, k⟩
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => rw [← w]
              have n := s.ι.naturality fj
              dsimp at n
              simp only [Category.comp_id] at n
              rw [← n]
              simp } }
  fac s j := by
    apply (Q j).hom_ext
    intro k
    simp
  uniq s m w := by
    refine' P.uniq
      { pt := s.pt
        ι := _ } m _
    rintro ⟨j, k⟩
    

Proof state:
case mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
m : (coconeOfCoconeUncurry Q c).pt ⟶ s.pt
w : ∀ (j : J), (coconeOfCoconeUncurry Q c).ι.app j ≫ m = s.ι.app j
j : J
k : K
⊢ c.ι.app (j, k) ≫ m =
    { pt := s.pt, ι := NatTrans.mk fun p => (DiagramOfCocones.obj D p.1).ι.app p.2 ≫ s.ι.app p.1 }.ι.app (j, k)

Next tactic:
dsimp
/-- `coconeOfCoconeUncurry Q c` is a colimit cocone when `c` is a colimit cocone.
-/
def coconeOfCoconeUncurryIsColimit {D : DiagramOfCocones F} (Q : ∀ j, IsColimit (D.obj j))
    {c : Cocone (uncurry.obj F)} (P : IsColimit c) : IsColimit (coconeOfCoconeUncurry Q c) where
  desc s :=
    P.desc
      { pt := s.pt
        ι :=
          { app := fun p => (D.obj p.1).ι.app p.2 ≫ s.ι.app p.1
            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_lhs 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
              slice_lhs 1 2 => rw [← w]
              have n := s.ι.naturality fj
              dsimp at n
              simp only [Category.comp_id] at n
              rw [← n]
              simp } }
  fac s j := by
    apply (Q j).hom_ext
    intro k
    simp
  uniq s m w := by
    refine' P.uniq
      { pt := s.pt
        ι := _ } m _
    rintro ⟨j, k⟩
    dsimp
    

Proof state:
case mk
J K : Type v
inst✝² : SmallCategory J
inst✝¹ : SmallCategory K
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ K ⥤ C
D : DiagramOfCocones F
Q : (j : J) → IsColimit (DiagramOfCocones.obj D j)
c : Cocone (uncurry.obj F)
P : IsColimit c
s : Cocone (DiagramOfCocones.coconePoints D)
m : (coconeOfCoconeUncurry Q c).pt ⟶ s.pt
w : ∀ (j : J), (coconeOfCoconeUncurry Q c).ι.app j ≫ m = s.ι.app j
j : J
k : K
⊢ c.ι.app (j, k) ≫ m = (DiagramOfCocones.obj D j).ι.app k ≫ s.ι.app j

Next tactic:
rw [← w j]