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.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) (j : J) : AddCommGroup ((F.comp (CategoryTheory.forget (ModuleCat R))).obj j)

Equations

• ModuleCat.addCommGroupObj F j = inferInstanceAs (AddCommGroup ↑(F.obj j))

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

Equations

• ModuleCat.moduleObj F j = inferInstanceAs (Module R ↑(F.obj j))

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

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

Equations

• ModuleCat.sectionsSubmodule F = { carrier := (F.comp (CategoryTheory.forget (ModuleCat R))).sections, add_mem' := ⋯, zero_mem' := ⋯, smul_mem' := ⋯ }

instance ModuleCat.instAddCommMonoidElemForallObjCompForgetSections {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) : AddCommMonoid ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections

Equations

• ModuleCat.instAddCommMonoidElemForallObjCompForgetSections F = inferInstanceAs (AddCommMonoid ↥(ModuleCat.sectionsSubmodule F))

instance ModuleCat.instModuleElemForallObjCompForgetSections {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) : Module R ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections

Equations

• ModuleCat.instModuleElemForallObjCompForgetSections F = inferInstanceAs (Module R ↥(ModuleCat.sectionsSubmodule F))

instance ModuleCat.instSmallSubtypeForallCarrierObjMemSubmoduleSectionsSubmodule {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) [Small.{w, max v w} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] : Small.{w, max v w} ↥(sectionsSubmodule F)

instance ModuleCat.limitAddCommMonoid {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) [Small.{w, max v w} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] : AddCommMonoid (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget (ModuleCat R)))).pt

Equations

• ModuleCat.limitAddCommMonoid F = inferInstanceAs (AddCommMonoid (Shrink.{?u.72, max ?u.73 ?u.72} ↥(ModuleCat.sectionsSubmodule F)))

instance ModuleCat.limitAddCommGroup {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) [Small.{w, max v w} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] : AddCommGroup (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget (ModuleCat R)))).pt

Equations

• ModuleCat.limitAddCommGroup F = inferInstanceAs (AddCommGroup (Shrink.{?u.73, max ?u.74 ?u.73} ↥(ModuleCat.sectionsSubmodule F)))

instance ModuleCat.limitModule {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) [Small.{w, max v w} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] : Module R (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget (ModuleCat R)))).pt

Equations

• ModuleCat.limitModule F = inferInstanceAs (Module R (Shrink.{?u.72, max ?u.73 ?u.72} ↥(ModuleCat.sectionsSubmodule F)))

def ModuleCat.limitπLinearMap {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) [Small.{w, max v w} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] (j : J) : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget (ModuleCat R)))).pt →ₗ[R] (F.comp (CategoryTheory.forget (ModuleCat R))).obj j

limit.π (F ⋙ forget (ModuleCat.{w} R)) j as an R-linear map.

Equations

• ModuleCat.limitπLinearMap F j = { toFun := (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget (ModuleCat R)))).π.app j, map_add' := ⋯, map_smul' := ⋯ }

def ModuleCat.HasLimits.limitCone {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) [Small.{w, max v w} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] : CategoryTheory.Limits.Cone F

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

Equations

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

def ModuleCat.HasLimits.limitConeIsLimit {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) [Small.{w, max v w} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] : CategoryTheory.Limits.IsLimit (limitCone F)

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

Equations

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

instance ModuleCat.hasLimit {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) [Small.{w, max v w} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] : CategoryTheory.Limits.HasLimit F

If (F ⋙ forget (ModuleCat R)).sections is u-small, F has a limit.

theorem ModuleCat.hasLimitsOfShape {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] [Small.{w, v} J] : CategoryTheory.Limits.HasLimitsOfShape J (ModuleCat R)

If J is u-small, the category of R-modules has limits of shape J.

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

The category of R-modules has all limits.

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

@[instance 10000]

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

def ModuleCat.forget₂AddCommGroup_preservesLimitsAux {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) [Small.{w, max v w} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] : CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).mapCone (HasLimits.limitCone F))

An auxiliary declaration to speed up typechecking.

Equations

• ModuleCat.forget₂AddCommGroup_preservesLimitsAux F = AddCommGrp.limitConeIsLimit (F.comp (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp))

instance ModuleCat.forget₂AddCommGroup_preservesLimit {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) [Small.{w, max v w} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] : CategoryTheory.Limits.PreservesLimit F (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

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

instance ModuleCat.forget₂AddCommGroup_preservesLimitsOfSize {R : Type u} [Ring R] [UnivLE.{v, w}] : CategoryTheory.Limits.PreservesLimitsOfSize.{t, v, w, w, max u (w + 1), w + 1} (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

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

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

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

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

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

instance ModuleCat.forget₂AddCommGroup_reflectsLimit {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] (F : CategoryTheory.Functor J (ModuleCat R)) : CategoryTheory.Limits.ReflectsLimit F (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

instance ModuleCat.forget₂AddCommGroup_reflectsLimitOfShape {R : Type u} [Ring R] {J : Type v} [CategoryTheory.Category.{t, v} J] : CategoryTheory.Limits.ReflectsLimitsOfShape J (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

instance ModuleCat.forget₂AddCommGroup_reflectsLimitOfSize {R : Type u} [Ring R] : CategoryTheory.Limits.ReflectsLimitsOfSize.{t, v, w, w, max u (w + 1), w + 1} (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

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 : i ≤ j) => ⇑(f i j h)] : CategoryTheory.Functor ι (ModuleCat R)

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

Equations

• ModuleCat.directLimitDiagram G f = { obj := fun (i : ι) => ModuleCat.of R (G i), map := fun {X Y : ι} (hij : X ⟶ Y) => ModuleCat.ofHom (f X Y ⋯), map_id := ⋯, map_comp := ⋯ }

@[simp]

theorem ModuleCat.directLimitDiagram_obj_carrier {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 : i ≤ j) => ⇑(f i j h)] (i : ι) : ↑((directLimitDiagram G f).obj i) = 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 : i ≤ j) => ⇑(f i j h)] {X✝ Y✝ : ι} (hij : X✝ ⟶ Y✝) : (directLimitDiagram G f).map hij = ofHom (f X✝ Y✝ ⋯)

@[simp]

theorem ModuleCat.directLimitDiagram_obj_isAddCommGroup {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 : i ≤ j) => ⇑(f i j h)] (i : ι) : ((directLimitDiagram G f).obj i).isAddCommGroup = inst✝ i

@[simp]

theorem ModuleCat.directLimitDiagram_obj_isModule {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 : i ≤ j) => ⇑(f i j h)] (i : ι) : ((directLimitDiagram G f).obj i).isModule = inst✝ i

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 : i ≤ j) => ⇑(f i j h)] [DecidableEq ι] : CategoryTheory.Limits.Cocone (directLimitDiagram G f)

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

In directLimitIsColimit we show that it is a colimit cocone.

Equations

• ModuleCat.directLimitCocone G f = { pt := ModuleCat.of R (Module.DirectLimit G f), ι := { app := fun (x : ι) => ModuleCat.ofHom (Module.DirectLimit.of R ι G f x), naturality := ⋯ } }

@[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 : i ≤ j) => ⇑(f i j h)] [DecidableEq ι] (x : ι) : (directLimitCocone G f).ι.app x = ofHom (Module.DirectLimit.of R ι G f x)

@[simp]

theorem ModuleCat.directLimitCocone_pt_isModule {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 : i ≤ j) => ⇑(f i j h)] [DecidableEq ι] : (directLimitCocone G f).pt.isModule = Module.DirectLimit.module G f

@[simp]

theorem ModuleCat.directLimitCocone_pt_carrier {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 : i ≤ j) => ⇑(f i j h)] [DecidableEq ι] : ↑(directLimitCocone G f).pt = Module.DirectLimit G f

@[simp]

theorem ModuleCat.directLimitCocone_pt_isAddCommGroup {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 : i ≤ j) => ⇑(f i j h)] [DecidableEq ι] : (directLimitCocone G f).pt.isAddCommGroup = Module.DirectLimit.addCommGroup G f

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 : i ≤ j) => ⇑(f i j h)] [DecidableEq ι] : CategoryTheory.Limits.IsColimit (directLimitCocone G f)

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

Equations

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

@[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 : i ≤ j) => ⇑(f i j h)] [DecidableEq ι] (s : CategoryTheory.Limits.Cocone (directLimitDiagram G f)) : (directLimitIsColimit G f).desc s = ofHom (Module.DirectLimit.lift R ι G f (fun (i : ι) => Hom.hom (s.ι.app i)) ⋯)