Presheaves of modules over a presheaf of rings.

Given a presheaf of rings R : Cᵒᵖ ⥤ RingCat, we define the category PresheafOfModules R. An object M : PresheafOfModules R consists of a family of modules M.obj X : ModuleCat (R.obj X) for all X : Cᵒᵖ, together with the data, for all f : X ⟶ Y, of a functorial linear map M.map f from M.obj X to the restriction of scalars of M.obj Y via R.map f.

Future work

• Compare this to the definition as a presheaf of pairs (R, M) with specified first part.
• Compare this to the definition as a module object of the presheaf of rings thought of as a monoid object.
• Presheaves of modules over a presheaf of commutative rings form a monoidal category.
• Pushforward and pullback.

structure PresheafOfModules {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) : Type (max (max (max u u₁) (v + 1)) v₁)

A presheaf of modules over R : Cᵒᵖ ⥤ RingCat consists of family of objects obj X : ModuleCat (R.obj X) for all X : Cᵒᵖ together with functorial maps obj X ⟶ (ModuleCat.restrictScalars (R.map f)).obj (obj Y) for all f : X ⟶ Y in Cᵒᵖ.

• obj (X : Cᵒᵖ) : ModuleCat ↑(R.obj X)

  a family of modules over R.obj X for all X

• map {X Y : Cᵒᵖ} (f : X ⟶ Y) : self.obj X ⟶ (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (self.obj Y)

  the restriction maps of a presheaf of modules

• map_id (X : Cᵒᵖ) : self.map (CategoryTheory.CategoryStruct.id X) = (ModuleCat.restrictScalarsId' (RingCat.Hom.hom (R.map (CategoryTheory.CategoryStruct.id X))) ⋯).inv.app (self.obj X)
• map_comp {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z) : self.map (CategoryTheory.CategoryStruct.comp f g) = CategoryTheory.CategoryStruct.comp (self.map f) (CategoryTheory.CategoryStruct.comp ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (self.map g)) ((ModuleCat.restrictScalarsComp' (RingCat.Hom.hom (R.map f)) (RingCat.Hom.hom (R.map g)) (RingCat.Hom.hom (R.map (CategoryTheory.CategoryStruct.comp f g))) ⋯).inv.app (self.obj Z)))

theorem PresheafOfModules.map_comp_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (self : PresheafOfModules R) {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z) {Z✝ : ModuleCat ↑(R.obj X)} (h : (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map (CategoryTheory.CategoryStruct.comp f g)))).obj (self.obj Z) ⟶ Z✝) : CategoryTheory.CategoryStruct.comp (self.map (CategoryTheory.CategoryStruct.comp f g)) h = CategoryTheory.CategoryStruct.comp (self.map f) (CategoryTheory.CategoryStruct.comp ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (self.map g)) (CategoryTheory.CategoryStruct.comp ((ModuleCat.restrictScalarsComp' (RingCat.Hom.hom (R.map f)) (RingCat.Hom.hom (R.map g)) (RingCat.Hom.hom (R.map (CategoryTheory.CategoryStruct.comp f g))) ⋯).inv.app (self.obj Z)) h))

theorem PresheafOfModules.map_smul {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)) : (CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) = (CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m

theorem PresheafOfModules.congr_map_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) {X Y : Cᵒᵖ} {f g : X ⟶ Y} (h : f = g) (m : ↑(M.obj X)) : (CategoryTheory.ConcreteCategory.hom (M.map f)) m = (CategoryTheory.ConcreteCategory.hom (M.map g)) m

structure PresheafOfModules.Hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M₁ M₂ : PresheafOfModules R) : Type (max u₁ v)

A morphism of presheaves of modules consists of a family of linear maps which satisfy the naturality condition.

• app (X : Cᵒᵖ) : M₁.obj X ⟶ M₂.obj X

  a family of linear maps M₁.obj X ⟶ M₂.obj X for all X.

• naturality {X Y : Cᵒᵖ} (f : X ⟶ Y) : CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (self.app Y)) = CategoryTheory.CategoryStruct.comp (self.app X) (M₂.map f)

theorem PresheafOfModules.Hom.ext_iff {C : Type u₁} {inst✝ : CategoryTheory.Category.{v₁, u₁} C} {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} {x y : M₁.Hom M₂} : x = y ↔ x.app = y.app

theorem PresheafOfModules.Hom.ext {C : Type u₁} {inst✝ : CategoryTheory.Category.{v₁, u₁} C} {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} {x y : M₁.Hom M₂} (app : x.app = y.app) : x = y

@[simp]

theorem PresheafOfModules.Hom.naturality_assoc {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (self : M₁.Hom M₂) {X Y : Cᵒᵖ} (f : X ⟶ Y) {Z : ModuleCat ↑(R.obj X)} (h : (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M₂.obj Y) ⟶ Z) : CategoryTheory.CategoryStruct.comp (M₁.map f) (CategoryTheory.CategoryStruct.comp ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (self.app Y)) h) = CategoryTheory.CategoryStruct.comp (self.app X) (CategoryTheory.CategoryStruct.comp (M₂.map f) h)

instance PresheafOfModules.instCategory {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} : CategoryTheory.Category.{max u₁ v, max (max (max (v + 1) u) u₁) v₁} (PresheafOfModules R)

theorem PresheafOfModules.hom_ext {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} {f g : M₁ ⟶ M₂} (h : ∀ (X : Cᵒᵖ), f.app X = g.app X) : f = g

theorem PresheafOfModules.hom_ext_iff {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} {f g : M₁ ⟶ M₂} : f = g ↔ ∀ (X : Cᵒᵖ), f.app X = g.app X

@[simp]

theorem PresheafOfModules.id_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) (X : Cᵒᵖ) : (CategoryTheory.CategoryStruct.id M).app X = CategoryTheory.CategoryStruct.id (M.obj X)

@[simp]

theorem PresheafOfModules.comp_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ M₃ : PresheafOfModules R} (f : M₁ ⟶ M₂) (g : M₂ ⟶ M₃) (X : Cᵒᵖ) : (CategoryTheory.CategoryStruct.comp f g).app X = CategoryTheory.CategoryStruct.comp (f.app X) (g.app X)

theorem PresheafOfModules.naturality_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (f : M₁ ⟶ M₂) {X Y : Cᵒᵖ} (g : X ⟶ Y) (x : ↑(M₁.obj X)) : (CategoryTheory.ConcreteCategory.hom (f.app Y)) ((CategoryTheory.ConcreteCategory.hom (M₁.map g)) x) = (CategoryTheory.ConcreteCategory.hom (M₂.map g)) ((CategoryTheory.ConcreteCategory.hom (f.app X)) x)

def PresheafOfModules.isoMk {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X) (naturality : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app Y).hom) = CategoryTheory.CategoryStruct.comp (app X).hom (M₂.map f) := by cat_disch) : M₁ ≅ M₂

Constructor for isomorphisms in the category of presheaves of modules.

@[simp]

theorem PresheafOfModules.isoMk_hom_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X) (naturality : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app Y).hom) = CategoryTheory.CategoryStruct.comp (app X).hom (M₂.map f) := by cat_disch) (X : Cᵒᵖ) : (isoMk app naturality).hom.app X = (app X).hom

@[simp]

theorem PresheafOfModules.isoMk_inv_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X) (naturality : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app Y).hom) = CategoryTheory.CategoryStruct.comp (app X).hom (M₂.map f) := by cat_disch) (X : Cᵒᵖ) : (isoMk app naturality).inv.app X = (app X).inv

noncomputable def PresheafOfModules.presheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) : CategoryTheory.Functor Cᵒᵖ Ab

The underlying presheaf of abelian groups of a presheaf of modules.

@[simp]

theorem PresheafOfModules.presheaf_obj_coe {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) (X : Cᵒᵖ) : ↑(M.presheaf.obj X) = ↑(M.obj X)

@[simp]

theorem PresheafOfModules.presheaf_map_apply_coe {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) (x : ↑(M.obj X)) : (AddCommGrp.Hom.hom (M.presheaf.map f)) x = (CategoryTheory.ConcreteCategory.hom (M.map f)) x

instance PresheafOfModules.instModuleCarrierObjOppositeRingCatCarrierAbPresheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) (X : Cᵒᵖ) : Module ↑(R.obj X) ↑(M.presheaf.obj X)

noncomputable def PresheafOfModules.toPresheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) : CategoryTheory.Functor (PresheafOfModules R) (CategoryTheory.Functor Cᵒᵖ Ab)

The forgetful functor PresheafOfModules R ⥤ Cᵒᵖ ⥤ Ab.

@[simp]

theorem PresheafOfModules.toPresheaf_obj_coe {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) (X : Cᵒᵖ) : ↑(((toPresheaf R).obj M).obj X) = ↑(M.obj X)

@[simp]

theorem PresheafOfModules.toPresheaf_map_app_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (f : M₁ ⟶ M₂) (X : Cᵒᵖ) (x : ↑(M₁.obj X)) : (AddCommGrp.Hom.hom (((toPresheaf R).map f).app X)) x = (CategoryTheory.ConcreteCategory.hom (f.app X)) x

instance PresheafOfModules.instFaithfulFunctorOppositeAbToPresheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} : (toPresheaf R).Faithful

noncomputable def PresheafOfModules.ofPresheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : CategoryTheory.Functor Cᵒᵖ Ab) [(X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)] (map_smul : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)), (CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) = (CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m) : PresheafOfModules R

The object in PresheafOfModules R that is obtained from M : Cᵒᵖ ⥤ Ab.{v} such that for all X : Cᵒᵖ, M.obj X is a R.obj X module, in such a way that the restriction maps are semilinear. (This constructor should be used only in cases when the preferred constructor PresheafOfModules.mk is not as convenient as this one.)

@[simp]

theorem PresheafOfModules.ofPresheaf_obj_carrier {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : CategoryTheory.Functor Cᵒᵖ Ab) [(X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)] (map_smul : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)), (CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) = (CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m) (X : Cᵒᵖ) : ↑((ofPresheaf M map_smul).obj X) = ↑(M.obj X)

@[simp]

theorem PresheafOfModules.ofPresheaf_obj_isModule {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : CategoryTheory.Functor Cᵒᵖ Ab) [(X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)] (map_smul : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)), (CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) = (CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m) (X : Cᵒᵖ) : ((ofPresheaf M map_smul).obj X).isModule = inst✝ X

@[simp]

theorem PresheafOfModules.ofPresheaf_obj_isAddCommGroup {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : CategoryTheory.Functor Cᵒᵖ Ab) [(X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)] (map_smul : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)), (CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) = (CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m) (X : Cᵒᵖ) : ((ofPresheaf M map_smul).obj X).isAddCommGroup = (M.obj X).str

@[simp]

theorem PresheafOfModules.ofPresheaf_map {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : CategoryTheory.Functor Cᵒᵖ Ab) [(X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)] (map_smul : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)), (CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) = (CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m) {X Y : Cᵒᵖ} (f : X ⟶ Y) : (ofPresheaf M map_smul).map f = ModuleCat.ofHom { toFun := fun (x : ↑(M.obj X)) => (CategoryTheory.ConcreteCategory.hom (M.map f)) x, map_add' := ⋯, map_smul' := ⋯ }

@[simp]

theorem PresheafOfModules.ofPresheaf_presheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : CategoryTheory.Functor Cᵒᵖ Ab) [(X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)] (map_smul : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)), (CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) = (CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m) : (ofPresheaf M map_smul).presheaf = M

noncomputable def PresheafOfModules.homMk {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (φ : M₁.presheaf ⟶ M₂.presheaf) (hφ : ∀ (X : Cᵒᵖ) (r : ↑(R.obj X)) (m : ↑(M₁.obj X)), (CategoryTheory.ConcreteCategory.hom (φ.app X)) (r • m) = r • (CategoryTheory.ConcreteCategory.hom (φ.app X)) m) : M₁ ⟶ M₂

The morphism of presheaves of modules M₁ ⟶ M₂ given by a morphism of abelian presheaves M₁.presheaf ⟶ M₂.presheaf which satisfy a suitable linearity condition.

@[simp]

theorem PresheafOfModules.homMk_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (φ : M₁.presheaf ⟶ M₂.presheaf) (hφ : ∀ (X : Cᵒᵖ) (r : ↑(R.obj X)) (m : ↑(M₁.obj X)), (CategoryTheory.ConcreteCategory.hom (φ.app X)) (r • m) = r • (CategoryTheory.ConcreteCategory.hom (φ.app X)) m) (X : Cᵒᵖ) : (homMk φ hφ).app X = ModuleCat.ofHom { toFun := ⇑(CategoryTheory.ConcreteCategory.hom (φ.app X)), map_add' := ⋯, map_smul' := ⋯ }

instance PresheafOfModules.instZeroHom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} : Zero (M₁ ⟶ M₂)

@[simp]

theorem PresheafOfModules.zero_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M₁ M₂ : PresheafOfModules R) (X : Cᵒᵖ) : Hom.app 0 X = 0

instance PresheafOfModules.instNegHom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} : Neg (M₁ ⟶ M₂)

instance PresheafOfModules.instAddHom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} : Add (M₁ ⟶ M₂)

instance PresheafOfModules.instSubHom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} : Sub (M₁ ⟶ M₂)

@[simp]

theorem PresheafOfModules.neg_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (f : M₁ ⟶ M₂) (X : Cᵒᵖ) : (-f).app X = -f.app X

@[simp]

theorem PresheafOfModules.add_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (f g : M₁ ⟶ M₂) (X : Cᵒᵖ) : (f + g).app X = f.app X + g.app X

@[simp]

theorem PresheafOfModules.sub_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (f g : M₁ ⟶ M₂) (X : Cᵒᵖ) : (f - g).app X = f.app X - g.app X

instance PresheafOfModules.instAddCommGroupHom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} : AddCommGroup (M₁ ⟶ M₂)

instance PresheafOfModules.instPreadditive {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} : CategoryTheory.Preadditive (PresheafOfModules R)

instance PresheafOfModules.instAdditiveFunctorOppositeAbToPresheaf {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} : (toPresheaf R).Additive

theorem PresheafOfModules.zsmul_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (n : ℤ) (f : M₁ ⟶ M₂) (X : Cᵒᵖ) : (n • f).app X = n • f.app X

def PresheafOfModules.evaluation {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) (X : Cᵒᵖ) : CategoryTheory.Functor (PresheafOfModules R) (ModuleCat ↑(R.obj X))

Evaluation on an object X gives a functor PresheafOfModules R ⥤ ModuleCat (R.obj X).

@[simp]

theorem PresheafOfModules.evaluation_obj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) (X : Cᵒᵖ) (M : PresheafOfModules R) : (evaluation R X).obj M = M.obj X

@[simp]

theorem PresheafOfModules.evaluation_map {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) (X : Cᵒᵖ) {X✝ Y✝ : PresheafOfModules R} (f : X✝ ⟶ Y✝) : (evaluation R X).map f = f.app X

instance PresheafOfModules.instAdditiveModuleCatCarrierObjOppositeRingCatEvaluation {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) (X : Cᵒᵖ) : (evaluation R X).Additive

noncomputable def PresheafOfModules.restriction {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) {X Y : Cᵒᵖ} (f : X ⟶ Y) : evaluation R X ⟶ (evaluation R Y).comp (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f)))

The restriction natural transformation on presheaves of modules, considered as linear maps to restriction of scalars.

@[simp]

theorem PresheafOfModules.restriction_app {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) {X Y : Cᵒᵖ} (f : X ⟶ Y) (M : PresheafOfModules R) : (restriction R f).app M = M.map f

noncomputable def PresheafOfModules.unit {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) : PresheafOfModules R

The obvious free presheaf of modules of rank 1.

theorem PresheafOfModules.unit_map_one {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) {X Y : Cᵒᵖ} (f : X ⟶ Y) : (CategoryTheory.ConcreteCategory.hom ((unit R).map f)) 1 = 1

def PresheafOfModules.sections {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) : Type (max u₁ v)

The type of sections of a presheaf of modules.

@[reducible, inline]

abbrev PresheafOfModules.sections.eval {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M : PresheafOfModules R} (s : M.sections) (X : Cᵒᵖ) : ↑(M.obj X)

Given a presheaf of modules M, s : M.sections and X : Cᵒᵖ, this is the induced element in M.obj X.

@[simp]

theorem PresheafOfModules.sections_property {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M : PresheafOfModules R} (s : M.sections) {X Y : Cᵒᵖ} (f : X ⟶ Y) : (CategoryTheory.ConcreteCategory.hom (M.map f)) (↑s X) = ↑s Y

def PresheafOfModules.sectionsMk {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M : PresheafOfModules R} (s : (X : Cᵒᵖ) → ↑(M.obj X)) (hs : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), (CategoryTheory.ConcreteCategory.hom (M.map f)) (s X) = s Y) : M.sections

Constructor for sections of a presheaf of modules.

@[simp]

theorem PresheafOfModules.sectionsMk_coe {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M : PresheafOfModules R} (s : (X : Cᵒᵖ) → ↑(M.obj X)) (hs : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), (CategoryTheory.ConcreteCategory.hom (M.map f)) (s X) = s Y) (X : Cᵒᵖ) : ↑(sectionsMk s hs) X = s X

theorem PresheafOfModules.sections_ext {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M : PresheafOfModules R} (s t : M.sections) (h : ∀ (X : Cᵒᵖ), ↑s X = ↑t X) : s = t

theorem PresheafOfModules.sections_ext_iff {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M : PresheafOfModules R} {s t : M.sections} : s = t ↔ ∀ (X : Cᵒᵖ), ↑s X = ↑t X

def PresheafOfModules.sectionsMap {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M N : PresheafOfModules R} (f : M ⟶ N) (s : M.sections) : N.sections

The map M.sections → N.sections induced by a morphisms M ⟶ N of presheaves of modules.

@[simp]

theorem PresheafOfModules.sectionsMap_coe {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M N : PresheafOfModules R} (f : M ⟶ N) (s : M.sections) (X : Cᵒᵖ) : ↑(sectionsMap f s) X = (CategoryTheory.ConcreteCategory.hom (f.app X)) (↑s X)

@[simp]

theorem PresheafOfModules.sectionsMap_comp {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M N P : PresheafOfModules R} (f : M ⟶ N) (g : N ⟶ P) (s : M.sections) : sectionsMap (CategoryTheory.CategoryStruct.comp f g) s = sectionsMap g (sectionsMap f s)

@[simp]

theorem PresheafOfModules.sectionsMap_id {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M : PresheafOfModules R} (s : M.sections) : sectionsMap (CategoryTheory.CategoryStruct.id M) s = s

noncomputable def PresheafOfModules.unitHomEquiv {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) : (unit R ⟶ M) ≃ M.sections

The bijection (unit R ⟶ M) ≃ M.sections for M : PresheafOfModules R.

@[simp]

theorem PresheafOfModules.unitHomEquiv_apply_coe {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) (f : unit R ⟶ M) (X : Cᵒᵖ) : ↑(M.unitHomEquiv f) X = (CategoryTheory.ConcreteCategory.hom (f.app X)) 1

PresheafOfModules R ⥤ Cᵒᵖ ⥤ ModuleCat (R.obj X) when X is initial

When X is initial, we have Module (R.obj X) (M.obj c) for any c : Cᵒᵖ.

@[reducible, inline]

noncomputable abbrev PresheafOfModules.forgetToPresheafModuleCatObjObj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) (M : PresheafOfModules R) (Y : Cᵒᵖ) : ModuleCat ↑(R.obj X)

Auxiliary definition for forgetToPresheafModuleCatObj.

theorem PresheafOfModules.forgetToPresheafModuleCatObjObj_coe {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) (M : PresheafOfModules R) (Y : Cᵒᵖ) : ↑(forgetToPresheafModuleCatObjObj X hX M Y) = ↑(M.obj Y)

noncomputable def PresheafOfModules.forgetToPresheafModuleCatObjMap {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) (M : PresheafOfModules R) {Y Z : Cᵒᵖ} (f : Y ⟶ Z) : forgetToPresheafModuleCatObjObj X hX M Y ⟶ forgetToPresheafModuleCatObjObj X hX M Z

Auxiliary definition for forgetToPresheafModuleCatObj.

@[simp]

theorem PresheafOfModules.forgetToPresheafModuleCatObjMap_apply {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) (M : PresheafOfModules R) {Y Z : Cᵒᵖ} (f : Y ⟶ Z) (m : ↑(M.obj Y)) : (ModuleCat.Hom.hom (forgetToPresheafModuleCatObjMap X hX M f)) m = (CategoryTheory.ConcreteCategory.hom (M.map f)) m

noncomputable def PresheafOfModules.forgetToPresheafModuleCatObj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) (M : PresheafOfModules R) : CategoryTheory.Functor Cᵒᵖ (ModuleCat ↑(R.obj X))

Implementation of the functor PresheafOfModules R ⥤ Cᵒᵖ ⥤ ModuleCat (R.obj X) when X is initial.

The functor is implemented as, on object level M ↦ (c ↦ M(c)) where the R(X)-module structure on M(c) is given by restriction of scalars along the unique morphism R(c) ⟶ R(X); and on morphism level (f : M ⟶ N) ↦ (c ↦ f(c)).

@[simp]

theorem PresheafOfModules.forgetToPresheafModuleCatObj_obj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) (M : PresheafOfModules R) (Y : Cᵒᵖ) : (forgetToPresheafModuleCatObj X hX M).obj Y = forgetToPresheafModuleCatObjObj X hX M Y

@[simp]

theorem PresheafOfModules.forgetToPresheafModuleCatObj_map {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) (M : PresheafOfModules R) {X✝ Y✝ : Cᵒᵖ} (f : X✝ ⟶ Y✝) : (forgetToPresheafModuleCatObj X hX M).map f = forgetToPresheafModuleCatObjMap X hX M f

noncomputable def PresheafOfModules.forgetToPresheafModuleCatMap {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) {M N : PresheafOfModules R} (f : M ⟶ N) : forgetToPresheafModuleCatObj X hX M ⟶ forgetToPresheafModuleCatObj X hX N

Implementation of the functor PresheafOfModules R ⥤ Cᵒᵖ ⥤ ModuleCat (R.obj X) when X is initial.

The functor is implemented as, on object level M ↦ (c ↦ M(c)) where the R(X)-module structure on M(c) is given by restriction of scalars along the unique morphism R(c) ⟶ R(X); and on morphism level (f : M ⟶ N) ↦ (c ↦ f(c)).

noncomputable def PresheafOfModules.forgetToPresheafModuleCat {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) : CategoryTheory.Functor (PresheafOfModules R) (CategoryTheory.Functor Cᵒᵖ (ModuleCat ↑(R.obj X)))

The forgetful functor from presheaves of modules over a presheaf of rings R to presheaves of R(X)-modules where X is an initial object.

The functor is implemented as, on object level M ↦ (c ↦ M(c)) where the R(X)-module structure on M(c) is given by restriction of scalars along the unique morphism R(c) ⟶ R(X); and on morphism level (f : M ⟶ N) ↦ (c ↦ f(c)).

@[simp]

theorem PresheafOfModules.forgetToPresheafModuleCat_map {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) {X✝ Y✝ : PresheafOfModules R} (f : X✝ ⟶ Y✝) : (forgetToPresheafModuleCat X hX).map f = forgetToPresheafModuleCatMap X hX f

@[simp]

theorem PresheafOfModules.forgetToPresheafModuleCat_obj {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) (M : PresheafOfModules R) : (forgetToPresheafModuleCat X hX).obj M = forgetToPresheafModuleCatObj X hX M