algebra.category.Algebra.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

1a51edf1

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.Algebra.Basic
-import Algebra.Category.Module.Limits
+import Algebra.Category.AlgebraCat.Basic
+import Algebra.Category.ModuleCat.Limits
 import Algebra.Category.Ring.Limits
 
 #align_import algebra.category.Algebra.limits from "leanprover-community/mathlib"@"1a51edf13debfcbe223fa06b1cb353b9ed9751cc"

1a51edf1

bump to nightly-2024-02-05-08

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

516c6ec2

Diff

@@ -132,7 +132,7 @@ end HasLimits
 
 open HasLimits
 
-/- ./././Mathport/Syntax/Translate/Command.lean:332:38: unsupported irreducible non-definition -/
+/- ./././Mathport/Syntax/Translate/Command.lean:335:38: unsupported irreducible non-definition -/
 #print AlgebraCat.hasLimitsOfSize /-
 /-- The category of R-algebras has all limits. -/
 irreducible_def hasLimitsOfSize : HasLimitsOfSize.{v, v} (AlgebraCat.{max v w} R) :=

1a51edf1

bump to nightly-2023-12-23-06

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

b8c74971

Diff

@@ -132,7 +132,7 @@ end HasLimits
 
 open HasLimits
 
-/- ./././Mathport/Syntax/Translate/Command.lean:322:38: unsupported irreducible non-definition -/
+/- ./././Mathport/Syntax/Translate/Command.lean:332:38: unsupported irreducible non-definition -/
 #print AlgebraCat.hasLimitsOfSize /-
 /-- The category of R-algebras has all limits. -/
 irreducible_def hasLimitsOfSize : HasLimitsOfSize.{v, v} (AlgebraCat.{max v w} R) :=

1a51edf1

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ 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.Algebra.Basic
-import Mathbin.Algebra.Category.Module.Limits
-import Mathbin.Algebra.Category.Ring.Limits
+import Algebra.Category.Algebra.Basic
+import Algebra.Category.Module.Limits
+import Algebra.Category.Ring.Limits
 
 #align_import algebra.category.Algebra.limits from "leanprover-community/mathlib"@"1a51edf13debfcbe223fa06b1cb353b9ed9751cc"

1a51edf1

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 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.Algebra.limits
-! leanprover-community/mathlib commit 1a51edf13debfcbe223fa06b1cb353b9ed9751cc
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Category.Algebra.Basic
 import Mathbin.Algebra.Category.Module.Limits
 import Mathbin.Algebra.Category.Ring.Limits
 
+#align_import algebra.category.Algebra.limits from "leanprover-community/mathlib"@"1a51edf13debfcbe223fa06b1cb353b9ed9751cc"
+
 /-!
 # The category of R-algebras has all limits

1a51edf1

bump to nightly-2023-07-09-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/1a51edf13debfcbe223fa06b1cb353b9ed9751cc

e0217a15

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.Algebra.limits
-! leanprover-community/mathlib commit c43486ecf2a5a17479a32ce09e4818924145e90e
+! leanprover-community/mathlib commit 1a51edf13debfcbe223fa06b1cb353b9ed9751cc
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.Algebra.Category.Ring.Limits
 /-!
 # The category of R-algebras 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-07-07-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8905e5ed90859939681a725b00f6063e65096d95

b4e86201

Diff

@@ -35,14 +35,19 @@ variable {R : Type u} [CommRing R]
 
 variable {J : Type v} [SmallCategory J]
 
+#print AlgebraCat.semiringObj /-
 instance semiringObj (F : J ⥤ AlgebraCat.{max v w} R) (j) :
     Semiring ((F ⋙ forget (AlgebraCat R)).obj j) := by change Semiring (F.obj j); infer_instance
 #align Algebra.semiring_obj AlgebraCat.semiringObj
+-/
 
+#print AlgebraCat.algebraObj /-
 instance algebraObj (F : J ⥤ AlgebraCat.{max v w} R) (j) :
     Algebra R ((F ⋙ forget (AlgebraCat R)).obj j) := by change Algebra R (F.obj j); infer_instance
 #align Algebra.algebra_obj AlgebraCat.algebraObj
+-/
 
+#print AlgebraCat.sectionsSubalgebra /-
 /-- The flat sections of a functor into `Algebra R` form a submodule of all sections.
 -/
 def sectionsSubalgebra (F : J ⥤ AlgebraCat.{max v w} R) : Subalgebra R (∀ j, F.obj j) :=
@@ -51,14 +56,18 @@ def sectionsSubalgebra (F : J ⥤ AlgebraCat.{max v w} R) : Subalgebra R (∀ j,
       (F ⋙ forget₂ (AlgebraCat R) RingCat.{max v w} ⋙ forget₂ RingCat SemiRingCat.{max v w}) with
     algebraMap_mem' := fun r j j' f => (F.map f).commutes r }
 #align Algebra.sections_subalgebra AlgebraCat.sectionsSubalgebra
+-/
 
+#print AlgebraCat.limitSemiring /-
 instance limitSemiring (F : J ⥤ AlgebraCat.{max v w} R) :
     Ring (Types.limitCone (F ⋙ forget (AlgebraCat.{max v w} R))).pt :=
   by
   change Ring (sections_subalgebra F)
   infer_instance
 #align Algebra.limit_semiring AlgebraCat.limitSemiring
+-/
 
+#print AlgebraCat.limitAlgebra /-
 instance limitAlgebra (F : J ⥤ AlgebraCat.{max v w} R) :
     Algebra R (Types.limitCone (F ⋙ forget (AlgebraCat.{max v w} R))).pt :=
   by
@@ -69,7 +78,9 @@ instance limitAlgebra (F : J ⥤ AlgebraCat.{max v w} R) :
   rw [this]
   infer_instance
 #align Algebra.limit_algebra AlgebraCat.limitAlgebra
+-/
 
+#print AlgebraCat.limitπAlgHom /-
 /-- `limit.π (F ⋙ forget (Algebra R)) j` as a `alg_hom`. -/
 def limitπAlgHom (F : J ⥤ AlgebraCat.{max v w} R) (j) :
     (Types.limitCone (F ⋙ forget (AlgebraCat R))).pt →ₐ[R]
@@ -79,9 +90,11 @@ def limitπAlgHom (F : J ⥤ AlgebraCat.{max v w} R) (j) :
       (F ⋙ forget₂ (AlgebraCat R) RingCat.{max v w} ⋙ forget₂ RingCat SemiRingCat.{max v w}) j with
     commutes' := fun r => rfl }
 #align Algebra.limit_π_alg_hom AlgebraCat.limitπAlgHom
+-/
 
 namespace HasLimits
 
+#print AlgebraCat.HasLimits.limitCone /-
 -- The next two definitions are used in the construction of `has_limits (Algebra R)`.
 -- After that, the limits should be constructed using the generic limits API,
 -- e.g. `limit F`, `limit.cone F`, and `limit.is_limit F`.
@@ -96,7 +109,9 @@ def limitCone (F : J ⥤ AlgebraCat.{max v w} R) : Cone F
       naturality' := fun j j' f =>
         AlgHom.coe_fn_injective ((Types.limitCone (F ⋙ forget _)).π.naturality f) }
 #align Algebra.has_limits.limit_cone AlgebraCat.HasLimits.limitCone
+-/
 
+#print AlgebraCat.HasLimits.limitConeIsLimit /-
 /-- Witness that the limit cone in `Algebra R` is a limit cone.
 (Internal use only; use the limits API.)
 -/
@@ -111,12 +126,14 @@ def limitConeIsLimit (F : J ⥤ AlgebraCat.{max v w} R) : IsLimit (limitCone F)
   · intro x y; simp only [forget_map_eq_coe, AlgHom.map_add, functor.map_cone_π_app]; rfl
   · intro r; ext j; exact (s.π.app j).commutes r
 #align Algebra.has_limits.limit_cone_is_limit AlgebraCat.HasLimits.limitConeIsLimit
+-/
 
 end HasLimits
 
 open HasLimits
 
 /- ./././Mathport/Syntax/Translate/Command.lean:322:38: unsupported irreducible non-definition -/
+#print AlgebraCat.hasLimitsOfSize /-
 /-- The category of R-algebras has all limits. -/
 irreducible_def hasLimitsOfSize : HasLimitsOfSize.{v, v} (AlgebraCat.{max v w} R) :=
   {
@@ -127,11 +144,15 @@ irreducible_def hasLimitsOfSize : HasLimitsOfSize.{v, v} (AlgebraCat.{max v w} R
             { Cone := limit_cone F
               IsLimit := limit_cone_is_limit F } } }
 #align Algebra.has_limits_of_size AlgebraCat.hasLimitsOfSize
+-/
 
+#print AlgebraCat.hasLimits /-
 instance hasLimits : HasLimits (AlgebraCat.{w} R) :=
   AlgebraCat.hasLimitsOfSize.{w, w, u}
 #align Algebra.has_limits AlgebraCat.hasLimits
+-/
 
+#print AlgebraCat.forget₂RingPreservesLimitsOfSize /-
 /-- The forgetful functor from R-algebras to rings preserves all limits.
 -/
 instance forget₂RingPreservesLimitsOfSize :
@@ -142,11 +163,15 @@ instance forget₂RingPreservesLimitsOfSize :
         preserves_limit_of_preserves_limit_cone (limit_cone_is_limit F)
           (by apply RingCat.limitConeIsLimit (F ⋙ forget₂ (AlgebraCat R) RingCat.{max v w})) }
 #align Algebra.forget₂_Ring_preserves_limits_of_size AlgebraCat.forget₂RingPreservesLimitsOfSize
+-/
 
+#print AlgebraCat.forget₂RingPreservesLimits /-
 instance forget₂RingPreservesLimits : PreservesLimits (forget₂ (AlgebraCat R) RingCat.{w}) :=
   AlgebraCat.forget₂RingPreservesLimitsOfSize.{w, w}
 #align Algebra.forget₂_Ring_preserves_limits AlgebraCat.forget₂RingPreservesLimits
+-/
 
+#print AlgebraCat.forget₂ModulePreservesLimitsOfSize /-
 /-- The forgetful functor from R-algebras to R-modules preserves all limits.
 -/
 instance forget₂ModulePreservesLimitsOfSize :
@@ -160,12 +185,16 @@ instance forget₂ModulePreservesLimitsOfSize :
               ModuleCat.HasLimits.limitConeIsLimit
                 (F ⋙ forget₂ (AlgebraCat R) (ModuleCat.{max v w} R))) }
 #align Algebra.forget₂_Module_preserves_limits_of_size AlgebraCat.forget₂ModulePreservesLimitsOfSize
+-/
 
+#print AlgebraCat.forget₂ModulePreservesLimits /-
 instance forget₂ModulePreservesLimits :
     PreservesLimits (forget₂ (AlgebraCat R) (ModuleCat.{w} R)) :=
   AlgebraCat.forget₂ModulePreservesLimitsOfSize.{w, w}
 #align Algebra.forget₂_Module_preserves_limits AlgebraCat.forget₂ModulePreservesLimits
+-/
 
+#print AlgebraCat.forgetPreservesLimitsOfSize /-
 /-- The forgetful functor from R-algebras to types preserves all limits.
 -/
 instance forgetPreservesLimitsOfSize :
@@ -176,10 +205,13 @@ instance forgetPreservesLimitsOfSize :
         preserves_limit_of_preserves_limit_cone (limit_cone_is_limit F)
           (types.limit_cone_is_limit (F ⋙ forget _)) }
 #align Algebra.forget_preserves_limits_of_size AlgebraCat.forgetPreservesLimitsOfSize
+-/
 
+#print AlgebraCat.forgetPreservesLimits /-
 instance forgetPreservesLimits : PreservesLimits (forget (AlgebraCat.{w} R)) :=
   AlgebraCat.forgetPreservesLimitsOfSize.{w, w}
 #align Algebra.forget_preserves_limits AlgebraCat.forgetPreservesLimits
+-/
 
 end AlgebraCat

c43486ec

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -116,7 +116,7 @@ end HasLimits
 
 open HasLimits
 
-/- ./././Mathport/Syntax/Translate/Command.lean:323:38: unsupported irreducible non-definition -/
+/- ./././Mathport/Syntax/Translate/Command.lean:322:38: unsupported irreducible non-definition -/
 /-- The category of R-algebras has all limits. -/
 irreducible_def hasLimitsOfSize : HasLimitsOfSize.{v, v} (AlgebraCat.{max v w} R) :=
   {

c43486ec

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -116,7 +116,7 @@ end HasLimits
 
 open HasLimits
 
-/- ./././Mathport/Syntax/Translate/Command.lean:322:38: unsupported irreducible non-definition -/
+/- ./././Mathport/Syntax/Translate/Command.lean:323:38: unsupported irreducible non-definition -/
 /-- The category of R-algebras has all limits. -/
 irreducible_def hasLimitsOfSize : HasLimitsOfSize.{v, v} (AlgebraCat.{max v w} R) :=
   {

c43486ec

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -36,17 +36,11 @@ variable {R : Type u} [CommRing R]
 variable {J : Type v} [SmallCategory J]
 
 instance semiringObj (F : J ⥤ AlgebraCat.{max v w} R) (j) :
-    Semiring ((F ⋙ forget (AlgebraCat R)).obj j) :=
-  by
-  change Semiring (F.obj j)
-  infer_instance
+    Semiring ((F ⋙ forget (AlgebraCat R)).obj j) := by change Semiring (F.obj j); infer_instance
 #align Algebra.semiring_obj AlgebraCat.semiringObj
 
 instance algebraObj (F : J ⥤ AlgebraCat.{max v w} R) (j) :
-    Algebra R ((F ⋙ forget (AlgebraCat R)).obj j) :=
-  by
-  change Algebra R (F.obj j)
-  infer_instance
+    Algebra R ((F ⋙ forget (AlgebraCat R)).obj j) := by change Algebra R (F.obj j); infer_instance
 #align Algebra.algebra_obj AlgebraCat.algebraObj
 
 /-- The flat sections of a functor into `Algebra R` form a submodule of all sections.
@@ -111,19 +105,11 @@ def limitConeIsLimit (F : J ⥤ AlgebraCat.{max v w} R) : IsLimit (limitCone F)
   refine'
     is_limit.of_faithful (forget (AlgebraCat R)) (types.limit_cone_is_limit _) (fun s => { .. })
       fun s => rfl
-  · simp only [forget_map_eq_coe, AlgHom.map_one, functor.map_cone_π_app]
-    rfl
-  · intro x y
-    simp only [forget_map_eq_coe, AlgHom.map_mul, functor.map_cone_π_app]
-    rfl
-  · simp only [forget_map_eq_coe, AlgHom.map_zero, functor.map_cone_π_app]
-    rfl
-  · intro x y
-    simp only [forget_map_eq_coe, AlgHom.map_add, functor.map_cone_π_app]
-    rfl
-  · intro r
-    ext j
-    exact (s.π.app j).commutes r
+  · simp only [forget_map_eq_coe, AlgHom.map_one, functor.map_cone_π_app]; rfl
+  · intro x y; simp only [forget_map_eq_coe, AlgHom.map_mul, functor.map_cone_π_app]; rfl
+  · simp only [forget_map_eq_coe, AlgHom.map_zero, functor.map_cone_π_app]; rfl
+  · intro x y; simp only [forget_map_eq_coe, AlgHom.map_add, functor.map_cone_π_app]; rfl
+  · intro r; ext j; exact (s.π.app j).commutes r
 #align Algebra.has_limits.limit_cone_is_limit AlgebraCat.HasLimits.limitConeIsLimit
 
 end HasLimits

c43486ec

bump to nightly-2023-05-14-04

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

f29e26a7

Diff

@@ -53,8 +53,8 @@ instance algebraObj (F : J ⥤ AlgebraCat.{max v w} R) (j) :
 -/
 def sectionsSubalgebra (F : J ⥤ AlgebraCat.{max v w} R) : Subalgebra R (∀ j, F.obj j) :=
   {
-    SemiRing.sectionsSubsemiring
-      (F ⋙ forget₂ (AlgebraCat R) RingCat.{max v w} ⋙ forget₂ RingCat SemiRing.{max v w}) with
+    SemiRingCat.sectionsSubsemiring
+      (F ⋙ forget₂ (AlgebraCat R) RingCat.{max v w} ⋙ forget₂ RingCat SemiRingCat.{max v w}) with
     algebraMap_mem' := fun r j j' f => (F.map f).commutes r }
 #align Algebra.sections_subalgebra AlgebraCat.sectionsSubalgebra
 
@@ -81,8 +81,8 @@ def limitπAlgHom (F : J ⥤ AlgebraCat.{max v w} R) (j) :
     (Types.limitCone (F ⋙ forget (AlgebraCat R))).pt →ₐ[R]
       (F ⋙ forget (AlgebraCat.{max v w} R)).obj j :=
   {
-    SemiRing.limitπRingHom
-      (F ⋙ forget₂ (AlgebraCat R) RingCat.{max v w} ⋙ forget₂ RingCat SemiRing.{max v w}) j with
+    SemiRingCat.limitπRingHom
+      (F ⋙ forget₂ (AlgebraCat R) RingCat.{max v w} ⋙ forget₂ RingCat SemiRingCat.{max v w}) j with
     commutes' := fun r => rfl }
 #align Algebra.limit_π_alg_hom AlgebraCat.limitπAlgHom

c43486ec

bump to nightly-2023-04-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/09079525fd01b3dda35e96adaa08d2f943e1648c

ff662d55

Diff

@@ -130,7 +130,7 @@ end HasLimits
 
 open HasLimits
 
-/- ./././Mathport/Syntax/Translate/Command.lean:317:38: unsupported irreducible non-definition -/
+/- ./././Mathport/Syntax/Translate/Command.lean:322:38: unsupported irreducible non-definition -/
 /-- The category of R-algebras has all limits. -/
 irreducible_def hasLimitsOfSize : HasLimitsOfSize.{v, v} (AlgebraCat.{max v w} R) :=
   {

c43486ec

bump to nightly-2023-02-28-22

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

1fb1623f

Diff

@@ -59,17 +59,17 @@ def sectionsSubalgebra (F : J ⥤ AlgebraCat.{max v w} R) : Subalgebra R (∀ j,
 #align Algebra.sections_subalgebra AlgebraCat.sectionsSubalgebra
 
 instance limitSemiring (F : J ⥤ AlgebraCat.{max v w} R) :
-    Ring (Types.limitCone (F ⋙ forget (AlgebraCat.{max v w} R))).x :=
+    Ring (Types.limitCone (F ⋙ forget (AlgebraCat.{max v w} R))).pt :=
   by
   change Ring (sections_subalgebra F)
   infer_instance
 #align Algebra.limit_semiring AlgebraCat.limitSemiring
 
 instance limitAlgebra (F : J ⥤ AlgebraCat.{max v w} R) :
-    Algebra R (Types.limitCone (F ⋙ forget (AlgebraCat.{max v w} R))).x :=
+    Algebra R (Types.limitCone (F ⋙ forget (AlgebraCat.{max v w} R))).pt :=
   by
   have :
-    Algebra R (types.limit_cone (F ⋙ forget (AlgebraCat.{max v w} R))).x =
+    Algebra R (types.limit_cone (F ⋙ forget (AlgebraCat.{max v w} R))).pt =
       Algebra R (sections_subalgebra F) :=
     by rfl
   rw [this]
@@ -78,7 +78,7 @@ instance limitAlgebra (F : J ⥤ AlgebraCat.{max v w} R) :
 
 /-- `limit.π (F ⋙ forget (Algebra R)) j` as a `alg_hom`. -/
 def limitπAlgHom (F : J ⥤ AlgebraCat.{max v w} R) (j) :
-    (Types.limitCone (F ⋙ forget (AlgebraCat R))).x →ₐ[R]
+    (Types.limitCone (F ⋙ forget (AlgebraCat R))).pt →ₐ[R]
       (F ⋙ forget (AlgebraCat.{max v w} R)).obj j :=
   {
     SemiRing.limitπRingHom
@@ -96,7 +96,7 @@ namespace HasLimits
 -/
 def limitCone (F : J ⥤ AlgebraCat.{max v w} R) : Cone F
     where
-  x := AlgebraCat.of R (Types.limitCone (F ⋙ forget _)).x
+  pt := AlgebraCat.of R (Types.limitCone (F ⋙ forget _)).pt
   π :=
     { app := limitπAlgHom F
       naturality' := fun j j' f =>

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

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

@@ -23,51 +23,69 @@ open CategoryTheory
 
 open CategoryTheory.Limits
 
-universe v w u
+universe v w u t
 
--- `u` is determined by the ring, so can come last
+-- `u` is determined by the ring, so can come later
 noncomputable section
 
 namespace AlgebraCat
 
 variable {R : Type u} [CommRing R]
-variable {J : Type v} [SmallCategory J]
+variable {J : Type v} [Category.{t} J] (F : J ⥤ AlgebraCat.{w} R)
 
-instance semiringObj (F : J ⥤ AlgebraCatMax.{v, w} R) (j) :
-    Semiring ((F ⋙ forget (AlgebraCat R)).obj j) :=
+instance semiringObj (j) : Semiring ((F ⋙ forget (AlgebraCat R)).obj j) :=
   inferInstanceAs <| Semiring (F.obj j)
 #align Algebra.semiring_obj AlgebraCat.semiringObj
 
-instance algebraObj (F : J ⥤ AlgebraCatMax.{v, w} R) (j) :
+instance algebraObj (j) :
     Algebra R ((F ⋙ forget (AlgebraCat R)).obj j) :=
   inferInstanceAs <| Algebra R (F.obj j)
 #align Algebra.algebra_obj AlgebraCat.algebraObj
 
 /-- The flat sections of a functor into `AlgebraCat R` form a submodule of all sections.
 -/
-def sectionsSubalgebra (F : J ⥤ AlgebraCatMax.{v, w} R) : Subalgebra R (∀ j, F.obj j) :=
+def sectionsSubalgebra : Subalgebra R (∀ j, F.obj j) :=
   { SemiRingCat.sectionsSubsemiring
-      (F ⋙ forget₂ (AlgebraCat R) RingCat.{max v w} ⋙ forget₂ RingCat SemiRingCatMax.{v, w}) with
+      (F ⋙ forget₂ (AlgebraCat R) RingCat.{w} ⋙ forget₂ RingCat SemiRingCat.{w}) with
     algebraMap_mem' := fun r _ _ f => (F.map f).commutes r }
 #align Algebra.sections_subalgebra AlgebraCat.sectionsSubalgebra
 
-instance limitSemiring (F : J ⥤ AlgebraCatMax.{v, w} R) :
-    Ring.{max v w} (Types.limitCone.{v, w} (F ⋙ forget (AlgebraCatMax.{v, w} R))).pt :=
+instance (F : J ⥤ AlgebraCat.{w} R) : Ring (F ⋙ forget _).sections :=
   inferInstanceAs <| Ring (sectionsSubalgebra F)
-#align Algebra.limit_semiring AlgebraCat.limitSemiring
 
-instance limitAlgebra (F : J ⥤ AlgebraCatMax.{v, w} R) :
-    Algebra R (Types.limitCone (F ⋙ forget (AlgebraCatMax.{v, w} R))).pt :=
+instance (F : J ⥤ AlgebraCat.{w} R) : Algebra R (F ⋙ forget _).sections :=
   inferInstanceAs <| Algebra R (sectionsSubalgebra F)
+
+variable [Small.{w} (F ⋙ forget (AlgebraCat.{w} R)).sections]
+
+instance : Small.{w} (sectionsSubalgebra F) :=
+  inferInstanceAs <| Small.{w} (F ⋙ forget _).sections
+
+instance limitSemiring :
+    Ring.{w} (Types.Small.limitCone.{v, w} (F ⋙ forget (AlgebraCat.{w} R))).pt :=
+  inferInstanceAs <| Ring (Shrink (sectionsSubalgebra F))
+#align Algebra.limit_semiring AlgebraCat.limitSemiring
+
+instance limitAlgebra :
+    Algebra R (Types.Small.limitCone (F ⋙ forget (AlgebraCat.{w} R))).pt :=
+  inferInstanceAs <| Algebra R (Shrink (sectionsSubalgebra F))
 #align Algebra.limit_algebra AlgebraCat.limitAlgebra
 
 /-- `limit.π (F ⋙ forget (AlgebraCat R)) j` as a `AlgHom`. -/
-def limitπAlgHom (F : J ⥤ AlgebraCatMax.{v, w} R) (j) :
-    (Types.limitCone (F ⋙ forget (AlgebraCat R))).pt →ₐ[R]
-      (F ⋙ forget (AlgebraCatMax.{v, w} R)).obj j :=
+def limitπAlgHom (j) :
+    (Types.Small.limitCone (F ⋙ forget (AlgebraCat R))).pt →ₐ[R]
+      (F ⋙ forget (AlgebraCat.{w} R)).obj j :=
+  letI : Small.{w}
+      (Functor.sections ((F ⋙ forget₂ _ RingCat ⋙ forget₂ _ SemiRingCat) ⋙ forget _)) :=
+    inferInstanceAs <| Small.{w} (F ⋙ forget _).sections
   { SemiRingCat.limitπRingHom
-      (F ⋙ forget₂ (AlgebraCat R) RingCat.{max v w} ⋙ forget₂ RingCat SemiRingCat.{max v w}) j with
-    commutes' := fun _ => rfl }
+      (F ⋙ forget₂ (AlgebraCat R) RingCat.{w} ⋙ forget₂ RingCat SemiRingCat.{w}) j with
+    toFun := (Types.Small.limitCone (F ⋙ forget (AlgebraCat.{w} R))).π.app j
+    commutes' := fun x => by
+      simp only [Types.Small.limitCone_π_app, ← Shrink.algEquiv_apply _ R,
+        Types.Small.limitCone_pt, AlgEquiv.commutes]
+      rfl
+    }
 #align Algebra.limit_π_alg_hom AlgebraCat.limitπAlgHom
 
 namespace HasLimits
@@ -78,70 +96,58 @@ namespace HasLimits
 /-- Construction of a limit cone in `AlgebraCat R`.
 (Internal use only; use the limits API.)
 -/
-def limitCone (F : J ⥤ AlgebraCatMax.{v, w} R) : Cone F where
-  pt := AlgebraCat.of R (Types.limitCone (F ⋙ forget _)).pt
+def limitCone : Cone F where
+  pt := AlgebraCat.of R (Types.Small.limitCone (F ⋙ forget _)).pt
   π :=
     { app := limitπAlgHom F
       naturality := fun _ _ f =>
-        AlgHom.coe_fn_injective ((Types.limitCone (F ⋙ forget _)).π.naturality f) }
+        AlgHom.coe_fn_injective ((Types.Small.limitCone (F ⋙ forget _)).π.naturality f) }
 #align Algebra.has_limits.limit_cone AlgebraCat.HasLimits.limitCone
 
 /-- Witness that the limit cone in `AlgebraCat R` is a limit cone.
 (Internal use only; use the limits API.)
 -/
-def limitConeIsLimit (F : J ⥤ AlgebraCatMax.{v, w} R) : IsLimit (limitCone.{v, w} F) := by
-  refine'
-    IsLimit.ofFaithful (forget (AlgebraCat R)) (Types.limitConeIsLimit.{v, w} _)
+def limitConeIsLimit : IsLimit (limitCone.{v, w} F) := by
+  refine
+    IsLimit.ofFaithful (forget (AlgebraCat R)) (Types.Small.limitConeIsLimit.{v, w} _)
       -- Porting note: in mathlib3 the function term
       -- `fun v => ⟨fun j => ((forget (AlgebraCat R)).mapCone s).π.app j v`
       -- was provided by unification, and the last argument `(fun s => _)` was `(fun s => rfl)`.
-      (fun s => ⟨⟨⟨⟨fun v => ⟨fun j => ((forget (AlgebraCat R)).mapCone s).π.app j v, _⟩,
-         _⟩, _⟩, _, _⟩, _⟩)
-      (fun s => _)
-  · intro j j' f
-    exact DFunLike.congr_fun (Cone.w s f) v
-  · -- Porting note: we could add a custom `ext` lemma here.
-    apply Subtype.ext
+      (fun s => { toFun := _, map_one' := ?_, map_mul' := ?_, map_zero' := ?_, map_add' := ?_,
+                  commutes' := ?_ })
+      (fun s => rfl)
+  · congr
     ext j
     simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
       forget_map_eq_coe]
-    -- This used to be as below but we need `erw` after leanprover/lean4#2644
-    -- simp [forget_map_eq_coe, AlgHom.map_one, Functor.mapCone_π_app]
     erw [map_one]
     rfl
   · intro x y
-    apply Subtype.ext
+    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app]
+    erw [← map_mul (MulEquiv.symm Shrink.mulEquiv)]
+    apply congrArg
     ext j
     simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
-      forget_map_eq_coe]
-    -- This used to be as below, but we need `erw` after leanprover/lean4#2644
-    -- simp [forget_map_eq_coe, AlgHom.map_mul, Functor.mapCone_π_app]
-    erw [map_mul]
-    rfl
-  · simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
-      forget_map_eq_coe]
-    -- The below `simp` was enough before leanprover/lean4#2644
-    -- simp [forget_map_eq_coe, AlgHom.map_zero, Functor.mapCone_π_app]
-    apply Subtype.ext
-    dsimp
-    funext u
-    erw [map_zero]
+      forget_map_eq_coe, map_mul]
     rfl
+  · simp only [Functor.mapCone_π_app, forget_map_eq_coe]
+    congr
+    funext j
+    simp only [map_zero, Pi.zero_apply]
   · intro x y
-    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
-      forget_map_eq_coe]
-    -- The below `simp` was enough before leanprover/lean4#2644
-    -- simp [forget_map_eq_coe, AlgHom.map_add, Functor.mapCone_π_app]
-    apply Subtype.ext
-    dsimp
-    funext u
-    erw [map_add]
+    simp only [Functor.mapCone_π_app]
+    erw [← map_add (AddEquiv.symm Shrink.addEquiv)]
+    apply congrArg
+    ext j
+    simp only [forget_map_eq_coe, map_add]
     rfl
   · intro r
+    simp only [← Shrink.algEquiv_symm_apply _ R, limitCone, Equiv.algebraMap_def,
+      Equiv.symm_symm]
+    apply congrArg
     apply Subtype.ext
     ext j
     exact (s.π.app j).commutes r
-  · rfl
 #align Algebra.has_limits.limit_cone_is_limit AlgebraCat.HasLimits.limitConeIsLimit
 
 end HasLimits
@@ -151,7 +157,7 @@ open HasLimits
 -- Porting note: mathport translated this as `irreducible_def`, but as `HasLimitsOfSize`
 -- is a `Prop`, declaring this as `irreducible` should presumably have no effect
 /-- The category of R-algebras has all limits. -/
-lemma hasLimitsOfSize : HasLimitsOfSize.{v, v} (AlgebraCatMax.{v, w} R) :=
+lemma hasLimitsOfSize [UnivLE.{v, w}] : HasLimitsOfSize.{t, v} (AlgebraCat.{w} R) :=
   { has_limits_of_shape := fun _ _ =>
     { has_limit := fun F => HasLimit.mk
         { cone := limitCone F
@@ -164,13 +170,13 @@ instance hasLimits : HasLimits (AlgebraCat.{w} R) :=
 
 /-- The forgetful functor from R-algebras to rings preserves all limits.
 -/
-instance forget₂RingPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ (AlgebraCatMax.{v, w} R) RingCatMax.{v, w}) where
+instance forget₂RingPreservesLimitsOfSize [UnivLE.{v, w}] :
+    PreservesLimitsOfSize.{t, v} (forget₂ (AlgebraCat.{w} R) RingCat.{w}) where
   preservesLimitsOfShape :=
-    { preservesLimit :=
-        preservesLimitOfPreservesLimitCone (limitConeIsLimit _)
+    { preservesLimit := fun {K} ↦
+        preservesLimitOfPreservesLimitCone (limitConeIsLimit K)
           (RingCat.limitConeIsLimit.{v, w}
-            (_ ⋙ forget₂ (AlgebraCatMax.{v, w} R) RingCatMax.{v, w})) }
+            (_ ⋙ forget₂ (AlgebraCat.{w} R) RingCat.{w})) }
 #align Algebra.forget₂_Ring_preserves_limits_of_size AlgebraCat.forget₂RingPreservesLimitsOfSize
 
 instance forget₂RingPreservesLimits : PreservesLimits (forget₂ (AlgebraCat R) RingCat.{w}) :=
@@ -179,13 +185,13 @@ instance forget₂RingPreservesLimits : PreservesLimits (forget₂ (AlgebraCat R
 
 /-- The forgetful functor from R-algebras to R-modules preserves all limits.
 -/
-instance forget₂ModulePreservesLimitsOfSize : PreservesLimitsOfSize.{v, v}
-    (forget₂ (AlgebraCatMax.{v, w} R) (ModuleCatMax.{v, w} R)) where
+instance forget₂ModulePreservesLimitsOfSize [UnivLE.{v, w}] : PreservesLimitsOfSize.{t, v}
+    (forget₂ (AlgebraCat.{w} R) (ModuleCat.{w} R)) where
   preservesLimitsOfShape :=
-    { preservesLimit :=
-        preservesLimitOfPreservesLimitCone (limitConeIsLimit _)
+    { preservesLimit := fun {K} ↦
+        preservesLimitOfPreservesLimitCone (limitConeIsLimit K)
           (ModuleCat.HasLimits.limitConeIsLimit
-            (_ ⋙ forget₂ (AlgebraCatMax.{v, w} R) (ModuleCatMax.{v, w} R))) }
+            (K ⋙ forget₂ (AlgebraCat.{w} R) (ModuleCat.{w} R))) }
 #align Algebra.forget₂_Module_preserves_limits_of_size AlgebraCat.forget₂ModulePreservesLimitsOfSize
 
 instance forget₂ModulePreservesLimits :
@@ -195,12 +201,12 @@ instance forget₂ModulePreservesLimits :
 
 /-- The forgetful functor from R-algebras to types preserves all limits.
 -/
-instance forgetPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget (AlgebraCatMax.{v, w} R)) where
+instance forgetPreservesLimitsOfSize [UnivLE.{v, w}] :
+    PreservesLimitsOfSize.{t, v} (forget (AlgebraCat.{w} R)) where
   preservesLimitsOfShape :=
-    { preservesLimit :=
-       preservesLimitOfPreservesLimitCone (limitConeIsLimit _)
-          (Types.limitConeIsLimit (_ ⋙ forget _)) }
+    { preservesLimit := fun {K} ↦
+       preservesLimitOfPreservesLimitCone (limitConeIsLimit K)
+          (Types.Small.limitConeIsLimit.{v} (K ⋙ forget _)) }
 #align Algebra.forget_preserves_limits_of_size AlgebraCat.forgetPreservesLimitsOfSize
 
 instance forgetPreservesLimits : PreservesLimits (forget (AlgebraCat.{w} R)) :=

c43486ec

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -31,7 +31,6 @@ noncomputable section
 namespace AlgebraCat
 
 variable {R : Type u} [CommRing R]
-
 variable {J : Type v} [SmallCategory J]
 
 instance semiringObj (F : J ⥤ AlgebraCatMax.{v, w} R) (j) :

c43486ec

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -149,7 +149,7 @@ end HasLimits
 
 open HasLimits
 
--- porting note: mathport translated this as `irreducible_def`, but as `HasLimitsOfSize`
+-- Porting note: mathport translated this as `irreducible_def`, but as `HasLimitsOfSize`
 -- is a `Prop`, declaring this as `irreducible` should presumably have no effect
 /-- The category of R-algebras has all limits. -/
 lemma hasLimitsOfSize : HasLimitsOfSize.{v, v} (AlgebraCatMax.{v, w} R) :=

c43486ec

chore(*): rename FunLike to DFunLike (#9785)

This prepares for the introduction of a non-dependent synonym of FunLike, which helps a lot with keeping #8386 readable.

This is entirely search-and-replace in 680197f combined with manual fixes in 4145626, e900597 and b8428f8. The commands that generated this change:

sed -i 's/\bFunLike\b/DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoFunLike\b/toDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/import Mathlib.Data.DFunLike/import Mathlib.Data.FunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bHom_FunLike\b/Hom_DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean     
sed -i 's/\binstFunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bfunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoo many metavariables to apply `fun_like.has_coe_to_fun`/too many metavariables to apply `DFunLike.hasCoeToFun`/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean

Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

82656743

Diff

@@ -100,7 +100,7 @@ def limitConeIsLimit (F : J ⥤ AlgebraCatMax.{v, w} R) : IsLimit (limitCone.{v,
          _⟩, _⟩, _, _⟩, _⟩)
       (fun s => _)
   · intro j j' f
-    exact FunLike.congr_fun (Cone.w s f) v
+    exact DFunLike.congr_fun (Cone.w s f) v
   · -- Porting note: we could add a custom `ext` lemma here.
     apply Subtype.ext
     ext j

c43486ec

Revert "chore: revert #7703 (#7710)"

This reverts commit f3695eb2.

ab56fa28

Diff

@@ -104,17 +104,39 @@ def limitConeIsLimit (F : J ⥤ AlgebraCatMax.{v, w} R) : IsLimit (limitCone.{v,
   · -- Porting note: we could add a custom `ext` lemma here.
     apply Subtype.ext
     ext j
-    simp [forget_map_eq_coe, AlgHom.map_one, Functor.mapCone_π_app]
+    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
+      forget_map_eq_coe]
+    -- This used to be as below but we need `erw` after leanprover/lean4#2644
+    -- simp [forget_map_eq_coe, AlgHom.map_one, Functor.mapCone_π_app]
+    erw [map_one]
     rfl
   · intro x y
     apply Subtype.ext
     ext j
-    simp [forget_map_eq_coe, AlgHom.map_mul, Functor.mapCone_π_app]
+    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
+      forget_map_eq_coe]
+    -- This used to be as below, but we need `erw` after leanprover/lean4#2644
+    -- simp [forget_map_eq_coe, AlgHom.map_mul, Functor.mapCone_π_app]
+    erw [map_mul]
     rfl
-  · simp [forget_map_eq_coe, AlgHom.map_zero, Functor.mapCone_π_app]
+  · simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
+      forget_map_eq_coe]
+    -- The below `simp` was enough before leanprover/lean4#2644
+    -- simp [forget_map_eq_coe, AlgHom.map_zero, Functor.mapCone_π_app]
+    apply Subtype.ext
+    dsimp
+    funext u
+    erw [map_zero]
     rfl
   · intro x y
-    simp [forget_map_eq_coe, AlgHom.map_add, Functor.mapCone_π_app]
+    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
+      forget_map_eq_coe]
+    -- The below `simp` was enough before leanprover/lean4#2644
+    -- simp [forget_map_eq_coe, AlgHom.map_add, Functor.mapCone_π_app]
+    apply Subtype.ext
+    dsimp
+    funext u
+    erw [map_add]
     rfl
   · intro r
     apply Subtype.ext

c43486ec

chore: revert #7703 (#7710)

This reverts commit 26eb2b0a.

f3695eb2

Diff

@@ -104,39 +104,17 @@ def limitConeIsLimit (F : J ⥤ AlgebraCatMax.{v, w} R) : IsLimit (limitCone.{v,
   · -- Porting note: we could add a custom `ext` lemma here.
     apply Subtype.ext
     ext j
-    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
-      forget_map_eq_coe]
-    -- This used to be as below but we need `erw` after leanprover/lean4#2644
-    -- simp [forget_map_eq_coe, AlgHom.map_one, Functor.mapCone_π_app]
-    erw [map_one]
+    simp [forget_map_eq_coe, AlgHom.map_one, Functor.mapCone_π_app]
     rfl
   · intro x y
     apply Subtype.ext
     ext j
-    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
-      forget_map_eq_coe]
-    -- This used to be as below, but we need `erw` after leanprover/lean4#2644
-    -- simp [forget_map_eq_coe, AlgHom.map_mul, Functor.mapCone_π_app]
-    erw [map_mul]
+    simp [forget_map_eq_coe, AlgHom.map_mul, Functor.mapCone_π_app]
     rfl
-  · simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
-      forget_map_eq_coe]
-    -- The below `simp` was enough before leanprover/lean4#2644
-    -- simp [forget_map_eq_coe, AlgHom.map_zero, Functor.mapCone_π_app]
-    apply Subtype.ext
-    dsimp
-    funext u
-    erw [map_zero]
+  · simp [forget_map_eq_coe, AlgHom.map_zero, Functor.mapCone_π_app]
     rfl
   · intro x y
-    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
-      forget_map_eq_coe]
-    -- The below `simp` was enough before leanprover/lean4#2644
-    -- simp [forget_map_eq_coe, AlgHom.map_add, Functor.mapCone_π_app]
-    apply Subtype.ext
-    dsimp
-    funext u
-    erw [map_add]
+    simp [forget_map_eq_coe, AlgHom.map_add, Functor.mapCone_π_app]
     rfl
   · intro r
     apply Subtype.ext

c43486ec

chore: bump toolchain to v4.2.0-rc2 (#7703)

This includes all the changes from #7606.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

26eb2b0a

Diff

@@ -104,17 +104,39 @@ def limitConeIsLimit (F : J ⥤ AlgebraCatMax.{v, w} R) : IsLimit (limitCone.{v,
   · -- Porting note: we could add a custom `ext` lemma here.
     apply Subtype.ext
     ext j
-    simp [forget_map_eq_coe, AlgHom.map_one, Functor.mapCone_π_app]
+    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
+      forget_map_eq_coe]
+    -- This used to be as below but we need `erw` after leanprover/lean4#2644
+    -- simp [forget_map_eq_coe, AlgHom.map_one, Functor.mapCone_π_app]
+    erw [map_one]
     rfl
   · intro x y
     apply Subtype.ext
     ext j
-    simp [forget_map_eq_coe, AlgHom.map_mul, Functor.mapCone_π_app]
+    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
+      forget_map_eq_coe]
+    -- This used to be as below, but we need `erw` after leanprover/lean4#2644
+    -- simp [forget_map_eq_coe, AlgHom.map_mul, Functor.mapCone_π_app]
+    erw [map_mul]
     rfl
-  · simp [forget_map_eq_coe, AlgHom.map_zero, Functor.mapCone_π_app]
+  · simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
+      forget_map_eq_coe]
+    -- The below `simp` was enough before leanprover/lean4#2644
+    -- simp [forget_map_eq_coe, AlgHom.map_zero, Functor.mapCone_π_app]
+    apply Subtype.ext
+    dsimp
+    funext u
+    erw [map_zero]
     rfl
   · intro x y
-    simp [forget_map_eq_coe, AlgHom.map_add, Functor.mapCone_π_app]
+    simp only [Functor.comp_obj, Functor.mapCone_pt, Functor.mapCone_π_app,
+      forget_map_eq_coe]
+    -- The below `simp` was enough before leanprover/lean4#2644
+    -- simp [forget_map_eq_coe, AlgHom.map_add, Functor.mapCone_π_app]
+    apply Subtype.ext
+    dsimp
+    funext u
+    erw [map_add]
     rfl
   · intro r
     apply Subtype.ext

c43486ec

refactor: colimits in ModuleCat (#6925)

This PR refactors the construction of colimits of modules in order to prove that the forgetful functor to abelian groups preserves colimits.

b1caad96

Diff

@@ -159,12 +159,12 @@ instance forget₂RingPreservesLimits : PreservesLimits (forget₂ (AlgebraCat R
 /-- The forgetful functor from R-algebras to R-modules preserves all limits.
 -/
 instance forget₂ModulePreservesLimitsOfSize : PreservesLimitsOfSize.{v, v}
-    (forget₂ (AlgebraCatMax.{v, w} R) (ModuleCat.ModuleCatMax.{v, w} R)) where
+    (forget₂ (AlgebraCatMax.{v, w} R) (ModuleCatMax.{v, w} R)) where
   preservesLimitsOfShape :=
     { preservesLimit :=
         preservesLimitOfPreservesLimitCone (limitConeIsLimit _)
           (ModuleCat.HasLimits.limitConeIsLimit
-            (_ ⋙ forget₂ (AlgebraCatMax.{v, w} R) (ModuleCat.ModuleCatMax.{v, w} R))) }
+            (_ ⋙ forget₂ (AlgebraCatMax.{v, w} R) (ModuleCatMax.{v, w} R))) }
 #align Algebra.forget₂_Module_preserves_limits_of_size AlgebraCat.forget₂ModulePreservesLimitsOfSize
 
 instance forget₂ModulePreservesLimits :

c43486ec

chore: tidy various files (#6393)

3697da16

Diff

@@ -44,7 +44,7 @@ instance algebraObj (F : J ⥤ AlgebraCatMax.{v, w} R) (j) :
   inferInstanceAs <| Algebra R (F.obj j)
 #align Algebra.algebra_obj AlgebraCat.algebraObj
 
-/-- The flat sections of a functor into `Algebra R` form a submodule of all sections.
+/-- The flat sections of a functor into `AlgebraCat R` form a submodule of all sections.
 -/
 def sectionsSubalgebra (F : J ⥤ AlgebraCatMax.{v, w} R) : Subalgebra R (∀ j, F.obj j) :=
   { SemiRingCat.sectionsSubsemiring
@@ -62,7 +62,7 @@ instance limitAlgebra (F : J ⥤ AlgebraCatMax.{v, w} R) :
   inferInstanceAs <| Algebra R (sectionsSubalgebra F)
 #align Algebra.limit_algebra AlgebraCat.limitAlgebra
 
-/-- `limit.π (F ⋙ forget (Algebra R)) j` as a `alg_hom`. -/
+/-- `limit.π (F ⋙ forget (AlgebraCat R)) j` as a `AlgHom`. -/
 def limitπAlgHom (F : J ⥤ AlgebraCatMax.{v, w} R) (j) :
     (Types.limitCone (F ⋙ forget (AlgebraCat R))).pt →ₐ[R]
       (F ⋙ forget (AlgebraCatMax.{v, w} R)).obj j :=
@@ -73,10 +73,10 @@ def limitπAlgHom (F : J ⥤ AlgebraCatMax.{v, w} R) (j) :
 
 namespace HasLimits
 
--- The next two definitions are used in the construction of `has_limits (Algebra R)`.
+-- The next two definitions are used in the construction of `HasLimits (AlgebraCat R)`.
 -- After that, the limits should be constructed using the generic limits API,
--- e.g. `limit F`, `limit.cone F`, and `limit.is_limit F`.
-/-- Construction of a limit cone in `Algebra R`.
+-- e.g. `limit F`, `limit.cone F`, and `limit.isLimit F`.
+/-- Construction of a limit cone in `AlgebraCat R`.
 (Internal use only; use the limits API.)
 -/
 def limitCone (F : J ⥤ AlgebraCatMax.{v, w} R) : Cone F where
@@ -87,7 +87,7 @@ def limitCone (F : J ⥤ AlgebraCatMax.{v, w} R) : Cone F where
         AlgHom.coe_fn_injective ((Types.limitCone (F ⋙ forget _)).π.naturality f) }
 #align Algebra.has_limits.limit_cone AlgebraCat.HasLimits.limitCone
 
-/-- Witness that the limit cone in `Algebra R` is a limit cone.
+/-- Witness that the limit cone in `AlgebraCat R` is a limit cone.
 (Internal use only; use the limits API.)
 -/
 def limitConeIsLimit (F : J ⥤ AlgebraCatMax.{v, w} R) : IsLimit (limitCone.{v, w} F) := by

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,17 +2,14 @@
 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.Algebra.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.AlgebraCat.Basic
 import Mathlib.Algebra.Category.ModuleCat.Basic
 import Mathlib.Algebra.Category.ModuleCat.Limits
 import Mathlib.Algebra.Category.Ring.Limits
 
+#align_import algebra.category.Algebra.limits from "leanprover-community/mathlib"@"c43486ecf2a5a17479a32ce09e4818924145e90e"
+
 /-!
 # The category of R-algebras has all limits

c43486ec

feat: port Algebra.Category.Algebra.Limits (#5716)

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: Calvin Lee <calvins.lee@utah.edu> Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: Antoine Chambert-Loir <antoine.chambert-loir@math.univ-paris-diderot.fr>

811ee339

`algebra.category.Algebra.limits` ⟷ `Mathlib.Algebra.Category.AlgebraCat.Limits`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 608

algebra.category.Algebra.limits ⟷ Mathlib.Algebra.Category.AlgebraCat.Limits

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 608

`algebra.category.Algebra.limits` ⟷ `Mathlib.Algebra.Category.AlgebraCat.Limits`