Theorem: AlgebraicGeometry.PresheafedSpace.colimitPresheafObjIsoComponentwiseLimit_inv_ι_app
File: Mathlib/AlgebraicGeometry/PresheafedSpace/HasColimits.lean

tactic: delta colimitPresheafObjIsoComponentwiseLimit
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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
⊢ (colimitPresheafObjIsoComponentwiseLimit F U).inv ≫ (colimit.ι F j).c.app U.op =
    limit.π (componentwiseDiagram F U) j.op

tactic: rw [Iso.trans_inv, Iso.trans_inv, Iso.app_inv, sheafIsoOfIso_inv, pushforwardToOfIso_app,
  congr_app (Iso.symm_inv _)]
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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
⊢ ((sheafIsoOfIso
                (colimit.isoColimitCocone
                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm).app
            U.op ≪≫
          limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              ((Functor.op
                    (Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                U.op) ≪≫
            Limits.lim.mapIso
              (NatIso.ofComponents fun X =>
                (F.obj X.unop).presheaf.mapIso
                  (eqToIso
                    (_ :
                      (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                          ((Functor.op
                                (Opens.map
                                  (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                            U.op) =
                        ((Opens.map (colimit.ι F X.unop).base).obj U).op)))).inv ≫
      (colimit.ι F j).c.app U.op =
    limit.π (componentwiseDiagram F U) j.op

tactic: dsimp
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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
                    (_ :
                      (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                          ((Functor.op
                                (Opens.map
                                  (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                            U.op) =
                        ((Opens.map (colimit.ι F X.unop).base).obj U).op)))).inv ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              ((Functor.op
                    (Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                U.op)).inv) ≫
        ((colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c.app
              ((Opens.map
                      ((forget C).mapIso
                            (colimit.isoColimitCocone
                                { cocone := colimitCocone F,
                                  isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                  U.op.unop).op ≫
            (Limits.colimit F).presheaf.map
              (eqToHom
                (_ :
                  (Functor.op
                          (Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base)).obj
                      ((Opens.map
                              ((forget C).mapIso
                                    (colimit.isoColimitCocone
                                        { cocone := colimitCocone F,
                                          isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                          U.op.unop).op =
                    (Functor.op
                          (Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.inv.base)).obj
                      ((Opens.map
                              ((forget C).mapIso
                                    (colimit.isoColimitCocone
                                        { cocone := colimitCocone F,
                                          isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                          U.op.unop).op))) ≫
          (Limits.colimit F).presheaf.map
            (eqToHom
              (_ :
                {
                      carrier :=
                        (CategoryTheory.forget TopCat).map
                            ((forget C).mapIso
                                  (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm).symm.hom ⁻¹'
                          ↑{
                                  carrier :=
                                    (CategoryTheory.forget TopCat).map
                                        ((forget C).mapIso
                                              (colimit.isoColimitCocone
                                                  { cocone := colimitCocone F,
                                                    isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                      ↑U.op.unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑((forget C).mapIso
                                                  (colimit.isoColimitCocone
                                                      { cocone := colimitCocone F,
                                                        isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                          ↑U.op.unop)) }.op.unop,
                      is_open' :=
                        (_ :
                          IsOpen
                            (↑((forget C).mapIso
                                      (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm).symm.hom ⁻¹'
                              ↑{
                                      carrier :=
                                        (CategoryTheory.forget TopCat).map
                                            ((forget C).mapIso
                                                  (colimit.isoColimitCocone
                                                      { cocone := colimitCocone F,
                                                        isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                          ↑U.op.unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑((forget C).mapIso
                                                      (colimit.isoColimitCocone
                                                          { cocone := colimitCocone F,
                                                            isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                              ↑U.op.unop)) }.op.unop)) }.op =
                  U.op))) ≫
      (colimit.ι F j).c.app U.op =
    limit.π (componentwiseDiagram F U) j.op

tactic: rw [map_id, comp_id, assoc, assoc, assoc, NatTrans.naturality]
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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
⊢ ((limMap
            (NatIso.ofComponents fun X =>
                (F.obj X.unop).presheaf.mapIso
                  (eqToIso
                    (_ :
                      (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                          ((Functor.op
                                (Opens.map
                                  (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                            U.op) =
                        ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              ((Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U).op).inv) ≫
        ((colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c.app
              ((Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U).op ≫
            (Limits.colimit F).presheaf.map
              (𝟙
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base).obj
                    ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U)).op)) ≫
          (Limits.colimit F).presheaf.map
            (eqToHom
              (_ :
                {
                      carrier :=
                        (CategoryTheory.forget TopCat).map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ((CategoryTheory.forget TopCat).map
                              (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 :=
                                    (CategoryTheory.forget TopCat).map
                                        (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.op))) ≫
      (colimit.ι F j).c.app U.op =
    limit.π (componentwiseDiagram F U) j.op

tactic: erw [← comp_c_app_assoc]
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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
⊢ limMap
        (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                      ((Functor.op
                            (Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                        U.op) =
                    ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U).op).inv ≫
        (colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c.app
            ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U).op ≫
          (colimit.ι F j).c.app
              ((Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base).obj
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)).op ≫
            ((colimit.ι F j).base _* (F.obj j).presheaf).map
              (eqToHom
                (_ :
                  {
                        carrier :=
                          (CategoryTheory.forget TopCat).map
                              (colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                            ((CategoryTheory.forget TopCat).map
                                (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 :=
                                      (CategoryTheory.forget TopCat).map
                                          (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.op)) =
    limit.π (componentwiseDiagram F U) j.op

tactic: rw [congr_app (colimit.isoColimitCocone_ι_hom _ _), assoc]
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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
⊢ limMap
        (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                      ((Functor.op
                            (Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                        U.op) =
                    ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U).op).inv ≫
        (colimit.ι F j ≫
                  (colimit.isoColimitCocone
                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).c.app
            ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U).op ≫
          ((colimit.ι F j).base _* (F.obj j).presheaf).map
            (eqToHom
              (_ :
                {
                      carrier :=
                        (CategoryTheory.forget TopCat).map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ((CategoryTheory.forget TopCat).map
                              (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 :=
                                    (CategoryTheory.forget TopCat).map
                                        (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.op)) =
    limit.π (componentwiseDiagram F U) j.op

tactic: erw [limitObjIsoLimitCompEvaluation_inv_π_app_assoc, limMap_π_assoc]
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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
⊢ limMap
        (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                      ((Functor.op
                            (Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                        U.op) =
                    ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U).op).inv ≫
        ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).c.app
            ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U).op ≫
          (F.obj j).presheaf.map
              (eqToHom
                (_ :
                  (Functor.op
                          (Opens.map
                            ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app
                                j).base)).obj
                      ((Opens.map
                              (colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                          U).op =
                    (Functor.op
                          (Opens.map
                            (colimit.ι F j ≫
                                (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                      ((Opens.map
                              (colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                          U).op)) ≫
            ((colimit.ι F j).base _* (F.obj j).presheaf).map
              (eqToHom
                (_ :
                  {
                        carrier :=
                          (CategoryTheory.forget TopCat).map
                              (colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                            ((CategoryTheory.forget TopCat).map
                                (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 :=
                                      (CategoryTheory.forget TopCat).map
                                          (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.op)) =
    limit.π (componentwiseDiagram F U) j.op

tactic: set f := _
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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
⊢ limit.π (componentwiseDiagram F U) j.op ≫
      (NatIso.ofComponents fun X =>
                (F.obj X.unop).presheaf.mapIso
                  (eqToIso
                    (_ :
                      (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                          ((Functor.op
                                (Opens.map
                                  (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                            U.op) =
                        ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv.app
          j.op ≫
        (F.obj j).presheaf.map
            (eqToHom
              (_ :
                (Functor.op
                        (Opens.map
                          ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app
                              j).base)).obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                        U).op =
                  (Functor.op
                        (Opens.map
                          (colimit.ι F j ≫
                              (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                        U).op)) ≫
          ((colimit.ι F j).base _* (F.obj j).presheaf).map
            (eqToHom
              (_ :
                {
                      carrier :=
                        (CategoryTheory.forget TopCat).map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ((CategoryTheory.forget TopCat).map
                              (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 :=
                                    (CategoryTheory.forget TopCat).map
                                        (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.op)) =
    limit.π (componentwiseDiagram F U) j.op

tactic: change _ ≫ f = _
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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 : ?m.283773 := ?m.283774
⊢ limit.π (componentwiseDiagram F U) j.op ≫
      (NatIso.ofComponents fun X =>
                (F.obj X.unop).presheaf.mapIso
                  (eqToIso
                    (_ :
                      (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                          ((Functor.op
                                (Opens.map
                                  (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                            U.op) =
                        ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv.app
          j.op ≫
        (F.obj j).presheaf.map
            (eqToHom
              (_ :
                (Functor.op
                        (Opens.map
                          ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app
                              j).base)).obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                        U).op =
                  (Functor.op
                        (Opens.map
                          (colimit.ι F j ≫
                              (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                        U).op)) ≫
          ((colimit.ι F j).base _* (F.obj j).presheaf).map
            (eqToHom
              (_ :
                {
                      carrier :=
                        (CategoryTheory.forget TopCat).map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ((CategoryTheory.forget TopCat).map
                              (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 :=
                                    (CategoryTheory.forget TopCat).map
                                        (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.op)) =
    limit.π (componentwiseDiagram F U) j.op

tactic: suffices f_eq : f = 𝟙 _ by rw [f_eq, comp_id]
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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 j.op ⟶ (F.obj j).presheaf.obj ((Opens.map (colimit.ι F j).base).obj U).op :=
  (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                      ((Functor.op
                            (Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                        U.op) =
                    ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv.app
      j.op ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Functor.op
                    (Opens.map
                      ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op =
              (Functor.op
                    (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op)) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            {
                  carrier :=
                    (CategoryTheory.forget TopCat).map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      ((CategoryTheory.forget TopCat).map
                          (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 :=
                                (CategoryTheory.forget TopCat).map
                                    (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.op))
⊢ limit.π (componentwiseDiagram F U) j.op ≫ f = limit.π (componentwiseDiagram F U) j.op

tactic: erw [← (F.obj j).presheaf.map_id]
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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 j.op ⟶ (F.obj j).presheaf.obj ((Opens.map (colimit.ι F j).base).obj U).op :=
  (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                      ((Functor.op
                            (Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                        U.op) =
                    ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv.app
      j.op ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Functor.op
                    (Opens.map
                      ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op =
              (Functor.op
                    (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op)) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            {
                  carrier :=
                    (CategoryTheory.forget TopCat).map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      ((CategoryTheory.forget TopCat).map
                          (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 :=
                                (CategoryTheory.forget TopCat).map
                                    (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.op))
⊢ f = 𝟙 ((componentwiseDiagram F U).obj j.op)

tactic: change (F.obj j).presheaf.map _ ≫ _ = _
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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 j.op ⟶ (F.obj j).presheaf.obj ((Opens.map (colimit.ι F j).base).obj U).op :=
  (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                      ((Functor.op
                            (Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                        U.op) =
                    ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv.app
      j.op ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Functor.op
                    (Opens.map
                      ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op =
              (Functor.op
                    (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op)) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            {
                  carrier :=
                    (CategoryTheory.forget TopCat).map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      ((CategoryTheory.forget TopCat).map
                          (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 :=
                                (CategoryTheory.forget TopCat).map
                                    (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.op))
⊢ f = (F.obj j).presheaf.map (𝟙 ((Opens.map (colimit.ι F j.op.unop).base).obj U).op)

tactic: erw [← (F.obj j).presheaf.map_comp, ← (F.obj j).presheaf.map_comp]
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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 j.op ⟶ (F.obj j).presheaf.obj ((Opens.map (colimit.ι F j).base).obj U).op :=
  (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                      ((Functor.op
                            (Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                        U.op) =
                    ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv.app
      j.op ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Functor.op
                    (Opens.map
                      ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op =
              (Functor.op
                    (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op)) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            {
                  carrier :=
                    (CategoryTheory.forget TopCat).map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      ((CategoryTheory.forget TopCat).map
                          (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 :=
                                (CategoryTheory.forget TopCat).map
                                    (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.op))
⊢ (F.obj j).presheaf.map
        (eqToIso
            (_ :
              (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) j.op.unop))).obj
                  ((Functor.op
                        (Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                    U.op) =
                ((Opens.map (colimit.ι F j.op.unop).base).obj U).op)).inv ≫
      (F.obj j).presheaf.map
          (eqToHom
            (_ :
              (Functor.op
                      (Opens.map
                        ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).base)).obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U).op =
                (Functor.op
                      (Opens.map
                        (colimit.ι F j ≫
                            (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U).op)) ≫
        ((colimit.ι F j).base _* (F.obj j).presheaf).map
          (eqToHom
            (_ :
              {
                    carrier :=
                      (CategoryTheory.forget TopCat).map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                        ((CategoryTheory.forget TopCat).map
                            (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 :=
                                  (CategoryTheory.forget TopCat).map
                                      (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.op)) =
    (F.obj j).presheaf.map (𝟙 ((Opens.map (colimit.ι F j.op.unop).base).obj U).op)

tactic: congr 1
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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 j.op ⟶ (F.obj j).presheaf.obj ((Opens.map (colimit.ι F j).base).obj U).op :=
  (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                      ((Functor.op
                            (Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                        U.op) =
                    ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv.app
      j.op ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Functor.op
                    (Opens.map
                      ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op =
              (Functor.op
                    (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op)) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            {
                  carrier :=
                    (CategoryTheory.forget TopCat).map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      ((CategoryTheory.forget TopCat).map
                          (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 :=
                                (CategoryTheory.forget TopCat).map
                                    (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.op))
⊢ (F.obj j).presheaf.map
      ((eqToIso
            (_ :
              (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) j.op.unop))).obj
                  ((Functor.op
                        (Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                    U.op) =
                ((Opens.map (colimit.ι F j.op.unop).base).obj U).op)).inv ≫
        eqToHom
            (_ :
              (Functor.op
                      (Opens.map
                        ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).base)).obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U).op =
                (Functor.op
                      (Opens.map
                        (colimit.ι F j ≫
                            (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U).op) ≫
          (Functor.op (Opens.map (colimit.ι F j).base)).map
            (eqToHom
              (_ :
                {
                      carrier :=
                        (CategoryTheory.forget TopCat).map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ((CategoryTheory.forget TopCat).map
                              (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 :=
                                    (CategoryTheory.forget TopCat).map
                                        (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.op))) =
    (F.obj j).presheaf.map (𝟙 ((Opens.map (colimit.ι F j.op.unop).base).obj U).op)

tactic: rw [f_eq, comp_id]
state_before: J : Type u'
inst✝⁴ : Category J
C : Type u
inst✝³ : Category 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 j.op ⟶ (F.obj j).presheaf.obj ((Opens.map (colimit.ι F j).base).obj U).op :=
  (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Functor.op (Opens.map (colimit.ι (F ⋙ forget C) X.unop))).obj
                      ((Functor.op
                            (Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base)).obj
                        U.op) =
                    ((Opens.map (colimit.ι F X.unop).base).obj U).op))).inv.app
      j.op ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Functor.op
                    (Opens.map
                      ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op =
              (Functor.op
                    (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base)).obj
                ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U).op)) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            {
                  carrier :=
                    (CategoryTheory.forget TopCat).map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      ((CategoryTheory.forget TopCat).map
                          (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 :=
                                (CategoryTheory.forget TopCat).map
                                    (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.op))
f_eq : f = 𝟙 ((componentwiseDiagram F U).obj j.op)
⊢ limit.π (componentwiseDiagram F U) j.op ≫ f = limit.π (componentwiseDiagram F U) j.op