ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/CharZero/Quotient.lean

full_name: AddSubgroup.zsmul_mem_zmultiples_iff_exists_sub_div
code: /-- `z • r` is a multiple of `p` iff `r` is `pk/z` above a multiple of `p`, where `0 ≤ k < |z|`. -/
theorem zsmul_mem_zmultiples_iff_exists_sub_div {r : R} {z : ℤ} (hz : z ≠ 0) :
    z • r ∈ AddSubgroup.zmultiples p ↔
      ∃ k : Fin z.natAbs, r - (k : ℕ) • (p / z : R) ∈ AddSubgroup.zmultiples p 
goal: z • r ∈ AddSubgroup.zmultiples p ↔ ∃ k, r - ↑k • (p / ↑z) ∈ AddSubgroup.zmultiples p

full_name: AddSubgroup.nsmul_mem_zmultiples_iff_exists_sub_div
code: theorem nsmul_mem_zmultiples_iff_exists_sub_div {r : R} {n : ℕ} (hn : n ≠ 0) :
    n • r ∈ AddSubgroup.zmultiples p ↔
      ∃ k : Fin n, r - (k : ℕ) • (p / n : R) ∈ AddSubgroup.zmultiples p 
goal: n • r ∈ AddSubgroup.zmultiples p ↔ ∃ k, r - ↑k • (p / ↑n) ∈ AddSubgroup.zmultiples p

full_name: QuotientAddGroup.zmultiples_zsmul_eq_zsmul_iff
code: theorem zmultiples_zsmul_eq_zsmul_iff {ψ θ : R ⧸ AddSubgroup.zmultiples p} {z : ℤ} (hz : z ≠ 0) :
    z • ψ = z • θ ↔ ∃ k : Fin z.natAbs, ψ = θ + ((k : ℕ) • (p / z) : R) 
goal: z • ψ = z • θ ↔ ∃ k, ψ = θ + ↑(↑k • (p / ↑z))

full_name: QuotientAddGroup.zmultiples_nsmul_eq_nsmul_iff
code: theorem zmultiples_nsmul_eq_nsmul_iff {ψ θ : R ⧸ AddSubgroup.zmultiples p} {n : ℕ} (hz : n ≠ 0) :
    n • ψ = n • θ ↔ ∃ k : Fin n, ψ = θ + (k : ℕ) • (p / n : R) 
goal: n • ψ = n • θ ↔ ∃ k, ψ = θ + ↑k • ↑(p / ↑n)
File: Mathlib/Algebra/Category/FGModuleCat/Limits.lean

full_name: FGModuleCat.instFiniteDimensionalCarrierPiObjModuleCatOfFinite
code: instance {J : Type} [Finite J] (Z : J → ModuleCat.{v} k) [∀ j, FiniteDimensional k (Z j)] :
    FiniteDimensional k (∏ᶜ fun j => Z j : ModuleCat.{v} k) 
goal: FiniteDimensional k ↑(∏ᶜ fun j => Z j)

full_name: FGModuleCat.instFiniteDimensionalCarrierLimitModuleCatCompForget₂
code: /-- Finite limits of finite dimensional vectors spaces are finite dimensional,
because we can realise them as subobjects of a finite product. -/
instance (F : J ⥤ FGModuleCat k) :
    FiniteDimensional k (limit (F ⋙ forget₂ (FGModuleCat k) (ModuleCat.{v} k)) : ModuleCat.{v} k) 
goal: FiniteDimensional k ↑(CategoryTheory.Limits.limit (F ⋙ CategoryTheory.forget₂ (FGModuleCat k) (ModuleCat k)))

full_name: FGModuleCat.forget₂CreatesLimit
code: /-- The forgetful functor from `FGModuleCat k` to `ModuleCat k` creates all finite limits. -/
def forget₂CreatesLimit (F : J ⥤ FGModuleCat k) :
    CreatesLimit F (forget₂ (FGModuleCat k) (ModuleCat.{v} k)) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ (FGModuleCat k) (ModuleCat k))

full_name: FGModuleCat.instCreatesLimitsOfShapeModuleCatForget₂
code: instance : CreatesLimitsOfShape J (forget₂ (FGModuleCat k) (ModuleCat.{v} k)) 
goal: CategoryTheory.CreatesLimitsOfShape J (CategoryTheory.forget₂ (FGModuleCat k) (ModuleCat k))

full_name: FGModuleCat.instHasLimitsOfShapeOfFinCategory
code: instance (J : Type) [Category J] [FinCategory J] :
    HasLimitsOfShape J (FGModuleCat.{v} k) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (FGModuleCat k)

full_name: FGModuleCat.instHasFiniteLimits
code: instance : HasFiniteLimits (FGModuleCat k) 
goal: CategoryTheory.Limits.HasFiniteLimits (FGModuleCat k)

full_name: FGModuleCat.instPreservesFiniteLimitsModuleCatForget₂
code: instance : PreservesFiniteLimits (forget₂ (FGModuleCat k) (ModuleCat.{v} k)) 
goal: CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.forget₂ (FGModuleCat k) (ModuleCat k))
File: Mathlib/Algebra/Category/ModuleCat/EpiMono.lean

full_name: ModuleCat.ker_eq_bot_of_mono
code: theorem ker_eq_bot_of_mono [Mono f] : LinearMap.ker f = ⊥ 
goal: LinearMap.ker f = ⊥

full_name: ModuleCat.range_eq_top_of_epi
code: theorem range_eq_top_of_epi [Epi f] : LinearMap.range f = ⊤ 
goal: LinearMap.range f = ⊤

full_name: ModuleCat.mono_iff_ker_eq_bot
code: theorem mono_iff_ker_eq_bot : Mono f ↔ LinearMap.ker f = ⊥ 
goal: CategoryTheory.Mono f ↔ LinearMap.ker f = ⊥

full_name: ModuleCat.mono_iff_injective
code: theorem mono_iff_injective : Mono f ↔ Function.Injective f 
goal: CategoryTheory.Mono f ↔ Function.Injective ⇑f

full_name: ModuleCat.epi_iff_range_eq_top
code: theorem epi_iff_range_eq_top : Epi f ↔ LinearMap.range f = ⊤ 
goal: CategoryTheory.Epi f ↔ LinearMap.range f = ⊤

full_name: ModuleCat.epi_iff_surjective
code: theorem epi_iff_surjective : Epi f ↔ Function.Surjective f 
goal: CategoryTheory.Epi f ↔ Function.Surjective ⇑f

full_name: ModuleCat.uniqueOfEpiZero
code: /-- If the zero morphism is an epi then the codomain is trivial. -/
def uniqueOfEpiZero (X) [h : Epi (0 : X ⟶ of R M)] : Unique M 
goal: Unique M

full_name: ModuleCat.mono_as_hom'_subtype
code: instance mono_as_hom'_subtype (U : Submodule R X) : Mono (ModuleCat.asHomRight U.subtype) 
goal: CategoryTheory.Mono (ModuleCat.asHomRight U.subtype)

full_name: ModuleCat.epi_as_hom''_mkQ
code: instance epi_as_hom''_mkQ (U : Submodule R X) : Epi (↿U.mkQ) 
goal: CategoryTheory.Epi (ModuleCat.asHomLeft U.mkQ)

full_name: ModuleCat.forget_preservesEpimorphisms
code: instance forget_preservesEpimorphisms : (forget (ModuleCat.{v} R)).PreservesEpimorphisms 
goal: (CategoryTheory.forget (ModuleCat R)).PreservesEpimorphisms

full_name: ModuleCat.forget_preservesMonomorphisms
code: instance forget_preservesMonomorphisms : (forget (ModuleCat.{v} R)).PreservesMonomorphisms 
goal: (CategoryTheory.forget (ModuleCat R)).PreservesMonomorphisms
File: Mathlib/Algebra/Category/ModuleCat/Tannaka.lean

full_name: ringEquivEndForget₂
code: /-- An ingredient of Tannaka duality for rings:
A ring `R` is equivalent to
the endomorphisms of the additive forgetful functor `Module R ⥤ AddCommGroup`.
-/
def ringEquivEndForget₂ (R : Type u) [Ring R] :
    R ≃+* End (AdditiveFunctor.of (forget₂ (ModuleCat.{u} R) AddCommGrp.{u})) 
goal: R ≃+* CategoryTheory.End (CategoryTheory.AdditiveFunctor.of (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp))
File: Mathlib/Algebra/Category/ModuleCat/Projective.lean

full_name: IsProjective.iff_projective
code: /-- The categorical notion of projective object agrees with the explicit module-theoretic notion. -/
theorem IsProjective.iff_projective {R : Type u} [Ring R] {P : Type max u v} [AddCommGroup P]
    [Module R P] : Module.Projective R P ↔ Projective (ModuleCat.of R P) 
goal: Module.Projective R P ↔ CategoryTheory.Projective (ModuleCat.of R P)

full_name: ModuleCat.projective_of_free
code: /-- Modules that have a basis are projective. -/
theorem projective_of_free {ι : Type u'} (b : Basis ι R M) : Projective M 
goal: CategoryTheory.Projective M

full_name: ModuleCat.moduleCat_enoughProjectives
code: /-- The category of modules has enough projectives, since every module is a quotient of a free
    module. -/
instance moduleCat_enoughProjectives : EnoughProjectives (ModuleCat.{max u v} R) 
goal: CategoryTheory.EnoughProjectives (ModuleCat R)
File: Mathlib/Algebra/Category/ModuleCat/Simple.lean

full_name: simple_iff_isSimpleModule
code: theorem simple_iff_isSimpleModule : Simple (of R M) ↔ IsSimpleModule R M 
goal: CategoryTheory.Simple (ModuleCat.of R M) ↔ IsSimpleModule R M

full_name: simple_iff_isSimpleModule'
code: theorem simple_iff_isSimpleModule' (M : ModuleCat R) : Simple M ↔ IsSimpleModule R M 
goal: CategoryTheory.Simple M ↔ IsSimpleModule R ↑M

full_name: simple_of_isSimpleModule
code: /-- A simple module is a simple object in the category of modules. -/
instance simple_of_isSimpleModule [IsSimpleModule R M] : Simple (of R M) 
goal: CategoryTheory.Simple (ModuleCat.of R M)

full_name: isSimpleModule_of_simple
code: /-- A simple object in the category of modules is a simple module. -/
instance isSimpleModule_of_simple (M : ModuleCat R) [Simple M] : IsSimpleModule R M 
goal: IsSimpleModule R ↑M

full_name: simple_of_finrank_eq_one
code: /-- Any `k`-algebra module which is 1-dimensional over `k` is simple. -/
theorem simple_of_finrank_eq_one {k : Type*} [Field k] [Algebra k R] {V : ModuleCat R}
    (h : finrank k V = 1) : Simple V 
goal: CategoryTheory.Simple V
File: Mathlib/Algebra/Category/ModuleCat/Abelian.lean

full_name: ModuleCat.normalMono
code: /-- In the category of modules, every monomorphism is normal. -/
def normalMono (hf : Mono f) : NormalMono f 
goal: CategoryTheory.NormalMono f

full_name: ModuleCat.normalEpi
code: /-- In the category of modules, every epimorphism is normal. -/
def normalEpi (hf : Epi f) : NormalEpi f 
goal: CategoryTheory.NormalEpi f

full_name: ModuleCat.abelian
code: /-- The category of R-modules is abelian. -/
instance abelian : Abelian (ModuleCat.{v} R) 
goal: CategoryTheory.Abelian (ModuleCat R)

full_name: ModuleCat.instHasLimitsOfSizeModuleCatMax
code: instance : HasLimitsOfSize.{v,v} (ModuleCatMax.{v, w} R) 
goal: CategoryTheory.Limits.HasLimitsOfSize.{v, v, max v w, max (max (v + 1) (w + 1)) u} (ModuleCatMax R)

full_name: ModuleCat.forgetReflectsLimitsOfSize
code: instance forgetReflectsLimitsOfSize :
    ReflectsLimitsOfSize.{v, v} (forget (ModuleCatMax.{v, w} R)) 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{v, v, max v w, max v w, max (max u (v + 1)) (w + 1), max (v + 1) (w + 1)}
  (CategoryTheory.forget (ModuleCatMax R))

full_name: ModuleCat.forget₂ReflectsLimitsOfSize
code: instance forget₂ReflectsLimitsOfSize :
    ReflectsLimitsOfSize.{v, v} (forget₂ (ModuleCatMax.{v, w} R) AddCommGrp.{max v w}) 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{v, v, max v w, max v w, max (max u (v + 1)) (w + 1), max (v + 1) (w + 1)}
  (CategoryTheory.forget₂ (ModuleCatMax R) AddCommGrp)

full_name: ModuleCat.forgetReflectsLimits
code: instance forgetReflectsLimits : ReflectsLimits (forget (ModuleCat.{v} R)) 
goal: CategoryTheory.Limits.ReflectsLimits (CategoryTheory.forget (ModuleCat R))

full_name: ModuleCat.forget₂ReflectsLimits
code: instance forget₂ReflectsLimits : ReflectsLimits (forget₂ (ModuleCat.{v} R) AddCommGrp.{v}) 
goal: CategoryTheory.Limits.ReflectsLimits (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)
File: Mathlib/Algebra/Category/ModuleCat/Products.lean

full_name: ModuleCat.productCone
code: /-- The product cone induced by the concrete product. -/
def productCone : Fan Z 
goal: CategoryTheory.Limits.Fan Z

full_name: ModuleCat.productConeIsLimit
code: /-- The concrete product cone is limiting. -/
def productConeIsLimit : IsLimit (productCone Z) 
goal: CategoryTheory.Limits.IsLimit (ModuleCat.productCone Z)

full_name: ModuleCat.piIsoPi
code: /-- The categorical product of a family of objects in `ModuleCat`
agrees with the usual module-theoretical product.
-/
noncomputable def piIsoPi : ∏ᶜ Z ≅ ModuleCat.of R (∀ i, Z i) 
goal: ∏ᶜ Z ≅ ModuleCat.of R ((i : ι) → ↑(Z i))

full_name: ModuleCat.piIsoPi_inv_kernel_ι
code: @[simp, elementwise]
theorem piIsoPi_inv_kernel_ι (i : ι) :
    (piIsoPi Z).inv ≫ Pi.π Z i = (LinearMap.proj i : (∀ i : ι, Z i) →ₗ[R] Z i) 
goal: (ModuleCat.piIsoPi Z).inv ≫ CategoryTheory.Limits.Pi.π Z i = LinearMap.proj i

full_name: ModuleCat.piIsoPi_hom_ker_subtype
code: @[simp, elementwise]
theorem piIsoPi_hom_ker_subtype (i : ι) :
    (piIsoPi Z).hom ≫ (LinearMap.proj i : (∀ i : ι, Z i) →ₗ[R] Z i) = Pi.π Z i 
goal: (ModuleCat.piIsoPi Z).hom ≫ LinearMap.proj i = CategoryTheory.Limits.Pi.π Z i
File: Mathlib/Algebra/Category/ModuleCat/Injective.lean

full_name: instEnoughInjectivesModuleCatInt
code: instance : EnoughInjectives (ModuleCat.{v} ℤ) 
goal: CategoryTheory.EnoughInjectives (ModuleCat ℤ)

full_name: ModuleCat.enoughInjectives
code: lemma ModuleCat.enoughInjectives : EnoughInjectives (ModuleCat.{max v u} R) 
goal: CategoryTheory.EnoughInjectives (ModuleCat R)

full_name: instEnoughInjectivesModuleCatOfUnivLE
code: instance [UnivLE.{u,v}] : EnoughInjectives (ModuleCat.{v} R) 
goal: CategoryTheory.EnoughInjectives (ModuleCat R)
File: Mathlib/Algebra/Category/ModuleCat/Presheaf/Abelian.lean

full_name: PresheafOfModules.instNormalEpiCategory
code: noncomputable instance : NormalEpiCategory (PresheafOfModules.{v} R) 
goal: CategoryTheory.NormalEpiCategory (PresheafOfModules R)

full_name: PresheafOfModules.instNormalMonoCategory
code: noncomputable instance : NormalMonoCategory (PresheafOfModules.{v} R) 
goal: CategoryTheory.NormalMonoCategory (PresheafOfModules R)

full_name: PresheafOfModules.instAbelian
code: noncomputable instance : Abelian (PresheafOfModules.{v} R) 
goal: CategoryTheory.Abelian (PresheafOfModules R)
File: Mathlib/Algebra/Category/ModuleCat/Subobject.lean

full_name: ModuleCat.subobjectModule
code: /-- The categorical subobjects of a module `M` are in one-to-one correspondence with its
    submodules. -/
noncomputable def subobjectModule : Subobject M ≃o Submodule R M 
goal: CategoryTheory.Subobject M ≃o Submodule R ↑M

full_name: ModuleCat.wellPowered_moduleCat
code: instance wellPowered_moduleCat : WellPowered (ModuleCat.{v} R) 
goal: CategoryTheory.WellPowered (ModuleCat R)

full_name: ModuleCat.toKernelSubobject
code: /-- Bundle an element `m : M` such that `f m = 0` as a term of `kernelSubobject f`. -/
noncomputable def toKernelSubobject {M N : ModuleCat.{v} R} {f : M ⟶ N} :
    LinearMap.ker f →ₗ[R] kernelSubobject f 
goal: ↥(LinearMap.ker f) →ₗ[R] ↑(CategoryTheory.Subobject.underlying.obj (CategoryTheory.Limits.kernelSubobject f))

full_name: ModuleCat.toKernelSubobject_arrow
code: @[simp]
theorem toKernelSubobject_arrow {M N : ModuleCat R} {f : M ⟶ N} (x : LinearMap.ker f) :
    (kernelSubobject f).arrow (toKernelSubobject x) = x.1 
goal: (CategoryTheory.Limits.kernelSubobject f).arrow (ModuleCat.toKernelSubobject x) = ↑x

full_name: ModuleCat.cokernel_π_imageSubobject_ext
code: /-- An extensionality lemma showing that two elements of a cokernel by an image
are equal if they differ by an element of the image.

The application is for homology:
two elements in homology are equal if they differ by a boundary.
-/
-- Porting note (#11215): TODO compiler complains that this is marked with `@[ext]`.
-- Should this be changed?
-- @[ext] this is no longer an ext lemma under the current interpretation see eg
-- the conversation beginning at
-- https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/
-- Goal.20state.20not.20updating.2C.20bugs.2C.20etc.2E/near/338456803
theorem cokernel_π_imageSubobject_ext {L M N : ModuleCat.{v} R} (f : L ⟶ M) [HasImage f]
    (g : (imageSubobject f : ModuleCat.{v} R) ⟶ N) [HasCokernel g] {x y : N} (l : L)
    (w : x = y + g (factorThruImageSubobject f l)) : cokernel.π g x = cokernel.π g y 
goal: (CategoryTheory.Limits.cokernel.π g) x = (CategoryTheory.Limits.cokernel.π g) y
File: Mathlib/Algebra/Category/ModuleCat/Presheaf/ChangeOfRings.lean

full_name: PresheafOfModules.restrictScalarsBundledCore
code: /-- The restriction of scalars of presheaves of modules, on objects. -/
@[simps]
noncomputable def restrictScalarsBundledCore (M' : PresheafOfModules R') (α : R ⟶ R') :
    BundledCorePresheafOfModules R 
goal: BundledCorePresheafOfModules R

full_name: PresheafOfModules.restrictScalarsBundledCore_map_apply
code: /-- The restriction of scalars of presheaves of modules, on objects. -/
@[simps]
noncomputable def restrictScalarsBundledCore (M' : PresheafOfModules R') (α : R ⟶ R') :
    BundledCorePresheafOfModules R 
goal: ((M'.restrictScalarsBundledCore α).map f) a = (M'.map f) a

full_name: PresheafOfModules.restrictScalarsBundledCore_obj
code: /-- The restriction of scalars of presheaves of modules, on objects. -/
@[simps]
noncomputable def restrictScalarsBundledCore (M' : PresheafOfModules R') (α : R ⟶ R') :
    BundledCorePresheafOfModules R 
goal: (M'.restrictScalarsBundledCore α).obj X = (ModuleCat.restrictScalars (α.app X)).obj (M'.obj X)

full_name: PresheafOfModules.restrictScalars
code: /-- The restriction of scalars functor `PresheafOfModules R' ⥤ PresheafOfModules R`
induced by a morphism of presheaves of rings `R ⟶ R'`. -/
@[simps]
noncomputable def restrictScalars (α : R ⟶ R') :
    PresheafOfModules.{v} R' ⥤ PresheafOfModules.{v} R 
goal: PresheafOfModules R' ⥤ PresheafOfModules R

full_name: PresheafOfModules.restrictScalars_obj
code: /-- The restriction of scalars functor `PresheafOfModules R' ⥤ PresheafOfModules R`
induced by a morphism of presheaves of rings `R ⟶ R'`. -/
@[simps]
noncomputable def restrictScalars (α : R ⟶ R') :
    PresheafOfModules.{v} R' ⥤ PresheafOfModules.{v} R 
goal: (PresheafOfModules.restrictScalars α).obj M' = (M'.restrictScalarsBundledCore α).toPresheafOfModules

full_name: PresheafOfModules.restrictScalars_map_hom
code: /-- The restriction of scalars functor `PresheafOfModules R' ⥤ PresheafOfModules R`
induced by a morphism of presheaves of rings `R ⟶ R'`. -/
@[simps]
noncomputable def restrictScalars (α : R ⟶ R') :
    PresheafOfModules.{v} R' ⥤ PresheafOfModules.{v} R 
goal: ((PresheafOfModules.restrictScalars α).map φ).hom = φ.hom

full_name: PresheafOfModules.instAdditiveRestrictScalars
code: instance (α : R ⟶ R') : (restrictScalars.{v} α).Additive 
goal: (PresheafOfModules.restrictScalars α).Additive

full_name: PresheafOfModules.instFullRestrictScalarsIdFunctorOppositeRingCat
code: instance : (restrictScalars (𝟙 R)).Full 
goal: (PresheafOfModules.restrictScalars (𝟙 R)).Full

full_name: PresheafOfModules.instFaithfulRestrictScalars
code: instance (α : R ⟶ R') : (restrictScalars α).Faithful 
goal: (PresheafOfModules.restrictScalars α).Faithful
File: Mathlib/Algebra/Category/ModuleCat/Algebra.lean

full_name: ModuleCat.moduleOfAlgebraModule
code: /-- Type synonym for considering a module over a `k`-algebra as a `k`-module. -/
def moduleOfAlgebraModule (M : ModuleCat.{v} A) : Module k M 
goal: Module k ↑M

full_name: ModuleCat.isScalarTower_of_algebra_moduleCat
code: theorem isScalarTower_of_algebra_moduleCat (M : ModuleCat.{v} A) : IsScalarTower k A M 
goal: IsScalarTower k A ↑M

full_name: ModuleCat.linearOverField
code: instance linearOverField : Linear k (ModuleCat.{v} A) 
goal: CategoryTheory.Linear k (ModuleCat A)
File: Mathlib/Algebra/Category/ModuleCat/Sheaf/Abelian.lean

full_name: SheafOfModules.instAbelian
code: noncomputable instance : Abelian (SheafOfModules.{v} R) 
goal: CategoryTheory.Abelian (SheafOfModules R)
File: Mathlib/Algebra/Category/ModuleCat/Sheaf/ChangeOfRings.lean

full_name: SheafOfModules.restrictScalars_map_val
code: /-- The restriction of scalars functor `SheafOfModules R' ⥤ SheafOfModules R`
induced by a morphism of sheaves of rings `R ⟶ R'`. -/
@[simps]
noncomputable def restrictScalars :
    SheafOfModules.{v} R' ⥤ SheafOfModules.{v} R 
goal: ∀ {X Y : SheafOfModules R'} (φ : X ⟶ Y),
  ((SheafOfModules.restrictScalars α).map φ).val = (PresheafOfModules.restrictScalars α.val).map φ.val

full_name: SheafOfModules.restrictScalars
code: /-- The restriction of scalars functor `SheafOfModules R' ⥤ SheafOfModules R`
induced by a morphism of sheaves of rings `R ⟶ R'`. -/
@[simps]
noncomputable def restrictScalars :
    SheafOfModules.{v} R' ⥤ SheafOfModules.{v} R 
goal: SheafOfModules R' ⥤ SheafOfModules R

full_name: SheafOfModules.restrictScalars_obj_val
code: /-- The restriction of scalars functor `SheafOfModules R' ⥤ SheafOfModules R`
induced by a morphism of sheaves of rings `R ⟶ R'`. -/
@[simps]
noncomputable def restrictScalars :
    SheafOfModules.{v} R' ⥤ SheafOfModules.{v} R 
goal: ((SheafOfModules.restrictScalars α).obj M').val = (PresheafOfModules.restrictScalars α.val).obj M'.val

full_name: SheafOfModules.instAdditiveRestrictScalars
code: instance : (restrictScalars.{v} α).Additive 
goal: (SheafOfModules.restrictScalars α).Additive

full_name: PresheafOfModules.restrictHomEquivOfIsLocallySurjective
code: /-- The functor `PresheafOfModules.restrictScalars α` induces bijection on
morphisms if `α` is locally surjective and the target presheaf is a sheaf. -/
noncomputable def restrictHomEquivOfIsLocallySurjective :
    (M₁ ⟶ M₂) ≃ ((restrictScalars α).obj M₁ ⟶ (restrictScalars α).obj M₂) 
goal: (M₁ ⟶ M₂) ≃ ((PresheafOfModules.restrictScalars α).obj M₁ ⟶ (PresheafOfModules.restrictScalars α).obj M₂)
File: Mathlib/Algebra/Category/ModuleCat/Sheaf/Colimits.lean

full_name: SheafOfModules.instHasColimitsOfShapeOfPresheafOfModulesValRingCat
code: instance [HasColimitsOfShape K (PresheafOfModules.{v} R.val)] :
    HasColimitsOfShape K (SheafOfModules.{v} R) 
goal: CategoryTheory.Limits.HasColimitsOfShape K (SheafOfModules R)
File: Mathlib/Algebra/Category/ModuleCat/Sheaf/PushforwardContinuous.lean

full_name: SheafOfModules.pushforward_map_val
code: /-- The pushforward of sheaves of modules that is induced by a continuous functor `F`
and a morphism of sheaves of rings `φ : S ⟶ (F.sheafPushforwardContinuous RingCat J K).obj R`. -/
@[simps]
noncomputable def pushforward : SheafOfModules.{v} R ⥤ SheafOfModules.{v} S 
goal: ∀ {X Y : SheafOfModules R} (f : X ⟶ Y),
  ((SheafOfModules.pushforward φ).map f).val = (PresheafOfModules.pushforward φ.val).map f.val

full_name: SheafOfModules.pushforward_obj_val
code: /-- The pushforward of sheaves of modules that is induced by a continuous functor `F`
and a morphism of sheaves of rings `φ : S ⟶ (F.sheafPushforwardContinuous RingCat J K).obj R`. -/
@[simps]
noncomputable def pushforward : SheafOfModules.{v} R ⥤ SheafOfModules.{v} S 
goal: ((SheafOfModules.pushforward φ).obj M).val = (PresheafOfModules.pushforward φ.val).obj M.val

full_name: SheafOfModules.pushforward
code: /-- The pushforward of sheaves of modules that is induced by a continuous functor `F`
and a morphism of sheaves of rings `φ : S ⟶ (F.sheafPushforwardContinuous RingCat J K).obj R`. -/
@[simps]
noncomputable def pushforward : SheafOfModules.{v} R ⥤ SheafOfModules.{v} S 
goal: SheafOfModules R ⥤ SheafOfModules S

full_name: SheafOfModules.over
code: /-- Given `M : SheafOfModules R` and `X : D`, this is the restriction of `M`
over the sheaf of rings `R.over X` on the category `Over X`. -/
noncomputable abbrev over (M : SheafOfModules.{v} R) (X : D) : SheafOfModules.{v} (R.over X) 
goal: SheafOfModules (R.over X)