@[simp]
theorem colimitPresheafObjIsoComponentwiseLimit_inv_ι_app (F : J ⥤ PresheafedSpace.{_, _, v} C)
    (U : Opens (Limits.colimit F).carrier) (j : J) :
    (colimitPresheafObjIsoComponentwiseLimit F U).inv ≫ (colimit.ι F j).c.app (op U) =
      limit.π _ (op j) := by
  delta colimitPresheafObjIsoComponentwiseLimit
  rw [Iso.trans_inv, Iso.trans_inv, Iso.app_inv, sheafIsoOfIso_inv, pushforwardToOfIso_app,
    congr_app (Iso.symm_inv _)]
  dsimp
  rw [map_id, comp_id, assoc, assoc, assoc, NatTrans.naturality]
  erw [← comp_c_app_assoc]
  rw [congr_app (colimit.isoColimitCocone_ι_hom _ _), assoc]
  erw [limitObjIsoLimitCompEvaluation_inv_π_app_assoc, limMap_π_assoc]
  -- Porting note : `convert` doesn't work due to meta variable, so change to a `suffices` block
  set f := _
  change _ ≫ f = _
  suffices f_eq : f = 𝟙 _ by rw [f_eq, comp_id]
  erw [← (F.obj j).presheaf.map_id]
  change (F.obj j).presheaf.map _ ≫ _ = _
  erw [← (F.obj j).presheaf.map_comp, ← (F.obj j).presheaf.map_comp]
  

Proof state:
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
U : Opens ↑↑(Limits.colimit F)
j : J
f : (componentwiseDiagram F U).obj (op j) ⟶ (F.obj j).presheaf.obj (op ((Opens.map (colimit.ι F j).base).obj U)) :=
  (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (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)))).inv.app
      (op j) ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Opens.map
                      ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)) =
              (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)))) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            op
                {
                  carrier :=
                    ⇑(colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      (⇑(colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                        ↑U),
                  is_open' :=
                    (_ :
                      IsOpen
                        (⇑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ↑{
                              carrier :=
                                ⇑(colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                  ↑U,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (⇑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U)) })) } =
              op U))
⊢ (F.obj j).presheaf.map
      ((eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) (op j).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 (op j).unop).base).obj U))).inv ≫
        eqToHom
            (_ :
              (Opens.map
                        ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app
                            j).base).op.obj
                  (op
                    ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U)) =
                (Opens.map
                        (colimit.ι F j ≫
                            (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                  (op
                    ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U))) ≫
          (Opens.map (colimit.ι F j).base).op.map
            (eqToHom
              (_ :
                op
                    {
                      carrier :=
                        ⇑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          (⇑(colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                            ↑U),
                      is_open' :=
                        (_ :
                          IsOpen
                            (⇑(colimit.isoColimitCocone
                                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                              ↑{
                                  carrier :=
                                    ⇑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (⇑(colimit.isoColimitCocone
                                                  { cocone := colimitCocone F,
                                                    isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                          ↑U)) })) } =
                  op U))) =
    (F.obj j).presheaf.map (𝟙 (op ((Opens.map (colimit.ι F (op j).unop).base).obj U)))

Next tactic:
congr 1