category_theory.limits.preserves.finite

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

3974a774

(last sync)

chore(category_theory/limits/preserves/finite): avoid instances with unbound universes (#18890)

There were some instances with unbounded universe variables, which Lean 4 couldn't cope with (reasonably!).

This PR backports some changes made in https://github.com/leanprover-community/mathlib4/pull/3615 to remove these bad instances.

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

Diff

@@ -55,8 +55,9 @@ noncomputable instance preserves_limits_of_shape_of_preserves_finite_limits (F :
   preserves_limits_of_shape J F :=
 by apply preserves_limits_of_shape_of_equiv (fin_category.equiv_as_type J)
 
-@[priority 100]
-noncomputable instance preserves_limits.preserves_finite_limits_of_size (F : C ⥤ D)
+-- This is a dangerous instance as it has unbound universe variables.
+/-- If we preserve limits of some arbitrary size, then we preserve all finite limits. -/
+noncomputable def preserves_limits_of_size.preserves_finite_limits (F : C ⥤ D)
   [preserves_limits_of_size.{w w₂} F] : preserves_finite_limits F :=
 ⟨λ J sJ fJ,
   begin
@@ -64,10 +65,17 @@ noncomputable instance preserves_limits.preserves_finite_limits_of_size (F : C 
     exact preserves_limits_of_shape_of_equiv (fin_category.equiv_as_type J) F,
   end⟩
 
+-- Added as a specialization of the dangerous instance above, for limits indexed in Type 0.
+@[priority 120]
+noncomputable instance preserves_limits_of_size.zero.preserves_finite_limits (F : C ⥤ D)
+    [preserves_limits_of_size.{0 0} F] : preserves_finite_limits F :=
+  preserves_limits_of_size.preserves_finite_limits F
+
+-- An alternative specialization of the dangerous instance for small limits.
 @[priority 120]
 noncomputable instance preserves_limits.preserves_finite_limits (F : C ⥤ D)
   [preserves_limits F] : preserves_finite_limits F :=
-preserves_limits.preserves_finite_limits_of_size F
+preserves_limits_of_size.preserves_finite_limits F
 
 /-- We can always derive `preserves_finite_limits C` by showing that we are preserving limits at an
 arbitrary universe. -/
@@ -109,8 +117,9 @@ noncomputable instance preserves_colimits_of_shape_of_preserves_finite_colimits
   preserves_colimits_of_shape J F :=
 by apply preserves_colimits_of_shape_of_equiv (fin_category.equiv_as_type J)
 
-@[priority 100]
-noncomputable instance preserves_colimits.preserves_finite_colimits (F : C ⥤ D)
+/-- If we preserve colimits of some arbitrary size, then we preserve all finite colimits. -/
+-- This is a dangerous instance as it has unbound universe variables.
+noncomputable def preserves_colimits_of_size.preserves_finite_colimits (F : C ⥤ D)
   [preserves_colimits_of_size.{w w₂} F] : preserves_finite_colimits F :=
 ⟨λ J sJ fJ,
   begin
@@ -118,6 +127,18 @@ noncomputable instance preserves_colimits.preserves_finite_colimits (F : C ⥤ D
     exact preserves_colimits_of_shape_of_equiv (fin_category.equiv_as_type J) F,
   end⟩
 
+-- Added as a specialization of the dangerous instance above, for colimits indexed in Type 0.
+@[priority 120]
+noncomputable instance preserves_colimits_of_size.zero.preserves_finite_colimits (F : C ⥤ D)
+    [preserves_colimits_of_size.{0 0} F] : preserves_finite_colimits F :=
+  preserves_colimits_of_size.preserves_finite_colimits F
+
+-- An alternative specialization of the dangerous instance for small colimits.
+@[priority 120]
+noncomputable instance preserves_colimits.preserves_finite_colimits (F : C ⥤ D)
+  [preserves_colimits F] : preserves_finite_colimits F :=
+preserves_colimits_of_size.preserves_finite_colimits F
+
 /-- We can always derive `preserves_finite_limits C` by showing that we are preserving limits at an
 arbitrary universe. -/
 def preserves_finite_colimits_of_preserves_finite_colimits_of_size (F : C ⥤ D)

024a4231

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

3974a774

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 -/
 import CategoryTheory.Limits.Preserves.Basic
-import CategoryTheory.FinCategory
+import CategoryTheory.FinCategory.Basic
 
 #align_import category_theory.limits.preserves.finite from "leanprover-community/mathlib"@"3974a774a707e2e06046a14c0eaef4654584fada"

3974a774

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2021 Andrew Yang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 -/
-import Mathbin.CategoryTheory.Limits.Preserves.Basic
-import Mathbin.CategoryTheory.FinCategory
+import CategoryTheory.Limits.Preserves.Basic
+import CategoryTheory.FinCategory
 
 #align_import category_theory.limits.preserves.finite from "leanprover-community/mathlib"@"3974a774a707e2e06046a14c0eaef4654584fada"

3974a774

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Andrew Yang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
-
-! This file was ported from Lean 3 source module category_theory.limits.preserves.finite
-! leanprover-community/mathlib commit 3974a774a707e2e06046a14c0eaef4654584fada
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Limits.Preserves.Basic
 import Mathbin.CategoryTheory.FinCategory
 
+#align_import category_theory.limits.preserves.finite from "leanprover-community/mathlib"@"3974a774a707e2e06046a14c0eaef4654584fada"
+
 /-!
 # Preservation of finite (co)limits.

3974a774

bump to nightly-2023-06-09-07

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

16afdc39

Diff

@@ -104,7 +104,7 @@ def preservesFiniteLimitsOfPreservesFiniteLimitsOfSize (F : C ⥤ D)
     PreservesFiniteLimits F :=
   ⟨fun J hJ hhJ => by
     skip
-    let this : Category.{w, w} (ULiftHom.{w} (ULift.{w, 0} J)) := by apply ULiftHom.category.{0};
+    let this.1 : Category.{w, w} (ULiftHom.{w} (ULift.{w, 0} J)) := by apply ULiftHom.category.{0};
       exact CategoryTheory.uliftCategory J
     haveI := h (ULiftHom.{w} (ULift.{w} J)) CategoryTheory.finCategoryUlift
     exact preserves_limits_of_shape_of_equiv (ULiftHomULiftCategory.equiv.{w, w} J).symm F⟩
@@ -182,7 +182,7 @@ def preservesFiniteColimitsOfPreservesFiniteColimitsOfSize (F : C ⥤ D)
     PreservesFiniteColimits F :=
   ⟨fun J hJ hhJ => by
     skip
-    let this : Category.{w, w} (ULiftHom.{w} (ULift.{w, 0} J)) := by apply ULiftHom.category.{0};
+    let this.1 : Category.{w, w} (ULiftHom.{w} (ULift.{w, 0} J)) := by apply ULiftHom.category.{0};
       exact CategoryTheory.uliftCategory J
     haveI := h (ULiftHom.{w} (ULift.{w} J)) CategoryTheory.finCategoryUlift
     exact preserves_colimits_of_shape_of_equiv (ULiftHomULiftCategory.equiv.{w, w} J).symm F⟩

3974a774

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -99,16 +99,12 @@ noncomputable instance (priority := 120) PreservesLimits.preservesFiniteLimits (
 arbitrary universe. -/
 def preservesFiniteLimitsOfPreservesFiniteLimitsOfSize (F : C ⥤ D)
     (h :
-      ∀ (J : Type w) {𝒥 : SmallCategory J} (hJ : @FinCategory J 𝒥),
-        by
-        skip
+      ∀ (J : Type w) {𝒥 : SmallCategory J} (hJ : @FinCategory J 𝒥), by skip;
         exact preserves_limits_of_shape J F) :
     PreservesFiniteLimits F :=
   ⟨fun J hJ hhJ => by
     skip
-    let this : Category.{w, w} (ULiftHom.{w} (ULift.{w, 0} J)) :=
-      by
-      apply ULiftHom.category.{0}
+    let this : Category.{w, w} (ULiftHom.{w} (ULift.{w, 0} J)) := by apply ULiftHom.category.{0};
       exact CategoryTheory.uliftCategory J
     haveI := h (ULiftHom.{w} (ULift.{w} J)) CategoryTheory.finCategoryUlift
     exact preserves_limits_of_shape_of_equiv (ULiftHomULiftCategory.equiv.{w, w} J).symm F⟩
@@ -124,9 +120,7 @@ instance idPreservesFiniteLimits : PreservesFiniteLimits (𝟭 C) where
 /-- The composition of two left exact functors is left exact. -/
 def compPreservesFiniteLimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteLimits F]
     [PreservesFiniteLimits G] : PreservesFiniteLimits (F ⋙ G) :=
-  ⟨fun _ _ _ => by
-    skip
-    infer_instance⟩
+  ⟨fun _ _ _ => by skip; infer_instance⟩
 #align category_theory.limits.comp_preserves_finite_limits CategoryTheory.Limits.compPreservesFiniteLimits
 -/
 
@@ -183,16 +177,12 @@ noncomputable instance (priority := 120) PreservesColimits.preservesFiniteColimi
 arbitrary universe. -/
 def preservesFiniteColimitsOfPreservesFiniteColimitsOfSize (F : C ⥤ D)
     (h :
-      ∀ (J : Type w) {𝒥 : SmallCategory J} (hJ : @FinCategory J 𝒥),
-        by
-        skip
+      ∀ (J : Type w) {𝒥 : SmallCategory J} (hJ : @FinCategory J 𝒥), by skip;
         exact preserves_colimits_of_shape J F) :
     PreservesFiniteColimits F :=
   ⟨fun J hJ hhJ => by
     skip
-    let this : Category.{w, w} (ULiftHom.{w} (ULift.{w, 0} J)) :=
-      by
-      apply ULiftHom.category.{0}
+    let this : Category.{w, w} (ULiftHom.{w} (ULift.{w, 0} J)) := by apply ULiftHom.category.{0};
       exact CategoryTheory.uliftCategory J
     haveI := h (ULiftHom.{w} (ULift.{w} J)) CategoryTheory.finCategoryUlift
     exact preserves_colimits_of_shape_of_equiv (ULiftHomULiftCategory.equiv.{w, w} J).symm F⟩
@@ -208,9 +198,7 @@ instance idPreservesFiniteColimits : PreservesFiniteColimits (𝟭 C) where
 /-- The composition of two right exact functors is right exact. -/
 def compPreservesFiniteColimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteColimits F]
     [PreservesFiniteColimits G] : PreservesFiniteColimits (F ⋙ G) :=
-  ⟨fun _ _ _ => by
-    skip
-    infer_instance⟩
+  ⟨fun _ _ _ => by skip; infer_instance⟩
 #align category_theory.limits.comp_preserves_finite_colimits CategoryTheory.Limits.compPreservesFiniteColimits
 -/

3974a774

bump to nightly-2023-04-29-02

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

ca3faf7a

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 
 ! This file was ported from Lean 3 source module category_theory.limits.preserves.finite
-! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
+! leanprover-community/mathlib commit 3974a774a707e2e06046a14c0eaef4654584fada
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -67,16 +67,27 @@ noncomputable instance (priority := 100) preservesLimitsOfShapeOfPreservesFinite
 #align category_theory.limits.preserves_limits_of_shape_of_preserves_finite_limits CategoryTheory.Limits.preservesLimitsOfShapeOfPreservesFiniteLimits
 -/
 
+/- warning: category_theory.limits.preserves_limits_of_size.preserves_finite_limits clashes with category_theory.limits.preserves_limits.preserves_finite_limits_of_size -> CategoryTheory.Limits.PreservesLimitsOfSize.preservesFiniteLimits
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.preserves_limits_of_size.preserves_finite_limits CategoryTheory.Limits.PreservesLimitsOfSize.preservesFiniteLimitsₓ'. -/
 #print CategoryTheory.Limits.PreservesLimitsOfSize.preservesFiniteLimits /-
-noncomputable instance (priority := 100) PreservesLimitsOfSize.preservesFiniteLimits (F : C ⥤ D)
+-- This is a dangerous instance as it has unbound universe variables.
+/-- If we preserve limits of some arbitrary size, then we preserve all finite limits. -/
+noncomputable def PreservesLimitsOfSize.preservesFiniteLimits (F : C ⥤ D)
     [PreservesLimitsOfSize.{w, w₂} F] : PreservesFiniteLimits F :=
   ⟨fun J sJ fJ =>
     haveI := preserves_smallest_limits_of_preserves_limits F
     preserves_limits_of_shape_of_equiv (fin_category.equiv_as_type J) F⟩
-#align category_theory.limits.preserves_limits.preserves_finite_limits_of_size CategoryTheory.Limits.PreservesLimitsOfSize.preservesFiniteLimits
+#align category_theory.limits.preserves_limits_of_size.preserves_finite_limits CategoryTheory.Limits.PreservesLimitsOfSize.preservesFiniteLimits
 -/
 
+-- Added as a specialization of the dangerous instance above, for limits indexed in Type 0.
+noncomputable instance (priority := 120) PreservesLimitsOfSize.Zero.preservesFiniteLimits
+    (F : C ⥤ D) [PreservesLimitsOfSize.{0, 0} F] : PreservesFiniteLimits F :=
+  PreservesLimitsOfSize.preservesFiniteLimits F
+#align category_theory.limits.preserves_limits_of_size.zero.preserves_finite_limits CategoryTheory.Limits.PreservesLimitsOfSize.Zero.preservesFiniteLimits
+
 #print CategoryTheory.Limits.PreservesLimits.preservesFiniteLimits /-
+-- An alternative specialization of the dangerous instance for small limits.
 noncomputable instance (priority := 120) PreservesLimits.preservesFiniteLimits (F : C ⥤ D)
     [PreservesLimits F] : PreservesFiniteLimits F :=
   PreservesLimitsOfSize.preservesFiniteLimits F
@@ -142,18 +153,30 @@ noncomputable instance (priority := 100) preservesColimitsOfShapeOfPreservesFini
 #align category_theory.limits.preserves_colimits_of_shape_of_preserves_finite_colimits CategoryTheory.Limits.preservesColimitsOfShapeOfPreservesFiniteColimits
 -/
 
-/- warning: category_theory.limits.preserves_colimits.preserves_finite_colimits -> CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u₁}} [_inst_1 : CategoryTheory.Category.{v₁, u₁} C] {D : Type.{u₂}} [_inst_2 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor.{v₁, v₂, u₁, u₂} C _inst_1 D _inst_2) [_inst_5 : CategoryTheory.Limits.PreservesColimitsOfSize.{w, w₂, v₁, v₂, u₁, u₂} C _inst_1 D _inst_2 F], CategoryTheory.Limits.PreservesFiniteColimits.{v₁, v₂, u₁, u₂} C _inst_1 D _inst_2 F
-but is expected to have type
-  forall {C : Type.{u₁}} [_inst_1 : CategoryTheory.Category.{v₁, u₁} C] {D : Type.{u₂}} [_inst_2 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor.{v₁, v₂, u₁, u₂} C _inst_1 D _inst_2) [_inst_5 : CategoryTheory.Limits.PreservesColimits.{v₁, v₂, u₁, u₂} C _inst_1 D _inst_2 F], CategoryTheory.Limits.PreservesFiniteColimits.{v₁, v₂, u₁, u₂} C _inst_1 D _inst_2 F
-Case conversion may be inaccurate. Consider using '#align category_theory.limits.preserves_colimits.preserves_finite_colimits CategoryTheory.Limits.PreservesColimits.preservesFiniteColimitsₓ'. -/
-noncomputable instance (priority := 100) PreservesColimits.preservesFiniteColimits (F : C ⥤ D)
+#print CategoryTheory.Limits.PreservesColimitsOfSize.preservesFiniteColimits /-
+-- This is a dangerous instance as it has unbound universe variables.
+/-- If we preserve colimits of some arbitrary size, then we preserve all finite colimits. -/
+noncomputable def PreservesColimitsOfSize.preservesFiniteColimits (F : C ⥤ D)
     [PreservesColimitsOfSize.{w, w₂} F] : PreservesFiniteColimits F :=
   ⟨fun J sJ fJ =>
     haveI := preserves_smallest_colimits_of_preserves_colimits F
     preserves_colimits_of_shape_of_equiv (fin_category.equiv_as_type J) F⟩
+#align category_theory.limits.preserves_colimits_of_size.preserves_finite_colimits CategoryTheory.Limits.PreservesColimitsOfSize.preservesFiniteColimits
+-/
+
+-- Added as a specialization of the dangerous instance above, for colimits indexed in Type 0.
+noncomputable instance (priority := 120) PreservesColimitsOfSize.Zero.preservesFiniteColimits
+    (F : C ⥤ D) [PreservesColimitsOfSize.{0, 0} F] : PreservesFiniteColimits F :=
+  PreservesColimitsOfSize.preservesFiniteColimits F
+#align category_theory.limits.preserves_colimits_of_size.zero.preserves_finite_colimits CategoryTheory.Limits.PreservesColimitsOfSize.Zero.preservesFiniteColimits
+
+#print CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits /-
+-- An alternative specialization of the dangerous instance for small colimits.
+noncomputable instance (priority := 120) PreservesColimits.preservesFiniteColimits (F : C ⥤ D)
+    [PreservesColimits F] : PreservesFiniteColimits F :=
+  PreservesColimitsOfSize.preservesFiniteColimits F
 #align category_theory.limits.preserves_colimits.preserves_finite_colimits CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits
+-/
 
 #print CategoryTheory.Limits.preservesFiniteColimitsOfPreservesFiniteColimitsOfSize /-
 /-- We can always derive `preserves_finite_limits C` by showing that we are preserving limits at an

f4758115

bump to nightly-2023-04-28-14

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

f7c08f8f

Diff

@@ -67,19 +67,19 @@ noncomputable instance (priority := 100) preservesLimitsOfShapeOfPreservesFinite
 #align category_theory.limits.preserves_limits_of_shape_of_preserves_finite_limits CategoryTheory.Limits.preservesLimitsOfShapeOfPreservesFiniteLimits
 -/
 
-#print CategoryTheory.Limits.PreservesLimits.preservesFiniteLimitsOfSize /-
-noncomputable instance (priority := 100) PreservesLimits.preservesFiniteLimitsOfSize (F : C ⥤ D)
+#print CategoryTheory.Limits.PreservesLimitsOfSize.preservesFiniteLimits /-
+noncomputable instance (priority := 100) PreservesLimitsOfSize.preservesFiniteLimits (F : C ⥤ D)
     [PreservesLimitsOfSize.{w, w₂} F] : PreservesFiniteLimits F :=
   ⟨fun J sJ fJ =>
     haveI := preserves_smallest_limits_of_preserves_limits F
     preserves_limits_of_shape_of_equiv (fin_category.equiv_as_type J) F⟩
-#align category_theory.limits.preserves_limits.preserves_finite_limits_of_size CategoryTheory.Limits.PreservesLimits.preservesFiniteLimitsOfSize
+#align category_theory.limits.preserves_limits.preserves_finite_limits_of_size CategoryTheory.Limits.PreservesLimitsOfSize.preservesFiniteLimits
 -/
 
 #print CategoryTheory.Limits.PreservesLimits.preservesFiniteLimits /-
 noncomputable instance (priority := 120) PreservesLimits.preservesFiniteLimits (F : C ⥤ D)
     [PreservesLimits F] : PreservesFiniteLimits F :=
-  PreservesLimits.preservesFiniteLimitsOfSize F
+  PreservesLimitsOfSize.preservesFiniteLimits F
 #align category_theory.limits.preserves_limits.preserves_finite_limits CategoryTheory.Limits.PreservesLimits.preservesFiniteLimits
 -/
 
@@ -142,14 +142,18 @@ noncomputable instance (priority := 100) preservesColimitsOfShapeOfPreservesFini
 #align category_theory.limits.preserves_colimits_of_shape_of_preserves_finite_colimits CategoryTheory.Limits.preservesColimitsOfShapeOfPreservesFiniteColimits
 -/
 
-#print CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits /-
+/- warning: category_theory.limits.preserves_colimits.preserves_finite_colimits -> CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits is a dubious translation:
+lean 3 declaration is
+  forall {C : Type.{u₁}} [_inst_1 : CategoryTheory.Category.{v₁, u₁} C] {D : Type.{u₂}} [_inst_2 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor.{v₁, v₂, u₁, u₂} C _inst_1 D _inst_2) [_inst_5 : CategoryTheory.Limits.PreservesColimitsOfSize.{w, w₂, v₁, v₂, u₁, u₂} C _inst_1 D _inst_2 F], CategoryTheory.Limits.PreservesFiniteColimits.{v₁, v₂, u₁, u₂} C _inst_1 D _inst_2 F
+but is expected to have type
+  forall {C : Type.{u₁}} [_inst_1 : CategoryTheory.Category.{v₁, u₁} C] {D : Type.{u₂}} [_inst_2 : CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor.{v₁, v₂, u₁, u₂} C _inst_1 D _inst_2) [_inst_5 : CategoryTheory.Limits.PreservesColimits.{v₁, v₂, u₁, u₂} C _inst_1 D _inst_2 F], CategoryTheory.Limits.PreservesFiniteColimits.{v₁, v₂, u₁, u₂} C _inst_1 D _inst_2 F
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.preserves_colimits.preserves_finite_colimits CategoryTheory.Limits.PreservesColimits.preservesFiniteColimitsₓ'. -/
 noncomputable instance (priority := 100) PreservesColimits.preservesFiniteColimits (F : C ⥤ D)
     [PreservesColimitsOfSize.{w, w₂} F] : PreservesFiniteColimits F :=
   ⟨fun J sJ fJ =>
     haveI := preserves_smallest_colimits_of_preserves_colimits F
     preserves_colimits_of_shape_of_equiv (fin_category.equiv_as_type J) F⟩
 #align category_theory.limits.preserves_colimits.preserves_finite_colimits CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits
--/
 
 #print CategoryTheory.Limits.preservesFiniteColimitsOfPreservesFiniteColimitsOfSize /-
 /-- We can always derive `preserves_finite_limits C` by showing that we are preserving limits at an

f4758115

bump to nightly-2023-03-09-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/21e3562c5e12d846c7def5eff8cdbc520d7d4936

061741a1

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 
 ! This file was ported from Lean 3 source module category_theory.limits.preserves.finite
-! leanprover-community/mathlib commit 024a4231815538ac739f52d08dd20a55da0d6b23
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.CategoryTheory.FinCategory
 /-!
 # Preservation of finite (co)limits.
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 These functors are also known as left exact (flat) or right exact functors when the categories
 involved are abelian, or more generally, finitely (co)complete.

024a4231

bump to nightly-2023-03-07-00

mathlib commit https://github.com/leanprover-community/mathlib/commit/3b267e70a936eebb21ab546f49a8df34dd300b25

b7d7cb8b

Diff

@@ -42,6 +42,7 @@ variable {E : Type u₃} [Category.{v₃} E]
 
 variable {J : Type w} [SmallCategory J] {K : J ⥤ C}
 
+#print CategoryTheory.Limits.PreservesFiniteLimits /-
 /-- A functor is said to preserve finite limits, if it preserves all limits of shape `J`,
 where `J : Type` is a finite category.
 -/
@@ -49,9 +50,11 @@ class PreservesFiniteLimits (F : C ⥤ D) where
   PreservesFiniteLimits :
     ∀ (J : Type) [SmallCategory J] [FinCategory J], PreservesLimitsOfShape J F := by infer_instance
 #align category_theory.limits.preserves_finite_limits CategoryTheory.Limits.PreservesFiniteLimits
+-/
 
 attribute [instance] preserves_finite_limits.preserves_finite_limits
 
+#print CategoryTheory.Limits.preservesLimitsOfShapeOfPreservesFiniteLimits /-
 /-- Preserving finite limits also implies preserving limits over finite shapes in higher universes,
 though through a noncomputable instance. -/
 noncomputable instance (priority := 100) preservesLimitsOfShapeOfPreservesFiniteLimits (F : C ⥤ D)
@@ -59,19 +62,25 @@ noncomputable instance (priority := 100) preservesLimitsOfShapeOfPreservesFinite
     PreservesLimitsOfShape J F := by
   apply preserves_limits_of_shape_of_equiv (fin_category.equiv_as_type J)
 #align category_theory.limits.preserves_limits_of_shape_of_preserves_finite_limits CategoryTheory.Limits.preservesLimitsOfShapeOfPreservesFiniteLimits
+-/
 
+#print CategoryTheory.Limits.PreservesLimits.preservesFiniteLimitsOfSize /-
 noncomputable instance (priority := 100) PreservesLimits.preservesFiniteLimitsOfSize (F : C ⥤ D)
     [PreservesLimitsOfSize.{w, w₂} F] : PreservesFiniteLimits F :=
   ⟨fun J sJ fJ =>
     haveI := preserves_smallest_limits_of_preserves_limits F
     preserves_limits_of_shape_of_equiv (fin_category.equiv_as_type J) F⟩
 #align category_theory.limits.preserves_limits.preserves_finite_limits_of_size CategoryTheory.Limits.PreservesLimits.preservesFiniteLimitsOfSize
+-/
 
+#print CategoryTheory.Limits.PreservesLimits.preservesFiniteLimits /-
 noncomputable instance (priority := 120) PreservesLimits.preservesFiniteLimits (F : C ⥤ D)
     [PreservesLimits F] : PreservesFiniteLimits F :=
   PreservesLimits.preservesFiniteLimitsOfSize F
 #align category_theory.limits.preserves_limits.preserves_finite_limits CategoryTheory.Limits.PreservesLimits.preservesFiniteLimits
+-/
 
+#print CategoryTheory.Limits.preservesFiniteLimitsOfPreservesFiniteLimitsOfSize /-
 /-- We can always derive `preserves_finite_limits C` by showing that we are preserving limits at an
 arbitrary universe. -/
 def preservesFiniteLimitsOfPreservesFiniteLimitsOfSize (F : C ⥤ D)
@@ -90,10 +99,14 @@ def preservesFiniteLimitsOfPreservesFiniteLimitsOfSize (F : C ⥤ D)
     haveI := h (ULiftHom.{w} (ULift.{w} J)) CategoryTheory.finCategoryUlift
     exact preserves_limits_of_shape_of_equiv (ULiftHomULiftCategory.equiv.{w, w} J).symm F⟩
 #align category_theory.limits.preserves_finite_limits_of_preserves_finite_limits_of_size CategoryTheory.Limits.preservesFiniteLimitsOfPreservesFiniteLimitsOfSize
+-/
 
+#print CategoryTheory.Limits.idPreservesFiniteLimits /-
 instance idPreservesFiniteLimits : PreservesFiniteLimits (𝟭 C) where
 #align category_theory.limits.id_preserves_finite_limits CategoryTheory.Limits.idPreservesFiniteLimits
+-/
 
+#print CategoryTheory.Limits.compPreservesFiniteLimits /-
 /-- The composition of two left exact functors is left exact. -/
 def compPreservesFiniteLimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteLimits F]
     [PreservesFiniteLimits G] : PreservesFiniteLimits (F ⋙ G) :=
@@ -101,7 +114,9 @@ def compPreservesFiniteLimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteLimits
     skip
     infer_instance⟩
 #align category_theory.limits.comp_preserves_finite_limits CategoryTheory.Limits.compPreservesFiniteLimits
+-/
 
+#print CategoryTheory.Limits.PreservesFiniteColimits /-
 /-- A functor is said to preserve finite colimits, if it preserves all colimits of
 shape `J`, where `J : Type` is a finite category.
 -/
@@ -110,9 +125,11 @@ class PreservesFiniteColimits (F : C ⥤ D) where
     ∀ (J : Type) [SmallCategory J] [FinCategory J], PreservesColimitsOfShape J F := by
     infer_instance
 #align category_theory.limits.preserves_finite_colimits CategoryTheory.Limits.PreservesFiniteColimits
+-/
 
 attribute [instance] preserves_finite_colimits.preserves_finite_colimits
 
+#print CategoryTheory.Limits.preservesColimitsOfShapeOfPreservesFiniteColimits /-
 /-- Preserving finite limits also implies preserving limits over finite shapes in higher universes,
 though through a noncomputable instance. -/
 noncomputable instance (priority := 100) preservesColimitsOfShapeOfPreservesFiniteColimits
@@ -120,14 +137,18 @@ noncomputable instance (priority := 100) preservesColimitsOfShapeOfPreservesFini
     PreservesColimitsOfShape J F := by
   apply preserves_colimits_of_shape_of_equiv (fin_category.equiv_as_type J)
 #align category_theory.limits.preserves_colimits_of_shape_of_preserves_finite_colimits CategoryTheory.Limits.preservesColimitsOfShapeOfPreservesFiniteColimits
+-/
 
+#print CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits /-
 noncomputable instance (priority := 100) PreservesColimits.preservesFiniteColimits (F : C ⥤ D)
     [PreservesColimitsOfSize.{w, w₂} F] : PreservesFiniteColimits F :=
   ⟨fun J sJ fJ =>
     haveI := preserves_smallest_colimits_of_preserves_colimits F
     preserves_colimits_of_shape_of_equiv (fin_category.equiv_as_type J) F⟩
 #align category_theory.limits.preserves_colimits.preserves_finite_colimits CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits
+-/
 
+#print CategoryTheory.Limits.preservesFiniteColimitsOfPreservesFiniteColimitsOfSize /-
 /-- We can always derive `preserves_finite_limits C` by showing that we are preserving limits at an
 arbitrary universe. -/
 def preservesFiniteColimitsOfPreservesFiniteColimitsOfSize (F : C ⥤ D)
@@ -146,10 +167,14 @@ def preservesFiniteColimitsOfPreservesFiniteColimitsOfSize (F : C ⥤ D)
     haveI := h (ULiftHom.{w} (ULift.{w} J)) CategoryTheory.finCategoryUlift
     exact preserves_colimits_of_shape_of_equiv (ULiftHomULiftCategory.equiv.{w, w} J).symm F⟩
 #align category_theory.limits.preserves_finite_colimits_of_preserves_finite_colimits_of_size CategoryTheory.Limits.preservesFiniteColimitsOfPreservesFiniteColimitsOfSize
+-/
 
+#print CategoryTheory.Limits.idPreservesFiniteColimits /-
 instance idPreservesFiniteColimits : PreservesFiniteColimits (𝟭 C) where
 #align category_theory.limits.id_preserves_finite_colimits CategoryTheory.Limits.idPreservesFiniteColimits
+-/
 
+#print CategoryTheory.Limits.compPreservesFiniteColimits /-
 /-- The composition of two right exact functors is right exact. -/
 def compPreservesFiniteColimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteColimits F]
     [PreservesFiniteColimits G] : PreservesFiniteColimits (F ⋙ G) :=
@@ -157,6 +182,7 @@ def compPreservesFiniteColimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteColi
     skip
     infer_instance⟩
 #align category_theory.limits.comp_preserves_finite_colimits CategoryTheory.Limits.compPreservesFiniteColimits
+-/
 
 end CategoryTheory.Limits

024a4231

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

3974a774

feat: existence of a limit in a concrete category implies smallness (#11625)

In this PR, it is shown that if a functor G : J ⥤ C to a concrete category has a limit and that forget C is corepresentable, then G ⋙ forget C).sections is small. As the corepresentability property holds in many concrete categories (e.g. groups, abelian groups) and that we already know since #11420 that limits exist under the smallness assumption in such categories, then this lemma may be used in future PR in order to show that usual forgetful functors preserve all limits (regardless of universe assumptions). This shall be convenient in the development of sheaves of modules.

In this PR, universes assumptions have also been generalized in the file Limits.Yoneda. In order to do this, a small refactor of the file Limits.Types was necessary. This introduces bijections like compCoyonedaSectionsEquiv (F : J ⥤ C) (X : C) : (F ⋙ coyoneda.obj (op X)).sections ≃ ((const J).obj X ⟶ F) with general universe parameters. In order to reduce imports in Limits.Yoneda, part of the file Limits.Types was moved to a new file Limits.TypesFiltered.

Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr>

3cb545c7

Diff

@@ -108,6 +108,14 @@ class PreservesFiniteProducts (F : C ⥤ D) where
 
 attribute [instance] PreservesFiniteProducts.preserves
 
+instance compPreservesFiniteProducts (F : C ⥤ D) (G : D ⥤ E)
+    [PreservesFiniteProducts F] [PreservesFiniteProducts G] :
+    PreservesFiniteProducts (F ⋙ G) where
+  preserves _ _ := by infer_instance
+
+noncomputable instance (F : C ⥤ D) [PreservesFiniteLimits F] : PreservesFiniteProducts F where
+  preserves _ _ := by infer_instance
+
 /-- A functor is said to preserve finite colimits, if it preserves all colimits of
 shape `J`, where `J : Type` is a finite category.
 -/
@@ -184,4 +192,12 @@ class PreservesFiniteCoproducts (F : C ⥤ D) where
 
 attribute [instance] PreservesFiniteCoproducts.preserves
 
+instance compPreservesFiniteCoproducts (F : C ⥤ D) (G : D ⥤ E)
+    [PreservesFiniteCoproducts F] [PreservesFiniteCoproducts G] :
+    PreservesFiniteCoproducts (F ⋙ G) where
+  preserves _ _ := by infer_instance
+
+noncomputable instance (F : C ⥤ D) [PreservesFiniteColimits F] : PreservesFiniteCoproducts F where
+  preserves _ _ := by infer_instance
+
 end CategoryTheory.Limits

3974a774

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

@@ -32,11 +32,8 @@ namespace CategoryTheory.Limits
 universe w w₂ v₁ v₂ v₃ u₁ u₂ u₃
 
 variable {C : Type u₁} [Category.{v₁} C]
-
 variable {D : Type u₂} [Category.{v₂} D]
-
 variable {E : Type u₃} [Category.{v₃} E]
-
 variable {J : Type w} [SmallCategory J] {K : J ⥤ C}
 
 /-- A functor is said to preserve finite limits, if it preserves all limits of shape `J`,

3974a774

chore: split CategoryTheory.FinCategory (#9923)

Minor clean up of imports, getting ready to minimize the heartbeats variation observed/reduced in #9732.

This has the effect of slightly (although not enough) delaying the import of positivity (which in turn imports the kitchen sink) into the category theory development.

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

9405a732

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 -/
 import Mathlib.CategoryTheory.Limits.Preserves.Basic
-import Mathlib.CategoryTheory.FinCategory
+import Mathlib.CategoryTheory.FinCategory.AsType
 
 #align_import category_theory.limits.preserves.finite from "leanprover-community/mathlib"@"3974a774a707e2e06046a14c0eaef4654584fada"

3974a774

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

@@ -165,7 +165,7 @@ def preservesFiniteColimitsOfPreservesFiniteColimitsOfSize (F : C ⥤ D)
         exact preservesColimitsOfShapeOfEquiv (ULiftHomULiftCategory.equiv J).symm F
 #align category_theory.limits.preserves_finite_colimits_of_preserves_finite_colimits_of_size CategoryTheory.Limits.preservesFiniteColimitsOfPreservesFiniteColimitsOfSize
 
--- porting note: the proof `⟨fun _ _ _ => by infer_instance⟩` used for `idPreservesFiniteLimits`
+-- Porting note: the proof `⟨fun _ _ _ => by infer_instance⟩` used for `idPreservesFiniteLimits`
 -- did not work here because of universe problems, could this be solved by tweaking the priorities
 -- of some instances?
 noncomputable instance idPreservesFiniteColimits : PreservesFiniteColimits (𝟭 C) :=

3974a774

feat(Condensed): Explicit descriptions of condensed sets (#6731)

We prove the characterisation of condensed sets as finite-product preserving presheaves satisfying the equalizer condition on CompHaus/Profinite, and just finite-product preserving presheaves on Stonean.

Co-authored-by: Riccardo Brasca @riccardobrasca [riccardo.brasca@gmail.com](mailto:riccardo.brasca@gmail.com) Co-authored-by: Filippo A E Nuccio @faenuccio [filippo.nuccio@univ-st-etienne.fr](mailto:filippo.nuccio@univ-st-etienne.fr)

c5eb45f0

Diff

@@ -109,6 +109,8 @@ for `Fintype J` -/
 class PreservesFiniteProducts (F : C ⥤ D) where
   preserves : ∀ (J : Type) [Fintype J], PreservesLimitsOfShape (Discrete J) F
 
+attribute [instance] PreservesFiniteProducts.preserves
+
 /-- A functor is said to preserve finite colimits, if it preserves all colimits of
 shape `J`, where `J : Type` is a finite category.
 -/

3974a774

feat(Topology/Category): CompHaus, Profinite and Stonean are FinitaryExtensive. (#8012)

Co-authored-by: Andrew Yang <36414270+erdOne@users.noreply.github.com>

95dc8041

Diff

@@ -183,4 +183,6 @@ for `Fintype J` -/
 class PreservesFiniteCoproducts (F : C ⥤ D) where
   preserves : ∀ (J : Type) [Fintype J], PreservesColimitsOfShape (Discrete J) F
 
+attribute [instance] PreservesFiniteCoproducts.preserves
+
 end CategoryTheory.Limits

3974a774

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,15 +2,12 @@
 Copyright (c) 2021 Andrew Yang. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
-
-! This file was ported from Lean 3 source module category_theory.limits.preserves.finite
-! leanprover-community/mathlib commit 3974a774a707e2e06046a14c0eaef4654584fada
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Limits.Preserves.Basic
 import Mathlib.CategoryTheory.FinCategory
 
+#align_import category_theory.limits.preserves.finite from "leanprover-community/mathlib"@"3974a774a707e2e06046a14c0eaef4654584fada"
+
 /-!
 # Preservation of finite (co)limits.

3974a774

chore: cleanup whitespace (#5988)

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

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

12343aa5

Diff

@@ -109,7 +109,7 @@ def compPreservesFiniteLimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteLimits
 [#2764](https://github.com/leanprover-community/mathlib4/pull/2764) -/
 /-- A functor `F` preserves finite products if it preserves all from `Discrete J`
 for `Fintype J` -/
-class PreservesFiniteProducts (F : C ⥤  D) where
+class PreservesFiniteProducts (F : C ⥤ D) where
   preserves : ∀ (J : Type) [Fintype J], PreservesLimitsOfShape (Discrete J) F
 
 /-- A functor is said to preserve finite colimits, if it preserves all colimits of
@@ -183,7 +183,7 @@ def compPreservesFiniteColimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteColi
 [#2764](https://github.com/leanprover-community/mathlib4/pull/2764) -/
 /-- A functor `F` preserves finite products if it preserves all from `Discrete J`
 for `Fintype J` -/
-class PreservesFiniteCoproducts (F : C ⥤  D) where
+class PreservesFiniteCoproducts (F : C ⥤ D) where
   preserves : ∀ (J : Type) [Fintype J], PreservesColimitsOfShape (Discrete J) F
 
 end CategoryTheory.Limits

3974a774

chore: forward-port backports (#3752)

data.mv_polynomial.basic, data.mv_polynomial.funext: leanprover-community/mathlib#18839
category_theory.limits.preserves.finite, category_theory.preadditive.projective: leanprover-community/mathlib#18890
category_theory.abelian.basic, category_theory.abelian.opposite: leanprover-community/mathlib#18740
topology.category.Top.limits.basic: leanprover-community/mathlib#18871. Note that this does not show a useful diff on the dashboard pages as file splits aren't tracked well by git.

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

4f474208

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Andrew Yang
 
 ! This file was ported from Lean 3 source module category_theory.limits.preserves.finite
-! leanprover-community/mathlib commit 024a4231815538ac739f52d08dd20a55da0d6b23
+! leanprover-community/mathlib commit 3974a774a707e2e06046a14c0eaef4654584fada
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -60,7 +60,8 @@ noncomputable instance (priority := 100) preservesLimitsOfShapeOfPreservesFinite
   apply preservesLimitsOfShapeOfEquiv (FinCategory.equivAsType J)
 #align category_theory.limits.preserves_limits_of_shape_of_preserves_finite_limits CategoryTheory.Limits.preservesLimitsOfShapeOfPreservesFiniteLimits
 
--- Porting note: this is a dangerous instance as it has unbound universe variables.
+-- This is a dangerous instance as it has unbound universe variables.
+/-- If we preserve limits of some arbitrary size, then we preserve all finite limits. -/
 noncomputable def PreservesLimitsOfSize.preservesFiniteLimits (F : C ⥤ D)
     [PreservesLimitsOfSize.{w, w₂} F] : PreservesFiniteLimits F where
   preservesFiniteLimits J (sJ : SmallCategory J) fJ := by
@@ -68,11 +69,13 @@ noncomputable def PreservesLimitsOfSize.preservesFiniteLimits (F : C ⥤ D)
     exact preservesLimitsOfShapeOfEquiv (FinCategory.equivAsType J) F
 #align category_theory.limits.preserves_limits.preserves_finite_limits_of_size CategoryTheory.Limits.PreservesLimitsOfSize.preservesFiniteLimits
 
--- Porting note: added as a specialization of the dangerous instance above.
+-- Added as a specialization of the dangerous instance above, for limits indexed in Type 0.
 noncomputable instance (priority := 120) PreservesLimitsOfSize0.preservesFiniteLimits
     (F : C ⥤ D) [PreservesLimitsOfSize.{0, 0} F] : PreservesFiniteLimits F :=
   PreservesLimitsOfSize.preservesFiniteLimits F
+#align preserves_limits_of_size.zero.preserves_finite_limits CategoryTheory.Limits.PreservesLimitsOfSize0.preservesFiniteLimits
 
+-- An alternative specialization of the dangerous instance for small limits.
 noncomputable instance (priority := 120) PreservesLimits.preservesFiniteLimits (F : C ⥤ D)
     [PreservesLimits F] : PreservesFiniteLimits F :=
   PreservesLimitsOfSize.preservesFiniteLimits F
@@ -128,18 +131,22 @@ noncomputable instance (priority := 100) preservesColimitsOfShapeOfPreservesFini
   apply preservesColimitsOfShapeOfEquiv (FinCategory.equivAsType J)
 #align category_theory.limits.preserves_colimits_of_shape_of_preserves_finite_colimits CategoryTheory.Limits.preservesColimitsOfShapeOfPreservesFiniteColimits
 
--- Porting note: this is a dangerous instance as it has unbound universe variables.
+-- This is a dangerous instance as it has unbound universe variables.
+/-- If we preserve colimits of some arbitrary size, then we preserve all finite colimits. -/
 noncomputable def PreservesColimitsOfSize.preservesFiniteColimits (F : C ⥤ D)
     [PreservesColimitsOfSize.{w, w₂} F] : PreservesFiniteColimits F where
   preservesFiniteColimits J (sJ : SmallCategory J) fJ := by
     haveI := preservesSmallestColimitsOfPreservesColimits F
     exact preservesColimitsOfShapeOfEquiv (FinCategory.equivAsType J) F
+#align category_theory.limits.preserves_colimits_of_size.preserves_finite_colimits CategoryTheory.Limits.PreservesColimitsOfSize.preservesFiniteColimits
 
--- Porting note: added as a specialization of the dangerous instance above.
+-- Added as a specialization of the dangerous instance above, for colimits indexed in Type 0.
 noncomputable instance (priority := 120) PreservesColimitsOfSize0.preservesFiniteColimits
     (F : C ⥤ D) [PreservesColimitsOfSize.{0, 0} F] : PreservesFiniteColimits F :=
   PreservesColimitsOfSize.preservesFiniteColimits F
+#align preserves_colimits_of_size.zero.preserves_finite_colimits CategoryTheory.Limits.PreservesColimitsOfSize0.preservesFiniteColimits
 
+-- An alternative specialization of the dangerous instance for small colimits.
 noncomputable instance (priority := 120) PreservesColimits.preservesFiniteColimits (F : C ⥤ D)
     [PreservesColimits F] : PreservesFiniteColimits F :=
   PreservesColimitsOfSize.preservesFiniteColimits F

024a4231

feat: port CategoryTheory.Preadditive.Projective (#3615)

Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

bfb4a245

Diff

@@ -60,18 +60,26 @@ noncomputable instance (priority := 100) preservesLimitsOfShapeOfPreservesFinite
   apply preservesLimitsOfShapeOfEquiv (FinCategory.equivAsType J)
 #align category_theory.limits.preserves_limits_of_shape_of_preserves_finite_limits CategoryTheory.Limits.preservesLimitsOfShapeOfPreservesFiniteLimits
 
-noncomputable instance (priority := 100) PreservesLimits.preservesFiniteLimitsOfSize (F : C ⥤ D)
+-- Porting note: this is a dangerous instance as it has unbound universe variables.
+noncomputable def PreservesLimitsOfSize.preservesFiniteLimits (F : C ⥤ D)
     [PreservesLimitsOfSize.{w, w₂} F] : PreservesFiniteLimits F where
   preservesFiniteLimits J (sJ : SmallCategory J) fJ := by
     haveI := preservesSmallestLimitsOfPreservesLimits F
     exact preservesLimitsOfShapeOfEquiv (FinCategory.equivAsType J) F
-#align category_theory.limits.preserves_limits.preserves_finite_limits_of_size CategoryTheory.Limits.PreservesLimits.preservesFiniteLimitsOfSize
+#align category_theory.limits.preserves_limits.preserves_finite_limits_of_size CategoryTheory.Limits.PreservesLimitsOfSize.preservesFiniteLimits
+
+-- Porting note: added as a specialization of the dangerous instance above.
+noncomputable instance (priority := 120) PreservesLimitsOfSize0.preservesFiniteLimits
+    (F : C ⥤ D) [PreservesLimitsOfSize.{0, 0} F] : PreservesFiniteLimits F :=
+  PreservesLimitsOfSize.preservesFiniteLimits F
 
 noncomputable instance (priority := 120) PreservesLimits.preservesFiniteLimits (F : C ⥤ D)
     [PreservesLimits F] : PreservesFiniteLimits F :=
-  PreservesLimits.preservesFiniteLimitsOfSize F
+  PreservesLimitsOfSize.preservesFiniteLimits F
 #align category_theory.limits.preserves_limits.preserves_finite_limits CategoryTheory.Limits.PreservesLimits.preservesFiniteLimits
 
+-- Porting note: is this unnecessary given the instance
+-- `PreservesLimitsOfSize0.preservesFiniteLimits`?
 /-- We can always derive `PreservesFiniteLimits C` by showing that we are preserving limits at an
 arbitrary universe. -/
 def preservesFiniteLimitsOfPreservesFiniteLimitsOfSize (F : C ⥤ D)
@@ -120,15 +128,27 @@ noncomputable instance (priority := 100) preservesColimitsOfShapeOfPreservesFini
   apply preservesColimitsOfShapeOfEquiv (FinCategory.equivAsType J)
 #align category_theory.limits.preserves_colimits_of_shape_of_preserves_finite_colimits CategoryTheory.Limits.preservesColimitsOfShapeOfPreservesFiniteColimits
 
-noncomputable instance (priority := 100) PreservesColimits.preservesFiniteColimits (F : C ⥤ D)
+-- Porting note: this is a dangerous instance as it has unbound universe variables.
+noncomputable def PreservesColimitsOfSize.preservesFiniteColimits (F : C ⥤ D)
     [PreservesColimitsOfSize.{w, w₂} F] : PreservesFiniteColimits F where
   preservesFiniteColimits J (sJ : SmallCategory J) fJ := by
     haveI := preservesSmallestColimitsOfPreservesColimits F
     exact preservesColimitsOfShapeOfEquiv (FinCategory.equivAsType J) F
+
+-- Porting note: added as a specialization of the dangerous instance above.
+noncomputable instance (priority := 120) PreservesColimitsOfSize0.preservesFiniteColimits
+    (F : C ⥤ D) [PreservesColimitsOfSize.{0, 0} F] : PreservesFiniteColimits F :=
+  PreservesColimitsOfSize.preservesFiniteColimits F
+
+noncomputable instance (priority := 120) PreservesColimits.preservesFiniteColimits (F : C ⥤ D)
+    [PreservesColimits F] : PreservesFiniteColimits F :=
+  PreservesColimitsOfSize.preservesFiniteColimits F
 #align category_theory.limits.preserves_colimits.preserves_finite_colimits CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits
 
-/-- We can always derive `PreservesFiniteLimits C` by showing that we are preserving limits at an
-arbitrary universe. -/
+-- Porting note: is this unnecessary given the instance
+-- `PreservesColimitsOfSize0.preservesFiniteColimits`?
+/-- We can always derive `PreservesFiniteColimits C`
+by showing that we are preserving colimits at an arbitrary universe. -/
 def preservesFiniteColimitsOfPreservesFiniteColimitsOfSize (F : C ⥤ D)
     (h :
       ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), PreservesColimitsOfShape J F) :

024a4231

refactor: lowercase structure member preservesFiniteLimits (#2827)

From this Zulip thread.

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

781d27ee

Diff

@@ -46,11 +46,11 @@ variable {J : Type w} [SmallCategory J] {K : J ⥤ C}
 where `J : Type` is a finite category.
 -/
 class PreservesFiniteLimits (F : C ⥤ D) where
-  PreservesFiniteLimits :
+  preservesFiniteLimits :
     ∀ (J : Type) [SmallCategory J] [FinCategory J], PreservesLimitsOfShape J F := by infer_instance
 #align category_theory.limits.preserves_finite_limits CategoryTheory.Limits.PreservesFiniteLimits
 
-attribute [instance] PreservesFiniteLimits.PreservesFiniteLimits
+attribute [instance] PreservesFiniteLimits.preservesFiniteLimits
 
 /-- Preserving finite limits also implies preserving limits over finite shapes in higher universes,
 though through a noncomputable instance. -/
@@ -62,7 +62,7 @@ noncomputable instance (priority := 100) preservesLimitsOfShapeOfPreservesFinite
 
 noncomputable instance (priority := 100) PreservesLimits.preservesFiniteLimitsOfSize (F : C ⥤ D)
     [PreservesLimitsOfSize.{w, w₂} F] : PreservesFiniteLimits F where
-  PreservesFiniteLimits J (sJ : SmallCategory J) fJ := by
+  preservesFiniteLimits J (sJ : SmallCategory J) fJ := by
     haveI := preservesSmallestLimitsOfPreservesLimits F
     exact preservesLimitsOfShapeOfEquiv (FinCategory.equivAsType J) F
 #align category_theory.limits.preserves_limits.preserves_finite_limits_of_size CategoryTheory.Limits.PreservesLimits.preservesFiniteLimitsOfSize
@@ -78,7 +78,7 @@ def preservesFiniteLimitsOfPreservesFiniteLimitsOfSize (F : C ⥤ D)
     (h :
       ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), PreservesLimitsOfShape J F) :
     PreservesFiniteLimits F where
-      PreservesFiniteLimits J (_ : SmallCategory J) _ := by
+      preservesFiniteLimits J (_ : SmallCategory J) _ := by
         letI : Category (ULiftHom (ULift J)) := ULiftHom.category
         haveI := h (ULiftHom (ULift J)) CategoryTheory.finCategoryUlift
         exact preservesLimitsOfShapeOfEquiv (ULiftHomULiftCategory.equiv J).symm F
@@ -105,12 +105,12 @@ class PreservesFiniteProducts (F : C ⥤  D) where
 shape `J`, where `J : Type` is a finite category.
 -/
 class PreservesFiniteColimits (F : C ⥤ D) where
-  PreservesFiniteColimits :
+  preservesFiniteColimits :
     ∀ (J : Type) [SmallCategory J] [FinCategory J], PreservesColimitsOfShape J F := by
     infer_instance
 #align category_theory.limits.preserves_finite_colimits CategoryTheory.Limits.PreservesFiniteColimits
 
-attribute [instance] PreservesFiniteColimits.PreservesFiniteColimits
+attribute [instance] PreservesFiniteColimits.preservesFiniteColimits
 
 /-- Preserving finite limits also implies preserving limits over finite shapes in higher universes,
 though through a noncomputable instance. -/
@@ -122,7 +122,7 @@ noncomputable instance (priority := 100) preservesColimitsOfShapeOfPreservesFini
 
 noncomputable instance (priority := 100) PreservesColimits.preservesFiniteColimits (F : C ⥤ D)
     [PreservesColimitsOfSize.{w, w₂} F] : PreservesFiniteColimits F where
-  PreservesFiniteColimits J (sJ : SmallCategory J) fJ := by
+  preservesFiniteColimits J (sJ : SmallCategory J) fJ := by
     haveI := preservesSmallestColimitsOfPreservesColimits F
     exact preservesColimitsOfShapeOfEquiv (FinCategory.equivAsType J) F
 #align category_theory.limits.preserves_colimits.preserves_finite_colimits CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits
@@ -133,7 +133,7 @@ def preservesFiniteColimitsOfPreservesFiniteColimitsOfSize (F : C ⥤ D)
     (h :
       ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), PreservesColimitsOfShape J F) :
     PreservesFiniteColimits F where
-      PreservesFiniteColimits J (_ : SmallCategory J) _ := by
+      preservesFiniteColimits J (_ : SmallCategory J) _ := by
         letI : Category (ULiftHom (ULift J)) := ULiftHom.category
         haveI := h (ULiftHom (ULift J)) CategoryTheory.finCategoryUlift
         exact preservesColimitsOfShapeOfEquiv (ULiftHomULiftCategory.equiv J).symm F

024a4231

chore: strip trailing spaces in lean files (#2828)

vscode is already configured by .vscode/settings.json to trim these on save. It's not clear how they've managed to stick around.

By doing this all in one PR now, it avoids getting random whitespace diffs in PRs later.

This was done with a regex search in vscode,

6ceb5945

Diff

@@ -94,11 +94,11 @@ def compPreservesFiniteLimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteLimits
   ⟨fun _ _ _ => by infer_instance⟩
 #align category_theory.limits.comp_preserves_finite_limits CategoryTheory.Limits.compPreservesFiniteLimits
 
-/- Porting note: adding this class because quantified classes don't behave well 
+/- Porting note: adding this class because quantified classes don't behave well
 [#2764](https://github.com/leanprover-community/mathlib4/pull/2764) -/
-/-- A functor `F` preserves finite products if it preserves all from `Discrete J` 
+/-- A functor `F` preserves finite products if it preserves all from `Discrete J`
 for `Fintype J` -/
-class PreservesFiniteProducts (F : C ⥤  D) where 
+class PreservesFiniteProducts (F : C ⥤  D) where
   preserves : ∀ (J : Type) [Fintype J], PreservesLimitsOfShape (Discrete J) F
 
 /-- A functor is said to preserve finite colimits, if it preserves all colimits of
@@ -152,11 +152,11 @@ def compPreservesFiniteColimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteColi
   ⟨fun _ _ _ => by infer_instance⟩
 #align category_theory.limits.comp_preserves_finite_colimits CategoryTheory.Limits.compPreservesFiniteColimits
 
-/- Porting note: adding this class because quantified classes don't behave well 
+/- Porting note: adding this class because quantified classes don't behave well
 [#2764](https://github.com/leanprover-community/mathlib4/pull/2764) -/
-/-- A functor `F` preserves finite products if it preserves all from `Discrete J` 
+/-- A functor `F` preserves finite products if it preserves all from `Discrete J`
 for `Fintype J` -/
-class PreservesFiniteCoproducts (F : C ⥤  D) where 
+class PreservesFiniteCoproducts (F : C ⥤  D) where
   preserves : ∀ (J : Type) [Fintype J], PreservesColimitsOfShape (Discrete J) F
 
 end CategoryTheory.Limits

024a4231

feat: port CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers (#2764)

07ab9d6a

Diff

@@ -94,6 +94,13 @@ def compPreservesFiniteLimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteLimits
   ⟨fun _ _ _ => by infer_instance⟩
 #align category_theory.limits.comp_preserves_finite_limits CategoryTheory.Limits.compPreservesFiniteLimits
 
+/- Porting note: adding this class because quantified classes don't behave well 
+[#2764](https://github.com/leanprover-community/mathlib4/pull/2764) -/
+/-- A functor `F` preserves finite products if it preserves all from `Discrete J` 
+for `Fintype J` -/
+class PreservesFiniteProducts (F : C ⥤  D) where 
+  preserves : ∀ (J : Type) [Fintype J], PreservesLimitsOfShape (Discrete J) F
+
 /-- A functor is said to preserve finite colimits, if it preserves all colimits of
 shape `J`, where `J : Type` is a finite category.
 -/
@@ -145,4 +152,11 @@ def compPreservesFiniteColimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteColi
   ⟨fun _ _ _ => by infer_instance⟩
 #align category_theory.limits.comp_preserves_finite_colimits CategoryTheory.Limits.compPreservesFiniteColimits
 
+/- Porting note: adding this class because quantified classes don't behave well 
+[#2764](https://github.com/leanprover-community/mathlib4/pull/2764) -/
+/-- A functor `F` preserves finite products if it preserves all from `Discrete J` 
+for `Fintype J` -/
+class PreservesFiniteCoproducts (F : C ⥤  D) where 
+  preserves : ∀ (J : Type) [Fintype J], PreservesColimitsOfShape (Discrete J) F
+
 end CategoryTheory.Limits

024a4231

feat: port CategoryTheory.Limits.Preserves.Finite (#2648)

d1ee6c39

`category_theory.limits.preserves.finite` ⟷ `Mathlib.CategoryTheory.Limits.Preserves.Finite`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 2 + 213

category_theory.limits.preserves.finite ⟷ Mathlib.CategoryTheory.Limits.Preserves.Finite

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 2 + 213

`category_theory.limits.preserves.finite` ⟷ `Mathlib.CategoryTheory.Limits.Preserves.Finite`