Theorem: TopCat.Presheaf.stalkPushforward.stalkPushforward_iso_of_openEmbedding
File: Mathlib/Topology/Sheaves/Stalks.lean

tactic: haveI := Functor.initial_of_adjunction (hf.isOpenMap.adjunctionNhds x)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
⊢ IsIso (stalkPushforward C f F x)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
⊢ IsIso (stalkPushforward C f F x)

tactic: convert
    ((Functor.Final.colimitIso (hf.isOpenMap.functorNhds x).op
            ((OpenNhds.inclusion (f x)).op ⋙ f _* F) :
          _).symm ≪≫
      colim.mapIso _).isIso_hom
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
⊢ IsIso (stalkPushforward C f F x)
state_after: case h.e'_5.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
⊢ stalkPushforward C f F x =
    ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
        colim.mapIso ?convert_2).hom

case convert_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
⊢ (⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F ≅
    ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F

tactic: swap
state_before: case h.e'_5.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
⊢ stalkPushforward C f F x =
    ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
        colim.mapIso ?convert_2).hom

case convert_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
⊢ (⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F ≅
    ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F
state_after: case convert_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
⊢ (⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F ≅
    ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F

case h.e'_5.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
⊢ stalkPushforward C f F x =
    ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
        colim.mapIso ?convert_2).hom

tactic: fapply NatIso.ofComponents
state_before: case convert_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
⊢ (⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F ≅
    ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F
state_after: case convert_2.app
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
⊢ (X_1 : (OpenNhds x)ᵒᵖ) →
    ((⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F).obj X_1 ≅
      (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F).obj X_1

case convert_2.naturality
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
⊢ autoParam
    (∀ {X_1 Y_1 : (OpenNhds x)ᵒᵖ} (f_1 : X_1 ⟶ Y_1),
      ((⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F).map f_1 ≫ (?convert_2.app Y_1).hom =
        (?convert_2.app X_1).hom ≫
          (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F).map f_1)
    _auto✝

tactic: intro U
state_before: case convert_2.app
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
⊢ (X_1 : (OpenNhds x)ᵒᵖ) →
    ((⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F).obj X_1 ≅
      (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F).obj X_1
state_after: case convert_2.app
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
U : (OpenNhds x)ᵒᵖ
⊢ ((⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F).obj U ≅
    (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F).obj U

tactic: refine F.mapIso (eqToIso ?_)
state_before: case convert_2.app
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
U : (OpenNhds x)ᵒᵖ
⊢ ((⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F).obj U ≅
    (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F).obj U
state_after: case convert_2.app
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
U : (OpenNhds x)ᵒᵖ
⊢ (Opens.map f).op.obj ((OpenNhds.inclusion (f x)).op.obj ((⋯.functorNhds x).op.obj U)) =
    (OpenNhds.inclusion x).op.obj U

tactic: dsimp only [Functor.op]
state_before: case convert_2.app
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
U : (OpenNhds x)ᵒᵖ
⊢ (Opens.map f).op.obj ((OpenNhds.inclusion (f x)).op.obj ((⋯.functorNhds x).op.obj U)) =
    (OpenNhds.inclusion x).op.obj U
state_after: case convert_2.app
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
U : (OpenNhds x)ᵒᵖ
⊢ { unop := (Opens.map f).obj ((OpenNhds.inclusion (f x)).obj ((⋯.functorNhds x).obj U.unop)) } =
    { unop := (OpenNhds.inclusion x).obj U.unop }

tactic: exact congr_arg op (Opens.ext <| Set.preimage_image_eq (unop U).1.1 hf.inj)
state_before: case convert_2.app
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
U : (OpenNhds x)ᵒᵖ
⊢ { unop := (Opens.map f).obj ((OpenNhds.inclusion (f x)).obj ((⋯.functorNhds x).obj U.unop)) } =
    { unop := (OpenNhds.inclusion x).obj U.unop }
state_after: no goals

tactic: intro U V i
state_before: case convert_2.naturality
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
⊢ autoParam
    (∀ {X_1 Y_1 : (OpenNhds x)ᵒᵖ} (f_1 : X_1 ⟶ Y_1),
      ((⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F).map f_1 ≫ (Functor.mapIso F (eqToIso ⋯)).hom =
        (Functor.mapIso F (eqToIso ⋯)).hom ≫
          (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F).map f_1)
    _auto✝
state_after: case convert_2.naturality
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
U V : (OpenNhds x)ᵒᵖ
i : U ⟶ V
⊢ ((⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F).map i ≫ (Functor.mapIso F (eqToIso ⋯)).hom =
    (Functor.mapIso F (eqToIso ⋯)).hom ≫
      (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F).map i

tactic: erw [← F.map_comp, ← F.map_comp]
state_before: case convert_2.naturality
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
U V : (OpenNhds x)ᵒᵖ
i : U ⟶ V
⊢ ((⋯.functorNhds x).op ⋙ (OpenNhds.inclusion (f x)).op ⋙ f _* F).map i ≫ (Functor.mapIso F (eqToIso ⋯)).hom =
    (Functor.mapIso F (eqToIso ⋯)).hom ≫
      (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F).map i
state_after: case convert_2.naturality
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
U V : (OpenNhds x)ᵒᵖ
i : U ⟶ V
⊢ F.map ((Opens.map f).op.map ((OpenNhds.inclusion (f x)).op.map ((⋯.functorNhds x).op.map i)) ≫ (eqToIso ⋯).hom) =
    F.map ((eqToIso ⋯).hom ≫ (OpenNhds.inclusion x).op.map i)

tactic: congr 1
state_before: case convert_2.naturality
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
U V : (OpenNhds x)ᵒᵖ
i : U ⟶ V
⊢ F.map ((Opens.map f).op.map ((OpenNhds.inclusion (f x)).op.map ((⋯.functorNhds x).op.map i)) ≫ (eqToIso ⋯).hom) =
    F.map ((eqToIso ⋯).hom ≫ (OpenNhds.inclusion x).op.map i)
state_after: no goals

tactic: ext U
state_before: case h.e'_5.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
⊢ stalkPushforward C f F x =
    ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
        colim.mapIso (NatIso.ofComponents (fun U => Functor.mapIso F (eqToIso ⋯)) ⋯)).hom
state_after: case h.e'_5.h.w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U ≫
      stalkPushforward C f F x =
    colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U ≫
      ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
          colim.mapIso (NatIso.ofComponents (fun U => Functor.mapIso F (eqToIso ⋯)) ⋯)).hom

tactic: rw [← Iso.comp_inv_eq]
state_before: case h.e'_5.h.w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U ≫
      stalkPushforward C f F x =
    colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U ≫
      ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
          colim.mapIso (NatIso.ofComponents (fun U => Functor.mapIso F (eqToIso ⋯)) ⋯)).hom
state_after: case h.e'_5.h.w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ (colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U ≫
        stalkPushforward C f F x) ≫
      ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
          colim.mapIso (NatIso.ofComponents (fun U => Functor.mapIso F (eqToIso ⋯)) ⋯)).inv =
    colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U

tactic: erw [colimit.ι_map_assoc]
state_before: case h.e'_5.h.w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ (colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U ≫
        stalkPushforward C f F x) ≫
      ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
          colim.mapIso (NatIso.ofComponents (fun U => Functor.mapIso F (eqToIso ⋯)) ⋯)).inv =
    colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U
state_after: case h.e'_5.h.w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ ((whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) F).app U ≫
        colimit.ι
            ((OpenNhds.map f x).op ⋙
              ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
            U ≫
          colimit.pre (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
            (OpenNhds.map f x).op) ≫
      ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
          colim.mapIso (NatIso.ofComponents (fun U => Functor.mapIso F (eqToIso ⋯)) ⋯)).inv =
    colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U

tactic: rw [colimit.ι_pre, Category.assoc]
state_before: case h.e'_5.h.w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ ((whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) F).app U ≫
        colimit.ι
            ((OpenNhds.map f x).op ⋙
              ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
            U ≫
          colimit.pre (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
            (OpenNhds.map f x).op) ≫
      ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
          colim.mapIso (NatIso.ofComponents (fun U => Functor.mapIso F (eqToIso ⋯)) ⋯)).inv =
    colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U
state_after: case h.e'_5.h.w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) F).app U ≫
      colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
          ((OpenNhds.map f x).op.obj U) ≫
        ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
            colim.mapIso (NatIso.ofComponents (fun U => Functor.mapIso F (eqToIso ⋯)) ⋯)).inv =
    colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U

tactic: erw [colimit.ι_map_assoc, colimit.ι_pre, ← F.map_comp_assoc]
state_before: case h.e'_5.h.w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) F).app U ≫
      colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
          ((OpenNhds.map f x).op.obj U) ≫
        ((Functor.Final.colimitIso (⋯.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F)).symm ≪≫
            colim.mapIso (NatIso.ofComponents (fun U => Functor.mapIso F (eqToIso ⋯)) ⋯)).inv =
    colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U
state_after: case h.e'_5.h.w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ F.map ((NatTrans.op (OpenNhds.inclusionMapIso f x).inv).app U ≫ (eqToIso ⋯).inv) ≫
      colimit.ι ((OpenNhds.inclusion (f x)).op ⋙ f _* F) ((⋯.functorNhds x).op.obj ((OpenNhds.map f x).op.obj U)) =
    colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U

tactic: apply colimit.w ((OpenNhds.inclusion (f x)).op ⋙ f _* F) _
state_before: case h.e'_5.h.w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ F.map ((NatTrans.op (OpenNhds.inclusionMapIso f x).inv).app U ≫ (eqToIso ⋯).inv) ≫
      colimit.ι ((OpenNhds.inclusion (f x)).op ⋙ f _* F) ((⋯.functorNhds x).op.obj ((OpenNhds.map f x).op.obj U)) =
    colimit.ι (((whiskeringLeft (OpenNhds (f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (f x)).op).obj (f _* F)) U
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ U ⟶ (⋯.functorNhds x).op.obj ((OpenNhds.map f x).op.obj U)

tactic: dsimp only [Functor.op]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ U ⟶ (⋯.functorNhds x).op.obj ((OpenNhds.map f x).op.obj U)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ U ⟶ { unop := (⋯.functorNhds x).obj ((OpenNhds.map f x).obj U.unop) }

tactic: refine ((homOfLE ?_).op : op (unop U) ⟶ _)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ U ⟶ { unop := (⋯.functorNhds x).obj ((OpenNhds.map f x).obj U.unop) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ (⋯.functorNhds x).obj ((OpenNhds.map f x).obj U.unop) ≤ U.unop

tactic: exact Set.image_preimage_subset _ _
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ⇑f
F : Presheaf C X
x : ↑X
this : (⋯.functorNhds x).Initial
e_3✝ : (f _* F).stalk (f x) = colimit ((OpenNhds.inclusion (f x)).op ⋙ f _* F)
e_4✝ : F.stalk x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (f x))ᵒᵖ
⊢ (⋯.functorNhds x).obj ((OpenNhds.map f x).obj U.unop) ≤ U.unop
state_after: no goals