Sheaves taking values in a category

If C is a category with a Grothendieck topology, we define the notion of a sheaf taking values in an arbitrary category A. We follow the definition in https://stacks.math.columbia.edu/tag/00VR, noting that the presheaf of sets "defined above" can be seen in the comments between tags 00VQ and 00VR on the page . The advantage of this definition is that we need no assumptions whatsoever on A other than the assumption that the morphisms in C and A live in the same universe.

• An A-valued presheaf P : Cᵒᵖ ⥤ A is defined to be a sheaf (for the topology J) iff for every E : A, the type-valued presheaves of sets given by sending U : Cᵒᵖ to Hom_{A}(E, P U) are all sheaves of sets, see CategoryTheory.Presheaf.IsSheaf.
• When A = Type, this recovers the basic definition of sheaves of sets, see CategoryTheory.isSheaf_iff_isSheaf_of_type.
• A alternate definition in terms of limits, unconditionally equivalent to the original one: see CategoryTheory.Presheaf.isSheaf_iff_isLimit.
• An alternate definition when C is small, has pullbacks and A has products is given by an equalizer condition CategoryTheory.Presheaf.IsSheaf'. This is equivalent to the earlier definition, shown in CategoryTheory.Presheaf.isSheaf_iff_isSheaf'.
• When A = Type, this is definitionally equal to the equalizer condition for presieves in CategoryTheory.Sites.SheafOfTypes.
• When A has limits and there is a functor s : A ⥤ Type which is faithful, reflects isomorphisms and preserves limits, then P : Cᵒᵖ ⥤ A is a sheaf iff the underlying presheaf of types P ⋙ s : Cᵒᵖ ⥤ Type is a sheaf (CategoryTheory.Presheaf.isSheaf_iff_isSheaf_forget). Cf https://stacks.math.columbia.edu/tag/0073, which is a weaker version of this statement (it's only over spaces, not sites) and https://stacks.math.columbia.edu/tag/00YR (a), which additionally assumes filtered colimits.

Implementation notes

Occasionally we need to take a limit in A of a collection of morphisms of C indexed by a collection of objects in C. This turns out to force the morphisms of A to be in a sufficiently large universe. Rather than use UnivLE we prove some results for a category A' instead, whose morphism universe of A' is defined to be max u₁ v₁, where u₁, v₁ are the universes for C. Perhaps after we get better at handling universe inequalities this can be changed.

def CategoryTheory.Presheaf.IsSheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) : Prop

A sheaf of A is a presheaf P : Cᵒᵖ => A such that for every E : A, the presheaf of types given by sending U : C to Hom_{A}(E, P U) is a sheaf of types.

https://stacks.math.columbia.edu/tag/00VR

Equations

• CategoryTheory.Presheaf.IsSheaf J P = ∀ (E : A), CategoryTheory.Presieve.IsSheaf J (CategoryTheory.Functor.comp P (CategoryTheory.coyoneda.toPrefunctor.obj (Opposite.op E)))

@[simp]

theorem CategoryTheory.Presheaf.conesEquivSieveCompatibleFamily_apply_coe {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.Sieve X) (E : Aᵒᵖ) (π : (CategoryTheory.Functor.cones (CategoryTheory.Functor.comp (CategoryTheory.Presieve.diagram S.arrows).op P)).toPrefunctor.obj E) (Y : C) (f : Y ⟶ X) (h : S.arrows f) : ↑((CategoryTheory.Presheaf.conesEquivSieveCompatibleFamily P S E) π) f h = π.app (Opposite.op { obj := CategoryTheory.Over.mk f, property := h })

@[simp]

theorem CategoryTheory.Presheaf.conesEquivSieveCompatibleFamily_symm_apply_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.Sieve X) (E : Aᵒᵖ) (x : { x : CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.Functor.comp P (CategoryTheory.coyoneda.toPrefunctor.obj E)) S.arrows // CategoryTheory.Presieve.FamilyOfElements.SieveCompatible x }) (f : (CategoryTheory.FullSubcategory fun (f : CategoryTheory.Over X) => S.arrows f.hom)ᵒᵖ) : ((CategoryTheory.Presheaf.conesEquivSieveCompatibleFamily P S E).symm x).app f = ↑x f.unop.obj.hom (_ : S.arrows f.unop.obj.hom)

def CategoryTheory.Presheaf.conesEquivSieveCompatibleFamily {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.Sieve X) (E : Aᵒᵖ) : (CategoryTheory.Functor.cones (CategoryTheory.Functor.comp (CategoryTheory.Presieve.diagram S.arrows).op P)).toPrefunctor.obj E ≃ { x : CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.Functor.comp P (CategoryTheory.coyoneda.toPrefunctor.obj E)) S.arrows // CategoryTheory.Presieve.FamilyOfElements.SieveCompatible x }

Given a sieve S on X : C, a presheaf P : Cᵒᵖ ⥤ A, and an object E of A, the cones over the natural diagram S.arrows.diagram.op ⋙ P associated to S and P with cone point E are in 1-1 correspondence with sieve_compatible family of elements for the sieve S and the presheaf of types Hom (E, P -).

Equations

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

def CategoryTheory.Presieve.FamilyOfElements.SieveCompatible.cone {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {P : CategoryTheory.Functor Cᵒᵖ A} {X : C} {S : CategoryTheory.Sieve X} {E : Aᵒᵖ} {x : CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.Functor.comp P (CategoryTheory.coyoneda.toPrefunctor.obj E)) S.arrows} (hx : CategoryTheory.Presieve.FamilyOfElements.SieveCompatible x) : CategoryTheory.Limits.Cone (CategoryTheory.Functor.comp (CategoryTheory.Presieve.diagram S.arrows).op P)

The cone corresponding to a sieve_compatible family of elements, dot notation enabled.

Equations

• CategoryTheory.Presieve.FamilyOfElements.SieveCompatible.cone hx = { pt := E.unop, π := (CategoryTheory.Presheaf.conesEquivSieveCompatibleFamily P S E).invFun { val := x, property := hx } }

def CategoryTheory.Presheaf.homEquivAmalgamation {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {P : CategoryTheory.Functor Cᵒᵖ A} {X : C} {S : CategoryTheory.Sieve X} {E : Aᵒᵖ} {x : CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.Functor.comp P (CategoryTheory.coyoneda.toPrefunctor.obj E)) S.arrows} (hx : CategoryTheory.Presieve.FamilyOfElements.SieveCompatible x) : (CategoryTheory.Presieve.FamilyOfElements.SieveCompatible.cone hx ⟶ P.mapCone (CategoryTheory.Limits.Cocone.op (CategoryTheory.Presieve.cocone S.arrows))) ≃ { t : (CategoryTheory.Functor.comp P (CategoryTheory.coyoneda.toPrefunctor.obj E)).toPrefunctor.obj (Opposite.op X) // CategoryTheory.Presieve.FamilyOfElements.IsAmalgamation x t }

Cone morphisms from the cone corresponding to a sieve_compatible family to the natural cone associated to a sieve S and a presheaf P are in 1-1 correspondence with amalgamations of the family.

Equations

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

theorem CategoryTheory.Presheaf.isLimit_iff_isSheafFor {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.Sieve X) : Nonempty (CategoryTheory.Limits.IsLimit (P.mapCone (CategoryTheory.Limits.Cocone.op (CategoryTheory.Presieve.cocone S.arrows)))) ↔ ∀ (E : Aᵒᵖ), CategoryTheory.Presieve.IsSheafFor (CategoryTheory.Functor.comp P (CategoryTheory.coyoneda.toPrefunctor.obj E)) S.arrows

Given sieve S and presheaf P : Cᵒᵖ ⥤ A, their natural associated cone is a limit cone iff Hom (E, P -) is a sheaf of types for the sieve S and all E : A.

theorem CategoryTheory.Presheaf.subsingleton_iff_isSeparatedFor {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.Sieve X) : (∀ (c : CategoryTheory.Limits.Cone (CategoryTheory.Functor.comp (CategoryTheory.Presieve.diagram S.arrows).op P)), Subsingleton (c ⟶ P.mapCone (CategoryTheory.Limits.Cocone.op (CategoryTheory.Presieve.cocone S.arrows)))) ↔ ∀ (E : Aᵒᵖ), CategoryTheory.Presieve.IsSeparatedFor (CategoryTheory.Functor.comp P (CategoryTheory.coyoneda.toPrefunctor.obj E)) S.arrows

Given sieve S and presheaf P : Cᵒᵖ ⥤ A, their natural associated cone admits at most one morphism from every cone in the same category (i.e. over the same diagram), iff Hom (E, P -)is separated for the sieve S and all E : A.

theorem CategoryTheory.Presheaf.isSheaf_iff_isLimit {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) : CategoryTheory.Presheaf.IsSheaf J P ↔ ∀ ⦃X : C⦄, ∀ S ∈ J.sieves X, Nonempty (CategoryTheory.Limits.IsLimit (P.mapCone (CategoryTheory.Limits.Cocone.op (CategoryTheory.Presieve.cocone S.arrows))))

A presheaf P is a sheaf for the Grothendieck topology J iff for every covering sieve S of J, the natural cone associated to P and S is a limit cone.

theorem CategoryTheory.Presheaf.isSeparated_iff_subsingleton {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) : (∀ (E : A), CategoryTheory.Presieve.IsSeparated J (CategoryTheory.Functor.comp P (CategoryTheory.coyoneda.toPrefunctor.obj (Opposite.op E)))) ↔ ∀ ⦃X : C⦄, ∀ S ∈ J.sieves X, ∀ (c : CategoryTheory.Limits.Cone (CategoryTheory.Functor.comp (CategoryTheory.Presieve.diagram S.arrows).op P)), Subsingleton (c ⟶ P.mapCone (CategoryTheory.Limits.Cocone.op (CategoryTheory.Presieve.cocone S.arrows)))

A presheaf P is separated for the Grothendieck topology J iff for every covering sieve S of J, the natural cone associated to P and S admits at most one morphism from every cone in the same category.

theorem CategoryTheory.Presheaf.isLimit_iff_isSheafFor_presieve {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (R : CategoryTheory.Presieve X) : Nonempty (CategoryTheory.Limits.IsLimit (P.mapCone (CategoryTheory.Limits.Cocone.op (CategoryTheory.Presieve.cocone (CategoryTheory.Sieve.generate R).arrows)))) ↔ ∀ (E : Aᵒᵖ), CategoryTheory.Presieve.IsSheafFor (CategoryTheory.Functor.comp P (CategoryTheory.coyoneda.toPrefunctor.obj E)) R

Given presieve R and presheaf P : Cᵒᵖ ⥤ A, the natural cone associated to P and the sieve Sieve.generate R generated by R is a limit cone iff Hom (E, P -) is a sheaf of types for the presieve R and all E : A.

theorem CategoryTheory.Presheaf.isSheaf_iff_isLimit_pretopology {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (P : CategoryTheory.Functor Cᵒᵖ A) [CategoryTheory.Limits.HasPullbacks C] (K : CategoryTheory.Pretopology C) : CategoryTheory.Presheaf.IsSheaf (CategoryTheory.Pretopology.toGrothendieck C K) P ↔ ∀ ⦃X : C⦄, ∀ R ∈ K.coverings X, Nonempty (CategoryTheory.Limits.IsLimit (P.mapCone (CategoryTheory.Limits.Cocone.op (CategoryTheory.Presieve.cocone (CategoryTheory.Sieve.generate R).arrows))))

A presheaf P is a sheaf for the Grothendieck topology generated by a pretopology K iff for every covering presieve R of K, the natural cone associated to P and Sieve.generate R is a limit cone.

def CategoryTheory.Presheaf.IsSheaf.amalgamate {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {E : A} {X : C} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : CategoryTheory.Presheaf.IsSheaf J P) (S : CategoryTheory.GrothendieckTopology.Cover J X) (x : (I : CategoryTheory.GrothendieckTopology.Cover.Arrow S) → E ⟶ P.toPrefunctor.obj (Opposite.op I.Y)) (hx : ∀ (I : CategoryTheory.GrothendieckTopology.Cover.Relation S), CategoryTheory.CategoryStruct.comp (x (CategoryTheory.GrothendieckTopology.Cover.Relation.fst I)) (P.toPrefunctor.map I.g₁.op) = CategoryTheory.CategoryStruct.comp (x (CategoryTheory.GrothendieckTopology.Cover.Relation.snd I)) (P.toPrefunctor.map I.g₂.op)) : E ⟶ P.toPrefunctor.obj (Opposite.op X)

This is a wrapper around Presieve.IsSheafFor.amalgamate to be used below. If Ps a sheaf, S is a cover of X, and x is a collection of morphisms from E to P evaluated at terms in the cover which are compatible, then we can amalgamate the xs to obtain a single morphism E ⟶ P.obj (op X).

Equations

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

@[simp]

theorem CategoryTheory.Presheaf.IsSheaf.amalgamate_map_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {E : A} {X : C} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : CategoryTheory.Presheaf.IsSheaf J P) (S : CategoryTheory.GrothendieckTopology.Cover J X) (x : (I : CategoryTheory.GrothendieckTopology.Cover.Arrow S) → E ⟶ P.toPrefunctor.obj (Opposite.op I.Y)) (hx : ∀ (I : CategoryTheory.GrothendieckTopology.Cover.Relation S), CategoryTheory.CategoryStruct.comp (x (CategoryTheory.GrothendieckTopology.Cover.Relation.fst I)) (P.toPrefunctor.map I.g₁.op) = CategoryTheory.CategoryStruct.comp (x (CategoryTheory.GrothendieckTopology.Cover.Relation.snd I)) (P.toPrefunctor.map I.g₂.op)) (I : CategoryTheory.GrothendieckTopology.Cover.Arrow S) {Z : A} (h : P.toPrefunctor.obj (Opposite.op I.Y) ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.IsSheaf.amalgamate hP S x hx) (CategoryTheory.CategoryStruct.comp (P.toPrefunctor.map I.f.op) h) = CategoryTheory.CategoryStruct.comp (x I) h

@[simp]

theorem CategoryTheory.Presheaf.IsSheaf.amalgamate_map {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {E : A} {X : C} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : CategoryTheory.Presheaf.IsSheaf J P) (S : CategoryTheory.GrothendieckTopology.Cover J X) (x : (I : CategoryTheory.GrothendieckTopology.Cover.Arrow S) → E ⟶ P.toPrefunctor.obj (Opposite.op I.Y)) (hx : ∀ (I : CategoryTheory.GrothendieckTopology.Cover.Relation S), CategoryTheory.CategoryStruct.comp (x (CategoryTheory.GrothendieckTopology.Cover.Relation.fst I)) (P.toPrefunctor.map I.g₁.op) = CategoryTheory.CategoryStruct.comp (x (CategoryTheory.GrothendieckTopology.Cover.Relation.snd I)) (P.toPrefunctor.map I.g₂.op)) (I : CategoryTheory.GrothendieckTopology.Cover.Arrow S) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.IsSheaf.amalgamate hP S x hx) (P.toPrefunctor.map I.f.op) = x I

theorem CategoryTheory.Presheaf.IsSheaf.hom_ext {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {E : A} {X : C} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : CategoryTheory.Presheaf.IsSheaf J P) (S : CategoryTheory.GrothendieckTopology.Cover J X) (e₁ : E ⟶ P.toPrefunctor.obj (Opposite.op X)) (e₂ : E ⟶ P.toPrefunctor.obj (Opposite.op X)) (h : ∀ (I : CategoryTheory.GrothendieckTopology.Cover.Arrow S), CategoryTheory.CategoryStruct.comp e₁ (P.toPrefunctor.map I.f.op) = CategoryTheory.CategoryStruct.comp e₂ (P.toPrefunctor.map I.f.op)) : e₁ = e₂

theorem CategoryTheory.Presheaf.isSheaf_of_iso_iff {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C} {P : CategoryTheory.Functor Cᵒᵖ A} {P' : CategoryTheory.Functor Cᵒᵖ A} (e : P ≅ P') : CategoryTheory.Presheaf.IsSheaf J P ↔ CategoryTheory.Presheaf.IsSheaf J P'

theorem CategoryTheory.Presheaf.isSheaf_of_isTerminal {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) {X : A} (hX : CategoryTheory.Limits.IsTerminal X) : CategoryTheory.Presheaf.IsSheaf J ((CategoryTheory.Functor.const Cᵒᵖ).toPrefunctor.obj X)

structure CategoryTheory.Sheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] : Type (max (max (max u₁ u₂) v₁) v₂)

The category of sheaves taking values in A on a grothendieck topology.

• val : CategoryTheory.Functor Cᵒᵖ A

  the underlying presheaf

• cond : CategoryTheory.Presheaf.IsSheaf J self.val

  the condition that the presheaf is a sheaf

theorem CategoryTheory.Sheaf.Hom.ext {C : Type u₁} : ∀ {inst : CategoryTheory.Category.{v₁, u₁} C} {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} A} {X Y : CategoryTheory.Sheaf J A} (x y : CategoryTheory.Sheaf.Hom X Y), x.val = y.val → x = y

theorem CategoryTheory.Sheaf.Hom.ext_iff {C : Type u₁} : ∀ {inst : CategoryTheory.Category.{v₁, u₁} C} {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} A} {X Y : CategoryTheory.Sheaf J A} (x y : CategoryTheory.Sheaf.Hom X Y), x = y ↔ x.val = y.val

structure CategoryTheory.Sheaf.Hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (X : CategoryTheory.Sheaf J A) (Y : CategoryTheory.Sheaf J A) : Type (max u₁ v₂)

Morphisms between sheaves are just morphisms of presheaves.

• val : X.val ⟶ Y.val

  a morphism between the underlying presheaves

@[simp]

theorem CategoryTheory.Sheaf.instCategorySheaf_id_val {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] : ∀ (x : CategoryTheory.Sheaf J A), (CategoryTheory.CategoryStruct.id x).val = CategoryTheory.CategoryStruct.id x.val

@[simp]

theorem CategoryTheory.Sheaf.instCategorySheaf_comp_val {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] : ∀ {X Y Z : CategoryTheory.Sheaf J A} (f : X ⟶ Y) (g : Y ⟶ Z), (CategoryTheory.CategoryStruct.comp f g).val = CategoryTheory.CategoryStruct.comp f.val g.val

instance CategoryTheory.Sheaf.instCategorySheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] : CategoryTheory.Category.{max u₁ v₂, max (max (max u₂ u₁) v₂) v₁} (CategoryTheory.Sheaf J A)

Equations

• CategoryTheory.Sheaf.instCategorySheaf = CategoryTheory.Category.mk

instance CategoryTheory.Sheaf.instInhabitedHom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (X : CategoryTheory.Sheaf J A) : Inhabited (CategoryTheory.Sheaf.Hom X X)

Equations

• CategoryTheory.Sheaf.instInhabitedHom X = { default := CategoryTheory.CategoryStruct.id X }

theorem CategoryTheory.Sheaf.hom_ext {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {X : CategoryTheory.Sheaf J A} {Y : CategoryTheory.Sheaf J A} (x : X ⟶ Y) (y : X ⟶ Y) (h : x.val = y.val) : x = y

@[simp]

theorem CategoryTheory.sheafToPresheaf_obj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] (self : CategoryTheory.Sheaf J A) : (CategoryTheory.sheafToPresheaf J A).toPrefunctor.obj self = self.val

@[simp]

theorem CategoryTheory.sheafToPresheaf_map {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] : ∀ {X Y : CategoryTheory.Sheaf J A} (f : X ⟶ Y), (CategoryTheory.sheafToPresheaf J A).toPrefunctor.map f = f.val

def CategoryTheory.sheafToPresheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] : CategoryTheory.Functor (CategoryTheory.Sheaf J A) (CategoryTheory.Functor Cᵒᵖ A)

The inclusion functor from sheaves to presheaves.

Equations

• CategoryTheory.sheafToPresheaf J A = CategoryTheory.Functor.mk { obj := CategoryTheory.Sheaf.val, map := fun {X Y : CategoryTheory.Sheaf J A} (f : X ⟶ Y) => f.val }

@[inline, reducible]

abbrev CategoryTheory.sheafSections {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] : CategoryTheory.Functor Cᵒᵖ (CategoryTheory.Functor (CategoryTheory.Sheaf J A) A)

The sections of a sheaf (i.e. evaluation as a presheaf on C).

Equations

• CategoryTheory.sheafSections J A = CategoryTheory.Functor.flip (CategoryTheory.sheafToPresheaf J A)

instance CategoryTheory.instFullSheafInstCategorySheafFunctorOppositeOppositeCategorySheafToPresheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] : CategoryTheory.Full (CategoryTheory.sheafToPresheaf J A)

Equations

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

instance CategoryTheory.instFaithfulSheafInstCategorySheafFunctorOppositeOppositeCategorySheafToPresheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] : CategoryTheory.Faithful (CategoryTheory.sheafToPresheaf J A)

Equations

• (_ : CategoryTheory.Faithful (CategoryTheory.sheafToPresheaf J A)) = (_ : CategoryTheory.Faithful (CategoryTheory.sheafToPresheaf J A))

theorem CategoryTheory.Sheaf.Hom.mono_of_presheaf_mono {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] {F : CategoryTheory.Sheaf J A} {G : CategoryTheory.Sheaf J A} (f : F ⟶ G) [h : CategoryTheory.Mono f.val] : CategoryTheory.Mono f

This is stated as a lemma to prevent class search from forming a loop since a sheaf morphism is monic if and only if it is monic as a presheaf morphism (under suitable assumption).

instance CategoryTheory.Sheaf.Hom.epi_of_presheaf_epi {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (A : Type u₂) [CategoryTheory.Category.{v₂, u₂} A] {F : CategoryTheory.Sheaf J A} {G : CategoryTheory.Sheaf J A} (f : F ⟶ G) [h : CategoryTheory.Epi f.val] : CategoryTheory.Epi f

Equations

• (_ : CategoryTheory.Epi f) = (_ : CategoryTheory.Epi f)

@[simp]

theorem CategoryTheory.sheafOver_val {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C} (ℱ : CategoryTheory.Sheaf J A) (E : A) : (CategoryTheory.sheafOver ℱ E).val = CategoryTheory.Functor.comp ℱ.val (CategoryTheory.coyoneda.toPrefunctor.obj (Opposite.op E))

def CategoryTheory.sheafOver {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {J : CategoryTheory.GrothendieckTopology C} (ℱ : CategoryTheory.Sheaf J A) (E : A) : CategoryTheory.SheafOfTypes J

The sheaf of sections guaranteed by the sheaf condition.

Equations

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

theorem CategoryTheory.isSheaf_iff_isSheaf_of_type {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ (Type w)) : CategoryTheory.Presheaf.IsSheaf J P ↔ CategoryTheory.Presieve.IsSheaf J P

@[simp]

theorem CategoryTheory.sheafEquivSheafOfTypes_unitIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) : (CategoryTheory.sheafEquivSheafOfTypes J).unitIso = CategoryTheory.NatIso.ofComponents fun (X : CategoryTheory.Sheaf J (Type w)) => CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Sheaf J (Type w))).toPrefunctor.obj X)

@[simp]

theorem CategoryTheory.sheafEquivSheafOfTypes_inverse_obj_val {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (S : CategoryTheory.SheafOfTypes J) : ((CategoryTheory.sheafEquivSheafOfTypes J).inverse.toPrefunctor.obj S).val = S.val

@[simp]

theorem CategoryTheory.sheafEquivSheafOfTypes_counitIso {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) : (CategoryTheory.sheafEquivSheafOfTypes J).counitIso = CategoryTheory.NatIso.ofComponents fun (X : CategoryTheory.SheafOfTypes J) => CategoryTheory.Iso.refl ((CategoryTheory.Functor.comp (CategoryTheory.Functor.mk { obj := fun (S : CategoryTheory.SheafOfTypes J) => { val := S.val, cond := (_ : CategoryTheory.Presheaf.IsSheaf J S.val) }, map := fun {X Y : CategoryTheory.SheafOfTypes J} (f : X ⟶ Y) => { val := f.val } }) (CategoryTheory.Functor.mk { obj := fun (S : CategoryTheory.Sheaf J (Type w)) => { val := S.val, cond := (_ : CategoryTheory.Presieve.IsSheaf J S.val) }, map := fun {X Y : CategoryTheory.Sheaf J (Type w)} (f : X ⟶ Y) => { val := f.val } })).toPrefunctor.obj X)

@[simp]

theorem CategoryTheory.sheafEquivSheafOfTypes_inverse_map_val {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) : ∀ {X Y : CategoryTheory.SheafOfTypes J} (f : X ⟶ Y), ((CategoryTheory.sheafEquivSheafOfTypes J).inverse.toPrefunctor.map f).val = f.val

@[simp]

theorem CategoryTheory.sheafEquivSheafOfTypes_functor_obj_val {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) (S : CategoryTheory.Sheaf J (Type w)) : ((CategoryTheory.sheafEquivSheafOfTypes J).functor.toPrefunctor.obj S).val = S.val

@[simp]

theorem CategoryTheory.sheafEquivSheafOfTypes_functor_map_val {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) : ∀ {X Y : CategoryTheory.Sheaf J (Type w)} (f : X ⟶ Y), ((CategoryTheory.sheafEquivSheafOfTypes J).functor.toPrefunctor.map f).val = f.val

def CategoryTheory.sheafEquivSheafOfTypes {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) : CategoryTheory.Sheaf J (Type w) ≌ CategoryTheory.SheafOfTypes J

The category of sheaves taking values in Type is the same as the category of set-valued sheaves.

Equations

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

instance CategoryTheory.instInhabitedSheafBotGrothendieckTopologyToBotInstCompleteLatticeGrothendieckTopologyTypeTypes {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] : Inhabited (CategoryTheory.Sheaf ⊥ (Type w))

Equations

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

def CategoryTheory.Sheaf.isTerminalOfBotCover {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (F : CategoryTheory.Sheaf J A) (X : C) (H : ⊥ ∈ J.sieves X) : CategoryTheory.Limits.IsTerminal (F.val.toPrefunctor.obj (Opposite.op X))

If the empty sieve is a cover of X, then F(X) is terminal.

Equations

• CategoryTheory.Sheaf.isTerminalOfBotCover F X H = CategoryTheory.Limits.IsTerminal.ofUnique (F.val.toPrefunctor.obj (Opposite.op X))

instance CategoryTheory.sheafHomHasZSMul {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Preadditive A] {P : CategoryTheory.Sheaf J A} {Q : CategoryTheory.Sheaf J A} : SMul ℤ (P ⟶ Q)

Equations

• CategoryTheory.sheafHomHasZSMul = { smul := fun (n : ℤ) (f : P ⟶ Q) => { val := CategoryTheory.NatTrans.mk fun (U : Cᵒᵖ) => n • f.val.app U } }

instance CategoryTheory.instSubHomSheafToQuiverToCategoryStructInstCategorySheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Preadditive A] {P : CategoryTheory.Sheaf J A} {Q : CategoryTheory.Sheaf J A} : Sub (P ⟶ Q)

Equations

• CategoryTheory.instSubHomSheafToQuiverToCategoryStructInstCategorySheaf = { sub := fun (f g : P ⟶ Q) => { val := f.val - g.val } }

instance CategoryTheory.instNegHomSheafToQuiverToCategoryStructInstCategorySheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Preadditive A] {P : CategoryTheory.Sheaf J A} {Q : CategoryTheory.Sheaf J A} : Neg (P ⟶ Q)

Equations

• CategoryTheory.instNegHomSheafToQuiverToCategoryStructInstCategorySheaf = { neg := fun (f : P ⟶ Q) => { val := -f.val } }

instance CategoryTheory.sheafHomHasNSMul {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Preadditive A] {P : CategoryTheory.Sheaf J A} {Q : CategoryTheory.Sheaf J A} : SMul ℕ (P ⟶ Q)

Equations

• CategoryTheory.sheafHomHasNSMul = { smul := fun (n : ℕ) (f : P ⟶ Q) => { val := CategoryTheory.NatTrans.mk fun (U : Cᵒᵖ) => n • f.val.app U } }

instance CategoryTheory.instZeroHomSheafToQuiverToCategoryStructInstCategorySheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Preadditive A] {P : CategoryTheory.Sheaf J A} {Q : CategoryTheory.Sheaf J A} : Zero (P ⟶ Q)

Equations

• CategoryTheory.instZeroHomSheafToQuiverToCategoryStructInstCategorySheaf = { zero := { val := 0 } }

instance CategoryTheory.instAddHomSheafToQuiverToCategoryStructInstCategorySheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Preadditive A] {P : CategoryTheory.Sheaf J A} {Q : CategoryTheory.Sheaf J A} : Add (P ⟶ Q)

Equations

• CategoryTheory.instAddHomSheafToQuiverToCategoryStructInstCategorySheaf = { add := fun (f g : P ⟶ Q) => { val := f.val + g.val } }

@[simp]

theorem CategoryTheory.Sheaf.Hom.add_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Preadditive A] {P : CategoryTheory.Sheaf J A} {Q : CategoryTheory.Sheaf J A} (f : P ⟶ Q) (g : P ⟶ Q) (U : Cᵒᵖ) : (f + g).val.app U = f.val.app U + g.val.app U

instance CategoryTheory.Sheaf.Hom.addCommGroup {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Preadditive A] {P : CategoryTheory.Sheaf J A} {Q : CategoryTheory.Sheaf J A} : AddCommGroup (P ⟶ Q)

Equations

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

instance CategoryTheory.instPreadditiveSheafInstCategorySheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Preadditive A] : CategoryTheory.Preadditive (CategoryTheory.Sheaf J A)

Equations

• CategoryTheory.instPreadditiveSheafInstCategorySheaf = CategoryTheory.Preadditive.mk

def CategoryTheory.Presheaf.isLimitOfIsSheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) {X : C} (S : CategoryTheory.GrothendieckTopology.Cover J X) (hP : CategoryTheory.Presheaf.IsSheaf J P) : CategoryTheory.Limits.IsLimit (CategoryTheory.GrothendieckTopology.Cover.multifork S P)

When P is a sheaf and S is a cover, the associated multifork is a limit.

Equations

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

theorem CategoryTheory.Presheaf.isSheaf_iff_multifork {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) : CategoryTheory.Presheaf.IsSheaf J P ↔ ∀ (X : C) (S : CategoryTheory.GrothendieckTopology.Cover J X), Nonempty (CategoryTheory.Limits.IsLimit (CategoryTheory.GrothendieckTopology.Cover.multifork S P))

theorem CategoryTheory.Presheaf.isSheaf_iff_multiequalizer {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) [∀ (X : C) (S : CategoryTheory.GrothendieckTopology.Cover J X), CategoryTheory.Limits.HasMultiequalizer (CategoryTheory.GrothendieckTopology.Cover.index S P)] : CategoryTheory.Presheaf.IsSheaf J P ↔ ∀ (X : C) (S : CategoryTheory.GrothendieckTopology.Cover J X), CategoryTheory.IsIso (CategoryTheory.GrothendieckTopology.Cover.toMultiequalizer S P)

def CategoryTheory.Presheaf.firstObj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {U : C} (R : CategoryTheory.Presieve U) (P : CategoryTheory.Functor Cᵒᵖ A) [CategoryTheory.Limits.HasProducts A] : A

The middle object of the fork diagram given in Equation (3) of [MM92], as well as the fork diagram of .

Equations

• CategoryTheory.Presheaf.firstObj R P = ∏ fun (f : (V : C) × { f : V ⟶ U // R f }) => P.toPrefunctor.obj (Opposite.op f.fst)

def CategoryTheory.Presheaf.forkMap {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {U : C} (R : CategoryTheory.Presieve U) (P : CategoryTheory.Functor Cᵒᵖ A) [CategoryTheory.Limits.HasProducts A] : P.toPrefunctor.obj (Opposite.op U) ⟶ CategoryTheory.Presheaf.firstObj R P

The left morphism of the fork diagram given in Equation (3) of [MM92], as well as the fork diagram of .

Equations

• CategoryTheory.Presheaf.forkMap R P = CategoryTheory.Limits.Pi.lift fun (f : (V : C) × { f : V ⟶ U // R f }) => P.toPrefunctor.map (↑f.snd).op

def CategoryTheory.Presheaf.secondObj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {U : C} (R : CategoryTheory.Presieve U) (P : CategoryTheory.Functor Cᵒᵖ A) [CategoryTheory.Limits.HasProducts A] [CategoryTheory.Limits.HasPullbacks C] : A

The rightmost object of the fork diagram of https://stacks.math.columbia.edu/tag/00VM, which contains the data used to check a family of elements for a presieve is compatible.

Equations

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

def CategoryTheory.Presheaf.firstMap {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {U : C} (R : CategoryTheory.Presieve U) (P : CategoryTheory.Functor Cᵒᵖ A) [CategoryTheory.Limits.HasProducts A] [CategoryTheory.Limits.HasPullbacks C] : CategoryTheory.Presheaf.firstObj R P ⟶ CategoryTheory.Presheaf.secondObj R P

The map pr₀* of .

Equations

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

def CategoryTheory.Presheaf.secondMap {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {U : C} (R : CategoryTheory.Presieve U) (P : CategoryTheory.Functor Cᵒᵖ A) [CategoryTheory.Limits.HasProducts A] [CategoryTheory.Limits.HasPullbacks C] : CategoryTheory.Presheaf.firstObj R P ⟶ CategoryTheory.Presheaf.secondObj R P

The map pr₁* of .

Equations

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

theorem CategoryTheory.Presheaf.w {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {U : C} (R : CategoryTheory.Presieve U) (P : CategoryTheory.Functor Cᵒᵖ A) [CategoryTheory.Limits.HasProducts A] [CategoryTheory.Limits.HasPullbacks C] : CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.forkMap R P) (CategoryTheory.Presheaf.firstMap R P) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.forkMap R P) (CategoryTheory.Presheaf.secondMap R P)

def CategoryTheory.Presheaf.IsSheaf' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] (J : CategoryTheory.GrothendieckTopology C) [CategoryTheory.Limits.HasProducts A] [CategoryTheory.Limits.HasPullbacks C] (P : CategoryTheory.Functor Cᵒᵖ A) : Prop

An alternative definition of the sheaf condition in terms of equalizers. This is shown to be equivalent in CategoryTheory.Presheaf.isSheaf_iff_isSheaf'.

Equations

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

def CategoryTheory.Presheaf.isSheafForIsSheafFor' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] [CategoryTheory.Limits.HasProducts A] [CategoryTheory.Limits.HasPullbacks C] (P : CategoryTheory.Functor Cᵒᵖ A) (s : CategoryTheory.Functor A (Type (max v₁ u₁))) [(J : Type (max v₁ u₁)) → CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete J) s] (U : C) (R : CategoryTheory.Presieve U) : CategoryTheory.Limits.IsLimit (s.mapCone (CategoryTheory.Limits.Fork.ofι (CategoryTheory.Presheaf.forkMap R P) (_ : CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.forkMap R P) (CategoryTheory.Presheaf.firstMap R P) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Presheaf.forkMap R P) (CategoryTheory.Presheaf.secondMap R P)))) ≃ CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fork.ofι (CategoryTheory.Equalizer.forkMap (CategoryTheory.Functor.comp P s) R) (_ : CategoryTheory.CategoryStruct.comp (CategoryTheory.Equalizer.forkMap (CategoryTheory.Functor.comp P s) R) (CategoryTheory.Equalizer.Presieve.firstMap (CategoryTheory.Functor.comp P s) R) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Equalizer.forkMap (CategoryTheory.Functor.comp P s) R) (CategoryTheory.Equalizer.Presieve.secondMap (CategoryTheory.Functor.comp P s) R)))

(Implementation). An auxiliary lemma to convert between sheaf conditions.

Equations

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

theorem CategoryTheory.Presheaf.isSheaf_iff_isSheaf' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A' : Type u₂} [CategoryTheory.Category.{max v₁ u₁, u₂} A'] (J : CategoryTheory.GrothendieckTopology C) (P' : CategoryTheory.Functor Cᵒᵖ A') [CategoryTheory.Limits.HasProducts A'] [CategoryTheory.Limits.HasPullbacks C] : CategoryTheory.Presheaf.IsSheaf J P' ↔ CategoryTheory.Presheaf.IsSheaf' J P'

The equalizer definition of a sheaf given by isSheaf' is equivalent to isSheaf.

theorem CategoryTheory.Presheaf.isSheaf_of_isSheaf_comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) (s : CategoryTheory.Functor A B) [CategoryTheory.Limits.ReflectsLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s] (h : CategoryTheory.Presheaf.IsSheaf J (CategoryTheory.Functor.comp P s)) : CategoryTheory.Presheaf.IsSheaf J P

theorem CategoryTheory.Presheaf.isSheaf_comp_of_isSheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) (s : CategoryTheory.Functor A B) [CategoryTheory.Limits.PreservesLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s] (h : CategoryTheory.Presheaf.IsSheaf J P) : CategoryTheory.Presheaf.IsSheaf J (CategoryTheory.Functor.comp P s)

theorem CategoryTheory.Presheaf.isSheaf_iff_isSheaf_comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A : Type u₂} [CategoryTheory.Category.{v₂, u₂} A] {B : Type u₃} [CategoryTheory.Category.{v₃, u₃} B] (J : CategoryTheory.GrothendieckTopology C) (P : CategoryTheory.Functor Cᵒᵖ A) (s : CategoryTheory.Functor A B) [CategoryTheory.Limits.HasLimitsOfSize.{v₁, max v₁ u₁, v₂, u₂} A] [CategoryTheory.Limits.PreservesLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s] [CategoryTheory.ReflectsIsomorphisms s] : CategoryTheory.Presheaf.IsSheaf J P ↔ CategoryTheory.Presheaf.IsSheaf J (CategoryTheory.Functor.comp P s)

theorem CategoryTheory.Presheaf.isSheaf_iff_isSheaf_forget {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {A' : Type u₂} [CategoryTheory.Category.{max v₁ u₁, u₂} A'] (J : CategoryTheory.GrothendieckTopology C) (P' : CategoryTheory.Functor Cᵒᵖ A') (s : CategoryTheory.Functor A' (Type (max v₁ u₁))) [CategoryTheory.Limits.HasLimits A'] [CategoryTheory.Limits.PreservesLimits s] [CategoryTheory.ReflectsIsomorphisms s] : CategoryTheory.Presheaf.IsSheaf J P' ↔ CategoryTheory.Presheaf.IsSheaf J (CategoryTheory.Functor.comp P' s)

For a concrete category (A, s) where the forgetful functor s : A ⥤ Type v preserves limits and reflects isomorphisms, and A has limits, an A-valued presheaf P : Cᵒᵖ ⥤ A is a sheaf iff its underlying Type-valued presheaf P ⋙ s : Cᵒᵖ ⥤ Type is a sheaf.

Note this lemma applies for "algebraic" categories, eg groups, abelian groups and rings, but not for the category of topological spaces, topological rings, etc since reflecting isomorphisms doesn't hold.