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

full_name: ModuleCat.addCommGroupObj
code: instance addCommGroupObj (j) :
    AddCommGroup ((F ⋙ forget (ModuleCat R)).obj j) 
goal: AddCommGroup ((F ⋙ CategoryTheory.forget (ModuleCat R)).obj j)

full_name: ModuleCat.moduleObj
code: instance moduleObj (j) :
    Module.{u, w} R ((F ⋙ forget (ModuleCat R)).obj j) 
goal: Module R ((F ⋙ CategoryTheory.forget (ModuleCat R)).obj j)

full_name: ModuleCat.sectionsSubmodule
code: /-- The flat sections of a functor into `ModuleCat R` form a submodule of all sections.
-/
def sectionsSubmodule : Submodule R (∀ j, F.obj j) 
goal: Submodule R ((j : J) → ↑(F.obj j))

full_name: ModuleCat.instAddCommMonoidElemForallObjCompForgetSections
code: instance : AddCommMonoid (F ⋙ forget (ModuleCat R)).sections 
goal: AddCommMonoid ↑(F ⋙ CategoryTheory.forget (ModuleCat R)).sections

full_name: ModuleCat.instModuleElemForallObjCompForgetSections
code: instance : Module R (F ⋙ forget (ModuleCat R)).sections 
goal: Module R ↑(F ⋙ CategoryTheory.forget (ModuleCat R)).sections

full_name: ModuleCat.instSmallSubtypeForallCarrierObjMemSubmoduleSectionsSubmodule
code: instance : Small.{w} (sectionsSubmodule F) 
goal: Small.{w, max v w} ↥(ModuleCat.sectionsSubmodule F)

full_name: ModuleCat.limitAddCommMonoid
code: instance limitAddCommMonoid :
    AddCommMonoid (Types.Small.limitCone.{v, w} (F ⋙ forget (ModuleCat.{w} R))).pt 
goal: AddCommMonoid (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget (ModuleCat R))).pt

full_name: ModuleCat.limitAddCommGroup
code: instance limitAddCommGroup :
    AddCommGroup (Types.Small.limitCone.{v, w} (F ⋙ forget (ModuleCat.{w} R))).pt 
goal: AddCommGroup (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget (ModuleCat R))).pt

full_name: ModuleCat.limitModule
code: instance limitModule :
    Module R (Types.Small.limitCone.{v, w} (F ⋙ forget (ModuleCat.{w} R))).pt 
goal: Module R (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget (ModuleCat R))).pt

full_name: ModuleCat.limitπLinearMap
code: /-- `limit.π (F ⋙ forget (ModuleCat.{w} R)) j` as an `R`-linear map. -/
def limitπLinearMap (j) :
    (Types.Small.limitCone (F ⋙ forget (ModuleCat.{w} R))).pt →ₗ[R]
      (F ⋙ forget (ModuleCat R)).obj j 
goal: (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget (ModuleCat R))).pt →ₗ[R]
  (F ⋙ CategoryTheory.forget (ModuleCat R)).obj j

full_name: ModuleCat.HasLimits.limitCone
code: /-- Construction of a limit cone in `ModuleCat R`.
(Internal use only; use the limits API.)
-/
def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: ModuleCat.HasLimits.limitConeIsLimit
code: /-- Witness that the limit cone in `ModuleCat R` is a limit cone.
(Internal use only; use the limits API.)
-/
def limitConeIsLimit : IsLimit (limitCone.{t, v, w} F) 
goal: CategoryTheory.Limits.IsLimit (ModuleCat.HasLimits.limitCone F)

full_name: ModuleCat.hasLimit
code: /-- If `(F ⋙ forget (ModuleCat R)).sections` is `u`-small, `F` has a limit. -/
instance hasLimit : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: ModuleCat.hasLimitsOfShape
code: /-- If `J` is `u`-small, the category of `R`-modules has limits of shape `J`. -/
lemma hasLimitsOfShape [Small.{w} J] : HasLimitsOfShape J (ModuleCat.{w} R) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (ModuleCat R)

full_name: ModuleCat.hasLimitsOfSize
code: /-- The category of R-modules has all limits. -/
lemma hasLimitsOfSize [UnivLE.{v, w}] : HasLimitsOfSize.{t, v} (ModuleCat.{w} R) 
goal: CategoryTheory.Limits.HasLimitsOfSize.{t, v, w, max (w + 1) u} (ModuleCat R)

full_name: ModuleCat.hasLimits
code: instance hasLimits : HasLimits (ModuleCat.{w} R) 
goal: CategoryTheory.Limits.HasLimits (ModuleCat R)

full_name: ModuleCat.hasLimits'
code: instance (priority := high) hasLimits' : HasLimits (ModuleCat.{u} R) 
goal: CategoryTheory.Limits.HasLimits (ModuleCat R)

full_name: ModuleCat.forget₂AddCommGroupPreservesLimitsAux
code: /-- An auxiliary declaration to speed up typechecking.
-/
def forget₂AddCommGroupPreservesLimitsAux :
    IsLimit ((forget₂ (ModuleCat R) AddCommGrp).mapCone (limitCone F)) 
goal: CategoryTheory.Limits.IsLimit
  ((CategoryTheory.forget₂ (ModuleCat R) AddCommGrp).mapCone (ModuleCat.HasLimits.limitCone F))

full_name: ModuleCat.forget₂AddCommGroupPreservesLimit
code: /-- The forgetful functor from R-modules to abelian groups preserves all limits. -/
instance forget₂AddCommGroupPreservesLimit :
    PreservesLimit F (forget₂ (ModuleCat R) AddCommGrp) 
goal: CategoryTheory.Limits.PreservesLimit F (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

full_name: ModuleCat.forget₂AddCommGroupPreservesLimitsOfSize
code: /-- The forgetful functor from R-modules to abelian groups preserves all limits.
-/
instance forget₂AddCommGroupPreservesLimitsOfSize [UnivLE.{v, w}] :
    PreservesLimitsOfSize.{t, v}
      (forget₂ (ModuleCat.{w} R) AddCommGrp.{w}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{t, v, w, w, max u (w + 1), w + 1}
  (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

full_name: ModuleCat.forget₂AddCommGroupPreservesLimits
code: instance forget₂AddCommGroupPreservesLimits :
    PreservesLimits (forget₂ (ModuleCat R) AddCommGrp.{w}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

full_name: ModuleCat.forgetPreservesLimitsOfSize
code: /-- The forgetful functor from R-modules to types preserves all limits.
-/
instance forgetPreservesLimitsOfSize [UnivLE.{v, w}] :
    PreservesLimitsOfSize.{t, v} (forget (ModuleCat.{w} R)) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{t, v, w, w, max u (w + 1), w + 1} (CategoryTheory.forget (ModuleCat R))

full_name: ModuleCat.forgetPreservesLimits
code: instance forgetPreservesLimits : PreservesLimits (forget (ModuleCat.{w} R)) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget (ModuleCat R))

full_name: ModuleCat.forget₂AddCommGroupReflectsLimit
code: instance forget₂AddCommGroupReflectsLimit :
    ReflectsLimit F (forget₂ (ModuleCat.{w} R) AddCommGrp) 
goal: CategoryTheory.Limits.ReflectsLimit F (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

full_name: ModuleCat.forget₂AddCommGroupReflectsLimitOfShape
code: instance forget₂AddCommGroupReflectsLimitOfShape :
    ReflectsLimitsOfShape J (forget₂ (ModuleCat.{w} R) AddCommGrp) 
goal: CategoryTheory.Limits.ReflectsLimitsOfShape J (CategoryTheory.forget₂ (ModuleCat R) AddCommGrp)

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

full_name: ModuleCat.directLimitDiagram_obj
code: /-- The diagram (in the sense of `CategoryTheory`)
 of an unbundled `directLimit` of modules. -/
@[simps]
def directLimitDiagram : ι ⥤ ModuleCat R 
goal: (ModuleCat.directLimitDiagram G f).obj i = ModuleCat.of R (G i)

full_name: ModuleCat.directLimitDiagram_map
code: /-- The diagram (in the sense of `CategoryTheory`)
 of an unbundled `directLimit` of modules. -/
@[simps]
def directLimitDiagram : ι ⥤ ModuleCat R 
goal: ∀ {X Y : ι} (hij : X ⟶ Y), (ModuleCat.directLimitDiagram G f).map hij = f X Y ⋯

full_name: ModuleCat.directLimitDiagram
code: /-- The diagram (in the sense of `CategoryTheory`)
 of an unbundled `directLimit` of modules. -/
@[simps]
def directLimitDiagram : ι ⥤ ModuleCat R 
goal: ι ⥤ ModuleCat R

full_name: ModuleCat.directLimitCocone_pt
code: /-- The `Cocone` on `directLimitDiagram` corresponding to
the unbundled `directLimit` of modules.

In `directLimitIsColimit` we show that it is a colimit cocone. -/
@[simps]
def directLimitCocone : Cocone (directLimitDiagram G f) 
goal: (ModuleCat.directLimitCocone G f).pt = ModuleCat.of R (Module.DirectLimit G f)

full_name: ModuleCat.directLimitCocone
code: /-- The `Cocone` on `directLimitDiagram` corresponding to
the unbundled `directLimit` of modules.

In `directLimitIsColimit` we show that it is a colimit cocone. -/
@[simps]
def directLimitCocone : Cocone (directLimitDiagram G f) 
goal: CategoryTheory.Limits.Cocone (ModuleCat.directLimitDiagram G f)

full_name: ModuleCat.directLimitCocone_ι_app
code: /-- The `Cocone` on `directLimitDiagram` corresponding to
the unbundled `directLimit` of modules.

In `directLimitIsColimit` we show that it is a colimit cocone. -/
@[simps]
def directLimitCocone : Cocone (directLimitDiagram G f) 
goal: (ModuleCat.directLimitCocone G f).ι.app i = Module.DirectLimit.of R ι G f i

full_name: ModuleCat.directLimitIsColimit_desc
code: /-- The unbundled `directLimit` of modules is a colimit
in the sense of `CategoryTheory`. -/
@[simps]
def directLimitIsColimit [IsDirected ι (· ≤ ·)] : IsColimit (directLimitCocone G f) 
goal: (ModuleCat.directLimitIsColimit G f).desc s = Module.DirectLimit.lift R ι G f s.ι.app ⋯

full_name: ModuleCat.directLimitIsColimit
code: /-- The unbundled `directLimit` of modules is a colimit
in the sense of `CategoryTheory`. -/
@[simps]
def directLimitIsColimit [IsDirected ι (· ≤ ·)] : IsColimit (directLimitCocone G f) 
goal: CategoryTheory.Limits.IsColimit (ModuleCat.directLimitCocone G f)