[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimits C
X Y Z : TopCat
F : Presheaf C X
U V : Opens ↑X
i : U ⟶ V
x : { x // x ∈ U }
inst✝ : ConcreteCategory C
s : (forget C).obj (F.obj (op V))
⊢ ↑(germ F x) (↑(F.map i.op) s) = ↑(germ F ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)) s
[PROOFSTEP]
rw [← comp_apply, germ_res]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y✝ Z : TopCat
F : Presheaf C X
x : ↑X
Y : C
f₁ f₂ : stalk F x ⟶ Y
ih :
  ∀ (U : Opens ↑X) (hxU : x ∈ U), germ F { val := x, property := hxU } ≫ f₁ = germ F { val := x, property := hxU } ≫ f₂
U : (OpenNhds x)ᵒᵖ
⊢ colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F) U ≫ f₁ =
    colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F) U ≫ f₂
[PROOFSTEP]
induction' U using Opposite.rec with U
[GOAL]
case mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y✝ Z : TopCat
F : Presheaf C X
x : ↑X
Y : C
f₁ f₂ : stalk F x ⟶ Y
ih :
  ∀ (U : Opens ↑X) (hxU : x ∈ U), germ F { val := x, property := hxU } ≫ f₁ = germ F { val := x, property := hxU } ≫ f₂
U : OpenNhds x
⊢ colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F) { unop := U } ≫ f₁ =
    colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F) { unop := U } ≫ f₂
[PROOFSTEP]
cases' U with U hxU
[GOAL]
case mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y✝ Z : TopCat
F : Presheaf C X
x : ↑X
Y : C
f₁ f₂ : stalk F x ⟶ Y
ih :
  ∀ (U : Opens ↑X) (hxU : x ∈ U), germ F { val := x, property := hxU } ≫ f₁ = germ F { val := x, property := hxU } ≫ f₂
U : Opens ↑X
hxU : x ∈ U
⊢ colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
        { unop := { obj := U, property := hxU } } ≫
      f₁ =
    colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
        { unop := { obj := U, property := hxU } } ≫
      f₂
[PROOFSTEP]
exact ih U hxU
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
x : ↑X
⊢ stalk (f _* F) (↑f x) ⟶ stalk F x
[PROOFSTEP]
refine' ?_ ≫ colimit.pre _ (OpenNhds.map f x).op
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
x : ↑X
⊢ stalk (f _* F) (↑f x) ⟶
    colimit
      ((OpenNhds.map f x).op ⋙ ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
[PROOFSTEP]
exact colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) F)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
U : Opens ↑Y
x : { x // x ∈ (Opens.map f).obj U }
⊢ germ (f _* F) { val := ↑f ↑x, property := (_ : ↑x ∈ (Opens.map f).obj U) } ≫ stalkPushforward C f F ↑x = germ F x
[PROOFSTEP]
rw [stalkPushforward, germ, colimit.ι_map_assoc, colimit.ι_pre, whiskerRight_app]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
U : Opens ↑Y
x : { x // x ∈ (Opens.map f).obj U }
⊢ F.map
        (NatTrans.app (NatTrans.op (OpenNhds.inclusionMapIso f ↑x).inv)
          (op { obj := U, property := (_ : ↑{ val := ↑f ↑x, property := (_ : ↑x ∈ (Opens.map f).obj U) } ∈ U) })) ≫
      colimit.ι (((whiskeringLeft (OpenNhds ↑x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion ↑x).op).obj F)
        ((OpenNhds.map f ↑x).op.obj
          (op { obj := U, property := (_ : ↑{ val := ↑f ↑x, property := (_ : ↑x ∈ (Opens.map f).obj U) } ∈ U) })) =
    germ F x
[PROOFSTEP]
erw [CategoryTheory.Functor.map_id, Category.id_comp]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
U : Opens ↑Y
x : { x // x ∈ (Opens.map f).obj U }
⊢ colimit.ι (((whiskeringLeft (OpenNhds ↑x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion ↑x).op).obj F)
      ((OpenNhds.map f ↑x).op.obj
        (op { obj := U, property := (_ : ↑{ val := ↑f ↑x, property := (_ : ↑x ∈ (Opens.map f).obj U) } ∈ U) })) =
    germ F x
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
x : ↑X
⊢ stalkPushforward C (𝟙 X) ℱ x = (stalkFunctor C x).map (Pushforward.id ℱ).hom
[PROOFSTEP]
change (_ : colimit _ ⟶ _) = (_ : colimit _ ⟶ _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
x : ↑X
⊢ stalkPushforward C (𝟙 X) ℱ x = (stalkFunctor C x).map (Pushforward.id ℱ).hom
[PROOFSTEP]
ext1 j
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
x : ↑X
j : (OpenNhds (↑(𝟙 X) x))ᵒᵖ
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (↑(𝟙 X) x))ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion (↑(𝟙 X) x)).op).obj
          (𝟙 X _* ℱ))
        j ≫
      stalkPushforward C (𝟙 X) ℱ x =
    colimit.ι
        (((whiskeringLeft (OpenNhds (↑(𝟙 X) x))ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion (↑(𝟙 X) x)).op).obj
          (𝟙 X _* ℱ))
        j ≫
      (stalkFunctor C x).map (Pushforward.id ℱ).hom
[PROOFSTEP]
induction' j with j
[GOAL]
case w.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
x : ↑X
j : OpenNhds (↑(𝟙 X) x)
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (↑(𝟙 X) x))ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion (↑(𝟙 X) x)).op).obj
          (𝟙 X _* ℱ))
        (op j) ≫
      stalkPushforward C (𝟙 X) ℱ x =
    colimit.ι
        (((whiskeringLeft (OpenNhds (↑(𝟙 X) x))ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion (↑(𝟙 X) x)).op).obj
          (𝟙 X _* ℱ))
        (op j) ≫
      (stalkFunctor C x).map (Pushforward.id ℱ).hom
[PROOFSTEP]
rcases j with ⟨⟨_, _⟩, _⟩
[GOAL]
case w.h.mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
x : ↑X
carrier✝ : Set ↑X
is_open'✝ : IsOpen carrier✝
property✝ : ↑(𝟙 X) x ∈ { carrier := carrier✝, is_open' := is_open'✝ }
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (↑(𝟙 X) x))ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion (↑(𝟙 X) x)).op).obj
          (𝟙 X _* ℱ))
        (op { obj := { carrier := carrier✝, is_open' := is_open'✝ }, property := property✝ }) ≫
      stalkPushforward C (𝟙 X) ℱ x =
    colimit.ι
        (((whiskeringLeft (OpenNhds (↑(𝟙 X) x))ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion (↑(𝟙 X) x)).op).obj
          (𝟙 X _* ℱ))
        (op { obj := { carrier := carrier✝, is_open' := is_open'✝ }, property := property✝ }) ≫
      (stalkFunctor C x).map (Pushforward.id ℱ).hom
[PROOFSTEP]
erw [colimit.ι_map_assoc]
[GOAL]
case w.h.mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
x : ↑X
carrier✝ : Set ↑X
is_open'✝ : IsOpen carrier✝
property✝ : ↑(𝟙 X) x ∈ { carrier := carrier✝, is_open' := is_open'✝ }
⊢ NatTrans.app (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso (𝟙 X) x).inv) ℱ)
        (op { obj := { carrier := carrier✝, is_open' := is_open'✝ }, property := property✝ }) ≫
      colimit.ι
          ((OpenNhds.map (𝟙 X) x).op ⋙
            ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj ℱ)
          (op { obj := { carrier := carrier✝, is_open' := is_open'✝ }, property := property✝ }) ≫
        colimit.pre (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj ℱ)
          (OpenNhds.map (𝟙 X) x).op =
    colimit.ι
        (((whiskeringLeft (OpenNhds (↑(𝟙 X) x))ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion (↑(𝟙 X) x)).op).obj
          (𝟙 X _* ℱ))
        (op { obj := { carrier := carrier✝, is_open' := is_open'✝ }, property := property✝ }) ≫
      (stalkFunctor C x).map (Pushforward.id ℱ).hom
[PROOFSTEP]
simp [stalkFunctor, stalkPushforward]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
f : X ⟶ Y
g : Y ⟶ Z
x : ↑X
⊢ stalkPushforward C (f ≫ g) ℱ x = stalkPushforward C g (f _* ℱ) (↑f x) ≫ stalkPushforward C f ℱ x
[PROOFSTEP]
change (_ : colimit _ ⟶ _) = (_ : colimit _ ⟶ _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
f : X ⟶ Y
g : Y ⟶ Z
x : ↑X
⊢ stalkPushforward C (f ≫ g) ℱ x = stalkPushforward C g (f _* ℱ) (↑f x) ≫ stalkPushforward C f ℱ x
[PROOFSTEP]
ext U
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
f : X ⟶ Y
g : Y ⟶ Z
x : ↑X
U : (OpenNhds (↑(f ≫ g) x))ᵒᵖ
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (↑(f ≫ g) x))ᵒᵖ (Opens ↑Z)ᵒᵖ C).obj (OpenNhds.inclusion (↑(f ≫ g) x)).op).obj
          ((f ≫ g) _* ℱ))
        U ≫
      stalkPushforward C (f ≫ g) ℱ x =
    colimit.ι
        (((whiskeringLeft (OpenNhds (↑(f ≫ g) x))ᵒᵖ (Opens ↑Z)ᵒᵖ C).obj (OpenNhds.inclusion (↑(f ≫ g) x)).op).obj
          ((f ≫ g) _* ℱ))
        U ≫
      stalkPushforward C g (f _* ℱ) (↑f x) ≫ stalkPushforward C f ℱ x
[PROOFSTEP]
rcases U with ⟨⟨_, _⟩, _⟩
[GOAL]
case w.mk.mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
f : X ⟶ Y
g : Y ⟶ Z
x : ↑X
carrier✝ : Set ↑Z
is_open'✝ : IsOpen carrier✝
property✝ : ↑(f ≫ g) x ∈ { carrier := carrier✝, is_open' := is_open'✝ }
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (↑(f ≫ g) x))ᵒᵖ (Opens ↑Z)ᵒᵖ C).obj (OpenNhds.inclusion (↑(f ≫ g) x)).op).obj
          ((f ≫ g) _* ℱ))
        { unop := { obj := { carrier := carrier✝, is_open' := is_open'✝ }, property := property✝ } } ≫
      stalkPushforward C (f ≫ g) ℱ x =
    colimit.ι
        (((whiskeringLeft (OpenNhds (↑(f ≫ g) x))ᵒᵖ (Opens ↑Z)ᵒᵖ C).obj (OpenNhds.inclusion (↑(f ≫ g) x)).op).obj
          ((f ≫ g) _* ℱ))
        { unop := { obj := { carrier := carrier✝, is_open' := is_open'✝ }, property := property✝ } } ≫
      stalkPushforward C g (f _* ℱ) (↑f x) ≫ stalkPushforward C f ℱ x
[PROOFSTEP]
simp only [colimit.ι_map_assoc, colimit.ι_pre_assoc, whiskerRight_app, Category.assoc]
[GOAL]
case w.mk.mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
ℱ : Presheaf C X
f : X ⟶ Y
g : Y ⟶ Z
x : ↑X
carrier✝ : Set ↑Z
is_open'✝ : IsOpen carrier✝
property✝ : ↑(f ≫ g) x ∈ { carrier := carrier✝, is_open' := is_open'✝ }
⊢ colimit.ι
        (((whiskeringLeft (OpenNhds (↑(f ≫ g) x))ᵒᵖ (Opens ↑Z)ᵒᵖ C).obj (OpenNhds.inclusion (↑(f ≫ g) x)).op).obj
          ((f ≫ g) _* ℱ))
        { unop := { obj := { carrier := carrier✝, is_open' := is_open'✝ }, property := property✝ } } ≫
      stalkPushforward C (f ≫ g) ℱ x =
    colimit.ι
        (((whiskeringLeft (OpenNhds (↑(f ≫ g) x))ᵒᵖ (Opens ↑Z)ᵒᵖ C).obj (OpenNhds.inclusion (↑(f ≫ g) x)).op).obj
          ((f ≫ g) _* ℱ))
        { unop := { obj := { carrier := carrier✝, is_open' := is_open'✝ }, property := property✝ } } ≫
      stalkPushforward C g (f _* ℱ) (↑f x) ≫ stalkPushforward C f ℱ x
[PROOFSTEP]
simp [stalkFunctor, stalkPushforward]
[GOAL]
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)
[PROOFSTEP]
haveI := Functor.initial_of_adjunction (hf.isOpenMap.adjunctionNhds x)
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
⊢ IsIso (stalkPushforward C f F x)
[PROOFSTEP]
convert
  IsIso.of_iso
    ((Functor.Final.colimitIso (hf.isOpenMap.functorNhds x).op ((OpenNhds.inclusion (f x)).op ⋙ f _* F) : _).symm ≪≫
      colim.mapIso _)
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
⊢ stalkPushforward C f F x =
    ((Functor.Final.colimitIso (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) 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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
⊢ (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op ⋙ (OpenNhds.inclusion (↑f x)).op ⋙ f _* F ≅
    ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F
[PROOFSTEP]
swap
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
⊢ (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op ⋙ (OpenNhds.inclusion (↑f x)).op ⋙ f _* F ≅
    ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F
[PROOFSTEP]
fapply NatIso.ofComponents
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
⊢ (X_1 : (OpenNhds x)ᵒᵖ) →
    ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) 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
[PROOFSTEP]
intro U
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
U : (OpenNhds x)ᵒᵖ
⊢ ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) 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
[PROOFSTEP]
refine' F.mapIso (eqToIso _)
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
U : (OpenNhds x)ᵒᵖ
⊢ (Opens.map f).op.obj ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj U)) =
    (OpenNhds.inclusion x).op.obj U
[PROOFSTEP]
dsimp only [Functor.op]
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
U : (OpenNhds x)ᵒᵖ
⊢ op
      ((Opens.map f).obj
        (op
            ((OpenNhds.inclusion (↑f x)).obj
              (op ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).obj U.unop)).unop)).unop) =
    op ((OpenNhds.inclusion x).obj U.unop)
[PROOFSTEP]
exact congr_arg op (Opens.ext <| Set.preimage_image_eq (unop U).1.1 hf.inj)
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
⊢ autoParam
    (∀ {X_1 Y_1 : (OpenNhds x)ᵒᵖ} (f_1 : X_1 ⟶ Y_1),
      ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op ⋙ (OpenNhds.inclusion (↑f x)).op ⋙ f _* F).map f_1 ≫
          (F.mapIso
              (eqToIso
                (_ :
                  (Opens.map f).op.obj
                      ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj Y_1)) =
                    (OpenNhds.inclusion x).op.obj Y_1))).hom =
        (F.mapIso
              (eqToIso
                (_ :
                  (Opens.map f).op.obj
                      ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj X_1)) =
                    (OpenNhds.inclusion x).op.obj X_1))).hom ≫
          (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F).map f_1)
    _auto✝
[PROOFSTEP]
intro U V i
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
U V : (OpenNhds x)ᵒᵖ
i : U ⟶ V
⊢ ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op ⋙ (OpenNhds.inclusion (↑f x)).op ⋙ f _* F).map i ≫
      (F.mapIso
          (eqToIso
            (_ :
              (Opens.map f).op.obj
                  ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj V)) =
                (OpenNhds.inclusion x).op.obj V))).hom =
    (F.mapIso
          (eqToIso
            (_ :
              (Opens.map f).op.obj
                  ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj U)) =
                (OpenNhds.inclusion x).op.obj U))).hom ≫
      (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F).map i
[PROOFSTEP]
erw [← F.map_comp, ← F.map_comp]
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
U V : (OpenNhds x)ᵒᵖ
i : U ⟶ V
⊢ F.map
      ((Opens.map f).op.map
          ((OpenNhds.inclusion (↑f x)).op.map ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.map i)) ≫
        (eqToIso
            (_ :
              (Opens.map f).op.obj
                  ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj V)) =
                (OpenNhds.inclusion x).op.obj V)).hom) =
    F.map
      ((eqToIso
            (_ :
              (Opens.map f).op.obj
                  ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj U)) =
                (OpenNhds.inclusion x).op.obj U)).hom ≫
        (OpenNhds.inclusion x).op.map i)
[PROOFSTEP]
congr 1
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
⊢ stalkPushforward C f F x =
    ((Functor.Final.colimitIso (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op
            ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)).symm ≪≫
        colim.mapIso
          (NatIso.ofComponents fun U =>
            F.mapIso
              (eqToIso
                (_ :
                  (Opens.map f).op.obj
                      ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj U)) =
                    (OpenNhds.inclusion x).op.obj U)))).hom
[PROOFSTEP]
change (_ : colimit _ ⟶ _) = (_ : colimit _ ⟶ _)
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
⊢ stalkPushforward C f F x =
    ((Functor.Final.colimitIso (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op
            ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)).symm ≪≫
        colim.mapIso
          (NatIso.ofComponents fun U =>
            F.mapIso
              (eqToIso
                (_ :
                  (Opens.map f).op.obj
                      ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj U)) =
                    (OpenNhds.inclusion x).op.obj U)))).hom
[PROOFSTEP]
ext U
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F 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 (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op
              ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)).symm ≪≫
          colim.mapIso
            (NatIso.ofComponents fun U =>
              F.mapIso
                (eqToIso
                  (_ :
                    (Opens.map f).op.obj
                        ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj U)) =
                      (OpenNhds.inclusion x).op.obj U)))).hom
[PROOFSTEP]
rw [← Iso.comp_inv_eq]
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F 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 (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op
              ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)).symm ≪≫
          colim.mapIso
            (NatIso.ofComponents fun U =>
              F.mapIso
                (eqToIso
                  (_ :
                    (Opens.map f).op.obj
                        ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj U)) =
                      (OpenNhds.inclusion x).op.obj U)))).inv =
    colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj (f _* F)) U
[PROOFSTEP]
erw [colimit.ι_map_assoc]
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (↑f x))ᵒᵖ
⊢ (NatTrans.app (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) F) 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 (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op
              ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)).symm ≪≫
          colim.mapIso
            (NatIso.ofComponents fun U =>
              F.mapIso
                (eqToIso
                  (_ :
                    (Opens.map f).op.obj
                        ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj U)) =
                      (OpenNhds.inclusion x).op.obj U)))).inv =
    colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj (f _* F)) U
[PROOFSTEP]
rw [colimit.ι_pre, Category.assoc]
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (↑f x))ᵒᵖ
⊢ NatTrans.app (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) F) 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 (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op
                ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)).symm ≪≫
            colim.mapIso
              (NatIso.ofComponents fun U =>
                F.mapIso
                  (eqToIso
                    (_ :
                      (Opens.map f).op.obj
                          ((OpenNhds.inclusion (↑f x)).op.obj ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj U)) =
                        (OpenNhds.inclusion x).op.obj U)))).inv =
    colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj (f _* F)) U
[PROOFSTEP]
erw [colimit.ι_map_assoc, colimit.ι_pre, ← F.map_comp_assoc]
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (↑f x))ᵒᵖ
⊢ F.map
        (NatTrans.app (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) U ≫
          (eqToIso
              (_ :
                (Opens.map f).op.obj
                    ((OpenNhds.inclusion (↑f x)).op.obj
                      ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj ((OpenNhds.map f x).op.obj U))) =
                  (OpenNhds.inclusion x).op.obj ((OpenNhds.map f x).op.obj U))).inv) ≫
      colimit.ι ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
        ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) 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
[PROOFSTEP]
apply colimit.w ((OpenNhds.inclusion (f x)).op ⋙ f _* F) _
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (↑f x))ᵒᵖ
⊢ U ⟶ (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).op.obj ((OpenNhds.map f x).op.obj U)
[PROOFSTEP]
dsimp only [Functor.op]
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (↑f x))ᵒᵖ
⊢ U ⟶ op ((IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).obj (op ((OpenNhds.map f x).obj U.unop)).unop)
[PROOFSTEP]
refine' ((homOfLE _).op : op (unop U) ⟶ _)
[GOAL]
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 : Functor.Initial (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x)
e_3✝ : stalk (f _* F) (↑f x) = colimit ((OpenNhds.inclusion (↑f x)).op ⋙ f _* F)
e_4✝ : stalk F x = colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
U : (OpenNhds (↑f x))ᵒᵖ
⊢ (IsOpenMap.functorNhds (_ : IsOpenMap ↑f) x).obj (op ((OpenNhds.map f x).obj U.unop)).unop ≤ U.unop
[PROOFSTEP]
exact Set.image_preimage_subset _ _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
U : Opens ↑X
x : { x // x ∈ U }
x✝¹ x✝ : CostructuredArrow (Opens.map f).op (op U)
i : x✝¹ ⟶ x✝
⊢ (Lan.diagram (Opens.map f).op F (op U)).map i ≫
      (fun V => germ F { val := ↑f ↑x, property := (_ : ↑x ∈ ↑((Opens.map f).op.obj V.left).unop) }) x✝ =
    (fun V => germ F { val := ↑f ↑x, property := (_ : ↑x ∈ ↑((Opens.map f).op.obj V.left).unop) }) x✝¹ ≫
      ((Functor.const (CostructuredArrow (Opens.map f).op (op U))).obj (stalk F (↑f ↑x))).map i
[PROOFSTEP]
erw [Category.comp_id]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
U : Opens ↑X
x : { x // x ∈ U }
x✝¹ x✝ : CostructuredArrow (Opens.map f).op (op U)
i : x✝¹ ⟶ x✝
⊢ (Lan.diagram (Opens.map f).op F (op U)).map i ≫
      (fun V => germ F { val := ↑f ↑x, property := (_ : ↑x ∈ ↑((Opens.map f).op.obj V.left).unop) }) x✝ =
    (fun V => germ F { val := ↑f ↑x, property := (_ : ↑x ∈ ↑((Opens.map f).op.obj V.left).unop) }) x✝¹
[PROOFSTEP]
exact F.germ_res i.left.unop _
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
x✝² x✝¹ : (OpenNhds x)ᵒᵖ
x✝ : x✝² ⟶ x✝¹
⊢ ((OpenNhds.inclusion x).op ⋙ pullbackObj f F).map x✝ ≫
      (fun U => germToPullbackStalk C f F U.unop.obj { val := x, property := (_ : x ∈ U.unop.obj) }) x✝¹ =
    (fun U => germToPullbackStalk C f F U.unop.obj { val := x, property := (_ : x ∈ U.unop.obj) }) x✝² ≫
      ((Functor.const (OpenNhds x)ᵒᵖ).obj (stalk F (↑f x))).map x✝
[PROOFSTEP]
erw [colimit.pre_desc, Category.comp_id]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
x✝² x✝¹ : (OpenNhds x)ᵒᵖ
x✝ : x✝² ⟶ x✝¹
⊢ colimit.desc
      (CostructuredArrow.map ((OpenNhds.inclusion x).op.map x✝) ⋙
        Lan.diagram (Opens.map f).op F ((OpenNhds.inclusion x).op.obj x✝¹))
      (Cocone.whisker (CostructuredArrow.map ((OpenNhds.inclusion x).op.map x✝))
        { pt := stalk F (↑f ↑{ val := x, property := (_ : x ∈ x✝¹.unop.obj) }),
          ι :=
            NatTrans.mk fun V =>
              germ F
                { val := ↑f ↑{ val := x, property := (_ : x ∈ x✝¹.unop.obj) },
                  property :=
                    (_ : ↑{ val := x, property := (_ : x ∈ x✝¹.unop.obj) } ∈ ↑((Opens.map f).op.obj V.left).unop) } }) =
    (fun U => germToPullbackStalk C f F U.unop.obj { val := x, property := (_ : x ∈ U.unop.obj) }) x✝²
[PROOFSTEP]
congr
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
⊢ stalkPullbackHom C f F x ≫ stalkPullbackInv C f F x = 𝟙 (stalk F (↑f x))
[PROOFSTEP]
delta stalkPullbackHom stalkPullbackInv stalkFunctor Presheaf.pullback stalkPushforward germToPullbackStalk germ
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
⊢ (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op ⋙ colim).map
          (NatTrans.app (pushforwardPullbackAdjunction C f).unit F) ≫
        colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F)) ≫
          colimit.pre
            (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
              ((lan (Opens.map f).op).obj F))
            (OpenNhds.map f x).op) ≫
      colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
        { pt := stalk F (↑f x),
          ι :=
            NatTrans.mk fun U =>
              colimit.desc (Lan.diagram (Opens.map f).op F (op U.unop.obj))
                { pt := stalk F (↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) }),
                  ι :=
                    NatTrans.mk fun V =>
                      colimit.ι
                        ((OpenNhds.inclusion
                              ↑{ val := ↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) },
                                  property :=
                                    (_ :
                                      ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                        ↑((Opens.map f).op.obj V.left).unop) }).op ⋙
                          F)
                        (op
                          { obj := V.left.unop,
                            property :=
                              (_ :
                                ↑{ val := ↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) },
                                      property :=
                                        (_ :
                                          ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                            ↑((Opens.map f).op.obj V.left).unop) } ∈
                                  V.left.unop) }) } } =
    𝟙 (stalk F (↑f x))
[PROOFSTEP]
change (_ : colimit _ ⟶ _) = (_ : colimit _ ⟶ _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
⊢ (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op ⋙ colim).map
          (NatTrans.app (pushforwardPullbackAdjunction C f).unit F) ≫
        colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F)) ≫
          colimit.pre
            (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
              ((lan (Opens.map f).op).obj F))
            (OpenNhds.map f x).op) ≫
      colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
        { pt := stalk F (↑f x),
          ι :=
            NatTrans.mk fun U =>
              colimit.desc (Lan.diagram (Opens.map f).op F (op U.unop.obj))
                { pt := stalk F (↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) }),
                  ι :=
                    NatTrans.mk fun V =>
                      colimit.ι
                        ((OpenNhds.inclusion
                              ↑{ val := ↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) },
                                  property :=
                                    (_ :
                                      ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                        ↑((Opens.map f).op.obj V.left).unop) }).op ⋙
                          F)
                        (op
                          { obj := V.left.unop,
                            property :=
                              (_ :
                                ↑{ val := ↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) },
                                      property :=
                                        (_ :
                                          ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                            ↑((Opens.map f).op.obj V.left).unop) } ∈
                                  V.left.unop) }) } } =
    𝟙 (stalk F (↑f x))
[PROOFSTEP]
ext j
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
j : (OpenNhds (↑f x))ᵒᵖ
⊢ colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj F) j ≫
      (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op ⋙ colim).map
            (NatTrans.app (pushforwardPullbackAdjunction C f).unit F) ≫
          colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F)) ≫
            colimit.pre
              (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
                ((lan (Opens.map f).op).obj F))
              (OpenNhds.map f x).op) ≫
        colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
          { pt := stalk F (↑f x),
            ι :=
              NatTrans.mk fun U =>
                colimit.desc (Lan.diagram (Opens.map f).op F (op U.unop.obj))
                  { pt := stalk F (↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) }),
                    ι :=
                      NatTrans.mk fun V =>
                        colimit.ι
                          ((OpenNhds.inclusion
                                ↑{ val := ↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) },
                                    property :=
                                      (_ :
                                        ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                          ↑((Opens.map f).op.obj V.left).unop) }).op ⋙
                            F)
                          (op
                            { obj := V.left.unop,
                              property :=
                                (_ :
                                  ↑{ val := ↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) },
                                        property :=
                                          (_ :
                                            ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                              ↑((Opens.map f).op.obj V.left).unop) } ∈
                                    V.left.unop) }) } } =
    colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj F) j ≫
      𝟙 (stalk F (↑f x))
[PROOFSTEP]
induction' j with j
[GOAL]
case w.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
j : OpenNhds (↑f x)
⊢ colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj F) (op j) ≫
      (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op ⋙ colim).map
            (NatTrans.app (pushforwardPullbackAdjunction C f).unit F) ≫
          colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F)) ≫
            colimit.pre
              (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
                ((lan (Opens.map f).op).obj F))
              (OpenNhds.map f x).op) ≫
        colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
          { pt := stalk F (↑f x),
            ι :=
              NatTrans.mk fun U =>
                colimit.desc (Lan.diagram (Opens.map f).op F (op U.unop.obj))
                  { pt := stalk F (↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) }),
                    ι :=
                      NatTrans.mk fun V =>
                        colimit.ι
                          ((OpenNhds.inclusion
                                ↑{ val := ↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) },
                                    property :=
                                      (_ :
                                        ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                          ↑((Opens.map f).op.obj V.left).unop) }).op ⋙
                            F)
                          (op
                            { obj := V.left.unop,
                              property :=
                                (_ :
                                  ↑{ val := ↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) },
                                        property :=
                                          (_ :
                                            ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                              ↑((Opens.map f).op.obj V.left).unop) } ∈
                                    V.left.unop) }) } } =
    colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj F) (op j) ≫
      𝟙 (stalk F (↑f x))
[PROOFSTEP]
cases j
[GOAL]
case w.h.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
obj✝ : Opens ↑Y
property✝ : ↑f x ∈ obj✝
⊢ colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj F)
        (op { obj := obj✝, property := property✝ }) ≫
      (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op ⋙ colim).map
            (NatTrans.app (pushforwardPullbackAdjunction C f).unit F) ≫
          colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F)) ≫
            colimit.pre
              (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
                ((lan (Opens.map f).op).obj F))
              (OpenNhds.map f x).op) ≫
        colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
          { pt := stalk F (↑f x),
            ι :=
              NatTrans.mk fun U =>
                colimit.desc (Lan.diagram (Opens.map f).op F (op U.unop.obj))
                  { pt := stalk F (↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) }),
                    ι :=
                      NatTrans.mk fun V =>
                        colimit.ι
                          ((OpenNhds.inclusion
                                ↑{ val := ↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) },
                                    property :=
                                      (_ :
                                        ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                          ↑((Opens.map f).op.obj V.left).unop) }).op ⋙
                            F)
                          (op
                            { obj := V.left.unop,
                              property :=
                                (_ :
                                  ↑{ val := ↑f ↑{ val := x, property := (_ : x ∈ U.unop.obj) },
                                        property :=
                                          (_ :
                                            ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                              ↑((Opens.map f).op.obj V.left).unop) } ∈
                                    V.left.unop) }) } } =
    colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj F)
        (op { obj := obj✝, property := property✝ }) ≫
      𝟙 (stalk F (↑f x))
[PROOFSTEP]
simp only [TopologicalSpace.OpenNhds.inclusionMapIso_inv, whiskerRight_app, whiskerLeft_app, whiskeringLeft_obj_map,
  Functor.comp_map, colimit.ι_map_assoc, NatTrans.op_id, lan_obj_map, pushforwardPullbackAdjunction_unit_app_app,
  Category.assoc, colimit.ι_pre_assoc]
[GOAL]
case w.h.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
obj✝ : Opens ↑Y
property✝ : ↑f x ∈ obj✝
⊢ colimit.ι
        (Lan.diagram (Opens.map f).op F
          (op
            ((Opens.map f).obj ((OpenNhds.inclusion (↑f x)).op.obj (op { obj := obj✝, property := property✝ })).unop)))
        (CostructuredArrow.mk
          (𝟙
            (op
              ((Opens.map f).obj
                ((OpenNhds.inclusion (↑f x)).op.obj (op { obj := obj✝, property := property✝ })).unop)))) ≫
      colimit.pre
          (Lan.diagram (Opens.map f).op F
            ((OpenNhds.map f x ⋙ OpenNhds.inclusion x).op.obj (op { obj := obj✝, property := property✝ })))
          (CostructuredArrow.map
            (NatTrans.app (𝟙 (OpenNhds.map f x ⋙ OpenNhds.inclusion x).op)
              (op { obj := obj✝, property := property✝ }))) ≫
        colimit.ι
            (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
              ((lan (Opens.map f).op).obj F))
            ((OpenNhds.map f x).op.obj (op { obj := obj✝, property := property✝ })) ≫
          colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
            { pt := stalk F (↑f x),
              ι :=
                NatTrans.mk fun U =>
                  colimit.desc (Lan.diagram (Opens.map f).op F (op U.unop.obj))
                    { pt := stalk F (↑f x),
                      ι :=
                        NatTrans.mk fun V =>
                          colimit.ι ((OpenNhds.inclusion (↑f x)).op ⋙ F)
                            (op
                              { obj := V.left.unop,
                                property :=
                                  (_ :
                                    ↑{ val := ↑f x,
                                          property :=
                                            (_ :
                                              ↑{ val := x, property := (_ : x ∈ U.unop.obj) } ∈
                                                ↑((Opens.map f).op.obj V.left).unop) } ∈
                                      V.left.unop) }) } } =
    colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj F)
        (op { obj := obj✝, property := property✝ }) ≫
      𝟙 (stalk F (↑f x))
[PROOFSTEP]
erw [colimit.ι_desc, colimit.pre_desc, colimit.ι_desc, Category.comp_id]
[GOAL]
case w.h.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
obj✝ : Opens ↑Y
property✝ : ↑f x ∈ obj✝
⊢ NatTrans.app
      (Cocone.whisker
          (CostructuredArrow.map
            (NatTrans.app (𝟙 (OpenNhds.map f x ⋙ OpenNhds.inclusion x).op) (op { obj := obj✝, property := property✝ })))
          { pt := stalk F (↑f x),
            ι :=
              NatTrans.mk fun V =>
                colimit.ι ((OpenNhds.inclusion (↑f x)).op ⋙ F)
                  (op
                    { obj := V.left.unop,
                      property :=
                        (_ :
                          ↑{ val := ↑f x,
                                property :=
                                  (_ :
                                    ↑{ val := x,
                                          property :=
                                            (_ :
                                              x ∈
                                                ((OpenNhds.map f x).op.obj
                                                      (op { obj := obj✝, property := property✝ })).unop.obj) } ∈
                                      ↑((Opens.map f).op.obj V.left).unop) } ∈
                            V.left.unop) }) }).ι
      (CostructuredArrow.mk
        (𝟙
          (op
            ((Opens.map f).obj
              ((OpenNhds.inclusion (↑f x)).op.obj (op { obj := obj✝, property := property✝ })).unop)))) =
    colimit.ι (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).obj F)
      (op { obj := obj✝, property := property✝ })
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
⊢ stalkPullbackInv C f F x ≫ stalkPullbackHom C f F x = 𝟙 (stalk (pullbackObj f F) x)
[PROOFSTEP]
delta stalkPullbackHom stalkPullbackInv stalkFunctor Presheaf.pullback stalkPushforward
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
⊢ colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
        { pt := stalk F (↑f x),
          ι :=
            NatTrans.mk fun U => germToPullbackStalk C f F U.unop.obj { val := x, property := (_ : x ∈ U.unop.obj) } } ≫
      ((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op ⋙ colim).map
          (NatTrans.app (pushforwardPullbackAdjunction C f).unit F) ≫
        colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F)) ≫
          colimit.pre
            (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
              ((lan (Opens.map f).op).obj F))
            (OpenNhds.map f x).op =
    𝟙 (stalk (pullbackObj f F) x)
[PROOFSTEP]
change (_ : colimit _ ⟶ _) = (_ : colimit _ ⟶ _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
⊢ colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
        { pt := stalk F (↑f x),
          ι :=
            NatTrans.mk fun U => germToPullbackStalk C f F U.unop.obj { val := x, property := (_ : x ∈ U.unop.obj) } } ≫
      ((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op ⋙ colim).map
          (NatTrans.app (pushforwardPullbackAdjunction C f).unit F) ≫
        colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F)) ≫
          colimit.pre
            (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
              ((lan (Opens.map f).op).obj F))
            (OpenNhds.map f x).op =
    𝟙 (stalk (pullbackObj f F) x)
[PROOFSTEP]
ext ⟨U_obj, U_property⟩
[GOAL]
case w.mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
U_obj : Opens ↑X
U_property : x ∈ U_obj
⊢ colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
        { unop := { obj := U_obj, property := U_property } } ≫
      colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
          { pt := stalk F (↑f x),
            ι :=
              NatTrans.mk fun U =>
                germToPullbackStalk C f F U.unop.obj { val := x, property := (_ : x ∈ U.unop.obj) } } ≫
        ((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op ⋙ colim).map
            (NatTrans.app (pushforwardPullbackAdjunction C f).unit F) ≫
          colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F)) ≫
            colimit.pre
              (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
                ((lan (Opens.map f).op).obj F))
              (OpenNhds.map f x).op =
    colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
        { unop := { obj := U_obj, property := U_property } } ≫
      𝟙 (stalk (pullbackObj f F) x)
[PROOFSTEP]
change (_ : colimit _ ⟶ _) = (_ : colimit _ ⟶ _)
[GOAL]
case w.mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
U_obj : Opens ↑X
U_property : x ∈ U_obj
⊢ colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
        { unop := { obj := U_obj, property := U_property } } ≫
      colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
          { pt := stalk F (↑f x),
            ι :=
              NatTrans.mk fun U =>
                germToPullbackStalk C f F U.unop.obj { val := x, property := (_ : x ∈ U.unop.obj) } } ≫
        ((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op ⋙ colim).map
            (NatTrans.app (pushforwardPullbackAdjunction C f).unit F) ≫
          colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F)) ≫
            colimit.pre
              (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
                ((lan (Opens.map f).op).obj F))
              (OpenNhds.map f x).op =
    colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
        { unop := { obj := U_obj, property := U_property } } ≫
      𝟙 (stalk (pullbackObj f F) x)
[PROOFSTEP]
ext ⟨j_left, ⟨⟨⟩⟩, j_hom⟩
[GOAL]
case w.mk.mk.w.mk.mk.unit
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
U_obj : Opens ↑X
U_property : x ∈ U_obj
j_left : (Opens ↑Y)ᵒᵖ
j_hom :
  (Opens.map f).op.obj j_left ⟶
    (Functor.fromPUnit ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } })).obj
      { as := PUnit.unit }
⊢ colimit.ι
        (Lan.diagram (Opens.map f).op F
          ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } }))
        { left := j_left, right := { as := PUnit.unit }, hom := j_hom } ≫
      colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
          { unop := { obj := U_obj, property := U_property } } ≫
        colimit.desc ((OpenNhds.inclusion x).op ⋙ pullbackObj f F)
            { pt := stalk F (↑f x),
              ι :=
                NatTrans.mk fun U =>
                  germToPullbackStalk C f F U.unop.obj { val := x, property := (_ : x ∈ U.unop.obj) } } ≫
          ((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op ⋙ colim).map
              (NatTrans.app (pushforwardPullbackAdjunction C f).unit F) ≫
            colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F)) ≫
              colimit.pre
                (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
                  ((lan (Opens.map f).op).obj F))
                (OpenNhds.map f x).op =
    colimit.ι
        (Lan.diagram (Opens.map f).op F
          ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } }))
        { left := j_left, right := { as := PUnit.unit }, hom := j_hom } ≫
      colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
          { unop := { obj := U_obj, property := U_property } } ≫
        𝟙 (stalk (pullbackObj f F) x)
[PROOFSTEP]
erw [colimit.map_desc, colimit.map_desc, colimit.ι_desc_assoc, colimit.ι_desc_assoc, colimit.ι_desc, Category.comp_id]
[GOAL]
case w.mk.mk.w.mk.mk.unit
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
U_obj : Opens ↑X
U_property : x ∈ U_obj
j_left : (Opens ↑Y)ᵒᵖ
j_hom :
  (Opens.map f).op.obj j_left ⟶
    (Functor.fromPUnit ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } })).obj
      { as := PUnit.unit }
⊢ NatTrans.app
      ((Cocones.precompose
              (((whiskeringLeft (OpenNhds (↑f x))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f x)).op).map
                (NatTrans.app (pushforwardPullbackAdjunction C f).unit F))).obj
          ((Cocones.precompose
                (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) ((lan (Opens.map f).op).obj F))).obj
            (Cocone.whisker (OpenNhds.map f x).op
              (colimit.cocone
                (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
                  ((lan (Opens.map f).op).obj F)))))).ι
      (op
        { obj := { left := j_left, right := { as := PUnit.unit }, hom := j_hom }.left.unop,
          property :=
            (_ :
              ↑{
                    val :=
                      ↑f
                        ↑{ val := x,
                            property := (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) },
                    property :=
                      (_ :
                        ↑{ val := x,
                              property := (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                          ↑((Opens.map f).op.obj
                                { left := j_left, right := { as := PUnit.unit }, hom := j_hom }.left).unop) } ∈
                { left := j_left, right := { as := PUnit.unit }, hom := j_hom }.left.unop) }) =
    colimit.ι
        (Lan.diagram (Opens.map f).op F
          ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } }))
        { left := j_left, right := { as := PUnit.unit }, hom := j_hom } ≫
      colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
        { unop := { obj := U_obj, property := U_property } }
[PROOFSTEP]
simp only [Cocone.whisker_ι, colimit.cocone_ι, OpenNhds.inclusionMapIso_inv, Cocones.precompose_obj_ι, whiskerRight_app,
  whiskerLeft_app, NatTrans.comp_app, whiskeringLeft_obj_map, NatTrans.op_id, lan_obj_map,
  pushforwardPullbackAdjunction_unit_app_app]
[GOAL]
case w.mk.mk.w.mk.mk.unit
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
U_obj : Opens ↑X
U_property : x ∈ U_obj
j_left : (Opens ↑Y)ᵒᵖ
j_hom :
  (Opens.map f).op.obj j_left ⟶
    (Functor.fromPUnit ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } })).obj
      { as := PUnit.unit }
⊢ colimit.ι
        (Lan.diagram (Opens.map f).op F
          (op
            ((Opens.map f).obj
              ((OpenNhds.inclusion (↑f x)).op.obj
                  (op
                    { obj := j_left.unop,
                      property :=
                        (_ :
                          ↑{ val := ↑f x,
                                property :=
                                  (_ :
                                    ↑{ val := x,
                                          property :=
                                            (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                      ↑((Opens.map f).op.obj
                                            { left := j_left, right := { as := PUnit.unit },
                                                hom := j_hom }.left).unop) } ∈
                            j_left.unop) })).unop)))
        (CostructuredArrow.mk
          (𝟙
            (op
              ((Opens.map f).obj
                ((OpenNhds.inclusion (↑f x)).op.obj
                    (op
                      { obj := j_left.unop,
                        property :=
                          (_ :
                            ↑{ val := ↑f x,
                                  property :=
                                    (_ :
                                      ↑{ val := x,
                                            property :=
                                              (_ :
                                                x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                        ↑((Opens.map f).op.obj
                                              { left := j_left, right := { as := PUnit.unit },
                                                  hom := j_hom }.left).unop) } ∈
                              j_left.unop) })).unop)))) ≫
      colimit.pre
          (Lan.diagram (Opens.map f).op F
            ((OpenNhds.map f x ⋙ OpenNhds.inclusion x).op.obj
              (op
                { obj := j_left.unop,
                  property :=
                    (_ :
                      ↑{ val := ↑f x,
                            property :=
                              (_ :
                                ↑{ val := x,
                                      property :=
                                        (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                  ↑((Opens.map f).op.obj
                                        { left := j_left, right := { as := PUnit.unit }, hom := j_hom }.left).unop) } ∈
                        j_left.unop) })))
          (CostructuredArrow.map
            (NatTrans.app (𝟙 (OpenNhds.map f x ⋙ OpenNhds.inclusion x).op)
              (op
                { obj := j_left.unop,
                  property :=
                    (_ :
                      ↑{ val := ↑f x,
                            property :=
                              (_ :
                                ↑{ val := x,
                                      property :=
                                        (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                  ↑((Opens.map f).op.obj
                                        { left := j_left, right := { as := PUnit.unit }, hom := j_hom }.left).unop) } ∈
                        j_left.unop) }))) ≫
        colimit.ι
          (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
            ((lan (Opens.map f).op).obj F))
          ((OpenNhds.map f x).op.obj
            (op
              { obj := j_left.unop,
                property :=
                  (_ :
                    ↑{ val := ↑f x,
                          property :=
                            (_ :
                              ↑{ val := x,
                                    property :=
                                      (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                ↑((Opens.map f).op.obj
                                      { left := j_left, right := { as := PUnit.unit }, hom := j_hom }.left).unop) } ∈
                      j_left.unop) })) =
    colimit.ι
        (Lan.diagram (Opens.map f).op F
          ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } }))
        { left := j_left, right := { as := PUnit.unit }, hom := j_hom } ≫
      colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
        { unop := { obj := U_obj, property := U_property } }
[PROOFSTEP]
erw [←
  colimit.w _
    (@homOfLE (OpenNhds x) _ ⟨_, U_property⟩ ⟨(Opens.map f).obj (unop j_left), j_hom.unop.le U_property⟩
        j_hom.unop.le).op]
[GOAL]
case w.mk.mk.w.mk.mk.unit
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
U_obj : Opens ↑X
U_property : x ∈ U_obj
j_left : (Opens ↑Y)ᵒᵖ
j_hom :
  (Opens.map f).op.obj j_left ⟶
    (Functor.fromPUnit ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } })).obj
      { as := PUnit.unit }
⊢ colimit.ι
        (Lan.diagram (Opens.map f).op F
          (op
            ((Opens.map f).obj
              ((OpenNhds.inclusion (↑f x)).op.obj
                  (op
                    { obj := j_left.unop,
                      property :=
                        (_ :
                          ↑{ val := ↑f x,
                                property :=
                                  (_ :
                                    ↑{ val := x,
                                          property :=
                                            (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                      ↑((Opens.map f).op.obj
                                            { left := j_left, right := { as := PUnit.unit },
                                                hom := j_hom }.left).unop) } ∈
                            j_left.unop) })).unop)))
        (CostructuredArrow.mk
          (𝟙
            (op
              ((Opens.map f).obj
                ((OpenNhds.inclusion (↑f x)).op.obj
                    (op
                      { obj := j_left.unop,
                        property :=
                          (_ :
                            ↑{ val := ↑f x,
                                  property :=
                                    (_ :
                                      ↑{ val := x,
                                            property :=
                                              (_ :
                                                x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                        ↑((Opens.map f).op.obj
                                              { left := j_left, right := { as := PUnit.unit },
                                                  hom := j_hom }.left).unop) } ∈
                              j_left.unop) })).unop)))) ≫
      colimit.pre
          (Lan.diagram (Opens.map f).op F
            ((OpenNhds.map f x ⋙ OpenNhds.inclusion x).op.obj
              (op
                { obj := j_left.unop,
                  property :=
                    (_ :
                      ↑{ val := ↑f x,
                            property :=
                              (_ :
                                ↑{ val := x,
                                      property :=
                                        (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                  ↑((Opens.map f).op.obj
                                        { left := j_left, right := { as := PUnit.unit }, hom := j_hom }.left).unop) } ∈
                        j_left.unop) })))
          (CostructuredArrow.map
            (NatTrans.app (𝟙 (OpenNhds.map f x ⋙ OpenNhds.inclusion x).op)
              (op
                { obj := j_left.unop,
                  property :=
                    (_ :
                      ↑{ val := ↑f x,
                            property :=
                              (_ :
                                ↑{ val := x,
                                      property :=
                                        (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                  ↑((Opens.map f).op.obj
                                        { left := j_left, right := { as := PUnit.unit }, hom := j_hom }.left).unop) } ∈
                        j_left.unop) }))) ≫
        (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
                ((lan (Opens.map f).op).obj F)).map
            (homOfLE
                (_ :
                  ((Functor.fromPUnit
                            ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } })).obj
                        { as := PUnit.unit }).unop ≤
                    ((Opens.map f).op.obj j_left).unop)).op ≫
          colimit.ι
            (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
              ((lan (Opens.map f).op).obj F))
            (op { obj := U_obj, property := U_property }) =
    colimit.ι
        (Lan.diagram (Opens.map f).op F
          ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } }))
        { left := j_left, right := { as := PUnit.unit }, hom := j_hom } ≫
      colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
        { unop := { obj := U_obj, property := U_property } }
[PROOFSTEP]
erw [colimit.ι_pre_assoc (Lan.diagram _ F _) (CostructuredArrow.map _)]
[GOAL]
case w.mk.mk.w.mk.mk.unit
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
U_obj : Opens ↑X
U_property : x ∈ U_obj
j_left : (Opens ↑Y)ᵒᵖ
j_hom :
  (Opens.map f).op.obj j_left ⟶
    (Functor.fromPUnit ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } })).obj
      { as := PUnit.unit }
⊢ colimit.ι
        (Lan.diagram (Opens.map f).op F
          (op
            ((Opens.map f).obj
              ((OpenNhds.inclusion (↑f x)).op.obj
                  (op
                    { obj := j_left.unop,
                      property :=
                        (_ :
                          ↑{ val := ↑f x,
                                property :=
                                  (_ :
                                    ↑{ val := x,
                                          property :=
                                            (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                      ↑((Opens.map f).op.obj
                                            { left := j_left, right := { as := PUnit.unit },
                                                hom := j_hom }.left).unop) } ∈
                            j_left.unop) })).unop)))
        ((CostructuredArrow.map
              (NatTrans.app (𝟙 (OpenNhds.map f x ⋙ OpenNhds.inclusion x).op)
                (op
                  { obj := j_left.unop,
                    property :=
                      (_ :
                        ↑{ val := ↑f x,
                              property :=
                                (_ :
                                  ↑{ val := x,
                                        property :=
                                          (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                    ↑((Opens.map f).op.obj
                                          { left := j_left, right := { as := PUnit.unit },
                                              hom := j_hom }.left).unop) } ∈
                          j_left.unop) }))).obj
          (CostructuredArrow.mk
            (𝟙
              (op
                ((Opens.map f).obj
                  ((OpenNhds.inclusion (↑f x)).op.obj
                      (op
                        { obj := j_left.unop,
                          property :=
                            (_ :
                              ↑{ val := ↑f x,
                                    property :=
                                      (_ :
                                        ↑{ val := x,
                                              property :=
                                                (_ :
                                                  x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                          ↑((Opens.map f).op.obj
                                                { left := j_left, right := { as := PUnit.unit },
                                                    hom := j_hom }.left).unop) } ∈
                                j_left.unop) })).unop))))) ≫
      (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
              ((lan (Opens.map f).op).obj F)).map
          (homOfLE
              (_ :
                ((Functor.fromPUnit
                          ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } })).obj
                      { as := PUnit.unit }).unop ≤
                  ((Opens.map f).op.obj j_left).unop)).op ≫
        colimit.ι
          (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
            ((lan (Opens.map f).op).obj F))
          (op { obj := U_obj, property := U_property }) =
    colimit.ι
        (Lan.diagram (Opens.map f).op F
          ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } }))
        { left := j_left, right := { as := PUnit.unit }, hom := j_hom } ≫
      colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
        { unop := { obj := U_obj, property := U_property } }
[PROOFSTEP]
erw [colimit.ι_pre_assoc (Lan.diagram _ F (op U_obj)) (CostructuredArrow.map _)]
[GOAL]
case w.mk.mk.w.mk.mk.unit
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C Y
x : ↑X
U_obj : Opens ↑X
U_property : x ∈ U_obj
j_left : (Opens ↑Y)ᵒᵖ
j_hom :
  (Opens.map f).op.obj j_left ⟶
    (Functor.fromPUnit ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } })).obj
      { as := PUnit.unit }
⊢ colimit.ι (Lan.diagram (Opens.map f).op F (op U_obj))
        ((CostructuredArrow.map
              ((OpenNhds.inclusion x).op.map
                (homOfLE
                    (_ :
                      ((Functor.fromPUnit
                                ((OpenNhds.inclusion x).op.obj
                                  { unop := { obj := U_obj, property := U_property } })).obj
                            { as := PUnit.unit }).unop ≤
                        ((Opens.map f).op.obj j_left).unop)).op)).obj
          ((CostructuredArrow.map
                (NatTrans.app (𝟙 (OpenNhds.map f x ⋙ OpenNhds.inclusion x).op)
                  (op
                    { obj := j_left.unop,
                      property :=
                        (_ :
                          ↑{ val := ↑f x,
                                property :=
                                  (_ :
                                    ↑{ val := x,
                                          property :=
                                            (_ : x ∈ { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                      ↑((Opens.map f).op.obj
                                            { left := j_left, right := { as := PUnit.unit },
                                                hom := j_hom }.left).unop) } ∈
                            j_left.unop) }))).obj
            (CostructuredArrow.mk
              (𝟙
                (op
                  ((Opens.map f).obj
                    ((OpenNhds.inclusion (↑f x)).op.obj
                        (op
                          { obj := j_left.unop,
                            property :=
                              (_ :
                                ↑{ val := ↑f x,
                                      property :=
                                        (_ :
                                          ↑{ val := x,
                                                property :=
                                                  (_ :
                                                    x ∈
                                                      { unop := { obj := U_obj, property := U_property } }.unop.obj) } ∈
                                            ↑((Opens.map f).op.obj
                                                  { left := j_left, right := { as := PUnit.unit },
                                                      hom := j_hom }.left).unop) } ∈
                                  j_left.unop) })).unop)))))) ≫
      colimit.ι
        (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj
          ((lan (Opens.map f).op).obj F))
        (op { obj := U_obj, property := U_property }) =
    colimit.ι
        (Lan.diagram (Opens.map f).op F
          ((OpenNhds.inclusion x).op.obj { unop := { obj := U_obj, property := U_property } }))
        { left := j_left, right := { as := PUnit.unit }, hom := j_hom } ≫
      colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj (pullbackObj f F))
        { unop := { obj := U_obj, property := U_property } }
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F : Presheaf C X
x y : ↑X
h : x ⤳ y
⊢ stalk F y ⟶ stalk F x
[PROOFSTEP]
refine' colimit.desc _ ⟨_, fun U => _, _⟩
[GOAL]
case refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F : Presheaf C X
x y : ↑X
h : x ⤳ y
U : (OpenNhds y)ᵒᵖ
⊢ (((whiskeringLeft (OpenNhds y)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion y).op).obj F).obj U ⟶
    ((Functor.const (OpenNhds y)ᵒᵖ).obj
          (colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F))).obj
      U
[PROOFSTEP]
exact
  colimit.ι ((OpenNhds.inclusion x).op ⋙ F)
    (op ⟨(unop U).1, (specializes_iff_forall_open.mp h _ (unop U).1.2 (unop U).2 : _)⟩)
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F : Presheaf C X
x y : ↑X
h : x ⤳ y
⊢ ∀ ⦃X_1 Y : (OpenNhds y)ᵒᵖ⦄ (f : X_1 ⟶ Y),
    (((whiskeringLeft (OpenNhds y)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion y).op).obj F).map f ≫
        (fun U =>
            colimit.ι ((OpenNhds.inclusion x).op ⋙ F)
              (op { obj := U.unop.obj, property := (_ : x ∈ U.unop.obj.carrier) }))
          Y =
      (fun U =>
            colimit.ι ((OpenNhds.inclusion x).op ⋙ F)
              (op { obj := U.unop.obj, property := (_ : x ∈ U.unop.obj.carrier) }))
          X_1 ≫
        ((Functor.const (OpenNhds y)ᵒᵖ).obj
              (colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F))).map
          f
[PROOFSTEP]
intro U V i
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F : Presheaf C X
x y : ↑X
h : x ⤳ y
U V : (OpenNhds y)ᵒᵖ
i : U ⟶ V
⊢ (((whiskeringLeft (OpenNhds y)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion y).op).obj F).map i ≫
      (fun U =>
          colimit.ι ((OpenNhds.inclusion x).op ⋙ F)
            (op { obj := U.unop.obj, property := (_ : x ∈ U.unop.obj.carrier) }))
        V =
    (fun U =>
          colimit.ι ((OpenNhds.inclusion x).op ⋙ F)
            (op { obj := U.unop.obj, property := (_ : x ∈ U.unop.obj.carrier) }))
        U ≫
      ((Functor.const (OpenNhds y)ᵒᵖ).obj
            (colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F))).map
        i
[PROOFSTEP]
dsimp
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F : Presheaf C X
x y : ↑X
h : x ⤳ y
U V : (OpenNhds y)ᵒᵖ
i : U ⟶ V
⊢ F.map ((OpenNhds.inclusion y).map i.unop).op ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ F) (op { obj := V.unop.obj, property := (_ : x ∈ ↑V.unop.obj) }) =
    colimit.ι ((OpenNhds.inclusion x).op ⋙ F) (op { obj := U.unop.obj, property := (_ : x ∈ ↑U.unop.obj) }) ≫
      𝟙 (colimit ((OpenNhds.inclusion x).op ⋙ F))
[PROOFSTEP]
rw [Category.comp_id]
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F : Presheaf C X
x y : ↑X
h : x ⤳ y
U V : (OpenNhds y)ᵒᵖ
i : U ⟶ V
⊢ F.map ((OpenNhds.inclusion y).map i.unop).op ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ F) (op { obj := V.unop.obj, property := (_ : x ∈ ↑V.unop.obj) }) =
    colimit.ι ((OpenNhds.inclusion x).op ⋙ F) (op { obj := U.unop.obj, property := (_ : x ∈ ↑U.unop.obj) })
[PROOFSTEP]
let U' : OpenNhds x := ⟨_, (specializes_iff_forall_open.mp h _ (unop U).1.2 (unop U).2 : _)⟩
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F : Presheaf C X
x y : ↑X
h : x ⤳ y
U V : (OpenNhds y)ᵒᵖ
i : U ⟶ V
U' : OpenNhds x := { obj := U.unop.obj, property := (_ : x ∈ U.unop.obj.carrier) }
⊢ F.map ((OpenNhds.inclusion y).map i.unop).op ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ F) (op { obj := V.unop.obj, property := (_ : x ∈ ↑V.unop.obj) }) =
    colimit.ι ((OpenNhds.inclusion x).op ⋙ F) (op { obj := U.unop.obj, property := (_ : x ∈ ↑U.unop.obj) })
[PROOFSTEP]
let V' : OpenNhds x := ⟨_, (specializes_iff_forall_open.mp h _ (unop V).1.2 (unop V).2 : _)⟩
[GOAL]
case refine'_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F : Presheaf C X
x y : ↑X
h : x ⤳ y
U V : (OpenNhds y)ᵒᵖ
i : U ⟶ V
U' : OpenNhds x := { obj := U.unop.obj, property := (_ : x ∈ U.unop.obj.carrier) }
V' : OpenNhds x := { obj := V.unop.obj, property := (_ : x ∈ V.unop.obj.carrier) }
⊢ F.map ((OpenNhds.inclusion y).map i.unop).op ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ F) (op { obj := V.unop.obj, property := (_ : x ∈ ↑V.unop.obj) }) =
    colimit.ι ((OpenNhds.inclusion x).op ⋙ F) (op { obj := U.unop.obj, property := (_ : x ∈ ↑U.unop.obj) })
[PROOFSTEP]
exact colimit.w ((OpenNhds.inclusion x).op ⋙ F) (show V' ⟶ U' from i.unop).op
[GOAL]
C✝ : Type u
inst✝³ : Category.{v, u} C✝
inst✝² : HasColimits C✝
X✝ Y Z : TopCat
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasColimits C
X : TopCat
F : Presheaf C X
x : ↑X
⊢ stalkSpecializes F (_ : x ⤳ x) = 𝟙 (stalk F x)
[PROOFSTEP]
ext
[GOAL]
case ih
C✝ : Type u
inst✝³ : Category.{v, u} C✝
inst✝² : HasColimits C✝
X✝ Y Z : TopCat
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasColimits C
X : TopCat
F : Presheaf C X
x : ↑X
U✝ : Opens ↑X
hxU✝ : x ∈ U✝
⊢ germ F { val := x, property := hxU✝ } ≫ stalkSpecializes F (_ : x ⤳ x) =
    germ F { val := x, property := hxU✝ } ≫ 𝟙 (stalk F x)
[PROOFSTEP]
simp
[GOAL]
C✝ : Type u
inst✝³ : Category.{v, u} C✝
inst✝² : HasColimits C✝
X✝ Y Z : TopCat
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasColimits C
X : TopCat
F : Presheaf C X
x y z : ↑X
h : x ⤳ y
h' : y ⤳ z
⊢ stalkSpecializes F h' ≫ stalkSpecializes F h = stalkSpecializes F (_ : x ⤳ z)
[PROOFSTEP]
ext
[GOAL]
case ih
C✝ : Type u
inst✝³ : Category.{v, u} C✝
inst✝² : HasColimits C✝
X✝ Y Z : TopCat
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasColimits C
X : TopCat
F : Presheaf C X
x y z : ↑X
h : x ⤳ y
h' : y ⤳ z
U✝ : Opens ↑X
hxU✝ : z ∈ U✝
⊢ germ F { val := z, property := hxU✝ } ≫ stalkSpecializes F h' ≫ stalkSpecializes F h =
    germ F { val := z, property := hxU✝ } ≫ stalkSpecializes F (_ : x ⤳ z)
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F G : Presheaf C X
f : F ⟶ G
x y : ↑X
h : x ⤳ y
⊢ stalkSpecializes F h ≫ (stalkFunctor C x).map f = (stalkFunctor C y).map f ≫ stalkSpecializes G h
[PROOFSTEP]
change (_ : colimit _ ⟶ _) = (_ : colimit _ ⟶ _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F G : Presheaf C X
f : F ⟶ G
x y : ↑X
h : x ⤳ y
⊢ stalkSpecializes F h ≫ (stalkFunctor C x).map f = (stalkFunctor C y).map f ≫ stalkSpecializes G h
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F G : Presheaf C X
f : F ⟶ G
x y : ↑X
h : x ⤳ y
j✝ : (OpenNhds y)ᵒᵖ
⊢ colimit.ι (((whiskeringLeft (OpenNhds y)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion y).op).obj F) j✝ ≫
      stalkSpecializes F h ≫ (stalkFunctor C x).map f =
    colimit.ι (((whiskeringLeft (OpenNhds y)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion y).op).obj F) j✝ ≫
      (stalkFunctor C y).map f ≫ stalkSpecializes G h
[PROOFSTEP]
delta stalkFunctor
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F G : Presheaf C X
f : F ⟶ G
x y : ↑X
h : x ⤳ y
j✝ : (OpenNhds y)ᵒᵖ
⊢ colimit.ι (((whiskeringLeft (OpenNhds y)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion y).op).obj F) j✝ ≫
      stalkSpecializes F h ≫
        ((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op ⋙ colim).map f =
    colimit.ι (((whiskeringLeft (OpenNhds y)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion y).op).obj F) j✝ ≫
      ((whiskeringLeft (OpenNhds y)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion y).op ⋙ colim).map f ≫
        stalkSpecializes G h
[PROOFSTEP]
simpa [stalkSpecializes] using by rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
F G : Presheaf C X
f : F ⟶ G
x y : ↑X
h : x ⤳ y
j✝ : (OpenNhds y)ᵒᵖ
⊢ NatTrans.app f (op j✝.unop.obj) ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ G) (op { obj := j✝.unop.obj, property := (_ : x ∈ j✝.unop.obj.carrier) }) =
    NatTrans.app f (op ((OpenNhds.inclusion y).obj j✝.unop)) ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ G) (op { obj := j✝.unop.obj, property := (_ : x ∈ j✝.unop.obj.carrier) })
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
x y : ↑X
h : x ⤳ y
⊢ stalkSpecializes (f _* F) (_ : ↑f x ⤳ ↑f y) ≫ stalkPushforward C f F x =
    stalkPushforward C f F y ≫ stalkSpecializes F h
[PROOFSTEP]
change (_ : colimit _ ⟶ _) = (_ : colimit _ ⟶ _)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
x y : ↑X
h : x ⤳ y
⊢ stalkSpecializes (f _* F) (_ : ↑f x ⤳ ↑f y) ≫ stalkPushforward C f F x =
    stalkPushforward C f F y ≫ stalkSpecializes F h
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
x y : ↑X
h : x ⤳ y
j✝ : (OpenNhds (↑f y))ᵒᵖ
⊢ colimit.ι (((whiskeringLeft (OpenNhds (↑f y))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f y)).op).obj (f _* F)) j✝ ≫
      stalkSpecializes (f _* F) (_ : ↑f x ⤳ ↑f y) ≫ stalkPushforward C f F x =
    colimit.ι (((whiskeringLeft (OpenNhds (↑f y))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f y)).op).obj (f _* F))
        j✝ ≫
      stalkPushforward C f F y ≫ stalkSpecializes F h
[PROOFSTEP]
delta stalkPushforward
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
x y : ↑X
h : x ⤳ y
j✝ : (OpenNhds (↑f y))ᵒᵖ
⊢ colimit.ι (((whiskeringLeft (OpenNhds (↑f y))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f y)).op).obj (f _* F)) j✝ ≫
      stalkSpecializes (f _* F) (_ : ↑f x ⤳ ↑f y) ≫
        colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) F) ≫
          colimit.pre (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
            (OpenNhds.map f x).op =
    colimit.ι (((whiskeringLeft (OpenNhds (↑f y))ᵒᵖ (Opens ↑Y)ᵒᵖ C).obj (OpenNhds.inclusion (↑f y)).op).obj (f _* F))
        j✝ ≫
      (colim.map (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f y).inv) F) ≫
          colimit.pre (((whiskeringLeft (OpenNhds y)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion y).op).obj F)
            (OpenNhds.map f y).op) ≫
        stalkSpecializes F h
[PROOFSTEP]
simp only [stalkSpecializes, colimit.ι_desc_assoc, colimit.ι_map_assoc, colimit.ι_pre, Category.assoc, colimit.pre_desc,
  colimit.ι_desc]
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
x y : ↑X
h : x ⤳ y
j✝ : (OpenNhds (↑f y))ᵒᵖ
⊢ NatTrans.app (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f x).inv) F)
        (op { obj := j✝.unop.obj, property := (_ : ↑f x ∈ j✝.unop.obj.carrier) }) ≫
      colimit.ι (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F)
        ((OpenNhds.map f x).op.obj (op { obj := j✝.unop.obj, property := (_ : ↑f x ∈ j✝.unop.obj.carrier) })) =
    NatTrans.app (whiskerRight (NatTrans.op (OpenNhds.inclusionMapIso f y).inv) F) j✝ ≫
      NatTrans.app
        (Cocone.whisker (OpenNhds.map f y).op
            { pt := colim.obj (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F),
              ι :=
                NatTrans.mk fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ F)
                    (op { obj := U.unop.obj, property := (_ : x ∈ U.unop.obj.carrier) }) }).ι
        j✝
[PROOFSTEP]
rfl
[GOAL]
C✝ : Type u
inst✝³ : Category.{v, u} C✝
inst✝² : HasColimits C✝
X✝ Y Z : TopCat
X : TopCat
C : Type u_1
inst✝¹ : Category.{?u.182834, u_1} C
inst✝ : HasColimits C
F : Presheaf C X
x y : ↑X
e : Inseparable x y
⊢ stalkSpecializes F (_ : nhds y ≤ nhds x) ≫ stalkSpecializes F (_ : nhds x ≤ nhds y) = 𝟙 (stalk F x)
[PROOFSTEP]
simp
[GOAL]
C✝ : Type u
inst✝³ : Category.{v, u} C✝
inst✝² : HasColimits C✝
X✝ Y Z : TopCat
X : TopCat
C : Type u_1
inst✝¹ : Category.{?u.182834, u_1} C
inst✝ : HasColimits C
F : Presheaf C X
x y : ↑X
e : Inseparable x y
⊢ stalkSpecializes F (_ : nhds x ≤ nhds y) ≫ stalkSpecializes F (_ : nhds y ≤ nhds x) = 𝟙 (stalk F y)
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimits C
X Y Z : TopCat
inst✝ : ConcreteCategory C
F : Presheaf C X
U V : Opens ↑X
x : ↑X
hxU : x ∈ U
hxV : x ∈ V
W : Opens ↑X
hxW : x ∈ W
iWU : W ⟶ U
iWV : W ⟶ V
sU : (forget C).obj (F.obj (op U))
sV : (forget C).obj (F.obj (op V))
ih : ↑(F.map iWU.op) sU = ↑(F.map iWV.op) sV
⊢ ↑(germ F { val := x, property := hxU }) sU = ↑(germ F { val := x, property := hxV }) sV
[PROOFSTEP]
erw [← F.germ_res iWU ⟨x, hxW⟩, ← F.germ_res iWV ⟨x, hxW⟩, comp_apply, comp_apply, ih]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
x : ↑X
t : (forget C).obj (stalk F x)
⊢ ∃ U m s, ↑(germ F { val := x, property := m }) s = t
[PROOFSTEP]
obtain ⟨U, s, e⟩ := Types.jointly_surjective.{v, v} _ (isColimitOfPreserves (forget C) (colimit.isColimit _)) t
[GOAL]
case intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
x : ↑X
t : (forget C).obj (stalk F x)
U : (OpenNhds x)ᵒᵖ
s : (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F ⋙ forget C).obj U
e :
  NatTrans.app
      ((forget C).mapCocone
          (colimit.cocone (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F))).ι
      U s =
    t
⊢ ∃ U m s, ↑(germ F { val := x, property := m }) s = t
[PROOFSTEP]
revert s e
[GOAL]
case intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
x : ↑X
t : (forget C).obj (stalk F x)
U : (OpenNhds x)ᵒᵖ
⊢ ∀ (s : (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F ⋙ forget C).obj U),
    NatTrans.app
          ((forget C).mapCocone
              (colimit.cocone (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F))).ι
          U s =
        t →
      ∃ U m s, ↑(germ F { val := x, property := m }) s = t
[PROOFSTEP]
induction U with
| h U => ?_
[GOAL]
case intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
x : ↑X
t : (forget C).obj (stalk F x)
U : (OpenNhds x)ᵒᵖ
⊢ ∀ (s : (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F ⋙ forget C).obj U),
    NatTrans.app
          ((forget C).mapCocone
              (colimit.cocone (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F))).ι
          U s =
        t →
      ∃ U m s, ↑(germ F { val := x, property := m }) s = t
[PROOFSTEP]
induction U with
| h U => ?_
[GOAL]
case intro.intro.h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
x : ↑X
t : (forget C).obj (stalk F x)
U : OpenNhds x
⊢ ∀ (s : (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F ⋙ forget C).obj (op U)),
    NatTrans.app
          ((forget C).mapCocone
              (colimit.cocone (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F))).ι
          (op U) s =
        t →
      ∃ U m s, ↑(germ F { val := x, property := m }) s = t
[PROOFSTEP]
cases' U with V m
[GOAL]
case intro.intro.h.mk
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
x : ↑X
t : (forget C).obj (stalk F x)
V : Opens ↑X
m : x ∈ V
⊢ ∀
    (s :
      (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F ⋙ forget C).obj
        (op { obj := V, property := m })),
    NatTrans.app
          ((forget C).mapCocone
              (colimit.cocone (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F))).ι
          (op { obj := V, property := m }) s =
        t →
      ∃ U m s, ↑(germ F { val := x, property := m }) s = t
[PROOFSTEP]
intro s e
[GOAL]
case intro.intro.h.mk
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
x : ↑X
t : (forget C).obj (stalk F x)
V : Opens ↑X
m : x ∈ V
s :
  (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F ⋙ forget C).obj
    (op { obj := V, property := m })
e :
  NatTrans.app
      ((forget C).mapCocone
          (colimit.cocone (((whiskeringLeft (OpenNhds x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (OpenNhds.inclusion x).op).obj F))).ι
      (op { obj := V, property := m }) s =
    t
⊢ ∃ U m s, ↑(germ F { val := x, property := m }) s = t
[PROOFSTEP]
exact ⟨V, m, s, e⟩
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
U V : Opens ↑X
x : ↑X
mU : x ∈ U
mV : x ∈ V
s : (forget C).obj (F.obj (op U))
t : (forget C).obj (F.obj (op V))
h : ↑(germ F { val := x, property := mU }) s = ↑(germ F { val := x, property := mV }) t
⊢ ∃ W _m iU iV, ↑(F.map iU.op) s = ↑(F.map iV.op) t
[PROOFSTEP]
obtain ⟨W, iU, iV, e⟩ :=
  (Types.FilteredColimit.isColimit_eq_iff.{v, v} _
        (isColimitOfPreserves _ (colimit.isColimit ((OpenNhds.inclusion x).op ⋙ F)))).mp
    h
[GOAL]
case intro.intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F : Presheaf C X
U V : Opens ↑X
x : ↑X
mU : x ∈ U
mV : x ∈ V
s : (forget C).obj (F.obj (op U))
t : (forget C).obj (F.obj (op V))
h : ↑(germ F { val := x, property := mU }) s = ↑(germ F { val := x, property := mV }) t
W : (OpenNhds x)ᵒᵖ
iU : op { obj := U, property := (_ : ↑{ val := x, property := mU } ∈ U) } ⟶ W
iV : op { obj := V, property := (_ : ↑{ val := x, property := mV } ∈ V) } ⟶ W
e : (((OpenNhds.inclusion x).op ⋙ F) ⋙ forget C).map iU s = (((OpenNhds.inclusion x).op ⋙ F) ⋙ forget C).map iV t
⊢ ∃ W _m iU iV, ↑(F.map iU.op) s = ↑(F.map iV.op) t
[PROOFSTEP]
exact ⟨(unop W).1, (unop W).2, iU.unop, iV.unop, e⟩
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F G : Presheaf C X
f : F ⟶ G
h : ∀ (U : Opens ↑X), Function.Injective ↑(NatTrans.app f (op U))
x : ↑X
s t : (forget C).obj ((stalkFunctor C x).obj F)
hst : ↑((stalkFunctor C x).map f) s = ↑((stalkFunctor C x).map f) t
⊢ s = t
[PROOFSTEP]
rcases germ_exist F x s with ⟨U₁, hxU₁, s, rfl⟩
[GOAL]
case intro.intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F G : Presheaf C X
f : F ⟶ G
h : ∀ (U : Opens ↑X), Function.Injective ↑(NatTrans.app f (op U))
x : ↑X
t : (forget C).obj ((stalkFunctor C x).obj F)
U₁ : Opens ↑X
hxU₁ : x ∈ U₁
s : (forget C).obj (F.obj (op U₁))
hst : ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₁ }) s) = ↑((stalkFunctor C x).map f) t
⊢ ↑(germ F { val := x, property := hxU₁ }) s = t
[PROOFSTEP]
rcases germ_exist F x t with ⟨U₂, hxU₂, t, rfl⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F G : Presheaf C X
f : F ⟶ G
h : ∀ (U : Opens ↑X), Function.Injective ↑(NatTrans.app f (op U))
x : ↑X
U₁ : Opens ↑X
hxU₁ : x ∈ U₁
s : (forget C).obj (F.obj (op U₁))
U₂ : Opens ↑X
hxU₂ : x ∈ U₂
t : (forget C).obj (F.obj (op U₂))
hst :
  ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₁ }) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
⊢ ↑(germ F { val := x, property := hxU₁ }) s = ↑(germ F { val := x, property := hxU₂ }) t
[PROOFSTEP]
erw [stalkFunctor_map_germ_apply _ ⟨x, _⟩] at hst
[GOAL]
case intro.intro.intro.intro.intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F G : Presheaf C X
f : F ⟶ G
h : ∀ (U : Opens ↑X), Function.Injective ↑(NatTrans.app f (op U))
x : ↑X
U₁ : Opens ↑X
hxU₁ : x ∈ U₁
s : (forget C).obj (F.obj (op U₁))
U₂ : Opens ↑X
hxU₂ : x ∈ U₂
t : (forget C).obj (F.obj (op U₂))
hst✝ :
  ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₁ }) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
⊢ ↑(germ F { val := x, property := hxU₁ }) s = ↑(germ F { val := x, property := hxU₂ }) t
[PROOFSTEP]
erw [stalkFunctor_map_germ_apply _ ⟨x, _⟩] at hst
[GOAL]
case intro.intro.intro.intro.intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F G : Presheaf C X
f : F ⟶ G
h : ∀ (U : Opens ↑X), Function.Injective ↑(NatTrans.app f (op U))
x : ↑X
U₁ : Opens ↑X
hxU₁ : x ∈ U₁
s : (forget C).obj (F.obj (op U₁))
U₂ : Opens ↑X
hxU₂ : x ∈ U₂
t : (forget C).obj (F.obj (op U₂))
hst✝¹ :
  ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₁ }) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst✝ :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₂ }).op ⋙ G)
          (op { obj := U₂, property := (_ : ↑{ val := x, property := hxU₂ } ∈ U₂) }))
      (↑(NatTrans.app f (op U₂)) t)
⊢ ↑(germ F { val := x, property := hxU₁ }) s = ↑(germ F { val := x, property := hxU₂ }) t
[PROOFSTEP]
obtain ⟨W, hxW, iWU₁, iWU₂, heq⟩ := G.germ_eq x hxU₁ hxU₂ _ _ hst
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F G : Presheaf C X
f : F ⟶ G
h : ∀ (U : Opens ↑X), Function.Injective ↑(NatTrans.app f (op U))
x : ↑X
U₁ : Opens ↑X
hxU₁ : x ∈ U₁
s : (forget C).obj (F.obj (op U₁))
U₂ : Opens ↑X
hxU₂ : x ∈ U₂
t : (forget C).obj (F.obj (op U₂))
hst✝¹ :
  ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₁ }) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst✝ :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₂ }).op ⋙ G)
          (op { obj := U₂, property := (_ : ↑{ val := x, property := hxU₂ } ∈ U₂) }))
      (↑(NatTrans.app f (op U₂)) t)
W : Opens ↑X
hxW : x ∈ W
iWU₁ : W ⟶ U₁
iWU₂ : W ⟶ U₂
heq : ↑(G.map iWU₁.op) (↑(NatTrans.app f (op U₁)) s) = ↑(G.map iWU₂.op) (↑(NatTrans.app f (op U₂)) t)
⊢ ↑(germ F { val := x, property := hxU₁ }) s = ↑(germ F { val := x, property := hxU₂ }) t
[PROOFSTEP]
rw [← comp_apply, ← comp_apply, ← f.naturality, ← f.naturality, comp_apply, comp_apply] at heq
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F G : Presheaf C X
f : F ⟶ G
h : ∀ (U : Opens ↑X), Function.Injective ↑(NatTrans.app f (op U))
x : ↑X
U₁ : Opens ↑X
hxU₁ : x ∈ U₁
s : (forget C).obj (F.obj (op U₁))
U₂ : Opens ↑X
hxU₂ : x ∈ U₂
t : (forget C).obj (F.obj (op U₂))
hst✝¹ :
  ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₁ }) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst✝ :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₂ }).op ⋙ G)
          (op { obj := U₂, property := (_ : ↑{ val := x, property := hxU₂ } ∈ U₂) }))
      (↑(NatTrans.app f (op U₂)) t)
W : Opens ↑X
hxW : x ∈ W
iWU₁ : W ⟶ U₁
iWU₂ : W ⟶ U₂
heq : ↑(NatTrans.app f (op W)) (↑(F.map iWU₁.op) s) = ↑(NatTrans.app f (op W)) (↑(F.map iWU₂.op) t)
⊢ ↑(germ F { val := x, property := hxU₁ }) s = ↑(germ F { val := x, property := hxU₂ }) t
[PROOFSTEP]
replace heq := h W heq
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F G : Presheaf C X
f : F ⟶ G
h : ∀ (U : Opens ↑X), Function.Injective ↑(NatTrans.app f (op U))
x : ↑X
U₁ : Opens ↑X
hxU₁ : x ∈ U₁
s : (forget C).obj (F.obj (op U₁))
U₂ : Opens ↑X
hxU₂ : x ∈ U₂
t : (forget C).obj (F.obj (op U₂))
hst✝¹ :
  ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₁ }) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst✝ :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₂ }).op ⋙ G)
          (op { obj := U₂, property := (_ : ↑{ val := x, property := hxU₂ } ∈ U₂) }))
      (↑(NatTrans.app f (op U₂)) t)
W : Opens ↑X
hxW : x ∈ W
iWU₁ : W ⟶ U₁
iWU₂ : W ⟶ U₂
heq : ↑(F.map iWU₁.op) s = ↑(F.map iWU₂.op) t
⊢ ↑(germ F { val := x, property := hxU₁ }) s = ↑(germ F { val := x, property := hxU₂ }) t
[PROOFSTEP]
convert congr_arg (F.germ ⟨x, hxW⟩) heq using 1
[GOAL]
case h.e'_2.h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F G : Presheaf C X
f : F ⟶ G
h : ∀ (U : Opens ↑X), Function.Injective ↑(NatTrans.app f (op U))
x : ↑X
U₁ : Opens ↑X
hxU₁ : x ∈ U₁
s : (forget C).obj (F.obj (op U₁))
U₂ : Opens ↑X
hxU₂ : x ∈ U₂
t : (forget C).obj (F.obj (op U₂))
hst✝¹ :
  ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₁ }) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst✝ :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₂ }).op ⋙ G)
          (op { obj := U₂, property := (_ : ↑{ val := x, property := hxU₂ } ∈ U₂) }))
      (↑(NatTrans.app f (op U₂)) t)
W : Opens ↑X
hxW : x ∈ W
iWU₁ : W ⟶ U₁
iWU₂ : W ⟶ U₂
heq : ↑(F.map iWU₁.op) s = ↑(F.map iWU₂.op) t
e_1✝ : (forget C).obj ((stalkFunctor C x).obj F) = (forget C).obj (stalk F ↑{ val := x, property := hxW })
⊢ ↑(germ F { val := x, property := hxU₁ }) s = ↑(germ F { val := x, property := hxW }) (↑(F.map iWU₁.op) s)
case h.e'_3.h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimits C
X Y Z : TopCat
inst✝¹ : ConcreteCategory C
inst✝ : PreservesFilteredColimits (forget C)
F G : Presheaf C X
f : F ⟶ G
h : ∀ (U : Opens ↑X), Function.Injective ↑(NatTrans.app f (op U))
x : ↑X
U₁ : Opens ↑X
hxU₁ : x ∈ U₁
s : (forget C).obj (F.obj (op U₁))
U₂ : Opens ↑X
hxU₂ : x ∈ U₂
t : (forget C).obj (F.obj (op U₂))
hst✝¹ :
  ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₁ }) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst✝ :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑((stalkFunctor C x).map f) (↑(germ F { val := x, property := hxU₂ }) t)
hst :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₁ }).op ⋙ G)
          (op { obj := U₁, property := (_ : ↑{ val := x, property := hxU₁ } ∈ U₁) }))
      (↑(NatTrans.app f (op U₁)) s) =
    ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := x, property := hxU₂ }).op ⋙ G)
          (op { obj := U₂, property := (_ : ↑{ val := x, property := hxU₂ } ∈ U₂) }))
      (↑(NatTrans.app f (op U₂)) t)
W : Opens ↑X
hxW : x ∈ W
iWU₁ : W ⟶ U₁
iWU₂ : W ⟶ U₂
heq : ↑(F.map iWU₁.op) s = ↑(F.map iWU₂.op) t
e_1✝ : (forget C).obj ((stalkFunctor C x).obj F) = (forget C).obj (stalk F ↑{ val := x, property := hxW })
⊢ ↑(germ F { val := x, property := hxU₂ }) t = ↑(germ F { val := x, property := hxW }) (↑(F.map iWU₂.op) t)
[PROOFSTEP]
exacts [(F.germ_res_apply iWU₁ ⟨x, hxW⟩ s).symm, (F.germ_res_apply iWU₂ ⟨x, hxW⟩ t).symm]
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F : Sheaf C X
U : Opens ↑X
s t : (forget C).obj (F.val.obj (op U))
h : ∀ (x : { x // x ∈ U }), ↑(germ (Sheaf.presheaf F) x) s = ↑(germ (Sheaf.presheaf F) x) t
⊢ s = t
[PROOFSTEP]
choose V m i₁ i₂ heq using fun x : U =>
  F.presheaf.germ_eq x.1 x.2 x.2 s t
    (h x)
      -- Since `F` is a sheaf, we can prove the equality locally, if we can show that these
        -- neighborhoods form a cover of `U`.
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F : Sheaf C X
U : Opens ↑X
s t : (forget C).obj (F.val.obj (op U))
h : ∀ (x : { x // x ∈ U }), ↑(germ (Sheaf.presheaf F) x) s = ↑(germ (Sheaf.presheaf F) x) t
V : { x // x ∈ U } → Opens ↑X
m : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
i₁ i₂ : (x : { x // x ∈ U }) → V x ⟶ U
heq : ∀ (x : { x // x ∈ U }), ↑((Sheaf.presheaf F).map (i₁ x).op) s = ↑((Sheaf.presheaf F).map (i₂ x).op) t
⊢ s = t
[PROOFSTEP]
apply F.eq_of_locally_eq' V U i₁
[GOAL]
case hcover
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F : Sheaf C X
U : Opens ↑X
s t : (forget C).obj (F.val.obj (op U))
h : ∀ (x : { x // x ∈ U }), ↑(germ (Sheaf.presheaf F) x) s = ↑(germ (Sheaf.presheaf F) x) t
V : { x // x ∈ U } → Opens ↑X
m : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
i₁ i₂ : (x : { x // x ∈ U }) → V x ⟶ U
heq : ∀ (x : { x // x ∈ U }), ↑((Sheaf.presheaf F).map (i₁ x).op) s = ↑((Sheaf.presheaf F).map (i₂ x).op) t
⊢ U ≤ iSup V
[PROOFSTEP]
intro x hxU
[GOAL]
case hcover
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F : Sheaf C X
U : Opens ↑X
s t : (forget C).obj (F.val.obj (op U))
h : ∀ (x : { x // x ∈ U }), ↑(germ (Sheaf.presheaf F) x) s = ↑(germ (Sheaf.presheaf F) x) t
V : { x // x ∈ U } → Opens ↑X
m : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
i₁ i₂ : (x : { x // x ∈ U }) → V x ⟶ U
heq : ∀ (x : { x // x ∈ U }), ↑((Sheaf.presheaf F).map (i₁ x).op) s = ↑((Sheaf.presheaf F).map (i₂ x).op) t
x : ↑X
hxU : x ∈ ↑U
⊢ x ∈ ↑(iSup V)
[PROOFSTEP]
erw [Opens.mem_iSup]
[GOAL]
case hcover
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F : Sheaf C X
U : Opens ↑X
s t : (forget C).obj (F.val.obj (op U))
h : ∀ (x : { x // x ∈ U }), ↑(germ (Sheaf.presheaf F) x) s = ↑(germ (Sheaf.presheaf F) x) t
V : { x // x ∈ U } → Opens ↑X
m : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
i₁ i₂ : (x : { x // x ∈ U }) → V x ⟶ U
heq : ∀ (x : { x // x ∈ U }), ↑((Sheaf.presheaf F).map (i₁ x).op) s = ↑((Sheaf.presheaf F).map (i₂ x).op) t
x : ↑X
hxU : x ∈ ↑U
⊢ ∃ i, x ∈ V i
[PROOFSTEP]
exact ⟨⟨x, hxU⟩, m ⟨x, hxU⟩⟩
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F : Sheaf C X
U : Opens ↑X
s t : (forget C).obj (F.val.obj (op U))
h : ∀ (x : { x // x ∈ U }), ↑(germ (Sheaf.presheaf F) x) s = ↑(germ (Sheaf.presheaf F) x) t
V : { x // x ∈ U } → Opens ↑X
m : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
i₁ i₂ : (x : { x // x ∈ U }) → V x ⟶ U
heq : ∀ (x : { x // x ∈ U }), ↑((Sheaf.presheaf F).map (i₁ x).op) s = ↑((Sheaf.presheaf F).map (i₂ x).op) t
⊢ ∀ (i : { x // x ∈ U }), ↑(F.val.map (i₁ i).op) s = ↑(F.val.map (i₁ i).op) t
[PROOFSTEP]
intro x
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F : Sheaf C X
U : Opens ↑X
s t : (forget C).obj (F.val.obj (op U))
h : ∀ (x : { x // x ∈ U }), ↑(germ (Sheaf.presheaf F) x) s = ↑(germ (Sheaf.presheaf F) x) t
V : { x // x ∈ U } → Opens ↑X
m : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
i₁ i₂ : (x : { x // x ∈ U }) → V x ⟶ U
heq : ∀ (x : { x // x ∈ U }), ↑((Sheaf.presheaf F).map (i₁ x).op) s = ↑((Sheaf.presheaf F).map (i₂ x).op) t
x : { x // x ∈ U }
⊢ ↑(F.val.map (i₁ x).op) s = ↑(F.val.map (i₁ x).op) t
[PROOFSTEP]
rw [heq, Subsingleton.elim (i₁ x) (i₂ x)]
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F : Sheaf C X
G : Presheaf C X
f : F.val ⟶ G
U : Opens ↑X
h : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f)
s t : (forget C).obj (F.val.obj (op U))
hst : ↑(NatTrans.app f (op U)) s = ↑(NatTrans.app f (op U)) t
x : { x // x ∈ U }
⊢ ↑((stalkFunctor C ↑x).map f) (↑(germ (Sheaf.presheaf F) x) s) =
    ↑((stalkFunctor C ↑x).map f) (↑(germ (Sheaf.presheaf F) x) t)
[PROOFSTEP]
erw [stalkFunctor_map_germ_apply, stalkFunctor_map_germ_apply, hst]
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
⊢ Function.Surjective ↑(NatTrans.app f.val (op U))
[PROOFSTEP]
intro t
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
⊢ ∃ a, ↑(NatTrans.app f.val (op U)) a = t
[PROOFSTEP]
choose V mV iVU sf heq using hsurj t
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
⊢ ∃ a, ↑(NatTrans.app f.val (op U)) a = t
[PROOFSTEP]
have V_cover : U ≤ iSup V := by
  intro x hxU
  erw [Opens.mem_iSup]
  exact ⟨⟨x, hxU⟩, mV ⟨x, hxU⟩⟩
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
⊢ U ≤ iSup V
[PROOFSTEP]
intro x hxU
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
x : ↑X
hxU : x ∈ ↑U
⊢ x ∈ ↑(iSup V)
[PROOFSTEP]
erw [Opens.mem_iSup]
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
x : ↑X
hxU : x ∈ ↑U
⊢ ∃ i, x ∈ V i
[PROOFSTEP]
exact ⟨⟨x, hxU⟩, mV ⟨x, hxU⟩⟩
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
⊢ ∃ a, ↑(NatTrans.app f.val (op U)) a = t
[PROOFSTEP]
suffices IsCompatible F.val V sf by
  -- Since `F` is a sheaf, we can glue all the local preimages together to get a global preimage.
  obtain ⟨s, s_spec, -⟩ := F.existsUnique_gluing' V U iVU V_cover sf this
  · use s
    apply G.eq_of_locally_eq' V U iVU V_cover
    intro x
    rw [← comp_apply, ← f.1.naturality, comp_apply, s_spec, heq]
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
⊢ ∃ a, ↑(NatTrans.app f.val (op U)) a = t
[PROOFSTEP]
obtain ⟨s, s_spec, -⟩ := F.existsUnique_gluing' V U iVU V_cover sf this
[GOAL]
case intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj (op U))
s_spec : ∀ (i : { x // x ∈ U }), ↑(F.val.map (iVU i).op) s = sf i
⊢ ∃ a, ↑(NatTrans.app f.val (op U)) a = t
[PROOFSTEP]
use s
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj (op U))
s_spec : ∀ (i : { x // x ∈ U }), ↑(F.val.map (iVU i).op) s = sf i
⊢ ↑(NatTrans.app f.val (op U)) s = t
[PROOFSTEP]
apply G.eq_of_locally_eq' V U iVU V_cover
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj (op U))
s_spec : ∀ (i : { x // x ∈ U }), ↑(F.val.map (iVU i).op) s = sf i
⊢ ∀ (i : { x // x ∈ U }), ↑(G.val.map (iVU i).op) (↑(NatTrans.app f.val (op U)) s) = ↑(G.val.map (iVU i).op) t
[PROOFSTEP]
intro x
[GOAL]
case h.h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
this : IsCompatible F.val V sf
s : (forget C).obj (F.val.obj (op U))
s_spec : ∀ (i : { x // x ∈ U }), ↑(F.val.map (iVU i).op) s = sf i
x : { x // x ∈ U }
⊢ ↑(G.val.map (iVU x).op) (↑(NatTrans.app f.val (op U)) s) = ↑(G.val.map (iVU x).op) t
[PROOFSTEP]
rw [← comp_apply, ← f.1.naturality, comp_apply, s_spec, heq]
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
⊢ IsCompatible F.val V sf
[PROOFSTEP]
intro x y
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : { x // x ∈ U }
⊢ ↑(F.val.map (Opens.infLELeft (V x) (V y)).op) (sf x) = ↑(F.val.map (Opens.infLERight (V x) (V y)).op) (sf y)
[PROOFSTEP]
apply section_ext
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : { x // x ∈ U }
⊢ ∀ (x_1 : { x_1 // x_1 ∈ V x ⊓ V y }),
    ↑(germ (Sheaf.presheaf F) x_1) (↑(F.val.map (Opens.infLELeft (V x) (V y)).op) (sf x)) =
      ↑(germ (Sheaf.presheaf F) x_1) (↑(F.val.map (Opens.infLERight (V x) (V y)).op) (sf y))
[PROOFSTEP]
intro z
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : { x // x ∈ U }
z : { x_1 // x_1 ∈ V x ⊓ V y }
⊢ ↑(germ (Sheaf.presheaf F) z) (↑(F.val.map (Opens.infLELeft (V x) (V y)).op) (sf x)) =
    ↑(germ (Sheaf.presheaf F) z) (↑(F.val.map (Opens.infLERight (V x) (V y)).op) (sf y))
[PROOFSTEP]
apply hinj ⟨z, (iVU x).le ((inf_le_left : V x ⊓ V y ≤ V x) z.2)⟩
[GOAL]
case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : { x // x ∈ U }
z : { x_1 // x_1 ∈ V x ⊓ V y }
⊢ ↑((stalkFunctor C ↑{ val := ↑z, property := (_ : ↑z ∈ ↑U) }).map f.val)
      (↑(germ (Sheaf.presheaf F) z) (↑(F.val.map (Opens.infLELeft (V x) (V y)).op) (sf x))) =
    ↑((stalkFunctor C ↑{ val := ↑z, property := (_ : ↑z ∈ ↑U) }).map f.val)
      (↑(germ (Sheaf.presheaf F) z) (↑(F.val.map (Opens.infLERight (V x) (V y)).op) (sf y)))
[PROOFSTEP]
dsimp only
[GOAL]
case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : { x // x ∈ U }
z : { x_1 // x_1 ∈ V x ⊓ V y }
⊢ ↑((stalkFunctor C ↑z).map f.val)
      (↑(germ (Sheaf.presheaf F) z) (↑(F.val.map (Opens.infLELeft (V x) (V y)).op) (sf x))) =
    ↑((stalkFunctor C ↑z).map f.val)
      (↑(germ (Sheaf.presheaf F) z) (↑(F.val.map (Opens.infLERight (V x) (V y)).op) (sf y)))
[PROOFSTEP]
erw [stalkFunctor_map_germ_apply, stalkFunctor_map_germ_apply]
[GOAL]
case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : { x // x ∈ U }
z : { x_1 // x_1 ∈ V x ⊓ V y }
⊢ ↑(colimit.ι ((OpenNhds.inclusion ↑z).op ⋙ G.val) (op { obj := V x ⊓ V y, property := (_ : ↑z ∈ V x ⊓ V y) }))
      (↑(NatTrans.app f.val (op (V x ⊓ V y))) (↑(F.val.map (Opens.infLELeft (V x) (V y)).op) (sf x))) =
    ↑(colimit.ι ((OpenNhds.inclusion ↑z).op ⋙ G.val) (op { obj := V x ⊓ V y, property := (_ : ↑z ∈ V x ⊓ V y) }))
      (↑(NatTrans.app f.val (op (V x ⊓ V y))) (↑(F.val.map (Opens.infLERight (V x) (V y)).op) (sf y)))
[PROOFSTEP]
simp_rw [← comp_apply, f.1.naturality, comp_apply, heq, ← comp_apply, ← G.1.map_comp]
[GOAL]
case h.a
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
hinj : ∀ (x : { x // x ∈ U }), Function.Injective ↑((stalkFunctor C ↑x).map f.val)
hsurj :
  ∀ (t : (forget C).obj (G.val.obj (op U))) (x : { x // x ∈ U }),
    ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
t : (forget C).obj (G.val.obj (op U))
V : { x // x ∈ U } → Opens ↑X
mV : ∀ (x : { x // x ∈ U }), ↑x ∈ V x
iVU : (x : { x // x ∈ U }) → V x ⟶ U
sf : (x : { x // x ∈ U }) → (forget C).obj (F.val.obj (op (V x)))
heq : ∀ (x : { x // x ∈ U }), ↑(NatTrans.app f.val (op (V x))) (sf x) = ↑(G.val.map (iVU x).op) t
V_cover : U ≤ iSup V
x y : { x // x ∈ U }
z : { x_1 // x_1 ∈ V x ⊓ V y }
⊢ ↑(colimit.ι ((OpenNhds.inclusion ↑z).op ⋙ G.val) (op { obj := V x ⊓ V y, property := (_ : ↑z ∈ V x ⊓ V y) }))
      (↑(G.val.map ((iVU x).op ≫ (Opens.infLELeft (V x) (V y)).op)) t) =
    ↑(colimit.ι ((OpenNhds.inclusion ↑z).op ⋙ G.val) (op { obj := V x ⊓ V y, property := (_ : ↑z ∈ V x ⊓ V y) }))
      (↑(G.val.map ((iVU y).op ≫ (Opens.infLERight (V x) (V y)).op)) t)
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
h : ∀ (x : { x // x ∈ U }), Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
⊢ Function.Surjective ↑(NatTrans.app f.val (op U))
[PROOFSTEP]
refine'
  app_surjective_of_injective_of_locally_surjective f U (fun x => (h x).1) fun t x =>
    _
      -- Now we need to prove our initial claim: That we can find preimages of `t` locally.
        -- Since `f` is surjective on stalks, we can find a preimage `s₀` of the germ of `t` at `x`
[GOAL]
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
h : ∀ (x : { x // x ∈ U }), Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
t : (forget C).obj (G.val.obj (op U))
x : { x // x ∈ U }
⊢ ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
[PROOFSTEP]
obtain ⟨s₀, hs₀⟩ :=
  (h x).2
    (G.presheaf.germ x t)
      -- ... and this preimage must come from some section `s₁` defined on some open neighborhood `V₁`
[GOAL]
case intro
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
h : ∀ (x : { x // x ∈ U }), Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
t : (forget C).obj (G.val.obj (op U))
x : { x // x ∈ U }
s₀ : (forget C).obj ((stalkFunctor C ↑x).obj F.val)
hs₀ : ↑((stalkFunctor C ↑x).map f.val) s₀ = ↑(germ (Sheaf.presheaf G) x) t
⊢ ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
[PROOFSTEP]
obtain ⟨V₁, hxV₁, s₁, hs₁⟩ := F.presheaf.germ_exist x.1 s₀
[GOAL]
case intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
h : ∀ (x : { x // x ∈ U }), Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
t : (forget C).obj (G.val.obj (op U))
x : { x // x ∈ U }
s₀ : (forget C).obj ((stalkFunctor C ↑x).obj F.val)
hs₀ : ↑((stalkFunctor C ↑x).map f.val) s₀ = ↑(germ (Sheaf.presheaf G) x) t
V₁ : Opens ↑X
hxV₁ : ↑x ∈ V₁
s₁ : (forget C).obj ((Sheaf.presheaf F).obj (op V₁))
hs₁ : ↑(germ (Sheaf.presheaf F) { val := ↑x, property := hxV₁ }) s₁ = s₀
⊢ ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
[PROOFSTEP]
subst hs₁
[GOAL]
case intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
h : ∀ (x : { x // x ∈ U }), Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
t : (forget C).obj (G.val.obj (op U))
x : { x // x ∈ U }
V₁ : Opens ↑X
hxV₁ : ↑x ∈ V₁
s₁ : (forget C).obj ((Sheaf.presheaf F).obj (op V₁))
hs₀ :
  ↑((stalkFunctor C ↑x).map f.val) (↑(germ (Sheaf.presheaf F) { val := ↑x, property := hxV₁ }) s₁) =
    ↑(germ (Sheaf.presheaf G) x) t
⊢ ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
[PROOFSTEP]
rename' hs₀ => hs₁
[GOAL]
case intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
h : ∀ (x : { x // x ∈ U }), Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
t : (forget C).obj (G.val.obj (op U))
x : { x // x ∈ U }
V₁ : Opens ↑X
hxV₁ : ↑x ∈ V₁
s₁ : (forget C).obj ((Sheaf.presheaf F).obj (op V₁))
hs₁ :
  ↑((stalkFunctor C ↑x).map f.val) (↑(germ (Sheaf.presheaf F) { val := ↑x, property := hxV₁ }) s₁) =
    ↑(germ (Sheaf.presheaf G) x) t
⊢ ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
[PROOFSTEP]
erw [stalkFunctor_map_germ_apply V₁ ⟨x.1, hxV₁⟩ f.1 s₁] at hs₁
[GOAL]
case intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
h : ∀ (x : { x // x ∈ U }), Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
t : (forget C).obj (G.val.obj (op U))
x : { x // x ∈ U }
V₁ : Opens ↑X
hxV₁ : ↑x ∈ V₁
s₁ : (forget C).obj ((Sheaf.presheaf F).obj (op V₁))
hs₁ :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := ↑x, property := hxV₁ }).op ⋙ G.val)
          (op { obj := V₁, property := (_ : ↑{ val := ↑x, property := hxV₁ } ∈ V₁) }))
      (↑(NatTrans.app f.val (op V₁)) s₁) =
    ↑(germ (Sheaf.presheaf G) x) t
⊢ ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
[PROOFSTEP]
obtain ⟨V₂, hxV₂, iV₂V₁, iV₂U, heq⟩ := G.presheaf.germ_eq x.1 hxV₁ x.2 _ _ hs₁
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.intro
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
h : ∀ (x : { x // x ∈ U }), Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
t : (forget C).obj (G.val.obj (op U))
x : { x // x ∈ U }
V₁ : Opens ↑X
hxV₁ : ↑x ∈ V₁
s₁ : (forget C).obj ((Sheaf.presheaf F).obj (op V₁))
hs₁ :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := ↑x, property := hxV₁ }).op ⋙ G.val)
          (op { obj := V₁, property := (_ : ↑{ val := ↑x, property := hxV₁ } ∈ V₁) }))
      (↑(NatTrans.app f.val (op V₁)) s₁) =
    ↑(germ (Sheaf.presheaf G) x) t
V₂ : Opens ↑X
hxV₂ : ↑x ∈ V₂
iV₂V₁ : V₂ ⟶ V₁
iV₂U : V₂ ⟶ U
heq : ↑((Sheaf.presheaf G).map iV₂V₁.op) (↑(NatTrans.app f.val (op V₁)) s₁) = ↑((Sheaf.presheaf G).map iV₂U.op) t
⊢ ∃ V x iVU s, ↑(NatTrans.app f.val (op V)) s = ↑(G.val.map iVU.op) t
[PROOFSTEP]
use V₂, hxV₂, iV₂U, F.1.map iV₂V₁.op s₁
[GOAL]
case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasColimits C
X Y Z : TopCat
inst✝⁴ : ConcreteCategory C
inst✝³ : PreservesFilteredColimits (forget C)
inst✝² : HasLimits C
inst✝¹ : PreservesLimits (forget C)
inst✝ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
h : ∀ (x : { x // x ∈ U }), Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
t : (forget C).obj (G.val.obj (op U))
x : { x // x ∈ U }
V₁ : Opens ↑X
hxV₁ : ↑x ∈ V₁
s₁ : (forget C).obj ((Sheaf.presheaf F).obj (op V₁))
hs₁ :
  ↑(colimit.ι ((OpenNhds.inclusion ↑{ val := ↑x, property := hxV₁ }).op ⋙ G.val)
          (op { obj := V₁, property := (_ : ↑{ val := ↑x, property := hxV₁ } ∈ V₁) }))
      (↑(NatTrans.app f.val (op V₁)) s₁) =
    ↑(germ (Sheaf.presheaf G) x) t
V₂ : Opens ↑X
hxV₂ : ↑x ∈ V₂
iV₂V₁ : V₂ ⟶ V₁
iV₂U : V₂ ⟶ U
heq : ↑((Sheaf.presheaf G).map iV₂V₁.op) (↑(NatTrans.app f.val (op V₁)) s₁) = ↑((Sheaf.presheaf G).map iV₂U.op) t
⊢ ↑(NatTrans.app f.val (op V₂)) (↑(F.val.map iV₂V₁.op) s₁) = ↑(G.val.map iV₂U.op) t
[PROOFSTEP]
rw [← comp_apply, f.1.naturality, comp_apply, heq]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
inst✝ : ∀ (x : { x // x ∈ U }), IsIso ((stalkFunctor C ↑x).map f.val)
⊢ IsIso (NatTrans.app f.val (op U))
[PROOFSTEP]
suffices IsIso ((forget C).map (f.1.app (op U))) by exact isIso_of_reflects_iso (f.1.app (op U)) (forget C)
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
inst✝ : ∀ (x : { x // x ∈ U }), IsIso ((stalkFunctor C ↑x).map f.val)
this : IsIso ((forget C).map (NatTrans.app f.val (op U)))
⊢ IsIso (NatTrans.app f.val (op U))
[PROOFSTEP]
exact isIso_of_reflects_iso (f.1.app (op U)) (forget C)
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
inst✝ : ∀ (x : { x // x ∈ U }), IsIso ((stalkFunctor C ↑x).map f.val)
⊢ IsIso ((forget C).map (NatTrans.app f.val (op U)))
[PROOFSTEP]
rw [isIso_iff_bijective]
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
inst✝ : ∀ (x : { x // x ∈ U }), IsIso ((stalkFunctor C ↑x).map f.val)
⊢ Function.Bijective ((forget C).map (NatTrans.app f.val (op U)))
[PROOFSTEP]
apply app_bijective_of_stalkFunctor_map_bijective
[GOAL]
case h
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
inst✝ : ∀ (x : { x // x ∈ U }), IsIso ((stalkFunctor C ↑x).map f.val)
⊢ ∀ (x : { x // x ∈ U }), Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
[PROOFSTEP]
intro x
[GOAL]
case h
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
inst✝ : ∀ (x : { x // x ∈ U }), IsIso ((stalkFunctor C ↑x).map f.val)
x : { x // x ∈ U }
⊢ Function.Bijective ↑((stalkFunctor C ↑x).map f.val)
[PROOFSTEP]
apply (isIso_iff_bijective _).mp
[GOAL]
case h
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
U : Opens ↑X
inst✝ : ∀ (x : { x // x ∈ U }), IsIso ((stalkFunctor C ↑x).map f.val)
x : { x // x ∈ U }
⊢ IsIso ↑((stalkFunctor C ↑x).map f.val)
[PROOFSTEP]
exact Functor.map_isIso (forget C) ((stalkFunctor C x.1).map f.1)
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
inst✝ : ∀ (x : ↑X), IsIso ((stalkFunctor C x).map f.val)
⊢ IsIso f
[PROOFSTEP]
suffices IsIso ((Sheaf.forget C X).map f) by exact isIso_of_fully_faithful (Sheaf.forget C X) f
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
inst✝ : ∀ (x : ↑X), IsIso ((stalkFunctor C x).map f.val)
this : IsIso ((Sheaf.forget C X).map f)
⊢ IsIso f
[PROOFSTEP]
exact isIso_of_fully_faithful (Sheaf.forget C X) f
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
inst✝ : ∀ (x : ↑X), IsIso ((stalkFunctor C x).map f.val)
⊢ IsIso ((Sheaf.forget C X).map f)
[PROOFSTEP]
suffices ∀ U : (Opens X)ᵒᵖ, IsIso (f.1.app U) by exact @NatIso.isIso_of_isIso_app _ _ _ _ F.1 G.1 f.1 this
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
inst✝ : ∀ (x : ↑X), IsIso ((stalkFunctor C x).map f.val)
this : ∀ (U : (Opens ↑X)ᵒᵖ), IsIso (NatTrans.app f.val U)
⊢ IsIso ((Sheaf.forget C X).map f)
[PROOFSTEP]
exact @NatIso.isIso_of_isIso_app _ _ _ _ F.1 G.1 f.1 this
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
inst✝ : ∀ (x : ↑X), IsIso ((stalkFunctor C x).map f.val)
⊢ ∀ (U : (Opens ↑X)ᵒᵖ), IsIso (NatTrans.app f.val U)
[PROOFSTEP]
intro U
[GOAL]
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
inst✝ : ∀ (x : ↑X), IsIso ((stalkFunctor C x).map f.val)
U : (Opens ↑X)ᵒᵖ
⊢ IsIso (NatTrans.app f.val U)
[PROOFSTEP]
induction U
[GOAL]
case h
C : Type u
inst✝⁷ : Category.{v, u} C
inst✝⁶ : HasColimits C
X Y Z : TopCat
inst✝⁵ : ConcreteCategory C
inst✝⁴ : PreservesFilteredColimits (forget C)
inst✝³ : HasLimits C
inst✝² : PreservesLimits (forget C)
inst✝¹ : ReflectsIsomorphisms (forget C)
F G : Sheaf C X
f : F ⟶ G
inst✝ : ∀ (x : ↑X), IsIso ((stalkFunctor C x).map f.val)
X✝ : Opens ↑X
⊢ IsIso (NatTrans.app f.val (op X✝))
[PROOFSTEP]
apply app_isIso_of_stalkFunctor_map_iso