category_theory.limits.shapes.regular_mono

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

239d882c

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

f4758115

bump to nightly-2024-02-10-08

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

c6692027

Diff

@@ -133,7 +133,7 @@ See also `pullback.fst_of_mono` for the basic monomorphism version, and
 def regularOfIsPullbackFstOfRegular {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S}
     [hr : RegularMono k] (comm : f ≫ h = g ≫ k) (t : IsLimit (PullbackCone.mk _ _ comm)) :
     RegularMono f :=
-  regularOfIsPullbackSndOfRegular comm.symm (PullbackCone.flipIsLimit t)
+  regularOfIsPullbackSndOfRegular comm.symm (PullbackCone.isLimitOfFlip t)
 #align category_theory.regular_of_is_pullback_fst_of_regular CategoryTheory.regularOfIsPullbackFstOfRegular
 -/
 
@@ -286,7 +286,7 @@ See also `pushout.fst_of_epi` for the basic epimorphism version, and
 def regularOfIsPushoutFstOfRegular {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S}
     [fr : RegularEpi f] (comm : f ≫ h = g ≫ k) (t : IsColimit (PushoutCocone.mk _ _ comm)) :
     RegularEpi k :=
-  regularOfIsPushoutSndOfRegular comm.symm (PushoutCocone.flipIsColimit t)
+  regularOfIsPushoutSndOfRegular comm.symm (PushoutCocone.isColimitOfFlip t)
 #align category_theory.regular_of_is_pushout_fst_of_regular CategoryTheory.regularOfIsPushoutFstOfRegular
 -/

f4758115

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Bhavik Mehta
 -/
-import Mathbin.CategoryTheory.Limits.Shapes.Pullbacks
-import Mathbin.CategoryTheory.Limits.Shapes.StrongEpi
-import Mathbin.CategoryTheory.Limits.Shapes.Equalizers
+import CategoryTheory.Limits.Shapes.Pullbacks
+import CategoryTheory.Limits.Shapes.StrongEpi
+import CategoryTheory.Limits.Shapes.Equalizers
 
 #align_import category_theory.limits.shapes.regular_mono 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,16 +2,13 @@
 Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Bhavik Mehta
-
-! This file was ported from Lean 3 source module category_theory.limits.shapes.regular_mono
-! 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.Pullbacks
 import Mathbin.CategoryTheory.Limits.Shapes.StrongEpi
 import Mathbin.CategoryTheory.Limits.Shapes.Equalizers
 
+#align_import category_theory.limits.shapes.regular_mono from "leanprover-community/mathlib"@"f47581155c818e6361af4e4fda60d27d020c226b"
+
 /-!
 # Definitions and basic properties of regular monomorphisms and epimorphisms.

f4758115

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -240,6 +240,7 @@ instance (priority := 100) RegularEpi.ofSplitEpi (f : X ⟶ Y) [IsSplitEpi f] :
 #align category_theory.regular_epi.of_split_epi CategoryTheory.RegularEpi.ofSplitEpi
 -/
 
+#print CategoryTheory.RegularEpi.desc' /-
 /-- If `f` is a regular epi, then every morphism `k : X ⟶ W` coequalizing `regular_epi.left` and
     `regular_epi.right` induces `l : Y ⟶ W` such that `f ≫ l = k`. -/
 def RegularEpi.desc' {W : C} (f : X ⟶ Y) [RegularEpi f] (k : X ⟶ W)
@@ -247,6 +248,7 @@ def RegularEpi.desc' {W : C} (f : X ⟶ Y) [RegularEpi f] (k : X ⟶ W)
     { l : Y ⟶ W // f ≫ l = k } :=
   Cofork.IsColimit.desc' RegularEpi.isColimit _ h
 #align category_theory.regular_epi.desc' CategoryTheory.RegularEpi.desc'
+-/
 
 #print CategoryTheory.regularOfIsPushoutSndOfRegular /-
 /-- The second leg of a pushout cocone is a regular epimorphism if the right component is too.

f4758115

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -240,12 +240,6 @@ instance (priority := 100) RegularEpi.ofSplitEpi (f : X ⟶ Y) [IsSplitEpi f] :
 #align category_theory.regular_epi.of_split_epi CategoryTheory.RegularEpi.ofSplitEpi
 -/
 
-/- warning: category_theory.regular_epi.desc' -> CategoryTheory.RegularEpi.desc' is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {X : C} {Y : C} {W : C} (f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y) [_inst_2 : CategoryTheory.RegularEpi.{u1, u2} C _inst_1 X Y f] (k : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X W), (Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.RegularEpi.w.{u1, u2} C _inst_1 X Y f _inst_2) W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.RegularEpi.w.{u1, u2} C _inst_1 X Y f _inst_2) X W (CategoryTheory.RegularEpi.left.{u1, u2} C _inst_1 X Y f _inst_2) k) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.RegularEpi.w.{u1, u2} C _inst_1 X Y f _inst_2) X W (CategoryTheory.RegularEpi.right.{u1, u2} C _inst_1 X Y f _inst_2) k)) -> (Subtype.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) Y W) (fun (l : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) Y W) => Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) X Y W f l) k))
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {X : C} {Y : C} {W : C} (f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y) [_inst_2 : CategoryTheory.RegularEpi.{u1, u2} C _inst_1 X Y f] (k : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X W), (Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.RegularEpi.W.{u1, u2} C _inst_1 X Y f _inst_2) W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.RegularEpi.W.{u1, u2} C _inst_1 X Y f _inst_2) X W (CategoryTheory.RegularEpi.left.{u1, u2} C _inst_1 X Y f _inst_2) k) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.RegularEpi.W.{u1, u2} C _inst_1 X Y f _inst_2) X W (CategoryTheory.RegularEpi.right.{u1, u2} C _inst_1 X Y f _inst_2) k)) -> (Subtype.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) Y W) (fun (l : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) Y W) => Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) X Y W f l) k))
-Case conversion may be inaccurate. Consider using '#align category_theory.regular_epi.desc' CategoryTheory.RegularEpi.desc'ₓ'. -/
 /-- If `f` is a regular epi, then every morphism `k : X ⟶ W` coequalizing `regular_epi.left` and
     `regular_epi.right` induces `l : Y ⟶ W` such that `f ≫ l = k`. -/
 def RegularEpi.desc' {W : C} (f : X ⟶ Y) [RegularEpi f] (k : X ⟶ W)

f4758115

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -71,11 +71,7 @@ instance equalizerRegular (g h : X ⟶ Y) [HasLimit (parallelPair g h)] :
   left := g
   right := h
   w := equalizer.condition g h
-  IsLimit :=
-    Fork.IsLimit.mk _ (fun s => limit.lift _ s) (by simp) fun s m w =>
-      by
-      ext1
-      simp [← w]
+  IsLimit := Fork.IsLimit.mk _ (fun s => limit.lift _ s) (by simp) fun s m w => by ext1; simp [← w]
 #align category_theory.equalizer_regular CategoryTheory.equalizerRegular
 -/
 
@@ -190,20 +186,14 @@ def regularMonoOfMono [RegularMonoCategory C] (f : X ⟶ Y) [Mono f] : RegularMo
 #print CategoryTheory.regularMonoCategoryOfSplitMonoCategory /-
 instance (priority := 100) regularMonoCategoryOfSplitMonoCategory [SplitMonoCategory C] :
     RegularMonoCategory C
-    where regularMonoOfMono _ _ f _ :=
-    by
-    haveI := is_split_mono_of_mono f
-    infer_instance
+    where regularMonoOfMono _ _ f _ := by haveI := is_split_mono_of_mono f; infer_instance
 #align category_theory.regular_mono_category_of_split_mono_category CategoryTheory.regularMonoCategoryOfSplitMonoCategory
 -/
 
 #print CategoryTheory.strongMonoCategory_of_regularMonoCategory /-
 instance (priority := 100) strongMonoCategory_of_regularMonoCategory [RegularMonoCategory C] :
     StrongMonoCategory C
-    where strongMono_of_mono _ _ f _ :=
-    by
-    haveI := regular_mono_of_mono f
-    infer_instance
+    where strongMono_of_mono _ _ f _ := by haveI := regular_mono_of_mono f; infer_instance
 #align category_theory.strong_mono_category_of_regular_mono_category CategoryTheory.strongMonoCategory_of_regularMonoCategory
 -/
 
@@ -234,10 +224,7 @@ instance coequalizerRegular (g h : X ⟶ Y) [HasColimit (parallelPair g h)] :
   right := h
   w := coequalizer.condition g h
   IsColimit :=
-    Cofork.IsColimit.mk _ (fun s => colimit.desc _ s) (by simp) fun s m w =>
-      by
-      ext1
-      simp [← w]
+    Cofork.IsColimit.mk _ (fun s => colimit.desc _ s) (by simp) fun s m w => by ext1; simp [← w]
 #align category_theory.coequalizer_regular CategoryTheory.coequalizerRegular
 -/
 
@@ -293,8 +280,7 @@ def regularOfIsPushoutSndOfRegular {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h
     apply t.hom_ext
     apply (pushout_cocone.mk _ _ comm).coequalizer_ext
     · exact z
-    · erw [← cancel_epi g, ← reassoc_of comm, ← reassoc_of comm, z]
-      rfl
+    · erw [← cancel_epi g, ← reassoc_of comm, ← reassoc_of comm, z]; rfl
 #align category_theory.regular_of_is_pushout_snd_of_regular CategoryTheory.regularOfIsPushoutSndOfRegular
 -/
 
@@ -360,20 +346,14 @@ def regularEpiOfEpi [RegularEpiCategory C] (f : X ⟶ Y) [Epi f] : RegularEpi f
 #print CategoryTheory.regularEpiCategoryOfSplitEpiCategory /-
 instance (priority := 100) regularEpiCategoryOfSplitEpiCategory [SplitEpiCategory C] :
     RegularEpiCategory C
-    where regularEpiOfEpi _ _ f _ :=
-    by
-    haveI := is_split_epi_of_epi f
-    infer_instance
+    where regularEpiOfEpi _ _ f _ := by haveI := is_split_epi_of_epi f; infer_instance
 #align category_theory.regular_epi_category_of_split_epi_category CategoryTheory.regularEpiCategoryOfSplitEpiCategory
 -/
 
 #print CategoryTheory.strongEpiCategory_of_regularEpiCategory /-
 instance (priority := 100) strongEpiCategory_of_regularEpiCategory [RegularEpiCategory C] :
     StrongEpiCategory C
-    where strongEpi_of_epi _ _ f _ :=
-    by
-    haveI := regular_epi_of_epi f
-    infer_instance
+    where strongEpi_of_epi _ _ f _ := by haveI := regular_epi_of_epi f; infer_instance
 #align category_theory.strong_epi_category_of_regular_epi_category CategoryTheory.strongEpiCategory_of_regularEpiCategory
 -/

f4758115

bump to nightly-2023-05-23-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/75e7fca56381d056096ce5d05e938f63a6567828

ed98987c

Diff

@@ -55,7 +55,7 @@ class RegularMono (f : X ⟶ Y) where
 #align category_theory.regular_mono CategoryTheory.RegularMono
 -/
 
-attribute [reassoc.1] regular_mono.w
+attribute [reassoc] regular_mono.w
 
 #print CategoryTheory.RegularMono.mono /-
 /-- Every regular monomorphism is a monomorphism. -/
@@ -217,7 +217,7 @@ class RegularEpi (f : X ⟶ Y) where
 #align category_theory.regular_epi CategoryTheory.RegularEpi
 -/
 
-attribute [reassoc.1] regular_epi.w
+attribute [reassoc] regular_epi.w
 
 #print CategoryTheory.RegularEpi.epi /-
 /-- Every regular epimorphism is an epimorphism. -/

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, Bhavik Mehta
 
 ! This file was ported from Lean 3 source module category_theory.limits.shapes.regular_mono
-! leanprover-community/mathlib commit 239d882c4fb58361ee8b3b39fb2091320edef10a
+! leanprover-community/mathlib commit f47581155c818e6361af4e4fda60d27d020c226b
 ! 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.Shapes.Equalizers
 /-!
 # Definitions and basic properties of regular monomorphisms and epimorphisms.
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 A regular monomorphism is a morphism that is the equalizer of some parallel pair.
 
 We give the constructions

239d882c

bump to nightly-2023-03-07-16

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

a8442c3c

Diff

@@ -42,6 +42,7 @@ variable {C : Type u₁} [Category.{v₁} C]
 
 variable {X Y : C}
 
+#print CategoryTheory.RegularMono /-
 /-- A regular monomorphism is a morphism which is the equalizer of some parallel pair. -/
 class RegularMono (f : X ⟶ Y) where
   z : C
@@ -49,14 +50,18 @@ class RegularMono (f : X ⟶ Y) where
   w : f ≫ left = f ≫ right
   IsLimit : IsLimit (Fork.ofι f w)
 #align category_theory.regular_mono CategoryTheory.RegularMono
+-/
 
 attribute [reassoc.1] regular_mono.w
 
+#print CategoryTheory.RegularMono.mono /-
 /-- Every regular monomorphism is a monomorphism. -/
 instance (priority := 100) RegularMono.mono (f : X ⟶ Y) [RegularMono f] : Mono f :=
   mono_of_isLimit_fork RegularMono.isLimit
 #align category_theory.regular_mono.mono CategoryTheory.RegularMono.mono
+-/
 
+#print CategoryTheory.equalizerRegular /-
 instance equalizerRegular (g h : X ⟶ Y) [HasLimit (parallelPair g h)] :
     RegularMono (equalizer.ι g h) where
   z := Y
@@ -69,7 +74,9 @@ instance equalizerRegular (g h : X ⟶ Y) [HasLimit (parallelPair g h)] :
       ext1
       simp [← w]
 #align category_theory.equalizer_regular CategoryTheory.equalizerRegular
+-/
 
+#print CategoryTheory.RegularMono.ofIsSplitMono /-
 /-- Every split monomorphism is a regular monomorphism. -/
 instance (priority := 100) RegularMono.ofIsSplitMono (f : X ⟶ Y) [IsSplitMono f] : RegularMono f
     where
@@ -79,7 +86,9 @@ instance (priority := 100) RegularMono.ofIsSplitMono (f : X ⟶ Y) [IsSplitMono
   w := by tidy
   IsLimit := isSplitMonoEqualizes f
 #align category_theory.regular_mono.of_is_split_mono CategoryTheory.RegularMono.ofIsSplitMono
+-/
 
+#print CategoryTheory.RegularMono.lift' /-
 /-- If `f` is a regular mono, then any map `k : W ⟶ Y` equalizing `regular_mono.left` and
     `regular_mono.right` induces a morphism `l : W ⟶ X` such that `l ≫ f = k`. -/
 def RegularMono.lift' {W : C} (f : X ⟶ Y) [RegularMono f] (k : W ⟶ Y)
@@ -87,7 +96,9 @@ def RegularMono.lift' {W : C} (f : X ⟶ Y) [RegularMono f] (k : W ⟶ Y)
     { l : W ⟶ X // l ≫ f = k } :=
   Fork.IsLimit.lift' RegularMono.isLimit _ h
 #align category_theory.regular_mono.lift' CategoryTheory.RegularMono.lift'
+-/
 
+#print CategoryTheory.regularOfIsPullbackSndOfRegular /-
 /-- The second leg of a pullback cone is a regular monomorphism if the right component is too.
 
 See also `pullback.snd_of_mono` for the basic monomorphism version, and
@@ -115,7 +126,9 @@ def regularOfIsPullbackSndOfRegular {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h
     · erw [← cancel_mono h, category.assoc, category.assoc, comm, reassoc_of z]
     · exact z
 #align category_theory.regular_of_is_pullback_snd_of_regular CategoryTheory.regularOfIsPullbackSndOfRegular
+-/
 
+#print CategoryTheory.regularOfIsPullbackFstOfRegular /-
 /-- The first leg of a pullback cone is a regular monomorphism if the left component is too.
 
 See also `pullback.fst_of_mono` for the basic monomorphism version, and
@@ -126,7 +139,9 @@ def regularOfIsPullbackFstOfRegular {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h
     RegularMono f :=
   regularOfIsPullbackSndOfRegular comm.symm (PullbackCone.flipIsLimit t)
 #align category_theory.regular_of_is_pullback_fst_of_regular CategoryTheory.regularOfIsPullbackFstOfRegular
+-/
 
+#print CategoryTheory.strongMono_of_regularMono /-
 instance (priority := 100) strongMono_of_regularMono (f : X ⟶ Y) [RegularMono f] : StrongMono f :=
   StrongMono.mk'
     (by
@@ -139,29 +154,37 @@ instance (priority := 100) strongMono_of_regularMono (f : X ⟶ Y) [RegularMono
       refine' comm_sq.has_lift.mk' ⟨t, (cancel_mono f).1 _, ht⟩
       simp only [arrow.mk_hom, arrow.hom_mk'_left, category.assoc, ht, sq.w])
 #align category_theory.strong_mono_of_regular_mono CategoryTheory.strongMono_of_regularMono
+-/
 
+#print CategoryTheory.isIso_of_regularMono_of_epi /-
 /-- A regular monomorphism is an isomorphism if it is an epimorphism. -/
 theorem isIso_of_regularMono_of_epi (f : X ⟶ Y) [RegularMono f] [e : Epi f] : IsIso f :=
   isIso_of_epi_of_strongMono _
 #align category_theory.is_iso_of_regular_mono_of_epi CategoryTheory.isIso_of_regularMono_of_epi
+-/
 
 section
 
 variable (C)
 
+#print CategoryTheory.RegularMonoCategory /-
 /-- A regular mono category is a category in which every monomorphism is regular. -/
 class RegularMonoCategory where
   regularMonoOfMono : ∀ {X Y : C} (f : X ⟶ Y) [Mono f], RegularMono f
 #align category_theory.regular_mono_category CategoryTheory.RegularMonoCategory
+-/
 
 end
 
+#print CategoryTheory.regularMonoOfMono /-
 /-- In a category in which every monomorphism is regular, we can express every monomorphism as
     an equalizer. This is not an instance because it would create an instance loop. -/
 def regularMonoOfMono [RegularMonoCategory C] (f : X ⟶ Y) [Mono f] : RegularMono f :=
   RegularMonoCategory.regularMonoOfMono _
 #align category_theory.regular_mono_of_mono CategoryTheory.regularMonoOfMono
+-/
 
+#print CategoryTheory.regularMonoCategoryOfSplitMonoCategory /-
 instance (priority := 100) regularMonoCategoryOfSplitMonoCategory [SplitMonoCategory C] :
     RegularMonoCategory C
     where regularMonoOfMono _ _ f _ :=
@@ -169,7 +192,9 @@ instance (priority := 100) regularMonoCategoryOfSplitMonoCategory [SplitMonoCate
     haveI := is_split_mono_of_mono f
     infer_instance
 #align category_theory.regular_mono_category_of_split_mono_category CategoryTheory.regularMonoCategoryOfSplitMonoCategory
+-/
 
+#print CategoryTheory.strongMonoCategory_of_regularMonoCategory /-
 instance (priority := 100) strongMonoCategory_of_regularMonoCategory [RegularMonoCategory C] :
     StrongMonoCategory C
     where strongMono_of_mono _ _ f _ :=
@@ -177,7 +202,9 @@ instance (priority := 100) strongMonoCategory_of_regularMonoCategory [RegularMon
     haveI := regular_mono_of_mono f
     infer_instance
 #align category_theory.strong_mono_category_of_regular_mono_category CategoryTheory.strongMonoCategory_of_regularMonoCategory
+-/
 
+#print CategoryTheory.RegularEpi /-
 /-- A regular epimorphism is a morphism which is the coequalizer of some parallel pair. -/
 class RegularEpi (f : X ⟶ Y) where
   w : C
@@ -185,14 +212,18 @@ class RegularEpi (f : X ⟶ Y) where
   w : left ≫ f = right ≫ f
   IsColimit : IsColimit (Cofork.ofπ f w)
 #align category_theory.regular_epi CategoryTheory.RegularEpi
+-/
 
 attribute [reassoc.1] regular_epi.w
 
+#print CategoryTheory.RegularEpi.epi /-
 /-- Every regular epimorphism is an epimorphism. -/
 instance (priority := 100) RegularEpi.epi (f : X ⟶ Y) [RegularEpi f] : Epi f :=
   epi_of_isColimit_cofork RegularEpi.isColimit
 #align category_theory.regular_epi.epi CategoryTheory.RegularEpi.epi
+-/
 
+#print CategoryTheory.coequalizerRegular /-
 instance coequalizerRegular (g h : X ⟶ Y) [HasColimit (parallelPair g h)] :
     RegularEpi (coequalizer.π g h) where
   w := X
@@ -205,7 +236,9 @@ instance coequalizerRegular (g h : X ⟶ Y) [HasColimit (parallelPair g h)] :
       ext1
       simp [← w]
 #align category_theory.coequalizer_regular CategoryTheory.coequalizerRegular
+-/
 
+#print CategoryTheory.RegularEpi.ofSplitEpi /-
 /-- Every split epimorphism is a regular epimorphism. -/
 instance (priority := 100) RegularEpi.ofSplitEpi (f : X ⟶ Y) [IsSplitEpi f] : RegularEpi f
     where
@@ -215,7 +248,14 @@ instance (priority := 100) RegularEpi.ofSplitEpi (f : X ⟶ Y) [IsSplitEpi f] :
   w := by tidy
   IsColimit := isSplitEpiCoequalizes f
 #align category_theory.regular_epi.of_split_epi CategoryTheory.RegularEpi.ofSplitEpi
+-/
 
+/- warning: category_theory.regular_epi.desc' -> CategoryTheory.RegularEpi.desc' is a dubious translation:
+lean 3 declaration is
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {X : C} {Y : C} {W : C} (f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y) [_inst_2 : CategoryTheory.RegularEpi.{u1, u2} C _inst_1 X Y f] (k : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X W), (Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.RegularEpi.w.{u1, u2} C _inst_1 X Y f _inst_2) W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.RegularEpi.w.{u1, u2} C _inst_1 X Y f _inst_2) X W (CategoryTheory.RegularEpi.left.{u1, u2} C _inst_1 X Y f _inst_2) k) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.RegularEpi.w.{u1, u2} C _inst_1 X Y f _inst_2) X W (CategoryTheory.RegularEpi.right.{u1, u2} C _inst_1 X Y f _inst_2) k)) -> (Subtype.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) Y W) (fun (l : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) Y W) => Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) X Y W f l) k))
+but is expected to have type
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {X : C} {Y : C} {W : C} (f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y) [_inst_2 : CategoryTheory.RegularEpi.{u1, u2} C _inst_1 X Y f] (k : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X W), (Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.RegularEpi.W.{u1, u2} C _inst_1 X Y f _inst_2) W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.RegularEpi.W.{u1, u2} C _inst_1 X Y f _inst_2) X W (CategoryTheory.RegularEpi.left.{u1, u2} C _inst_1 X Y f _inst_2) k) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.RegularEpi.W.{u1, u2} C _inst_1 X Y f _inst_2) X W (CategoryTheory.RegularEpi.right.{u1, u2} C _inst_1 X Y f _inst_2) k)) -> (Subtype.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) Y W) (fun (l : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) Y W) => Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) X Y W f l) k))
+Case conversion may be inaccurate. Consider using '#align category_theory.regular_epi.desc' CategoryTheory.RegularEpi.desc'ₓ'. -/
 /-- If `f` is a regular epi, then every morphism `k : X ⟶ W` coequalizing `regular_epi.left` and
     `regular_epi.right` induces `l : Y ⟶ W` such that `f ≫ l = k`. -/
 def RegularEpi.desc' {W : C} (f : X ⟶ Y) [RegularEpi f] (k : X ⟶ W)
@@ -224,6 +264,7 @@ def RegularEpi.desc' {W : C} (f : X ⟶ Y) [RegularEpi f] (k : X ⟶ W)
   Cofork.IsColimit.desc' RegularEpi.isColimit _ h
 #align category_theory.regular_epi.desc' CategoryTheory.RegularEpi.desc'
 
+#print CategoryTheory.regularOfIsPushoutSndOfRegular /-
 /-- The second leg of a pushout cocone is a regular epimorphism if the right component is too.
 
 See also `pushout.snd_of_epi` for the basic epimorphism version, and
@@ -252,7 +293,9 @@ def regularOfIsPushoutSndOfRegular {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h
     · erw [← cancel_epi g, ← reassoc_of comm, ← reassoc_of comm, z]
       rfl
 #align category_theory.regular_of_is_pushout_snd_of_regular CategoryTheory.regularOfIsPushoutSndOfRegular
+-/
 
+#print CategoryTheory.regularOfIsPushoutFstOfRegular /-
 /-- The first leg of a pushout cocone is a regular epimorphism if the left component is too.
 
 See also `pushout.fst_of_epi` for the basic epimorphism version, and
@@ -263,7 +306,9 @@ def regularOfIsPushoutFstOfRegular {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h
     RegularEpi k :=
   regularOfIsPushoutSndOfRegular comm.symm (PushoutCocone.flipIsColimit t)
 #align category_theory.regular_of_is_pushout_fst_of_regular CategoryTheory.regularOfIsPushoutFstOfRegular
+-/
 
+#print CategoryTheory.strongEpi_of_regularEpi /-
 instance (priority := 100) strongEpi_of_regularEpi (f : X ⟶ Y) [RegularEpi f] : StrongEpi f :=
   StrongEpi.mk'
     (by
@@ -279,29 +324,37 @@ instance (priority := 100) strongEpi_of_regularEpi (f : X ⟶ Y) [RegularEpi f]
             (cancel_epi f).1
               (by simp only [← category.assoc, ht, ← sq.w, arrow.mk_hom, arrow.hom_mk'_right])⟩)
 #align category_theory.strong_epi_of_regular_epi CategoryTheory.strongEpi_of_regularEpi
+-/
 
+#print CategoryTheory.isIso_of_regularEpi_of_mono /-
 /-- A regular epimorphism is an isomorphism if it is a monomorphism. -/
 theorem isIso_of_regularEpi_of_mono (f : X ⟶ Y) [RegularEpi f] [m : Mono f] : IsIso f :=
   isIso_of_mono_of_strongEpi _
 #align category_theory.is_iso_of_regular_epi_of_mono CategoryTheory.isIso_of_regularEpi_of_mono
+-/
 
 section
 
 variable (C)
 
+#print CategoryTheory.RegularEpiCategory /-
 /-- A regular epi category is a category in which every epimorphism is regular. -/
 class RegularEpiCategory where
   regularEpiOfEpi : ∀ {X Y : C} (f : X ⟶ Y) [Epi f], RegularEpi f
 #align category_theory.regular_epi_category CategoryTheory.RegularEpiCategory
+-/
 
 end
 
+#print CategoryTheory.regularEpiOfEpi /-
 /-- In a category in which every epimorphism is regular, we can express every epimorphism as
     a coequalizer. This is not an instance because it would create an instance loop. -/
 def regularEpiOfEpi [RegularEpiCategory C] (f : X ⟶ Y) [Epi f] : RegularEpi f :=
   RegularEpiCategory.regularEpiOfEpi _
 #align category_theory.regular_epi_of_epi CategoryTheory.regularEpiOfEpi
+-/
 
+#print CategoryTheory.regularEpiCategoryOfSplitEpiCategory /-
 instance (priority := 100) regularEpiCategoryOfSplitEpiCategory [SplitEpiCategory C] :
     RegularEpiCategory C
     where regularEpiOfEpi _ _ f _ :=
@@ -309,7 +362,9 @@ instance (priority := 100) regularEpiCategoryOfSplitEpiCategory [SplitEpiCategor
     haveI := is_split_epi_of_epi f
     infer_instance
 #align category_theory.regular_epi_category_of_split_epi_category CategoryTheory.regularEpiCategoryOfSplitEpiCategory
+-/
 
+#print CategoryTheory.strongEpiCategory_of_regularEpiCategory /-
 instance (priority := 100) strongEpiCategory_of_regularEpiCategory [RegularEpiCategory C] :
     StrongEpiCategory C
     where strongEpi_of_epi _ _ f _ :=
@@ -317,6 +372,7 @@ instance (priority := 100) strongEpiCategory_of_regularEpiCategory [RegularEpiCa
     haveI := regular_epi_of_epi f
     infer_instance
 #align category_theory.strong_epi_category_of_regular_epi_category CategoryTheory.strongEpiCategory_of_regularEpiCategory
+-/
 
 end CategoryTheory

239d882c

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

239d882c

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

@@ -37,7 +37,6 @@ open CategoryTheory.Limits
 universe v₁ u₁ u₂
 
 variable {C : Type u₁} [Category.{v₁} C]
-
 variable {X Y : C}
 
 /-- A regular monomorphism is a morphism which is the equalizer of some parallel pair. -/

239d882c

feat(CategoryTheory): relate mathlib's notion of EffectiveEpi to more standard definitions and RegularEpi (#8426)

We prove that RegularEpi implies EffectiveEpi in full generality, and its converse under additional hypotheses.

886de864

Diff

@@ -212,6 +212,15 @@ instance coequalizerRegular (g h : X ⟶ Y) [HasColimit (parallelPair g h)] :
       simp [← w]
 #align category_theory.coequalizer_regular CategoryTheory.coequalizerRegular
 
+/-- A morphism which is a coequalizer for its kernel pair is a regular epi. -/
+noncomputable def regularEpiOfKernelPair {B X : C} (f : X ⟶ B) [HasPullback f f]
+    (hc : IsColimit (Cofork.ofπ f pullback.condition)) : RegularEpi f where
+  W := pullback f f
+  left := pullback.fst
+  right := pullback.snd
+  w := pullback.condition
+  isColimit := hc
+
 /-- Every split epimorphism is a regular epimorphism. -/
 instance (priority := 100) RegularEpi.ofSplitEpi (f : X ⟶ Y) [IsSplitEpi f] : RegularEpi f
     where

239d882c

chore: avoid lean3 style have/suffices (#6964)

Many proofs use the "stream of consciousness" style from Lean 3, rather than have ... := or suffices ... from/by.

This PR updates a fraction of these to the preferred Lean 4 style.

I think a good goal would be to delete the "deferred" versions of have, suffices, and let at the bottom of Mathlib.Tactic.Have

(Anyone who would like to contribute more cleanup is welcome to push directly to this branch.)

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

bdc47f68

Diff

@@ -107,8 +107,8 @@ def regularOfIsPullbackSndOfRegular {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h
   isLimit := by
     apply Fork.IsLimit.mk' _ _
     intro s
-    have l₁ : (Fork.ι s ≫ k) ≫ RegularMono.left = (Fork.ι s ≫ k) ≫ hr.right
-    rw [Category.assoc, s.condition, Category.assoc]
+    have l₁ : (Fork.ι s ≫ k) ≫ RegularMono.left = (Fork.ι s ≫ k) ≫ hr.right := by
+      rw [Category.assoc, s.condition, Category.assoc]
     obtain ⟨l, hl⟩ := Fork.IsLimit.lift' hr.isLimit _ l₁
     obtain ⟨p, _, hp₂⟩ := PullbackCone.IsLimit.lift' t _ _ hl
     refine' ⟨p, hp₂, _⟩
@@ -244,8 +244,8 @@ def regularOfIsPushoutSndOfRegular {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h
   isColimit := by
     apply Cofork.IsColimit.mk' _ _
     intro s
-    have l₁ : gr.left ≫ f ≫ s.π = gr.right ≫ f ≫ s.π
-    rw [← Category.assoc, ← Category.assoc, s.condition]
+    have l₁ : gr.left ≫ f ≫ s.π = gr.right ≫ f ≫ s.π := by
+      rw [← Category.assoc, ← Category.assoc, s.condition]
     obtain ⟨l, hl⟩ := Cofork.IsColimit.desc' gr.isColimit (f ≫ Cofork.π s) l₁
     obtain ⟨p, hp₁, _⟩ := PushoutCocone.IsColimit.desc' t _ _ hl.symm
     refine' ⟨p, hp₁, _⟩

239d882c

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Bhavik Mehta
-
-! This file was ported from Lean 3 source module category_theory.limits.shapes.regular_mono
-! leanprover-community/mathlib commit 239d882c4fb58361ee8b3b39fb2091320edef10a
-! 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.StrongEpi
 import Mathlib.CategoryTheory.Limits.Shapes.Equalizers
 import Mathlib.Lean.Expr.Basic
 
+#align_import category_theory.limits.shapes.regular_mono from "leanprover-community/mathlib"@"239d882c4fb58361ee8b3b39fb2091320edef10a"
+
 /-!
 # Definitions and basic properties of regular monomorphisms and epimorphisms.

239d882c

feat: more consistent use of ext, and updating porting notes. (#5242)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

dbae2f17

Diff

@@ -211,7 +211,8 @@ instance coequalizerRegular (g h : X ⟶ Y) [HasColimit (parallelPair g h)] :
   w := coequalizer.condition g h
   isColimit :=
     Cofork.IsColimit.mk _ (fun s => colimit.desc _ s) (by simp) fun s m w => by
-      apply coequalizer.hom_ext; simp [← w]
+      apply coequalizer.hom_ext
+      simp [← w]
 #align category_theory.coequalizer_regular CategoryTheory.coequalizerRegular
 
 /-- Every split epimorphism is a regular epimorphism. -/

239d882c

chore: review of automation in category theory (#4793)

Clean up of automation in the category theory library. Leaving out unnecessary proof steps, or fields done by aesop_cat, and making more use of available autoparameters.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

5b958613

Diff

@@ -52,7 +52,7 @@ class RegularMono (f : X ⟶ Y) where
   /-- Another map from the codomain of `f` to `Z` -/
   right : Y ⟶ Z
   /-- `f` equalizes the two maps -/
-  w : f ≫ left = f ≫ right
+  w : f ≫ left = f ≫ right := by aesop_cat
   /-- `f` is the equalizer of the two maps -/
   isLimit : IsLimit (Fork.ofι f w)
 #align category_theory.regular_mono CategoryTheory.RegularMono
@@ -77,12 +77,11 @@ instance equalizerRegular (g h : X ⟶ Y) [HasLimit (parallelPair g h)] :
 #align category_theory.equalizer_regular CategoryTheory.equalizerRegular
 
 /-- Every split monomorphism is a regular monomorphism. -/
-instance (priority := 100) RegularMono.ofIsSplitMono (f : X ⟶ Y) [IsSplitMono f] : RegularMono f
-    where
+instance (priority := 100) RegularMono.ofIsSplitMono (f : X ⟶ Y) [IsSplitMono f] :
+    RegularMono f where
   Z := Y
   left := 𝟙 Y
   right := retraction f ≫ f
-  w := by aesop_cat
   isLimit := isSplitMonoEqualizes f
 #align category_theory.regular_mono.of_is_split_mono CategoryTheory.RegularMono.ofIsSplitMono
 
@@ -192,7 +191,7 @@ class RegularEpi (f : X ⟶ Y) where
   /-- Two maps to the domain of `f` -/
   (left right : W ⟶ X)
   /-- `f` coequalizes the two maps -/
-  w : left ≫ f = right ≫ f
+  w : left ≫ f = right ≫ f := by aesop_cat
   /-- `f` is the coequalizer -/
   isColimit : IsColimit (Cofork.ofπ f w)
 #align category_theory.regular_epi CategoryTheory.RegularEpi
@@ -221,7 +220,6 @@ instance (priority := 100) RegularEpi.ofSplitEpi (f : X ⟶ Y) [IsSplitEpi f] :
   W := X
   left := 𝟙 X
   right := f ≫ section_ f
-  w := by aesop_cat
   isColimit := isSplitEpiCoequalizes f
 #align category_theory.regular_epi.of_split_epi CategoryTheory.RegularEpi.ofSplitEpi

239d882c

chore: bye-bye, solo bys! (#3825)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

14167e48

Diff

@@ -71,8 +71,7 @@ instance equalizerRegular (g h : X ⟶ Y) [HasLimit (parallelPair g h)] :
   right := h
   w := equalizer.condition g h
   isLimit :=
-    Fork.IsLimit.mk _ (fun s => limit.lift _ s) (by simp) fun s m w =>
-      by
+    Fork.IsLimit.mk _ (fun s => limit.lift _ s) (by simp) fun s m w => by
       apply equalizer.hom_ext
       simp [← w]
 #align category_theory.equalizer_regular CategoryTheory.equalizerRegular
@@ -279,8 +278,7 @@ instance (priority := 100) strongEpi_of_regularEpi (f : X ⟶ Y) [RegularEpi f]
   StrongEpi.mk'
     (by
       intro A B z hz u v sq
-      have : (RegularEpi.left : RegularEpi.W f ⟶ X) ≫ u = RegularEpi.right ≫ u :=
-        by
+      have : (RegularEpi.left : RegularEpi.W f ⟶ X) ≫ u = RegularEpi.right ≫ u := by
         apply (cancel_mono z).1
         simp only [Category.assoc, sq.w, RegularEpi.w_assoc]
       obtain ⟨t, ht⟩ := RegularEpi.desc' f u this
@@ -316,8 +314,7 @@ def regularEpiOfEpi [RegularEpiCategory C] (f : X ⟶ Y) [Epi f] : RegularEpi f
 
 instance (priority := 100) regularEpiCategoryOfSplitEpiCategory [SplitEpiCategory C] :
     RegularEpiCategory C where
-  regularEpiOfEpi f _ :=
-    by
+  regularEpiOfEpi f _ := by
     haveI := isSplitEpi_of_epi f
     infer_instance
 #align category_theory.regular_epi_category_of_split_epi_category CategoryTheory.regularEpiCategoryOfSplitEpiCategory

239d882c

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

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

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

This was done with a regex search in vscode,

6ceb5945

Diff

@@ -106,8 +106,8 @@ def regularOfIsPullbackSndOfRegular {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h
   Z := hr.Z
   left := k ≫ hr.left
   right := k ≫ hr.right
-  w := by 
-    repeat (rw [← Category.assoc, ← eq_whisker comm]) 
+  w := by
+    repeat (rw [← Category.assoc, ← eq_whisker comm])
     simp only [Category.assoc, hr.w]
   isLimit := by
     apply Fork.IsLimit.mk' _ _
@@ -173,14 +173,14 @@ def regularMonoOfMono [RegularMonoCategory C] (f : X ⟶ Y) [Mono f] : RegularMo
 #align category_theory.regular_mono_of_mono CategoryTheory.regularMonoOfMono
 
 instance (priority := 100) regularMonoCategoryOfSplitMonoCategory [SplitMonoCategory C] :
-    RegularMonoCategory C where 
+    RegularMonoCategory C where
   regularMonoOfMono f _ := by
     haveI := isSplitMono_of_mono f
     infer_instance
 #align category_theory.regular_mono_category_of_split_mono_category CategoryTheory.regularMonoCategoryOfSplitMonoCategory
 
 instance (priority := 100) strongMonoCategory_of_regularMonoCategory [RegularMonoCategory C] :
-    StrongMonoCategory C where 
+    StrongMonoCategory C where
   strongMono_of_mono f _ := by
     haveI := regularMonoOfMono f
     infer_instance
@@ -315,7 +315,7 @@ def regularEpiOfEpi [RegularEpiCategory C] (f : X ⟶ Y) [Epi f] : RegularEpi f
 #align category_theory.regular_epi_of_epi CategoryTheory.regularEpiOfEpi
 
 instance (priority := 100) regularEpiCategoryOfSplitEpiCategory [SplitEpiCategory C] :
-    RegularEpiCategory C where 
+    RegularEpiCategory C where
   regularEpiOfEpi f _ :=
     by
     haveI := isSplitEpi_of_epi f
@@ -330,4 +330,3 @@ instance (priority := 100) strongEpiCategory_of_regularEpiCategory [RegularEpiCa
 #align category_theory.strong_epi_category_of_regular_epi_category CategoryTheory.strongEpiCategory_of_regularEpiCategory
 
 end CategoryTheory
-

239d882c

feat: port CategoryTheory.Limits.Shapes.RegularMono (#2686)

eaca0de1

`category_theory.limits.shapes.regular_mono` ⟷ `Mathlib.CategoryTheory.Limits.Shapes.RegularMono`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 111

category_theory.limits.shapes.regular_mono ⟷ Mathlib.CategoryTheory.Limits.Shapes.RegularMono

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 111

`category_theory.limits.shapes.regular_mono` ⟷ `Mathlib.CategoryTheory.Limits.Shapes.RegularMono`