Theorem: AlgebraicGeometry.PresheafedSpace.stalkMap.stalkSpecializes_stalkMap
File: Mathlib/Geometry/RingedSpace/Stalks.lean

tactic: dsimp [stalkSpecializes, stalkMap, stalkFunctor, stalkPushforward]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
⊢ Y.presheaf.stalkSpecializes ⋯ ≫ stalkMap f x = stalkMap f y ≫ X.presheaf.stalkSpecializes h
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
⊢ colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
        { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
          ι :=
            {
              app := fun U =>
                colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                  { unop := { obj := U.unop.obj, property := ⋯ } },
              naturality := ⋯ } } ≫
      colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
        colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
          colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
        colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
          colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
      colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
        { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
          ι :=
            {
              app := fun U =>
                colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) { unop := { obj := U.unop.obj, property := ⋯ } },
              naturality := ⋯ } }

tactic: refine colimit.hom_ext fun j => ?_
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
⊢ colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
        { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
          ι :=
            {
              app := fun U =>
                colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                  { unop := { obj := U.unop.obj, property := ⋯ } },
              naturality := ⋯ } } ≫
      colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
        colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
          colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
        colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
          colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
      colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
        { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
          ι :=
            {
              app := fun U =>
                colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) { unop := { obj := U.unop.obj, property := ⋯ } },
              naturality := ⋯ } }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : (OpenNhds (f.base y))ᵒᵖ
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        j ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
          { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                    { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } } ≫
        colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        j ≫
      (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
        colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
          { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } }

tactic: induction j with | h j => ?_
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : (OpenNhds (f.base y))ᵒᵖ
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        j ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
          { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                    { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } } ≫
        colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        j ≫
      (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
        colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
          { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } }
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        { unop := j } ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
          { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                    { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } } ≫
        colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        { unop := j } ≫
      (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
        colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
          { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } }

tactic: dsimp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        { unop := j } ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
          { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                    { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } } ≫
        colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    colimit.ι
        (((whiskeringLeft (OpenNhds (f.base y))ᵒᵖ (Opens ↑↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f.base y)).op).obj
          Y.presheaf)
        { unop := j } ≫
      (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
        colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
          { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } }
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ colimit.ι ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf) { unop := j } ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
          { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                    { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } } ≫
        colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    colimit.ι ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf) { unop := j } ≫
      (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
        colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
          { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } }

tactic: simp only [colimit.ι_desc_assoc, comp_obj, op_obj, unop_op, ι_colimMap_assoc, colimit.map_desc,
  OpenNhds.inclusion_obj, pushforwardObj_obj, whiskerLeft_app, OpenNhds.map_obj, whiskerRight_app,
  NatTrans.id_app, map_id, colimit.ι_pre, id_comp, assoc, colimit.pre_desc]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ colimit.ι ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf) { unop := j } ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
          { pt := colimit ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion (f.base x)).op ⋙ Y.presheaf)
                    { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } } ≫
        colimMap (whiskerLeft (OpenNhds.inclusion (f.base x)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    colimit.ι ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf) { unop := j } ≫
      (colimMap (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
        colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
          { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) { unop := { obj := U.unop.obj, property := ⋯ } },
                naturality := ⋯ } }
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ f.c.app { unop := j.obj } ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        { unop := { obj := (Opens.map f.base).obj j.obj, property := ⋯ } } =
    colimit.ι ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf) { unop := j } ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
        ((Cocones.precompose (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c)).obj
          ((Cocones.precompose (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf)).obj
            (Cocone.whisker (OpenNhds.map f.base y).op
              { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
                ι :=
                  {
                    app := fun U =>
                      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
                        { unop := { obj := U.unop.obj, property := ⋯ } },
                    naturality := ⋯ } })))

tactic: erw [colimit.ι_desc]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ f.c.app { unop := j.obj } ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        { unop := { obj := (Opens.map f.base).obj j.obj, property := ⋯ } } =
    colimit.ι ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf) { unop := j } ≫
      colimit.desc ((OpenNhds.inclusion (f.base y)).op ⋙ Y.presheaf)
        ((Cocones.precompose (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c)).obj
          ((Cocones.precompose (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf)).obj
            (Cocone.whisker (OpenNhds.map f.base y).op
              { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
                ι :=
                  {
                    app := fun U =>
                      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
                        { unop := { obj := U.unop.obj, property := ⋯ } },
                    naturality := ⋯ } })))
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ f.c.app { unop := j.obj } ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        { unop := { obj := (Opens.map f.base).obj j.obj, property := ⋯ } } =
    ((Cocones.precompose (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c)).obj
            ((Cocones.precompose (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf)).obj
              (Cocone.whisker (OpenNhds.map f.base y).op
                { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
                  ι :=
                    {
                      app := fun U =>
                        colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
                          { unop := { obj := U.unop.obj, property := ⋯ } },
                      naturality := ⋯ } }))).ι.app
      { unop := j }

tactic: dsimp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ f.c.app { unop := j.obj } ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        { unop := { obj := (Opens.map f.base).obj j.obj, property := ⋯ } } =
    ((Cocones.precompose (whiskerLeft (OpenNhds.inclusion (f.base y)).op f.c)).obj
            ((Cocones.precompose (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf)).obj
              (Cocone.whisker (OpenNhds.map f.base y).op
                { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
                  ι :=
                    {
                      app := fun U =>
                        colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
                          { unop := { obj := U.unop.obj, property := ⋯ } },
                      naturality := ⋯ } }))).ι.app
      { unop := j }
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ f.c.app { unop := j.obj } ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        { unop := { obj := (Opens.map f.base).obj j.obj, property := ⋯ } } =
    f.c.app { unop := (OpenNhds.inclusion (f.base y)).obj j } ≫
      X.presheaf.map (𝟙 { unop := (OpenNhds.inclusion y).obj ((OpenNhds.map f.base y).obj j) }) ≫
        colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
          { unop := { obj := ((OpenNhds.map f.base y).obj j).obj, property := ⋯ } }

tactic: erw [X.presheaf.map_id, id_comp]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ f.c.app { unop := j.obj } ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        { unop := { obj := (Opens.map f.base).obj j.obj, property := ⋯ } } =
    f.c.app { unop := (OpenNhds.inclusion (f.base y)).obj j } ≫
      X.presheaf.map (𝟙 { unop := (OpenNhds.inclusion y).obj ((OpenNhds.map f.base y).obj j) }) ≫
        colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
          { unop := { obj := ((OpenNhds.map f.base y).obj j).obj, property := ⋯ } }
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ f.c.app { unop := j.obj } ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        { unop := { obj := (Opens.map f.base).obj j.obj, property := ⋯ } } =
    f.c.app { unop := (OpenNhds.inclusion (f.base y)).obj j } ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        { unop := { obj := ((OpenNhds.map f.base y).obj j).obj, property := ⋯ } }

tactic: rfl
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds (f.base y)
⊢ f.c.app { unop := j.obj } ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        { unop := { obj := (Opens.map f.base).obj j.obj, property := ⋯ } } =
    f.c.app { unop := (OpenNhds.inclusion (f.base y)).obj j } ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        { unop := { obj := ((OpenNhds.map f.base y).obj j).obj, property := ⋯ } }
state_after: no goals