/-- The components of the colimit of a diagram of `PresheafedSpace C` is obtained
via taking componentwise limits.
-/
def colimitPresheafObjIsoComponentwiseLimit (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) :
    (Limits.colimit F).presheaf.obj (op U) ≅ limit (componentwiseDiagram F U) := by
  refine'
    ((sheafIsoOfIso (colimit.isoColimitCocone ⟨_, colimitCoconeIsColimit F⟩).symm).app
          (op U)).trans
      _
  refine' (limitObjIsoLimitCompEvaluation _ _).trans (Limits.lim.mapIso _)
  fapply NatIso.ofComponents
  · intro X
    refine' (F.obj (unop X)).presheaf.mapIso (eqToIso _)
    simp only [Functor.op_obj, unop_op, op_inj_iff, Opens.map_coe, SetLike.ext'_iff,
      Set.preimage_preimage]
    refine congr_arg (Set.preimage . U.1) (funext fun x => ?_)
    erw [← comp_app]
    congr
    exact ι_preservesColimitsIso_inv (forget C) F (unop X)
  · intro X Y f
    change ((F.map f.unop).c.app _ ≫ _ ≫ _) ≫ (F.obj (unop Y)).presheaf.map _ = _ ≫ _
    rw [TopCat.Presheaf.Pushforward.comp_inv_app]
    erw [Category.id_comp]
    rw [Category.assoc]
    erw [← (F.obj (unop Y)).presheaf.map_comp, (F.map f.unop).c.naturality_assoc,
      ← (F.obj (unop Y)).presheaf.map_comp]
    

Proof state:
case naturality
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
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X Y : Jᵒᵖ
f : X ⟶ Y
⊢ (F.map f.unop).c.app
        ((Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
          ((Opens.map
                  (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
            (op U))) ≫
      (F.obj Y.unop).presheaf.map
        ((NatIso.op
                  (Opens.mapIso ((F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) X.unop)
                      (colimit.ι (F ⋙ forget C) Y.unop)
                      (_ :
                        (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) X.unop =
                          colimit.ι (F ⋙ forget C) Y.unop)).symm).hom.app
            ((Opens.map
                    (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
              (op U)) ≫
          (eqToIso
              (_ :
                (Opens.map (colimit.ι (F ⋙ forget C) Y.unop)).op.obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                      (op U)) =
                  op ((Opens.map (colimit.ι F Y.unop).base).obj U))).hom) =
    (F.map f.unop).c.app
        ((Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
          ((Opens.map
                  (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
            (op U))) ≫
      (F.obj Y.unop).presheaf.map
        ((Opens.map (F.map f.unop).base).op.map
            (eqToIso
                (_ :
                  (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                      ((Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                        (op U)) =
                    op ((Opens.map (colimit.ι F X.unop).base).obj U))).hom ≫
          eqToHom
            (_ :
              (Opens.map (F.map f.unop).base).op.obj (op ((Opens.map (colimit.ι F X.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F Y.unop).base).obj U)))

Next tactic:
rfl