l3lab/ntp-mathlib huggingface dataset:
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]
      

Proof state:
case mp.intro.intro.left
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 : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
⊢ IsPullback (BinaryCofan.inl c') (𝟙 X' ≫ αX) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inl c)

Next tactic:
haveI : IsIso (𝟙 X') := inferInstance
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
      

Proof state:
case mp.intro.intro.left
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 : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this : IsIso (𝟙 X')
⊢ IsPullback (BinaryCofan.inl c') (𝟙 X' ≫ αX) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inl c)

Next tactic:
have : c'.inl ≫ e.hom = 𝟙 X' ≫ (cofans X' Y').inl := by
        dsimp
        simp
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
        

Proof state:
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 : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this : IsIso (𝟙 X')
⊢ BinaryCofan.inl c' ≫ e.hom = 𝟙 X' ≫ BinaryCofan.inl (cofans X' Y')

Next tactic:
dsimp
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
        

Proof state:
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 : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this : IsIso (𝟙 X')
⊢ BinaryCofan.inl c' ≫ (IsColimit.coconePointUniqueUpToIso h (colimits X' Y')).hom =
    𝟙 X' ≫ BinaryCofan.inl (cofans X' Y')

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

Proof state:
case mp.intro.intro.left
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 : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this✝ : IsIso (𝟙 X')
this : BinaryCofan.inl c' ≫ e.hom = 𝟙 X' ≫ BinaryCofan.inl (cofans X' Y')
⊢ IsPullback (BinaryCofan.inl c') (𝟙 X' ≫ αX) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inl c)

Next tactic:
exact (IsPullback.of_vert_isIso ⟨this⟩).paste_vert hl
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
    · 

Proof state:
case mp.intro.intro.right
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 : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
⊢ IsPullback (BinaryCofan.inr c') αY f (BinaryCofan.inr c)

Next tactic:
rw [← Category.id_comp αY, ← Iso.hom_inv_id_assoc e f]
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]
      

Proof state:
case mp.intro.intro.right
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 : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
⊢ IsPullback (BinaryCofan.inr c') (𝟙 Y' ≫ αY) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inr c)

Next tactic:
haveI : IsIso (𝟙 Y') := inferInstance
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
      

Proof state:
case mp.intro.intro.right
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 : IsColimit c'
e : c'.pt ≅ (cofans X' Y').pt := IsColimit.coconePointUniqueUpToIso h (colimits X' Y')
hl : IsPullback (BinaryCofan.inl (cofans X' Y')) αX (e.inv ≫ f) (BinaryCofan.inl c)
hr : IsPullback (BinaryCofan.inr (cofans X' Y')) αY (e.inv ≫ f) (BinaryCofan.inr c)
this : IsIso (𝟙 Y')
⊢ IsPullback (BinaryCofan.inr c') (𝟙 Y' ≫ αY) (e.hom ≫ e.inv ≫ f) (BinaryCofan.inr c)

Next tactic:
have : c'.inr ≫ e.hom = 𝟙 Y' ≫ (cofans X' Y').inr := by
        dsimp
        simp