theorem BinaryCofan.isVanKampen_mk {X Y : C} (c : BinaryCofan X Y)
    (cofans : ∀ X Y : C, BinaryCofan X Y) (colimits : ∀ X Y, IsColimit (cofans X Y))
    (cones : ∀ {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z), PullbackCone f g)
    (limits : ∀ {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z), IsLimit (cones f g))
    (h₁ : ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt)
      (_ : αX ≫ c.inl = (cofans X' Y').inl ≫ f) (_ : αY ≫ c.inr = (cofans X' Y').inr ≫ f),
      IsPullback (cofans X' Y').inl αX f c.inl ∧ IsPullback (cofans X' Y').inr αY f c.inr)
    (h₂ : ∀ {Z : C} (f : Z ⟶ c.pt),
      IsColimit (BinaryCofan.mk (cones f c.inl).fst (cones f c.inr).fst)) :
    IsVanKampenColimit c := by
  rw [BinaryCofan.isVanKampen_iff]
  introv hX hY
  constructor
  · rintro ⟨h⟩
    let e := h.coconePointUniqueUpToIso (colimits _ _)
    obtain ⟨hl, hr⟩ := h₁ αX αY (e.inv ≫ f) (by simp [hX]) (by simp [hY])
    constructor
    · rw [← Category.id_comp αX, ← Iso.hom_inv_id_assoc e f]
      haveI : IsIso (𝟙 X') := inferInstance
      have : c'.inl ≫ e.hom = 𝟙 X' ≫ (cofans X' Y').inl := by
        dsimp
        simp
      exact (IsPullback.of_vert_isIso ⟨this⟩).paste_vert hl
    · rw [← Category.id_comp αY, ← Iso.hom_inv_id_assoc e f]
      haveI : IsIso (𝟙 Y') := inferInstance
      have : c'.inr ≫ e.hom = 𝟙 Y' ≫ (cofans X' Y').inr := by
        dsimp
        simp
      exact (IsPullback.of_vert_isIso ⟨this⟩).paste_vert hr
  · rintro ⟨H₁, H₂⟩
    refine' ⟨IsColimit.ofIsoColimit _ <| (isoBinaryCofanMk _).symm⟩
    let e₁ : X' ≅ _ := H₁.isLimit.conePointUniqueUpToIso (limits _ _)
    let e₂ : Y' ≅ _ := H₂.isLimit.conePointUniqueUpToIso (limits _ _)
    have he₁ : c'.inl = e₁.hom ≫ (cones f c.inl).fst := by simp
    have he₂ : c'.inr = e₂.hom ≫ (cones f c.inr).fst := by simp
    rw [he₁, he₂]
    apply BinaryCofan.isColimitCompRightIso (BinaryCofan.mk _ _)
    apply BinaryCofan.isColimitCompLeftIso (BinaryCofan.mk _ _)
    

Proof state:
case mpr.intro.h.h
J : Type v'
inst✝³ : Category.{u', v'} J
C : Type u
inst✝² : Category.{v, u} C
K : Type u_1
inst✝¹ : Category.{?u.277312, u_1} K
D : Type u_2
inst✝ : Category.{?u.277319, u_2} D
X✝ Y✝ X Y : C
c : BinaryCofan X Y
cofans : (X Y : C) → BinaryCofan X Y
colimits : (X Y : C) → IsColimit (cofans X Y)
cones : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → PullbackCone f g
limits : {X Y Z : C} → (f : X ⟶ Z) → (g : Y ⟶ Z) → IsLimit (cones f g)
h₁ :
  ∀ {X' Y' : C} (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : (cofans X' Y').pt ⟶ c.pt),
    αX ≫ BinaryCofan.inl c = BinaryCofan.inl (cofans X' Y') ≫ f →
      αY ≫ BinaryCofan.inr c = BinaryCofan.inr (cofans X' Y') ≫ f →
        IsPullback (BinaryCofan.inl (cofans X' Y')) αX f (BinaryCofan.inl c) ∧
          IsPullback (BinaryCofan.inr (cofans X' Y')) αY f (BinaryCofan.inr c)
h₂ :
  {Z : C} →
    (f : Z ⟶ c.pt) →
      IsColimit
        (BinaryCofan.mk (PullbackCone.fst (cones f (BinaryCofan.inl c)))
          (PullbackCone.fst (cones f (BinaryCofan.inr c))))
X' Y' : C
c' : BinaryCofan X' Y'
αX : X' ⟶ X
αY : Y' ⟶ Y
f : c'.pt ⟶ c.pt
hX : αX ≫ BinaryCofan.inl c = BinaryCofan.inl c' ≫ f
hY : αY ≫ BinaryCofan.inr c = BinaryCofan.inr c' ≫ f
H₁ : IsPullback (BinaryCofan.inl c') αX f (BinaryCofan.inl c)
H₂ : IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)
e₁ : X' ≅ (cones f (BinaryCofan.inl c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₁) (limits f (BinaryCofan.inl c))
e₂ : Y' ≅ (cones f (BinaryCofan.inr c)).pt :=
  IsLimit.conePointUniqueUpToIso (IsPullback.isLimit H₂) (limits f (BinaryCofan.inr c))
he₁ : BinaryCofan.inl c' = e₁.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inl c))
he₂ : BinaryCofan.inr c' = e₂.hom ≫ PullbackCone.fst (cones f (BinaryCofan.inr c))
⊢ IsColimit
    (BinaryCofan.mk ((cones f (BinaryCofan.inl c)).π.1 WalkingCospan.left)
      ((cones f (BinaryCofan.inr c)).π.1 WalkingCospan.left))

Next tactic:
exact h₂ f