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

full_name: SemiRingCat.semiringObj
code: instance semiringObj (j) : Semiring ((F ⋙ forget SemiRingCat).obj j) 
goal: Semiring ((F ⋙ CategoryTheory.forget SemiRingCat).obj j)

full_name: SemiRingCat.sectionsSubsemiring
code: /-- The flat sections of a functor into `SemiRingCat` form a subsemiring of all sections.
-/
def sectionsSubsemiring : Subsemiring (∀ j, F.obj j) 
goal: Subsemiring ((j : J) → ↑(F.obj j))

full_name: SemiRingCat.sectionsSemiring
code: instance sectionsSemiring : Semiring (F ⋙ forget SemiRingCat.{u}).sections 
goal: Semiring ↑(F ⋙ CategoryTheory.forget SemiRingCat).sections

full_name: SemiRingCat.limitSemiring
code: instance limitSemiring :
    Semiring (Types.Small.limitCone.{v, u} (F ⋙ forget SemiRingCat.{u})).pt 
goal: Semiring (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget SemiRingCat)).pt

full_name: SemiRingCat.limitπRingHom
code: /-- `limit.π (F ⋙ forget SemiRingCat) j` as a `RingHom`. -/
def limitπRingHom (j) :
    (Types.Small.limitCone.{v, u} (F ⋙ forget SemiRingCat)).pt →+* (F ⋙ forget SemiRingCat).obj j 
goal: (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget SemiRingCat)).pt →+*
  (F ⋙ CategoryTheory.forget SemiRingCat).obj j

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

full_name: SemiRingCat.HasLimits.limitConeIsLimit
code: /-- Witness that the limit cone in `SemiRingCat` is a limit cone.
(Internal use only; use the limits API.)
-/
def limitConeIsLimit : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (SemiRingCat.HasLimits.limitCone F)

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

full_name: SemiRingCat.hasLimitsOfShape
code: /-- If `J` is `u`-small, `SemiRingCat.{u}` has limits of shape `J`. -/
instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J SemiRingCat.{u} 
goal: CategoryTheory.Limits.HasLimitsOfShape J SemiRingCat

full_name: SemiRingCat.hasLimitsOfSize
code: /-- The category of rings has all limits. -/
instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} SemiRingCat.{u} 
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} SemiRingCat

full_name: SemiRingCat.hasLimits
code: instance hasLimits : HasLimits SemiRingCat.{u} 
goal: CategoryTheory.Limits.HasLimits SemiRingCat

full_name: SemiRingCat.forget₂AddCommMonPreservesLimitsAux
code: /--
Auxiliary lemma to prove the cone induced by `limitCone` is a limit cone.
-/
def forget₂AddCommMonPreservesLimitsAux :
    IsLimit ((forget₂ SemiRingCat AddCommMonCat).mapCone (limitCone F)) 
goal: CategoryTheory.Limits.IsLimit
  ((CategoryTheory.forget₂ SemiRingCat AddCommMonCat).mapCone (SemiRingCat.HasLimits.limitCone F))

full_name: SemiRingCat.forget₂AddCommMonPreservesLimitsOfSize
code: /-- The forgetful functor from semirings to additive commutative monoids preserves all limits.
-/
instance forget₂AddCommMonPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ SemiRingCat AddCommMonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1}
  (CategoryTheory.forget₂ SemiRingCat AddCommMonCat)

full_name: SemiRingCat.forget₂AddCommMonPreservesLimits
code: instance forget₂AddCommMonPreservesLimits :
    PreservesLimits (forget₂ SemiRingCat AddCommMonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ SemiRingCat AddCommMonCat)

full_name: SemiRingCat.forget₂MonPreservesLimitsAux
code: /-- An auxiliary declaration to speed up typechecking.
-/
def forget₂MonPreservesLimitsAux :
    IsLimit ((forget₂ SemiRingCat MonCat).mapCone (limitCone F)) 
goal: CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ SemiRingCat MonCat).mapCone (SemiRingCat.HasLimits.limitCone F))

full_name: SemiRingCat.forget₂MonPreservesLimitsOfSize
code: /-- The forgetful functor from semirings to monoids preserves all limits.
-/
instance forget₂MonPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ SemiRingCat MonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ SemiRingCat MonCat)

full_name: SemiRingCat.forget₂MonPreservesLimits
code: instance forget₂MonPreservesLimits : PreservesLimits (forget₂ SemiRingCat MonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ SemiRingCat MonCat)

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

full_name: SemiRingCat.forgetPreservesLimits
code: instance forgetPreservesLimits : PreservesLimits (forget SemiRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget SemiRingCat)

full_name: CommSemiRingCatMax
code: /-- An alias for `CommSemiring.{max u v}`, to deal with unification issues. -/
@[nolint checkUnivs]
abbrev CommSemiRingCatMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: CommSemiRingCat.commSemiringObj
code: instance commSemiringObj (j) :
    CommSemiring ((F ⋙ forget CommSemiRingCat).obj j) 
goal: CommSemiring ((F ⋙ CategoryTheory.forget CommSemiRingCat).obj j)

full_name: CommSemiRingCat.limitCommSemiring
code: instance limitCommSemiring :
    CommSemiring (Types.Small.limitCone.{v, u} (F ⋙ forget CommSemiRingCat.{u})).pt 
goal: CommSemiring (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget CommSemiRingCat)).pt

full_name: CommSemiRingCat.instCreatesLimitSemiRingCatForget₂
code: /-- 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.
-/
instance :
    CreatesLimit F (forget₂ CommSemiRingCat.{u} SemiRingCat.{u}) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ CommSemiRingCat SemiRingCat)

full_name: CommSemiRingCat.limitCone
code: /-- A choice of limit cone for a functor into `CommSemiRingCat`.
(Generally, you'll just want to use `limit F`.)
-/
def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CommSemiRingCat.limitConeIsLimit
code: /-- The chosen cone is a limit cone.
(Generally, you'll just want to use `limit.cone F`.)
-/
def limitConeIsLimit : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (CommSemiRingCat.limitCone F)

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

full_name: CommSemiRingCat.hasLimitsOfShape
code: /-- If `J` is `u`-small, `CommSemiRingCat.{u}` has limits of shape `J`. -/
instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J CommSemiRingCat.{u} 
goal: CategoryTheory.Limits.HasLimitsOfShape J CommSemiRingCat

full_name: CommSemiRingCat.hasLimitsOfSize
code: /-- The category of rings has all limits. -/
instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} CommSemiRingCat.{u} 
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} CommSemiRingCat

full_name: CommSemiRingCat.hasLimits
code: instance hasLimits : HasLimits CommSemiRingCat.{u} 
goal: CategoryTheory.Limits.HasLimits CommSemiRingCat

full_name: CommSemiRingCat.forget₂SemiRingPreservesLimitsOfSize
code: /-- The forgetful functor from rings to semirings preserves all limits.
-/
instance forget₂SemiRingPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ CommSemiRingCat SemiRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1}
  (CategoryTheory.forget₂ CommSemiRingCat SemiRingCat)

full_name: CommSemiRingCat.forget₂SemiRingPreservesLimits
code: instance forget₂SemiRingPreservesLimits :
    PreservesLimits (forget₂ CommSemiRingCat SemiRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommSemiRingCat SemiRingCat)

full_name: CommSemiRingCat.forgetPreservesLimitsOfSize
code: /-- 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.)
-/
instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget CommSemiRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget CommSemiRingCat)

full_name: CommSemiRingCat.forgetPreservesLimits
code: instance forgetPreservesLimits : PreservesLimits (forget CommSemiRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget CommSemiRingCat)

full_name: RingCatMax
code: /-- An alias for `RingCat.{max u v}`, to deal around unification issues. -/
@[nolint checkUnivs]
abbrev RingCatMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: RingCat.ringObj
code: instance ringObj (j) : Ring ((F ⋙ forget RingCat).obj j) 
goal: Ring ((F ⋙ CategoryTheory.forget RingCat).obj j)

full_name: RingCat.sectionsSubring
code: /-- The flat sections of a functor into `RingCat` form a subring of all sections.
-/
def sectionsSubring : Subring (∀ j, F.obj j) 
goal: Subring ((j : J) → ↑(F.obj j))

full_name: RingCat.limitRing
code: instance limitRing : Ring.{u} (Types.Small.limitCone.{v, u} (F ⋙ forget RingCat.{u})).pt 
goal: Ring (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget RingCat)).pt

full_name: RingCat.instCreatesLimitSemiRingCatForget₂
code: /-- 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.
-/
instance : CreatesLimit F (forget₂ RingCat.{u} SemiRingCat.{u}) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ RingCat SemiRingCat)

full_name: RingCat.limitCone
code: /-- A choice of limit cone for a functor into `RingCat`.
(Generally, you'll just want to use `limit F`.)
-/
def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: RingCat.limitConeIsLimit
code: /-- The chosen cone is a limit cone.
(Generally, you'll just want to use `limit.cone F`.)
-/
def limitConeIsLimit : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (RingCat.limitCone F)

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

full_name: RingCat.hasLimitsOfShape
code: /-- If `J` is `u`-small, `RingCat.{u}` has limits of shape `J`. -/
instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J RingCat.{u} 
goal: CategoryTheory.Limits.HasLimitsOfShape J RingCat

full_name: RingCat.hasLimitsOfSize
code: /-- The category of rings has all limits. -/
instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} RingCat.{u} 
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} RingCat

full_name: RingCat.hasLimits
code: instance hasLimits : HasLimits RingCat.{u} 
goal: CategoryTheory.Limits.HasLimits RingCat

full_name: RingCat.forget₂SemiRingPreservesLimitsOfSize
code: /-- The forgetful functor from rings to semirings preserves all limits.
-/
instance forget₂SemiRingPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ RingCat SemiRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ RingCat SemiRingCat)

full_name: RingCat.forget₂SemiRingPreservesLimits
code: instance forget₂SemiRingPreservesLimits : PreservesLimits (forget₂ RingCat SemiRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ RingCat SemiRingCat)

full_name: RingCat.forget₂AddCommGroupPreservesLimitsAux
code: /-- An auxiliary declaration to speed up typechecking.
-/
def forget₂AddCommGroupPreservesLimitsAux :
    IsLimit ((forget₂ RingCat.{u} AddCommGrp).mapCone (limitCone.{v, u} F)) 
goal: CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ RingCat AddCommGrp).mapCone (RingCat.limitCone F))

full_name: RingCat.forget₂AddCommGroupPreservesLimitsOfSize
code: /-- The forgetful functor from rings to additive commutative groups preserves all limits.
-/
instance forget₂AddCommGroupPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{v, v} (forget₂ RingCat.{u} AddCommGrp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ RingCat AddCommGrp)

full_name: RingCat.forget₂AddCommGroupPreservesLimits
code: instance forget₂AddCommGroupPreservesLimits :
    PreservesLimits (forget₂ RingCat AddCommGrp.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ RingCat AddCommGrp)

full_name: RingCat.forgetPreservesLimitsOfSize
code: /-- 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.)
-/
instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{v, v} (forget RingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, u, u, u + 1, u + 1} (CategoryTheory.forget RingCat)

full_name: RingCat.forgetPreservesLimits
code: instance forgetPreservesLimits : PreservesLimits (forget RingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget RingCat)

full_name: CommRingCatMax
code: /-- An alias for `CommRingCat.{max u v}`, to deal around unification issues. -/
@[nolint checkUnivs]
abbrev CommRingCatMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: CommRingCat.commRingObj
code: instance commRingObj (j) : CommRing ((F ⋙ forget CommRingCat).obj j) 
goal: CommRing ((F ⋙ CategoryTheory.forget CommRingCat).obj j)

full_name: CommRingCat.limitCommRing
code: instance limitCommRing :
    CommRing.{u} (Types.Small.limitCone.{v, u} (F ⋙ forget CommRingCat.{u})).pt 
goal: CommRing (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget CommRingCat)).pt

full_name: CommRingCat.instCreatesLimitRingCatForget₂
code: /-- We show that the forgetful functor `CommRingCat ⥤ RingCat` creates limits.

All we need to do is notice that the limit point has a `CommRing` instance available,
and then reuse the existing limit.
-/
instance :
   CreatesLimit F (forget₂ CommRingCat.{u} RingCat.{u}) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ CommRingCat RingCat)

full_name: CommRingCat.limitCone
code: /-- A choice of limit cone for a functor into `CommRingCat`.
(Generally, you'll just want to use `limit F`.)
-/
def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CommRingCat.limitConeIsLimit
code: /-- The chosen cone is a limit cone.
(Generally, you'll just want to use `limit.cone F`.)
-/
def limitConeIsLimit : IsLimit (limitCone.{v, u} F) 
goal: CategoryTheory.Limits.IsLimit (CommRingCat.limitCone F)

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

full_name: CommRingCat.hasLimitsOfShape
code: /-- If `J` is `u`-small, `CommRingCat.{u}` has limits of shape `J`. -/
instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J CommRingCat.{u} 
goal: CategoryTheory.Limits.HasLimitsOfShape J CommRingCat

full_name: CommRingCat.hasLimitsOfSize
code: /-- The category of commutative rings has all limits. -/
instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} CommRingCat.{u} 
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} CommRingCat

full_name: CommRingCat.hasLimits
code: instance hasLimits : HasLimits CommRingCat.{u} 
goal: CategoryTheory.Limits.HasLimits CommRingCat

full_name: CommRingCat.forget₂RingPreservesLimitsOfSize
code: /-- 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.)
-/
instance forget₂RingPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ CommRingCat RingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ CommRingCat RingCat)

full_name: CommRingCat.forget₂RingPreservesLimits
code: instance forget₂RingPreservesLimits : PreservesLimits (forget₂ CommRingCat RingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommRingCat RingCat)

full_name: CommRingCat.forget₂CommSemiRingPreservesLimitsAux
code: /-- An auxiliary declaration to speed up typechecking.
-/
def forget₂CommSemiRingPreservesLimitsAux :
    IsLimit ((forget₂ CommRingCat CommSemiRingCat).mapCone (limitCone F)) 
goal: CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ CommRingCat CommSemiRingCat).mapCone (CommRingCat.limitCone F))

full_name: CommRingCat.forget₂CommSemiRingPreservesLimitsOfSize
code: /-- 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.)
-/
instance forget₂CommSemiRingPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ CommRingCat CommSemiRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1}
  (CategoryTheory.forget₂ CommRingCat CommSemiRingCat)

full_name: CommRingCat.forget₂CommSemiRingPreservesLimits
code: instance forget₂CommSemiRingPreservesLimits :
    PreservesLimits (forget₂ CommRingCat CommSemiRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommRingCat CommSemiRingCat)

full_name: CommRingCat.forgetPreservesLimitsOfSize
code: /-- 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.)
-/
instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget CommRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget CommRingCat)

full_name: CommRingCat.forgetPreservesLimits
code: instance forgetPreservesLimits : PreservesLimits (forget CommRingCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget CommRingCat)