The category of (commutative) rings 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 SemiRingCat.semiringObj {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J SemiRingCat) (j : J) : Semiring ((F.comp (CategoryTheory.forget SemiRingCat)).obj j)

Equations

• SemiRingCat.semiringObj F j = inferInstanceAs (Semiring ↑(F.obj j))

def SemiRingCat.sectionsSubsemiring {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J SemiRingCat) : Subsemiring ((j : J) → ↑(F.obj j))

The flat sections of a functor into SemiRingCat form a subsemiring of all sections.

Equations

• SemiRingCat.sectionsSubsemiring F = { carrier := (F.comp (CategoryTheory.forget SemiRingCat)).sections, mul_mem' := ⋯, one_mem' := ⋯, add_mem' := ⋯, zero_mem' := ⋯ }

instance SemiRingCat.sectionsSemiring {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J SemiRingCat) : Semiring ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections

Equations

• SemiRingCat.sectionsSemiring F = (SemiRingCat.sectionsSubsemiring F).toSemiring

instance SemiRingCat.limitSemiring {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J SemiRingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] : Semiring (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget SemiRingCat))).pt

Equations

• SemiRingCat.limitSemiring F = inferInstanceAs (Semiring (Shrink.{?u.65, max ?u.65 ?u.66} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections))

def SemiRingCat.limitπRingHom {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J SemiRingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] (j : J) : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget SemiRingCat))).pt →+* (F.comp (CategoryTheory.forget SemiRingCat)).obj j

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

Equations

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

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

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

Equations

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

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

Witness that the limit cone in SemiRingCat 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 SemiRingCat.hasLimit {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J SemiRingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] : CategoryTheory.Limits.HasLimit F

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

Equations

• ⋯ = ⋯

instance SemiRingCat.hasLimitsOfShape {J : Type v} [CategoryTheory.Category.{w, v} J] [Small.{u, v} J] : CategoryTheory.Limits.HasLimitsOfShape J SemiRingCat

If J is u-small, SemiRingCat.{u} has limits of shape J.

Equations

• ⋯ = ⋯

instance SemiRingCat.hasLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} SemiRingCat

The category of rings has all limits.

Equations

• ⋯ = ⋯

instance SemiRingCat.hasLimits : CategoryTheory.Limits.HasLimits SemiRingCat

Equations

• SemiRingCat.hasLimits = ⋯

def SemiRingCat.forget₂AddCommMonPreservesLimitsAux {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J SemiRingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] : CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ SemiRingCat AddCommMonCat).mapCone (SemiRingCat.HasLimits.limitCone F))

Auxiliary lemma to prove the cone induced by limitCone is a limit cone.

Equations

• SemiRingCat.forget₂AddCommMonPreservesLimitsAux F = AddCommMonCat.limitConeIsLimit (F.comp (CategoryTheory.forget₂ SemiRingCat AddCommMonCat))

instance SemiRingCat.forget₂AddCommMon_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ SemiRingCat AddCommMonCat)

The forgetful functor from semirings to additive commutative monoids preserves all limits.

Equations

• ⋯ = ⋯

instance SemiRingCat.forget₂AddCommMon_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ SemiRingCat AddCommMonCat)

Equations

• SemiRingCat.forget₂AddCommMon_preservesLimits = ⋯

def SemiRingCat.forget₂MonPreservesLimitsAux {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J SemiRingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] : CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ SemiRingCat MonCat).mapCone (SemiRingCat.HasLimits.limitCone F))

An auxiliary declaration to speed up typechecking.

Equations

• SemiRingCat.forget₂MonPreservesLimitsAux F = MonCat.HasLimits.limitConeIsLimit (F.comp (CategoryTheory.forget₂ SemiRingCat MonCat))

instance SemiRingCat.forget₂Mon_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ SemiRingCat MonCat)

The forgetful functor from semirings to monoids preserves all limits.

Equations

• ⋯ = ⋯

instance SemiRingCat.forget₂Mon_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ SemiRingCat MonCat)

Equations

• SemiRingCat.forget₂Mon_preservesLimits = ⋯

instance SemiRingCat.forget_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget SemiRingCat)

The forgetful functor from semirings to types preserves all limits.

Equations

• ⋯ = ⋯

instance SemiRingCat.forget_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget SemiRingCat)

Equations

• SemiRingCat.forget_preservesLimits = ⋯

@[reducible, inline]

abbrev CommSemiRingCatMax : Type ((max u1 u2) + 1)

An alias for CommSemiring.{max u v}, to deal with unification issues.

Equations

• CommSemiRingCatMax = CommSemiRingCat

instance CommSemiRingCat.commSemiringObj {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommSemiRingCat) (j : J) : CommSemiring ((F.comp (CategoryTheory.forget CommSemiRingCat)).obj j)

Equations

• CommSemiRingCat.commSemiringObj F j = inferInstanceAs (CommSemiring ↑(F.obj j))

instance CommSemiRingCat.limitCommSemiring {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommSemiRingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections] : CommSemiring (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommSemiRingCat))).pt

Equations

• CommSemiRingCat.limitCommSemiring F = inferInstanceAs (CommSemiring (Shrink.{?u.65, max ?u.65 ?u.66} ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections))

instance CommSemiRingCat.instCreatesLimitSemiRingCatForget₂ {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommSemiRingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections] : CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ CommSemiRingCat SemiRingCat)

We show that the forgetful functor CommSemiRingCat ⥤ SemiRingCat creates limits.

All we need to do is notice that the limit point has a CommSemiring instance available, and then reuse the existing limit.

Equations

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

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

A choice of limit cone for a functor into CommSemiRingCat. (Generally, you'll just want to use limit F.)

Equations

• CommSemiRingCat.limitCone F = CategoryTheory.liftLimit (CategoryTheory.Limits.limit.isLimit (F.comp (CategoryTheory.forget₂ CommSemiRingCat SemiRingCat)))

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

The chosen cone is a limit cone. (Generally, you'll just want to use limit.cone F.)

Equations

• CommSemiRingCat.limitConeIsLimit F = CategoryTheory.liftedLimitIsLimit (CategoryTheory.Limits.limit.isLimit (F.comp (CategoryTheory.forget₂ CommSemiRingCat SemiRingCat)))

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

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

Equations

• ⋯ = ⋯

instance CommSemiRingCat.hasLimitsOfShape {J : Type v} [CategoryTheory.Category.{w, v} J] [Small.{u, v} J] : CategoryTheory.Limits.HasLimitsOfShape J CommSemiRingCat

If J is u-small, CommSemiRingCat.{u} has limits of shape J.

Equations

• ⋯ = ⋯

instance CommSemiRingCat.hasLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} CommSemiRingCat

The category of rings has all limits.

Equations

• ⋯ = ⋯

instance CommSemiRingCat.hasLimits : CategoryTheory.Limits.HasLimits CommSemiRingCat

Equations

• CommSemiRingCat.hasLimits = ⋯

instance CommSemiRingCat.forget₂SemiRing_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ CommSemiRingCat SemiRingCat)

The forgetful functor from rings to semirings preserves all limits.

Equations

• ⋯ = ⋯

instance CommSemiRingCat.forget₂SemiRing_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommSemiRingCat SemiRingCat)

Equations

• CommSemiRingCat.forget₂SemiRing_preservesLimits = ⋯

instance CommSemiRingCat.forget_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget CommSemiRingCat)

The forgetful functor from rings to types preserves all limits. (That is, the underlying types could have been computed instead as limits in the category of types.)

Equations

• ⋯ = ⋯

instance CommSemiRingCat.forget_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget CommSemiRingCat)

Equations

• CommSemiRingCat.forget_preservesLimits = ⋯

@[reducible, inline]

abbrev RingCatMax : Type ((max u1 u2) + 1)

An alias for RingCat.{max u v}, to deal around unification issues.

Equations

• RingCatMax = RingCat

instance RingCat.ringObj {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J RingCat) (j : J) : Ring ((F.comp (CategoryTheory.forget RingCat)).obj j)

Equations

• RingCat.ringObj F j = inferInstanceAs (Ring ↑(F.obj j))

def RingCat.sectionsSubring {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J RingCat) : Subring ((j : J) → ↑(F.obj j))

The flat sections of a functor into RingCat form a subring of all sections.

Equations

• RingCat.sectionsSubring F = { carrier := (F.comp (CategoryTheory.forget RingCat)).sections, mul_mem' := ⋯, one_mem' := ⋯, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯ }

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

Equations

• RingCat.limitRing F = inferInstanceAs (Ring (Shrink.{?u.65, max ?u.65 ?u.66} ↑(F.comp (CategoryTheory.forget RingCat)).sections))

instance RingCat.instCreatesLimitSemiRingCatForget₂ {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J RingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget RingCat)).sections] : CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ RingCat SemiRingCat)

We show that the forgetful functor CommRingCat ⥤ RingCat creates limits.

All we need to do is notice that the limit point has a Ring instance available, and then reuse the existing limit.

Equations

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

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

A choice of limit cone for a functor into RingCat. (Generally, you'll just want to use limit F.)

Equations

• RingCat.limitCone F = CategoryTheory.liftLimit (CategoryTheory.Limits.limit.isLimit (F.comp (CategoryTheory.forget₂ RingCat SemiRingCat)))

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

The chosen cone is a limit cone. (Generally, you'll just want to use limit.cone F.)

Equations

• RingCat.limitConeIsLimit F = CategoryTheory.liftedLimitIsLimit (CategoryTheory.Limits.limit.isLimit (F.comp (CategoryTheory.forget₂ RingCat SemiRingCat)))

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

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

Equations

• ⋯ = ⋯

instance RingCat.hasLimitsOfShape {J : Type v} [CategoryTheory.Category.{w, v} J] [Small.{u, v} J] : CategoryTheory.Limits.HasLimitsOfShape J RingCat

If J is u-small, RingCat.{u} has limits of shape J.

Equations

• ⋯ = ⋯

instance RingCat.hasLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} RingCat

The category of rings has all limits.

Equations

• ⋯ = ⋯

instance RingCat.hasLimits : CategoryTheory.Limits.HasLimits RingCat

Equations

• RingCat.hasLimits = ⋯

instance RingCat.forget₂SemiRing_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ RingCat SemiRingCat)

The forgetful functor from rings to semirings preserves all limits.

Equations

• ⋯ = ⋯

instance RingCat.forget₂SemiRing_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ RingCat SemiRingCat)

Equations

• RingCat.forget₂SemiRing_preservesLimits = ⋯

def RingCat.forget₂AddCommGroupPreservesLimitsAux {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J RingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget RingCat)).sections] : CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ RingCat AddCommGrp).mapCone (RingCat.limitCone F))

An auxiliary declaration to speed up typechecking.

Equations

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

instance RingCat.forget₂AddCommGroup_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ RingCat AddCommGrp)

The forgetful functor from rings to additive commutative groups preserves all limits.

Equations

• ⋯ = ⋯

instance RingCat.forget₂AddCommGroup_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ RingCat AddCommGrp)

Equations

• RingCat.forget₂AddCommGroup_preservesLimits = ⋯

instance RingCat.forget_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, u, u, u + 1, u + 1} (CategoryTheory.forget RingCat)

The forgetful functor from rings to types preserves all limits. (That is, the underlying types could have been computed instead as limits in the category of types.)

Equations

• ⋯ = ⋯

instance RingCat.forget_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget RingCat)

Equations

• RingCat.forget_preservesLimits = ⋯

@[reducible, inline]

abbrev CommRingCatMax : Type ((max u1 u2) + 1)

An alias for CommRingCat.{max u v}, to deal around unification issues.

Equations

• CommRingCatMax = CommRingCat

instance CommRingCat.commRingObj {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommRingCat) (j : J) : CommRing ((F.comp (CategoryTheory.forget CommRingCat)).obj j)

Equations

• CommRingCat.commRingObj F j = inferInstanceAs (CommRing ↑(F.obj j))

instance CommRingCat.limitCommRing {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommRingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections] : CommRing (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommRingCat))).pt

Equations

• CommRingCat.limitCommRing F = inferInstanceAs (CommRing (Shrink.{?u.65, max ?u.65 ?u.66} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections))

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

A choice of limit cone for a functor into CommRingCat. (Generally, you'll just want to use limit F.)

Equations

• CommRingCat.limitCone F = CategoryTheory.liftLimit (CategoryTheory.Limits.limit.isLimit (F.comp (CategoryTheory.forget₂ CommRingCat RingCat)))

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

The chosen cone is a limit cone. (Generally, you'll just want to use limit.cone F.)

Equations

• CommRingCat.limitConeIsLimit F = CategoryTheory.liftedLimitIsLimit (CategoryTheory.Limits.limit.isLimit (F.comp (CategoryTheory.forget₂ CommRingCat RingCat)))

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

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

Equations

• ⋯ = ⋯

instance CommRingCat.hasLimitsOfShape {J : Type v} [CategoryTheory.Category.{w, v} J] [Small.{u, v} J] : CategoryTheory.Limits.HasLimitsOfShape J CommRingCat

If J is u-small, CommRingCat.{u} has limits of shape J.

Equations

• ⋯ = ⋯

instance CommRingCat.hasLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} CommRingCat

The category of commutative rings has all limits.

Equations

• ⋯ = ⋯

instance CommRingCat.hasLimits : CategoryTheory.Limits.HasLimits CommRingCat

Equations

• CommRingCat.hasLimits = ⋯

instance CommRingCat.forget₂Ring_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ CommRingCat RingCat)

The forgetful functor from commutative rings to rings preserves all limits. (That is, the underlying rings could have been computed instead as limits in the category of rings.)

Equations

• ⋯ = ⋯

instance CommRingCat.forget₂Ring_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommRingCat RingCat)

Equations

• CommRingCat.forget₂Ring_preservesLimits = ⋯

def CommRingCat.forget₂CommSemiRingPreservesLimitsAux {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommRingCat) [Small.{u, max u v} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections] : CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ CommRingCat CommSemiRingCat).mapCone (CommRingCat.limitCone F))

An auxiliary declaration to speed up typechecking.

instance CommRingCat.forget₂CommSemiRing_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ CommRingCat CommSemiRingCat)

The forgetful functor from commutative rings to commutative semirings preserves all limits. (That is, the underlying commutative semirings could have been computed instead as limits in the category of commutative semirings.)

Equations

• ⋯ = ⋯

instance CommRingCat.forget₂CommSemiRing_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommRingCat CommSemiRingCat)

Equations

• CommRingCat.forget₂CommSemiRing_preservesLimits = ⋯

instance CommRingCat.forget_preservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget CommRingCat)

The forgetful functor from commutative rings to types preserves all limits. (That is, the underlying types could have been computed instead as limits in the category of types.)

Equations

• ⋯ = ⋯

instance CommRingCat.forget_preservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget CommRingCat)

Equations

• CommRingCat.forget_preservesLimits = ⋯