File: Mathlib/Algebra/Category/ModuleCat/Sheaf.lean

full_name: SheafOfModules
code: /-- A sheaf of modules is a presheaf of modules such that the underlying presheaf
of abelian groups is a sheaf. -/
structure SheafOfModules where
  /-- the underlying presheaf of modules of a sheaf of modules -/
  val : PresheafOfModules.{v} R.val
  isSheaf : Presheaf.IsSheaf J val.presheaf
goal: Type (max (max (max u u₁) (v + 1)) v₁)

full_name: SheafOfModules.val
code: /-- A sheaf of modules is a presheaf of modules such that the underlying presheaf
of abelian groups is a sheaf. -/
structure SheafOfModules where
  /-- the underlying presheaf of modules of a sheaf of modules -/
  val : PresheafOfModules.{v} R.val
  isSheaf : Presheaf.IsSheaf J val.presheaf
goal: PresheafOfModules R.val

full_name: SheafOfModules.isSheaf
code: /-- A sheaf of modules is a presheaf of modules such that the underlying presheaf
of abelian groups is a sheaf. -/
structure SheafOfModules where
  /-- the underlying presheaf of modules of a sheaf of modules -/
  val : PresheafOfModules.{v} R.val
  isSheaf : Presheaf.IsSheaf J val.presheaf
goal: CategoryTheory.Presheaf.IsSheaf J self.val.presheaf

full_name: SheafOfModules.Hom.val
code: /-- A morphism between sheaves of modules is a morphism between the underlying
presheaves of modules. -/
@[ext]
structure Hom (X Y : SheafOfModules.{v} R) where
  /-- a morphism between the underlying presheaves of modules -/
  val : X.val ⟶ Y.val
goal: X.val ⟶ Y.val

full_name: SheafOfModules.Hom
code: /-- A morphism between sheaves of modules is a morphism between the underlying
presheaves of modules. -/
@[ext]
structure Hom (X Y : SheafOfModules.{v} R) where
  /-- a morphism between the underlying presheaves of modules -/
  val : X.val ⟶ Y.val
goal: Type (max u₁ v)

full_name: SheafOfModules.instCategory
code: instance : Category (SheafOfModules.{v} R) 
goal: CategoryTheory.Category.{max u₁ v, max (max (max (v + 1) u) u₁) v₁} (SheafOfModules R)

full_name: SheafOfModules.hom_ext
code: @[ext]
lemma hom_ext {X Y : SheafOfModules.{v} R} {f g : X ⟶ Y} (h : f.val = g.val) : f = g 
goal: f = g

full_name: SheafOfModules.id_val
code: @[simp]
lemma id_val (X : SheafOfModules.{v} R) : Hom.val (𝟙 X) = 𝟙 X.val 
goal: (𝟙 X).val = 𝟙 X.val

full_name: SheafOfModules.comp_val
code: @[simp, reassoc]
lemma comp_val {X Y Z : SheafOfModules.{v} R} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).val = f.val ≫ g.val 
goal: (f ≫ g).val = f.val ≫ g.val

full_name: SheafOfModules.forget
code: /-- The forgetful functor `SheafOfModules.{v} R ⥤ PresheafOfModules R.val`. -/
@[simps]
def forget : SheafOfModules.{v} R ⥤ PresheafOfModules R.val 
goal: SheafOfModules R ⥤ PresheafOfModules R.val

full_name: SheafOfModules.forget_map
code: /-- The forgetful functor `SheafOfModules.{v} R ⥤ PresheafOfModules R.val`. -/
@[simps]
def forget : SheafOfModules.{v} R ⥤ PresheafOfModules R.val 
goal: ∀ {X Y : SheafOfModules R} (φ : X ⟶ Y), (SheafOfModules.forget R).map φ = φ.val

full_name: SheafOfModules.forget_obj
code: /-- The forgetful functor `SheafOfModules.{v} R ⥤ PresheafOfModules R.val`. -/
@[simps]
def forget : SheafOfModules.{v} R ⥤ PresheafOfModules R.val 
goal: (SheafOfModules.forget R).obj F = F.val

full_name: SheafOfModules.fullyFaithfulForget
code: /-- The forget functor `SheafOfModules R ⥤ PresheafOfModules R.val` is fully faithful. -/
@[simps]
def fullyFaithfulForget : (forget.{v} R).FullyFaithful 
goal: (SheafOfModules.forget R).FullyFaithful

full_name: SheafOfModules.fullyFaithfulForget_preimage_val
code: /-- The forget functor `SheafOfModules R ⥤ PresheafOfModules R.val` is fully faithful. -/
@[simps]
def fullyFaithfulForget : (forget.{v} R).FullyFaithful 
goal: ∀ {X Y : SheafOfModules R} (φ : (SheafOfModules.forget R).obj X ⟶ (SheafOfModules.forget R).obj Y),
  ((SheafOfModules.fullyFaithfulForget R).preimage φ).val = φ

full_name: SheafOfModules.instFaithfulPresheafOfModulesValRingCatForget
code: instance : (forget.{v} R).Faithful 
goal: (SheafOfModules.forget R).Faithful

full_name: SheafOfModules.instFullPresheafOfModulesValRingCatForget
code: instance : (forget.{v} R).Full 
goal: (SheafOfModules.forget R).Full

full_name: SheafOfModules.instReflectsIsomorphismsPresheafOfModulesValRingCatForget
code: instance : (forget.{v} R).ReflectsIsomorphisms 
goal: (SheafOfModules.forget R).ReflectsIsomorphisms

full_name: SheafOfModules.evaluation
code: /-- Evaluation on an object `X` gives a functor
`SheafOfModules R ⥤ ModuleCat (R.val.obj X)`. -/
def evaluation (X : Cᵒᵖ) : SheafOfModules.{v} R ⥤ ModuleCat.{v} (R.val.obj X) 
goal: SheafOfModules R ⥤ ModuleCat ↑(R.val.obj X)

full_name: SheafOfModules.toSheaf
code: /-- The forget functor `SheafOfModules R ⥤ Sheaf J AddCommGrp`. -/
@[simps]
def toSheaf : SheafOfModules.{v} R ⥤ Sheaf J AddCommGrp.{v} 
goal: SheafOfModules R ⥤ CategoryTheory.Sheaf J AddCommGrp

full_name: SheafOfModules.toSheaf_map_val
code: /-- The forget functor `SheafOfModules R ⥤ Sheaf J AddCommGrp`. -/
@[simps]
def toSheaf : SheafOfModules.{v} R ⥤ Sheaf J AddCommGrp.{v} 
goal: ∀ {X Y : SheafOfModules R} (f : X ⟶ Y), ((SheafOfModules.toSheaf R).map f).val = f.val.hom

full_name: SheafOfModules.toSheaf_obj_val
code: /-- The forget functor `SheafOfModules R ⥤ Sheaf J AddCommGrp`. -/
@[simps]
def toSheaf : SheafOfModules.{v} R ⥤ Sheaf J AddCommGrp.{v} 
goal: ((SheafOfModules.toSheaf R).obj M).val = M.val.presheaf

full_name: SheafOfModules.forgetToSheafModuleCat
code: /--
The forgetful functor from sheaves of modules over sheaf of ring `R` to sheaves of `R(X)`-module
when `X` is initial.
-/
@[simps]
noncomputable def forgetToSheafModuleCat
      (X : Cᵒᵖ) (hX : Limits.IsInitial X)  :
    SheafOfModules.{w} R ⥤ Sheaf J (ModuleCat.{w} (R.1.obj X)) 
goal: SheafOfModules R ⥤ CategoryTheory.Sheaf J (ModuleCat ↑(R.val.obj X))

full_name: SheafOfModules.forgetToSheafModuleCat_map_val
code: /--
The forgetful functor from sheaves of modules over sheaf of ring `R` to sheaves of `R(X)`-module
when `X` is initial.
-/
@[simps]
noncomputable def forgetToSheafModuleCat
      (X : Cᵒᵖ) (hX : Limits.IsInitial X)  :
    SheafOfModules.{w} R ⥤ Sheaf J (ModuleCat.{w} (R.1.obj X)) 
goal: ∀ {X_1 Y : SheafOfModules R} (f : X_1 ⟶ Y),
  ((SheafOfModules.forgetToSheafModuleCat R X hX).map f).val =
    (PresheafOfModules.forgetToPresheafModuleCat X hX).map f.val

full_name: SheafOfModules.forgetToSheafModuleCat_obj_val
code: /--
The forgetful functor from sheaves of modules over sheaf of ring `R` to sheaves of `R(X)`-module
when `X` is initial.
-/
@[simps]
noncomputable def forgetToSheafModuleCat
      (X : Cᵒᵖ) (hX : Limits.IsInitial X)  :
    SheafOfModules.{w} R ⥤ Sheaf J (ModuleCat.{w} (R.1.obj X)) 
goal: ((SheafOfModules.forgetToSheafModuleCat R X hX).obj M).val =
  (PresheafOfModules.forgetToPresheafModuleCat X hX).obj M.val

full_name: SheafOfModules.toSheafCompSheafToPresheafIso
code: /-- The canonical isomorphism between
`SheafOfModules.toSheaf R ⋙ sheafToPresheaf J AddCommGrp.{v}`
and `SheafOfModules.forget R ⋙ PresheafOfModules.toPresheaf R.val`. -/
def toSheafCompSheafToPresheafIso :
    toSheaf R ⋙ sheafToPresheaf J AddCommGrp.{v} ≅
      forget R ⋙ PresheafOfModules.toPresheaf R.val 
goal: SheafOfModules.toSheaf R ⋙ CategoryTheory.sheafToPresheaf J AddCommGrp ≅
  SheafOfModules.forget R ⋙ PresheafOfModules.toPresheaf R.val

full_name: SheafOfModules.instFaithfulSheafAddCommGrpToSheaf
code: instance : (toSheaf.{v} R).Faithful 
goal: (SheafOfModules.toSheaf R).Faithful

full_name: SheafOfModules.instAddCommGroupHom
code: instance (M N : SheafOfModules.{v} R) : AddCommGroup (M ⟶ N) 
goal: AddCommGroup (M ⟶ N)

full_name: SheafOfModules.add_val
code: @[simp]
lemma add_val {M N : SheafOfModules.{v} R} (f g : M ⟶ N) :
    (f + g).val = f.val + g.val 
goal: (f + g).val = f.val + g.val

full_name: SheafOfModules.instPreadditive
code: instance : Preadditive (SheafOfModules.{v} R) 
goal: CategoryTheory.Preadditive (SheafOfModules R)

full_name: SheafOfModules.instAdditivePresheafOfModulesValRingCatForget
code: instance : (forget R).Additive 
goal: (SheafOfModules.forget R).Additive

full_name: SheafOfModules.instAdditiveSheafAddCommGrpToSheaf
code: instance : (toSheaf R).Additive 
goal: (SheafOfModules.toSheaf R).Additive

full_name: SheafOfModules.sections
code: /-- The type of sections of a sheaf of modules. -/
abbrev sections (M : SheafOfModules.{v} R) : Type _ 
goal: Type (max u₁ v)

full_name: SheafOfModules.sectionsMap
code: /-- The map `M.sections → N.sections` induced by a morphisms `M ⟶ N` of sheaves of modules. -/
abbrev sectionsMap {M N : SheafOfModules.{v} R} (f : M ⟶ N) (s : M.sections) : N.sections 
goal: N.sections

full_name: SheafOfModules.sectionsMap_comp
code: @[simp]
lemma sectionsMap_comp {M N P : SheafOfModules.{v} R} (f : M ⟶ N) (g : N ⟶ P) (s : M.sections) :
    sectionsMap (f ≫ g) s = sectionsMap g (sectionsMap f s) 
goal: SheafOfModules.sectionsMap (f ≫ g) s = SheafOfModules.sectionsMap g (SheafOfModules.sectionsMap f s)

full_name: SheafOfModules.sectionsMap_id
code: @[simp]
lemma sectionsMap_id {M : SheafOfModules.{v} R} (s : M.sections) :
    sectionsMap (𝟙 M) s = s 
goal: SheafOfModules.sectionsMap (𝟙 M) s = s

full_name: SheafOfModules.sectionsFunctor_map
code: /-- The functor which sends a sheaf of modules to its type of sections. -/
@[simps]
def sectionsFunctor : SheafOfModules.{v} R ⥤ Type _ 
goal: ∀ {X Y : SheafOfModules R} (f : X ⟶ Y) (s : X.sections),
  (SheafOfModules.sectionsFunctor R).map f s = SheafOfModules.sectionsMap f s

full_name: SheafOfModules.sectionsFunctor
code: /-- The functor which sends a sheaf of modules to its type of sections. -/
@[simps]
def sectionsFunctor : SheafOfModules.{v} R ⥤ Type _ 
goal: SheafOfModules R ⥤ Type (max u₁ v)

full_name: SheafOfModules.sectionsFunctor_obj
code: /-- The functor which sends a sheaf of modules to its type of sections. -/
@[simps]
def sectionsFunctor : SheafOfModules.{v} R ⥤ Type _ 
goal: (SheafOfModules.sectionsFunctor R).obj M = M.sections

full_name: SheafOfModules.unit
code: /-- The obvious free sheaf of modules of rank `1`. -/
@[simps]
def unit : SheafOfModules R 
goal: SheafOfModules R

full_name: SheafOfModules.unit_val
code: /-- The obvious free sheaf of modules of rank `1`. -/
@[simps]
def unit : SheafOfModules R 
goal: (SheafOfModules.unit R).val = PresheafOfModules.unit R.val

full_name: SheafOfModules.unitHomEquiv
code: /-- The bijection `(unit R ⟶ M) ≃ M.sections` for `M : SheafOfModules R`. -/
def unitHomEquiv (M : SheafOfModules R) :
    (unit R ⟶ M) ≃ M.sections 
goal: (SheafOfModules.unit R ⟶ M) ≃ M.sections

full_name: SheafOfModules.unitHomEquiv_apply_coe
code: @[simp]
lemma unitHomEquiv_apply_coe (M : SheafOfModules R) (f : unit R ⟶ M) (X : Cᵒᵖ) :
    (M.unitHomEquiv f).val X = f.val.app X (1 : R.val.obj X) 
goal: ↑(M.unitHomEquiv f) X = (PresheafOfModules.Hom.app f.val X) 1

full_name: SheafOfModules.unitHomEquiv_comp_apply
code: lemma unitHomEquiv_comp_apply {M N : SheafOfModules.{u} R}
    (f : unit R ⟶ M) (p : M ⟶ N) :
    N.unitHomEquiv (f ≫ p) = sectionsMap p (M.unitHomEquiv f) 
goal: N.unitHomEquiv (f ≫ p) = SheafOfModules.sectionsMap p (M.unitHomEquiv f)

full_name: SheafOfModules.unitHomEquiv_symm_comp
code: lemma unitHomEquiv_symm_comp {M N : SheafOfModules.{u} R} (s : M.sections) (p : M ⟶ N) :
    M.unitHomEquiv.symm s ≫ p = N.unitHomEquiv.symm (sectionsMap p s) 
goal: M.unitHomEquiv.symm s ≫ p = N.unitHomEquiv.symm (SheafOfModules.sectionsMap p s)

full_name: PresheafOfModules.homEquivOfIsLocallyBijective_apply
code: /-- The bijection `(M₂ ⟶ N) ≃ (M₁ ⟶ N)` induced by a locally bijective morphism
`f : M₁ ⟶ M₂` of presheaves of modules, when `N` is a sheaf. -/
@[simps]
noncomputable def homEquivOfIsLocallyBijective : (M₂ ⟶ N) ≃ (M₁ ⟶ N) 
goal: (PresheafOfModules.homEquivOfIsLocallyBijective f hN) φ = f ≫ φ

full_name: PresheafOfModules.homEquivOfIsLocallyBijective
code: /-- The bijection `(M₂ ⟶ N) ≃ (M₁ ⟶ N)` induced by a locally bijective morphism
`f : M₁ ⟶ M₂` of presheaves of modules, when `N` is a sheaf. -/
@[simps]
noncomputable def homEquivOfIsLocallyBijective : (M₂ ⟶ N) ≃ (M₁ ⟶ N) 
goal: (M₂ ⟶ N) ≃ (M₁ ⟶ N)

full_name: PresheafOfModules.homEquivOfIsLocallyBijective_symm_apply_hom
code: /-- The bijection `(M₂ ⟶ N) ≃ (M₁ ⟶ N)` induced by a locally bijective morphism
`f : M₁ ⟶ M₂` of presheaves of modules, when `N` is a sheaf. -/
@[simps]
noncomputable def homEquivOfIsLocallyBijective : (M₂ ⟶ N) ≃ (M₁ ⟶ N) 
goal: ((PresheafOfModules.homEquivOfIsLocallyBijective f hN).symm ψ).hom =
  (CategoryTheory.Localization.LeftBousfield.W.homEquiv ⋯ N.presheaf hN).symm ψ.hom