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

tactic: fapply PresheafedSpace.ext
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
j : J
⊢ (colimitCocone F).ι.app j ≫ desc F s = s.ι.app j

tactic: simp [desc]
state_before: case w
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
j : J
⊢ ((colimitCocone F).ι.app j ≫ desc F s).base = (s.ι.app j).base

tactic: refine NatTrans.ext _ _ (funext fun U => ?_)
state_before: case h
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
j : J
⊢ ((colimitCocone F).ι.app j ≫ desc F s).c ≫
      whiskerRight
        (eqToHom
          (_ :
            Functor.op (Opens.map ((colimitCocone F).ι.app j ≫ desc F s).base) =
              Functor.op (Opens.map (s.ι.app j).base)))
        (F.obj j).presheaf =
    (s.ι.app j).c

tactic: rw [NatTrans.comp_app, PresheafedSpace.comp_c_app, whiskerRight_app]
state_before: case h
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
j : J
U : (Opens ↑↑s.pt)ᵒᵖ
⊢ (((colimitCocone F).ι.app j ≫ desc F s).c ≫
          whiskerRight
            (eqToHom
              (_ :
                Functor.op (Opens.map ((colimitCocone F).ι.app j ≫ desc F s).base) =
                  Functor.op (Opens.map (s.ι.app j).base)))
            (F.obj j).presheaf).app
      U =
    (s.ι.app j).c.app U

tactic: dsimp [desc, descCApp]
state_before: case h
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
j : J
U : (Opens ↑↑s.pt)ᵒᵖ
⊢ ((desc F s).c.app U ≫ ((colimitCocone F).ι.app j).c.app ((Opens.map (desc F s).base).obj U.unop).op) ≫
      (F.obj j).presheaf.map
        ((eqToHom
              (_ :
                Functor.op (Opens.map ((colimitCocone F).ι.app j ≫ desc F s).base) =
                  Functor.op (Opens.map (s.ι.app j).base))).app
          U) =
    (s.ι.app j).c.app U

tactic: simp only [eqToHom_app, op_obj, Opens.map_comp_obj, eqToHom_map, Functor.leftOp, assoc]
state_before: case h
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
j : J
U : (Opens ↑↑s.pt)ᵒᵖ
⊢ ((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 j.op).app
          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop).op) ≫
      (F.obj j).presheaf.map
        ((eqToHom
              (_ :
                Functor.op
                    (Opens.map (colimit.ι (F ⋙ forget C) j ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))) =
                  Functor.op (Opens.map (s.ι.app j).base))).app
          U) =
    (s.ι.app j).c.app U

tactic: rw [limitObjIsoLimitCompEvaluation_inv_π_app_assoc]
state_before: case h
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
j : J
U : (Opens ↑↑s.pt)ᵒᵖ
⊢ limit.lift
        (CategoryTheory.Functor.mk
            { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
              map := fun X Y f => ((pushforwardDiagramToColimit F).map f.unop).unop } ⋙
          (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
            (CategoryTheory.Functor.mk
              { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
                map := fun X Y f => ((pushforwardDiagramToColimit F).map f.unop).unop })
            ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop).op).inv ≫
        (limit.π
                (CategoryTheory.Functor.mk
                  { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
                    map := fun X Y f => ((pushforwardDiagramToColimit F).map f.unop).unop })
                j.op).app
            ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop).op ≫
          eqToHom
            (_ :
              (F.obj j).presheaf.obj
                  ((Opens.map (colimit.ι (F ⋙ forget C) j)).obj
                      ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)).op =
                (F.obj j).presheaf.obj ((Opens.map (s.ι.app j).base).obj U.unop).op) =
    (s.ι.app j).c.app U

tactic: simp
state_before: case h
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
j : J
U : (Opens ↑↑s.pt)ᵒᵖ
⊢ limit.lift
        (CategoryTheory.Functor.mk
            { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
              map := fun X Y f => ((pushforwardDiagramToColimit F).map f.unop).unop } ⋙
          (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))) } ≫
      limit.π
          (CategoryTheory.Functor.mk
              { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
                map := fun X Y f => ((pushforwardDiagramToColimit F).map f.unop).unop } ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop).op)
          j.op ≫
        eqToHom
          (_ :
            (F.obj j).presheaf.obj
                ((Opens.map (colimit.ι (F ⋙ forget C) j)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)).op =
              (F.obj j).presheaf.obj ((Opens.map (s.ι.app j).base).obj U.unop).op) =
    (s.ι.app j).c.app U