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 C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ((forget TopCat).map f)
F : Presheaf C X
x : ↑X
⊢ IsIso (stalkPushforward C f F x)

tactic: convert IsIso.of_iso
    ((Functor.Final.colimitIso (hf.isOpenMap.functorNhds x).op
            ((OpenNhds.inclusion (f x)).op ⋙ f _* F) :
          _).symm ≪≫
      colim.mapIso _)
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ((forget TopCat).map f)
F : Presheaf C X
x : ↑X
this : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x)
⊢ IsIso (stalkPushforward C f F x)

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

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

tactic: fapply NatIso.ofComponents
state_before: case convert_2
C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ((forget TopCat).map f)
F : Presheaf C X
x : ↑X
this : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x)
⊢ Functor.op (IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x) ⋙
      Functor.op (OpenNhds.inclusion ((forget TopCat).map f x)) ⋙ f _* F ≅
    ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (Functor.op (OpenNhds.inclusion x))).obj F

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

tactic: refine' F.mapIso (eqToIso _)
state_before: case convert_2.app
C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ((forget TopCat).map f)
F : Presheaf C X
x : ↑X
this : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x)
U : (OpenNhds x)ᵒᵖ
⊢ (Functor.op (IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x) ⋙
          Functor.op (OpenNhds.inclusion ((forget TopCat).map f x)) ⋙ f _* F).obj
      U ≅
    (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (Functor.op (OpenNhds.inclusion x))).obj F).obj U

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

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 C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ((forget TopCat).map f)
F : Presheaf C X
x : ↑X
this : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x)
U : (OpenNhds x)ᵒᵖ
⊢ ((Opens.map f).obj
        ((OpenNhds.inclusion ((forget TopCat).map f x)).obj
              ((IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x).obj U.unop).op.unop).op.unop).op =
    ((OpenNhds.inclusion x).obj U.unop).op

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

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

tactic: congr 1
state_before: case convert_2.naturality
C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
hf : OpenEmbedding ((forget TopCat).map f)
F : Presheaf C X
x : ↑X
this : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x)
U V : (OpenNhds x)ᵒᵖ
i : U ⟶ V
⊢ F.map
      ((Functor.op (Opens.map f)).map
          ((Functor.op (OpenNhds.inclusion ((forget TopCat).map f x))).map
            ((Functor.op (IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x)).map i)) ≫
        (eqToIso
            (_ :
              (Functor.op (Opens.map f)).obj
                  ((Functor.op (OpenNhds.inclusion ((forget TopCat).map f x))).obj
                    ((Functor.op (IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x)).obj V)) =
                (Functor.op (OpenNhds.inclusion x)).obj V)).hom) =
    F.map
      ((eqToIso
            (_ :
              (Functor.op (Opens.map f)).obj
                  ((Functor.op (OpenNhds.inclusion ((forget TopCat).map f x))).obj
                    ((Functor.op (IsOpenMap.functorNhds (_ : IsOpenMap ((forget TopCat).map f)) x)).obj U)) =
                (Functor.op (OpenNhds.inclusion x)).obj U)).hom ≫
        (Functor.op (OpenNhds.inclusion x)).map i)

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

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

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

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

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

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

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

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