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

tactic: delta colimitPresheafObjIsoComponentwiseLimit
state_before: 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
⊢ (colimitPresheafObjIsoComponentwiseLimit F U).inv ≫ (colimit.ι F j).c.app { unop := U } =
    limit.π (componentwiseDiagram F U) { unop := j }
state_after: 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
⊢ ((sheafIsoOfIso
                (colimit.isoColimitCocone
                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm).app
            { unop := U } ≪≫
          limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              ((Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F,
                                isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                { unop := U }) ≪≫
            Limits.lim.mapIso (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯)).inv ≫
      (colimit.ι F j).c.app { unop := U } =
    limit.π (componentwiseDiagram F U) { unop := j }

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.{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
⊢ ((sheafIsoOfIso
                (colimit.isoColimitCocone
                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm).app
            { unop := U } ≪≫
          limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              ((Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F,
                                isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                { unop := U }) ≪≫
            Limits.lim.mapIso (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯)).inv ≫
      (colimit.ι F j).c.app { unop := U } =
    limit.π (componentwiseDiagram F U) { unop := j }
state_after: 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 => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯)).inv ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              ((Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F,
                                isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                { unop := U })).inv) ≫
        ((colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c.app
              {
                unop :=
                  (Opens.map
                        ((forget C).mapIso
                              (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                    { unop := U }.unop } ≫
            (Limits.colimit F).presheaf.map (eqToHom ⋯)) ≫
          (Limits.colimit F).presheaf.map (eqToHom ⋯)) ≫
      (colimit.ι F j).c.app { unop := U } =
    limit.π (componentwiseDiagram F U) { unop := j }

tactic: dsimp
state_before: 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 => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯)).inv ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              ((Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F,
                                isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                { unop := U })).inv) ≫
        ((colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c.app
              {
                unop :=
                  (Opens.map
                        ((forget C).mapIso
                              (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                    { unop := U }.unop } ≫
            (Limits.colimit F).presheaf.map (eqToHom ⋯)) ≫
          (Limits.colimit F).presheaf.map (eqToHom ⋯)) ≫
      (colimit.ι F j).c.app { unop := U } =
    limit.π (componentwiseDiagram F U) { unop := j }
state_after: 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
⊢ ((limMap (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              {
                unop :=
                  (Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U }).inv) ≫
        ((colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c.app
              {
                unop :=
                  (Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U } ≫
            (Limits.colimit F).presheaf.map
              (𝟙
                {
                  unop :=
                    (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) })) ≫
          (Limits.colimit F).presheaf.map (eqToHom ⋯)) ≫
      (colimit.ι F j).c.app { unop := U } =
    limit.π (componentwiseDiagram F U) { unop := j }

tactic: rw [map_id, comp_id, assoc, assoc, assoc, NatTrans.naturality]
state_before: 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
⊢ ((limMap (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              {
                unop :=
                  (Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U }).inv) ≫
        ((colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c.app
              {
                unop :=
                  (Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U } ≫
            (Limits.colimit F).presheaf.map
              (𝟙
                {
                  unop :=
                    (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) })) ≫
          (Limits.colimit F).presheaf.map (eqToHom ⋯)) ≫
      (colimit.ι F j).c.app { unop := U } =
    limit.π (componentwiseDiagram F U) { unop := j }
state_after: 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
⊢ limMap (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U }).inv ≫
        (colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c.app
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U } ≫
          (colimit.ι F j).c.app
              {
                unop :=
                  (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) } ≫
            ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    limit.π (componentwiseDiagram F U) { unop := j }

tactic: erw [← comp_c_app_assoc]
state_before: 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
⊢ limMap (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U }).inv ≫
        (colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c.app
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U } ≫
          (colimit.ι F j).c.app
              {
                unop :=
                  (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) } ≫
            ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    limit.π (componentwiseDiagram F U) { unop := j }
state_after: 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
⊢ limMap (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U }).inv ≫
        (colimit.ι F j ≫
                  (colimit.isoColimitCocone
                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).c.app
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U } ≫
          ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    limit.π (componentwiseDiagram F U) { unop := j }

tactic: rw [congr_app (colimit.isoColimitCocone_ι_hom _ _), assoc]
state_before: 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
⊢ limMap (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U }).inv ≫
        (colimit.ι F j ≫
                  (colimit.isoColimitCocone
                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).c.app
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U } ≫
          ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    limit.π (componentwiseDiagram F U) { unop := j }
state_after: 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
⊢ limMap (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U }).inv ≫
        ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).c.app
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U } ≫
          (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    limit.π (componentwiseDiagram F U) { unop := j }

tactic: erw [limitObjIsoLimitCompEvaluation_inv_π_app_assoc, limMap_π_assoc]
state_before: 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
⊢ limMap (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U }).inv ≫
        ({ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι.app j).c.app
            {
              unop :=
                (Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U } ≫
          (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    limit.π (componentwiseDiagram F U) { unop := j }
state_after: 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
⊢ limit.π (componentwiseDiagram F U) { unop := j } ≫
      (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
        (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    limit.π (componentwiseDiagram F U) { unop := j }

tactic: set f := _
state_before: 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
⊢ limit.π (componentwiseDiagram F U) { unop := j } ≫
      (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
        (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    limit.π (componentwiseDiagram F U) { unop := j }
state_after: 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 : ?m.270454 := ?m.270455
⊢ limit.π (componentwiseDiagram F U) { unop := j } ≫
      (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
        (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    limit.π (componentwiseDiagram F U) { unop := j }

tactic: change _ ≫ f = _
state_before: 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 : ?m.270454 := ?m.270455
⊢ limit.π (componentwiseDiagram F U) { unop := j } ≫
      (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
        (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    limit.π (componentwiseDiagram F U) { unop := j }
state_after: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
⊢ limit.π (componentwiseDiagram F U) { unop := j } ≫ f = limit.π (componentwiseDiagram F U) { unop := j }

tactic: suffices f_eq : f = 𝟙 _ by rw [f_eq, comp_id]
state_before: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
⊢ limit.π (componentwiseDiagram F U) { unop := j } ≫ f = limit.π (componentwiseDiagram F U) { unop := j }
state_after: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
⊢ f = 𝟙 ((componentwiseDiagram F U).obj { unop := j })

tactic: erw [← (F.obj j).presheaf.map_id]
state_before: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
⊢ f = 𝟙 ((componentwiseDiagram F U).obj { unop := j })
state_after: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
⊢ f = (F.obj j).presheaf.map (𝟙 { unop := (Opens.map (colimit.ι F { unop := j }.unop).base).obj U })

tactic: change (F.obj j).presheaf.map _ ≫ _ = _
state_before: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
⊢ f = (F.obj j).presheaf.map (𝟙 { unop := (Opens.map (colimit.ι F { unop := j }.unop).base).obj U })
state_after: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
⊢ (F.obj j).presheaf.map (eqToIso ⋯).inv ≫
      (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    (F.obj j).presheaf.map (𝟙 { unop := (Opens.map (colimit.ι F { unop := j }.unop).base).obj U })

tactic: erw [← (F.obj j).presheaf.map_comp, ← (F.obj j).presheaf.map_comp]
state_before: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
⊢ (F.obj j).presheaf.map (eqToIso ⋯).inv ≫
      (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯) =
    (F.obj j).presheaf.map (𝟙 { unop := (Opens.map (colimit.ι F { unop := j }.unop).base).obj U })
state_after: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
⊢ (F.obj j).presheaf.map ((eqToIso ⋯).inv ≫ eqToHom ⋯ ≫ (Opens.map (colimit.ι F j).base).op.map (eqToHom ⋯)) =
    (F.obj j).presheaf.map (𝟙 { unop := (Opens.map (colimit.ι F { unop := j }.unop).base).obj U })

tactic: congr 1
state_before: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
⊢ (F.obj j).presheaf.map ((eqToIso ⋯).inv ≫ eqToHom ⋯ ≫ (Opens.map (colimit.ι F j).base).op.map (eqToHom ⋯)) =
    (F.obj j).presheaf.map (𝟙 { unop := (Opens.map (colimit.ι F { unop := j }.unop).base).obj U })
state_after: no goals

tactic: rw [f_eq, comp_id]
state_before: 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 { unop := j } ⟶
  (F.obj j).presheaf.obj { unop := (Opens.map (colimit.ι F j).base).obj U } :=
  (NatIso.ofComponents (fun X => mapIso (F.obj X.unop).presheaf (eqToIso ⋯)) ⋯).inv.app { unop := j } ≫
    (F.obj j).presheaf.map (eqToHom ⋯) ≫ ((colimit.ι F j).base _* (F.obj j).presheaf).map (eqToHom ⋯)
f_eq : f = 𝟙 ((componentwiseDiagram F U).obj { unop := j })
⊢ limit.π (componentwiseDiagram F U) { unop := j } ≫ f = limit.π (componentwiseDiagram F U) { unop := j }
state_after: no goals