category_theory.limits.preserves.opposites

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

9ed43666

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

10bf4f82

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -64,7 +64,7 @@ def preservesLimitLeftOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ Dᵒᵖ) [PreservesColim
 def preservesLimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesColimit K.op F] :
     PreservesLimit K F.rightOp
     where preserves c hc :=
-    isLimitConeRightOpOfCocone _ (isColimitOfPreserves F (isColimitConeOp _ hc))
+    isLimitConeRightOpOfCocone _ (isColimitOfPreserves F (CategoryTheory.Limits.IsLimit.op _ hc))
 #align category_theory.limits.preserves_limit_right_op CategoryTheory.Limits.preservesLimitRightOp
 -/
 
@@ -74,7 +74,7 @@ def preservesLimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesColimit K.
 def preservesLimitUnop (K : J ⥤ C) (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesColimit K.op F] :
     PreservesLimit K F.unop
     where preserves c hc :=
-    isLimitConeUnopOfCocone _ (isColimitOfPreserves F (isColimitConeOp _ hc))
+    isLimitConeUnopOfCocone _ (isColimitOfPreserves F (CategoryTheory.Limits.IsLimit.op _ hc))
 #align category_theory.limits.preserves_limit_unop CategoryTheory.Limits.preservesLimitUnop
 -/
 
@@ -104,7 +104,7 @@ def preservesColimitLeftOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ Dᵒᵖ) [PreservesLim
 def preservesColimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesLimit K.op F] :
     PreservesColimit K F.rightOp
     where preserves c hc :=
-    isColimitCoconeRightOpOfCone _ (isLimitOfPreserves F (isLimitCoconeOp _ hc))
+    isColimitCoconeRightOpOfCone _ (isLimitOfPreserves F (CategoryTheory.Limits.IsColimit.op _ hc))
 #align category_theory.limits.preserves_colimit_right_op CategoryTheory.Limits.preservesColimitRightOp
 -/
 
@@ -114,7 +114,7 @@ def preservesColimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesLimit K.
 def preservesColimitUnop (K : J ⥤ C) (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesLimit K.op F] :
     PreservesColimit K F.unop
     where preserves c hc :=
-    isColimitCoconeUnopOfCone _ (isLimitOfPreserves F (isLimitCoconeOp _ hc))
+    isColimitCoconeUnopOfCone _ (isLimitOfPreserves F (CategoryTheory.Limits.IsColimit.op _ hc))
 #align category_theory.limits.preserves_colimit_unop CategoryTheory.Limits.preservesColimitUnop
 -/

10bf4f82

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) 2022 Markus Himmel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Markus Himmel
 -/
-import Mathbin.CategoryTheory.Limits.Opposites
-import Mathbin.CategoryTheory.Limits.Preserves.Finite
+import CategoryTheory.Limits.Opposites
+import CategoryTheory.Limits.Preserves.Finite
 
 #align_import category_theory.limits.preserves.opposites from "leanprover-community/mathlib"@"10bf4f825ad729c5653adc039dafa3622e7f93c9"

10bf4f82

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) 2022 Markus Himmel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Markus Himmel
-
-! This file was ported from Lean 3 source module category_theory.limits.preserves.opposites
-! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Limits.Opposites
 import Mathbin.CategoryTheory.Limits.Preserves.Finite
 
+#align_import category_theory.limits.preserves.opposites from "leanprover-community/mathlib"@"10bf4f825ad729c5653adc039dafa3622e7f93c9"
+
 /-!
 # Limit preservation properties of `functor.op` and related constructions

10bf4f82

bump to nightly-2023-03-16-03

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

8ae28b0b

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Markus Himmel
 
 ! This file was ported from Lean 3 source module category_theory.limits.preserves.opposites
-! leanprover-community/mathlib commit 9ed4366659f4fcca0ee70310d26ac5518dcb6dd0
+! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
 ! 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.Limits.Preserves.Finite
 /-!
 # Limit preservation properties of `functor.op` and related constructions
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We formulate conditions about `F` which imply that `F.op`, `F.unop`, `F.left_op` and `F.right_op`
 preserve certain (co)limits.

9ed43666

bump to nightly-2023-03-13-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/2af0836443b4cfb5feda0df0051acdb398304931

a0c9db6f

Diff

@@ -39,13 +39,16 @@ variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
 
 variable {J : Type w} [Category.{w'} J]
 
+#print CategoryTheory.Limits.preservesLimitOp /-
 /-- If `F : C ⥤ D` preserves colimits of `K.left_op : Jᵒᵖ ⥤ C`, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves
     limits of `K : J ⥤ Cᵒᵖ`. -/
 def preservesLimitOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ D) [PreservesColimit K.leftOp F] : PreservesLimit K F.op
     where preserves c hc :=
     isLimitConeRightOpOfCocone _ (isColimitOfPreserves F (isColimitCoconeLeftOpOfCone _ hc))
 #align category_theory.limits.preserves_limit_op CategoryTheory.Limits.preservesLimitOp
+-/
 
+#print CategoryTheory.Limits.preservesLimitLeftOp /-
 /-- If `F : C ⥤ Dᵒᵖ` preserves colimits of `K.left_op : Jᵒᵖ ⥤ C`, then `F.left_op : Cᵒᵖ ⥤ D`
     preserves limits of `K : J ⥤ Cᵒᵖ`. -/
 def preservesLimitLeftOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ Dᵒᵖ) [PreservesColimit K.leftOp F] :
@@ -53,7 +56,9 @@ def preservesLimitLeftOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ Dᵒᵖ) [PreservesColim
     where preserves c hc :=
     isLimitConeUnopOfCocone _ (isColimitOfPreserves F (isColimitCoconeLeftOpOfCone _ hc))
 #align category_theory.limits.preserves_limit_left_op CategoryTheory.Limits.preservesLimitLeftOp
+-/
 
+#print CategoryTheory.Limits.preservesLimitRightOp /-
 /-- If `F : Cᵒᵖ ⥤ D` preserves colimits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.right_op : C ⥤ Dᵒᵖ` preserves
     limits of `K : J ⥤ C`. -/
 def preservesLimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesColimit K.op F] :
@@ -61,7 +66,9 @@ def preservesLimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesColimit K.
     where preserves c hc :=
     isLimitConeRightOpOfCocone _ (isColimitOfPreserves F (isColimitConeOp _ hc))
 #align category_theory.limits.preserves_limit_right_op CategoryTheory.Limits.preservesLimitRightOp
+-/
 
+#print CategoryTheory.Limits.preservesLimitUnop /-
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves colimits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.unop : C ⥤ D` preserves
     limits of `K : J ⥤ C`. -/
 def preservesLimitUnop (K : J ⥤ C) (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesColimit K.op F] :
@@ -69,7 +76,9 @@ def preservesLimitUnop (K : J ⥤ C) (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesColimit
     where preserves c hc :=
     isLimitConeUnopOfCocone _ (isColimitOfPreserves F (isColimitConeOp _ hc))
 #align category_theory.limits.preserves_limit_unop CategoryTheory.Limits.preservesLimitUnop
+-/
 
+#print CategoryTheory.Limits.preservesColimitOp /-
 /-- If `F : C ⥤ D` preserves limits of `K.left_op : Jᵒᵖ ⥤ C`, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves
     colimits of `K : J ⥤ Cᵒᵖ`. -/
 def preservesColimitOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ D) [PreservesLimit K.leftOp F] :
@@ -77,7 +86,9 @@ def preservesColimitOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ D) [PreservesLimit K.leftO
     where preserves c hc :=
     isColimitCoconeRightOpOfCone _ (isLimitOfPreserves F (isLimitConeLeftOpOfCocone _ hc))
 #align category_theory.limits.preserves_colimit_op CategoryTheory.Limits.preservesColimitOp
+-/
 
+#print CategoryTheory.Limits.preservesColimitLeftOp /-
 /-- If `F : C ⥤ Dᵒᵖ` preserves limits of `K.left_op : Jᵒᵖ ⥤ C`, then `F.left_op : Cᵒᵖ ⥤ D` preserves
     colimits of `K : J ⥤ Cᵒᵖ`. -/
 def preservesColimitLeftOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ Dᵒᵖ) [PreservesLimit K.leftOp F] :
@@ -85,7 +96,9 @@ def preservesColimitLeftOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ Dᵒᵖ) [PreservesLim
     where preserves c hc :=
     isColimitCoconeUnopOfCone _ (isLimitOfPreserves F (isLimitConeLeftOpOfCocone _ hc))
 #align category_theory.limits.preserves_colimit_left_op CategoryTheory.Limits.preservesColimitLeftOp
+-/
 
+#print CategoryTheory.Limits.preservesColimitRightOp /-
 /-- If `F : Cᵒᵖ ⥤ D` preserves limits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.right_op : C ⥤ Dᵒᵖ` preserves
     colimits of `K : J ⥤ C`. -/
 def preservesColimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesLimit K.op F] :
@@ -93,7 +106,9 @@ def preservesColimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesLimit K.
     where preserves c hc :=
     isColimitCoconeRightOpOfCone _ (isLimitOfPreserves F (isLimitCoconeOp _ hc))
 #align category_theory.limits.preserves_colimit_right_op CategoryTheory.Limits.preservesColimitRightOp
+-/
 
+#print CategoryTheory.Limits.preservesColimitUnop /-
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.unop : C ⥤ D` preserves
     colimits of `K : J ⥤ C`. -/
 def preservesColimitUnop (K : J ⥤ C) (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesLimit K.op F] :
@@ -101,100 +116,133 @@ def preservesColimitUnop (K : J ⥤ C) (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesLimit
     where preserves c hc :=
     isColimitCoconeUnopOfCone _ (isLimitOfPreserves F (isLimitCoconeOp _ hc))
 #align category_theory.limits.preserves_colimit_unop CategoryTheory.Limits.preservesColimitUnop
+-/
 
 section
 
 variable (J)
 
+#print CategoryTheory.Limits.preservesLimitsOfShapeOp /-
 /-- If `F : C ⥤ D` preserves colimits of shape `Jᵒᵖ`, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits of
     shape `J`. -/
 def preservesLimitsOfShapeOp (F : C ⥤ D) [PreservesColimitsOfShape Jᵒᵖ F] :
     PreservesLimitsOfShape J F.op where PreservesLimit K := preservesLimitOp K F
 #align category_theory.limits.preserves_limits_of_shape_op CategoryTheory.Limits.preservesLimitsOfShapeOp
+-/
 
+#print CategoryTheory.Limits.preservesLimitsOfShapeLeftOp /-
 /-- If `F : C ⥤ Dᵒᵖ` preserves colimits of shape `Jᵒᵖ`, then `F.left_op : Cᵒᵖ ⥤ D` preserves limits
     of shape `J`. -/
 def preservesLimitsOfShapeLeftOp (F : C ⥤ Dᵒᵖ) [PreservesColimitsOfShape Jᵒᵖ F] :
     PreservesLimitsOfShape J F.leftOp where PreservesLimit K := preservesLimitLeftOp K F
 #align category_theory.limits.preserves_limits_of_shape_left_op CategoryTheory.Limits.preservesLimitsOfShapeLeftOp
+-/
 
+#print CategoryTheory.Limits.preservesLimitsOfShapeRightOp /-
 /-- If `F : Cᵒᵖ ⥤ D` preserves colimits of shape `Jᵒᵖ`, then `F.right_op : C ⥤ Dᵒᵖ` preserves limits
     of shape `J`. -/
 def preservesLimitsOfShapeRightOp (F : Cᵒᵖ ⥤ D) [PreservesColimitsOfShape Jᵒᵖ F] :
     PreservesLimitsOfShape J F.rightOp where PreservesLimit K := preservesLimitRightOp K F
 #align category_theory.limits.preserves_limits_of_shape_right_op CategoryTheory.Limits.preservesLimitsOfShapeRightOp
+-/
 
+#print CategoryTheory.Limits.preservesLimitsOfShapeUnop /-
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves colimits of shape `Jᵒᵖ`, then `F.unop : C ⥤ D` preserves limits of
     shape `J`. -/
 def preservesLimitsOfShapeUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesColimitsOfShape Jᵒᵖ F] :
     PreservesLimitsOfShape J F.unop where PreservesLimit K := preservesLimitUnop K F
 #align category_theory.limits.preserves_limits_of_shape_unop CategoryTheory.Limits.preservesLimitsOfShapeUnop
+-/
 
+#print CategoryTheory.Limits.preservesColimitsOfShapeOp /-
 /-- If `F : C ⥤ D` preserves limits of shape `Jᵒᵖ`, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves colimits of
     shape `J`. -/
 def preservesColimitsOfShapeOp (F : C ⥤ D) [PreservesLimitsOfShape Jᵒᵖ F] :
     PreservesColimitsOfShape J F.op where PreservesColimit K := preservesColimitOp K F
 #align category_theory.limits.preserves_colimits_of_shape_op CategoryTheory.Limits.preservesColimitsOfShapeOp
+-/
 
+#print CategoryTheory.Limits.preservesColimitsOfShapeLeftOp /-
 /-- If `F : C ⥤ Dᵒᵖ` preserves limits of shape `Jᵒᵖ`, then `F.left_op : Cᵒᵖ ⥤ D` preserves colimits
     of shape `J`. -/
 def preservesColimitsOfShapeLeftOp (F : C ⥤ Dᵒᵖ) [PreservesLimitsOfShape Jᵒᵖ F] :
     PreservesColimitsOfShape J F.leftOp where PreservesColimit K := preservesColimitLeftOp K F
 #align category_theory.limits.preserves_colimits_of_shape_left_op CategoryTheory.Limits.preservesColimitsOfShapeLeftOp
+-/
 
+#print CategoryTheory.Limits.preservesColimitsOfShapeRightOp /-
 /-- If `F : Cᵒᵖ ⥤ D` preserves limits of shape `Jᵒᵖ`, then `F.right_op : C ⥤ Dᵒᵖ` preserves colimits
     of shape `J`. -/
 def preservesColimitsOfShapeRightOp (F : Cᵒᵖ ⥤ D) [PreservesLimitsOfShape Jᵒᵖ F] :
     PreservesColimitsOfShape J F.rightOp where PreservesColimit K := preservesColimitRightOp K F
 #align category_theory.limits.preserves_colimits_of_shape_right_op CategoryTheory.Limits.preservesColimitsOfShapeRightOp
+-/
 
+#print CategoryTheory.Limits.preservesColimitsOfShapeUnop /-
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits of shape `Jᵒᵖ`, then `F.unop : C ⥤ D` preserves colimits
     of shape `J`. -/
 def preservesColimitsOfShapeUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesLimitsOfShape Jᵒᵖ F] :
     PreservesColimitsOfShape J F.unop where PreservesColimit K := preservesColimitUnop K F
 #align category_theory.limits.preserves_colimits_of_shape_unop CategoryTheory.Limits.preservesColimitsOfShapeUnop
+-/
 
 end
 
+#print CategoryTheory.Limits.preservesLimitsOp /-
 /-- If `F : C ⥤ D` preserves colimits, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits. -/
 def preservesLimitsOp (F : C ⥤ D) [PreservesColimits F] : PreservesLimits F.op
     where PreservesLimitsOfShape J _ := preserves_limits_of_shape_op J F
 #align category_theory.limits.preserves_limits_op CategoryTheory.Limits.preservesLimitsOp
+-/
 
+#print CategoryTheory.Limits.preservesLimitsLeftOp /-
 /-- If `F : C ⥤ Dᵒᵖ` preserves colimits, then `F.left_op : Cᵒᵖ ⥤ D` preserves limits. -/
 def preservesLimitsLeftOp (F : C ⥤ Dᵒᵖ) [PreservesColimits F] : PreservesLimits F.leftOp
     where PreservesLimitsOfShape J _ := preserves_limits_of_shape_left_op J F
 #align category_theory.limits.preserves_limits_left_op CategoryTheory.Limits.preservesLimitsLeftOp
+-/
 
+#print CategoryTheory.Limits.preservesLimitsRightOp /-
 /-- If `F : Cᵒᵖ ⥤ D` preserves colimits, then `F.right_op : C ⥤ Dᵒᵖ` preserves limits. -/
 def preservesLimitsRightOp (F : Cᵒᵖ ⥤ D) [PreservesColimits F] : PreservesLimits F.rightOp
     where PreservesLimitsOfShape J _ := preserves_limits_of_shape_right_op J F
 #align category_theory.limits.preserves_limits_right_op CategoryTheory.Limits.preservesLimitsRightOp
+-/
 
+#print CategoryTheory.Limits.preservesLimitsUnop /-
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves colimits, then `F.unop : C ⥤ D` preserves limits. -/
 def preservesLimitsUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesColimits F] : PreservesLimits F.unop
     where PreservesLimitsOfShape J _ := preserves_limits_of_shape_unop J F
 #align category_theory.limits.preserves_limits_unop CategoryTheory.Limits.preservesLimitsUnop
+-/
 
+#print CategoryTheory.Limits.perservesColimitsOp /-
 /-- If `F : C ⥤ D` preserves limits, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves colimits. -/
 def perservesColimitsOp (F : C ⥤ D) [PreservesLimits F] : PreservesColimits F.op
     where PreservesColimitsOfShape J _ := preserves_colimits_of_shape_op J F
 #align category_theory.limits.perserves_colimits_op CategoryTheory.Limits.perservesColimitsOp
+-/
 
+#print CategoryTheory.Limits.preservesColimitsLeftOp /-
 /-- If `F : C ⥤ Dᵒᵖ` preserves limits, then `F.left_op : Cᵒᵖ ⥤ D` preserves colimits. -/
 def preservesColimitsLeftOp (F : C ⥤ Dᵒᵖ) [PreservesLimits F] : PreservesColimits F.leftOp
     where PreservesColimitsOfShape J _ := preserves_colimits_of_shape_left_op J F
 #align category_theory.limits.preserves_colimits_left_op CategoryTheory.Limits.preservesColimitsLeftOp
+-/
 
+#print CategoryTheory.Limits.preservesColimitsRightOp /-
 /-- If `F : Cᵒᵖ ⥤ D` preserves limits, then `F.right_op : C ⥤ Dᵒᵖ` preserves colimits. -/
 def preservesColimitsRightOp (F : Cᵒᵖ ⥤ D) [PreservesLimits F] : PreservesColimits F.rightOp
     where PreservesColimitsOfShape J _ := preserves_colimits_of_shape_right_op J F
 #align category_theory.limits.preserves_colimits_right_op CategoryTheory.Limits.preservesColimitsRightOp
+-/
 
+#print CategoryTheory.Limits.preservesColimitsUnop /-
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits, then `F.unop : C ⥤ D` preserves colimits. -/
 def preservesColimitsUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesLimits F] : PreservesColimits F.unop
     where PreservesColimitsOfShape J _ := preserves_colimits_of_shape_unop J F
 #align category_theory.limits.preserves_colimits_unop CategoryTheory.Limits.preservesColimitsUnop
+-/
 
 end
 
@@ -204,59 +252,75 @@ section
 -- universe.
 variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₁} D]
 
+#print CategoryTheory.Limits.preservesFiniteLimitsOp /-
 /-- If `F : C ⥤ D` preserves finite colimits, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite
     limits. -/
 def preservesFiniteLimitsOp (F : C ⥤ D) [PreservesFiniteColimits F] : PreservesFiniteLimits F.op
     where PreservesFiniteLimits J _ _ := preserves_limits_of_shape_op J F
 #align category_theory.limits.preserves_finite_limits_op CategoryTheory.Limits.preservesFiniteLimitsOp
+-/
 
+#print CategoryTheory.Limits.preservesFiniteLimitsLeftOp /-
 /-- If `F : C ⥤ Dᵒᵖ` preserves finite colimits, then `F.left_op : Cᵒᵖ ⥤ D` preserves finite
     limits. -/
 def preservesFiniteLimitsLeftOp (F : C ⥤ Dᵒᵖ) [PreservesFiniteColimits F] :
     PreservesFiniteLimits F.leftOp
     where PreservesFiniteLimits J _ _ := preserves_limits_of_shape_left_op J F
 #align category_theory.limits.preserves_finite_limits_left_op CategoryTheory.Limits.preservesFiniteLimitsLeftOp
+-/
 
+#print CategoryTheory.Limits.preservesFiniteLimitsRightOp /-
 /-- If `F : Cᵒᵖ ⥤ D` preserves finite colimits, then `F.right_op : C ⥤ Dᵒᵖ` preserves finite
     limits. -/
 def preservesFiniteLimitsRightOp (F : Cᵒᵖ ⥤ D) [PreservesFiniteColimits F] :
     PreservesFiniteLimits F.rightOp
     where PreservesFiniteLimits J _ _ := preserves_limits_of_shape_right_op J F
 #align category_theory.limits.preserves_finite_limits_right_op CategoryTheory.Limits.preservesFiniteLimitsRightOp
+-/
 
+#print CategoryTheory.Limits.preservesFiniteLimitsUnop /-
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite colimits, then `F.unop : C ⥤ D` preserves finite
     limits. -/
 def preservesFiniteLimitsUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesFiniteColimits F] :
     PreservesFiniteLimits F.unop
     where PreservesFiniteLimits J _ _ := preserves_limits_of_shape_unop J F
 #align category_theory.limits.preserves_finite_limits_unop CategoryTheory.Limits.preservesFiniteLimitsUnop
+-/
 
+#print CategoryTheory.Limits.preservesFiniteColimitsOp /-
 /-- If `F : C ⥤ D` preserves finite limits, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite
     colimits. -/
 def preservesFiniteColimitsOp (F : C ⥤ D) [PreservesFiniteLimits F] : PreservesFiniteColimits F.op
     where PreservesFiniteColimits J _ _ := preserves_colimits_of_shape_op J F
 #align category_theory.limits.preserves_finite_colimits_op CategoryTheory.Limits.preservesFiniteColimitsOp
+-/
 
+#print CategoryTheory.Limits.preservesFiniteColimitsLeftOp /-
 /-- If `F : C ⥤ Dᵒᵖ` preserves finite limits, then `F.left_op : Cᵒᵖ ⥤ D` preserves finite
     colimits. -/
 def preservesFiniteColimitsLeftOp (F : C ⥤ Dᵒᵖ) [PreservesFiniteLimits F] :
     PreservesFiniteColimits F.leftOp
     where PreservesFiniteColimits J _ _ := preserves_colimits_of_shape_left_op J F
 #align category_theory.limits.preserves_finite_colimits_left_op CategoryTheory.Limits.preservesFiniteColimitsLeftOp
+-/
 
+#print CategoryTheory.Limits.preservesFiniteColimitsRightOp /-
 /-- If `F : Cᵒᵖ ⥤ D` preserves finite limits, then `F.right_op : C ⥤ Dᵒᵖ` preserves finite
     colimits. -/
 def preservesFiniteColimitsRightOp (F : Cᵒᵖ ⥤ D) [PreservesFiniteLimits F] :
     PreservesFiniteColimits F.rightOp
     where PreservesFiniteColimits J _ _ := preserves_colimits_of_shape_right_op J F
 #align category_theory.limits.preserves_finite_colimits_right_op CategoryTheory.Limits.preservesFiniteColimitsRightOp
+-/
 
+#print CategoryTheory.Limits.preservesFiniteColimitsUnop /-
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite limits, then `F.unop : C ⥤ D` preserves finite
     colimits. -/
 def preservesFiniteColimitsUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesFiniteLimits F] :
     PreservesFiniteColimits F.unop
     where PreservesFiniteColimits J _ _ := preserves_colimits_of_shape_unop J F
 #align category_theory.limits.preserves_finite_colimits_unop CategoryTheory.Limits.preservesFiniteColimitsUnop
+-/
 
 end

9ed43666

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

9ed43666

chore: remove duplicates of IsLimit.op and variants (#11683)

d5876416

Diff

@@ -56,7 +56,7 @@ def preservesLimitLeftOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ Dᵒᵖ) [PreservesColim
 def preservesLimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesColimit K.op F] :
     PreservesLimit K F.rightOp where
   preserves {_} hc :=
-    isLimitConeRightOpOfCocone _ (isColimitOfPreserves F (isColimitConeOp _ hc))
+    isLimitConeRightOpOfCocone _ (isColimitOfPreserves F hc.op)
 #align category_theory.limits.preserves_limit_right_op CategoryTheory.Limits.preservesLimitRightOp
 
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves colimits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.unop : C ⥤ D` preserves
@@ -64,7 +64,7 @@ def preservesLimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesColimit K.
 def preservesLimitUnop (K : J ⥤ C) (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesColimit K.op F] :
     PreservesLimit K F.unop where
   preserves {_} hc :=
-    isLimitConeUnopOfCocone _ (isColimitOfPreserves F (isColimitConeOp _ hc))
+    isLimitConeUnopOfCocone _ (isColimitOfPreserves F hc.op)
 #align category_theory.limits.preserves_limit_unop CategoryTheory.Limits.preservesLimitUnop
 
 /-- If `F : C ⥤ D` preserves limits of `K.left_op : Jᵒᵖ ⥤ C`, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves
@@ -88,7 +88,7 @@ def preservesColimitLeftOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ Dᵒᵖ) [PreservesLim
 def preservesColimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesLimit K.op F] :
     PreservesColimit K F.rightOp where
   preserves {_} hc :=
-    isColimitCoconeRightOpOfCone _ (isLimitOfPreserves F (isLimitCoconeOp _ hc))
+    isColimitCoconeRightOpOfCone _ (isLimitOfPreserves F hc.op)
 #align category_theory.limits.preserves_colimit_right_op CategoryTheory.Limits.preservesColimitRightOp
 
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.unop : C ⥤ D` preserves
@@ -96,7 +96,7 @@ def preservesColimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesLimit K.
 def preservesColimitUnop (K : J ⥤ C) (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesLimit K.op F] :
     PreservesColimit K F.unop where
   preserves {_} hc :=
-    isColimitCoconeUnopOfCone _ (isLimitOfPreserves F (isLimitCoconeOp _ hc))
+    isColimitCoconeUnopOfCone _ (isLimitOfPreserves F hc.op)
 #align category_theory.limits.preserves_colimit_unop CategoryTheory.Limits.preservesColimitUnop
 
 section

9ed43666

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

@@ -33,7 +33,6 @@ namespace CategoryTheory.Limits
 section
 
 variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
-
 variable {J : Type w} [Category.{w'} J]
 
 /-- If `F : C ⥤ D` preserves colimits of `K.left_op : Jᵒᵖ ⥤ C`, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves

9ed43666

style: fix wrapping of where (#7149)

084cfb35

Diff

@@ -38,64 +38,65 @@ variable {J : Type w} [Category.{w'} J]
 
 /-- If `F : C ⥤ D` preserves colimits of `K.left_op : Jᵒᵖ ⥤ C`, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves
     limits of `K : J ⥤ Cᵒᵖ`. -/
-def preservesLimitOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ D) [PreservesColimit K.leftOp F] : PreservesLimit K F.op
-    where preserves {_} hc :=
+def preservesLimitOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ D) [PreservesColimit K.leftOp F] :
+    PreservesLimit K F.op where
+  preserves {_} hc :=
     isLimitConeRightOpOfCocone _ (isColimitOfPreserves F (isColimitCoconeLeftOpOfCone _ hc))
 #align category_theory.limits.preserves_limit_op CategoryTheory.Limits.preservesLimitOp
 
 /-- If `F : C ⥤ Dᵒᵖ` preserves colimits of `K.left_op : Jᵒᵖ ⥤ C`, then `F.left_op : Cᵒᵖ ⥤ D`
     preserves limits of `K : J ⥤ Cᵒᵖ`. -/
 def preservesLimitLeftOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ Dᵒᵖ) [PreservesColimit K.leftOp F] :
-    PreservesLimit K F.leftOp
-    where preserves {_} hc :=
+    PreservesLimit K F.leftOp where
+  preserves {_} hc :=
     isLimitConeUnopOfCocone _ (isColimitOfPreserves F (isColimitCoconeLeftOpOfCone _ hc))
 #align category_theory.limits.preserves_limit_left_op CategoryTheory.Limits.preservesLimitLeftOp
 
 /-- If `F : Cᵒᵖ ⥤ D` preserves colimits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.right_op : C ⥤ Dᵒᵖ` preserves
     limits of `K : J ⥤ C`. -/
 def preservesLimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesColimit K.op F] :
-    PreservesLimit K F.rightOp
-    where preserves {_} hc :=
+    PreservesLimit K F.rightOp where
+  preserves {_} hc :=
     isLimitConeRightOpOfCocone _ (isColimitOfPreserves F (isColimitConeOp _ hc))
 #align category_theory.limits.preserves_limit_right_op CategoryTheory.Limits.preservesLimitRightOp
 
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves colimits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.unop : C ⥤ D` preserves
     limits of `K : J ⥤ C`. -/
 def preservesLimitUnop (K : J ⥤ C) (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesColimit K.op F] :
-    PreservesLimit K F.unop
-    where preserves {_} hc :=
+    PreservesLimit K F.unop where
+  preserves {_} hc :=
     isLimitConeUnopOfCocone _ (isColimitOfPreserves F (isColimitConeOp _ hc))
 #align category_theory.limits.preserves_limit_unop CategoryTheory.Limits.preservesLimitUnop
 
 /-- If `F : C ⥤ D` preserves limits of `K.left_op : Jᵒᵖ ⥤ C`, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves
     colimits of `K : J ⥤ Cᵒᵖ`. -/
 def preservesColimitOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ D) [PreservesLimit K.leftOp F] :
-    PreservesColimit K F.op
-    where preserves {_} hc :=
+    PreservesColimit K F.op where
+  preserves {_} hc :=
     isColimitCoconeRightOpOfCone _ (isLimitOfPreserves F (isLimitConeLeftOpOfCocone _ hc))
 #align category_theory.limits.preserves_colimit_op CategoryTheory.Limits.preservesColimitOp
 
 /-- If `F : C ⥤ Dᵒᵖ` preserves limits of `K.left_op : Jᵒᵖ ⥤ C`, then `F.left_op : Cᵒᵖ ⥤ D` preserves
     colimits of `K : J ⥤ Cᵒᵖ`. -/
 def preservesColimitLeftOp (K : J ⥤ Cᵒᵖ) (F : C ⥤ Dᵒᵖ) [PreservesLimit K.leftOp F] :
-    PreservesColimit K F.leftOp
-    where preserves {_} hc :=
+    PreservesColimit K F.leftOp where
+  preserves {_} hc :=
     isColimitCoconeUnopOfCone _ (isLimitOfPreserves F (isLimitConeLeftOpOfCocone _ hc))
 #align category_theory.limits.preserves_colimit_left_op CategoryTheory.Limits.preservesColimitLeftOp
 
 /-- If `F : Cᵒᵖ ⥤ D` preserves limits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.right_op : C ⥤ Dᵒᵖ` preserves
     colimits of `K : J ⥤ C`. -/
 def preservesColimitRightOp (K : J ⥤ C) (F : Cᵒᵖ ⥤ D) [PreservesLimit K.op F] :
-    PreservesColimit K F.rightOp
-    where preserves {_} hc :=
+    PreservesColimit K F.rightOp where
+  preserves {_} hc :=
     isColimitCoconeRightOpOfCone _ (isLimitOfPreserves F (isLimitCoconeOp _ hc))
 #align category_theory.limits.preserves_colimit_right_op CategoryTheory.Limits.preservesColimitRightOp
 
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.unop : C ⥤ D` preserves
     colimits of `K : J ⥤ C`. -/
 def preservesColimitUnop (K : J ⥤ C) (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesLimit K.op F] :
-    PreservesColimit K F.unop
-    where preserves {_} hc :=
+    PreservesColimit K F.unop where
+  preserves {_} hc :=
     isColimitCoconeUnopOfCone _ (isLimitOfPreserves F (isLimitCoconeOp _ hc))
 #align category_theory.limits.preserves_colimit_unop CategoryTheory.Limits.preservesColimitUnop
 
@@ -154,43 +155,43 @@ def preservesColimitsOfShapeUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesLimitsOfSha
 end
 
 /-- If `F : C ⥤ D` preserves colimits, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits. -/
-def preservesLimitsOp (F : C ⥤ D) [PreservesColimits F] : PreservesLimits F.op
-    where preservesLimitsOfShape {_} _ := preservesLimitsOfShapeOp _ _
+def preservesLimitsOp (F : C ⥤ D) [PreservesColimits F] : PreservesLimits F.op where
+  preservesLimitsOfShape {_} _ := preservesLimitsOfShapeOp _ _
 #align category_theory.limits.preserves_limits_op CategoryTheory.Limits.preservesLimitsOp
 
 /-- If `F : C ⥤ Dᵒᵖ` preserves colimits, then `F.left_op : Cᵒᵖ ⥤ D` preserves limits. -/
-def preservesLimitsLeftOp (F : C ⥤ Dᵒᵖ) [PreservesColimits F] : PreservesLimits F.leftOp
-    where preservesLimitsOfShape {_} _ := preservesLimitsOfShapeLeftOp _ _
+def preservesLimitsLeftOp (F : C ⥤ Dᵒᵖ) [PreservesColimits F] : PreservesLimits F.leftOp where
+  preservesLimitsOfShape {_} _ := preservesLimitsOfShapeLeftOp _ _
 #align category_theory.limits.preserves_limits_left_op CategoryTheory.Limits.preservesLimitsLeftOp
 
 /-- If `F : Cᵒᵖ ⥤ D` preserves colimits, then `F.right_op : C ⥤ Dᵒᵖ` preserves limits. -/
-def preservesLimitsRightOp (F : Cᵒᵖ ⥤ D) [PreservesColimits F] : PreservesLimits F.rightOp
-    where preservesLimitsOfShape {_} _ := preservesLimitsOfShapeRightOp _ _
+def preservesLimitsRightOp (F : Cᵒᵖ ⥤ D) [PreservesColimits F] : PreservesLimits F.rightOp where
+  preservesLimitsOfShape {_} _ := preservesLimitsOfShapeRightOp _ _
 #align category_theory.limits.preserves_limits_right_op CategoryTheory.Limits.preservesLimitsRightOp
 
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves colimits, then `F.unop : C ⥤ D` preserves limits. -/
-def preservesLimitsUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesColimits F] : PreservesLimits F.unop
-    where preservesLimitsOfShape {_} _ := preservesLimitsOfShapeUnop _ _
+def preservesLimitsUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesColimits F] : PreservesLimits F.unop where
+  preservesLimitsOfShape {_} _ := preservesLimitsOfShapeUnop _ _
 #align category_theory.limits.preserves_limits_unop CategoryTheory.Limits.preservesLimitsUnop
 
 /-- If `F : C ⥤ D` preserves limits, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves colimits. -/
-def perservesColimitsOp (F : C ⥤ D) [PreservesLimits F] : PreservesColimits F.op
-    where preservesColimitsOfShape {_} _ := preservesColimitsOfShapeOp _ _
+def perservesColimitsOp (F : C ⥤ D) [PreservesLimits F] : PreservesColimits F.op where
+  preservesColimitsOfShape {_} _ := preservesColimitsOfShapeOp _ _
 #align category_theory.limits.perserves_colimits_op CategoryTheory.Limits.perservesColimitsOp
 
 /-- If `F : C ⥤ Dᵒᵖ` preserves limits, then `F.left_op : Cᵒᵖ ⥤ D` preserves colimits. -/
-def preservesColimitsLeftOp (F : C ⥤ Dᵒᵖ) [PreservesLimits F] : PreservesColimits F.leftOp
-    where preservesColimitsOfShape {_} _ := preservesColimitsOfShapeLeftOp _ _
+def preservesColimitsLeftOp (F : C ⥤ Dᵒᵖ) [PreservesLimits F] : PreservesColimits F.leftOp where
+  preservesColimitsOfShape {_} _ := preservesColimitsOfShapeLeftOp _ _
 #align category_theory.limits.preserves_colimits_left_op CategoryTheory.Limits.preservesColimitsLeftOp
 
 /-- If `F : Cᵒᵖ ⥤ D` preserves limits, then `F.right_op : C ⥤ Dᵒᵖ` preserves colimits. -/
-def preservesColimitsRightOp (F : Cᵒᵖ ⥤ D) [PreservesLimits F] : PreservesColimits F.rightOp
-    where preservesColimitsOfShape {_} _ := preservesColimitsOfShapeRightOp _ _
+def preservesColimitsRightOp (F : Cᵒᵖ ⥤ D) [PreservesLimits F] : PreservesColimits F.rightOp where
+  preservesColimitsOfShape {_} _ := preservesColimitsOfShapeRightOp _ _
 #align category_theory.limits.preserves_colimits_right_op CategoryTheory.Limits.preservesColimitsRightOp
 
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves limits, then `F.unop : C ⥤ D` preserves colimits. -/
-def preservesColimitsUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesLimits F] : PreservesColimits F.unop
-    where preservesColimitsOfShape {_} _ := preservesColimitsOfShapeUnop _ _
+def preservesColimitsUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesLimits F] : PreservesColimits F.unop where
+  preservesColimitsOfShape {_} _ := preservesColimitsOfShapeUnop _ _
 #align category_theory.limits.preserves_colimits_unop CategoryTheory.Limits.preservesColimitsUnop
 
 end
@@ -203,56 +204,58 @@ variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₁} D]
 
 /-- If `F : C ⥤ D` preserves finite colimits, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite
     limits. -/
-def preservesFiniteLimitsOp (F : C ⥤ D) [PreservesFiniteColimits F] : PreservesFiniteLimits F.op
-    where preservesFiniteLimits J (_ : SmallCategory J) _ := preservesLimitsOfShapeOp J F
+def preservesFiniteLimitsOp (F : C ⥤ D) [PreservesFiniteColimits F] :
+    PreservesFiniteLimits F.op where
+  preservesFiniteLimits J (_ : SmallCategory J) _ := preservesLimitsOfShapeOp J F
 #align category_theory.limits.preserves_finite_limits_op CategoryTheory.Limits.preservesFiniteLimitsOp
 
 /-- If `F : C ⥤ Dᵒᵖ` preserves finite colimits, then `F.left_op : Cᵒᵖ ⥤ D` preserves finite
     limits. -/
 def preservesFiniteLimitsLeftOp (F : C ⥤ Dᵒᵖ) [PreservesFiniteColimits F] :
-    PreservesFiniteLimits F.leftOp
-    where preservesFiniteLimits J (_ : SmallCategory J) _ := preservesLimitsOfShapeLeftOp J F
+    PreservesFiniteLimits F.leftOp where
+  preservesFiniteLimits J (_ : SmallCategory J) _ := preservesLimitsOfShapeLeftOp J F
 #align category_theory.limits.preserves_finite_limits_left_op CategoryTheory.Limits.preservesFiniteLimitsLeftOp
 
 /-- If `F : Cᵒᵖ ⥤ D` preserves finite colimits, then `F.right_op : C ⥤ Dᵒᵖ` preserves finite
     limits. -/
 def preservesFiniteLimitsRightOp (F : Cᵒᵖ ⥤ D) [PreservesFiniteColimits F] :
-    PreservesFiniteLimits F.rightOp
-    where preservesFiniteLimits J (_ : SmallCategory J) _ := preservesLimitsOfShapeRightOp J F
+    PreservesFiniteLimits F.rightOp where
+  preservesFiniteLimits J (_ : SmallCategory J) _ := preservesLimitsOfShapeRightOp J F
 #align category_theory.limits.preserves_finite_limits_right_op CategoryTheory.Limits.preservesFiniteLimitsRightOp
 
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite colimits, then `F.unop : C ⥤ D` preserves finite
     limits. -/
 def preservesFiniteLimitsUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesFiniteColimits F] :
-    PreservesFiniteLimits F.unop
-    where preservesFiniteLimits J (_ : SmallCategory J) _ := preservesLimitsOfShapeUnop J F
+    PreservesFiniteLimits F.unop where
+  preservesFiniteLimits J (_ : SmallCategory J) _ := preservesLimitsOfShapeUnop J F
 #align category_theory.limits.preserves_finite_limits_unop CategoryTheory.Limits.preservesFiniteLimitsUnop
 
 /-- If `F : C ⥤ D` preserves finite limits, then `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite
     colimits. -/
-def preservesFiniteColimitsOp (F : C ⥤ D) [PreservesFiniteLimits F] : PreservesFiniteColimits F.op
-    where preservesFiniteColimits J (_ : SmallCategory J) _ := preservesColimitsOfShapeOp J F
+def preservesFiniteColimitsOp (F : C ⥤ D) [PreservesFiniteLimits F] :
+    PreservesFiniteColimits F.op where
+  preservesFiniteColimits J (_ : SmallCategory J) _ := preservesColimitsOfShapeOp J F
 #align category_theory.limits.preserves_finite_colimits_op CategoryTheory.Limits.preservesFiniteColimitsOp
 
 /-- If `F : C ⥤ Dᵒᵖ` preserves finite limits, then `F.left_op : Cᵒᵖ ⥤ D` preserves finite
     colimits. -/
 def preservesFiniteColimitsLeftOp (F : C ⥤ Dᵒᵖ) [PreservesFiniteLimits F] :
-    PreservesFiniteColimits F.leftOp
-    where preservesFiniteColimits J (_ : SmallCategory J) _ := preservesColimitsOfShapeLeftOp J F
+    PreservesFiniteColimits F.leftOp where
+  preservesFiniteColimits J (_ : SmallCategory J) _ := preservesColimitsOfShapeLeftOp J F
 #align category_theory.limits.preserves_finite_colimits_left_op CategoryTheory.Limits.preservesFiniteColimitsLeftOp
 
 /-- If `F : Cᵒᵖ ⥤ D` preserves finite limits, then `F.right_op : C ⥤ Dᵒᵖ` preserves finite
     colimits. -/
 def preservesFiniteColimitsRightOp (F : Cᵒᵖ ⥤ D) [PreservesFiniteLimits F] :
-    PreservesFiniteColimits F.rightOp
-    where preservesFiniteColimits J (_ : SmallCategory J) _ := preservesColimitsOfShapeRightOp J F
+    PreservesFiniteColimits F.rightOp where
+  preservesFiniteColimits J (_ : SmallCategory J) _ := preservesColimitsOfShapeRightOp J F
 #align category_theory.limits.preserves_finite_colimits_right_op CategoryTheory.Limits.preservesFiniteColimitsRightOp
 
 /-- If `F : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite limits, then `F.unop : C ⥤ D` preserves finite
     colimits. -/
 def preservesFiniteColimitsUnop (F : Cᵒᵖ ⥤ Dᵒᵖ) [PreservesFiniteLimits F] :
-    PreservesFiniteColimits F.unop
-    where preservesFiniteColimits J (_ : SmallCategory J) _ := preservesColimitsOfShapeUnop J F
+    PreservesFiniteColimits F.unop where
+  preservesFiniteColimits J (_ : SmallCategory J) _ := preservesColimitsOfShapeUnop J F
 #align category_theory.limits.preserves_finite_colimits_unop CategoryTheory.Limits.preservesFiniteColimitsUnop
 
 end

9ed43666

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) 2022 Markus Himmel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Markus Himmel
-
-! This file was ported from Lean 3 source module category_theory.limits.preserves.opposites
-! leanprover-community/mathlib commit 9ed4366659f4fcca0ee70310d26ac5518dcb6dd0
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Limits.Opposites
 import Mathlib.CategoryTheory.Limits.Preserves.Finite
 
+#align_import category_theory.limits.preserves.opposites from "leanprover-community/mathlib"@"9ed4366659f4fcca0ee70310d26ac5518dcb6dd0"
+
 /-!
 # Limit preservation properties of `functor.op` and related constructions

9ed43666

feat: port CategoryTheory.Limits.Preserves.Opposites (#2826)

ec210bab

`category_theory.limits.preserves.opposites` ⟷ `Mathlib.CategoryTheory.Limits.Preserves.Opposites`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 2 + 241

category_theory.limits.preserves.opposites ⟷ Mathlib.CategoryTheory.Limits.Preserves.Opposites

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 2 + 241

`category_theory.limits.preserves.opposites` ⟷ `Mathlib.CategoryTheory.Limits.Preserves.Opposites`