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} ↥(ModuleCat.sectionsSubmodule F)

Equations

• ⋯ = ⋯

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.77, max ?u.78 ?u.77} ↥(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.78, max ?u.79 ?u.78} ↥(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.77, max ?u.78 ?u.77} ↥(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 (ModuleCat.HasLimits.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.

Equations

• ⋯ = ⋯

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)

Equations

• ⋯ = ⋯

@[instance 10000]

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

Equations

• ⋯ = ⋯

def ModuleCat.forget₂AddCommGroupPreservesLimitsAux {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 (ModuleCat.HasLimits.limitCone F))

An auxiliary declaration to speed up typechecking.

Equations

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

instance ModuleCat.forget₂AddCommGroupPreservesLimit {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.

Equations

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

instance ModuleCat.forget₂AddCommGroupPreservesLimitsOfSize {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.

Equations

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

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

Equations

• ModuleCat.forget₂AddCommGroupPreservesLimits = ModuleCat.forget₂AddCommGroupPreservesLimitsOfSize

instance ModuleCat.forgetPreservesLimitsOfSize {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.

Equations

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

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

Equations

• ModuleCat.forgetPreservesLimits = ModuleCat.forgetPreservesLimitsOfSize

instance ModuleCat.forget₂AddCommGroupReflectsLimit {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)

Equations

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

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

Equations

• ModuleCat.forget₂AddCommGroupReflectsLimitOfShape = { reflectsLimit := fun {K : CategoryTheory.Functor J (ModuleCat R)} => inferInstance }

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

Equations

• ModuleCat.forget₂AddCommGroupReflectsLimitOfSize = { reflectsLimitsOfShape := fun {J : Type ?u.26} [CategoryTheory.Category.{?u.27, ?u.26} J] => inferInstance }

@[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), (ModuleCat.directLimitDiagram G f).map hij = f X Y ⋯

@[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 : i ≤ j) => ⇑(f i j h)] (i : ι) : (ModuleCat.directLimitDiagram G f).obj i = ModuleCat.of R (G i)

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) => f X Y ⋯, map_id := ⋯, map_comp := ⋯ }

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

@[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 ι] (i : ι) : (ModuleCat.directLimitCocone G f).ι.app i = Module.DirectLimit.of R ι G f 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 (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.

Equations

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

@[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 ι] [IsDirected ι fun (x1 x2 : ι) => x1 ≤ x2] (s : CategoryTheory.Limits.Cocone (ModuleCat.directLimitDiagram G f)) : (ModuleCat.directLimitIsColimit G f).desc s = Module.DirectLimit.lift R ι G f s.ι.app ⋯

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 ι] [IsDirected ι fun (x1 x2 : ι) => x1 ≤ x2] : CategoryTheory.Limits.IsColimit (ModuleCat.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.