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

tactic: ext U
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
j : J
⊢ (colimitCocone F).ι.app j ≫ desc F s = s.ι.app j
state_after: case w.w
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
j : J
U : (CategoryTheory.forget TopCat).obj ↑(F.obj j)
⊢ ((colimitCocone F).ι.app j ≫ desc F s).base U = (s.ι.app j).base U

case h.w
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
j : J
U : Opens ↑↑s.pt
⊢ (((colimitCocone F).ι.app j ≫ desc F s).c ≫ whiskerRight (eqToHom ⋯) (F.obj j).presheaf).app { unop := U } =
    (s.ι.app j).c.app { unop := U }

tactic: simp [desc]
state_before: case w.w
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
j : J
U : (CategoryTheory.forget TopCat).obj ↑(F.obj j)
⊢ ((colimitCocone F).ι.app j ≫ desc F s).base U = (s.ι.app j).base U
state_after: no goals

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

tactic: dsimp [desc, descCApp]
state_before: case h.w
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
j : J
U : Opens ↑↑s.pt
⊢ ((desc F s).c.app { unop := U } ≫
        ((colimitCocone F).ι.app j).c.app { unop := (Opens.map (desc F s).base).obj { unop := U }.unop }) ≫
      (F.obj j).presheaf.map ((eqToHom ⋯).app { unop := U }) =
    (s.ι.app j).c.app { unop := U }
state_after: case h.w
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
j : J
U : Opens ↑↑s.pt
⊢ ((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 })
            { pt := s.pt.presheaf.obj { unop := U },
              π :=
                { app := fun j => (s.ι.app j.unop).c.app { unop := 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 }).inv) ≫
        (limit.π (pushforwardDiagramToColimit F).leftOp { unop := j }).app
          { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U }) ≫
      (F.obj j).presheaf.map ((eqToHom ⋯).app { unop := U }) =
    (s.ι.app j).c.app { unop := U }

tactic: simp only [eqToHom_app, op_obj, Opens.map_comp_obj, eqToHom_map, Functor.leftOp, assoc]
state_before: case h.w
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
j : J
U : Opens ↑↑s.pt
⊢ ((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 })
            { pt := s.pt.presheaf.obj { unop := U },
              π :=
                { app := fun j => (s.ι.app j.unop).c.app { unop := 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 }).inv) ≫
        (limit.π (pushforwardDiagramToColimit F).leftOp { unop := j }).app
          { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U }) ≫
      (F.obj j).presheaf.map ((eqToHom ⋯).app { unop := U }) =
    (s.ι.app j).c.app { unop := U }
state_after: case h.w
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
j : J
U : Opens ↑↑s.pt
⊢ limit.lift
        ({ obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
            map := fun {X Y} f => ((pushforwardDiagramToColimit F).map f.unop).unop, map_id := ⋯, map_comp := ⋯ } ⋙
          (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
            { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U })
        { pt := s.pt.presheaf.obj { unop := U },
          π :=
            { app := fun j => (s.ι.app j.unop).c.app { unop := U } ≫ (F.obj j.unop).presheaf.map (eqToHom ⋯),
              naturality := ⋯ } } ≫
      (limitObjIsoLimitCompEvaluation
            { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
              map := fun {X Y} f => ((pushforwardDiagramToColimit F).map f.unop).unop, map_id := ⋯, map_comp := ⋯ }
            { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U }).inv ≫
        (limit.π
                { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
                  map := fun {X Y} f => ((pushforwardDiagramToColimit F).map f.unop).unop, map_id := ⋯, map_comp := ⋯ }
                { unop := j }).app
            { unop := (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U } ≫
          eqToHom ⋯ =
    (s.ι.app j).c.app { unop := U }

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

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