/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.instHasColimits`.
-/
def colimitCoconeIsColimit (F : J ⥤ PresheafedSpace.{_, _, v} C) :
    IsColimit (colimitCocone F) where
  desc s := desc F s
  fac s := desc_fac F s
  uniq s m w := by
    -- We need to use the identity on the continuous maps twice, so we prepare that first:
    have t :
      m.base =
        colimit.desc (F ⋙ PresheafedSpace.forget C) ((PresheafedSpace.forget C).mapCocone s) := by
      dsimp
      ext j
      rw [colimit.ι_desc, mapCocone_ι_app, ← w j]
      simp
    ext : 1
    · exact t
    · refine NatTrans.ext _ _ (funext fun U => limit_obj_ext fun j => ?_)
      dsimp only [colimitCocone_pt, colimit_carrier, leftOp_obj, pushforwardDiagramToColimit_obj,
        comp_obj, forget_obj, unop_op, op_obj, desc, colimit_presheaf, descCApp, mapCocone_pt,
        pushforwardObj_obj, const_obj_obj, id_eq, evaluation_obj_obj, Eq.ndrec, eq_mpr_eq_cast]
      rw [NatTrans.comp_app, whiskerRight_app]
      simp only [pushforwardObj_obj, op_obj, comp_obj, eqToHom_app, eqToHom_map, assoc,
        limitObjIsoLimitCompEvaluation_inv_π_app, limit.lift_π]
      rw [PresheafedSpace.congr_app (w (unop j)).symm U]
      dsimp
      have w := congr_arg op (Functor.congr_obj (congr_arg Opens.map t) (unop U))
      rw [NatTrans.congr (limit.π (pushforwardDiagramToColimit F).leftOp j) w]
      

Proof state:
case h
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w✝ : ∀ (j : J), (colimitCocone F).ι.app j ≫ m = s.ι.app j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
w :
  op ((Opens.map m.base).obj U.unop) =
    op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)
⊢ m.c.app U ≫
      eqToHom
          (_ :
            (limit (pushforwardDiagramToColimit F).leftOp).obj (op ((Opens.map m.base).obj U.unop)) =
              (limit (pushforwardDiagramToColimit F).leftOp).obj
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        (limit.π (pushforwardDiagramToColimit F).leftOp j).app
          (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    ((m.c.app U ≫
          (limit (pushforwardDiagramToColimit F).leftOp).map (eqToHom w) ≫
            (limit.π (pushforwardDiagramToColimit F).leftOp j).app
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
              ((pushforwardDiagramToColimit F).leftOp.obj j).map
                (eqToHom
                  (_ :
                    op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop) =
                      op ((Opens.map m.base).obj U.unop)))) ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map ((colimitCocone F).ι.app j.unop ≫ m).base).obj U.unop) =
                op ((Opens.map (s.ι.app j.unop).base).obj U.unop)))) ≫
      eqToHom
        (_ :
          (F.obj j.unop).presheaf.obj (op ((Opens.map (s.ι.app j.unop).base).obj U.unop)) =
            (F.obj j.unop).presheaf.obj
              (op
                ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                  ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))

Next tactic:
simp