The category of R-modules has all limits

Further, these limits are preserved by the forgetful functor --- that is, the underlying types are just the limits in the category of types.

instance ModuleCat.addCommGroupObj {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J (ModuleCatMax R)) (j : J) : AddCommGroup ((CategoryTheory.Functor.comp F (CategoryTheory.forget (ModuleCat R))).obj j)

instance ModuleCat.moduleObj {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J (ModuleCatMax R)) (j : J) : Module R ((CategoryTheory.Functor.comp F (CategoryTheory.forget (ModuleCat R))).obj j)

def ModuleCat.sectionsSubmodule {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J (ModuleCatMax R)) : Submodule R ((j : J) → ↑(F.obj j))

The flat sections of a functor into ModuleCat R form a submodule of all sections.

instance ModuleCat.limitAddCommMonoid {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J (ModuleCatMax R)) : AddCommMonoid (CategoryTheory.Limits.Types.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget (ModuleCatMax R)))).pt

instance ModuleCat.limitAddCommGroup {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J (ModuleCatMax R)) : AddCommGroup (CategoryTheory.Limits.Types.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget (ModuleCatMax R)))).pt

instance ModuleCat.limitModule {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J (ModuleCatMax R)) : Module R (CategoryTheory.Limits.Types.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget (ModuleCat R)))).pt

def ModuleCat.limitπLinearMap {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J (ModuleCatMax R)) (j : J) : (CategoryTheory.Limits.Types.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget (ModuleCat R)))).pt →ₗ[R] (CategoryTheory.Functor.comp F (CategoryTheory.forget (ModuleCat R))).obj j

limit.π (F ⋙ forget Ring) j as a RingHom.

def ModuleCat.HasLimits.limitCone {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J (ModuleCatMax R)) : CategoryTheory.Limits.Cone F

Construction of a limit cone in ModuleCat R. (Internal use only; use the limits API.)

def ModuleCat.HasLimits.limitConeIsLimit {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J (ModuleCatMax R)) : CategoryTheory.Limits.IsLimit (ModuleCat.HasLimits.limitCone F)

Witness that the limit cone in ModuleCat R is a limit cone. (Internal use only; use the limits API.)

theorem ModuleCat.hasLimitsOfSize {R : Type u} [Ring R] : CategoryTheory.Limits.HasLimitsOfSize.{v, v, max v w, max (max u (v + 1)) (w + 1)} (ModuleCatMax R)

The category of R-modules has all limits.

instance ModuleCat.hasLimits {R : Type u} [Ring R] : CategoryTheory.Limits.HasLimits (ModuleCat R)

instance ModuleCat.hasLimits' {R : Type u} [Ring R] : CategoryTheory.Limits.HasLimits (ModuleCat R)

def ModuleCat.forget₂AddCommGroupPreservesLimitsAux {R : Type u} [Ring R] {J : Type v} [CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J (ModuleCatMax R)) : CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ (ModuleCat R) AddCommGroupCat).mapCone (ModuleCat.HasLimits.limitCone F))

An auxiliary declaration to speed up typechecking.

instance ModuleCat.forget₂AddCommGroupPreservesLimitsOfSize {R : Type u} [Ring R] : CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, max v w, max v w, max (max u (v + 1)) (w + 1), max (v + 1) (w + 1)} (CategoryTheory.forget₂ (ModuleCatMax R) AddCommGroupCat)

The forgetful functor from R-modules to abelian groups preserves all limits.

instance ModuleCat.forget₂AddCommGroupPreservesLimits {R : Type u} [Ring R] : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ (ModuleCat R) AddCommGroupCat)

instance ModuleCat.forgetPreservesLimitsOfSize {R : Type u} [Ring R] : CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, max v w, max v w, max (max u (v + 1)) (w + 1), max (v + 1) (w + 1)} (CategoryTheory.forget (ModuleCatMax R))

The forgetful functor from R-modules to types preserves all limits.

instance ModuleCat.forgetPreservesLimits {R : Type u} [Ring R] : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget (ModuleCat R))

@[simp]

theorem ModuleCat.directLimitDiagram_obj {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ↑(f i j h)] (i : ι) : (ModuleCat.directLimitDiagram G f).obj i = ModuleCat.of R (G i)

@[simp]

theorem ModuleCat.directLimitDiagram_map {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ↑(f i j h)] : ∀ {X Y : ι} (hij : X ⟶ Y), (ModuleCat.directLimitDiagram G f).map hij = f X Y (_ : X ≤ Y)

def ModuleCat.directLimitDiagram {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ↑(f i j h)] : CategoryTheory.Functor ι (ModuleCat R)

The diagram (in the sense of CategoryTheory) of an unbundled directLimit of modules.

@[simp]

theorem ModuleCat.directLimitCocone_ι_app {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ↑(f i j h)] [DecidableEq ι] (i : ι) : (ModuleCat.directLimitCocone G f).ι.app i = Module.DirectLimit.of R ι G f i

@[simp]

theorem ModuleCat.directLimitCocone_pt {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ↑(f i j h)] [DecidableEq ι] : (ModuleCat.directLimitCocone G f).pt = ModuleCat.of R (Module.DirectLimit G f)

def ModuleCat.directLimitCocone {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ↑(f i j h)] [DecidableEq ι] : CategoryTheory.Limits.Cocone (ModuleCat.directLimitDiagram G f)

The Cocone on directLimitDiagram corresponding to the unbundled directLimit of modules.

In directLimitIsColimit we show that it is a colimit cocone.

@[simp]

theorem ModuleCat.directLimitIsColimit_desc {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ↑(f i j h)] [DecidableEq ι] [Nonempty ι] [IsDirected ι fun x x_1 => x ≤ x_1] (s : CategoryTheory.Limits.Cocone (ModuleCat.directLimitDiagram G f)) : CategoryTheory.Limits.IsColimit.desc (ModuleCat.directLimitIsColimit G f) s = Module.DirectLimit.lift R ι G f s.ι.app (_ : ∀ (i j : ι) (h : i ≤ j) (x : G i), ↑(s.ι.app j) (↑(f i j h) x) = ↑(s.ι.app i) x)

def ModuleCat.directLimitIsColimit {R : Type u} [Ring R] {ι : Type v} [Preorder ι] (G : ι → Type v) [(i : ι) → AddCommGroup (G i)] [(i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) [DirectedSystem G fun i j h => ↑(f i j h)] [DecidableEq ι] [Nonempty ι] [IsDirected ι fun x x_1 => x ≤ x_1] : CategoryTheory.Limits.IsColimit (ModuleCat.directLimitCocone G f)

The unbundled directLimit of modules is a colimit in the sense of CategoryTheory.