File: Mathlib/Topology/Sheaves/Stalks.lean

full_name: TopCat.Presheaf.stalkFunctor
code: /-- Stalks are functorial with respect to morphisms of presheaves over a fixed `X`. -/
def stalkFunctor (x : X) : X.Presheaf C ⥤ C 
goal: TopCat.Presheaf C X ⥤ C

full_name: TopCat.Presheaf.stalk
code: /-- The stalk of a presheaf `F` at a point `x` is calculated as the colimit of the functor
nbhds x ⥤ opens F.X ⥤ C
-/
def stalk (ℱ : X.Presheaf C) (x : X) : C 
goal: C

full_name: TopCat.Presheaf.stalkFunctor_obj
code: @[simp]
theorem stalkFunctor_obj (ℱ : X.Presheaf C) (x : X) : (stalkFunctor C x).obj ℱ = ℱ.stalk x 
goal: (TopCat.Presheaf.stalkFunctor C x).obj ℱ = ℱ.stalk x

full_name: TopCat.Presheaf.germ
code: /-- The germ of a section of a presheaf over an open at a point of that open.
-/
def germ (F : X.Presheaf C) {U : Opens X} (x : U) : F.obj (op U) ⟶ stalk F x 
goal: F.obj (Opposite.op U) ⟶ F.stalk ↑x

full_name: TopCat.Presheaf.Γgerm
code: /-- The germ of a global section of a presheaf at a point. -/
def Γgerm (F : X.Presheaf C) (x : X) : F.obj (op ⊤) ⟶ stalk F x 
goal: F.obj (Opposite.op ⊤) ⟶ F.stalk x

full_name: TopCat.Presheaf.germ_res
code: @[reassoc (attr := simp)]
theorem germ_res (F : X.Presheaf C) {U V : Opens X} (i : U ⟶ V) (x : U) :
    F.map i.op ≫ germ F x = germ F (i x : V) 
goal: F.map i.op ≫ F.germ x = F.germ ((fun x => ⟨↑x, ⋯⟩) x)

full_name: TopCat.Presheaf.map_germ_eq_Γgerm
code: @[reassoc]
lemma map_germ_eq_Γgerm (F : X.Presheaf C) {U : Opens X} {i : U ⟶ ⊤} (x : U) :
    F.map i.op ≫ germ F x = Γgerm F (i x) 
goal: F.map i.op ≫ F.germ x = F.Γgerm ↑((fun x => ⟨↑x, ⋯⟩) x)

full_name: TopCat.Presheaf.germ_res_apply
code: theorem germ_res_apply (F : X.Presheaf C) {U V : Opens X} (i : U ⟶ V) (x : U) [ConcreteCategory C]
    (s) : germ F x (F.map i.op s) = germ F (i x) s 
goal: (F.germ x) ((F.map i.op) s) = (F.germ ((fun x => ⟨↑x, ⋯⟩) x)) s

full_name: TopCat.Presheaf.Γgerm_res_apply
code: lemma Γgerm_res_apply (F : X.Presheaf C) {U : Opens X} {i : U ⟶ ⊤} (x : U) [ConcreteCategory C]
    (s) : germ F x (F.map i.op s) = Γgerm F x.val s 
goal: (F.germ x) ((F.map i.op) s) = (F.Γgerm ↑x) s

full_name: TopCat.Presheaf.stalk_hom_ext
code: /-- A morphism from the stalk of `F` at `x` to some object `Y` is completely determined by its
composition with the `germ` morphisms.
-/
@[ext]
theorem stalk_hom_ext (F : X.Presheaf C) {x} {Y : C} {f₁ f₂ : F.stalk x ⟶ Y}
    (ih : ∀ (U : Opens X) (hxU : x ∈ U), F.germ ⟨x, hxU⟩ ≫ f₁ = F.germ ⟨x, hxU⟩ ≫ f₂) : f₁ = f₂ 
goal: f₁ = f₂

full_name: TopCat.Presheaf.stalkFunctor_map_germ
code: @[reassoc (attr := simp), elementwise (attr := simp)]
theorem stalkFunctor_map_germ {F G : X.Presheaf C} (U : Opens X) (x : U) (f : F ⟶ G) :
    germ F x ≫ (stalkFunctor C x.1).map f = f.app (op U) ≫ germ G x 
goal: F.germ x ≫ (TopCat.Presheaf.stalkFunctor C ↑x).map f = f.app (Opposite.op U) ≫ G.germ x

full_name: TopCat.Presheaf.stalkPushforward
code: /-- For a presheaf `F` on a space `X`, a continuous map `f : X ⟶ Y` induces a morphisms between the
stalk of `f _ * F` at `f x` and the stalk of `F` at `x`.
-/
def stalkPushforward (f : X ⟶ Y) (F : X.Presheaf C) (x : X) : (f _* F).stalk (f x) ⟶ F.stalk x 
goal: ((TopCat.Presheaf.pushforward C f).obj F).stalk (f x) ⟶ F.stalk x

full_name: TopCat.Presheaf.stalkPushforward_germ
code: @[reassoc (attr := simp), elementwise (attr := simp)]
theorem stalkPushforward_germ (f : X ⟶ Y) (F : X.Presheaf C) (U : Opens Y)
    (x : (Opens.map f).obj U) :
      (f _* F).germ ⟨(f : X → Y) (x : X), x.2⟩ ≫ F.stalkPushforward C f x = F.germ x 
goal: ((TopCat.Presheaf.pushforward C f).obj F).germ ⟨f ↑x, ⋯⟩ ≫ TopCat.Presheaf.stalkPushforward C f F ↑x = F.germ x

full_name: TopCat.Presheaf.stalkPushforward.id
code: @[simp]
theorem id (ℱ : X.Presheaf C) (x : X) :
    ℱ.stalkPushforward C (𝟙 X) x = (stalkFunctor C x).map (Pushforward.id ℱ).hom 
goal: TopCat.Presheaf.stalkPushforward C (𝟙 X) ℱ x =
  (TopCat.Presheaf.stalkFunctor C x).map (TopCat.Presheaf.Pushforward.id ℱ).hom

full_name: TopCat.Presheaf.stalkPushforward.comp
code: @[simp]
theorem comp (ℱ : X.Presheaf C) (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) :
    ℱ.stalkPushforward C (f ≫ g) x =
      (f _* ℱ).stalkPushforward C g (f x) ≫ ℱ.stalkPushforward C f x 
goal: TopCat.Presheaf.stalkPushforward C (f ≫ g) ℱ x =
  TopCat.Presheaf.stalkPushforward C g ((TopCat.Presheaf.pushforward C f).obj ℱ) (f x) ≫
    TopCat.Presheaf.stalkPushforward C f ℱ x

full_name: TopCat.Presheaf.stalkPushforward.stalkPushforward_iso_of_openEmbedding
code: theorem stalkPushforward_iso_of_openEmbedding {f : X ⟶ Y} (hf : OpenEmbedding f) (F : X.Presheaf C)
    (x : X) : IsIso (F.stalkPushforward _ f x) 
goal: CategoryTheory.IsIso (TopCat.Presheaf.stalkPushforward C f F x)

full_name: TopCat.Presheaf.stalkPullbackHom
code: /-- The morphism `ℱ_{f x} ⟶ (f⁻¹ℱ)ₓ` that factors through `(f_*f⁻¹ℱ)_{f x}`. -/
def stalkPullbackHom (f : X ⟶ Y) (F : Y.Presheaf C) (x : X) :
    F.stalk (f x) ⟶ ((pullback C f).obj F).stalk x 
goal: F.stalk (f x) ⟶ ((TopCat.Presheaf.pullback C f).obj F).stalk x

full_name: TopCat.Presheaf.germ_stalkPullbackHom
code: @[reassoc (attr := simp)]
lemma germ_stalkPullbackHom
    (f : X ⟶ Y) (F : Y.Presheaf C) (x : X) (U : Opens Y) (hU : f x ∈ U) :
    F.germ ⟨f x, hU⟩ ≫ stalkPullbackHom C f F x =
      ((pushforwardPullbackAdjunction C f).unit.app F).app _ ≫
        ((pullback C f).obj F).germ ⟨x, show x ∈ (Opens.map f).obj U from hU⟩ 
goal: F.germ ⟨f x, hU⟩ ≫ TopCat.Presheaf.stalkPullbackHom C f F x =
  ((TopCat.Presheaf.pushforwardPullbackAdjunction C f).unit.app F).app (Opposite.op U) ≫
    ((TopCat.Presheaf.pullback C f).obj F).germ ⟨x, ⋯⟩

full_name: TopCat.Presheaf.germToPullbackStalk
code: /-- The morphism `(f⁻¹ℱ)(U) ⟶ ℱ_{f(x)}` for some `U ∋ x`. -/
def germToPullbackStalk (f : X ⟶ Y) (F : Y.Presheaf C) (U : Opens X) (x : U) :
    ((pullback C f).obj F).obj (op U) ⟶ F.stalk ((f : X → Y) (x : X)) 
goal: ((TopCat.Presheaf.pullback C f).obj F).obj (Opposite.op U) ⟶ F.stalk (f ↑x)

full_name: TopCat.Presheaf.pullback_obj_obj_ext
code: @[ext]
lemma pullback_obj_obj_ext {Z : C} {f : X ⟶ Y} {F : Y.Presheaf C} (U : (Opens X)ᵒᵖ)
    {φ ψ : ((pullback C f).obj F).obj U ⟶ Z}
    (h : ∀ (V : Opens Y) (hV : U.unop ≤ (Opens.map f).obj V),
      ((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
        ((pullback C f).obj F).map (homOfLE hV).op ≫ φ =
      ((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
        ((pullback C f).obj F).map (homOfLE hV).op ≫ ψ) : φ = ψ 
goal: φ = ψ

full_name: TopCat.Presheaf.pushforwardPullbackAdjunction_unit_pullback_map_germToPullbackStalk
code: @[reassoc (attr := simp)]
lemma pushforwardPullbackAdjunction_unit_pullback_map_germToPullbackStalk
    (f : X ⟶ Y) (F : Y.Presheaf C) (U : Opens X) (x : U) (V : Opens Y)
    (hV : U ≤ (Opens.map f).obj V) :
    ((pushforwardPullbackAdjunction C f).unit.app F).app (op V) ≫
      ((pullback C f).obj F).map (homOfLE hV).op ≫ germToPullbackStalk C f F U x =
        F.germ ⟨f x, hV x.2⟩ 
goal: ((TopCat.Presheaf.pushforwardPullbackAdjunction C f).unit.app F).app (Opposite.op V) ≫
    ((TopCat.Presheaf.pullback C f).obj F).map (CategoryTheory.homOfLE hV).op ≫
      TopCat.Presheaf.germToPullbackStalk C f F U x =
  F.germ ⟨f ↑x, ⋯⟩

full_name: TopCat.Presheaf.germToPullbackStalk_stalkPullbackHom
code: @[reassoc (attr := simp)]
lemma germToPullbackStalk_stalkPullbackHom
    (f : X ⟶ Y) (F : Y.Presheaf C) (U : Opens X) (x : U) :
    germToPullbackStalk C f F U x ≫ stalkPullbackHom C f F x =
      ((pullback C f).obj F).germ x 
goal: TopCat.Presheaf.germToPullbackStalk C f F U x ≫ TopCat.Presheaf.stalkPullbackHom C f F ↑x =
  ((TopCat.Presheaf.pullback C f).obj F).germ x

full_name: TopCat.Presheaf.pushforwardPullbackAdjunction_unit_app_app_germToPullbackStalk
code: @[reassoc (attr := simp)]
lemma pushforwardPullbackAdjunction_unit_app_app_germToPullbackStalk
    (f : X ⟶ Y) (F : Y.Presheaf C) (V : (Opens Y)ᵒᵖ) (x : (Opens.map f).obj V.unop) :
    ((pushforwardPullbackAdjunction C f).unit.app F).app V ≫ germToPullbackStalk C f F _ x =
      F.germ ⟨f x, x.2⟩ 
goal: ((TopCat.Presheaf.pushforwardPullbackAdjunction C f).unit.app F).app V ≫
    TopCat.Presheaf.germToPullbackStalk C f F ((TopologicalSpace.Opens.map f).obj (Opposite.unop V)) x =
  F.germ ⟨f ↑x, ⋯⟩

full_name: TopCat.Presheaf.stalkPullbackInv
code: /-- The morphism `(f⁻¹ℱ)ₓ ⟶ ℱ_{f(x)}`. -/
def stalkPullbackInv (f : X ⟶ Y) (F : Y.Presheaf C) (x : X) :
    ((pullback C f).obj F).stalk x ⟶ F.stalk (f x) 
goal: ((TopCat.Presheaf.pullback C f).obj F).stalk x ⟶ F.stalk (f x)

full_name: TopCat.Presheaf.germ_stalkPullbackInv
code: @[reassoc (attr := simp)]
lemma germ_stalkPullbackInv (f : X ⟶ Y) (F : Y.Presheaf C) (x : X) (V : Opens X) (hV : x ∈ V) :
    ((pullback C f).obj F).germ ⟨x, hV⟩ ≫ stalkPullbackInv C f F x =
    F.germToPullbackStalk _ f V ⟨x, hV⟩ 
goal: ((TopCat.Presheaf.pullback C f).obj F).germ ⟨x, hV⟩ ≫ TopCat.Presheaf.stalkPullbackInv C f F x =
  TopCat.Presheaf.germToPullbackStalk C f F V ⟨x, hV⟩

full_name: TopCat.Presheaf.stalkPullbackIso
code: /-- The isomorphism `ℱ_{f(x)} ≅ (f⁻¹ℱ)ₓ`. -/
def stalkPullbackIso (f : X ⟶ Y) (F : Y.Presheaf C) (x : X) :
    F.stalk (f x) ≅ ((pullback C f).obj F).stalk x 
goal: F.stalk (f x) ≅ ((TopCat.Presheaf.pullback C f).obj F).stalk x

full_name: TopCat.Presheaf.stalkSpecializes
code: /-- If `x` specializes to `y`, then there is a natural map `F.stalk y ⟶ F.stalk x`. -/
noncomputable def stalkSpecializes (F : X.Presheaf C) {x y : X} (h : x ⤳ y) :
    F.stalk y ⟶ F.stalk x 
goal: F.stalk y ⟶ F.stalk x

full_name: TopCat.Presheaf.germ_stalkSpecializes
code: @[reassoc (attr := simp), elementwise nosimp]
theorem germ_stalkSpecializes (F : X.Presheaf C) {U : Opens X} {y : U} {x : X} (h : x ⤳ y) :
    F.germ y ≫ F.stalkSpecializes h = F.germ (⟨x, h.mem_open U.isOpen y.prop⟩ : U) 
goal: F.germ y ≫ F.stalkSpecializes h = F.germ ⟨x, ⋯⟩

full_name: TopCat.Presheaf.germ_stalkSpecializes'
code: @[reassoc, elementwise nosimp]
theorem germ_stalkSpecializes' (F : X.Presheaf C) {U : Opens X} {x y : X} (h : x ⤳ y)
    (hy : y ∈ U) : F.germ ⟨y, hy⟩ ≫ F.stalkSpecializes h = F.germ ⟨x, h.mem_open U.isOpen hy⟩ 
goal: F.germ ⟨y, hy⟩ ≫ F.stalkSpecializes h = F.germ ⟨x, ⋯⟩

full_name: TopCat.Presheaf.stalkSpecializes_refl
code: @[simp]
theorem stalkSpecializes_refl {C : Type*} [Category C] [Limits.HasColimits C] {X : TopCat}
    (F : X.Presheaf C) (x : X) : F.stalkSpecializes (specializes_refl x) = 𝟙 _ 
goal: F.stalkSpecializes ⋯ = 𝟙 (F.stalk x)

full_name: TopCat.Presheaf.stalkSpecializes_comp
code: @[reassoc (attr := simp), elementwise (attr := simp)]
theorem stalkSpecializes_comp {C : Type*} [Category C] [Limits.HasColimits C] {X : TopCat}
    (F : X.Presheaf C) {x y z : X} (h : x ⤳ y) (h' : y ⤳ z) :
    F.stalkSpecializes h' ≫ F.stalkSpecializes h = F.stalkSpecializes (h.trans h') 
goal: F.stalkSpecializes h' ≫ F.stalkSpecializes h = F.stalkSpecializes ⋯

full_name: TopCat.Presheaf.stalkSpecializes_stalkFunctor_map
code: @[reassoc (attr := simp), elementwise (attr := simp)]
theorem stalkSpecializes_stalkFunctor_map {F G : X.Presheaf C} (f : F ⟶ G) {x y : X} (h : x ⤳ y) :
    F.stalkSpecializes h ≫ (stalkFunctor C x).map f =
      (stalkFunctor C y).map f ≫ G.stalkSpecializes h 
goal: F.stalkSpecializes h ≫ (TopCat.Presheaf.stalkFunctor C x).map f =
  (TopCat.Presheaf.stalkFunctor C y).map f ≫ G.stalkSpecializes h

full_name: TopCat.Presheaf.stalkSpecializes_stalkPushforward
code: @[reassoc, elementwise, simp, nolint simpNF] -- see std4#365 for the simpNF issue
theorem stalkSpecializes_stalkPushforward (f : X ⟶ Y) (F : X.Presheaf C) {x y : X} (h : x ⤳ y) :
    (f _* F).stalkSpecializes (f.map_specializes h) ≫ F.stalkPushforward _ f x =
      F.stalkPushforward _ f y ≫ F.stalkSpecializes h 
goal: ((TopCat.Presheaf.pushforward C f).obj F).stalkSpecializes ⋯ ≫ TopCat.Presheaf.stalkPushforward C f F x =
  TopCat.Presheaf.stalkPushforward C f F y ≫ F.stalkSpecializes h

full_name: TopCat.Presheaf.stalkCongr_inv
code: /-- The stalks are isomorphic on inseparable points -/
@[simps]
def stalkCongr {X : TopCat} {C : Type*} [Category C] [HasColimits C] (F : X.Presheaf C) {x y : X}
    (e : Inseparable x y) : F.stalk x ≅ F.stalk y 
goal: (F.stalkCongr e).inv = F.stalkSpecializes ⋯

full_name: TopCat.Presheaf.stalkCongr_hom
code: /-- The stalks are isomorphic on inseparable points -/
@[simps]
def stalkCongr {X : TopCat} {C : Type*} [Category C] [HasColimits C] (F : X.Presheaf C) {x y : X}
    (e : Inseparable x y) : F.stalk x ≅ F.stalk y 
goal: (F.stalkCongr e).hom = F.stalkSpecializes ⋯

full_name: TopCat.Presheaf.stalkCongr
code: /-- The stalks are isomorphic on inseparable points -/
@[simps]
def stalkCongr {X : TopCat} {C : Type*} [Category C] [HasColimits C] (F : X.Presheaf C) {x y : X}
    (e : Inseparable x y) : F.stalk x ≅ F.stalk y 
goal: F.stalk x ≅ F.stalk y

full_name: TopCat.Presheaf.germ_ext
code: theorem germ_ext (F : X.Presheaf C) {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 : F.obj (op U)} {sV : F.obj (op V)}
    (ih : F.map iWU.op sU = F.map iWV.op sV) :
      F.germ ⟨x, hxU⟩ sU = F.germ ⟨x, hxV⟩ sV 
goal: (F.germ ⟨x, hxU⟩) sU = (F.germ ⟨x, hxV⟩) sV

full_name: TopCat.Presheaf.germ_exist
code: /--
For presheaves valued in a concrete category whose forgetful functor preserves filtered colimits,
every element of the stalk is the germ of a section.
-/
theorem germ_exist (F : X.Presheaf C) (x : X) (t : (stalk.{v, u} F x : Type v)) :
    ∃ (U : Opens X) (m : x ∈ U) (s : F.obj (op U)), F.germ ⟨x, m⟩ s = t 
goal: ∃ U, ∃ (m : x ∈ U), ∃ s, (F.germ ⟨x, m⟩) s = t

full_name: TopCat.Presheaf.germ_eq
code: theorem germ_eq (F : X.Presheaf C) {U V : Opens X} (x : X) (mU : x ∈ U) (mV : x ∈ V)
    (s : F.obj (op U)) (t : F.obj (op V)) (h : germ F ⟨x, mU⟩ s = germ F ⟨x, mV⟩ t) :
    ∃ (W : Opens X) (_m : x ∈ W) (iU : W ⟶ U) (iV : W ⟶ V), F.map iU.op s = F.map iV.op t 
goal: ∃ W, ∃ (_ : x ∈ W), ∃ iU iV, (F.map iU.op) s = (F.map iV.op) t

full_name: TopCat.Presheaf.stalkFunctor_map_injective_of_app_injective
code: theorem stalkFunctor_map_injective_of_app_injective {F G : Presheaf C X} (f : F ⟶ G)
    (h : ∀ U : Opens X, Function.Injective (f.app (op U))) (x : X) :
    Function.Injective ((stalkFunctor C x).map f) 
goal: Function.Injective ⇑((TopCat.Presheaf.stalkFunctor C x).map f)

full_name: TopCat.Presheaf.section_ext
code: /-- Let `F` be a sheaf valued in a concrete category, whose forgetful functor reflects isomorphisms,
preserves limits and filtered colimits. Then two sections who agree on every stalk must be equal.
-/
theorem section_ext (F : Sheaf C X) (U : Opens X) (s t : F.1.obj (op U))
    (h : ∀ x : U, F.presheaf.germ x s = F.presheaf.germ x t) : s = t 
goal: s = t

full_name: TopCat.Presheaf.app_injective_of_stalkFunctor_map_injective
code: theorem app_injective_of_stalkFunctor_map_injective {F : Sheaf C X} {G : Presheaf C X} (f : F.1 ⟶ G)
    (U : Opens X) (h : ∀ x : U, Function.Injective ((stalkFunctor C x.val).map f)) :
    Function.Injective (f.app (op U)) 
goal: Function.Injective ⇑(f.app (Opposite.op U))

full_name: TopCat.Presheaf.app_injective_iff_stalkFunctor_map_injective
code: theorem app_injective_iff_stalkFunctor_map_injective {F : Sheaf C X} {G : Presheaf C X}
    (f : F.1 ⟶ G) :
    (∀ x : X, Function.Injective ((stalkFunctor C x).map f)) ↔
      ∀ U : Opens X, Function.Injective (f.app (op U)) 
goal: (∀ (x : ↑X), Function.Injective ⇑((TopCat.Presheaf.stalkFunctor C x).map f)) ↔
  ∀ (U : TopologicalSpace.Opens ↑X), Function.Injective ⇑(f.app (Opposite.op U))

full_name: TopCat.Presheaf.stalkFunctor_preserves_mono
code: instance stalkFunctor_preserves_mono (x : X) :
    Functor.PreservesMonomorphisms (Sheaf.forget C X ⋙ stalkFunctor C x) 
goal: (TopCat.Sheaf.forget C X ⋙ TopCat.Presheaf.stalkFunctor C x).PreservesMonomorphisms

full_name: TopCat.Presheaf.stalk_mono_of_mono
code: theorem stalk_mono_of_mono {F G : Sheaf C X} (f : F ⟶ G) [Mono f] :
    ∀ x, Mono <| (stalkFunctor C x).map f.1 
goal: CategoryTheory.Mono ((TopCat.Presheaf.stalkFunctor C x).map f.val)

full_name: TopCat.Presheaf.mono_of_stalk_mono
code: theorem mono_of_stalk_mono {F G : Sheaf C X} (f : F ⟶ G) [∀ x, Mono <| (stalkFunctor C x).map f.1] :
    Mono f 
goal: CategoryTheory.Mono f

full_name: TopCat.Presheaf.mono_iff_stalk_mono
code: theorem mono_iff_stalk_mono {F G : Sheaf C X} (f : F ⟶ G) :
    Mono f ↔ ∀ x, Mono ((stalkFunctor C x).map f.1) 
goal: CategoryTheory.Mono f ↔ ∀ (x : ↑X), CategoryTheory.Mono ((TopCat.Presheaf.stalkFunctor C x).map f.val)

full_name: TopCat.Presheaf.app_surjective_of_injective_of_locally_surjective
code: /-- For surjectivity, we are given an arbitrary section `t` and need to find a preimage for it.
We claim that it suffices to find preimages *locally*. That is, for each `x : U` we construct
a neighborhood `V ≤ U` and a section `s : F.obj (op V))` such that `f.app (op V) s` and `t`
agree on `V`. -/
theorem app_surjective_of_injective_of_locally_surjective {F G : Sheaf C X} (f : F ⟶ G)
    (U : Opens X) (hinj : ∀ x : U, Function.Injective ((stalkFunctor C x.1).map f.1))
    (hsurj : ∀ (t) (x : U), ∃ (V : Opens X) (_ : x.1 ∈ V) (iVU : V ⟶ U) (s : F.1.obj (op V)),
          f.1.app (op V) s = G.1.map iVU.op t) :
    Function.Surjective (f.1.app (op U)) 
goal: Function.Surjective ⇑(f.val.app (Opposite.op U))

full_name: TopCat.Presheaf.app_surjective_of_stalkFunctor_map_bijective
code: theorem app_surjective_of_stalkFunctor_map_bijective {F G : Sheaf C X} (f : F ⟶ G) (U : Opens X)
    (h : ∀ x : U, Function.Bijective ((stalkFunctor C x.val).map f.1)) :
    Function.Surjective (f.1.app (op U)) 
goal: Function.Surjective ⇑(f.val.app (Opposite.op U))

full_name: TopCat.Presheaf.app_bijective_of_stalkFunctor_map_bijective
code: theorem app_bijective_of_stalkFunctor_map_bijective {F G : Sheaf C X} (f : F ⟶ G) (U : Opens X)
    (h : ∀ x : U, Function.Bijective ((stalkFunctor C x.val).map f.1)) :
    Function.Bijective (f.1.app (op U)) 
goal: Function.Bijective ⇑(f.val.app (Opposite.op U))

full_name: TopCat.Presheaf.app_isIso_of_stalkFunctor_map_iso
code: theorem app_isIso_of_stalkFunctor_map_iso {F G : Sheaf C X} (f : F ⟶ G) (U : Opens X)
    [∀ x : U, IsIso ((stalkFunctor C x.val).map f.1)] : IsIso (f.1.app (op U)) 
goal: CategoryTheory.IsIso (f.val.app (Opposite.op U))

full_name: TopCat.Presheaf.isIso_of_stalkFunctor_map_iso
code: /-- Let `F` and `G` be sheaves valued in a concrete category, whose forgetful functor reflects
isomorphisms, preserves limits and filtered colimits. Then if the stalk maps of a morphism
`f : F ⟶ G` are all isomorphisms, `f` must be an isomorphism.
-/
theorem isIso_of_stalkFunctor_map_iso {F G : Sheaf C X} (f : F ⟶ G)
    [∀ x : X, IsIso ((stalkFunctor C x).map f.1)] : IsIso f 
goal: CategoryTheory.IsIso f

full_name: TopCat.Presheaf.isIso_iff_stalkFunctor_map_iso
code: /-- Let `F` and `G` be sheaves valued in a concrete category, whose forgetful functor reflects
isomorphisms, preserves limits and filtered colimits. Then a morphism `f : F ⟶ G` is an
isomorphism if and only if all of its stalk maps are isomorphisms.
-/
theorem isIso_iff_stalkFunctor_map_iso {F G : Sheaf C X} (f : F ⟶ G) :
    IsIso f ↔ ∀ x : X, IsIso ((stalkFunctor C x).map f.1) 
goal: CategoryTheory.IsIso f ↔ ∀ (x : ↑X), CategoryTheory.IsIso ((TopCat.Presheaf.stalkFunctor C x).map f.val)

full_name: TopCat.Presheaf.algebra_section_stalk
code: instance algebra_section_stalk (F : X.Presheaf CommRingCat) {U : Opens X} (x : U) :
    Algebra (F.obj <| op U) (F.stalk x) 
goal: Algebra ↑(F.obj (Opposite.op U)) ↑(F.stalk ↑x)

full_name: TopCat.Presheaf.stalk_open_algebraMap
code: @[simp]
theorem stalk_open_algebraMap {X : TopCat} (F : X.Presheaf CommRingCat) {U : Opens X} (x : U) :
    algebraMap (F.obj <| op U) (F.stalk x) = F.germ x 
goal: algebraMap ↑(F.obj (Opposite.op U)) ↑(F.stalk ↑x) = F.germ x