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

tactic: dsimp [descCApp]
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
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

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

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