instance types.finitaryExtensive : FinitaryExtensive (Type u) := by
  classical
  rw [finitaryExtensive_iff_of_isTerminal (Type u) PUnit Types.isTerminalPunit _
      (Types.binaryCoproductColimit _ _)]
  apply BinaryCofan.isVanKampen_mk _ _ (fun X Y => Types.binaryCoproductColimit X Y) _
      fun f g => (Limits.Types.pullbackLimitCone f g).2
  · intros _ _ _ _ f hαX hαY
    constructor
    · refine' ⟨⟨hαX.symm⟩, ⟨PullbackCone.isLimitAux' _ _⟩⟩
      intro s
      have : ∀ x, ∃! y, s.fst x = Sum.inl y := by
        intro x
        cases' h : s.fst x with val val
        · simp only [Types.binaryCoproductCocone_pt, Functor.const_obj_obj, Sum.inl.injEq,
            exists_unique_eq']
        · apply_fun f at h
          cases ((congr_fun s.condition x).symm.trans h).trans (congr_fun hαY val : _).symm
      delta ExistsUnique at this
      choose l hl hl' using this
      exact ⟨l, (funext hl).symm, Types.isTerminalPunit.hom_ext _ _,
        fun {l'} h₁ _ => funext fun x => hl' x (l' x) (congr_fun h₁ x).symm⟩
    · refine' ⟨⟨hαY.symm⟩, ⟨PullbackCone.isLimitAux' _ _⟩⟩
      intro s
      have : ∀ x, ∃! y, s.fst x = Sum.inr y := by
        intro x
        cases' h : s.fst x with val val
        · apply_fun f at h
          cases ((congr_fun s.condition x).symm.trans h).trans (congr_fun hαX val : _).symm
        · simp only [Types.binaryCoproductCocone_pt, Functor.const_obj_obj, Sum.inr.injEq,
            exists_unique_eq']
      delta ExistsUnique at this
      choose l hl hl' using this
      exact ⟨l, (funext hl).symm, Types.isTerminalPunit.hom_ext _ _,
        fun {l'} h₁ _ => funext fun x => hl' x (l' x) (congr_fun h₁ x).symm⟩
  · intro Z f
    dsimp [Limits.Types.binaryCoproductCocone]
    delta Types.PullbackObj
    have : ∀ x, f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit := by
      intro x
      rcases f x with (⟨⟨⟩⟩ | ⟨⟨⟩⟩)
      exacts [Or.inl rfl, Or.inr rfl]
    let eX : { p : Z × PUnit // f p.fst = Sum.inl p.snd } ≃ { x : Z // f x = Sum.inl PUnit.unit } :=
      ⟨fun p => ⟨p.1.1, by convert p.2⟩, fun x => ⟨⟨_, _⟩, x.2⟩, fun _ => by ext; rfl,
        fun _ => by ext; rfl⟩
    let eY : { p : Z × PUnit // f p.fst = Sum.inr p.snd } ≃ { x : Z // f x = Sum.inr PUnit.unit } :=
      ⟨fun p => ⟨p.1.1, p.2.trans (congr_arg Sum.inr <| Subsingleton.elim _ _)⟩,
        fun x => ⟨⟨_, _⟩, x.2⟩, fun _ => by ext; rfl, fun _ => by ext; rfl⟩
    fapply BinaryCofan.isColimitMk
    · exact fun s x => dite _ (fun h => s.inl <| eX.symm ⟨x, h⟩)
        fun h => s.inr <| eY.symm ⟨x, (this x).resolve_left h⟩
    · intro s
      ext ⟨⟨x, ⟨⟩⟩, _⟩
      dsimp
      split_ifs <;> rfl
    · intro s
      ext ⟨⟨x, ⟨⟩⟩, hx⟩
      dsimp
      split_ifs with h
      · cases h.symm.trans hx
      · rfl
    · intro s m e₁ e₂
      ext x
      split_ifs
      · rw [← e₁]
        rfl
      · 

Proof state:
case neg
J : Type v'
inst✝² : Category.{u', v'} J
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u''
inst✝ : Category.{v'', u''} D
X Y : C
Z : Type u
f : Z ⟶ (Types.binaryCoproductCocone PUnit.{u + 1} PUnit.{u + 1}).pt
this : ∀ (x : Z), f x = Sum.inl PUnit.unit ∨ f x = Sum.inr PUnit.unit
eX : { p // f p.1 = Sum.inl p.2 } ≃ { x // f x = Sum.inl PUnit.unit } :=
  { toFun := fun p => { val := (↑p).1, property := (_ : f (↑p).1 = Sum.inl PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.1 = Sum.inl p.2 }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) })
              ((fun p => { val := (↑p).1, property := (_ : f (↑p).1 = Sum.inl PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inl PUnit.unit }),
          (fun p => { val := (↑p).1, property := (_ : f (↑p).1 = Sum.inl PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inl PUnit.unit) }) x) =
            x) }
eY : { p // f p.1 = Sum.inr p.2 } ≃ { x // f x = Sum.inr PUnit.unit } :=
  { toFun := fun p => { val := (↑p).1, property := (_ : f (↑p).1 = Sum.inr PUnit.unit) },
    invFun := fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) },
    left_inv :=
      (_ :
        ∀ (x : { p // f p.1 = Sum.inr p.2 }),
          (fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) })
              ((fun p => { val := (↑p).1, property := (_ : f (↑p).1 = Sum.inr PUnit.unit) }) x) =
            x),
    right_inv :=
      (_ :
        ∀ (x : { x // f x = Sum.inr PUnit.unit }),
          (fun p => { val := (↑p).1, property := (_ : f (↑p).1 = Sum.inr PUnit.unit) })
              ((fun x => { val := (x.1, PUnit.unit), property := (_ : f ↑x = Sum.inr PUnit.unit) }) x) =
            x) }
s : BinaryCofan { p // f p.1 = Sum.inl p.2 } { p // f p.1 = Sum.inr p.2 }
m : Z ⟶ s.pt
e₁ : (fun p => (↑p).1) ≫ m = BinaryCofan.inl s
e₂ : (fun p => (↑p).1) ≫ m = BinaryCofan.inr s
x : Z
h✝ : ¬f x = Sum.inl PUnit.unit
⊢ m x = BinaryCofan.inr s (eY.symm { val := x, property := (_ : f x = Sum.inr PUnit.unit) })

Next tactic:
rw [← e₂]