Theorem: AlgebraicGeometry.PresheafedSpace.ColimitCoconeIsColimit.desc_c_naturality
File: Mathlib/Geometry/RingedSpace/PresheafedSpace/HasColimits.lean

tactic: dsimp [descCApp]
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
⊢ s.pt.presheaf.map i ≫ descCApp F s V =
    descCApp F s U ≫ (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s) _* (colimitCocone F).pt.presheaf).map i
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
⊢ s.pt.presheaf.map i ≫
      limit.lift
          ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop })
          { pt := s.pt.presheaf.obj V,
            π :=
              { app := fun j => (s.ι.app j.unop).c.app V ≫ (F.obj j.unop).presheaf.map (eqToHom ⋯),
                naturality := ⋯ } } ≫
        (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop }).inv =
    (limit.lift
          ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop })
          { pt := s.pt.presheaf.obj U,
            π :=
              { app := fun j => (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map (eqToHom ⋯),
                naturality := ⋯ } } ≫
        (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop }).inv) ≫
      (limit (pushforwardDiagramToColimit F).leftOp).map
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop).op

tactic: refine limit_obj_ext (fun j => ?_)
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
⊢ s.pt.presheaf.map i ≫
      limit.lift
          ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop })
          { pt := s.pt.presheaf.obj V,
            π :=
              { app := fun j => (s.ι.app j.unop).c.app V ≫ (F.obj j.unop).presheaf.map (eqToHom ⋯),
                naturality := ⋯ } } ≫
        (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop }).inv =
    (limit.lift
          ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop })
          { pt := s.pt.presheaf.obj U,
            π :=
              { app := fun j => (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map (eqToHom ⋯),
                naturality := ⋯ } } ≫
        (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop }).inv) ≫
      (limit (pushforwardDiagramToColimit F).leftOp).map
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop).op
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
⊢ (s.pt.presheaf.map i ≫
        limit.lift
            ((pushforwardDiagramToColimit F).leftOp ⋙
              (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
                { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop })
            { pt := s.pt.presheaf.obj V,
              π :=
                { app := fun j => (s.ι.app j.unop).c.app V ≫ (F.obj j.unop).presheaf.map (eqToHom ⋯),
                  naturality := ⋯ } } ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop }).inv) ≫
      (limit.π (pushforwardDiagramToColimit F).leftOp j).app
        { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop } =
    ((limit.lift
            ((pushforwardDiagramToColimit F).leftOp ⋙
              (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
                { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop })
            { pt := s.pt.presheaf.obj U,
              π :=
                { app := fun j => (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map (eqToHom ⋯),
                  naturality := ⋯ } } ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop }).inv) ≫
        (limit (pushforwardDiagramToColimit F).leftOp).map
          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop).op) ≫
      (limit.π (pushforwardDiagramToColimit F).leftOp j).app
        { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop }

tactic: simp only [limit.lift_π, NatTrans.naturality, limit.lift_π_assoc, eqToHom_map, assoc,
  pushforwardObj_map, NatTrans.naturality_assoc, op_map,
  limitObjIsoLimitCompEvaluation_inv_π_app_assoc,
  limitObjIsoLimitCompEvaluation_inv_π_app]
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
⊢ (s.pt.presheaf.map i ≫
        limit.lift
            ((pushforwardDiagramToColimit F).leftOp ⋙
              (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
                { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop })
            { pt := s.pt.presheaf.obj V,
              π :=
                { app := fun j => (s.ι.app j.unop).c.app V ≫ (F.obj j.unop).presheaf.map (eqToHom ⋯),
                  naturality := ⋯ } } ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop }).inv) ≫
      (limit.π (pushforwardDiagramToColimit F).leftOp j).app
        { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop } =
    ((limit.lift
            ((pushforwardDiagramToColimit F).leftOp ⋙
              (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
                { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop })
            { pt := s.pt.presheaf.obj U,
              π :=
                { app := fun j => (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map (eqToHom ⋯),
                  naturality := ⋯ } } ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop }).inv) ≫
        (limit (pushforwardDiagramToColimit F).leftOp).map
          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop).op) ≫
      (limit.π (pushforwardDiagramToColimit F).leftOp j).app
        { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop }
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        ((pushforwardDiagramToColimit F).leftOp.obj j).map
          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop).op

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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        ((pushforwardDiagramToColimit F).leftOp.obj j).map
          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop).op
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op

tactic: have w :=
  Functor.congr_hom
    (congr_arg Opens.map (colimit.ι_desc ((PresheafedSpace.forget C).mapCocone s) (unop j)))
    i.unop
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop =
    eqToHom ⋯ ≫ (Opens.map (((forget C).mapCocone s).ι.app j.unop)).map i.unop ≫ eqToHom ⋯
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op

tactic: simp only [Opens.map_comp_map] at w
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop =
    eqToHom ⋯ ≫ (Opens.map (((forget C).mapCocone s).ι.app j.unop)).map i.unop ≫ eqToHom ⋯
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
      ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop) =
    eqToHom ⋯ ≫ (Opens.map (((forget C).mapCocone s).ι.app j.unop)).map i.unop ≫ eqToHom ⋯
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op

tactic: replace w := congr_arg Quiver.Hom.op w
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
      ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop) =
    eqToHom ⋯ ≫ (Opens.map (((forget C).mapCocone s).ι.app j.unop)).map i.unop ≫ eqToHom ⋯
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op =
    (eqToHom ⋯ ≫ (Opens.map (((forget C).mapCocone s).ι.app j.unop)).map i.unop ≫ eqToHom ⋯).op
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op

tactic: rw [w]
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op =
    (eqToHom ⋯ ≫ (Opens.map (((forget C).mapCocone s).ι.app j.unop)).map i.unop ≫ eqToHom ⋯).op
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op =
    (eqToHom ⋯ ≫ (Opens.map (((forget C).mapCocone s).ι.app j.unop)).map i.unop ≫ eqToHom ⋯).op
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        (F.obj j.unop).presheaf.map
          (eqToHom ⋯ ≫ (Opens.map (((forget C).mapCocone s).ι.app j.unop)).map i.unop ≫ eqToHom ⋯).op

tactic: simp
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
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op =
    (eqToHom ⋯ ≫ (Opens.map (((forget C).mapCocone s).ι.app j.unop)).map i.unop ≫ eqToHom ⋯).op
⊢ (s.ι.app j.unop).c.app U ≫ (F.obj j.unop).presheaf.map ((Opens.map (s.ι.app j.unop).base).map i.unop).op ≫ eqToHom ⋯ =
    (s.ι.app j.unop).c.app U ≫
      eqToHom ⋯ ≫
        (F.obj j.unop).presheaf.map
          (eqToHom ⋯ ≫ (Opens.map (((forget C).mapCocone s).ι.app j.unop)).map i.unop ≫ eqToHom ⋯).op
state_after: no goals