The category of (commutative) (additive) monoids 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.

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

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

Equations

• AddMonCatMax = AddMonCat

@[inline, reducible]

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

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

Equations

• MonCatMax = MonCat

instance AddMonCat.addMonoidObj {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J AddMonCat) (j : J) : AddMonoid ((CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)).obj j)

Equations

• AddMonCat.addMonoidObj F j = inferInstanceAs (AddMonoid ↑(F.obj j))

instance MonCat.monoidObj {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J MonCat) (j : J) : Monoid ((CategoryTheory.Functor.comp F (CategoryTheory.forget MonCat)).obj j)

Equations

• MonCat.monoidObj F j = inferInstanceAs (Monoid ↑(F.obj j))

theorem AddMonCat.sectionsAddSubmonoid.proof_1 {J : Type u_3} [CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddMonCat) {a : (j : J) → ↑(F.obj j)} {b : (j : J) → ↑(F.obj j)} (ah : a ∈ CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat))) (bh : b ∈ CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat))) {j : J} {j' : J} (f : j ⟶ j') : (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)).map f ((a + b) j) = (a + b) j'

def AddMonCat.sectionsAddSubmonoid {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J AddMonCat) : AddSubmonoid ((j : J) → ↑(F.obj j))

The flat sections of a functor into AddMonCat form an additive submonoid of all sections.

Equations

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

theorem AddMonCat.sectionsAddSubmonoid.proof_2 {J : Type u_2} [CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddMonCat) {j : J} {j' : J} (f : j ⟶ j') : (F.map f) 0 = 0

def MonCat.sectionsSubmonoid {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J MonCat) : Submonoid ((j : J) → ↑(F.obj j))

The flat sections of a functor into MonCat form a submonoid of all sections.

Equations

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

instance AddMonCat.sectionsAddMonoid {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J AddMonCat) : AddMonoid ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))

Equations

• AddMonCat.sectionsAddMonoid F = AddSubmonoid.toAddMonoid (AddMonCat.sectionsAddSubmonoid F)

instance MonCat.sectionsMonoid {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J MonCat) : Monoid ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget MonCat)))

Equations

• MonCat.sectionsMonoid F = Submonoid.toMonoid (MonCat.sectionsSubmonoid F)

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

Equations

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

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

Equations

• MonCat.limitMonoid F = inferInstanceAs (Monoid (Shrink.{u, max u v} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget MonCat)))))

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

limit.π (F ⋙ forget AddMonCat) j as an AddMonoidHom.

Equations

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

theorem AddMonCat.limitπAddMonoidHom.proof_1 {J : Type u_3} [CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddMonCat) [Small.{u_1, max u_1 u_3} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))] (j : J) : (CategoryTheory.Limits.Types.Small.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat))).π.app j 0 = 0

theorem AddMonCat.limitπAddMonoidHom.proof_2 {J : Type u_3} [CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddMonCat) [Small.{u_2, max u_2 u_3} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))] (j : J) : ∀ (x x_1 : (CategoryTheory.Limits.Types.Small.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat))).pt), { toFun := (CategoryTheory.Limits.Types.Small.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat))).π.app j, map_zero' := ⋯ }.toFun (x + x_1) = { toFun := (CategoryTheory.Limits.Types.Small.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat))).π.app j, map_zero' := ⋯ }.toFun x + { toFun := (CategoryTheory.Limits.Types.Small.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat))).π.app j, map_zero' := ⋯ }.toFun x_1

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

limit.π (F ⋙ forget MonCat) j as a MonoidHom.

Equations

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

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

(Internal use only; use the limits API.)

Equations

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

theorem AddMonCat.HasLimits.limitCone.proof_1 {J : Type u_2} [CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddMonCat) [Small.{u_3, max u_3 u_2} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))] : ∀ (x x_1 : J) (f : x ⟶ x_1), CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const J).obj (AddMonCat.of (CategoryTheory.Limits.Types.Small.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat))).pt)).map f) (AddMonCat.limitπAddMonoidHom F x_1) = CategoryTheory.CategoryStruct.comp (AddMonCat.limitπAddMonoidHom F x) (F.map f)

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

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

Equations

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

theorem AddMonCat.HasLimits.limitConeIsLimit.proof_3 {J : Type u_3} [CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddMonCat) [Small.{u_1, max u_1 u_3} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))] (s : CategoryTheory.Limits.Cone F) (x : ↑s.pt) (y : ↑s.pt) : { toFun := fun (v : ((CategoryTheory.forget AddMonCat).mapCone s).pt) => (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone s).π.app j v, property := ⋯ }, map_zero' := ⋯ }.toFun (x + y) = { toFun := fun (v : ((CategoryTheory.forget AddMonCat).mapCone s).pt) => (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone s).π.app j v, property := ⋯ }, map_zero' := ⋯ }.toFun x + { toFun := fun (v : ((CategoryTheory.forget AddMonCat).mapCone s).pt) => (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone s).π.app j v, property := ⋯ }, map_zero' := ⋯ }.toFun y

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

(Internal use only; use the limits API.)

Equations

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

theorem AddMonCat.HasLimits.limitConeIsLimit.proof_1 {J : Type u_2} [CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddMonCat) (s : CategoryTheory.Limits.Cone F) (v : ((CategoryTheory.forget AddMonCat).mapCone s).pt) : ∀ {j j' : J} (f : j ⟶ j'), CategoryTheory.CategoryStruct.comp (((CategoryTheory.forget AddMonCat).mapCone s).π.app j) ((CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)).map f) v = ((CategoryTheory.forget AddMonCat).mapCone s).π.app j' v

theorem AddMonCat.HasLimits.limitConeIsLimit.proof_2 {J : Type u_3} [CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddMonCat) [Small.{u_1, max u_1 u_3} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))] (s : CategoryTheory.Limits.Cone F) : (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone s).π.app j 0, property := ⋯ } = 0

theorem AddMonCat.HasLimits.limitConeIsLimit.proof_4 {J : Type u_3} [CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddMonCat) [Small.{u_2, max u_2 u_3} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))] (s : CategoryTheory.Limits.Cone F) : (CategoryTheory.forget AddMonCat).map ((fun (s : CategoryTheory.Limits.Cone F) => { toZeroHom := { toFun := fun (v : ((CategoryTheory.forget AddMonCat).mapCone s).pt) => (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone s).π.app j v, property := ⋯ }, map_zero' := ⋯ }, map_add' := ⋯ }) s) = (CategoryTheory.forget AddMonCat).map ((fun (s : CategoryTheory.Limits.Cone F) => { toZeroHom := { toFun := fun (v : ((CategoryTheory.forget AddMonCat).mapCone s).pt) => (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone s).π.app j v, property := ⋯ }, map_zero' := ⋯ }, map_add' := ⋯ }) s)

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

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

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

Equations

• ⋯ = ⋯

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

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

Equations

• ⋯ = ⋯

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

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

Equations

• ⋯ = ⋯

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

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

Equations

• ⋯ = ⋯

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

The category of additive monoids has all limits.

Equations

• ⋯ = ⋯

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

The category of monoids has all limits.

Equations

• ⋯ = ⋯

instance AddMonCat.hasLimits : CategoryTheory.Limits.HasLimits AddMonCat

Equations

• AddMonCat.hasLimits = ⋯

instance MonCat.hasLimits : CategoryTheory.Limits.HasLimits MonCat

Equations

• MonCat.hasLimits = ⋯

noncomputable instance AddMonCat.forgetPreservesLimitsOfShape {J : Type v} [CategoryTheory.Category.{w, v} J] [Small.{u, v} J] : CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget AddMonCat)

If J is u-small, the forgetful functor from AddMonCat.{u}

preserves limits of shape J.

Equations

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

theorem AddMonCat.forgetPreservesLimitsOfShape.proof_1 {J : Type u_2} [CategoryTheory.Category.{u_3, u_2} J] [Small.{u_1, u_2} J] {F : CategoryTheory.Functor J AddMonCat} : Small.{u_1, max u_1 u_2} { x : (j : J) → (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)).obj j // x ∈ CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddMonCat)) }

noncomputable instance MonCat.forgetPreservesLimitsOfShape {J : Type v} [CategoryTheory.Category.{w, v} J] [Small.{u, v} J] : CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget MonCat)

If J is u-small, the forgetful functor from MonCat.{u} preserves limits of shape J.

Equations

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

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

The forgetful functor from additive monoids to types preserves all limits.

This means the underlying type of a limit can be computed as a limit in the category of types.

Equations

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

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

The forgetful functor from monoids to types preserves all limits.

This means the underlying type of a limit can be computed as a limit in the category of types.

Equations

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

noncomputable instance AddMonCat.forgetPreservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget AddMonCat)

Equations

• AddMonCat.forgetPreservesLimits = AddMonCat.forgetPreservesLimitsOfSize

theorem AddMonCat.forgetPreservesLimits.proof_1 (α : Type u_1) : Small.{u_1, u_1} α

noncomputable instance MonCat.forgetPreservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget MonCat)

Equations

• MonCat.forgetPreservesLimits = MonCat.forgetPreservesLimitsOfSize

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

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

Equations

• AddCommMonCatMax = AddCommMonCat

@[inline, reducible]

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

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

Equations

• CommMonCatMax = CommMonCat

instance AddCommMonCat.addCommMonoidObj {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J AddCommMonCat) (j : J) : AddCommMonoid ((CategoryTheory.Functor.comp F (CategoryTheory.forget AddCommMonCat)).obj j)

Equations

• AddCommMonCat.addCommMonoidObj F j = inferInstanceAs (AddCommMonoid ↑(F.obj j))

instance CommMonCat.commMonoidObj {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommMonCat) (j : J) : CommMonoid ((CategoryTheory.Functor.comp F (CategoryTheory.forget CommMonCat)).obj j)

Equations

• CommMonCat.commMonoidObj F j = inferInstanceAs (CommMonoid ↑(F.obj j))

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

Equations

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

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

Equations

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

instance AddCommMonCat.instSmallElemForAllObjToQuiverToCategoryStructTypeToQuiverToCategoryStructTypesToPrefunctorCompMonCatInstMonCatLargeCategoryCommMonCatInstCommMonCatLargeCategoryForget₂ConcreteCategoryConcreteCategoryHasForgetToMonCatForgetSections {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J AddCommMonCat) [Small.{u, max u v} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddCommMonCat)))] : Small.{u, max u v} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)) (CategoryTheory.forget AddMonCat)))

Equations

• ⋯ = ⋯

instance CommMonCat.instSmallElemForAllObjToQuiverToCategoryStructTypeToQuiverToCategoryStructTypesToPrefunctorCompMonCatInstMonCatLargeCategoryCommMonCatInstCommMonCatLargeCategoryForget₂ConcreteCategoryConcreteCategoryHasForgetToMonCatForgetSections {J : Type v} [CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommMonCat) [Small.{u, max u v} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget CommMonCat)))] : Small.{u, max u v} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ CommMonCat MonCat)) (CategoryTheory.forget MonCat)))

Equations

• ⋯ = ⋯

theorem AddCommMonCat.forget₂CreatesLimit.proof_6 {J : Type u_3} [CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddCommMonCat) [Small.{u_2, max u_2 u_3} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddCommMonCat)))] (c' : CategoryTheory.Limits.Cone (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat))) (t : CategoryTheory.Limits.IsLimit c') (s : CategoryTheory.Limits.Cone F) : (CategoryTheory.forget₂ AddCommMonCat AddMonCat).map ((fun (s : CategoryTheory.Limits.Cone F) => { toZeroHom := { toFun := fun (v : ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).pt) => (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)) (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).π.app j v, property := ⋯ }, map_zero' := ⋯ }, map_add' := ⋯ }) s) = (CategoryTheory.forget₂ AddCommMonCat AddMonCat).map ((fun (s : CategoryTheory.Limits.Cone F) => { toZeroHom := { toFun := fun (v : ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).pt) => (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)) (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).π.app j v, property := ⋯ }, map_zero' := ⋯ }, map_add' := ⋯ }) s)

theorem AddCommMonCat.forget₂CreatesLimit.proof_1 : CategoryTheory.Functor.ReflectsIsomorphisms (CategoryTheory.forget₂ AddCommMonCat AddMonCat)

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

We show that the forgetful functor AddCommMonCat ⥤ AddMonCat creates limits.

All we need to do is notice that the limit point has an AddCommMonoid instance available,

and then reuse the existing limit.

Equations

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

theorem AddCommMonCat.forget₂CreatesLimit.proof_3 {J : Type u_2} [CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddCommMonCat) (s : CategoryTheory.Limits.Cone F) (v : ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).pt) : ∀ {j j' : J} (f : j ⟶ j'), CategoryTheory.CategoryStruct.comp (((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).π.app j) ((CategoryTheory.Functor.comp (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)) (CategoryTheory.forget AddMonCat)).map f) v = ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).π.app j' v

theorem AddCommMonCat.forget₂CreatesLimit.proof_5 {J : Type u_3} [CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddCommMonCat) [Small.{u_1, max u_1 u_3} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddCommMonCat)))] (s : CategoryTheory.Limits.Cone F) (x : ↑((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s).pt) (y : ↑((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s).pt) : { toFun := fun (v : ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).pt) => (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)) (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).π.app j v, property := ⋯ }, map_zero' := ⋯ }.toFun (x + y) = { toFun := fun (v : ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).pt) => (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)) (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).π.app j v, property := ⋯ }, map_zero' := ⋯ }.toFun x + { toFun := fun (v : ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).pt) => (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)) (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).π.app j v, property := ⋯ }, map_zero' := ⋯ }.toFun y

theorem AddCommMonCat.forget₂CreatesLimit.proof_4 {J : Type u_3} [CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddCommMonCat) [Small.{u_1, max u_1 u_3} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddCommMonCat)))] (s : CategoryTheory.Limits.Cone F) : (equivShrink ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)) (CategoryTheory.forget AddMonCat)))).1 { val := fun (j : J) => ((CategoryTheory.forget AddMonCat).mapCone ((CategoryTheory.forget₂ AddCommMonCat AddMonCat).mapCone s)).π.app j 0, property := ⋯ } = 0

theorem AddCommMonCat.forget₂CreatesLimit.proof_2 {J : Type u_2} [CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddCommMonCat) [Small.{u_3, max u_3 u_2} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddCommMonCat)))] ⦃X : J⦄ ⦃Y : J⦄ (f : X ⟶ Y) : CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const J).obj (AddMonCat.HasLimits.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat))).pt).map f) ((AddMonCat.HasLimits.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat))).π.app Y) = CategoryTheory.CategoryStruct.comp ((AddMonCat.HasLimits.limitCone (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat))).π.app X) ((CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)).map f)

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

We show that the forgetful functor CommMonCat ⥤ MonCat creates limits.

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

Equations

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

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

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

Equations

• AddCommMonCat.limitCone F = CategoryTheory.liftLimit (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)))

theorem AddCommMonCat.limitCone.proof_1 {J : Type u_2} [CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J AddCommMonCat) [Small.{u_3, max u_3 u_2} ↑(CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddCommMonCat)))] : CategoryTheory.Limits.HasLimit (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat))

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

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

Equations

• CommMonCat.limitCone F = CategoryTheory.liftLimit (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ CommMonCat MonCat)))

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

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

Equations

• AddCommMonCat.limitConeIsLimit F = CategoryTheory.liftedLimitIsLimit (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)))

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

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

Equations

• CommMonCat.limitConeIsLimit F = CategoryTheory.liftedLimitIsLimit (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Functor.comp F (CategoryTheory.forget₂ CommMonCat MonCat)))

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

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

Equations

• ⋯ = ⋯

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

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

Equations

• ⋯ = ⋯

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

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

Equations

• ⋯ = ⋯

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

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

Equations

• ⋯ = ⋯

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

The category of additive commutative monoids has all limits.

Equations

• ⋯ = ⋯

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

The category of commutative monoids has all limits.

Equations

• ⋯ = ⋯

instance AddCommMonCat.hasLimits : CategoryTheory.Limits.HasLimits AddCommMonCat

Equations

• AddCommMonCat.hasLimits = ⋯

instance CommMonCat.hasLimits : CategoryTheory.Limits.HasLimits CommMonCat

Equations

• CommMonCat.hasLimits = ⋯

theorem AddCommMonCat.forget₂AddMonPreservesLimitsOfSize.proof_1 [UnivLE.{u_2, u_1} ] {J : Type u_2} (𝒥 : CategoryTheory.Category.{u_3, u_2} J) : ∀ {K : CategoryTheory.Functor J AddCommMonCat}, Small.{u_1, max u_1 u_2} { x : (j : J) → (CategoryTheory.Functor.comp K (CategoryTheory.forget AddCommMonCat)).obj j // x ∈ CategoryTheory.Functor.sections (CategoryTheory.Functor.comp K (CategoryTheory.forget AddCommMonCat)) }

theorem AddCommMonCat.forget₂AddMonPreservesLimitsOfSize.proof_2 [UnivLE.{u_2, u_3} ] {J : Type u_2} (𝒥 : CategoryTheory.Category.{u_1, u_2} J) : ∀ {K : CategoryTheory.Functor J AddCommMonCat}, CategoryTheory.Limits.HasLimit (CategoryTheory.Functor.comp K (CategoryTheory.forget₂ AddCommMonCat AddMonCat))

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

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

This means the underlying type of a limit can be computed as a limit in the category of additive

monoids.

Equations

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

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

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

This means the underlying type of a limit can be computed as a limit in the category of monoids.

Equations

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

noncomputable instance AddCommMonCat.forget₂MonPreservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ AddCommMonCat AddMonCat)

Equations

• AddCommMonCat.forget₂MonPreservesLimits = AddCommMonCat.forget₂AddMonPreservesLimitsOfSize

theorem AddCommMonCat.forget₂MonPreservesLimits.proof_1 (α : Type u_1) : Small.{u_1, u_1} α

noncomputable instance CommMonCat.forget₂MonPreservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommMonCat MonCat)

Equations

• CommMonCat.forget₂MonPreservesLimits = CommMonCat.forget₂MonPreservesLimitsOfSize

noncomputable instance AddCommMonCat.forgetPreservesLimitsOfShape {J : Type v} [CategoryTheory.Category.{w, v} J] [Small.{u, v} J] : CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget AddCommMonCat)

If J is u-small, the forgetful functor from AddCommMonCat.{u}

preserves limits of shape J.

Equations

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

theorem AddCommMonCat.forgetPreservesLimitsOfShape.proof_1 {J : Type u_2} [CategoryTheory.Category.{u_3, u_2} J] [Small.{u_1, u_2} J] {F : CategoryTheory.Functor J AddCommMonCat} : Small.{u_1, max u_1 u_2} { x : (j : J) → (CategoryTheory.Functor.comp F (CategoryTheory.forget AddCommMonCat)).obj j // x ∈ CategoryTheory.Functor.sections (CategoryTheory.Functor.comp F (CategoryTheory.forget AddCommMonCat)) }

noncomputable instance CommMonCat.forgetPreservesLimitsOfShape {J : Type v} [CategoryTheory.Category.{w, v} J] [Small.{u, v} J] : CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget CommMonCat)

If J is u-small, the forgetful functor from CommMonCat.{u} preserves limits of shape J.

Equations

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

noncomputable instance AddCommMonCat.forgetPreservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, u, u, u + 1, u + 1} (CategoryTheory.forget AddCommMonCat)

The forgetful functor from additive commutative monoids to types preserves all

limits.

This means the underlying type of a limit can be computed as a limit in the category of types.

Equations

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

noncomputable instance CommMonCat.forgetPreservesLimitsOfSize [UnivLE.{v, u} ] : CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, u, u, u + 1, u + 1} (CategoryTheory.forget CommMonCat)

The forgetful functor from commutative monoids to types preserves all limits.

This means the underlying type of a limit can be computed as a limit in the category of types.

Equations

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

noncomputable instance AddCommMonCat.forgetPreservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget AddCommMonCat)

Equations

• AddCommMonCat.forgetPreservesLimits = AddCommMonCat.forgetPreservesLimitsOfSize

noncomputable instance CommMonCat.forgetPreservesLimits : CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget CommMonCat)

Equations

• CommMonCat.forgetPreservesLimits = CommMonCat.forgetPreservesLimitsOfSize