algebra.category.Mon.limits | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

c43486ec

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

33c67ae6

bump to nightly-2024-04-06-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

e34029c9

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Algebra.Category.Mon.Basic
-import Algebra.Group.Pi
+import Algebra.Category.MonCat.Basic
+import Algebra.Group.Pi.Lemmas
 import CategoryTheory.Limits.Creates
 import CategoryTheory.Limits.Types
 import GroupTheory.Submonoid.Operations
@@ -258,13 +258,13 @@ instance hasLimits : HasLimits CommMonCat.{u} :=
 /-- 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. -/
-@[to_additive AddCommMonCat.forget₂AddMonPreservesLimits
+@[to_additive AddCommMonCat.forget₂AddMonPreservesLimitsOfSize
       "The forgetful functor from additive\ncommutative monoids to additive monoids preserves all limits.\n\nThis means the underlying type of a limit can be computed as a limit in the category of additive\nmonoids."]
 instance forget₂MonPreservesLimitsOfSize :
     PreservesLimitsOfSize.{v, v} (forget₂ CommMonCat MonCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance }
 #align CommMon.forget₂_Mon_preserves_limits_of_size CommMonCat.forget₂MonPreservesLimitsOfSize
-#align AddCommMon.forget₂_AddMon_preserves_limits AddCommMonCat.forget₂AddMonPreservesLimits
+#align AddCommMon.forget₂_AddMon_preserves_limits AddCommMonCat.forget₂AddMonPreservesLimitsOfSize
 -/
 
 #print CommMonCat.forget₂MonPreservesLimits /-

33c67ae6

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -55,7 +55,7 @@ def sectionsSubmonoid (F : J ⥤ MonCat.{max v u}) : Submonoid (∀ j, F.obj j)
   hMul_mem' a b ah bh j j' f :=
     by
     simp only [forget_map_eq_coe, functor.comp_map, MonoidHom.map_mul, Pi.mul_apply]
-    dsimp [functor.sections] at ah bh 
+    dsimp [functor.sections] at ah bh
     rw [ah f, bh f]
 #align Mon.sections_submonoid MonCat.sectionsSubmonoid
 #align AddMon.sections_add_submonoid AddMonCat.sectionsAddSubmonoid

33c67ae6

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,11 +3,11 @@ Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Mathbin.Algebra.Category.Mon.Basic
-import Mathbin.Algebra.Group.Pi
-import Mathbin.CategoryTheory.Limits.Creates
-import Mathbin.CategoryTheory.Limits.Types
-import Mathbin.GroupTheory.Submonoid.Operations
+import Algebra.Category.Mon.Basic
+import Algebra.Group.Pi
+import CategoryTheory.Limits.Creates
+import CategoryTheory.Limits.Types
+import GroupTheory.Submonoid.Operations
 
 #align_import algebra.category.Mon.limits from "leanprover-community/mathlib"@"33c67ae661dd8988516ff7f247b0be3018cdd952"

33c67ae6

bump to nightly-2023-08-17-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

60285dcc

Diff

@@ -52,7 +52,7 @@ def sectionsSubmonoid (F : J ⥤ MonCat.{max v u}) : Submonoid (∀ j, F.obj j)
     where
   carrier := (F ⋙ forget MonCat).sections
   one_mem' j j' f := by simp
-  mul_mem' a b ah bh j j' f :=
+  hMul_mem' a b ah bh j j' f :=
     by
     simp only [forget_map_eq_coe, functor.comp_map, MonoidHom.map_mul, Pi.mul_apply]
     dsimp [functor.sections] at ah bh

33c67ae6

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,11 +2,6 @@
 Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module algebra.category.Mon.limits
-! leanprover-community/mathlib commit 33c67ae661dd8988516ff7f247b0be3018cdd952
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Category.Mon.Basic
 import Mathbin.Algebra.Group.Pi
@@ -14,6 +9,8 @@ import Mathbin.CategoryTheory.Limits.Creates
 import Mathbin.CategoryTheory.Limits.Types
 import Mathbin.GroupTheory.Submonoid.Operations
 
+#align_import algebra.category.Mon.limits from "leanprover-community/mathlib"@"33c67ae661dd8988516ff7f247b0be3018cdd952"
+
 /-!
 # The category of (commutative) (additive) monoids has all limits

33c67ae6

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -38,12 +38,15 @@ namespace MonCat
 
 variable {J : Type v} [SmallCategory J]
 
+#print MonCat.monoidObj /-
 @[to_additive]
 instance monoidObj (F : J ⥤ MonCat.{max v u}) (j) : Monoid ((F ⋙ forget MonCat).obj j) := by
   change Monoid (F.obj j); infer_instance
 #align Mon.monoid_obj MonCat.monoidObj
 #align AddMon.add_monoid_obj AddMonCat.addMonoidObj
+-/
 
+#print MonCat.sectionsSubmonoid /-
 /-- The flat sections of a functor into `Mon` form a submonoid of all sections.
 -/
 @[to_additive
@@ -59,6 +62,7 @@ def sectionsSubmonoid (F : J ⥤ MonCat.{max v u}) : Submonoid (∀ j, F.obj j)
     rw [ah f, bh f]
 #align Mon.sections_submonoid MonCat.sectionsSubmonoid
 #align AddMon.sections_add_submonoid AddMonCat.sectionsAddSubmonoid
+-/
 
 #print MonCat.limitMonoid /-
 @[to_additive]
@@ -69,6 +73,7 @@ instance limitMonoid (F : J ⥤ MonCat.{max v u}) :
 #align AddMon.limit_add_monoid AddMonCat.limitAddMonoid
 -/
 
+#print MonCat.limitπMonoidHom /-
 /-- `limit.π (F ⋙ forget Mon) j` as a `monoid_hom`. -/
 @[to_additive "`limit.π (F ⋙ forget AddMon) j` as an `add_monoid_hom`."]
 def limitπMonoidHom (F : J ⥤ MonCat.{max v u}) (j) :
@@ -79,6 +84,7 @@ def limitπMonoidHom (F : J ⥤ MonCat.{max v u}) (j) :
   map_mul' x y := rfl
 #align Mon.limit_π_monoid_hom MonCat.limitπMonoidHom
 #align AddMon.limit_π_add_monoid_hom AddMonCat.limitπAddMonoidHom
+-/
 
 namespace HasLimits
 
@@ -171,11 +177,13 @@ namespace CommMonCat
 
 variable {J : Type v} [SmallCategory J]
 
+#print CommMonCat.commMonoidObj /-
 @[to_additive]
 instance commMonoidObj (F : J ⥤ CommMonCat.{max v u}) (j) :
     CommMonoid ((F ⋙ forget CommMonCat).obj j) := by change CommMonoid (F.obj j); infer_instance
 #align CommMon.comm_monoid_obj CommMonCat.commMonoidObj
 #align AddCommMon.add_comm_monoid_obj AddCommMonCat.addCommMonoidObj
+-/
 
 #print CommMonCat.limitCommMonoid /-
 @[to_additive]

33c67ae6

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -55,7 +55,7 @@ def sectionsSubmonoid (F : J ⥤ MonCat.{max v u}) : Submonoid (∀ j, F.obj j)
   mul_mem' a b ah bh j j' f :=
     by
     simp only [forget_map_eq_coe, functor.comp_map, MonoidHom.map_mul, Pi.mul_apply]
-    dsimp [functor.sections] at ah bh
+    dsimp [functor.sections] at ah bh 
     rw [ah f, bh f]
 #align Mon.sections_submonoid MonCat.sectionsSubmonoid
 #align AddMon.sections_add_submonoid AddMonCat.sectionsAddSubmonoid

33c67ae6

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -38,24 +38,12 @@ namespace MonCat
 
 variable {J : Type v} [SmallCategory J]
 
-/- warning: Mon.monoid_obj -> MonCat.monoidObj is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2}) (j : J), Monoid.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})) j)
-but is expected to have type
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1}) (j : J), Monoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{succ (max u2 u1), max u2 u1, max u2 u1} MonCat.{max u2 u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1}))) j)
-Case conversion may be inaccurate. Consider using '#align Mon.monoid_obj MonCat.monoidObjₓ'. -/
 @[to_additive]
 instance monoidObj (F : J ⥤ MonCat.{max v u}) (j) : Monoid ((F ⋙ forget MonCat).obj j) := by
   change Monoid (F.obj j); infer_instance
 #align Mon.monoid_obj MonCat.monoidObj
 #align AddMon.add_monoid_obj AddMonCat.addMonoidObj
 
-/- warning: Mon.sections_submonoid -> MonCat.sectionsSubmonoid is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2}), Submonoid.{max u1 u2} (forall (j : J), coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} MonCat.{max u1 u2} Type.{max u1 u2} MonCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} F j)) (Pi.mulOneClass.{u1, max u1 u2} J (fun (j : J) => coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} MonCat.{max u1 u2} Type.{max u1 u2} MonCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} F j)) (fun (i : J) => Monoid.toMulOneClass.{max u1 u2} (coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} MonCat.{max u1 u2} Type.{max u1 u2} MonCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} F i)) (MonCat.monoid.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} F i))))
-but is expected to have type
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1}), Submonoid.{max u2 u1} (forall (j : J), CategoryTheory.Bundled.α.{max u2 u1, max u2 u1} Monoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) MonCatMax.{u2, u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} F) j)) (Pi.mulOneClass.{u1, max u2 u1} J (fun (j : J) => CategoryTheory.Bundled.α.{max u2 u1, max u2 u1} Monoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) MonCatMax.{u2, u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} F) j)) (fun (i : J) => Monoid.toMulOneClass.{max u2 u1} (CategoryTheory.Bundled.α.{max u2 u1, max u2 u1} Monoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) MonCatMax.{u2, u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} F) i)) (MonCat.instMonoidα.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) MonCatMax.{u2, u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} F) i))))
-Case conversion may be inaccurate. Consider using '#align Mon.sections_submonoid MonCat.sectionsSubmonoidₓ'. -/
 /-- The flat sections of a functor into `Mon` form a submonoid of all sections.
 -/
 @[to_additive
@@ -81,12 +69,6 @@ instance limitMonoid (F : J ⥤ MonCat.{max v u}) :
 #align AddMon.limit_add_monoid AddMonCat.limitAddMonoid
 -/
 
-/- warning: Mon.limit_π_monoid_hom -> MonCat.limitπMonoidHom is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2}) (j : J), MonoidHom.{max u1 u2, max u1 u2} (CategoryTheory.Limits.Cone.pt.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})) (CategoryTheory.Limits.Types.limitCone.{u1, u2} J _inst_1 (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})))) (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})) j) (Monoid.toMulOneClass.{max u1 u2} (CategoryTheory.Limits.Cone.pt.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})) (CategoryTheory.Limits.Types.limitCone.{u1, u2} J _inst_1 (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})))) (MonCat.limitMonoid.{u1, u2} J _inst_1 F)) (Monoid.toMulOneClass.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})) j) (MonCat.monoidObj.{u1, u2} J _inst_1 F j))
-but is expected to have type
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1}) (j : J), MonoidHom.{max u2 u1, max u2 u1} (CategoryTheory.Limits.Cone.pt.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1})) (CategoryTheory.Limits.Types.limitCone.{u1, u2} J _inst_1 (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1})))) (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCat.{max u1 u2} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1}))) j) (Monoid.toMulOneClass.{max u2 u1} (CategoryTheory.Limits.Cone.pt.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1})) (CategoryTheory.Limits.Types.limitCone.{u1, u2} J _inst_1 (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1})))) (MonCat.limitMonoid.{u1, u2} J _inst_1 F)) (Monoid.toMulOneClass.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCat.{max u1 u2} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1}))) j) (MonCat.monoidObj.{u1, u2} J _inst_1 F j))
-Case conversion may be inaccurate. Consider using '#align Mon.limit_π_monoid_hom MonCat.limitπMonoidHomₓ'. -/
 /-- `limit.π (F ⋙ forget Mon) j` as a `monoid_hom`. -/
 @[to_additive "`limit.π (F ⋙ forget AddMon) j` as an `add_monoid_hom`."]
 def limitπMonoidHom (F : J ⥤ MonCat.{max v u}) (j) :
@@ -189,12 +171,6 @@ namespace CommMonCat
 
 variable {J : Type v} [SmallCategory J]
 
-/- warning: CommMon.comm_monoid_obj -> CommMonCat.commMonoidObj is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2}) (j : J), CommMonoid.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} CommMonCat.concreteCategory.{max u1 u2})) j)
-but is expected to have type
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommMonCatMax.{u2, u1} instCommMonCatLargeCategory.{max u2 u1}) (j : J), CommMonoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommMonCatMax.{u2, u1} instCommMonCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} CommMonCatMax.{u2, u1} instCommMonCatLargeCategory.{max u2 u1} CommMonCat.concreteCategory.{max u2 u1}))) j)
-Case conversion may be inaccurate. Consider using '#align CommMon.comm_monoid_obj CommMonCat.commMonoidObjₓ'. -/
 @[to_additive]
 instance commMonoidObj (F : J ⥤ CommMonCat.{max v u}) (j) :
     CommMonoid ((F ⋙ forget CommMonCat).obj j) := by change CommMonoid (F.obj j); infer_instance

33c67ae6

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -45,10 +45,8 @@ but is expected to have type
   forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1}) (j : J), Monoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{succ (max u2 u1), max u2 u1, max u2 u1} MonCat.{max u2 u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1}))) j)
 Case conversion may be inaccurate. Consider using '#align Mon.monoid_obj MonCat.monoidObjₓ'. -/
 @[to_additive]
-instance monoidObj (F : J ⥤ MonCat.{max v u}) (j) : Monoid ((F ⋙ forget MonCat).obj j) :=
-  by
-  change Monoid (F.obj j)
-  infer_instance
+instance monoidObj (F : J ⥤ MonCat.{max v u}) (j) : Monoid ((F ⋙ forget MonCat).obj j) := by
+  change Monoid (F.obj j); infer_instance
 #align Mon.monoid_obj MonCat.monoidObj
 #align AddMon.add_monoid_obj AddMonCat.addMonoidObj
 
@@ -199,10 +197,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align CommMon.comm_monoid_obj CommMonCat.commMonoidObjₓ'. -/
 @[to_additive]
 instance commMonoidObj (F : J ⥤ CommMonCat.{max v u}) (j) :
-    CommMonoid ((F ⋙ forget CommMonCat).obj j) :=
-  by
-  change CommMonoid (F.obj j)
-  infer_instance
+    CommMonoid ((F ⋙ forget CommMonCat).obj j) := by change CommMonoid (F.obj j); infer_instance
 #align CommMon.comm_monoid_obj CommMonCat.commMonoidObj
 #align AddCommMon.add_comm_monoid_obj AddCommMonCat.addCommMonoidObj

33c67ae6

bump to nightly-2023-05-21-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/33c67ae661dd8988516ff7f247b0be3018cdd952

7b1466d5

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 
 ! This file was ported from Lean 3 source module algebra.category.Mon.limits
-! leanprover-community/mathlib commit c43486ecf2a5a17479a32ce09e4818924145e90e
+! leanprover-community/mathlib commit 33c67ae661dd8988516ff7f247b0be3018cdd952
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -17,6 +17,9 @@ import Mathbin.GroupTheory.Submonoid.Operations
 /-!
 # The category of (commutative) (additive) monoids has all limits
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Further, these limits are preserved by the forgetful functor --- that is,
 the underlying types are just the limits in the category of types.

c43486ec

bump to nightly-2023-05-18-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/c89fe2d59ae06402c3f55f978016d1ada444f57e

f937b764

Diff

@@ -35,6 +35,12 @@ namespace MonCat
 
 variable {J : Type v} [SmallCategory J]
 
+/- warning: Mon.monoid_obj -> MonCat.monoidObj is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2}) (j : J), Monoid.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})) j)
+but is expected to have type
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1}) (j : J), Monoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{succ (max u2 u1), max u2 u1, max u2 u1} MonCat.{max u2 u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1}))) j)
+Case conversion may be inaccurate. Consider using '#align Mon.monoid_obj MonCat.monoidObjₓ'. -/
 @[to_additive]
 instance monoidObj (F : J ⥤ MonCat.{max v u}) (j) : Monoid ((F ⋙ forget MonCat).obj j) :=
   by
@@ -43,6 +49,12 @@ instance monoidObj (F : J ⥤ MonCat.{max v u}) (j) : Monoid ((F ⋙ forget MonC
 #align Mon.monoid_obj MonCat.monoidObj
 #align AddMon.add_monoid_obj AddMonCat.addMonoidObj
 
+/- warning: Mon.sections_submonoid -> MonCat.sectionsSubmonoid is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2}), Submonoid.{max u1 u2} (forall (j : J), coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} MonCat.{max u1 u2} Type.{max u1 u2} MonCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} F j)) (Pi.mulOneClass.{u1, max u1 u2} J (fun (j : J) => coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} MonCat.{max u1 u2} Type.{max u1 u2} MonCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} F j)) (fun (i : J) => Monoid.toMulOneClass.{max u1 u2} (coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} MonCat.{max u1 u2} Type.{max u1 u2} MonCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} F i)) (MonCat.monoid.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} F i))))
+but is expected to have type
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1}), Submonoid.{max u2 u1} (forall (j : J), CategoryTheory.Bundled.α.{max u2 u1, max u2 u1} Monoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) MonCatMax.{u2, u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} F) j)) (Pi.mulOneClass.{u1, max u2 u1} J (fun (j : J) => CategoryTheory.Bundled.α.{max u2 u1, max u2 u1} Monoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) MonCatMax.{u2, u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} F) j)) (fun (i : J) => Monoid.toMulOneClass.{max u2 u1} (CategoryTheory.Bundled.α.{max u2 u1, max u2 u1} Monoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) MonCatMax.{u2, u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} F) i)) (MonCat.instMonoidα.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) MonCatMax.{u2, u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} F) i))))
+Case conversion may be inaccurate. Consider using '#align Mon.sections_submonoid MonCat.sectionsSubmonoidₓ'. -/
 /-- The flat sections of a functor into `Mon` form a submonoid of all sections.
 -/
 @[to_additive
@@ -59,13 +71,21 @@ def sectionsSubmonoid (F : J ⥤ MonCat.{max v u}) : Submonoid (∀ j, F.obj j)
 #align Mon.sections_submonoid MonCat.sectionsSubmonoid
 #align AddMon.sections_add_submonoid AddMonCat.sectionsAddSubmonoid
 
+#print MonCat.limitMonoid /-
 @[to_additive]
 instance limitMonoid (F : J ⥤ MonCat.{max v u}) :
     Monoid (Types.limitCone (F ⋙ forget MonCat.{max v u})).pt :=
   (sectionsSubmonoid F).toMonoid
 #align Mon.limit_monoid MonCat.limitMonoid
 #align AddMon.limit_add_monoid AddMonCat.limitAddMonoid
+-/
 
+/- warning: Mon.limit_π_monoid_hom -> MonCat.limitπMonoidHom is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2}) (j : J), MonoidHom.{max u1 u2, max u1 u2} (CategoryTheory.Limits.Cone.pt.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})) (CategoryTheory.Limits.Types.limitCone.{u1, u2} J _inst_1 (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})))) (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})) j) (Monoid.toMulOneClass.{max u1 u2} (CategoryTheory.Limits.Cone.pt.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})) (CategoryTheory.Limits.Types.limitCone.{u1, u2} J _inst_1 (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})))) (MonCat.limitMonoid.{u1, u2} J _inst_1 F)) (Monoid.toMulOneClass.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} MonCat.{max u1 u2} MonCat.largeCategory.{max u1 u2} MonCat.concreteCategory.{max u1 u2})) j) (MonCat.monoidObj.{u1, u2} J _inst_1 F j))
+but is expected to have type
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1}) (j : J), MonoidHom.{max u2 u1, max u2 u1} (CategoryTheory.Limits.Cone.pt.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1})) (CategoryTheory.Limits.Types.limitCone.{u1, u2} J _inst_1 (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1})))) (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCat.{max u1 u2} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1}))) j) (Monoid.toMulOneClass.{max u2 u1} (CategoryTheory.Limits.Cone.pt.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1})) (CategoryTheory.Limits.Types.limitCone.{u1, u2} J _inst_1 (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} TypeMax.{u1, u2} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1})))) (MonCat.limitMonoid.{u1, u2} J _inst_1 F)) (Monoid.toMulOneClass.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 MonCatMax.{u2, u1} instMonCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} MonCat.{max u1 u2} instMonCatLargeCategory.{max u2 u1} MonCat.concreteCategory.{max u2 u1}))) j) (MonCat.monoidObj.{u1, u2} J _inst_1 F j))
+Case conversion may be inaccurate. Consider using '#align Mon.limit_π_monoid_hom MonCat.limitπMonoidHomₓ'. -/
 /-- `limit.π (F ⋙ forget Mon) j` as a `monoid_hom`. -/
 @[to_additive "`limit.π (F ⋙ forget AddMon) j` as an `add_monoid_hom`."]
 def limitπMonoidHom (F : J ⥤ MonCat.{max v u}) (j) :
@@ -79,6 +99,7 @@ def limitπMonoidHom (F : J ⥤ MonCat.{max v u}) (j) :
 
 namespace HasLimits
 
+#print MonCat.HasLimits.limitCone /-
 -- The next two definitions are used in the construction of `has_limits Mon`.
 -- After that, the limits should be constructed using the generic limits API,
 -- e.g. `limit F`, `limit.cone F`, and `limit.is_limit F`.
@@ -95,7 +116,9 @@ def limitCone (F : J ⥤ MonCat.{max v u}) : Cone F
         MonoidHom.coe_inj ((Types.limitCone (F ⋙ forget _)).π.naturality f) }
 #align Mon.has_limits.limit_cone MonCat.HasLimits.limitCone
 #align AddMon.has_limits.limit_cone AddMonCat.HasLimits.limitCone
+-/
 
+#print MonCat.HasLimits.limitConeIsLimit /-
 /-- Witness that the limit cone in `Mon` is a limit cone.
 (Internal use only; use the limits API.)
 -/
@@ -107,11 +130,13 @@ def limitConeIsLimit (F : J ⥤ MonCat.{max v u}) : IsLimit (limitCone F) := by
     tidy
 #align Mon.has_limits.limit_cone_is_limit MonCat.HasLimits.limitConeIsLimit
 #align AddMon.has_limits.limit_cone_is_limit AddMonCat.HasLimits.limitConeIsLimit
+-/
 
 end HasLimits
 
 open HasLimits
 
+#print MonCat.hasLimitsOfSize /-
 /-- The category of monoids has all limits. -/
 @[to_additive "The category of additive monoids has all limits."]
 instance hasLimitsOfSize : HasLimitsOfSize.{v} MonCat.{max v u}
@@ -123,13 +148,17 @@ instance hasLimitsOfSize : HasLimitsOfSize.{v} MonCat.{max v u}
             IsLimit := limit_cone_is_limit F } }
 #align Mon.has_limits_of_size MonCat.hasLimitsOfSize
 #align AddMon.has_limits_of_size AddMonCat.hasLimitsOfSize
+-/
 
+#print MonCat.hasLimits /-
 @[to_additive]
 instance hasLimits : HasLimits MonCat.{u} :=
   MonCat.hasLimitsOfSize.{u, u}
 #align Mon.has_limits MonCat.hasLimits
 #align AddMon.has_limits AddMonCat.hasLimits
+-/
 
+#print MonCat.forgetPreservesLimitsOfSize /-
 /-- 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. -/
@@ -143,12 +172,15 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v} (forget MonCat.
           (types.limit_cone_is_limit (F ⋙ forget _)) }
 #align Mon.forget_preserves_limits_of_size MonCat.forgetPreservesLimitsOfSize
 #align AddMon.forget_preserves_limits_of_size AddMonCat.forgetPreservesLimitsOfSize
+-/
 
+#print MonCat.forgetPreservesLimits /-
 @[to_additive]
 instance forgetPreservesLimits : PreservesLimits (forget MonCat.{u}) :=
   MonCat.forgetPreservesLimitsOfSize.{u, u}
 #align Mon.forget_preserves_limits MonCat.forgetPreservesLimits
 #align AddMon.forget_preserves_limits AddMonCat.forgetPreservesLimits
+-/
 
 end MonCat
 
@@ -156,6 +188,12 @@ namespace CommMonCat
 
 variable {J : Type v} [SmallCategory J]
 
+/- warning: CommMon.comm_monoid_obj -> CommMonCat.commMonoidObj is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2}) (j : J), CommMonoid.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} CommMonCat.concreteCategory.{max u1 u2})) j)
+but is expected to have type
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommMonCatMax.{u2, u1} instCommMonCatLargeCategory.{max u2 u1}) (j : J), CommMonoid.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommMonCatMax.{u2, u1} instCommMonCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} CommMonCatMax.{u2, u1} instCommMonCatLargeCategory.{max u2 u1} CommMonCat.concreteCategory.{max u2 u1}))) j)
+Case conversion may be inaccurate. Consider using '#align CommMon.comm_monoid_obj CommMonCat.commMonoidObjₓ'. -/
 @[to_additive]
 instance commMonoidObj (F : J ⥤ CommMonCat.{max v u}) (j) :
     CommMonoid ((F ⋙ forget CommMonCat).obj j) :=
@@ -165,6 +203,7 @@ instance commMonoidObj (F : J ⥤ CommMonCat.{max v u}) (j) :
 #align CommMon.comm_monoid_obj CommMonCat.commMonoidObj
 #align AddCommMon.add_comm_monoid_obj AddCommMonCat.addCommMonoidObj
 
+#print CommMonCat.limitCommMonoid /-
 @[to_additive]
 instance limitCommMonoid (F : J ⥤ CommMonCat.{max v u}) :
     CommMonoid (Types.limitCone (F ⋙ forget CommMonCat.{max v u})).pt :=
@@ -172,6 +211,7 @@ instance limitCommMonoid (F : J ⥤ CommMonCat.{max v u}) :
     (MonCat.sectionsSubmonoid (F ⋙ forget₂ CommMonCat MonCat.{max v u}))
 #align CommMon.limit_comm_monoid CommMonCat.limitCommMonoid
 #align AddCommMon.limit_add_comm_monoid AddCommMonCat.limitAddCommMonoid
+-/
 
 /-- We show that the forgetful functor `CommMon ⥤ Mon` creates limits.
 
@@ -193,6 +233,7 @@ instance (F : J ⥤ CommMonCat.{max v u}) : CreatesLimit F (forget₂ CommMonCat
         IsLimit.ofFaithful (forget₂ CommMonCat MonCat.{max v u})
           (MonCat.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl }
 
+#print CommMonCat.limitCone /-
 /-- A choice of limit cone for a functor into `CommMon`.
 (Generally, you'll just want to use `limit F`.)
 -/
@@ -202,7 +243,9 @@ def limitCone (F : J ⥤ CommMonCat.{max v u}) : Cone F :=
   liftLimit (limit.isLimit (F ⋙ forget₂ CommMonCat MonCat.{max v u}))
 #align CommMon.limit_cone CommMonCat.limitCone
 #align AddCommMon.limit_cone AddCommMonCat.limitCone
+-/
 
+#print CommMonCat.limitConeIsLimit /-
 /-- The chosen cone is a limit cone.
 (Generally, you'll just want to use `limit.cone F`.)
 -/
@@ -212,7 +255,9 @@ def limitConeIsLimit (F : J ⥤ CommMonCat.{max v u}) : IsLimit (limitCone F) :=
   liftedLimitIsLimit _
 #align CommMon.limit_cone_is_limit CommMonCat.limitConeIsLimit
 #align AddCommMon.limit_cone_is_limit AddCommMonCat.limitConeIsLimit
+-/
 
+#print CommMonCat.hasLimitsOfSize /-
 /-- The category of commutative monoids has all limits. -/
 @[to_additive "The category of commutative monoids has all limits."]
 instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommMonCat.{max v u}
@@ -220,13 +265,17 @@ instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommMonCat.{max v u}
     { HasLimit := fun F => has_limit_of_created F (forget₂ CommMonCat MonCat.{max v u}) }
 #align CommMon.has_limits_of_size CommMonCat.hasLimitsOfSize
 #align AddCommMon.has_limits_of_size AddCommMonCat.hasLimitsOfSize
+-/
 
+#print CommMonCat.hasLimits /-
 @[to_additive]
 instance hasLimits : HasLimits CommMonCat.{u} :=
   CommMonCat.hasLimitsOfSize.{u, u}
 #align CommMon.has_limits CommMonCat.hasLimits
 #align AddCommMon.has_limits AddCommMonCat.hasLimits
+-/
 
+#print CommMonCat.forget₂MonPreservesLimitsOfSize /-
 /-- 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. -/
@@ -237,13 +286,17 @@ instance forget₂MonPreservesLimitsOfSize :
     where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance }
 #align CommMon.forget₂_Mon_preserves_limits_of_size CommMonCat.forget₂MonPreservesLimitsOfSize
 #align AddCommMon.forget₂_AddMon_preserves_limits AddCommMonCat.forget₂AddMonPreservesLimits
+-/
 
+#print CommMonCat.forget₂MonPreservesLimits /-
 @[to_additive]
 instance forget₂MonPreservesLimits : PreservesLimits (forget₂ CommMonCat MonCat.{u}) :=
   CommMonCat.forget₂MonPreservesLimitsOfSize.{u, u}
 #align CommMon.forget₂_Mon_preserves_limits CommMonCat.forget₂MonPreservesLimits
 #align AddCommMon.forget₂_Mon_preserves_limits AddCommMonCat.forget₂MonPreservesLimits
+-/
 
+#print CommMonCat.forgetPreservesLimitsOfSize /-
 /-- 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. -/
@@ -256,12 +309,15 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget Comm
         limits.comp_preserves_limit (forget₂ CommMonCat MonCat) (forget MonCat) }
 #align CommMon.forget_preserves_limits_of_size CommMonCat.forgetPreservesLimitsOfSize
 #align AddCommMon.forget_preserves_limits_of_size AddCommMonCat.forgetPreservesLimitsOfSize
+-/
 
+#print CommMonCat.forgetPreservesLimits /-
 @[to_additive]
 instance forgetPreservesLimits : PreservesLimits (forget CommMonCat.{u}) :=
   CommMonCat.forgetPreservesLimitsOfSize.{u, u}
 #align CommMon.forget_preserves_limits CommMonCat.forgetPreservesLimits
 #align AddCommMon.forget_preserves_limits AddCommMonCat.forgetPreservesLimits
+-/
 
 end CommMonCat

c43486ec

bump to nightly-2023-03-21-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/290a7ba01fbcab1b64757bdaa270d28f4dcede35

4b782568

Diff

@@ -31,51 +31,51 @@ open CategoryTheory.Limits
 
 universe v u
 
-namespace Mon
+namespace MonCat
 
 variable {J : Type v} [SmallCategory J]
 
 @[to_additive]
-instance monoidObj (F : J ⥤ Mon.{max v u}) (j) : Monoid ((F ⋙ forget Mon).obj j) :=
+instance monoidObj (F : J ⥤ MonCat.{max v u}) (j) : Monoid ((F ⋙ forget MonCat).obj j) :=
   by
   change Monoid (F.obj j)
   infer_instance
-#align Mon.monoid_obj Mon.monoidObj
-#align AddMon.add_monoid_obj AddMon.addMonoidObj
+#align Mon.monoid_obj MonCat.monoidObj
+#align AddMon.add_monoid_obj AddMonCat.addMonoidObj
 
 /-- The flat sections of a functor into `Mon` form a submonoid of all sections.
 -/
 @[to_additive
       "The flat sections of a functor into `AddMon` form an additive submonoid of all sections."]
-def sectionsSubmonoid (F : J ⥤ Mon.{max v u}) : Submonoid (∀ j, F.obj j)
+def sectionsSubmonoid (F : J ⥤ MonCat.{max v u}) : Submonoid (∀ j, F.obj j)
     where
-  carrier := (F ⋙ forget Mon).sections
+  carrier := (F ⋙ forget MonCat).sections
   one_mem' j j' f := by simp
   mul_mem' a b ah bh j j' f :=
     by
     simp only [forget_map_eq_coe, functor.comp_map, MonoidHom.map_mul, Pi.mul_apply]
     dsimp [functor.sections] at ah bh
     rw [ah f, bh f]
-#align Mon.sections_submonoid Mon.sectionsSubmonoid
-#align AddMon.sections_add_submonoid AddMon.sectionsAddSubmonoid
+#align Mon.sections_submonoid MonCat.sectionsSubmonoid
+#align AddMon.sections_add_submonoid AddMonCat.sectionsAddSubmonoid
 
 @[to_additive]
-instance limitMonoid (F : J ⥤ Mon.{max v u}) :
-    Monoid (Types.limitCone (F ⋙ forget Mon.{max v u})).pt :=
+instance limitMonoid (F : J ⥤ MonCat.{max v u}) :
+    Monoid (Types.limitCone (F ⋙ forget MonCat.{max v u})).pt :=
   (sectionsSubmonoid F).toMonoid
-#align Mon.limit_monoid Mon.limitMonoid
-#align AddMon.limit_add_monoid AddMon.limitAddMonoid
+#align Mon.limit_monoid MonCat.limitMonoid
+#align AddMon.limit_add_monoid AddMonCat.limitAddMonoid
 
 /-- `limit.π (F ⋙ forget Mon) j` as a `monoid_hom`. -/
 @[to_additive "`limit.π (F ⋙ forget AddMon) j` as an `add_monoid_hom`."]
-def limitπMonoidHom (F : J ⥤ Mon.{max v u}) (j) :
-    (Types.limitCone (F ⋙ forget Mon)).pt →* (F ⋙ forget Mon).obj j
+def limitπMonoidHom (F : J ⥤ MonCat.{max v u}) (j) :
+    (Types.limitCone (F ⋙ forget MonCat)).pt →* (F ⋙ forget MonCat).obj j
     where
-  toFun := (Types.limitCone (F ⋙ forget Mon)).π.app j
+  toFun := (Types.limitCone (F ⋙ forget MonCat)).π.app j
   map_one' := rfl
   map_mul' x y := rfl
-#align Mon.limit_π_monoid_hom Mon.limitπMonoidHom
-#align AddMon.limit_π_add_monoid_hom AddMon.limitπAddMonoidHom
+#align Mon.limit_π_monoid_hom MonCat.limitπMonoidHom
+#align AddMon.limit_π_add_monoid_hom AddMonCat.limitπAddMonoidHom
 
 namespace HasLimits
 
@@ -86,27 +86,27 @@ namespace HasLimits
 (Internal use only; use the limits API.)
 -/
 @[to_additive "(Internal use only; use the limits API.)"]
-def limitCone (F : J ⥤ Mon.{max v u}) : Cone F
+def limitCone (F : J ⥤ MonCat.{max v u}) : Cone F
     where
-  pt := Mon.of (Types.limitCone (F ⋙ forget _)).pt
+  pt := MonCat.of (Types.limitCone (F ⋙ forget _)).pt
   π :=
     { app := limitπMonoidHom F
       naturality' := fun j j' f =>
         MonoidHom.coe_inj ((Types.limitCone (F ⋙ forget _)).π.naturality f) }
-#align Mon.has_limits.limit_cone Mon.HasLimits.limitCone
-#align AddMon.has_limits.limit_cone AddMon.HasLimits.limitCone
+#align Mon.has_limits.limit_cone MonCat.HasLimits.limitCone
+#align AddMon.has_limits.limit_cone AddMonCat.HasLimits.limitCone
 
 /-- Witness that the limit cone in `Mon` is a limit cone.
 (Internal use only; use the limits API.)
 -/
 @[to_additive "(Internal use only; use the limits API.)"]
-def limitConeIsLimit (F : J ⥤ Mon.{max v u}) : IsLimit (limitCone F) := by
+def limitConeIsLimit (F : J ⥤ MonCat.{max v u}) : IsLimit (limitCone F) := by
   refine'
-      is_limit.of_faithful (forget Mon) (types.limit_cone_is_limit _) (fun s => ⟨_, _, _⟩) fun s =>
-        rfl <;>
+      is_limit.of_faithful (forget MonCat) (types.limit_cone_is_limit _) (fun s => ⟨_, _, _⟩)
+        fun s => rfl <;>
     tidy
-#align Mon.has_limits.limit_cone_is_limit Mon.HasLimits.limitConeIsLimit
-#align AddMon.has_limits.limit_cone_is_limit AddMon.HasLimits.limitConeIsLimit
+#align Mon.has_limits.limit_cone_is_limit MonCat.HasLimits.limitConeIsLimit
+#align AddMon.has_limits.limit_cone_is_limit AddMonCat.HasLimits.limitConeIsLimit
 
 end HasLimits
 
@@ -114,63 +114,64 @@ open HasLimits
 
 /-- The category of monoids has all limits. -/
 @[to_additive "The category of additive monoids has all limits."]
-instance hasLimitsOfSize : HasLimitsOfSize.{v} Mon.{max v u}
+instance hasLimitsOfSize : HasLimitsOfSize.{v} MonCat.{max v u}
     where HasLimitsOfShape J 𝒥 :=
     {
       HasLimit := fun F =>
         has_limit.mk
           { Cone := limit_cone F
             IsLimit := limit_cone_is_limit F } }
-#align Mon.has_limits_of_size Mon.hasLimitsOfSize
-#align AddMon.has_limits_of_size AddMon.hasLimitsOfSize
+#align Mon.has_limits_of_size MonCat.hasLimitsOfSize
+#align AddMon.has_limits_of_size AddMonCat.hasLimitsOfSize
 
 @[to_additive]
-instance hasLimits : HasLimits Mon.{u} :=
-  Mon.hasLimitsOfSize.{u, u}
-#align Mon.has_limits Mon.hasLimits
-#align AddMon.has_limits AddMon.hasLimits
+instance hasLimits : HasLimits MonCat.{u} :=
+  MonCat.hasLimitsOfSize.{u, u}
+#align Mon.has_limits MonCat.hasLimits
+#align AddMon.has_limits AddMonCat.hasLimits
 
 /-- 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. -/
 @[to_additive
       "The forgetful functor from additive monoids to types preserves all limits.\n\nThis means the underlying type of a limit can be computed as a limit in the category of types."]
-instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v} (forget Mon.{max v u})
+instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v} (forget MonCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 :=
     {
       PreservesLimit := fun F =>
         preserves_limit_of_preserves_limit_cone (limit_cone_is_limit F)
           (types.limit_cone_is_limit (F ⋙ forget _)) }
-#align Mon.forget_preserves_limits_of_size Mon.forgetPreservesLimitsOfSize
-#align AddMon.forget_preserves_limits_of_size AddMon.forgetPreservesLimitsOfSize
+#align Mon.forget_preserves_limits_of_size MonCat.forgetPreservesLimitsOfSize
+#align AddMon.forget_preserves_limits_of_size AddMonCat.forgetPreservesLimitsOfSize
 
 @[to_additive]
-instance forgetPreservesLimits : PreservesLimits (forget Mon.{u}) :=
-  Mon.forgetPreservesLimitsOfSize.{u, u}
-#align Mon.forget_preserves_limits Mon.forgetPreservesLimits
-#align AddMon.forget_preserves_limits AddMon.forgetPreservesLimits
+instance forgetPreservesLimits : PreservesLimits (forget MonCat.{u}) :=
+  MonCat.forgetPreservesLimitsOfSize.{u, u}
+#align Mon.forget_preserves_limits MonCat.forgetPreservesLimits
+#align AddMon.forget_preserves_limits AddMonCat.forgetPreservesLimits
 
-end Mon
+end MonCat
 
-namespace CommMon
+namespace CommMonCat
 
 variable {J : Type v} [SmallCategory J]
 
 @[to_additive]
-instance commMonoidObj (F : J ⥤ CommMon.{max v u}) (j) : CommMonoid ((F ⋙ forget CommMon).obj j) :=
+instance commMonoidObj (F : J ⥤ CommMonCat.{max v u}) (j) :
+    CommMonoid ((F ⋙ forget CommMonCat).obj j) :=
   by
   change CommMonoid (F.obj j)
   infer_instance
-#align CommMon.comm_monoid_obj CommMon.commMonoidObj
-#align AddCommMon.add_comm_monoid_obj AddCommMon.addCommMonoidObj
+#align CommMon.comm_monoid_obj CommMonCat.commMonoidObj
+#align AddCommMon.add_comm_monoid_obj AddCommMonCat.addCommMonoidObj
 
 @[to_additive]
-instance limitCommMonoid (F : J ⥤ CommMon.{max v u}) :
-    CommMonoid (Types.limitCone (F ⋙ forget CommMon.{max v u})).pt :=
+instance limitCommMonoid (F : J ⥤ CommMonCat.{max v u}) :
+    CommMonoid (Types.limitCone (F ⋙ forget CommMonCat.{max v u})).pt :=
   @Submonoid.toCommMonoid (∀ j, F.obj j) _
-    (Mon.sectionsSubmonoid (F ⋙ forget₂ CommMon Mon.{max v u}))
-#align CommMon.limit_comm_monoid CommMon.limitCommMonoid
-#align AddCommMon.limit_add_comm_monoid AddCommMon.limitAddCommMonoid
+    (MonCat.sectionsSubmonoid (F ⋙ forget₂ CommMonCat MonCat.{max v u}))
+#align CommMon.limit_comm_monoid CommMonCat.limitCommMonoid
+#align AddCommMon.limit_add_comm_monoid AddCommMonCat.limitAddCommMonoid
 
 /-- We show that the forgetful functor `CommMon ⥤ Mon` creates limits.
 
@@ -178,86 +179,89 @@ All we need to do is notice that the limit point has a `comm_monoid` instance av
 and then reuse the existing limit. -/
 @[to_additive
       "We show that the forgetful functor `AddCommMon ⥤ AddMon` creates limits.\n\nAll we need to do is notice that the limit point has an `add_comm_monoid` instance available,\nand then reuse the existing limit."]
-instance (F : J ⥤ CommMon.{max v u}) : CreatesLimit F (forget₂ CommMon Mon.{max v u}) :=
+instance (F : J ⥤ CommMonCat.{max v u}) : CreatesLimit F (forget₂ CommMonCat MonCat.{max v u}) :=
   createsLimitOfReflectsIso fun c' t =>
     { liftedCone :=
-        { pt := CommMon.of (Types.limitCone (F ⋙ forget CommMon)).pt
+        { pt := CommMonCat.of (Types.limitCone (F ⋙ forget CommMonCat)).pt
           π :=
-            { app := Mon.limitπMonoidHom (F ⋙ forget₂ CommMon Mon.{max v u})
+            { app := MonCat.limitπMonoidHom (F ⋙ forget₂ CommMonCat MonCat.{max v u})
               naturality' :=
-                (Mon.HasLimits.limitCone (F ⋙ forget₂ CommMon Mon.{max v u})).π.naturality } }
-      validLift := by apply is_limit.unique_up_to_iso (Mon.HasLimits.limitConeIsLimit _) t
+                (MonCat.HasLimits.limitCone
+                      (F ⋙ forget₂ CommMonCat MonCat.{max v u})).π.naturality } }
+      validLift := by apply is_limit.unique_up_to_iso (MonCat.HasLimits.limitConeIsLimit _) t
       makesLimit :=
-        IsLimit.ofFaithful (forget₂ CommMon Mon.{max v u}) (Mon.HasLimits.limitConeIsLimit _)
-          (fun s => _) fun s => rfl }
+        IsLimit.ofFaithful (forget₂ CommMonCat MonCat.{max v u})
+          (MonCat.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl }
 
 /-- A choice of limit cone for a functor into `CommMon`.
 (Generally, you'll just want to use `limit F`.)
 -/
 @[to_additive
       "A choice of limit cone for a functor into `CommMon`. (Generally, you'll just want\nto use `limit F`.)"]
-def limitCone (F : J ⥤ CommMon.{max v u}) : Cone F :=
-  liftLimit (limit.isLimit (F ⋙ forget₂ CommMon Mon.{max v u}))
-#align CommMon.limit_cone CommMon.limitCone
-#align AddCommMon.limit_cone AddCommMon.limitCone
+def limitCone (F : J ⥤ CommMonCat.{max v u}) : Cone F :=
+  liftLimit (limit.isLimit (F ⋙ forget₂ CommMonCat MonCat.{max v u}))
+#align CommMon.limit_cone CommMonCat.limitCone
+#align AddCommMon.limit_cone AddCommMonCat.limitCone
 
 /-- The chosen cone is a limit cone.
 (Generally, you'll just want to use `limit.cone F`.)
 -/
 @[to_additive
       "The chosen cone is a limit cone. (Generally, you'll just want to use\n`limit.cone F`.)"]
-def limitConeIsLimit (F : J ⥤ CommMon.{max v u}) : IsLimit (limitCone F) :=
+def limitConeIsLimit (F : J ⥤ CommMonCat.{max v u}) : IsLimit (limitCone F) :=
   liftedLimitIsLimit _
-#align CommMon.limit_cone_is_limit CommMon.limitConeIsLimit
-#align AddCommMon.limit_cone_is_limit AddCommMon.limitConeIsLimit
+#align CommMon.limit_cone_is_limit CommMonCat.limitConeIsLimit
+#align AddCommMon.limit_cone_is_limit AddCommMonCat.limitConeIsLimit
 
 /-- The category of commutative monoids has all limits. -/
 @[to_additive "The category of commutative monoids has all limits."]
-instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommMon.{max v u}
+instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommMonCat.{max v u}
     where HasLimitsOfShape J 𝒥 :=
-    { HasLimit := fun F => has_limit_of_created F (forget₂ CommMon Mon.{max v u}) }
-#align CommMon.has_limits_of_size CommMon.hasLimitsOfSize
-#align AddCommMon.has_limits_of_size AddCommMon.hasLimitsOfSize
+    { HasLimit := fun F => has_limit_of_created F (forget₂ CommMonCat MonCat.{max v u}) }
+#align CommMon.has_limits_of_size CommMonCat.hasLimitsOfSize
+#align AddCommMon.has_limits_of_size AddCommMonCat.hasLimitsOfSize
 
 @[to_additive]
-instance hasLimits : HasLimits CommMon.{u} :=
-  CommMon.hasLimitsOfSize.{u, u}
-#align CommMon.has_limits CommMon.hasLimits
-#align AddCommMon.has_limits AddCommMon.hasLimits
+instance hasLimits : HasLimits CommMonCat.{u} :=
+  CommMonCat.hasLimitsOfSize.{u, u}
+#align CommMon.has_limits CommMonCat.hasLimits
+#align AddCommMon.has_limits AddCommMonCat.hasLimits
 
 /-- 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. -/
-@[to_additive AddCommMon.forget₂AddMonPreservesLimits
+@[to_additive AddCommMonCat.forget₂AddMonPreservesLimits
       "The forgetful functor from additive\ncommutative monoids to additive monoids preserves all limits.\n\nThis means the underlying type of a limit can be computed as a limit in the category of additive\nmonoids."]
 instance forget₂MonPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ CommMon Mon.{max v u})
+    PreservesLimitsOfSize.{v, v} (forget₂ CommMonCat MonCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance }
-#align CommMon.forget₂_Mon_preserves_limits_of_size CommMon.forget₂MonPreservesLimitsOfSize
-#align AddCommMon.forget₂_AddMon_preserves_limits AddCommMon.forget₂AddMonPreservesLimits
+#align CommMon.forget₂_Mon_preserves_limits_of_size CommMonCat.forget₂MonPreservesLimitsOfSize
+#align AddCommMon.forget₂_AddMon_preserves_limits AddCommMonCat.forget₂AddMonPreservesLimits
 
 @[to_additive]
-instance forget₂MonPreservesLimits : PreservesLimits (forget₂ CommMon Mon.{u}) :=
-  CommMon.forget₂MonPreservesLimitsOfSize.{u, u}
-#align CommMon.forget₂_Mon_preserves_limits CommMon.forget₂MonPreservesLimits
-#align AddCommMon.forget₂_Mon_preserves_limits AddCommMon.forget₂MonPreservesLimits
+instance forget₂MonPreservesLimits : PreservesLimits (forget₂ CommMonCat MonCat.{u}) :=
+  CommMonCat.forget₂MonPreservesLimitsOfSize.{u, u}
+#align CommMon.forget₂_Mon_preserves_limits CommMonCat.forget₂MonPreservesLimits
+#align AddCommMon.forget₂_Mon_preserves_limits AddCommMonCat.forget₂MonPreservesLimits
 
 /-- 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. -/
 @[to_additive
       "The forgetful functor from additive commutative monoids to types preserves all\nlimits.\n\nThis means the underlying type of a limit can be computed as a limit in the category of types."]
-instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget CommMon.{max v u})
+instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget CommMonCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 :=
-    { PreservesLimit := fun F => limits.comp_preserves_limit (forget₂ CommMon Mon) (forget Mon) }
-#align CommMon.forget_preserves_limits_of_size CommMon.forgetPreservesLimitsOfSize
-#align AddCommMon.forget_preserves_limits_of_size AddCommMon.forgetPreservesLimitsOfSize
+    {
+      PreservesLimit := fun F =>
+        limits.comp_preserves_limit (forget₂ CommMonCat MonCat) (forget MonCat) }
+#align CommMon.forget_preserves_limits_of_size CommMonCat.forgetPreservesLimitsOfSize
+#align AddCommMon.forget_preserves_limits_of_size AddCommMonCat.forgetPreservesLimitsOfSize
 
 @[to_additive]
-instance forgetPreservesLimits : PreservesLimits (forget CommMon.{u}) :=
-  CommMon.forgetPreservesLimitsOfSize.{u, u}
-#align CommMon.forget_preserves_limits CommMon.forgetPreservesLimits
-#align AddCommMon.forget_preserves_limits AddCommMon.forgetPreservesLimits
+instance forgetPreservesLimits : PreservesLimits (forget CommMonCat.{u}) :=
+  CommMonCat.forgetPreservesLimitsOfSize.{u, u}
+#align CommMon.forget_preserves_limits CommMonCat.forgetPreservesLimits
+#align AddCommMon.forget_preserves_limits AddCommMonCat.forgetPreservesLimits
 
-end CommMon
+end CommMonCat

c43486ec

bump to nightly-2023-02-28-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/9da1b3534b65d9661eb8f42443598a92bbb49211

1fb1623f

Diff

@@ -61,7 +61,7 @@ def sectionsSubmonoid (F : J ⥤ Mon.{max v u}) : Submonoid (∀ j, F.obj j)
 
 @[to_additive]
 instance limitMonoid (F : J ⥤ Mon.{max v u}) :
-    Monoid (Types.limitCone (F ⋙ forget Mon.{max v u})).x :=
+    Monoid (Types.limitCone (F ⋙ forget Mon.{max v u})).pt :=
   (sectionsSubmonoid F).toMonoid
 #align Mon.limit_monoid Mon.limitMonoid
 #align AddMon.limit_add_monoid AddMon.limitAddMonoid
@@ -69,7 +69,7 @@ instance limitMonoid (F : J ⥤ Mon.{max v u}) :
 /-- `limit.π (F ⋙ forget Mon) j` as a `monoid_hom`. -/
 @[to_additive "`limit.π (F ⋙ forget AddMon) j` as an `add_monoid_hom`."]
 def limitπMonoidHom (F : J ⥤ Mon.{max v u}) (j) :
-    (Types.limitCone (F ⋙ forget Mon)).x →* (F ⋙ forget Mon).obj j
+    (Types.limitCone (F ⋙ forget Mon)).pt →* (F ⋙ forget Mon).obj j
     where
   toFun := (Types.limitCone (F ⋙ forget Mon)).π.app j
   map_one' := rfl
@@ -88,7 +88,7 @@ namespace HasLimits
 @[to_additive "(Internal use only; use the limits API.)"]
 def limitCone (F : J ⥤ Mon.{max v u}) : Cone F
     where
-  x := Mon.of (Types.limitCone (F ⋙ forget _)).x
+  pt := Mon.of (Types.limitCone (F ⋙ forget _)).pt
   π :=
     { app := limitπMonoidHom F
       naturality' := fun j j' f =>
@@ -166,7 +166,7 @@ instance commMonoidObj (F : J ⥤ CommMon.{max v u}) (j) : CommMonoid ((F ⋙ fo
 
 @[to_additive]
 instance limitCommMonoid (F : J ⥤ CommMon.{max v u}) :
-    CommMonoid (Types.limitCone (F ⋙ forget CommMon.{max v u})).x :=
+    CommMonoid (Types.limitCone (F ⋙ forget CommMon.{max v u})).pt :=
   @Submonoid.toCommMonoid (∀ j, F.obj j) _
     (Mon.sectionsSubmonoid (F ⋙ forget₂ CommMon Mon.{max v u}))
 #align CommMon.limit_comm_monoid CommMon.limitCommMonoid
@@ -181,7 +181,7 @@ and then reuse the existing limit. -/
 instance (F : J ⥤ CommMon.{max v u}) : CreatesLimit F (forget₂ CommMon Mon.{max v u}) :=
   createsLimitOfReflectsIso fun c' t =>
     { liftedCone :=
-        { x := CommMon.of (Types.limitCone (F ⋙ forget CommMon)).x
+        { pt := CommMon.of (Types.limitCone (F ⋙ forget CommMon)).pt
           π :=
             { app := Mon.limitπMonoidHom (F ⋙ forget₂ CommMon Mon.{max v u})
               naturality' :=

c43486ec

bump to nightly-2023-02-27-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/eb0cb4511aaef0da2462207b67358a0e1fe1e2ee

91d8c210

Diff

@@ -106,7 +106,7 @@ def limitConeIsLimit (F : J ⥤ Mon.{max v u}) : IsLimit (limitCone F) := by
         rfl <;>
     tidy
 #align Mon.has_limits.limit_cone_is_limit Mon.HasLimits.limitConeIsLimit
-#align AddMon.has_limits.limit_cone_is_limit AddMon.HasLimits.limit_cone_is_limit
+#align AddMon.has_limits.limit_cone_is_limit AddMon.HasLimits.limitConeIsLimit
 
 end HasLimits
 
@@ -122,7 +122,7 @@ instance hasLimitsOfSize : HasLimitsOfSize.{v} Mon.{max v u}
           { Cone := limit_cone F
             IsLimit := limit_cone_is_limit F } }
 #align Mon.has_limits_of_size Mon.hasLimitsOfSize
-#align AddMon.has_limits_of_size AddMon.has_limits_of_size
+#align AddMon.has_limits_of_size AddMon.hasLimitsOfSize
 
 @[to_additive]
 instance hasLimits : HasLimits Mon.{u} :=
@@ -142,7 +142,7 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v} (forget Mon.{ma
         preserves_limit_of_preserves_limit_cone (limit_cone_is_limit F)
           (types.limit_cone_is_limit (F ⋙ forget _)) }
 #align Mon.forget_preserves_limits_of_size Mon.forgetPreservesLimitsOfSize
-#align AddMon.forget_preserves_limits_of_size AddMon.forget_preserves_limits_of_size
+#align AddMon.forget_preserves_limits_of_size AddMon.forgetPreservesLimitsOfSize
 
 @[to_additive]
 instance forgetPreservesLimits : PreservesLimits (forget Mon.{u}) :=
@@ -209,7 +209,7 @@ def limitCone (F : J ⥤ CommMon.{max v u}) : Cone F :=
 def limitConeIsLimit (F : J ⥤ CommMon.{max v u}) : IsLimit (limitCone F) :=
   liftedLimitIsLimit _
 #align CommMon.limit_cone_is_limit CommMon.limitConeIsLimit
-#align AddCommMon.limit_cone_is_limit AddCommMon.limit_cone_is_limit
+#align AddCommMon.limit_cone_is_limit AddCommMon.limitConeIsLimit
 
 /-- The category of commutative monoids has all limits. -/
 @[to_additive "The category of commutative monoids has all limits."]
@@ -217,7 +217,7 @@ instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommMon.{max v u}
     where HasLimitsOfShape J 𝒥 :=
     { HasLimit := fun F => has_limit_of_created F (forget₂ CommMon Mon.{max v u}) }
 #align CommMon.has_limits_of_size CommMon.hasLimitsOfSize
-#align AddCommMon.has_limits_of_size AddCommMon.has_limits_of_size
+#align AddCommMon.has_limits_of_size AddCommMon.hasLimitsOfSize
 
 @[to_additive]
 instance hasLimits : HasLimits CommMon.{u} :=
@@ -228,13 +228,13 @@ instance hasLimits : HasLimits CommMon.{u} :=
 /-- 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. -/
-@[to_additive AddCommMon.forget₂_AddMon_preserves_limits
+@[to_additive AddCommMon.forget₂AddMonPreservesLimits
       "The forgetful functor from additive\ncommutative monoids to additive monoids preserves all limits.\n\nThis means the underlying type of a limit can be computed as a limit in the category of additive\nmonoids."]
 instance forget₂MonPreservesLimitsOfSize :
     PreservesLimitsOfSize.{v, v} (forget₂ CommMon Mon.{max v u})
     where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance }
 #align CommMon.forget₂_Mon_preserves_limits_of_size CommMon.forget₂MonPreservesLimitsOfSize
-#align AddCommMon.forget₂_AddMon_preserves_limits AddCommMon.forget₂_AddMon_preserves_limits
+#align AddCommMon.forget₂_AddMon_preserves_limits AddCommMon.forget₂AddMonPreservesLimits
 
 @[to_additive]
 instance forget₂MonPreservesLimits : PreservesLimits (forget₂ CommMon Mon.{u}) :=
@@ -251,7 +251,7 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget Comm
     where PreservesLimitsOfShape J 𝒥 :=
     { PreservesLimit := fun F => limits.comp_preserves_limit (forget₂ CommMon Mon) (forget Mon) }
 #align CommMon.forget_preserves_limits_of_size CommMon.forgetPreservesLimitsOfSize
-#align AddCommMon.forget_preserves_limits_of_size AddCommMon.forget_preserves_limits_of_size
+#align AddCommMon.forget_preserves_limits_of_size AddCommMon.forgetPreservesLimitsOfSize
 
 @[to_additive]
 instance forgetPreservesLimits : PreservesLimits (forget CommMon.{u}) :=

c43486ec

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

c43486ec

doc(Algebra,AlgebraicGeometry): remove mathlib3 names in doc comments (#11955)

Mostly automatic, with a few manual corrections.

11516514

Diff

@@ -20,7 +20,7 @@ the underlying types are just the limits in the category of types.
 
 -/
 
-set_option linter.uppercaseLean3 false -- `Mon`
+set_option linter.uppercaseLean3 false
 
 noncomputable section

c43486ec

refactor(Algebra/Category): replace TypeMax constructions by UnivLE assumptions (#11420)

Replaces TypeMax limit constructions in MonCat, GroupCat, Ring, AlgebraCat and ModuleCat by the UnivLE analogs. Also generalizes some universe assumptions.

a746c523

Diff

@@ -8,6 +8,7 @@ import Mathlib.Algebra.Group.Pi.Lemmas
 import Mathlib.CategoryTheory.Limits.Creates
 import Mathlib.CategoryTheory.Limits.Types
 import Mathlib.GroupTheory.Submonoid.Operations
+import Mathlib.Logic.Equiv.TransferInstance
 
 #align_import algebra.category.Mon.limits from "leanprover-community/mathlib"@"c43486ecf2a5a17479a32ce09e4818924145e90e"
 
@@ -27,7 +28,7 @@ open CategoryTheory
 
 open CategoryTheory.Limits
 
-universe v u
+universe v u w
 
 -- Porting note: typemax hack to fix universe complaints
 /-- An alias for `MonCat.{max u v}`, to deal around unification issues. -/
@@ -37,12 +38,11 @@ abbrev MonCatMax.{u1, u2} := MonCat.{max u1 u2}
 
 namespace MonCat
 
-variable {J : Type v} [SmallCategory J]
+variable {J : Type v} [Category.{w} J] (F : J ⥤ MonCat.{u})
 
 @[to_additive]
-instance monoidObj (F : J ⥤ MonCatMax.{u,v} ) (j) : Monoid ((F ⋙ forget MonCat).obj j) := by
-  change Monoid (F.obj j)
-  infer_instance
+instance monoidObj (j) : Monoid ((F ⋙ forget MonCat).obj j) :=
+  inferInstanceAs <| Monoid (F.obj j)
 #align Mon.monoid_obj MonCat.monoidObj
 #align AddMon.add_monoid_obj AddMonCat.addMonoidObj
 
@@ -50,7 +50,7 @@ instance monoidObj (F : J ⥤ MonCatMax.{u,v} ) (j) : Monoid ((F ⋙ forget MonC
 -/
 @[to_additive
       "The flat sections of a functor into `AddMonCat` form an additive submonoid of all sections."]
-def sectionsSubmonoid (F : J ⥤ MonCatMax.{u,v}) : Submonoid (∀ j, F.obj j) where
+def sectionsSubmonoid : Submonoid (∀ j, F.obj j) where
   carrier := (F ⋙ forget MonCat).sections
   one_mem' {j} {j'} f := by simp
   mul_mem' {a} {b} ah bh {j} {j'} f := by
@@ -61,20 +61,30 @@ def sectionsSubmonoid (F : J ⥤ MonCatMax.{u,v}) : Submonoid (∀ j, F.obj j) w
 #align AddMon.sections_add_submonoid AddMonCat.sectionsAddSubmonoid
 
 @[to_additive]
-instance limitMonoid (F : J ⥤ MonCatMax.{u,v}) :
-    Monoid (Types.limitCone.{v, u} (F ⋙ forget MonCatMax.{u,v})).pt :=
-  (sectionsSubmonoid.{v, u} F).toMonoid
+instance sectionsMonoid : Monoid (F ⋙ forget MonCat.{u}).sections :=
+  (sectionsSubmonoid F).toMonoid
+
+variable [Small.{u} (Functor.sections (F ⋙ forget MonCat))]
+
+@[to_additive]
+noncomputable instance limitMonoid :
+    Monoid (Types.Small.limitCone.{v, u} (F ⋙ forget MonCat.{u})).pt :=
+  inferInstanceAs <| Monoid (Shrink (F ⋙ forget MonCat.{u}).sections)
 #align Mon.limit_monoid MonCat.limitMonoid
 #align AddMon.limit_add_monoid AddMonCat.limitAddMonoid
 
 /-- `limit.π (F ⋙ forget MonCat) j` as a `MonoidHom`. -/
 @[to_additive "`limit.π (F ⋙ forget AddMonCat) j` as an `AddMonoidHom`."]
-noncomputable def limitπMonoidHom (F : J ⥤ MonCatMax.{u, v}) (j : J) :
-  (Types.limitCone.{v, u} (F ⋙ forget MonCatMax.{u, v})).pt →*
-    ((F ⋙ forget MonCat.{max v u}).obj j) :=
-  { toFun := (Types.limitCone.{v, u} (F ⋙ forget MonCatMax.{u, v})).π.app j,
-    map_one' := rfl
-    map_mul' := fun _ _ => rfl }
+noncomputable def limitπMonoidHom (j : J) :
+    (Types.Small.limitCone.{v, u} (F ⋙ forget MonCat.{u})).pt →*
+      ((F ⋙ forget MonCat.{u}).obj j) where
+  toFun := (Types.Small.limitCone.{v, u} (F ⋙ forget MonCat.{u})).π.app j
+  map_one' := by
+    simp only [Types.Small.limitCone_π_app, ← Equiv.mulEquiv_apply, map_one]
+    rfl
+  map_mul' _ _ := by
+    simp only [Types.Small.limitCone_π_app, ← Equiv.mulEquiv_apply, map_mul]
+    rfl
 #align Mon.limit_π_monoid_hom MonCat.limitπMonoidHom
 #align AddMon.limit_π_add_monoid_hom AddMonCat.limitπAddMonoidHom
 
@@ -87,13 +97,13 @@ namespace HasLimits
 (Internal use only; use the limits API.)
 -/
 @[to_additive "(Internal use only; use the limits API.)"]
-noncomputable def limitCone (F : J ⥤ MonCatMax.{u,v}) : Cone F :=
-  { pt := MonCat.of (Types.limitCone (F ⋙ forget _)).pt
+noncomputable def limitCone : Cone F :=
+  { pt := MonCat.of (Types.Small.limitCone (F ⋙ forget _)).pt
     π :=
     { app := limitπMonoidHom F
       naturality := fun _ _ f =>
         set_option linter.deprecated false in
-        MonoidHom.coe_inj ((Types.limitCone (F ⋙ forget _)).π.naturality f) } }
+        MonoidHom.coe_inj ((Types.Small.limitCone (F ⋙ forget _)).π.naturality f) } }
 #align Mon.has_limits.limit_cone MonCat.HasLimits.limitCone
 #align AddMon.has_limits.limit_cone AddMonCat.HasLimits.limitCone
 
@@ -101,25 +111,39 @@ noncomputable def limitCone (F : J ⥤ MonCatMax.{u,v}) : Cone F :=
 (Internal use only; use the limits API.)
 -/
 @[to_additive "(Internal use only; use the limits API.)"]
-noncomputable def limitConeIsLimit (F : J ⥤ MonCatMax.{u,v}) : IsLimit (limitCone F) := by
-  refine IsLimit.ofFaithful (forget MonCatMax) (Types.limitConeIsLimit.{v,u} _)
-    (fun s => { toFun := _, map_one' := ?_, map_mul' := ?_ }) (fun s => rfl) <;>
-  aesop_cat
+noncomputable def limitConeIsLimit : IsLimit (limitCone F) := by
+  refine IsLimit.ofFaithful (forget MonCat) (Types.Small.limitConeIsLimit.{v,u} _)
+    (fun s => { toFun := _, map_one' := ?_, map_mul' := ?_ }) (fun s => rfl)
+  · simp only [Functor.mapCone_π_app, forget_map, map_one]
+    rfl
+  · intro x y
+    simp only [Functor.mapCone_π_app, forget_map, map_mul]
+    erw [← map_mul (MulEquiv.symm Shrink.mulEquiv)]
+    rfl
 #align Mon.has_limits.limit_cone_is_limit MonCat.HasLimits.limitConeIsLimit
 #align AddMon.has_limits.limit_cone_is_limit AddMonCat.HasLimits.limitConeIsLimit
 
+/-- If `(F ⋙ forget MonCat).sections` is `u`-small, `F` has a limit. -/
+@[to_additive "If `(F ⋙ forget AddMonCat).sections` is `u`-small, `F` has a limit."]
+instance hasLimit : HasLimit F :=
+  HasLimit.mk {
+    cone := limitCone F
+    isLimit := limitConeIsLimit F
+  }
+
+/-- If `J` is `u`-small, `MonCat.{u}` has limits of shape `J`. -/
+@[to_additive "If `J` is `u`-small, `AddMonCat.{u}` has limits of shape `J`."]
+instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J MonCat.{u} where
+  has_limit _ := inferInstance
+
 end HasLimits
 
 open HasLimits
 
 /-- The category of monoids has all limits. -/
 @[to_additive "The category of additive monoids has all limits."]
-instance hasLimitsOfSize : HasLimitsOfSize.{v} MonCatMax.{u,v} where
-  has_limits_of_shape _ _ :=
-    { has_limit := fun F =>
-        HasLimit.mk
-          { cone := limitCone F
-            isLimit := limitConeIsLimit F } }
+instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} MonCat.{u} where
+  has_limits_of_shape _ _ := { }
 #align Mon.has_limits_of_size MonCat.hasLimitsOfSize
 #align AddMon.has_limits_of_size AddMonCat.hasLimitsOfSize
 
@@ -129,17 +153,24 @@ instance hasLimits : HasLimits MonCat.{u} :=
 #align Mon.has_limits MonCat.hasLimits
 #align AddMon.has_limits AddMonCat.hasLimits
 
+/-- If `J` is `u`-small, the forgetful functor from `MonCat.{u}` preserves limits of shape `J`. -/
+@[to_additive "If `J` is `u`-small, the forgetful functor from `AddMonCat.{u}`\n
+preserves limits of shape `J`."]
+noncomputable instance forgetPreservesLimitsOfShape [Small.{u} J] :
+    PreservesLimitsOfShape J (forget MonCat.{u}) where
+  preservesLimit {F} := preservesLimitOfPreservesLimitCone (limitConeIsLimit F)
+    (Types.Small.limitConeIsLimit (F ⋙ forget _))
+
 /-- 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. -/
-@[to_additive "The forgetful functor from additive monoids to types preserves all limits.\n\n
-This means the underlying type of a limit can be computed as a limit in the category of types."]
-noncomputable instance forgetPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v} (forget MonCatMax.{u,v}) where
-  preservesLimitsOfShape {_} _ :=
-    { preservesLimit := fun {F} =>
-        preservesLimitOfPreservesLimitCone (limitConeIsLimit F)
-          (Types.limitConeIsLimit (F ⋙ forget _)) }
+@[to_additive
+  "The forgetful functor from additive monoids to types preserves all limits.\n\n
+  This means the underlying type of a limit can be computed as a limit in the category of types.",
+  to_additive_relevant_arg 2]
+noncomputable instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
+    PreservesLimitsOfSize.{w, v} (forget MonCat.{u}) where
+  preservesLimitsOfShape := { }
 #align Mon.forget_preserves_limits_of_size MonCat.forgetPreservesLimitsOfSize
 #align AddMon.forget_preserves_limits_of_size AddMonCat.forgetPreservesLimitsOfSize
 
@@ -153,8 +184,6 @@ end MonCat
 
 open MonCat
 
--- Porting note: typemax hack
-
 /-- An alias for `CommMonCat.{max u v}`, to deal around unification issues. -/
 @[to_additive (attr := nolint checkUnivs) AddCommMonCatMax
   "An alias for `AddCommMonCat.{max u v}`, to deal around unification issues."]
@@ -162,24 +191,30 @@ abbrev CommMonCatMax.{u1, u2} := CommMonCat.{max u1 u2}
 
 namespace CommMonCat
 
-variable {J : Type v} [SmallCategory J]
+variable {J : Type v} [Category.{w} J] (F : J ⥤ CommMonCat.{u})
 
 @[to_additive]
-instance commMonoidObj (F : J ⥤ CommMonCatMax.{u,v}) (j) :
-    CommMonoid ((F ⋙ forget CommMonCatMax.{u,v}).obj j) := by
-  change CommMonoid (F.obj j)
-  infer_instance
+instance commMonoidObj (j) : CommMonoid ((F ⋙ forget CommMonCat.{u}).obj j) :=
+  inferInstanceAs <| CommMonoid (F.obj j)
 #align CommMon.comm_monoid_obj CommMonCat.commMonoidObj
 #align AddCommMon.add_comm_monoid_obj AddCommMonCat.addCommMonoidObj
 
+variable [Small.{u} (Functor.sections (F ⋙ forget CommMonCat))]
+
 @[to_additive]
-instance limitCommMonoid (F : J ⥤ CommMonCatMax.{u,v}) :
-    CommMonoid (Types.limitCone.{v,u} (F ⋙ forget CommMonCatMax.{u,v})).pt :=
-  @Submonoid.toCommMonoid (∀ j, F.obj j) _
-    (MonCat.sectionsSubmonoid (F ⋙ forget₂ CommMonCatMax.{u,v} MonCatMax.{u,v}))
+noncomputable instance limitCommMonoid :
+    CommMonoid (Types.Small.limitCone (F ⋙ forget CommMonCat.{u})).pt :=
+  letI : CommMonoid (F ⋙ forget CommMonCat.{u}).sections :=
+    @Submonoid.toCommMonoid (∀ j, F.obj j) _
+      (MonCat.sectionsSubmonoid (F ⋙ forget₂ CommMonCat.{u} MonCat.{u}))
+  inferInstanceAs <| CommMonoid (Shrink (F ⋙ forget CommMonCat.{u}).sections)
 #align CommMon.limit_comm_monoid CommMonCat.limitCommMonoid
 #align AddCommMon.limit_add_comm_monoid AddCommMonCat.limitAddCommMonoid
 
+@[to_additive]
+instance : Small.{u} (Functor.sections ((F ⋙ forget₂ CommMonCat MonCat) ⋙ forget MonCat)) :=
+  inferInstanceAs <| Small.{u} (Functor.sections (F ⋙ forget CommMonCat))
+
 /-- 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,
@@ -187,19 +222,18 @@ and then reuse the existing limit. -/
 @[to_additive "We show that the forgetful functor `AddCommMonCat ⥤ AddMonCat` creates limits.\n\n
 All we need to do is notice that the limit point has an `AddCommMonoid` instance available,\n
 and then reuse the existing limit."]
-noncomputable instance forget₂CreatesLimit (F : J ⥤ CommMonCatMax.{u,v}) :
-    CreatesLimit F (forget₂ CommMonCat MonCatMax.{u, v}) :=
+noncomputable instance forget₂CreatesLimit : CreatesLimit F (forget₂ CommMonCat MonCat.{u}) :=
   createsLimitOfReflectsIso fun c' t =>
     { liftedCone :=
-        { pt := CommMonCat.of (Types.limitCone (F ⋙ forget CommMonCat)).pt
+        { pt := CommMonCat.of (Types.Small.limitCone (F ⋙ forget CommMonCat)).pt
           π :=
-            { app := MonCat.limitπMonoidHom (F ⋙ forget₂ CommMonCatMax.{u,v} MonCatMax.{u,v})
+            { app := MonCat.limitπMonoidHom (F ⋙ forget₂ CommMonCat.{u} MonCat.{u})
               naturality :=
                 (MonCat.HasLimits.limitCone
-                      (F ⋙ forget₂ CommMonCat MonCat.{max v u})).π.naturality } }
+                      (F ⋙ forget₂ CommMonCat MonCat.{u})).π.naturality } }
       validLift := by apply IsLimit.uniqueUpToIso (MonCat.HasLimits.limitConeIsLimit _) t
       makesLimit :=
-        IsLimit.ofFaithful (forget₂ CommMonCat MonCat.{max v u})
+        IsLimit.ofFaithful (forget₂ CommMonCat MonCat.{u})
           (MonCat.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl }
 
 /-- A choice of limit cone for a functor into `CommMonCat`.
@@ -207,8 +241,8 @@ noncomputable instance forget₂CreatesLimit (F : J ⥤ CommMonCatMax.{u,v}) :
 -/
 @[to_additive "A choice of limit cone for a functor into `AddCommMonCat`.
 (Generally, you'll just want to use `limit F`.)"]
-noncomputable def limitCone (F : J ⥤ CommMonCatMax.{u,v}) : Cone F :=
-  liftLimit (limit.isLimit (F ⋙ forget₂ CommMonCatMax.{u,v} MonCatMax.{u,v}))
+noncomputable def limitCone : Cone F :=
+  liftLimit (limit.isLimit (F ⋙ forget₂ CommMonCat.{u} MonCat.{u}))
 #align CommMon.limit_cone CommMonCat.limitCone
 #align AddCommMon.limit_cone AddCommMonCat.limitCone
 
@@ -217,16 +251,28 @@ noncomputable def limitCone (F : J ⥤ CommMonCatMax.{u,v}) : Cone F :=
 -/
 @[to_additive
       "The chosen cone is a limit cone. (Generally, you'll just want to use\n`limit.cone F`.)"]
-noncomputable def limitConeIsLimit (F : J ⥤ CommMonCatMax.{u,v}) : IsLimit (limitCone F) :=
+noncomputable def limitConeIsLimit : IsLimit (limitCone F) :=
   liftedLimitIsLimit _
 #align CommMon.limit_cone_is_limit CommMonCat.limitConeIsLimit
 #align AddCommMon.limit_cone_is_limit AddCommMonCat.limitConeIsLimit
 
+/-- If `(F ⋙ forget CommMonCat).sections` is `u`-small, `F` has a limit. -/
+@[to_additive "If `(F ⋙ forget AddCommMonCat).sections` is `u`-small, `F` has a limit."]
+instance hasLimit : HasLimit F :=
+  HasLimit.mk {
+    cone := limitCone F
+    isLimit := limitConeIsLimit F
+  }
+
+/-- If `J` is `u`-small, `CommMonCat.{u}` has limits of shape `J`. -/
+@[to_additive "If `J` is `u`-small, `AddCommMonCat.{u}` has limits of shape `J`."]
+instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J CommMonCat.{u} where
+  has_limit _ := inferInstance
+
 /-- The category of commutative monoids has all limits. -/
 @[to_additive "The category of additive commutative monoids has all limits."]
-instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommMonCatMax.{u,v} where
-  has_limits_of_shape _ _ :=
-    { has_limit := fun F => hasLimit_of_created F (forget₂ CommMonCatMax.{u,v} MonCatMax.{u,v}) }
+instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} CommMonCat.{u} where
+  has_limits_of_shape _ _ := { }
 #align CommMon.has_limits_of_size CommMonCat.hasLimitsOfSize
 #align AddCommMon.has_limits_of_size AddCommMonCat.hasLimitsOfSize
 
@@ -239,43 +285,53 @@ instance hasLimits : HasLimits CommMonCat.{u} :=
 /-- 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. -/
-@[to_additive AddCommMonCat.forget₂AddMonPreservesLimits "The forgetful functor from additive\n
-commutative monoids to additive monoids preserves all limits.\n\n
-This means the underlying type of a limit can be computed as a limit in the category of additive\n
-monoids."]
-noncomputable instance forget₂MonPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ CommMonCatMax.{u,v} MonCatMax.{u,v}) where
-  preservesLimitsOfShape {J} 𝒥 := { preservesLimit := fun {F} => by infer_instance }
+@[to_additive AddCommMonCat.forget₂AddMonPreservesLimitsOfSize "The forgetful functor from
+  additive commutative monoids to additive monoids preserves all limits.\n\n
+  This means the underlying type of a limit can be computed as a limit in the category of additive\n
+  monoids.",
+  to_additive_relevant_arg 2]
+noncomputable instance forget₂MonPreservesLimitsOfSize [UnivLE.{v, u}] :
+    PreservesLimitsOfSize.{w, v} (forget₂ CommMonCat.{u} MonCat.{u}) where
+  preservesLimitsOfShape {J} 𝒥 := { }
 #align CommMon.forget₂_Mon_preserves_limits_of_size CommMonCat.forget₂MonPreservesLimitsOfSize
-#align AddCommMon.forget₂_AddMon_preserves_limits AddCommMonCat.forget₂AddMonPreservesLimits
+#align AddCommMon.forget₂_AddMon_preserves_limits AddCommMonCat.forget₂AddMonPreservesLimitsOfSize
 
 @[to_additive]
 noncomputable instance forget₂MonPreservesLimits :
-    PreservesLimits (forget₂ CommMonCat MonCat.{u}) :=
+    PreservesLimits (forget₂ CommMonCat.{u} MonCat.{u}) :=
   CommMonCat.forget₂MonPreservesLimitsOfSize.{u, u}
 #align CommMon.forget₂_Mon_preserves_limits CommMonCat.forget₂MonPreservesLimits
 #align AddCommMon.forget₂_Mon_preserves_limits AddCommMonCat.forget₂MonPreservesLimits
 
+/-- If `J` is `u`-small, the forgetful functor from `CommMonCat.{u}` preserves limits of
+shape `J`. -/
+@[to_additive "If `J` is `u`-small, the forgetful functor from `AddCommMonCat.{u}`\n
+preserves limits of shape `J`."]
+noncomputable instance forgetPreservesLimitsOfShape [Small.{u} J] :
+    PreservesLimitsOfShape J (forget CommMonCat.{u}) where
+  preservesLimit {F} := preservesLimitOfPreservesLimitCone (limitConeIsLimit F)
+    (Types.Small.limitConeIsLimit (F ⋙ forget _))
+
 /-- 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. -/
 @[to_additive "The forgetful functor from additive commutative monoids to types preserves all\n
 limits.\n\n
 This means the underlying type of a limit can be computed as a limit in the category of types."]
-noncomputable instance forgetPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget CommMonCatMax.{u, v}) where
-  preservesLimitsOfShape {_} _ :=
-    { preservesLimit := fun {F} =>
-        -- Porting note: we need to specify `F` here explicitly.
-        @Limits.compPreservesLimit _ _ _ _ _ _ F _ _
-          (forget₂ CommMonCatMax.{u, v} MonCatMax.{u, v}) (forget MonCat) _ _ }
+noncomputable instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
+    PreservesLimitsOfSize.{v, v} (forget CommMonCat.{u}) where
+  preservesLimitsOfShape {_} _ := { }
 #align CommMon.forget_preserves_limits_of_size CommMonCat.forgetPreservesLimitsOfSize
 #align AddCommMon.forget_preserves_limits_of_size AddCommMonCat.forgetPreservesLimitsOfSize
 
-@[to_additive]
+noncomputable instance _root_.AddCommMonCat.forgetPreservesLimits :
+    PreservesLimits (forget AddCommMonCat.{u}) :=
+  AddCommMonCat.forgetPreservesLimitsOfSize.{u, u}
+#align AddCommMon.forget_preserves_limits AddCommMonCat.forgetPreservesLimits
+
+@[to_additive existing]
 noncomputable instance forgetPreservesLimits : PreservesLimits (forget CommMonCat.{u}) :=
   CommMonCat.forgetPreservesLimitsOfSize.{u, u}
 #align CommMon.forget_preserves_limits CommMonCat.forgetPreservesLimits
-#align AddCommMon.forget_preserves_limits AddCommMonCat.forgetPreservesLimits
 
 end CommMonCat

c43486ec

move: Algebraic pi instances (#10693)

Rename

Data.Pi.Algebra to Algebra.Group.Pi.Basic
Algebra.Group.Pi to Algebra.Group.Pi.Lemmas

Move a few instances from the latter to the former, the goal being that Algebra.Group.Pi.Basic is about all the pi instances of the classes defined in Algebra.Group.Defs. Algebra.Group.Pi.Lemmas will need further rearranging.

c76aa9d6

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
 import Mathlib.Algebra.Category.MonCat.Basic
-import Mathlib.Algebra.Group.Pi
+import Mathlib.Algebra.Group.Pi.Lemmas
 import Mathlib.CategoryTheory.Limits.Creates
 import Mathlib.CategoryTheory.Limits.Types
 import Mathlib.GroupTheory.Submonoid.Operations

c43486ec

chore: replace anonymous morphism constructors with named fields (#7015)

This makes it easier to refactor the order or inheritance structure of morphisms without having to change all of the anonymous constructors.

This is far from exhaustive.

2bffb702

Diff

@@ -103,7 +103,7 @@ noncomputable def limitCone (F : J ⥤ MonCatMax.{u,v}) : Cone F :=
 @[to_additive "(Internal use only; use the limits API.)"]
 noncomputable def limitConeIsLimit (F : J ⥤ MonCatMax.{u,v}) : IsLimit (limitCone F) := by
   refine IsLimit.ofFaithful (forget MonCatMax) (Types.limitConeIsLimit.{v,u} _)
-    (fun s => ⟨⟨_, ?_⟩, ?_⟩) (fun s => rfl) <;>
+    (fun s => { toFun := _, map_one' := ?_, map_mul' := ?_ }) (fun s => rfl) <;>
   aesop_cat
 #align Mon.has_limits.limit_cone_is_limit MonCat.HasLimits.limitConeIsLimit
 #align AddMon.has_limits.limit_cone_is_limit AddMonCat.HasLimits.limitConeIsLimit

c43486ec

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,11 +2,6 @@
 Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module algebra.category.Mon.limits
-! leanprover-community/mathlib commit c43486ecf2a5a17479a32ce09e4818924145e90e
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Category.MonCat.Basic
 import Mathlib.Algebra.Group.Pi
@@ -14,6 +9,8 @@ import Mathlib.CategoryTheory.Limits.Creates
 import Mathlib.CategoryTheory.Limits.Types
 import Mathlib.GroupTheory.Submonoid.Operations
 
+#align_import algebra.category.Mon.limits from "leanprover-community/mathlib"@"c43486ecf2a5a17479a32ce09e4818924145e90e"
+
 /-!
 # The category of (commutative) (additive) monoids has all limits

c43486ec

feat: using UnivLE in constructing limits in Type (#5724)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Apurva <apurvnakade@gmail.com> Co-authored-by: Jon Eugster <eugster.jon@gmail.com> Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr> Co-authored-by: Johan Commelin <johan@commelin.net>

56112d4c

Diff

@@ -72,7 +72,7 @@ instance limitMonoid (F : J ⥤ MonCatMax.{u,v}) :
 
 /-- `limit.π (F ⋙ forget MonCat) j` as a `MonoidHom`. -/
 @[to_additive "`limit.π (F ⋙ forget AddMonCat) j` as an `AddMonoidHom`."]
-def limitπMonoidHom (F : J ⥤ MonCatMax.{u, v}) (j : J) :
+noncomputable def limitπMonoidHom (F : J ⥤ MonCatMax.{u, v}) (j : J) :
   (Types.limitCone.{v, u} (F ⋙ forget MonCatMax.{u, v})).pt →*
     ((F ⋙ forget MonCat.{max v u}).obj j) :=
   { toFun := (Types.limitCone.{v, u} (F ⋙ forget MonCatMax.{u, v})).π.app j,
@@ -90,7 +90,7 @@ namespace HasLimits
 (Internal use only; use the limits API.)
 -/
 @[to_additive "(Internal use only; use the limits API.)"]
-def limitCone (F : J ⥤ MonCatMax.{u,v}) : Cone F :=
+noncomputable def limitCone (F : J ⥤ MonCatMax.{u,v}) : Cone F :=
   { pt := MonCat.of (Types.limitCone (F ⋙ forget _)).pt
     π :=
     { app := limitπMonoidHom F
@@ -104,7 +104,7 @@ def limitCone (F : J ⥤ MonCatMax.{u,v}) : Cone F :=
 (Internal use only; use the limits API.)
 -/
 @[to_additive "(Internal use only; use the limits API.)"]
-def limitConeIsLimit (F : J ⥤ MonCatMax.{u,v}) : IsLimit (limitCone F) := by
+noncomputable def limitConeIsLimit (F : J ⥤ MonCatMax.{u,v}) : IsLimit (limitCone F) := by
   refine IsLimit.ofFaithful (forget MonCatMax) (Types.limitConeIsLimit.{v,u} _)
     (fun s => ⟨⟨_, ?_⟩, ?_⟩) (fun s => rfl) <;>
   aesop_cat
@@ -137,7 +137,8 @@ instance hasLimits : HasLimits MonCat.{u} :=
 This means the underlying type of a limit can be computed as a limit in the category of types. -/
 @[to_additive "The forgetful functor from additive monoids to types preserves all limits.\n\n
 This means the underlying type of a limit can be computed as a limit in the category of types."]
-instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v} (forget MonCatMax.{u,v}) where
+noncomputable instance forgetPreservesLimitsOfSize :
+    PreservesLimitsOfSize.{v} (forget MonCatMax.{u,v}) where
   preservesLimitsOfShape {_} _ :=
     { preservesLimit := fun {F} =>
         preservesLimitOfPreservesLimitCone (limitConeIsLimit F)
@@ -146,7 +147,7 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v} (forget MonCatM
 #align AddMon.forget_preserves_limits_of_size AddMonCat.forgetPreservesLimitsOfSize
 
 @[to_additive]
-instance forgetPreservesLimits : PreservesLimits (forget MonCat.{u}) :=
+noncomputable instance forgetPreservesLimits : PreservesLimits (forget MonCat.{u}) :=
   MonCat.forgetPreservesLimitsOfSize.{u, u}
 #align Mon.forget_preserves_limits MonCat.forgetPreservesLimits
 #align AddMon.forget_preserves_limits AddMonCat.forgetPreservesLimits

c43486ec

feat: port Algebra.Category.Mon.Limits (#3073)

Co-authored-by: Jason Yuen <jason_yuen2007@hotmail.com> Co-authored-by: int-y1 <jason_yuen2007@hotmail.com> Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

87c4a75e

`algebra.category.Mon.limits` ⟷ `Mathlib.Algebra.Category.MonCat.Limits`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 4 + 283

algebra.category.Mon.limits ⟷ Mathlib.Algebra.Category.MonCat.Limits

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 4 + 283

`algebra.category.Mon.limits` ⟷ `Mathlib.Algebra.Category.MonCat.Limits`