category_theory.limits.constructions.zero_objects

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

52a270e2

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

10bf4f82

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2022 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Mathbin.CategoryTheory.Limits.Shapes.Pullbacks
-import Mathbin.CategoryTheory.Limits.Shapes.ZeroMorphisms
-import Mathbin.CategoryTheory.Limits.Constructions.BinaryProducts
+import CategoryTheory.Limits.Shapes.Pullbacks
+import CategoryTheory.Limits.Shapes.ZeroMorphisms
+import CategoryTheory.Limits.Constructions.BinaryProducts
 
 #align_import category_theory.limits.constructions.zero_objects 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,16 +2,13 @@
 Copyright (c) 2022 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module category_theory.limits.constructions.zero_objects
-! 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.Shapes.Pullbacks
 import Mathbin.CategoryTheory.Limits.Shapes.ZeroMorphisms
 import Mathbin.CategoryTheory.Limits.Constructions.BinaryProducts
 
+#align_import category_theory.limits.constructions.zero_objects from "leanprover-community/mathlib"@"10bf4f825ad729c5653adc039dafa3622e7f93c9"
+
 /-!
 # Limits involving zero objects

10bf4f82

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -33,7 +33,7 @@ namespace CategoryTheory.Limits
 
 variable [HasZeroObject C] [HasZeroMorphisms C]
 
-open ZeroObject
+open scoped ZeroObject
 
 #print CategoryTheory.Limits.binaryFanZeroLeft /-
 /-- The limit cone for the product with a zero object. -/

10bf4f82

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -71,10 +71,8 @@ theorem zeroProdIso_hom (X : C) : (zeroProdIso X).Hom = prod.snd :=
 
 #print CategoryTheory.Limits.zeroProdIso_inv_snd /-
 @[simp]
-theorem zeroProdIso_inv_snd (X : C) : (zeroProdIso X).inv ≫ prod.snd = 𝟙 X :=
-  by
-  dsimp [zero_prod_iso, binary_fan_zero_left]
-  simp
+theorem zeroProdIso_inv_snd (X : C) : (zeroProdIso X).inv ≫ prod.snd = 𝟙 X := by
+  dsimp [zero_prod_iso, binary_fan_zero_left]; simp
 #align category_theory.limits.zero_prod_iso_inv_snd CategoryTheory.Limits.zeroProdIso_inv_snd
 -/
 
@@ -114,10 +112,8 @@ theorem prodZeroIso_hom (X : C) : (prodZeroIso X).Hom = prod.fst :=
 
 #print CategoryTheory.Limits.prodZeroIso_iso_inv_snd /-
 @[simp]
-theorem prodZeroIso_iso_inv_snd (X : C) : (prodZeroIso X).inv ≫ prod.fst = 𝟙 X :=
-  by
-  dsimp [prod_zero_iso, binary_fan_zero_right]
-  simp
+theorem prodZeroIso_iso_inv_snd (X : C) : (prodZeroIso X).inv ≫ prod.fst = 𝟙 X := by
+  dsimp [prod_zero_iso, binary_fan_zero_right]; simp
 #align category_theory.limits.prod_zero_iso_iso_inv_snd CategoryTheory.Limits.prodZeroIso_iso_inv_snd
 -/
 
@@ -150,10 +146,8 @@ def zeroCoprodIso (X : C) : (0 : C) ⨿ X ≅ X :=
 
 #print CategoryTheory.Limits.inr_zeroCoprodIso_hom /-
 @[simp]
-theorem inr_zeroCoprodIso_hom (X : C) : coprod.inr ≫ (zeroCoprodIso X).Hom = 𝟙 X :=
-  by
-  dsimp [zero_coprod_iso, binary_cofan_zero_left]
-  simp
+theorem inr_zeroCoprodIso_hom (X : C) : coprod.inr ≫ (zeroCoprodIso X).Hom = 𝟙 X := by
+  dsimp [zero_coprod_iso, binary_cofan_zero_left]; simp
 #align category_theory.limits.inr_zero_coprod_iso_hom CategoryTheory.Limits.inr_zeroCoprodIso_hom
 -/
 
@@ -193,10 +187,8 @@ def coprodZeroIso (X : C) : X ⨿ (0 : C) ≅ X :=
 
 #print CategoryTheory.Limits.inr_coprodZeroIso_hom /-
 @[simp]
-theorem inr_coprodZeroIso_hom (X : C) : coprod.inl ≫ (coprodZeroIso X).Hom = 𝟙 X :=
-  by
-  dsimp [coprod_zero_iso, binary_cofan_zero_right]
-  simp
+theorem inr_coprodZeroIso_hom (X : C) : coprod.inl ≫ (coprodZeroIso X).Hom = 𝟙 X := by
+  dsimp [coprod_zero_iso, binary_cofan_zero_right]; simp
 #align category_theory.limits.inr_coprod_zeroiso_hom CategoryTheory.Limits.inr_coprodZeroIso_hom
 -/
 
@@ -227,9 +219,7 @@ def pullbackZeroZeroIso (X Y : C) [HasBinaryProduct X Y] :
 #print CategoryTheory.Limits.pullbackZeroZeroIso_inv_fst /-
 @[simp]
 theorem pullbackZeroZeroIso_inv_fst (X Y : C) [HasBinaryProduct X Y] :
-    (pullbackZeroZeroIso X Y).inv ≫ pullback.fst = prod.fst :=
-  by
-  dsimp [pullback_zero_zero_iso]
+    (pullbackZeroZeroIso X Y).inv ≫ pullback.fst = prod.fst := by dsimp [pullback_zero_zero_iso];
   simp
 #align category_theory.limits.pullback_zero_zero_iso_inv_fst CategoryTheory.Limits.pullbackZeroZeroIso_inv_fst
 -/
@@ -237,9 +227,7 @@ theorem pullbackZeroZeroIso_inv_fst (X Y : C) [HasBinaryProduct X Y] :
 #print CategoryTheory.Limits.pullbackZeroZeroIso_inv_snd /-
 @[simp]
 theorem pullbackZeroZeroIso_inv_snd (X Y : C) [HasBinaryProduct X Y] :
-    (pullbackZeroZeroIso X Y).inv ≫ pullback.snd = prod.snd :=
-  by
-  dsimp [pullback_zero_zero_iso]
+    (pullbackZeroZeroIso X Y).inv ≫ pullback.snd = prod.snd := by dsimp [pullback_zero_zero_iso];
   simp
 #align category_theory.limits.pullback_zero_zero_iso_inv_snd CategoryTheory.Limits.pullbackZeroZeroIso_inv_snd
 -/
@@ -278,9 +266,7 @@ def pushoutZeroZeroIso (X Y : C) [HasBinaryCoproduct X Y] :
 #print CategoryTheory.Limits.inl_pushoutZeroZeroIso_hom /-
 @[simp]
 theorem inl_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
-    pushout.inl ≫ (pushoutZeroZeroIso X Y).Hom = coprod.inl :=
-  by
-  dsimp [pushout_zero_zero_iso]
+    pushout.inl ≫ (pushoutZeroZeroIso X Y).Hom = coprod.inl := by dsimp [pushout_zero_zero_iso];
   simp
 #align category_theory.limits.inl_pushout_zero_zero_iso_hom CategoryTheory.Limits.inl_pushoutZeroZeroIso_hom
 -/
@@ -288,9 +274,7 @@ theorem inl_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
 #print CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom /-
 @[simp]
 theorem inr_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
-    pushout.inr ≫ (pushoutZeroZeroIso X Y).Hom = coprod.inr :=
-  by
-  dsimp [pushout_zero_zero_iso]
+    pushout.inr ≫ (pushoutZeroZeroIso X Y).Hom = coprod.inr := by dsimp [pushout_zero_zero_iso];
   simp
 #align category_theory.limits.inr_pushout_zero_zero_iso_hom CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom
 -/

10bf4f82

bump to nightly-2023-03-21-20

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

563f4a0b

Diff

@@ -191,13 +191,13 @@ def coprodZeroIso (X : C) : X ⨿ (0 : C) ≅ X :=
 #align category_theory.limits.coprod_zero_iso CategoryTheory.Limits.coprodZeroIso
 -/
 
-#print CategoryTheory.Limits.inr_coprod_zeroiso_hom /-
+#print CategoryTheory.Limits.inr_coprodZeroIso_hom /-
 @[simp]
-theorem inr_coprod_zeroiso_hom (X : C) : coprod.inl ≫ (coprodZeroIso X).Hom = 𝟙 X :=
+theorem inr_coprodZeroIso_hom (X : C) : coprod.inl ≫ (coprodZeroIso X).Hom = 𝟙 X :=
   by
   dsimp [coprod_zero_iso, binary_cofan_zero_right]
   simp
-#align category_theory.limits.inr_coprod_zeroiso_hom CategoryTheory.Limits.inr_coprod_zeroiso_hom
+#align category_theory.limits.inr_coprod_zeroiso_hom CategoryTheory.Limits.inr_coprodZeroIso_hom
 -/
 
 #print CategoryTheory.Limits.coprodZeroIso_inv /-

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: Scott Morrison
 
 ! This file was ported from Lean 3 source module category_theory.limits.constructions.zero_objects
-! leanprover-community/mathlib commit 52a270e2ea4e342c2587c106f8be904524214a4b
+! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.CategoryTheory.Limits.Constructions.BinaryProducts
 /-!
 # Limits involving zero objects
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Binary products and coproducts with a zero object always exist,
 and pullbacks/pushouts over a zero object are products/coproducts.
 -/

52a270e2

bump to nightly-2023-03-13-14

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

a0c9db6f

Diff

@@ -32,143 +32,196 @@ variable [HasZeroObject C] [HasZeroMorphisms C]
 
 open ZeroObject
 
+#print CategoryTheory.Limits.binaryFanZeroLeft /-
 /-- The limit cone for the product with a zero object. -/
 def binaryFanZeroLeft (X : C) : BinaryFan (0 : C) X :=
   BinaryFan.mk 0 (𝟙 X)
 #align category_theory.limits.binary_fan_zero_left CategoryTheory.Limits.binaryFanZeroLeft
+-/
 
+#print CategoryTheory.Limits.binaryFanZeroLeftIsLimit /-
 /-- The limit cone for the product with a zero object is limiting. -/
 def binaryFanZeroLeftIsLimit (X : C) : IsLimit (binaryFanZeroLeft X) :=
   BinaryFan.isLimitMk (fun s => BinaryFan.snd s) (by tidy) (by tidy) (by tidy)
 #align category_theory.limits.binary_fan_zero_left_is_limit CategoryTheory.Limits.binaryFanZeroLeftIsLimit
+-/
 
+#print CategoryTheory.Limits.hasBinaryProduct_zero_left /-
 instance hasBinaryProduct_zero_left (X : C) : HasBinaryProduct (0 : C) X :=
   HasLimit.mk ⟨_, binaryFanZeroLeftIsLimit X⟩
 #align category_theory.limits.has_binary_product_zero_left CategoryTheory.Limits.hasBinaryProduct_zero_left
+-/
 
+#print CategoryTheory.Limits.zeroProdIso /-
 /-- A zero object is a left unit for categorical product. -/
 def zeroProdIso (X : C) : (0 : C) ⨯ X ≅ X :=
   limit.isoLimitCone ⟨_, binaryFanZeroLeftIsLimit X⟩
 #align category_theory.limits.zero_prod_iso CategoryTheory.Limits.zeroProdIso
+-/
 
+#print CategoryTheory.Limits.zeroProdIso_hom /-
 @[simp]
 theorem zeroProdIso_hom (X : C) : (zeroProdIso X).Hom = prod.snd :=
   rfl
 #align category_theory.limits.zero_prod_iso_hom CategoryTheory.Limits.zeroProdIso_hom
+-/
 
+#print CategoryTheory.Limits.zeroProdIso_inv_snd /-
 @[simp]
 theorem zeroProdIso_inv_snd (X : C) : (zeroProdIso X).inv ≫ prod.snd = 𝟙 X :=
   by
   dsimp [zero_prod_iso, binary_fan_zero_left]
   simp
 #align category_theory.limits.zero_prod_iso_inv_snd CategoryTheory.Limits.zeroProdIso_inv_snd
+-/
 
+#print CategoryTheory.Limits.binaryFanZeroRight /-
 /-- The limit cone for the product with a zero object. -/
 def binaryFanZeroRight (X : C) : BinaryFan X (0 : C) :=
   BinaryFan.mk (𝟙 X) 0
 #align category_theory.limits.binary_fan_zero_right CategoryTheory.Limits.binaryFanZeroRight
+-/
 
+#print CategoryTheory.Limits.binaryFanZeroRightIsLimit /-
 /-- The limit cone for the product with a zero object is limiting. -/
 def binaryFanZeroRightIsLimit (X : C) : IsLimit (binaryFanZeroRight X) :=
   BinaryFan.isLimitMk (fun s => BinaryFan.fst s) (by tidy) (by tidy) (by tidy)
 #align category_theory.limits.binary_fan_zero_right_is_limit CategoryTheory.Limits.binaryFanZeroRightIsLimit
+-/
 
+#print CategoryTheory.Limits.hasBinaryProduct_zero_right /-
 instance hasBinaryProduct_zero_right (X : C) : HasBinaryProduct X (0 : C) :=
   HasLimit.mk ⟨_, binaryFanZeroRightIsLimit X⟩
 #align category_theory.limits.has_binary_product_zero_right CategoryTheory.Limits.hasBinaryProduct_zero_right
+-/
 
+#print CategoryTheory.Limits.prodZeroIso /-
 /-- A zero object is a right unit for categorical product. -/
 def prodZeroIso (X : C) : X ⨯ (0 : C) ≅ X :=
   limit.isoLimitCone ⟨_, binaryFanZeroRightIsLimit X⟩
 #align category_theory.limits.prod_zero_iso CategoryTheory.Limits.prodZeroIso
+-/
 
+#print CategoryTheory.Limits.prodZeroIso_hom /-
 @[simp]
 theorem prodZeroIso_hom (X : C) : (prodZeroIso X).Hom = prod.fst :=
   rfl
 #align category_theory.limits.prod_zero_iso_hom CategoryTheory.Limits.prodZeroIso_hom
+-/
 
+#print CategoryTheory.Limits.prodZeroIso_iso_inv_snd /-
 @[simp]
 theorem prodZeroIso_iso_inv_snd (X : C) : (prodZeroIso X).inv ≫ prod.fst = 𝟙 X :=
   by
   dsimp [prod_zero_iso, binary_fan_zero_right]
   simp
 #align category_theory.limits.prod_zero_iso_iso_inv_snd CategoryTheory.Limits.prodZeroIso_iso_inv_snd
+-/
 
+#print CategoryTheory.Limits.binaryCofanZeroLeft /-
 /-- The colimit cocone for the coproduct with a zero object. -/
 def binaryCofanZeroLeft (X : C) : BinaryCofan (0 : C) X :=
   BinaryCofan.mk 0 (𝟙 X)
 #align category_theory.limits.binary_cofan_zero_left CategoryTheory.Limits.binaryCofanZeroLeft
+-/
 
+#print CategoryTheory.Limits.binaryCofanZeroLeftIsColimit /-
 /-- The colimit cocone for the coproduct with a zero object is colimiting. -/
 def binaryCofanZeroLeftIsColimit (X : C) : IsColimit (binaryCofanZeroLeft X) :=
   BinaryCofan.isColimitMk (fun s => BinaryCofan.inr s) (by tidy) (by tidy) (by tidy)
 #align category_theory.limits.binary_cofan_zero_left_is_colimit CategoryTheory.Limits.binaryCofanZeroLeftIsColimit
+-/
 
+#print CategoryTheory.Limits.hasBinaryCoproduct_zero_left /-
 instance hasBinaryCoproduct_zero_left (X : C) : HasBinaryCoproduct (0 : C) X :=
   HasColimit.mk ⟨_, binaryCofanZeroLeftIsColimit X⟩
 #align category_theory.limits.has_binary_coproduct_zero_left CategoryTheory.Limits.hasBinaryCoproduct_zero_left
+-/
 
+#print CategoryTheory.Limits.zeroCoprodIso /-
 /-- A zero object is a left unit for categorical coproduct. -/
 def zeroCoprodIso (X : C) : (0 : C) ⨿ X ≅ X :=
   colimit.isoColimitCocone ⟨_, binaryCofanZeroLeftIsColimit X⟩
 #align category_theory.limits.zero_coprod_iso CategoryTheory.Limits.zeroCoprodIso
+-/
 
+#print CategoryTheory.Limits.inr_zeroCoprodIso_hom /-
 @[simp]
 theorem inr_zeroCoprodIso_hom (X : C) : coprod.inr ≫ (zeroCoprodIso X).Hom = 𝟙 X :=
   by
   dsimp [zero_coprod_iso, binary_cofan_zero_left]
   simp
 #align category_theory.limits.inr_zero_coprod_iso_hom CategoryTheory.Limits.inr_zeroCoprodIso_hom
+-/
 
+#print CategoryTheory.Limits.zeroCoprodIso_inv /-
 @[simp]
 theorem zeroCoprodIso_inv (X : C) : (zeroCoprodIso X).inv = coprod.inr :=
   rfl
 #align category_theory.limits.zero_coprod_iso_inv CategoryTheory.Limits.zeroCoprodIso_inv
+-/
 
+#print CategoryTheory.Limits.binaryCofanZeroRight /-
 /-- The colimit cocone for the coproduct with a zero object. -/
 def binaryCofanZeroRight (X : C) : BinaryCofan X (0 : C) :=
   BinaryCofan.mk (𝟙 X) 0
 #align category_theory.limits.binary_cofan_zero_right CategoryTheory.Limits.binaryCofanZeroRight
+-/
 
+#print CategoryTheory.Limits.binaryCofanZeroRightIsColimit /-
 /-- The colimit cocone for the coproduct with a zero object is colimiting. -/
 def binaryCofanZeroRightIsColimit (X : C) : IsColimit (binaryCofanZeroRight X) :=
   BinaryCofan.isColimitMk (fun s => BinaryCofan.inl s) (by tidy) (by tidy) (by tidy)
 #align category_theory.limits.binary_cofan_zero_right_is_colimit CategoryTheory.Limits.binaryCofanZeroRightIsColimit
+-/
 
+#print CategoryTheory.Limits.hasBinaryCoproduct_zero_right /-
 instance hasBinaryCoproduct_zero_right (X : C) : HasBinaryCoproduct X (0 : C) :=
   HasColimit.mk ⟨_, binaryCofanZeroRightIsColimit X⟩
 #align category_theory.limits.has_binary_coproduct_zero_right CategoryTheory.Limits.hasBinaryCoproduct_zero_right
+-/
 
+#print CategoryTheory.Limits.coprodZeroIso /-
 /-- A zero object is a right unit for categorical coproduct. -/
 def coprodZeroIso (X : C) : X ⨿ (0 : C) ≅ X :=
   colimit.isoColimitCocone ⟨_, binaryCofanZeroRightIsColimit X⟩
 #align category_theory.limits.coprod_zero_iso CategoryTheory.Limits.coprodZeroIso
+-/
 
+#print CategoryTheory.Limits.inr_coprod_zeroiso_hom /-
 @[simp]
 theorem inr_coprod_zeroiso_hom (X : C) : coprod.inl ≫ (coprodZeroIso X).Hom = 𝟙 X :=
   by
   dsimp [coprod_zero_iso, binary_cofan_zero_right]
   simp
 #align category_theory.limits.inr_coprod_zeroiso_hom CategoryTheory.Limits.inr_coprod_zeroiso_hom
+-/
 
+#print CategoryTheory.Limits.coprodZeroIso_inv /-
 @[simp]
 theorem coprodZeroIso_inv (X : C) : (coprodZeroIso X).inv = coprod.inl :=
   rfl
 #align category_theory.limits.coprod_zero_iso_inv CategoryTheory.Limits.coprodZeroIso_inv
+-/
 
+#print CategoryTheory.Limits.hasPullback_over_zero /-
 instance hasPullback_over_zero (X Y : C) [HasBinaryProduct X Y] :
     HasPullback (0 : X ⟶ 0) (0 : Y ⟶ 0) :=
   HasLimit.mk
     ⟨_, isPullbackOfIsTerminalIsProduct _ _ _ _ HasZeroObject.zeroIsTerminal (prodIsProd X Y)⟩
 #align category_theory.limits.has_pullback_over_zero CategoryTheory.Limits.hasPullback_over_zero
+-/
 
+#print CategoryTheory.Limits.pullbackZeroZeroIso /-
 /-- The pullback over the zeron object is the product. -/
 def pullbackZeroZeroIso (X Y : C) [HasBinaryProduct X Y] :
     pullback (0 : X ⟶ 0) (0 : Y ⟶ 0) ≅ X ⨯ Y :=
   limit.isoLimitCone
     ⟨_, isPullbackOfIsTerminalIsProduct _ _ _ _ HasZeroObject.zeroIsTerminal (prodIsProd X Y)⟩
 #align category_theory.limits.pullback_zero_zero_iso CategoryTheory.Limits.pullbackZeroZeroIso
+-/
 
+#print CategoryTheory.Limits.pullbackZeroZeroIso_inv_fst /-
 @[simp]
 theorem pullbackZeroZeroIso_inv_fst (X Y : C) [HasBinaryProduct X Y] :
     (pullbackZeroZeroIso X Y).inv ≫ pullback.fst = prod.fst :=
@@ -176,7 +229,9 @@ theorem pullbackZeroZeroIso_inv_fst (X Y : C) [HasBinaryProduct X Y] :
   dsimp [pullback_zero_zero_iso]
   simp
 #align category_theory.limits.pullback_zero_zero_iso_inv_fst CategoryTheory.Limits.pullbackZeroZeroIso_inv_fst
+-/
 
+#print CategoryTheory.Limits.pullbackZeroZeroIso_inv_snd /-
 @[simp]
 theorem pullbackZeroZeroIso_inv_snd (X Y : C) [HasBinaryProduct X Y] :
     (pullbackZeroZeroIso X Y).inv ≫ pullback.snd = prod.snd :=
@@ -184,30 +239,40 @@ theorem pullbackZeroZeroIso_inv_snd (X Y : C) [HasBinaryProduct X Y] :
   dsimp [pullback_zero_zero_iso]
   simp
 #align category_theory.limits.pullback_zero_zero_iso_inv_snd CategoryTheory.Limits.pullbackZeroZeroIso_inv_snd
+-/
 
+#print CategoryTheory.Limits.pullbackZeroZeroIso_hom_fst /-
 @[simp]
 theorem pullbackZeroZeroIso_hom_fst (X Y : C) [HasBinaryProduct X Y] :
     (pullbackZeroZeroIso X Y).Hom ≫ prod.fst = pullback.fst := by simp [← iso.eq_inv_comp]
 #align category_theory.limits.pullback_zero_zero_iso_hom_fst CategoryTheory.Limits.pullbackZeroZeroIso_hom_fst
+-/
 
+#print CategoryTheory.Limits.pullbackZeroZeroIso_hom_snd /-
 @[simp]
 theorem pullbackZeroZeroIso_hom_snd (X Y : C) [HasBinaryProduct X Y] :
     (pullbackZeroZeroIso X Y).Hom ≫ prod.snd = pullback.snd := by simp [← iso.eq_inv_comp]
 #align category_theory.limits.pullback_zero_zero_iso_hom_snd CategoryTheory.Limits.pullbackZeroZeroIso_hom_snd
+-/
 
+#print CategoryTheory.Limits.hasPushout_over_zero /-
 instance hasPushout_over_zero (X Y : C) [HasBinaryCoproduct X Y] :
     HasPushout (0 : 0 ⟶ X) (0 : 0 ⟶ Y) :=
   HasColimit.mk
     ⟨_, isPushoutOfIsInitialIsCoproduct _ _ _ _ HasZeroObject.zeroIsInitial (coprodIsCoprod X Y)⟩
 #align category_theory.limits.has_pushout_over_zero CategoryTheory.Limits.hasPushout_over_zero
+-/
 
+#print CategoryTheory.Limits.pushoutZeroZeroIso /-
 /-- The pushout over the zero object is the coproduct. -/
 def pushoutZeroZeroIso (X Y : C) [HasBinaryCoproduct X Y] :
     pushout (0 : 0 ⟶ X) (0 : 0 ⟶ Y) ≅ X ⨿ Y :=
   colimit.isoColimitCocone
     ⟨_, isPushoutOfIsInitialIsCoproduct _ _ _ _ HasZeroObject.zeroIsInitial (coprodIsCoprod X Y)⟩
 #align category_theory.limits.pushout_zero_zero_iso CategoryTheory.Limits.pushoutZeroZeroIso
+-/
 
+#print CategoryTheory.Limits.inl_pushoutZeroZeroIso_hom /-
 @[simp]
 theorem inl_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
     pushout.inl ≫ (pushoutZeroZeroIso X Y).Hom = coprod.inl :=
@@ -215,7 +280,9 @@ theorem inl_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
   dsimp [pushout_zero_zero_iso]
   simp
 #align category_theory.limits.inl_pushout_zero_zero_iso_hom CategoryTheory.Limits.inl_pushoutZeroZeroIso_hom
+-/
 
+#print CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom /-
 @[simp]
 theorem inr_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
     pushout.inr ≫ (pushoutZeroZeroIso X Y).Hom = coprod.inr :=
@@ -223,16 +290,21 @@ theorem inr_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
   dsimp [pushout_zero_zero_iso]
   simp
 #align category_theory.limits.inr_pushout_zero_zero_iso_hom CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom
+-/
 
+#print CategoryTheory.Limits.inl_pushoutZeroZeroIso_inv /-
 @[simp]
 theorem inl_pushoutZeroZeroIso_inv (X Y : C) [HasBinaryCoproduct X Y] :
     coprod.inl ≫ (pushoutZeroZeroIso X Y).inv = pushout.inl := by simp [iso.comp_inv_eq]
 #align category_theory.limits.inl_pushout_zero_zero_iso_inv CategoryTheory.Limits.inl_pushoutZeroZeroIso_inv
+-/
 
+#print CategoryTheory.Limits.inr_pushoutZeroZeroIso_inv /-
 @[simp]
 theorem inr_pushoutZeroZeroIso_inv (X Y : C) [HasBinaryCoproduct X Y] :
     coprod.inr ≫ (pushoutZeroZeroIso X Y).inv = pushout.inr := by simp [iso.comp_inv_eq]
 #align category_theory.limits.inr_pushout_zero_zero_iso_inv CategoryTheory.Limits.inr_pushoutZeroZeroIso_inv
+-/
 
 end CategoryTheory.Limits

52a270e2

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

52a270e2

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -21,7 +21,7 @@ noncomputable section
 
 open CategoryTheory
 
-variable {C : Type _} [Category C]
+variable {C : Type*} [Category C]
 
 namespace CategoryTheory.Limits

52a270e2

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,16 +2,13 @@
 Copyright (c) 2022 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module category_theory.limits.constructions.zero_objects
-! leanprover-community/mathlib commit 52a270e2ea4e342c2587c106f8be904524214a4b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
 import Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms
 import Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts
 
+#align_import category_theory.limits.constructions.zero_objects from "leanprover-community/mathlib"@"52a270e2ea4e342c2587c106f8be904524214a4b"
+
 /-!
 # Limits involving zero objects

52a270e2

chore: fix many typos (#4967)

These are all doc fixes

6f9e51c3

Diff

@@ -162,7 +162,7 @@ instance hasPullback_over_zero (X Y : C) [HasBinaryProduct X Y] :
     ⟨_, isPullbackOfIsTerminalIsProduct _ _ _ _ HasZeroObject.zeroIsTerminal (prodIsProd X Y)⟩
 #align category_theory.limits.has_pullback_over_zero CategoryTheory.Limits.hasPullback_over_zero
 
-/-- The pullback over the zeron object is the product. -/
+/-- The pullback over the zero object is the product. -/
 def pullbackZeroZeroIso (X Y : C) [HasBinaryProduct X Y] :
     pullback (0 : X ⟶ 0) (0 : Y ⟶ 0) ≅ X ⨯ Y :=
   limit.isoLimitCone

52a270e2

chore: reenable eta, bump to nightly 2023-05-16 (#3414)

Now that leanprover/lean4#2210 has been merged, this PR:

removes all the set_option synthInstance.etaExperiment true commands (and some etaExperiment% term elaborators)
removes many but not quite all set_option maxHeartbeats commands
makes various other changes required to cope with leanprover/lean4#2210.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Matthew Ballard <matt@mrb.email>

a6e1045f

Diff

@@ -71,7 +71,7 @@ def binaryFanZeroRight (X : C) : BinaryFan X (0 : C) :=
 /-- The limit cone for the product with a zero object is limiting. -/
 def binaryFanZeroRightIsLimit (X : C) : IsLimit (binaryFanZeroRight X) :=
   BinaryFan.isLimitMk (fun s => BinaryFan.fst s) (by aesop_cat) (by aesop_cat)
-    (fun s m h₁ => by simpa using h₁)
+    (fun s m h₁ _ => by simpa using h₁)
 #align category_theory.limits.binary_fan_zero_right_is_limit CategoryTheory.Limits.binaryFanZeroRightIsLimit
 
 instance hasBinaryProduct_zero_right (X : C) : HasBinaryProduct X (0 : C) :=

52a270e2

chore: tidy various files (#2999)

f02ff00e

Diff

@@ -146,10 +146,10 @@ def coprodZeroIso (X : C) : X ⨿ (0 : C) ≅ X :=
 #align category_theory.limits.coprod_zero_iso CategoryTheory.Limits.coprodZeroIso
 
 @[simp]
-theorem inr_coprod_zeroiso_hom (X : C) : coprod.inl ≫ (coprodZeroIso X).hom = 𝟙 X := by
+theorem inr_coprodZeroIso_hom (X : C) : coprod.inl ≫ (coprodZeroIso X).hom = 𝟙 X := by
   dsimp [coprodZeroIso, binaryCofanZeroRight]
   simp
-#align category_theory.limits.inr_coprod_zeroiso_hom CategoryTheory.Limits.inr_coprod_zeroiso_hom
+#align category_theory.limits.inr_coprod_zeroiso_hom CategoryTheory.Limits.inr_coprodZeroIso_hom
 
 @[simp]
 theorem coprodZeroIso_inv (X : C) : (coprodZeroIso X).inv = coprod.inl :=

52a270e2

feat: port CategoryTheory.Limits.Constructions.ZeroObjects (#2823)

8a946eea

`category_theory.limits.constructions.zero_objects` ⟷ `Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 121

category_theory.limits.constructions.zero_objects ⟷ Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 121

`category_theory.limits.constructions.zero_objects` ⟷ `Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects`