Stalks

For a presheaf F on a topological space X, valued in some category C, the stalk of F at the point x : X is defined as the colimit of the composition of the inclusion of categories (OpenNhds x)ᵒᵖ ⥤ (Opens X)ᵒᵖ and the functor F : (Opens X)ᵒᵖ ⥤ C. For an open neighborhood U of x, we define the map F.germ x : F.obj (op U) ⟶ F.stalk x as the canonical morphism into this colimit.

Taking stalks is functorial: For every point x : X we define a functor stalkFunctor C x, sending presheaves on X to objects of C. Furthermore, for a map f : X ⟶ Y between topological spaces, we define stalkPushforward as the induced map on the stalks (f _* ℱ).stalk (f x) ⟶ ℱ.stalk x.

Some lemmas about stalks and germs only hold for certain classes of concrete categories. A basic property of forgetful functors of categories of algebraic structures (like MonCat, CommRingCat,...) is that they preserve filtered colimits. Since stalks are filtered colimits, this ensures that the stalks of presheaves valued in these categories behave exactly as for Type-valued presheaves. For example, in germ_exist we prove that in such a category, every element of the stalk is the germ of a section.

Furthermore, if we require the forgetful functor to reflect isomorphisms and preserve limits (as is the case for most algebraic structures), we have access to the unique gluing API and can prove further properties. Most notably, in is_iso_iff_stalk_functor_map_iso, we prove that in such a category, a morphism of sheaves is an isomorphism if and only if all of its stalk maps are isomorphisms.

See also the definition of "algebraic structures" in the stacks project: https://stacks.math.columbia.edu/tag/007L

def TopCat.Presheaf.stalkFunctor (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (x : ↑X) : CategoryTheory.Functor (TopCat.Presheaf C X) C

Stalks are functorial with respect to morphisms of presheaves over a fixed X.

Equations

• One or more equations did not get rendered due to their size.

def TopCat.Presheaf.stalk {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (ℱ : TopCat.Presheaf C X) (x : ↑X) : C

The stalk of a presheaf F at a point x is calculated as the colimit of the functor nbhds x ⥤ opens F.X ⥤ C

Equations

• TopCat.Presheaf.stalk ℱ x = (TopCat.Presheaf.stalkFunctor C x).toPrefunctor.obj ℱ

@[simp]

theorem TopCat.Presheaf.stalkFunctor_obj {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (ℱ : TopCat.Presheaf C X) (x : ↑X) : (TopCat.Presheaf.stalkFunctor C x).toPrefunctor.obj ℱ = TopCat.Presheaf.stalk ℱ x

def TopCat.Presheaf.germ {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} (x : ↥U) : F.toPrefunctor.obj (Opposite.op U) ⟶ TopCat.Presheaf.stalk F ↑x

The germ of a section of a presheaf over an open at a point of that open.

Equations

• TopCat.Presheaf.germ F x = CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion ↑x).op F) (Opposite.op { obj := U, property := (_ : ↑x ∈ U) })

theorem TopCat.Presheaf.germ_res {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {V : TopologicalSpace.Opens ↑X} (i : U ⟶ V) (x : ↥U) : CategoryTheory.CategoryStruct.comp (F.toPrefunctor.map i.op) (TopCat.Presheaf.germ F x) = TopCat.Presheaf.germ F ((fun (x : ↥U) => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)

theorem TopCat.Presheaf.germ_res_apply {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {V : TopologicalSpace.Opens ↑X} (i : U ⟶ V) (x : ↥U) [CategoryTheory.ConcreteCategory C] (s : (CategoryTheory.forget C).toPrefunctor.obj (F.toPrefunctor.obj (Opposite.op V))) : (TopCat.Presheaf.germ F x) ((F.toPrefunctor.map i.op) s) = (TopCat.Presheaf.germ F ((fun (x : ↥U) => { val := ↑x, property := (_ : ↑x ∈ ↑V) }) x)) s

theorem TopCat.Presheaf.stalk_hom_ext {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {x : ↑X} {Y : C} {f₁ : TopCat.Presheaf.stalk F x ⟶ Y} {f₂ : TopCat.Presheaf.stalk F x ⟶ Y} (ih : ∀ (U : TopologicalSpace.Opens ↑X) (hxU : x ∈ U), CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F { val := x, property := hxU }) f₁ = CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F { val := x, property := hxU }) f₂) : f₁ = f₂

A morphism from the stalk of F at x to some object Y is completely determined by its composition with the germ morphisms.

@[simp]

theorem TopCat.Presheaf.stalkFunctor_map_germ_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {F : TopCat.Presheaf C X} {G : TopCat.Presheaf C X} (U : TopologicalSpace.Opens ↑X) (x : ↥U) (f : F ⟶ G) {Z : C} (h : (TopCat.Presheaf.stalkFunctor C ↑x).toPrefunctor.obj G ⟶ Z) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F x) (CategoryTheory.CategoryStruct.comp ((TopCat.Presheaf.stalkFunctor C ↑x).toPrefunctor.map f) h) = CategoryTheory.CategoryStruct.comp (f.app (Opposite.op U)) (CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ G x) h)

@[simp]

theorem TopCat.Presheaf.stalkFunctor_map_germ_apply {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {F : TopCat.Presheaf C X} {G : TopCat.Presheaf C X} (U : TopologicalSpace.Opens ↑X) (x : ↥U) (f : F ⟶ G) [inst : CategoryTheory.ConcreteCategory C] (x : (CategoryTheory.forget C).toPrefunctor.obj ((CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion ↑x✝).op F).toPrefunctor.obj (Opposite.op { obj := U, property := (_ : ↑x✝ ∈ U) }))) : (CategoryTheory.Limits.colimMap (CategoryTheory.whiskerLeft (TopologicalSpace.OpenNhds.inclusion ↑x✝).op f)) ((CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion ↑x✝).op F) (Opposite.op { obj := U, property := (_ : ↑x✝ ∈ U) })) x) = (CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion ↑x✝).op G) (Opposite.op { obj := U, property := (_ : ↑x✝ ∈ U) })) ((f.app (Opposite.op U)) x)

@[simp]

theorem TopCat.Presheaf.stalkFunctor_map_germ {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {F : TopCat.Presheaf C X} {G : TopCat.Presheaf C X} (U : TopologicalSpace.Opens ↑X) (x : ↥U) (f : F ⟶ G) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F x) ((TopCat.Presheaf.stalkFunctor C ↑x).toPrefunctor.map f) = CategoryTheory.CategoryStruct.comp (f.app (Opposite.op U)) (TopCat.Presheaf.germ G x)

def TopCat.Presheaf.stalkPushforward (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C X) (x : ↑X) : TopCat.Presheaf.stalk (f _* F) (f x) ⟶ TopCat.Presheaf.stalk F x

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.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem TopCat.Presheaf.stalkPushforward_germ_assoc (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C X) (U : TopologicalSpace.Opens ↑Y) (x : ↥((TopologicalSpace.Opens.map f).toPrefunctor.obj U)) {Z : C} (h : TopCat.Presheaf.stalk F ↑x ⟶ Z) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ (f _* F) { val := f ↑x, property := (_ : ↑x ∈ (TopologicalSpace.Opens.map f).toPrefunctor.obj U) }) (CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkPushforward C f F ↑x) h) = CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F x) h

@[simp]

theorem TopCat.Presheaf.stalkPushforward_germ_apply (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C X) (U : TopologicalSpace.Opens ↑Y) (x : ↥((TopologicalSpace.Opens.map f).toPrefunctor.obj U)) [inst : CategoryTheory.ConcreteCategory C] (x : (CategoryTheory.forget C).toPrefunctor.obj ((f _* F).toPrefunctor.obj (Opposite.op U))) : (TopCat.Presheaf.stalkPushforward C f F ↑x✝) ((TopCat.Presheaf.germ (f _* F) { val := f ↑x✝, property := (_ : ↑x✝ ∈ (TopologicalSpace.Opens.map f).toPrefunctor.obj U) }) x) = (TopCat.Presheaf.germ F x✝) x

@[simp]

theorem TopCat.Presheaf.stalkPushforward_germ (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C X) (U : TopologicalSpace.Opens ↑Y) (x : ↥((TopologicalSpace.Opens.map f).toPrefunctor.obj U)) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ (f _* F) { val := f ↑x, property := (_ : ↑x ∈ (TopologicalSpace.Opens.map f).toPrefunctor.obj U) }) (TopCat.Presheaf.stalkPushforward C f F ↑x) = TopCat.Presheaf.germ F x

@[simp]

theorem TopCat.Presheaf.stalkPushforward.id (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (ℱ : TopCat.Presheaf C X) (x : ↑X) : TopCat.Presheaf.stalkPushforward C (CategoryTheory.CategoryStruct.id X) ℱ x = (TopCat.Presheaf.stalkFunctor C x).toPrefunctor.map (TopCat.Presheaf.Pushforward.id ℱ).hom

@[simp]

theorem TopCat.Presheaf.stalkPushforward.comp (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} {Z : TopCat} (ℱ : TopCat.Presheaf C X) (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X) : TopCat.Presheaf.stalkPushforward C (CategoryTheory.CategoryStruct.comp f g) ℱ x = CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkPushforward C g (f _* ℱ) (f x)) (TopCat.Presheaf.stalkPushforward C f ℱ x)

theorem TopCat.Presheaf.stalkPushforward.stalkPushforward_iso_of_openEmbedding (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} {f : X ⟶ Y} (hf : OpenEmbedding ⇑f) (F : TopCat.Presheaf C X) (x : ↑X) : CategoryTheory.IsIso (TopCat.Presheaf.stalkPushforward C f F x)

def TopCat.Presheaf.stalkPullbackHom (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C Y) (x : ↑X) : TopCat.Presheaf.stalk F (f x) ⟶ TopCat.Presheaf.stalk (TopCat.Presheaf.pullbackObj f F) x

The morphism ℱ_{f x} ⟶ (f⁻¹ℱ)ₓ that factors through (f_*f⁻¹ℱ)_{f x}.

Equations

• One or more equations did not get rendered due to their size.

def TopCat.Presheaf.germToPullbackStalk (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C Y) (U : TopologicalSpace.Opens ↑X) (x : ↥U) : (TopCat.Presheaf.pullbackObj f F).toPrefunctor.obj (Opposite.op U) ⟶ TopCat.Presheaf.stalk F (f ↑x)

The morphism (f⁻¹ℱ)(U) ⟶ ℱ_{f(x)} for some U ∋ x.

Equations

• One or more equations did not get rendered due to their size.

def TopCat.Presheaf.stalkPullbackInv (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C Y) (x : ↑X) : TopCat.Presheaf.stalk (TopCat.Presheaf.pullbackObj f F) x ⟶ TopCat.Presheaf.stalk F (f x)

The morphism (f⁻¹ℱ)ₓ ⟶ ℱ_{f(x)}.

Equations

• One or more equations did not get rendered due to their size.

def TopCat.Presheaf.stalkPullbackIso (C : Type u) [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C Y) (x : ↑X) : TopCat.Presheaf.stalk F (f x) ≅ TopCat.Presheaf.stalk (TopCat.Presheaf.pullbackObj f F) x

The isomorphism ℱ_{f(x)} ≅ (f⁻¹ℱ)ₓ.

Equations

• TopCat.Presheaf.stalkPullbackIso C f F x = CategoryTheory.Iso.mk (TopCat.Presheaf.stalkPullbackHom C f F x) (TopCat.Presheaf.stalkPullbackInv C f F x)

noncomputable def TopCat.Presheaf.stalkSpecializes {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {x : ↑X} {y : ↑X} (h : x ⤳ y) : TopCat.Presheaf.stalk F y ⟶ TopCat.Presheaf.stalk F x

If x specializes to y, then there is a natural map F.stalk y ⟶ F.stalk x.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem TopCat.Presheaf.germ_stalkSpecializes_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {y : ↥U} {x : ↑X} (h : x ⤳ ↑y) {Z : C} (h : TopCat.Presheaf.stalk F x ⟶ Z) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F y) (CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes F h✝) h) = CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F { val := x, property := (_ : x ∈ ↑U) }) h

theorem TopCat.Presheaf.germ_stalkSpecializes_apply {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {y : ↥U} {x : ↑X} (h : x✝ ⤳ ↑y) [inst : CategoryTheory.ConcreteCategory C] (x : (CategoryTheory.forget C).toPrefunctor.obj ((CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion ↑y).op F).toPrefunctor.obj (Opposite.op { obj := U, property := (_ : ↑y ∈ U) }))) : (CategoryTheory.Limits.colimit.desc (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion ↑y).op F) { pt := CategoryTheory.Limits.colim.toPrefunctor.obj (((CategoryTheory.whiskeringLeft (TopologicalSpace.OpenNhds x✝)ᵒᵖ (TopologicalSpace.Opens ↑X)ᵒᵖ C).toPrefunctor.obj (TopologicalSpace.OpenNhds.inclusion x✝).op).toPrefunctor.obj F), ι := CategoryTheory.NatTrans.mk fun (U_1 : (TopologicalSpace.OpenNhds ↑y)ᵒᵖ) => CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion x✝).op F) (Opposite.op { obj := U_1.unop.obj, property := (_ : x✝ ∈ U_1.unop.obj.carrier) }) }) ((CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion ↑y).op F) (Opposite.op { obj := U, property := (_ : ↑y ∈ U) })) x) = (CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion x✝).op F) (Opposite.op { obj := (Opposite.op { obj := U, property := (_ : ↑y ∈ U) }).unop.obj, property := (_ : x✝ ∈ (Opposite.op { obj := U, property := (_ : ↑y ∈ U) }).unop.obj.carrier) })) x

@[simp]

theorem TopCat.Presheaf.germ_stalkSpecializes {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {y : ↥U} {x : ↑X} (h : x ⤳ ↑y) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F y) (TopCat.Presheaf.stalkSpecializes F h) = TopCat.Presheaf.germ F { val := x, property := (_ : x ∈ ↑U) }

theorem TopCat.Presheaf.germ_stalkSpecializes'_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {x : ↑X} {y : ↑X} (h : x ⤳ y) (hy : y ∈ U) {Z : C} (h : TopCat.Presheaf.stalk F x ⟶ Z) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F { val := y, property := hy }) (CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes F h✝) h) = CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F { val := x, property := (_ : x ∈ ↑U) }) h

theorem TopCat.Presheaf.germ_stalkSpecializes'_apply {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {x : ↑X} {y : ↑X} (h : x✝ ⤳ y) (hy : y ∈ U) [inst : CategoryTheory.ConcreteCategory C] (x : (CategoryTheory.forget C).toPrefunctor.obj ((CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion y).op F).toPrefunctor.obj (Opposite.op { obj := U, property := (_ : ↑{ val := y, property := hy } ∈ U) }))) : (CategoryTheory.Limits.colimit.desc (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion y).op F) { pt := CategoryTheory.Limits.colim.toPrefunctor.obj (((CategoryTheory.whiskeringLeft (TopologicalSpace.OpenNhds x✝)ᵒᵖ (TopologicalSpace.Opens ↑X)ᵒᵖ C).toPrefunctor.obj (TopologicalSpace.OpenNhds.inclusion x✝).op).toPrefunctor.obj F), ι := CategoryTheory.NatTrans.mk fun (U : (TopologicalSpace.OpenNhds y)ᵒᵖ) => CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion x✝).op F) (Opposite.op { obj := U.unop.obj, property := (_ : x✝ ∈ U.unop.obj.carrier) }) }) ((CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion y).op F) (Opposite.op { obj := U, property := (_ : ↑{ val := y, property := hy } ∈ U) })) x) = (CategoryTheory.Limits.colimit.ι (CategoryTheory.Functor.comp (TopologicalSpace.OpenNhds.inclusion x✝).op F) (Opposite.op { obj := (Opposite.op { obj := U, property := (_ : ↑{ val := y, property := hy } ∈ U) }).unop.obj, property := (_ : x✝ ∈ (Opposite.op { obj := U, property := (_ : ↑{ val := y, property := hy } ∈ U) }).unop.obj.carrier) })) x

theorem TopCat.Presheaf.germ_stalkSpecializes' {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {x : ↑X} {y : ↑X} (h : x ⤳ y) (hy : y ∈ U) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.germ F { val := y, property := hy }) (TopCat.Presheaf.stalkSpecializes F h) = TopCat.Presheaf.germ F { val := x, property := (_ : x ∈ ↑U) }

@[simp]

theorem TopCat.Presheaf.stalkSpecializes_refl {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) (x : ↑X) : TopCat.Presheaf.stalkSpecializes F (_ : x ⤳ x) = CategoryTheory.CategoryStruct.id (TopCat.Presheaf.stalk F x)

@[simp]

theorem TopCat.Presheaf.stalkSpecializes_comp_assoc {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {x : ↑X} {y : ↑X} {z : ↑X} (h : x ⤳ y) (h' : y ⤳ z) {Z : C} (h : TopCat.Presheaf.stalk F x ⟶ Z) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes F h') (CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes F h✝) h) = CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes F (_ : x ⤳ z)) h

@[simp]

theorem TopCat.Presheaf.stalkSpecializes_comp_apply {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {x : ↑X} {y : ↑X} {z : ↑X} (h : x✝ ⤳ y) (h' : y ⤳ z) [inst : CategoryTheory.ConcreteCategory C] (x : (CategoryTheory.forget C).toPrefunctor.obj (TopCat.Presheaf.stalk F z)) : (TopCat.Presheaf.stalkSpecializes F h) ((TopCat.Presheaf.stalkSpecializes F h') x) = (TopCat.Presheaf.stalkSpecializes F (_ : x✝ ⤳ z)) x

@[simp]

theorem TopCat.Presheaf.stalkSpecializes_comp {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} (F : TopCat.Presheaf C X) {x : ↑X} {y : ↑X} {z : ↑X} (h : x ⤳ y) (h' : y ⤳ z) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes F h') (TopCat.Presheaf.stalkSpecializes F h) = TopCat.Presheaf.stalkSpecializes F (_ : x ⤳ z)

@[simp]

theorem TopCat.Presheaf.stalkSpecializes_stalkFunctor_map_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {F : TopCat.Presheaf C X} {G : TopCat.Presheaf C X} (f : F ⟶ G) {x : ↑X} {y : ↑X} (h : x ⤳ y) {Z : C} (h : (TopCat.Presheaf.stalkFunctor C x).toPrefunctor.obj G ⟶ Z) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes F h✝) (CategoryTheory.CategoryStruct.comp ((TopCat.Presheaf.stalkFunctor C x).toPrefunctor.map f) h) = CategoryTheory.CategoryStruct.comp ((TopCat.Presheaf.stalkFunctor C y).toPrefunctor.map f) (CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes G h✝) h)

@[simp]

theorem TopCat.Presheaf.stalkSpecializes_stalkFunctor_map_apply {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {F : TopCat.Presheaf C X} {G : TopCat.Presheaf C X} (f : F ⟶ G) {x : ↑X} {y : ↑X} (h : x✝ ⤳ y) [inst : CategoryTheory.ConcreteCategory C] (x : (CategoryTheory.forget C).toPrefunctor.obj (TopCat.Presheaf.stalk F y)) : ((TopCat.Presheaf.stalkFunctor C x✝).toPrefunctor.map f) ((TopCat.Presheaf.stalkSpecializes F h) x) = (TopCat.Presheaf.stalkSpecializes G h) (((TopCat.Presheaf.stalkFunctor C y).toPrefunctor.map f) x)

@[simp]

theorem TopCat.Presheaf.stalkSpecializes_stalkFunctor_map {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {F : TopCat.Presheaf C X} {G : TopCat.Presheaf C X} (f : F ⟶ G) {x : ↑X} {y : ↑X} (h : x ⤳ y) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes F h) ((TopCat.Presheaf.stalkFunctor C x).toPrefunctor.map f) = CategoryTheory.CategoryStruct.comp ((TopCat.Presheaf.stalkFunctor C y).toPrefunctor.map f) (TopCat.Presheaf.stalkSpecializes G h)

theorem TopCat.Presheaf.stalkSpecializes_stalkPushforward_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C X) {x : ↑X} {y : ↑X} (h : x ⤳ y) {Z : C} (h : TopCat.Presheaf.stalk F x ⟶ Z) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes (f _* F) (_ : f x ⤳ f y)) (CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkPushforward C f F x) h) = CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkPushforward C f F y) (CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes F h✝) h)

theorem TopCat.Presheaf.stalkSpecializes_stalkPushforward_apply {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C X) {x : ↑X} {y : ↑X} (h : x✝ ⤳ y) [inst : CategoryTheory.ConcreteCategory C] (x : (CategoryTheory.forget C).toPrefunctor.obj (TopCat.Presheaf.stalk (f _* F) (f y))) : (TopCat.Presheaf.stalkPushforward C f F x✝) ((TopCat.Presheaf.stalkSpecializes (f _* F) (_ : f x✝ ⤳ f y)) x) = (CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkPushforward C f F y) (TopCat.Presheaf.stalkSpecializes F h)) x

@[simp]

theorem TopCat.Presheaf.stalkSpecializes_stalkPushforward {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} {Y : TopCat} (f : X ⟶ Y) (F : TopCat.Presheaf C X) {x : ↑X} {y : ↑X} (h : x ⤳ y) : CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkSpecializes (f _* F) (_ : f x ⤳ f y)) (TopCat.Presheaf.stalkPushforward C f F x) = CategoryTheory.CategoryStruct.comp (TopCat.Presheaf.stalkPushforward C f F y) (TopCat.Presheaf.stalkSpecializes F h)

@[simp]

theorem TopCat.Presheaf.stalkCongr_inv {X : TopCat} {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasColimits C] (F : TopCat.Presheaf C X) {x : ↑X} {y : ↑X} (e : Inseparable x y) : (TopCat.Presheaf.stalkCongr F e).inv = TopCat.Presheaf.stalkSpecializes F (_ : nhds x ≤ nhds y)

@[simp]

theorem TopCat.Presheaf.stalkCongr_hom {X : TopCat} {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasColimits C] (F : TopCat.Presheaf C X) {x : ↑X} {y : ↑X} (e : Inseparable x y) : (TopCat.Presheaf.stalkCongr F e).hom = TopCat.Presheaf.stalkSpecializes F (_ : nhds y ≤ nhds x)

def TopCat.Presheaf.stalkCongr {X : TopCat} {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasColimits C] (F : TopCat.Presheaf C X) {x : ↑X} {y : ↑X} (e : Inseparable x y) : TopCat.Presheaf.stalk F x ≅ TopCat.Presheaf.stalk F y

The stalks are isomorphic on inseparable points

Equations

• TopCat.Presheaf.stalkCongr F e = CategoryTheory.Iso.mk (TopCat.Presheaf.stalkSpecializes F (_ : nhds y ≤ nhds x)) (TopCat.Presheaf.stalkSpecializes F (_ : nhds x ≤ nhds y))

theorem TopCat.Presheaf.germ_ext {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {V : TopologicalSpace.Opens ↑X} {x : ↑X} {hxU : x ∈ U} {hxV : x ∈ V} (W : TopologicalSpace.Opens ↑X) (hxW : x ∈ W) (iWU : W ⟶ U) (iWV : W ⟶ V) {sU : (CategoryTheory.forget C).toPrefunctor.obj (F.toPrefunctor.obj (Opposite.op U))} {sV : (CategoryTheory.forget C).toPrefunctor.obj (F.toPrefunctor.obj (Opposite.op V))} (ih : (F.toPrefunctor.map iWU.op) sU = (F.toPrefunctor.map iWV.op) sV) : (TopCat.Presheaf.germ F { val := x, property := hxU }) sU = (TopCat.Presheaf.germ F { val := x, property := hxV }) sV

theorem TopCat.Presheaf.germ_exist {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] (F : TopCat.Presheaf C X) (x : ↑X) (t : (CategoryTheory.forget C).toPrefunctor.obj (TopCat.Presheaf.stalk F x)) : ∃ (U : TopologicalSpace.Opens ↑X) (m : x ∈ U) (s : (CategoryTheory.forget C).toPrefunctor.obj (F.toPrefunctor.obj (Opposite.op U))), (TopCat.Presheaf.germ F { val := x, property := m }) s = t

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 TopCat.Presheaf.germ_eq {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] (F : TopCat.Presheaf C X) {U : TopologicalSpace.Opens ↑X} {V : TopologicalSpace.Opens ↑X} (x : ↑X) (mU : x ∈ U) (mV : x ∈ V) (s : (CategoryTheory.forget C).toPrefunctor.obj (F.toPrefunctor.obj (Opposite.op U))) (t : (CategoryTheory.forget C).toPrefunctor.obj (F.toPrefunctor.obj (Opposite.op V))) (h : (TopCat.Presheaf.germ F { val := x, property := mU }) s = (TopCat.Presheaf.germ F { val := x, property := mV }) t) : ∃ (W : TopologicalSpace.Opens ↑X) (_ : x ∈ W) (iU : W ⟶ U) (iV : W ⟶ V), (F.toPrefunctor.map iU.op) s = (F.toPrefunctor.map iV.op) t

theorem TopCat.Presheaf.stalkFunctor_map_injective_of_app_injective {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] {F : TopCat.Presheaf C X} {G : TopCat.Presheaf C X} (f : F ⟶ G) (h : ∀ (U : TopologicalSpace.Opens ↑X), Function.Injective ⇑(f.app (Opposite.op U))) (x : ↑X) : Function.Injective ⇑((TopCat.Presheaf.stalkFunctor C x).toPrefunctor.map f)

theorem TopCat.Presheaf.section_ext {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] (F : TopCat.Sheaf C X) (U : TopologicalSpace.Opens ↑X) (s : (CategoryTheory.forget C).toPrefunctor.obj (F.val.toPrefunctor.obj (Opposite.op U))) (t : (CategoryTheory.forget C).toPrefunctor.obj (F.val.toPrefunctor.obj (Opposite.op U))) (h : ∀ (x : ↥U), (TopCat.Presheaf.germ (TopCat.Sheaf.presheaf F) x) s = (TopCat.Presheaf.germ (TopCat.Sheaf.presheaf F) x) t) : s = t

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 TopCat.Presheaf.app_injective_of_stalkFunctor_map_injective {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Presheaf C X} (f : F.val ⟶ G) (U : TopologicalSpace.Opens ↑X) (h : ∀ (x : ↥U), Function.Injective ⇑((TopCat.Presheaf.stalkFunctor C ↑x).toPrefunctor.map f)) : Function.Injective ⇑(f.app (Opposite.op U))

theorem TopCat.Presheaf.app_injective_iff_stalkFunctor_map_injective {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Presheaf C X} (f : F.val ⟶ G) : (∀ (x : ↑X), Function.Injective ⇑((TopCat.Presheaf.stalkFunctor C x).toPrefunctor.map f)) ↔ ∀ (U : TopologicalSpace.Opens ↑X), Function.Injective ⇑(f.app (Opposite.op U))

instance TopCat.Presheaf.stalkFunctor_preserves_mono {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] (x : ↑X) : CategoryTheory.Functor.PreservesMonomorphisms (CategoryTheory.Functor.comp (TopCat.Sheaf.forget C X) (TopCat.Presheaf.stalkFunctor C x))

Equations

• One or more equations did not get rendered due to their size.

theorem TopCat.Presheaf.stalk_mono_of_mono {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Sheaf C X} (f : F ⟶ G) [CategoryTheory.Mono f] (x : ↑X) : CategoryTheory.Mono ((TopCat.Presheaf.stalkFunctor C x).toPrefunctor.map f.val)

theorem TopCat.Presheaf.mono_of_stalk_mono {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Sheaf C X} (f : F ⟶ G) [∀ (x : ↑X), CategoryTheory.Mono ((TopCat.Presheaf.stalkFunctor C x).toPrefunctor.map f.val)] : CategoryTheory.Mono f

theorem TopCat.Presheaf.mono_iff_stalk_mono {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Sheaf C X} (f : F ⟶ G) : CategoryTheory.Mono f ↔ ∀ (x : ↑X), CategoryTheory.Mono ((TopCat.Presheaf.stalkFunctor C x).toPrefunctor.map f.val)

theorem TopCat.Presheaf.app_surjective_of_injective_of_locally_surjective {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Sheaf C X} (f : F ⟶ G) (U : TopologicalSpace.Opens ↑X) (hinj : ∀ (x : ↥U), Function.Injective ⇑((TopCat.Presheaf.stalkFunctor C ↑x).toPrefunctor.map f.val)) (hsurj : ∀ (t : (CategoryTheory.forget C).toPrefunctor.obj (G.val.toPrefunctor.obj (Opposite.op U))) (x : ↥U), ∃ (V : TopologicalSpace.Opens ↑X) (_ : ↑x ∈ V) (iVU : V ⟶ U) (s : (CategoryTheory.forget C).toPrefunctor.obj (F.val.toPrefunctor.obj (Opposite.op V))), (f.val.app (Opposite.op V)) s = (G.val.toPrefunctor.map iVU.op) t) : Function.Surjective ⇑(f.val.app (Opposite.op U))

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 TopCat.Presheaf.app_surjective_of_stalkFunctor_map_bijective {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Sheaf C X} (f : F ⟶ G) (U : TopologicalSpace.Opens ↑X) (h : ∀ (x : ↥U), Function.Bijective ⇑((TopCat.Presheaf.stalkFunctor C ↑x).toPrefunctor.map f.val)) : Function.Surjective ⇑(f.val.app (Opposite.op U))

theorem TopCat.Presheaf.app_bijective_of_stalkFunctor_map_bijective {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Sheaf C X} (f : F ⟶ G) (U : TopologicalSpace.Opens ↑X) (h : ∀ (x : ↥U), Function.Bijective ⇑((TopCat.Presheaf.stalkFunctor C ↑x).toPrefunctor.map f.val)) : Function.Bijective ⇑(f.val.app (Opposite.op U))

theorem TopCat.Presheaf.app_isIso_of_stalkFunctor_map_iso {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Sheaf C X} (f : F ⟶ G) (U : TopologicalSpace.Opens ↑X) [∀ (x : ↥U), CategoryTheory.IsIso ((TopCat.Presheaf.stalkFunctor C ↑x).toPrefunctor.map f.val)] : CategoryTheory.IsIso (f.val.app (Opposite.op U))

theorem TopCat.Presheaf.isIso_of_stalkFunctor_map_iso {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Sheaf C X} (f : F ⟶ G) [∀ (x : ↑X), CategoryTheory.IsIso ((TopCat.Presheaf.stalkFunctor C x).toPrefunctor.map f.val)] : CategoryTheory.IsIso f

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 TopCat.Presheaf.isIso_iff_stalkFunctor_map_iso {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat} [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget C)] [CategoryTheory.Limits.HasLimits C] [CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget C)] [CategoryTheory.ReflectsIsomorphisms (CategoryTheory.forget C)] {F : TopCat.Sheaf C X} {G : TopCat.Sheaf C X} (f : F ⟶ G) : CategoryTheory.IsIso f ↔ ∀ (x : ↑X), CategoryTheory.IsIso ((TopCat.Presheaf.stalkFunctor C x).toPrefunctor.map f.val)

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.

instance TopCat.Presheaf.algebra_section_stalk {X : TopCat} (F : TopCat.Presheaf CommRingCat X) {U : TopologicalSpace.Opens ↑X} (x : ↥U) : Algebra ↑(F.toPrefunctor.obj (Opposite.op U)) ↑(TopCat.Presheaf.stalk F ↑x)

Equations

• TopCat.Presheaf.algebra_section_stalk F x = RingHom.toAlgebra (TopCat.Presheaf.germ F x)

@[simp]

theorem TopCat.Presheaf.stalk_open_algebraMap {X : TopCat} (F : TopCat.Presheaf CommRingCat X) {U : TopologicalSpace.Opens ↑X} (x : ↥U) : algebraMap ↑(F.toPrefunctor.obj (Opposite.op U)) ↑(TopCat.Presheaf.stalk F ↑x) = TopCat.Presheaf.germ F x