-- Lean 4 proof step from Mathlib.Geometry.RingedSpace.PresheafedSpace.HasColimits (goal)
Goal:
J : Type u'
inst : Category.{v', u'} J
C : Type u
inst_1 : Category.{v, u} C
inst_2 : HasColimitsOfShape.{v', u', v, v + 1} J TopCat
inst_3 : ∀ (X : TopCat.{v}), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst_4 : HasLimitsOfShape.{v', u', v, u} Jᵒᵖ C
F : J ⥤ PresheafedSpace.{v, u, v} C
inst_5 : HasColimit F
U : Opens (↑(↑(Limits.colimit F) : TopCat) : Type v)
X Y : Jᵒᵖ
f : X ⟶ Y
⊢ Eq (α :=
    (F.obj (unop X)).presheaf.obj
        (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop X))))
          (obj
            (Functor.op
              (Opens.map
                (Hom.base
                  (Iso.hom
                    (Iso.symm
                      (colimit.isoColimitCocone
                        { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
            (op U))) ⟶
      (F.obj (unop Y)).presheaf.obj (op (obj (Opens.map (Hom.base (colimit.ι F (unop Y)))) U)))
    (CategoryStruct.comp (Y :=
        (F.obj (unop Y)).presheaf.obj
          (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop Y))))
            (obj
              (Functor.op
                (Opens.map
                  (Hom.base
                    (Iso.hom
                      (Iso.symm
                        (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
              (op U))))
        ((F.map f.unop).c.app
              (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop X))))
                (obj
                  (Functor.op
                    (Opens.map
                      (Hom.base
                        (Iso.hom
                          (Iso.symm
                            (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F :
                                ColimitCocone F }))))))
                  (op U))) ≫
            NatTrans.app
                (Iso.inv
                  (Pushforward.comp ((F ⋙ forget C).map f.unop) (colimit.ι (F ⋙ forget C) (unop X))
                    (F.obj (unop Y)).presheaf))
                (obj
                  (Functor.op
                    (Opens.map
                      (Hom.base
                        (Iso.hom
                          (Iso.symm
                            (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F :
                                ColimitCocone F }))))))
                  (op U)) ≫
              NatTrans.app (Iso.hom (pushforwardEq ⋯ (F.obj (unop Y)).presheaf))
                (obj
                  (Functor.op
                    (Opens.map
                      (Hom.base
                        (Iso.hom
                          (Iso.symm
                            (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F :
                                ColimitCocone F }))))))
                  (op U)) :
          (F.obj (unop X)).presheaf.obj
              (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop X))))
                (obj
                  (Functor.op
                    (Opens.map
                      (Hom.base
                        (Iso.hom
                          (Iso.symm
                            (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F :
                                ColimitCocone F }))))))
                  (op U))) ⟶
            (F.obj (unop Y)).presheaf.obj
              (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop Y))))
                (obj
                  (Functor.op
                    (Opens.map
                      (Hom.base
                        (Iso.hom
                          (Iso.symm
                            (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F :
                                ColimitCocone F }))))))
                  (op U))))
        ((F.obj (unop Y)).presheaf.map (Iso.hom (eqToIso ⋯)) :
          (F.obj (unop Y)).presheaf.obj
              (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop Y))))
                (obj
                  (Functor.op
                    (Opens.map
                      (Hom.base
                        (Iso.hom
                          (Iso.symm
                            (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F :
                                ColimitCocone F }))))))
                  (op U))) ⟶
            (F.obj (unop Y)).presheaf.obj (op (obj (Opens.map (Hom.base (colimit.ι F (unop Y)))) U))) :
      (F.obj (unop X)).presheaf.obj
          (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop X))))
            (obj
              (Functor.op
                (Opens.map
                  (Hom.base
                    (Iso.hom
                      (Iso.symm
                        (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
              (op U))) ⟶
        (F.obj (unop Y)).presheaf.obj (op (obj (Opens.map (Hom.base (colimit.ι F (unop Y)))) U)))
    (Iso.hom (mapIso (F.obj (unop X)).presheaf (eqToIso ⋯)) ≫ (componentwiseDiagram F U).map f :
      (F.obj (unop X)).presheaf.obj
          (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop X))))
            (obj
              (Functor.op
                (Opens.map
                  (Hom.base
                    (Iso.hom
                      (Iso.symm
                        (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
              (op U))) ⟶
        (F.obj (unop Y)).presheaf.obj (op (obj (Opens.map (Hom.base (colimit.ι F (unop Y)))) U)))
have naturality : CategoryStruct.comp (Y :=
    (F.obj (unop Y)).presheaf.obj
      (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop Y))))
        (obj
          (Functor.op
            (Opens.map
              (Hom.base
                (Iso.hom
                  (Iso.symm
                    (colimit.isoColimitCocone
                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
          (op U))))
    ((F.map f.unop).c.app
          (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop X))))
            (obj
              (Functor.op
                (Opens.map
                  (Hom.base
                    (Iso.hom
                      (Iso.symm
                        (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
              (op U))) ≫
        𝟙
            (obj
              (obj (pushforward C (colimit.ι (F ⋙ forget C) (unop X)))
                (obj (pushforward C ((F ⋙ forget C).map f.unop)) (F.obj (unop Y)).presheaf))
              (obj
                (Functor.op
                  (Opens.map
                    (Hom.base
                      (Iso.hom
                        (Iso.symm
                          (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
                (op U))) ≫
          NatTrans.app (Iso.hom (pushforwardEq sorry (F.obj (unop Y)).presheaf))
            (obj
              (Functor.op
                (Opens.map
                  (Hom.base
                    (Iso.hom
                      (Iso.symm
                        (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
              (op U)) :
      (F.obj (unop X)).presheaf.obj
          (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop X))))
            (obj
              (Functor.op
                (Opens.map
                  (Hom.base
                    (Iso.hom
                      (Iso.symm
                        (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
              (op U))) ⟶
        (F.obj (unop Y)).presheaf.obj
          (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop Y))))
            (obj
              (Functor.op
                (Opens.map
                  (Hom.base
                    (Iso.hom
                      (Iso.symm
                        (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
              (op U))))
    ((F.obj (unop Y)).presheaf.map (Iso.hom (eqToIso sorry)) :
      (F.obj (unop Y)).presheaf.obj
          (obj (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) (unop Y))))
            (obj
              (Functor.op
                (Opens.map
                  (Hom.base
                    (Iso.hom
                      (Iso.symm
                        (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F : ColimitCocone F }))))))
              (op U))) ⟶
        (F.obj (unop Y)).presheaf.obj (op (obj (Opens.map (Hom.base (colimit.ι F (unop Y)))) U))) =
  Iso.hom (mapIso (F.obj (unop X)).presheaf (eqToIso sorry)) ≫ (componentwiseDiagram F U).map f
Tactic: rw [TopCat.Presheaf.Pushforward.comp_inv_app]