category_theory.limits.shapes.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

74333bd5

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

f4758115

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Johan Commelin
 -/
-import Mathbin.CategoryTheory.Limits.Shapes.Terminal
+import CategoryTheory.Limits.Shapes.Terminal
 
 #align_import category_theory.limits.shapes.zero_objects from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"

f4758115

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Johan Commelin
-
-! This file was ported from Lean 3 source module category_theory.limits.shapes.zero_objects
-! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Limits.Shapes.Terminal
 
+#align_import category_theory.limits.shapes.zero_objects from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
+
 /-!
 # Zero objects

f4758115

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -181,6 +181,7 @@ theorem Iso.isZero_iff {X Y : C} (e : X ≅ Y) : IsZero X ↔ IsZero Y :=
 #align category_theory.iso.is_zero_iff CategoryTheory.Iso.isZero_iff
 -/
 
+#print CategoryTheory.Functor.isZero /-
 theorem Functor.isZero (F : C ⥤ D) (hF : ∀ X, IsZero (F.obj X)) : IsZero F :=
   by
   constructor <;> intro G <;> refine' ⟨⟨⟨_⟩, _⟩⟩
@@ -195,6 +196,7 @@ theorem Functor.isZero (F : C ⥤ D) (hF : ∀ X, IsZero (F.obj X)) : IsZero F :
     intros; exact (hF _).eq_of_tgt _ _
   · intro f; ext; apply (hF _).eq_of_tgt _ _
 #align category_theory.functor.is_zero CategoryTheory.Functor.isZero
+-/
 
 namespace Limits
 
@@ -263,6 +265,7 @@ def IsZero.isoZero [HasZeroObject C] {X : C} (hX : IsZero X) : X ≅ 0 :=
 #align category_theory.limits.is_zero.iso_zero CategoryTheory.Limits.IsZero.isoZero
 -/
 
+#print CategoryTheory.Limits.IsZero.obj /-
 theorem IsZero.obj [HasZeroObject D] {F : C ⥤ D} (hF : IsZero F) (X : C) : IsZero (F.obj X) :=
   by
   let G : C ⥤ D := (CategoryTheory.Functor.const C).obj 0
@@ -270,6 +273,7 @@ theorem IsZero.obj [HasZeroObject D] {F : C ⥤ D} (hF : IsZero F) (X : C) : IsZ
   let e : F ≅ G := hF.iso hG
   exact (is_zero_zero _).of_iso (e.app X)
 #align category_theory.limits.is_zero.obj CategoryTheory.Limits.IsZero.obj
+-/
 
 namespace HasZeroObject
 
@@ -389,9 +393,11 @@ open CategoryTheory.Limits
 
 open scoped ZeroObject
 
+#print CategoryTheory.Functor.isZero_iff /-
 theorem Functor.isZero_iff [HasZeroObject D] (F : C ⥤ D) : IsZero F ↔ ∀ X, IsZero (F.obj X) :=
   ⟨fun hF X => hF.obj X, Functor.isZero _⟩
 #align category_theory.functor.is_zero_iff CategoryTheory.Functor.isZero_iff
+-/
 
 end CategoryTheory

f4758115

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -187,12 +187,12 @@ theorem Functor.isZero (F : C ⥤ D) (hF : ∀ X, IsZero (F.obj X)) : IsZero F :
   · refine'
       { app := fun X => (hF _).to _
         naturality' := _ }
-    intros ; exact (hF _).eq_of_src _ _
+    intros; exact (hF _).eq_of_src _ _
   · intro f; ext; apply (hF _).eq_of_src _ _
   · refine'
       { app := fun X => (hF _).from _
         naturality' := _ }
-    intros ; exact (hF _).eq_of_tgt _ _
+    intros; exact (hF _).eq_of_tgt _ _
   · intro f; ext; apply (hF _).eq_of_tgt _ _
 #align category_theory.functor.is_zero CategoryTheory.Functor.isZero

f4758115

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -240,7 +240,7 @@ instance hasZeroObject_op : HasZeroObject Cᵒᵖ :=
 
 end
 
-open ZeroObject
+open scoped ZeroObject
 
 #print CategoryTheory.Limits.hasZeroObject_unop /-
 theorem hasZeroObject_unop [HasZeroObject Cᵒᵖ] : HasZeroObject C :=
@@ -387,7 +387,7 @@ end Limits
 
 open CategoryTheory.Limits
 
-open ZeroObject
+open scoped ZeroObject
 
 theorem Functor.isZero_iff [HasZeroObject D] (F : C ⥤ D) : IsZero F ↔ ∀ X, IsZero (F.obj X) :=
   ⟨fun hF X => hF.obj X, Functor.isZero _⟩

f4758115

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -181,12 +181,6 @@ theorem Iso.isZero_iff {X Y : C} (e : X ≅ Y) : IsZero X ↔ IsZero Y :=
 #align category_theory.iso.is_zero_iff CategoryTheory.Iso.isZero_iff
 -/
 
-/- warning: category_theory.functor.is_zero -> CategoryTheory.Functor.isZero is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] (F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2), (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (CategoryTheory.Functor.obj.{u1, u3, u2, u4} C _inst_1 D _inst_2 F X)) -> (CategoryTheory.Limits.IsZero.{max u2 u3, max u1 u3 u2 u4} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F)
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] (F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2), (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (Prefunctor.obj.{succ u1, succ u3, u2, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u4} D (CategoryTheory.Category.toCategoryStruct.{u3, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u2, u4} C _inst_1 D _inst_2 F) X)) -> (CategoryTheory.Limits.IsZero.{max u2 u3, max (max (max u2 u4) u1) u3} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F)
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.is_zero CategoryTheory.Functor.isZeroₓ'. -/
 theorem Functor.isZero (F : C ⥤ D) (hF : ∀ X, IsZero (F.obj X)) : IsZero F :=
   by
   constructor <;> intro G <;> refine' ⟨⟨⟨_⟩, _⟩⟩
@@ -269,12 +263,6 @@ def IsZero.isoZero [HasZeroObject C] {X : C} (hX : IsZero X) : X ≅ 0 :=
 #align category_theory.limits.is_zero.iso_zero CategoryTheory.Limits.IsZero.isoZero
 -/
 
-/- warning: category_theory.limits.is_zero.obj -> CategoryTheory.Limits.IsZero.obj is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] [_inst_3 : CategoryTheory.Limits.HasZeroObject.{u3, u4} D _inst_2] {F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2}, (CategoryTheory.Limits.IsZero.{max u2 u3, max u1 u3 u2 u4} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F) -> (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (CategoryTheory.Functor.obj.{u1, u3, u2, u4} C _inst_1 D _inst_2 F X))
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] [_inst_3 : CategoryTheory.Limits.HasZeroObject.{u3, u4} D _inst_2] {F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2}, (CategoryTheory.Limits.IsZero.{max u2 u3, max (max (max u2 u4) u1) u3} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F) -> (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (Prefunctor.obj.{succ u1, succ u3, u2, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u4} D (CategoryTheory.Category.toCategoryStruct.{u3, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u2, u4} C _inst_1 D _inst_2 F) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.limits.is_zero.obj CategoryTheory.Limits.IsZero.objₓ'. -/
 theorem IsZero.obj [HasZeroObject D] {F : C ⥤ D} (hF : IsZero F) (X : C) : IsZero (F.obj X) :=
   by
   let G : C ⥤ D := (CategoryTheory.Functor.const C).obj 0
@@ -401,12 +389,6 @@ open CategoryTheory.Limits
 
 open ZeroObject
 
-/- warning: category_theory.functor.is_zero_iff -> CategoryTheory.Functor.isZero_iff is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] [_inst_3 : CategoryTheory.Limits.HasZeroObject.{u3, u4} D _inst_2] (F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2), Iff (CategoryTheory.Limits.IsZero.{max u2 u3, max u1 u3 u2 u4} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F) (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (CategoryTheory.Functor.obj.{u1, u3, u2, u4} C _inst_1 D _inst_2 F X))
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] [_inst_3 : CategoryTheory.Limits.HasZeroObject.{u3, u4} D _inst_2] (F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2), Iff (CategoryTheory.Limits.IsZero.{max u2 u3, max (max (max u2 u4) u1) u3} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F) (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (Prefunctor.obj.{succ u1, succ u3, u2, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u4} D (CategoryTheory.Category.toCategoryStruct.{u3, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u2, u4} C _inst_1 D _inst_2 F) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.is_zero_iff CategoryTheory.Functor.isZero_iffₓ'. -/
 theorem Functor.isZero_iff [HasZeroObject D] (F : C ⥤ D) : IsZero F ↔ ∀ X, IsZero (F.obj X) :=
   ⟨fun hF X => hF.obj X, Functor.isZero _⟩
 #align category_theory.functor.is_zero_iff CategoryTheory.Functor.isZero_iff

f4758115

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -150,10 +150,8 @@ def isoIsTerminal (hX : IsZero X) (hY : IsTerminal Y) : X ≅ Y :=
 theorem of_iso (hY : IsZero Y) (e : X ≅ Y) : IsZero X :=
   by
   refine' ⟨fun Z => ⟨⟨⟨e.hom ≫ hY.to Z⟩, fun f => _⟩⟩, fun Z => ⟨⟨⟨hY.from Z ≫ e.inv⟩, fun f => _⟩⟩⟩
-  · rw [← cancel_epi e.inv]
-    apply hY.eq_of_src
-  · rw [← cancel_mono e.hom]
-    apply hY.eq_of_tgt
+  · rw [← cancel_epi e.inv]; apply hY.eq_of_src
+  · rw [← cancel_mono e.hom]; apply hY.eq_of_tgt
 #align category_theory.limits.is_zero.of_iso CategoryTheory.Limits.IsZero.of_iso
 -/
 
@@ -195,19 +193,13 @@ theorem Functor.isZero (F : C ⥤ D) (hF : ∀ X, IsZero (F.obj X)) : IsZero F :
   · refine'
       { app := fun X => (hF _).to _
         naturality' := _ }
-    intros
-    exact (hF _).eq_of_src _ _
-  · intro f
-    ext
-    apply (hF _).eq_of_src _ _
+    intros ; exact (hF _).eq_of_src _ _
+  · intro f; ext; apply (hF _).eq_of_src _ _
   · refine'
       { app := fun X => (hF _).from _
         naturality' := _ }
-    intros
-    exact (hF _).eq_of_tgt _ _
-  · intro f
-    ext
-    apply (hF _).eq_of_tgt _ _
+    intros ; exact (hF _).eq_of_tgt _ _
+  · intro f; ext; apply (hF _).eq_of_tgt _ _
 #align category_theory.functor.is_zero CategoryTheory.Functor.isZero
 
 namespace Limits

f4758115

bump to nightly-2023-03-09-16

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

75cac28a

Diff

@@ -230,15 +230,15 @@ section
 
 variable [HasZeroObject C]
 
-#print CategoryTheory.Limits.HasZeroObject.hasZero /-
+#print CategoryTheory.Limits.HasZeroObject.zero' /-
 /-- Construct a `has_zero C` for a category with a zero object.
 This can not be a global instance as it will trigger for every `has_zero C` typeclass search.
 -/
-protected def HasZeroObject.hasZero : Zero C where zero := HasZeroObject.zero.some
-#align category_theory.limits.has_zero_object.has_zero CategoryTheory.Limits.HasZeroObject.hasZero
+protected def HasZeroObject.zero' : Zero C where zero := HasZeroObject.zero.some
+#align category_theory.limits.has_zero_object.has_zero CategoryTheory.Limits.HasZeroObject.zero'
 -/
 
-scoped[ZeroObject] attribute [instance] CategoryTheory.Limits.HasZeroObject.hasZero
+scoped[ZeroObject] attribute [instance] CategoryTheory.Limits.HasZeroObject.zero'
 
 #print CategoryTheory.Limits.isZero_zero /-
 theorem isZero_zero : IsZero (0 : C) :=
@@ -395,10 +395,10 @@ def zeroIsoTerminal [HasTerminal C] : 0 ≅ ⊤_ C :=
 #align category_theory.limits.has_zero_object.zero_iso_terminal CategoryTheory.Limits.HasZeroObject.zeroIsoTerminal
 -/
 
-#print CategoryTheory.Limits.HasZeroObject.has_strict_initial /-
-instance (priority := 100) has_strict_initial : InitialMonoClass C :=
+#print CategoryTheory.Limits.HasZeroObject.initialMonoClass /-
+instance (priority := 100) initialMonoClass : InitialMonoClass C :=
   InitialMonoClass.of_isInitial zeroIsInitial fun X => CategoryTheory.mono _
-#align category_theory.limits.has_zero_object.has_strict_initial CategoryTheory.Limits.HasZeroObject.has_strict_initial
+#align category_theory.limits.has_zero_object.has_strict_initial CategoryTheory.Limits.HasZeroObject.initialMonoClass
 -/
 
 end HasZeroObject

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: Scott Morrison, Johan Commelin
 
 ! This file was ported from Lean 3 source module category_theory.limits.shapes.zero_objects
-! leanprover-community/mathlib commit 74333bd53d25b6809203a2bfae80eea5fc1fc076
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.CategoryTheory.Limits.Shapes.Terminal
 /-!
 # Zero objects
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 A category "has a zero object" if it has an object which is both initial and terminal. Having a
 zero object provides zero morphisms, as the unique morphisms factoring through the zero object;
 see `category_theory.limits.shapes.zero_morphisms`.

74333bd5

bump to nightly-2023-03-07-16

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

a8442c3c

Diff

@@ -39,6 +39,7 @@ namespace CategoryTheory
 
 namespace Limits
 
+#print CategoryTheory.Limits.IsZero /-
 /-- An object `X` in a category is a *zero object* if for every object `Y`
 there is a unique morphism `to : X → Y` and a unique morphism `from : Y → X`.
 
@@ -47,45 +48,63 @@ structure IsZero (X : C) : Prop where
   unique_to : ∀ Y, Nonempty (Unique (X ⟶ Y))
   unique_from : ∀ Y, Nonempty (Unique (Y ⟶ X))
 #align category_theory.limits.is_zero CategoryTheory.Limits.IsZero
+-/
 
 namespace IsZero
 
 variable {X Y : C}
 
+#print CategoryTheory.Limits.IsZero.to_ /-
 /-- If `h : is_zero X`, then `h.to Y` is a choice of unique morphism `X → Y`. -/
-protected def to (h : IsZero X) (Y : C) : X ⟶ Y :=
+protected def to_ (h : IsZero X) (Y : C) : X ⟶ Y :=
   @default (X ⟶ Y) <| @Unique.inhabited _ <| (h.unique_to Y).some
-#align category_theory.limits.is_zero.to CategoryTheory.Limits.IsZero.to
+#align category_theory.limits.is_zero.to CategoryTheory.Limits.IsZero.to_
+-/
 
+#print CategoryTheory.Limits.IsZero.eq_to /-
 theorem eq_to (h : IsZero X) (f : X ⟶ Y) : f = h.to Y :=
   @Unique.eq_default _ (id _) _
 #align category_theory.limits.is_zero.eq_to CategoryTheory.Limits.IsZero.eq_to
+-/
 
+#print CategoryTheory.Limits.IsZero.to_eq /-
 theorem to_eq (h : IsZero X) (f : X ⟶ Y) : h.to Y = f :=
   (h.eq_to f).symm
 #align category_theory.limits.is_zero.to_eq CategoryTheory.Limits.IsZero.to_eq
+-/
 
+#print CategoryTheory.Limits.IsZero.from_ /-
 /-- If `h : is_zero X`, then `h.from Y` is a choice of unique morphism `Y → X`. -/
-protected def from (h : IsZero X) (Y : C) : Y ⟶ X :=
+protected def from_ (h : IsZero X) (Y : C) : Y ⟶ X :=
   @default (Y ⟶ X) <| @Unique.inhabited _ <| (h.unique_from Y).some
-#align category_theory.limits.is_zero.from CategoryTheory.Limits.IsZero.from
+#align category_theory.limits.is_zero.from CategoryTheory.Limits.IsZero.from_
+-/
 
+#print CategoryTheory.Limits.IsZero.eq_from /-
 theorem eq_from (h : IsZero X) (f : Y ⟶ X) : f = h.from Y :=
   @Unique.eq_default _ (id _) _
 #align category_theory.limits.is_zero.eq_from CategoryTheory.Limits.IsZero.eq_from
+-/
 
+#print CategoryTheory.Limits.IsZero.from_eq /-
 theorem from_eq (h : IsZero X) (f : Y ⟶ X) : h.from Y = f :=
   (h.eq_from f).symm
 #align category_theory.limits.is_zero.from_eq CategoryTheory.Limits.IsZero.from_eq
+-/
 
+#print CategoryTheory.Limits.IsZero.eq_of_src /-
 theorem eq_of_src (hX : IsZero X) (f g : X ⟶ Y) : f = g :=
   (hX.eq_to f).trans (hX.eq_to g).symm
 #align category_theory.limits.is_zero.eq_of_src CategoryTheory.Limits.IsZero.eq_of_src
+-/
 
+#print CategoryTheory.Limits.IsZero.eq_of_tgt /-
 theorem eq_of_tgt (hX : IsZero X) (f g : Y ⟶ X) : f = g :=
   (hX.eq_from f).trans (hX.eq_from g).symm
 #align category_theory.limits.is_zero.eq_of_tgt CategoryTheory.Limits.IsZero.eq_of_tgt
+-/
 
+#print CategoryTheory.Limits.IsZero.iso /-
 /-- Any two zero objects are isomorphic. -/
 def iso (hX : IsZero X) (hY : IsZero Y) : X ≅ Y
     where
@@ -94,27 +113,37 @@ def iso (hX : IsZero X) (hY : IsZero Y) : X ≅ Y
   hom_inv_id' := hX.eq_of_src _ _
   inv_hom_id' := hY.eq_of_src _ _
 #align category_theory.limits.is_zero.iso CategoryTheory.Limits.IsZero.iso
+-/
 
+#print CategoryTheory.Limits.IsZero.isInitial /-
 /-- A zero object is in particular initial. -/
 protected def isInitial (hX : IsZero X) : IsInitial X :=
   @IsInitial.ofUnique _ _ X fun Y => (hX.unique_to Y).some
 #align category_theory.limits.is_zero.is_initial CategoryTheory.Limits.IsZero.isInitial
+-/
 
+#print CategoryTheory.Limits.IsZero.isTerminal /-
 /-- A zero object is in particular terminal. -/
 protected def isTerminal (hX : IsZero X) : IsTerminal X :=
   @IsTerminal.ofUnique _ _ X fun Y => (hX.unique_from Y).some
 #align category_theory.limits.is_zero.is_terminal CategoryTheory.Limits.IsZero.isTerminal
+-/
 
+#print CategoryTheory.Limits.IsZero.isoIsInitial /-
 /-- The (unique) isomorphism between any initial object and the zero object. -/
 def isoIsInitial (hX : IsZero X) (hY : IsInitial Y) : X ≅ Y :=
   hX.IsInitial.uniqueUpToIso hY
 #align category_theory.limits.is_zero.iso_is_initial CategoryTheory.Limits.IsZero.isoIsInitial
+-/
 
+#print CategoryTheory.Limits.IsZero.isoIsTerminal /-
 /-- The (unique) isomorphism between any terminal object and the zero object. -/
 def isoIsTerminal (hX : IsZero X) (hY : IsTerminal Y) : X ≅ Y :=
   hX.IsTerminal.uniqueUpToIso hY
 #align category_theory.limits.is_zero.iso_is_terminal CategoryTheory.Limits.IsZero.isoIsTerminal
+-/
 
+#print CategoryTheory.Limits.IsZero.of_iso /-
 theorem of_iso (hY : IsZero Y) (e : X ≅ Y) : IsZero X :=
   by
   refine' ⟨fun Z => ⟨⟨⟨e.hom ≫ hY.to Z⟩, fun f => _⟩⟩, fun Z => ⟨⟨⟨hY.from Z ≫ e.inv⟩, fun f => _⟩⟩⟩
@@ -123,16 +152,21 @@ theorem of_iso (hY : IsZero Y) (e : X ≅ Y) : IsZero X :=
   · rw [← cancel_mono e.hom]
     apply hY.eq_of_tgt
 #align category_theory.limits.is_zero.of_iso CategoryTheory.Limits.IsZero.of_iso
+-/
 
+#print CategoryTheory.Limits.IsZero.op /-
 theorem op (h : IsZero X) : IsZero (Opposite.op X) :=
   ⟨fun Y => ⟨⟨⟨(h.from (Opposite.unop Y)).op⟩, fun f => Quiver.Hom.unop_inj (h.eq_of_tgt _ _)⟩⟩,
     fun Y => ⟨⟨⟨(h.to (Opposite.unop Y)).op⟩, fun f => Quiver.Hom.unop_inj (h.eq_of_src _ _)⟩⟩⟩
 #align category_theory.limits.is_zero.op CategoryTheory.Limits.IsZero.op
+-/
 
+#print CategoryTheory.Limits.IsZero.unop /-
 theorem unop {X : Cᵒᵖ} (h : IsZero X) : IsZero (Opposite.unop X) :=
   ⟨fun Y => ⟨⟨⟨(h.from (Opposite.op Y)).unop⟩, fun f => Quiver.Hom.op_inj (h.eq_of_tgt _ _)⟩⟩,
     fun Y => ⟨⟨⟨(h.to (Opposite.op Y)).unop⟩, fun f => Quiver.Hom.op_inj (h.eq_of_src _ _)⟩⟩⟩
 #align category_theory.limits.is_zero.unop CategoryTheory.Limits.IsZero.unop
+-/
 
 end IsZero
 
@@ -140,10 +174,18 @@ end Limits
 
 open CategoryTheory.Limits
 
+#print CategoryTheory.Iso.isZero_iff /-
 theorem Iso.isZero_iff {X Y : C} (e : X ≅ Y) : IsZero X ↔ IsZero Y :=
   ⟨fun h => h.of_iso e.symm, fun h => h.of_iso e⟩
 #align category_theory.iso.is_zero_iff CategoryTheory.Iso.isZero_iff
+-/
 
+/- warning: category_theory.functor.is_zero -> CategoryTheory.Functor.isZero is a dubious translation:
+lean 3 declaration is
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] (F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2), (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (CategoryTheory.Functor.obj.{u1, u3, u2, u4} C _inst_1 D _inst_2 F X)) -> (CategoryTheory.Limits.IsZero.{max u2 u3, max u1 u3 u2 u4} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F)
+but is expected to have type
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] (F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2), (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (Prefunctor.obj.{succ u1, succ u3, u2, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u4} D (CategoryTheory.Category.toCategoryStruct.{u3, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u2, u4} C _inst_1 D _inst_2 F) X)) -> (CategoryTheory.Limits.IsZero.{max u2 u3, max (max (max u2 u4) u1) u3} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F)
+Case conversion may be inaccurate. Consider using '#align category_theory.functor.is_zero CategoryTheory.Functor.isZeroₓ'. -/
 theorem Functor.isZero (F : C ⥤ D) (hF : ∀ X, IsZero (F.obj X)) : IsZero F :=
   by
   constructor <;> intro G <;> refine' ⟨⟨⟨_⟩, _⟩⟩
@@ -169,53 +211,75 @@ namespace Limits
 
 variable (C)
 
+#print CategoryTheory.Limits.HasZeroObject /-
 /-- A category "has a zero object" if it has an object which is both initial and terminal. -/
 class HasZeroObject : Prop where
   zero : ∃ X : C, IsZero X
 #align category_theory.limits.has_zero_object CategoryTheory.Limits.HasZeroObject
+-/
 
+#print CategoryTheory.Limits.hasZeroObject_pUnit /-
 instance hasZeroObject_pUnit : HasZeroObject (Discrete PUnit) where zero := ⟨⟨⟨⟩⟩, by tidy, by tidy⟩
 #align category_theory.limits.has_zero_object_punit CategoryTheory.Limits.hasZeroObject_pUnit
+-/
 
 section
 
 variable [HasZeroObject C]
 
+#print CategoryTheory.Limits.HasZeroObject.hasZero /-
 /-- Construct a `has_zero C` for a category with a zero object.
 This can not be a global instance as it will trigger for every `has_zero C` typeclass search.
 -/
 protected def HasZeroObject.hasZero : Zero C where zero := HasZeroObject.zero.some
 #align category_theory.limits.has_zero_object.has_zero CategoryTheory.Limits.HasZeroObject.hasZero
+-/
 
 scoped[ZeroObject] attribute [instance] CategoryTheory.Limits.HasZeroObject.hasZero
 
+#print CategoryTheory.Limits.isZero_zero /-
 theorem isZero_zero : IsZero (0 : C) :=
   HasZeroObject.zero.choose_spec
 #align category_theory.limits.is_zero_zero CategoryTheory.Limits.isZero_zero
+-/
 
+#print CategoryTheory.Limits.hasZeroObject_op /-
 instance hasZeroObject_op : HasZeroObject Cᵒᵖ :=
   ⟨⟨Opposite.op 0, IsZero.op (isZero_zero C)⟩⟩
 #align category_theory.limits.has_zero_object_op CategoryTheory.Limits.hasZeroObject_op
+-/
 
 end
 
 open ZeroObject
 
+#print CategoryTheory.Limits.hasZeroObject_unop /-
 theorem hasZeroObject_unop [HasZeroObject Cᵒᵖ] : HasZeroObject C :=
   ⟨⟨Opposite.unop 0, IsZero.unop (isZero_zero Cᵒᵖ)⟩⟩
 #align category_theory.limits.has_zero_object_unop CategoryTheory.Limits.hasZeroObject_unop
+-/
 
 variable {C}
 
+#print CategoryTheory.Limits.IsZero.hasZeroObject /-
 theorem IsZero.hasZeroObject {X : C} (hX : IsZero X) : HasZeroObject C :=
   ⟨⟨X, hX⟩⟩
 #align category_theory.limits.is_zero.has_zero_object CategoryTheory.Limits.IsZero.hasZeroObject
+-/
 
+#print CategoryTheory.Limits.IsZero.isoZero /-
 /-- Every zero object is isomorphic to *the* zero object. -/
 def IsZero.isoZero [HasZeroObject C] {X : C} (hX : IsZero X) : X ≅ 0 :=
   hX.Iso (isZero_zero C)
 #align category_theory.limits.is_zero.iso_zero CategoryTheory.Limits.IsZero.isoZero
+-/
 
+/- warning: category_theory.limits.is_zero.obj -> CategoryTheory.Limits.IsZero.obj is a dubious translation:
+lean 3 declaration is
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] [_inst_3 : CategoryTheory.Limits.HasZeroObject.{u3, u4} D _inst_2] {F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2}, (CategoryTheory.Limits.IsZero.{max u2 u3, max u1 u3 u2 u4} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F) -> (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (CategoryTheory.Functor.obj.{u1, u3, u2, u4} C _inst_1 D _inst_2 F X))
+but is expected to have type
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] [_inst_3 : CategoryTheory.Limits.HasZeroObject.{u3, u4} D _inst_2] {F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2}, (CategoryTheory.Limits.IsZero.{max u2 u3, max (max (max u2 u4) u1) u3} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F) -> (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (Prefunctor.obj.{succ u1, succ u3, u2, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u4} D (CategoryTheory.Category.toCategoryStruct.{u3, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u2, u4} C _inst_1 D _inst_2 F) X))
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.is_zero.obj CategoryTheory.Limits.IsZero.objₓ'. -/
 theorem IsZero.obj [HasZeroObject D] {F : C ⥤ D} (hF : IsZero F) (X : C) : IsZero (F.obj X) :=
   by
   let G : C ⥤ D := (CategoryTheory.Functor.const C).obj 0
@@ -228,29 +292,37 @@ namespace HasZeroObject
 
 variable [HasZeroObject C]
 
+#print CategoryTheory.Limits.HasZeroObject.uniqueTo /-
 /-- There is a unique morphism from the zero object to any object `X`. -/
 protected def uniqueTo (X : C) : Unique (0 ⟶ X) :=
   ((isZero_zero C).unique_to X).some
 #align category_theory.limits.has_zero_object.unique_to CategoryTheory.Limits.HasZeroObject.uniqueTo
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.uniqueFrom /-
 /-- There is a unique morphism from any object `X` to the zero object. -/
 protected def uniqueFrom (X : C) : Unique (X ⟶ 0) :=
   ((isZero_zero C).unique_from X).some
 #align category_theory.limits.has_zero_object.unique_from CategoryTheory.Limits.HasZeroObject.uniqueFrom
+-/
 
 scoped[ZeroObject] attribute [instance] CategoryTheory.Limits.HasZeroObject.uniqueTo
 
 scoped[ZeroObject] attribute [instance] CategoryTheory.Limits.HasZeroObject.uniqueFrom
 
+#print CategoryTheory.Limits.HasZeroObject.to_zero_ext /-
 @[ext]
 theorem to_zero_ext {X : C} (f g : X ⟶ 0) : f = g :=
   (isZero_zero C).eq_of_tgt _ _
 #align category_theory.limits.has_zero_object.to_zero_ext CategoryTheory.Limits.HasZeroObject.to_zero_ext
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.from_zero_ext /-
 @[ext]
 theorem from_zero_ext {X : C} (f g : 0 ⟶ X) : f = g :=
   (isZero_zero C).eq_of_src _ _
 #align category_theory.limits.has_zero_object.from_zero_ext CategoryTheory.Limits.HasZeroObject.from_zero_ext
+-/
 
 instance (X : C) : Subsingleton (X ≅ 0) := by tidy
 
@@ -258,53 +330,73 @@ instance {X : C} (f : 0 ⟶ X) : Mono f where right_cancellation Z g h w := by e
 
 instance {X : C} (f : X ⟶ 0) : Epi f where left_cancellation Z g h w := by ext
 
+#print CategoryTheory.Limits.HasZeroObject.zero_to_zero_isIso /-
 instance zero_to_zero_isIso (f : (0 : C) ⟶ 0) : IsIso f := by
   convert show is_iso (𝟙 (0 : C)) by infer_instance
 #align category_theory.limits.has_zero_object.zero_to_zero_is_iso CategoryTheory.Limits.HasZeroObject.zero_to_zero_isIso
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.zeroIsInitial /-
 /-- A zero object is in particular initial. -/
 def zeroIsInitial : IsInitial (0 : C) :=
   (isZero_zero C).IsInitial
 #align category_theory.limits.has_zero_object.zero_is_initial CategoryTheory.Limits.HasZeroObject.zeroIsInitial
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.zeroIsTerminal /-
 /-- A zero object is in particular terminal. -/
 def zeroIsTerminal : IsTerminal (0 : C) :=
   (isZero_zero C).IsTerminal
 #align category_theory.limits.has_zero_object.zero_is_terminal CategoryTheory.Limits.HasZeroObject.zeroIsTerminal
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.hasInitial /-
 /-- A zero object is in particular initial. -/
 instance (priority := 10) hasInitial : HasInitial C :=
   hasInitial_of_unique 0
 #align category_theory.limits.has_zero_object.has_initial CategoryTheory.Limits.HasZeroObject.hasInitial
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.hasTerminal /-
 /-- A zero object is in particular terminal. -/
 instance (priority := 10) hasTerminal : HasTerminal C :=
   hasTerminal_of_unique 0
 #align category_theory.limits.has_zero_object.has_terminal CategoryTheory.Limits.HasZeroObject.hasTerminal
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.zeroIsoIsInitial /-
 /-- The (unique) isomorphism between any initial object and the zero object. -/
 def zeroIsoIsInitial {X : C} (t : IsInitial X) : 0 ≅ X :=
   zeroIsInitial.uniqueUpToIso t
 #align category_theory.limits.has_zero_object.zero_iso_is_initial CategoryTheory.Limits.HasZeroObject.zeroIsoIsInitial
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.zeroIsoIsTerminal /-
 /-- The (unique) isomorphism between any terminal object and the zero object. -/
 def zeroIsoIsTerminal {X : C} (t : IsTerminal X) : 0 ≅ X :=
   zeroIsTerminal.uniqueUpToIso t
 #align category_theory.limits.has_zero_object.zero_iso_is_terminal CategoryTheory.Limits.HasZeroObject.zeroIsoIsTerminal
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.zeroIsoInitial /-
 /-- The (unique) isomorphism between the chosen initial object and the chosen zero object. -/
 def zeroIsoInitial [HasInitial C] : 0 ≅ ⊥_ C :=
   zeroIsInitial.uniqueUpToIso initialIsInitial
 #align category_theory.limits.has_zero_object.zero_iso_initial CategoryTheory.Limits.HasZeroObject.zeroIsoInitial
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.zeroIsoTerminal /-
 /-- The (unique) isomorphism between the chosen terminal object and the chosen zero object. -/
 def zeroIsoTerminal [HasTerminal C] : 0 ≅ ⊤_ C :=
   zeroIsTerminal.uniqueUpToIso terminalIsTerminal
 #align category_theory.limits.has_zero_object.zero_iso_terminal CategoryTheory.Limits.HasZeroObject.zeroIsoTerminal
+-/
 
+#print CategoryTheory.Limits.HasZeroObject.has_strict_initial /-
 instance (priority := 100) has_strict_initial : InitialMonoClass C :=
   InitialMonoClass.of_isInitial zeroIsInitial fun X => CategoryTheory.mono _
 #align category_theory.limits.has_zero_object.has_strict_initial CategoryTheory.Limits.HasZeroObject.has_strict_initial
+-/
 
 end HasZeroObject
 
@@ -314,6 +406,12 @@ open CategoryTheory.Limits
 
 open ZeroObject
 
+/- warning: category_theory.functor.is_zero_iff -> CategoryTheory.Functor.isZero_iff is a dubious translation:
+lean 3 declaration is
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] [_inst_3 : CategoryTheory.Limits.HasZeroObject.{u3, u4} D _inst_2] (F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2), Iff (CategoryTheory.Limits.IsZero.{max u2 u3, max u1 u3 u2 u4} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F) (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (CategoryTheory.Functor.obj.{u1, u3, u2, u4} C _inst_1 D _inst_2 F X))
+but is expected to have type
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u4}} [_inst_2 : CategoryTheory.Category.{u3, u4} D] [_inst_3 : CategoryTheory.Limits.HasZeroObject.{u3, u4} D _inst_2] (F : CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2), Iff (CategoryTheory.Limits.IsZero.{max u2 u3, max (max (max u2 u4) u1) u3} (CategoryTheory.Functor.{u1, u3, u2, u4} C _inst_1 D _inst_2) (CategoryTheory.Functor.category.{u1, u3, u2, u4} C _inst_1 D _inst_2) F) (forall (X : C), CategoryTheory.Limits.IsZero.{u3, u4} D _inst_2 (Prefunctor.obj.{succ u1, succ u3, u2, u4} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u4} D (CategoryTheory.Category.toCategoryStruct.{u3, u4} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u3, u2, u4} C _inst_1 D _inst_2 F) X))
+Case conversion may be inaccurate. Consider using '#align category_theory.functor.is_zero_iff CategoryTheory.Functor.isZero_iffₓ'. -/
 theorem Functor.isZero_iff [HasZeroObject D] (F : C ⥤ D) : IsZero F ↔ ∀ X, IsZero (F.obj X) :=
   ⟨fun hF X => hF.obj X, Functor.isZero _⟩
 #align category_theory.functor.is_zero_iff CategoryTheory.Functor.isZero_iff

74333bd5

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

74333bd5

feat: FastSubsingleton and FastIsEmpty to speed up congr!/convert (#12495)

This is a PR that's a temporary measure to improve performance of congr!/convert, and the implementation may change in a future PR with a new version of congr!.

Introduces two typeclasses that are meant to quickly evaluate in common cases of Subsingleton and IsEmpty. Makes congr! use these typeclasses rather than Subsingleton.

Local Subsingleton/IsEmpty instances are included as Fast instances. To get congr!/convert to reason about subsingleton types, you can add such instances to the local context. Or, you can apply Subsingleton.elim yourself.

Zulip discussion

0924a3d4

Diff

@@ -268,6 +268,7 @@ instance {X : C} (f : X ⟶ 0) : Epi f where left_cancellation g h _ := by ext
 
 instance zero_to_zero_isIso (f : (0 : C) ⟶ 0) : IsIso f := by
   convert show IsIso (𝟙 (0 : C)) by infer_instance
+  apply Subsingleton.elim
 #align category_theory.limits.has_zero_object.zero_to_zero_is_iso CategoryTheory.Limits.HasZeroObject.zero_to_zero_isIso
 
 /-- A zero object is in particular initial. -/

74333bd5

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

@@ -29,7 +29,6 @@ open CategoryTheory
 open CategoryTheory.Category
 
 variable {C : Type u} [Category.{v} C]
-
 variable {D : Type u'} [Category.{v'} D]
 
 namespace CategoryTheory

74333bd5

chore: change 'Porting:' to 'Porting note:' (#6378)

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

ffef20af

Diff

@@ -51,7 +51,7 @@ namespace IsZero
 
 variable {X Y : C}
 
--- Porting: `to` is a reserved word, it was replaced by `to_`
+-- Porting note: `to` is a reserved word, it was replaced by `to_`
 /-- If `h : IsZero X`, then `h.to_ Y` is a choice of unique morphism `X → Y`. -/
 protected def to_ (h : IsZero X) (Y : C) : X ⟶ Y :=
   @default _ <| (h.unique_to Y).some.toInhabited
@@ -65,7 +65,7 @@ theorem to_eq (h : IsZero X) (f : X ⟶ Y) : h.to_ Y = f :=
   (h.eq_to f).symm
 #align category_theory.limits.is_zero.to_eq CategoryTheory.Limits.IsZero.to_eq
 
--- Porting: `from` is a reserved word, it was replaced by `from_`
+-- Porting note: `from` is a reserved word, it was replaced by `from_`
 /-- If `h : is_zero X`, then `h.from_ Y` is a choice of unique morphism `Y → X`. -/
 protected def from_ (h : IsZero X) (Y : C) : Y ⟶ X :=
   @default _ <| (h.unique_from Y).some.toInhabited

74333bd5

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,14 +2,11 @@
 Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Johan Commelin
-
-! This file was ported from Lean 3 source module category_theory.limits.shapes.zero_objects
-! leanprover-community/mathlib commit 74333bd53d25b6809203a2bfae80eea5fc1fc076
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Limits.Shapes.Terminal
 
+#align_import category_theory.limits.shapes.zero_objects from "leanprover-community/mathlib"@"74333bd53d25b6809203a2bfae80eea5fc1fc076"
+
 /-!
 # Zero objects

74333bd5

feat: add Mathlib.Tactic.Common, and import (#4056)

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

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

a4eaf1c4

Diff

@@ -9,7 +9,6 @@ Authors: Scott Morrison, Johan Commelin
 ! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Limits.Shapes.Terminal
-import Mathlib.Tactic.ScopedNS
 
 /-!
 # Zero objects

74333bd5

chore: tidy various files (#2742)

8c7b65ad

Diff

@@ -193,13 +193,13 @@ section
 
 variable [HasZeroObject C]
 
-/-- Construct a `HasZero C` for a category with a zero object.
-This can not be a global instance as it will trigger for every `HasZero C` typeclass search.
+/-- Construct a `Zero C` for a category with a zero object.
+This can not be a global instance as it will trigger for every `Zero C` typeclass search.
 -/
-protected def HasZeroObject.hasZero : Zero C where zero := HasZeroObject.zero.choose
-#align category_theory.limits.has_zero_object.has_zero CategoryTheory.Limits.HasZeroObject.hasZero
+protected def HasZeroObject.zero' : Zero C where zero := HasZeroObject.zero.choose
+#align category_theory.limits.has_zero_object.has_zero CategoryTheory.Limits.HasZeroObject.zero'
 
-scoped[ZeroObject] attribute [instance] CategoryTheory.Limits.HasZeroObject.hasZero
+scoped[ZeroObject] attribute [instance] CategoryTheory.Limits.HasZeroObject.zero'
 
 open ZeroObject
 
@@ -315,9 +315,9 @@ def zeroIsoTerminal [HasTerminal C] : 0 ≅ ⊤_ C :=
   zeroIsTerminal.uniqueUpToIso terminalIsTerminal
 #align category_theory.limits.has_zero_object.zero_iso_terminal CategoryTheory.Limits.HasZeroObject.zeroIsoTerminal
 
-instance (priority := 100) has_strict_initial : InitialMonoClass C :=
+instance (priority := 100) initialMonoClass : InitialMonoClass C :=
   InitialMonoClass.of_isInitial zeroIsInitial fun X => by infer_instance
-#align category_theory.limits.has_zero_object.has_strict_initial CategoryTheory.Limits.HasZeroObject.has_strict_initial
+#align category_theory.limits.has_zero_object.has_strict_initial CategoryTheory.Limits.HasZeroObject.initialMonoClass
 
 end HasZeroObject

74333bd5

feat: port CategoryTheory.Limits.Shapes.ZeroObjects (#2594)

dcdfad20

`category_theory.limits.shapes.zero_objects` ⟷ `Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 83

category_theory.limits.shapes.zero_objects ⟷ Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 83

`category_theory.limits.shapes.zero_objects` ⟷ `Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects`