l3lab/ntp-mathlib huggingface dataset:
theorem desc_c_naturality (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F)
    {U V : (Opens s.pt.carrier)ᵒᵖ} (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 := by
  dsimp [descCApp]
  

Proof state:
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
              (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))
          { pt := s.pt.presheaf.obj V,
            π :=
              NatTrans.mk fun j =>
                (s.ι.app j.unop).c.app V ≫
                  (F.obj j.unop).presheaf.map
                    (eqToHom
                      (_ :
                        (Opens.map (s.ι.app j.unop).base).op.obj V =
                          (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                            ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj V))) } ≫
        (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            (op ((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
              (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))
          { pt := s.pt.presheaf.obj U,
            π :=
              NatTrans.mk fun j =>
                (s.ι.app j.unop).c.app U ≫
                  (F.obj j.unop).presheaf.map
                    (eqToHom
                      (_ :
                        (Opens.map (s.ι.app j.unop).base).op.obj U =
                          (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                            ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj U))) } ≫
        (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            (op ((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

Next tactic:
refine limit_obj_ext (fun j => ?_)
theorem desc_c_naturality (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F)
    {U V : (Opens s.pt.carrier)ᵒᵖ} (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 := by
  dsimp [descCApp]
  refine limit_obj_ext (fun j => ?_)
  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]
  

Proof state:
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
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (s.ι.app j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    (s.ι.app j.unop).c.app U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (s.ι.app j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        ((pushforwardDiagramToColimit F).leftOp.obj j).map
          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop).op

Next tactic:
dsimp
theorem desc_c_naturality (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F)
    {U V : (Opens s.pt.carrier)ᵒᵖ} (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 := by
  dsimp [descCApp]
  refine limit_obj_ext (fun j => ?_)
  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]
  dsimp
  

Proof state:
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
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (s.ι.app j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    (s.ι.app j.unop).c.app U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (s.ι.app j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        (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

Next tactic:
have w :=
    Functor.congr_hom
      (congr_arg Opens.map (colimit.ι_desc ((PresheafedSpace.forget C).mapCocone s) (unop j)))
      i.unop
theorem desc_c_naturality (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F)
    {U V : (Opens s.pt.carrier)ᵒᵖ} (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 := by
  dsimp [descCApp]
  refine limit_obj_ext (fun j => ?_)
  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]
  dsimp
  have w :=
    Functor.congr_hom
      (congr_arg Opens.map (colimit.ι_desc ((PresheafedSpace.forget C).mapCocone s) (unop j)))
      i.unop
  

Proof state:
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 (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 (op ((Opens.map (s.ι.app j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    (s.ι.app j.unop).c.app U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (s.ι.app j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        (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

Next tactic:
simp only [Opens.map_comp_map] at w
theorem desc_c_naturality (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F)
    {U V : (Opens s.pt.carrier)ᵒᵖ} (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 := by
  dsimp [descCApp]
  refine limit_obj_ext (fun j => ?_)
  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]
  dsimp
  have w :=
    Functor.congr_hom
      (congr_arg Opens.map (colimit.ι_desc ((PresheafedSpace.forget C).mapCocone s) (unop j)))
      i.unop
  simp only [Opens.map_comp_map] at w
  

Proof state:
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 (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 (op ((Opens.map (s.ι.app j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    (s.ι.app j.unop).c.app U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (s.ι.app j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        (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

Next tactic:
replace w := congr_arg Quiver.Hom.op w
theorem desc_c_naturality (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F)
    {U V : (Opens s.pt.carrier)ᵒᵖ} (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 := by
  dsimp [descCApp]
  refine limit_obj_ext (fun j => ?_)
  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]
  dsimp
  have w :=
    Functor.congr_hom
      (congr_arg Opens.map (colimit.ι_desc ((PresheafedSpace.forget C).mapCocone s) (unop j)))
      i.unop
  simp only [Opens.map_comp_map] at w
  replace w := congr_arg Quiver.Hom.op w
  

Proof state:
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 (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 (op ((Opens.map (s.ι.app j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    (s.ι.app j.unop).c.app U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (s.ι.app j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        (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

Next tactic:
rw [w]
theorem desc_fac (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (j : J) :
    (colimitCocone F).ι.app j ≫ desc F s = s.ι.app j := by
  

Proof state:
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

Next tactic:
ext U
theorem desc_fac (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (j : J) :
    (colimitCocone F).ι.app j ≫ desc F s = s.ι.app j := by
  ext U
  · 

Proof state:
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

Next tactic:
simp [desc]
theorem desc_fac (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (j : J) :
    (colimitCocone F).ι.app j ≫ desc F s = s.ι.app j := by
  ext U
  · simp [desc]
  · -- Porting note : the original proof is just `ext; dsimp [desc, descCApp]; simpa`,
    -- but this has to be expanded a bit
    

Proof state:
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 (_ : (Opens.map ((colimitCocone F).ι.app j ≫ desc F s).base).op = (Opens.map (s.ι.app j).base).op))
            (F.obj j).presheaf).app
      (op U) =
    (s.ι.app j).c.app (op U)

Next tactic:
rw [NatTrans.comp_app, PresheafedSpace.comp_c_app, whiskerRight_app]
theorem desc_fac (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (j : J) :
    (colimitCocone F).ι.app j ≫ desc F s = s.ι.app j := by
  ext U
  · simp [desc]
  · -- Porting note : the original proof is just `ext; dsimp [desc, descCApp]; simpa`,
    -- but this has to be expanded a bit
    rw [NatTrans.comp_app, PresheafedSpace.comp_c_app, whiskerRight_app]
    

Proof state:
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 (op U) ≫ ((colimitCocone F).ι.app j).c.app (op ((Opens.map (desc F s).base).obj (op U).unop))) ≫
      (F.obj j).presheaf.map
        ((eqToHom
              (_ : (Opens.map ((colimitCocone F).ι.app j ≫ desc F s).base).op = (Opens.map (s.ι.app j).base).op)).app
          (op U)) =
    (s.ι.app j).c.app (op U)

Next tactic:
dsimp [desc, descCApp]
theorem desc_fac (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (j : J) :
    (colimitCocone F).ι.app j ≫ desc F s = s.ι.app j := by
  ext U
  · simp [desc]
  · -- Porting note : the original proof is just `ext; dsimp [desc, descCApp]; simpa`,
    -- but this has to be expanded a bit
    rw [NatTrans.comp_app, PresheafedSpace.comp_c_app, whiskerRight_app]
    dsimp [desc, descCApp]
    

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

Next tactic:
simp only [eqToHom_app, op_obj, Opens.map_comp_obj, eqToHom_map, Functor.leftOp, assoc]
theorem desc_fac (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (j : J) :
    (colimitCocone F).ι.app j ≫ desc F s = s.ι.app j := by
  ext U
  · simp [desc]
  · -- Porting note : the original proof is just `ext; dsimp [desc, descCApp]; simpa`,
    -- but this has to be expanded a bit
    rw [NatTrans.comp_app, PresheafedSpace.comp_c_app, whiskerRight_app]
    dsimp [desc, descCApp]
    simp only [eqToHom_app, op_obj, Opens.map_comp_obj, eqToHom_map, Functor.leftOp, assoc]
    

Proof state:
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
        (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
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U)))
        { pt := s.pt.presheaf.obj (op U),
          π :=
            NatTrans.mk fun j =>
              (s.ι.app j.unop).c.app (op U) ≫
                (F.obj j.unop).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map (s.ι.app j.unop).base).op.obj (op U) =
                        (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj (op 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 })
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U))).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 })
                (op j)).app
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U)) ≫
          eqToHom
            (_ :
              (F.obj j).presheaf.obj
                  (op
                    ((Opens.map (colimit.ι (F ⋙ forget C) j)).obj
                      ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U))) =
                (F.obj j).presheaf.obj (op ((Opens.map (s.ι.app j).base).obj U))) =
    (s.ι.app j).c.app (op U)

Next tactic:
rw [limitObjIsoLimitCompEvaluation_inv_π_app_assoc]