@[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 _)]
  

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
⊢ (((Limits.lim.mapIso
              (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 ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              ((Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F,
                                isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                (op U))).inv) ≫
        ((colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c.app
              (op
                ((Opens.map
                      ((forget C).mapIso
                            (colimit.isoColimitCocone
                                { cocone := colimitCocone F,
                                  isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                  (op U).unop)) ≫
            (Limits.colimit F).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base).op.obj
                      (op
                        ((Opens.map
                              ((forget C).mapIso
                                    (colimit.isoColimitCocone
                                        { cocone := colimitCocone F,
                                          isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                          (op U).unop)) =
                    (Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.inv.base).op.obj
                      (op
                        ((Opens.map
                              ((forget C).mapIso
                                    (colimit.isoColimitCocone
                                        { cocone := colimitCocone F,
                                          isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                          (op U).unop))))) ≫
          (Limits.colimit F).presheaf.map
            (eqToHom
              (_ :
                op
                    {
                      carrier :=
                        ⇑((forget C).mapIso
                                  (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm).symm.hom ⁻¹'
                          ↑(op
                                {
                                  carrier :=
                                    ⇑((forget C).mapIso
                                              (colimit.isoColimitCocone
                                                  { cocone := colimitCocone F,
                                                    isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                      ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (⇑((forget C).mapIso
                                                  (colimit.isoColimitCocone
                                                      { cocone := colimitCocone F,
                                                        isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                          ↑(op U).unop)) }).unop,
                      is_open' :=
                        (_ :
                          IsOpen
                            (⇑((forget C).mapIso
                                      (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm).symm.hom ⁻¹'
                              ↑(op
                                    {
                                      carrier :=
                                        ⇑((forget C).mapIso
                                                  (colimit.isoColimitCocone
                                                      { cocone := colimitCocone F,
                                                        isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                          ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (⇑((forget C).mapIso
                                                      (colimit.isoColimitCocone
                                                          { cocone := colimitCocone F,
                                                            isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                              ↑(op U).unop)) }).unop)) } =
                  op U))) ≫
      (colimit.ι F j).c.app (op U) =
    limit.π (componentwiseDiagram F U) (op j)

Next tactic:
dsimp