instance finitaryExtensive_TopCat : FinitaryExtensive TopCat.{u} := by
  rw [finitaryExtensive_iff_of_isTerminal TopCat.{u} _ TopCat.isTerminalPUnit _
      (TopCat.binaryCofanIsColimit _ _)]
  apply BinaryCofan.isVanKampen_mk _ _ (fun X Y => TopCat.binaryCofanIsColimit X Y) _
      fun f g => TopCat.pullbackConeIsLimit f g
  · intro X' Y' αX αY 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
        · exact ⟨val, rfl, fun y h => Sum.inl_injective h.symm⟩
        · apply_fun f at h
          cases ((ConcreteCategory.congr_hom s.condition x).symm.trans h).trans
            (ConcreteCategory.congr_hom hαY val : _).symm
      delta ExistsUnique at this
      choose l hl hl' using this
      refine' ⟨⟨l, _⟩, ContinuousMap.ext fun a => (hl a).symm, TopCat.isTerminalPUnit.hom_ext _ _,
        fun {l'} h₁ _ => ContinuousMap.ext fun x =>
          hl' x (l' x) (ConcreteCategory.congr_hom h₁ x).symm⟩
      apply (embedding_inl (α := X') (β := Y')).toInducing.continuous_iff.mpr
      convert s.fst.2 using 1
      exact (funext hl).symm
    · refine' ⟨⟨hαY.symm⟩, ⟨PullbackCone.isLimitAux' _ _⟩⟩
      intro s
      

Proof state:
case h₁.right
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
X' Y' : TopCat
αX : X' ⟶ TopCat.of PUnit.{u + 1}
αY : Y' ⟶ TopCat.of PUnit.{u + 1}
f : (TopCat.binaryCofan X' Y').pt ⟶ (TopCat.binaryCofan (TopCat.of PUnit.{u + 1}) (TopCat.of PUnit.{u + 1})).pt
hαX :
  αX ≫ BinaryCofan.inl (TopCat.binaryCofan (TopCat.of PUnit.{u + 1}) (TopCat.of PUnit.{u + 1})) =
    BinaryCofan.inl (TopCat.binaryCofan X' Y') ≫ f
hαY :
  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit.{u + 1}) (TopCat.of PUnit.{u + 1})) =
    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f
s : PullbackCone f (BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit.{u + 1}) (TopCat.of PUnit.{u + 1})))
⊢ { l //
    l ≫
          PullbackCone.fst
            (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
              (_ :
                BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                  αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit.{u + 1}) (TopCat.of PUnit.{u + 1})))) =
        PullbackCone.fst s ∧
      l ≫
            PullbackCone.snd
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                (_ :
                  BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                    αY ≫ BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit.{u + 1}) (TopCat.of PUnit.{u + 1})))) =
          PullbackCone.snd s ∧
        ∀
          {m :
            s.pt ⟶
              (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                  (_ :
                    BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                      αY ≫
                        BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit.{u + 1}) (TopCat.of PUnit.{u + 1})))).pt},
          m ≫
                PullbackCone.fst
                  (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                    (_ :
                      BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                        αY ≫
                          BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit.{u + 1}) (TopCat.of PUnit.{u + 1})))) =
              PullbackCone.fst s →
            m ≫
                  PullbackCone.snd
                    (PullbackCone.mk (BinaryCofan.inr (TopCat.binaryCofan X' Y')) αY
                      (_ :
                        BinaryCofan.inr (TopCat.binaryCofan X' Y') ≫ f =
                          αY ≫
                            BinaryCofan.inr (TopCat.binaryCofan (TopCat.of PUnit.{u + 1}) (TopCat.of PUnit.{u + 1})))) =
                PullbackCone.snd s →
              m = l }

Next tactic:
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 ((ConcreteCategory.congr_hom s.condition x).symm.trans h).trans
            (ConcreteCategory.congr_hom hαX val : _).symm
        · exact ⟨val, rfl, fun y h => Sum.inr_injective h.symm⟩