category_theory.limits.shapes.normal_mono.basic

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

bbe25d4d

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

69c6a5a1

bump to nightly-2024-04-14-09

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

f736ea6b

Diff

@@ -64,11 +64,11 @@ attribute [local instance] equivalence.ess_surj_of_equivalence
 #print CategoryTheory.equivalenceReflectsNormalMono /-
 /-- If `F` is an equivalence and `F.map f` is a normal mono, then `f` is a normal mono. -/
 def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMorphisms D] (F : C ⥤ D)
-    [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalMono (F.map f)) : NormalMono f
-    where
+    [CategoryTheory.Functor.IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalMono (F.map f)) :
+    NormalMono f where
   z := F.objPreimage hf.z
-  g := Full.preimage (hf.g ≫ (F.objObjPreimageIso hf.z).inv)
-  w := Faithful.map_injective F <| by simp [reassoc_of hf.w]
+  g := CategoryTheory.Functor.Full.preimage (hf.g ≫ (F.objObjPreimageIso hf.z).inv)
+  w := CategoryTheory.Functor.Faithful.map_injective F <| by simp [reassoc_of hf.w]
   IsLimit :=
     ReflectsLimit.reflects <|
       IsLimit.ofConeEquiv (Cones.postcomposeEquivalence (compNatIso F : _)) <|
@@ -188,11 +188,11 @@ attribute [local instance] equivalence.ess_surj_of_equivalence
 #print CategoryTheory.equivalenceReflectsNormalEpi /-
 /-- If `F` is an equivalence and `F.map f` is a normal epi, then `f` is a normal epi. -/
 def equivalenceReflectsNormalEpi {D : Type u₂} [Category.{v₁} D] [HasZeroMorphisms D] (F : C ⥤ D)
-    [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalEpi (F.map f)) : NormalEpi f
-    where
+    [CategoryTheory.Functor.IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalEpi (F.map f)) :
+    NormalEpi f where
   w := F.objPreimage hf.w
-  g := Full.preimage ((F.objObjPreimageIso hf.w).Hom ≫ hf.g)
-  w := Faithful.map_injective F <| by simp [hf.w]
+  g := CategoryTheory.Functor.Full.preimage ((F.objObjPreimageIso hf.w).Hom ≫ hf.g)
+  w := CategoryTheory.Functor.Faithful.map_injective F <| by simp [hf.w]
   IsColimit :=
     ReflectsColimit.reflects <|
       IsColimit.ofCoconeEquiv (Cocones.precomposeEquivalence (compNatIso F).symm) <|

69c6a5a1

bump to nightly-2024-02-10-08

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

c6692027

Diff

@@ -131,7 +131,7 @@ See also `pullback.fst_of_mono` for the basic monomorphism version, and
 def normalOfIsPullbackFstOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S}
     [hn : NormalMono k] (comm : f ≫ h = g ≫ k) (t : IsLimit (PullbackCone.mk _ _ comm)) :
     NormalMono f :=
-  normalOfIsPullbackSndOfNormal comm.symm (PullbackCone.flipIsLimit t)
+  normalOfIsPullbackSndOfNormal comm.symm (PullbackCone.isLimitOfFlip t)
 #align category_theory.normal_of_is_pullback_fst_of_normal CategoryTheory.normalOfIsPullbackFstOfNormal
 -/
 
@@ -255,7 +255,7 @@ See also `pushout.fst_of_epi` for the basic epimorphism version, and
 def normalOfIsPushoutFstOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S}
     [hn : NormalEpi f] (comm : f ≫ h = g ≫ k) (t : IsColimit (PushoutCocone.mk _ _ comm)) :
     NormalEpi k :=
-  normalOfIsPushoutSndOfNormal comm.symm (PushoutCocone.flipIsColimit t)
+  normalOfIsPushoutSndOfNormal comm.symm (PushoutCocone.isColimitOfFlip t)
 #align category_theory.normal_of_is_pushout_fst_of_normal CategoryTheory.normalOfIsPushoutFstOfNormal
 -/

69c6a5a1

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.RegularMono
-import Mathbin.CategoryTheory.Limits.Shapes.Kernels
-import Mathbin.CategoryTheory.Limits.Preserves.Basic
+import CategoryTheory.Limits.Shapes.RegularMono
+import CategoryTheory.Limits.Shapes.Kernels
+import CategoryTheory.Limits.Preserves.Basic
 
 #align_import category_theory.limits.shapes.normal_mono.basic from "leanprover-community/mathlib"@"69c6a5a12d8a2b159f20933e60115a4f2de62b58"

69c6a5a1

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.normal_mono.basic
-! leanprover-community/mathlib commit 69c6a5a12d8a2b159f20933e60115a4f2de62b58
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Limits.Shapes.RegularMono
 import Mathbin.CategoryTheory.Limits.Shapes.Kernels
 import Mathbin.CategoryTheory.Limits.Preserves.Basic
 
+#align_import category_theory.limits.shapes.normal_mono.basic from "leanprover-community/mathlib"@"69c6a5a12d8a2b159f20933e60115a4f2de62b58"
+
 /-!
 # Definitions and basic properties of normal monomorphisms and epimorphisms.

69c6a5a1

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -64,6 +64,7 @@ attribute [local instance] fully_faithful_reflects_limits
 
 attribute [local instance] equivalence.ess_surj_of_equivalence
 
+#print CategoryTheory.equivalenceReflectsNormalMono /-
 /-- If `F` is an equivalence and `F.map f` is a normal mono, then `f` is a normal mono. -/
 def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMorphisms D] (F : C ⥤ D)
     [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalMono (F.map f)) : NormalMono f
@@ -80,6 +81,7 @@ def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMo
             (of_ι_congr (category.comp_id _).symm))
           (isoOfι _).symm
 #align category_theory.equivalence_reflects_normal_mono CategoryTheory.equivalenceReflectsNormalMono
+-/
 
 end
 
@@ -186,6 +188,7 @@ attribute [local instance] fully_faithful_reflects_colimits
 
 attribute [local instance] equivalence.ess_surj_of_equivalence
 
+#print CategoryTheory.equivalenceReflectsNormalEpi /-
 /-- If `F` is an equivalence and `F.map f` is a normal epi, then `f` is a normal epi. -/
 def equivalenceReflectsNormalEpi {D : Type u₂} [Category.{v₁} D] [HasZeroMorphisms D] (F : C ⥤ D)
     [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalEpi (F.map f)) : NormalEpi f
@@ -202,6 +205,7 @@ def equivalenceReflectsNormalEpi {D : Type u₂} [Category.{v₁} D] [HasZeroMor
             (of_π_congr (category.id_comp _).symm))
           (isoOfπ _).symm
 #align category_theory.equivalence_reflects_normal_epi CategoryTheory.equivalenceReflectsNormalEpi
+-/
 
 end
 
@@ -215,12 +219,14 @@ instance (priority := 100) NormalEpi.regularEpi (f : X ⟶ Y) [I : NormalEpi f]
 #align category_theory.normal_epi.regular_epi CategoryTheory.NormalEpi.regularEpi
 -/
 
+#print CategoryTheory.NormalEpi.desc' /-
 /-- If `f` is a normal epi, then every morphism `k : X ⟶ W` satisfying `normal_epi.g ≫ k = 0`
     induces `l : Y ⟶ W` such that `f ≫ l = k`. -/
 def NormalEpi.desc' {W : C} (f : X ⟶ Y) [NormalEpi f] (k : X ⟶ W) (h : NormalEpi.g ≫ k = 0) :
     { l : Y ⟶ W // f ≫ l = k } :=
   CokernelCofork.IsColimit.desc' NormalEpi.isColimit _ h
 #align category_theory.normal_epi.desc' CategoryTheory.NormalEpi.desc'
+-/
 
 #print CategoryTheory.normalOfIsPushoutSndOfNormal /-
 /-- The second leg of a pushout cocone is a normal epimorphism if the right component is too.

69c6a5a1

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -119,7 +119,7 @@ def normalOfIsPullbackSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
     have q := (has_zero_morphisms.comp_zero k hn.Z).symm
     convert gr.is_limit
     dsimp only [kernel_fork.of_ι, fork.of_ι]
-    congr ; exact q; exact q; exact q; apply proof_irrel_heq
+    congr; exact q; exact q; exact q; apply proof_irrel_heq
 #align category_theory.normal_of_is_pullback_snd_of_normal CategoryTheory.normalOfIsPullbackSndOfNormal
 -/
 
@@ -239,7 +239,7 @@ def normalOfIsPushoutSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
     have q := (@zero_comp _ _ _ gn.W _ _ f).symm
     convert hn.is_colimit
     dsimp only [cokernel_cofork.of_π, cofork.of_π]
-    congr ; exact q; exact q; exact q; apply proof_irrel_heq
+    congr; exact q; exact q; exact q; apply proof_irrel_heq
 #align category_theory.normal_of_is_pushout_snd_of_normal CategoryTheory.normalOfIsPushoutSndOfNormal
 -/

69c6a5a1

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -64,12 +64,6 @@ attribute [local instance] fully_faithful_reflects_limits
 
 attribute [local instance] equivalence.ess_surj_of_equivalence
 
-/- warning: category_theory.equivalence_reflects_normal_mono -> CategoryTheory.equivalenceReflectsNormalMono is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {D : Type.{u3}} [_inst_3 : CategoryTheory.Category.{u1, u3} D] [_inst_4 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u3} D _inst_3] (F : CategoryTheory.Functor.{u1, u1, u2, u3} C _inst_1 D _inst_3) [_inst_5 : CategoryTheory.IsEquivalence.{u1, u1, u2, u3} C _inst_1 D _inst_3 F] {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y}, (CategoryTheory.NormalMono.{u1, u3} D _inst_3 (CategoryTheory.Functor.obj.{u1, u1, u2, u3} C _inst_1 D _inst_3 F X) (CategoryTheory.Functor.obj.{u1, u1, u2, u3} C _inst_1 D _inst_3 F Y) _inst_4 (CategoryTheory.Functor.map.{u1, u1, u2, u3} C _inst_1 D _inst_3 F X Y f)) -> (CategoryTheory.NormalMono.{u1, u2} C _inst_1 X Y _inst_2 f)
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {D : Type.{u3}} [_inst_3 : CategoryTheory.Category.{u1, u3} D] [_inst_4 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u3} D _inst_3] (F : CategoryTheory.Functor.{u1, u1, u2, u3} C _inst_1 D _inst_3) [_inst_5 : CategoryTheory.IsEquivalence.{u1, u1, u2, u3} C _inst_1 D _inst_3 F] {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y}, (CategoryTheory.NormalMono.{u1, u3} D _inst_3 (Prefunctor.obj.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) X) (Prefunctor.obj.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) Y) _inst_4 (Prefunctor.map.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) X Y f)) -> (CategoryTheory.NormalMono.{u1, u2} C _inst_1 X Y _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence_reflects_normal_mono CategoryTheory.equivalenceReflectsNormalMonoₓ'. -/
 /-- If `F` is an equivalence and `F.map f` is a normal mono, then `f` is a normal mono. -/
 def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMorphisms D] (F : C ⥤ D)
     [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalMono (F.map f)) : NormalMono f
@@ -192,12 +186,6 @@ attribute [local instance] fully_faithful_reflects_colimits
 
 attribute [local instance] equivalence.ess_surj_of_equivalence
 
-/- warning: category_theory.equivalence_reflects_normal_epi -> CategoryTheory.equivalenceReflectsNormalEpi is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {D : Type.{u3}} [_inst_3 : CategoryTheory.Category.{u1, u3} D] [_inst_4 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u3} D _inst_3] (F : CategoryTheory.Functor.{u1, u1, u2, u3} C _inst_1 D _inst_3) [_inst_5 : CategoryTheory.IsEquivalence.{u1, u1, u2, u3} C _inst_1 D _inst_3 F] {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y}, (CategoryTheory.NormalEpi.{u1, u3} D _inst_3 (CategoryTheory.Functor.obj.{u1, u1, u2, u3} C _inst_1 D _inst_3 F X) (CategoryTheory.Functor.obj.{u1, u1, u2, u3} C _inst_1 D _inst_3 F Y) _inst_4 (CategoryTheory.Functor.map.{u1, u1, u2, u3} C _inst_1 D _inst_3 F X Y f)) -> (CategoryTheory.NormalEpi.{u1, u2} C _inst_1 X Y _inst_2 f)
-but is expected to have type
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {D : Type.{u3}} [_inst_3 : CategoryTheory.Category.{u1, u3} D] [_inst_4 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u3} D _inst_3] (F : CategoryTheory.Functor.{u1, u1, u2, u3} C _inst_1 D _inst_3) [_inst_5 : CategoryTheory.IsEquivalence.{u1, u1, u2, u3} C _inst_1 D _inst_3 F] {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y}, (CategoryTheory.NormalEpi.{u1, u3} D _inst_3 (Prefunctor.obj.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) X) (Prefunctor.obj.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) Y) _inst_4 (Prefunctor.map.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) X Y f)) -> (CategoryTheory.NormalEpi.{u1, u2} C _inst_1 X Y _inst_2 f)
-Case conversion may be inaccurate. Consider using '#align category_theory.equivalence_reflects_normal_epi CategoryTheory.equivalenceReflectsNormalEpiₓ'. -/
 /-- If `F` is an equivalence and `F.map f` is a normal epi, then `f` is a normal epi. -/
 def equivalenceReflectsNormalEpi {D : Type u₂} [Category.{v₁} D] [HasZeroMorphisms D] (F : C ⥤ D)
     [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalEpi (F.map f)) : NormalEpi f
@@ -227,12 +215,6 @@ instance (priority := 100) NormalEpi.regularEpi (f : X ⟶ Y) [I : NormalEpi f]
 #align category_theory.normal_epi.regular_epi CategoryTheory.NormalEpi.regularEpi
 -/
 
-/- warning: category_theory.normal_epi.desc' -> CategoryTheory.NormalEpi.desc' is a dubious translation:
-lean 3 declaration is
-  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {X : C} {Y : C} [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {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_3 : CategoryTheory.NormalEpi.{u1, u2} C _inst_1 X Y _inst_2 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.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) X W (CategoryTheory.NormalEpi.g.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) k) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) 0 (OfNat.mk.{u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) 0 (Zero.zero.{u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) (CategoryTheory.Limits.HasZeroMorphisms.hasZero.{u1, u2} C _inst_1 _inst_2 (CategoryTheory.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W))))) -> (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} [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {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_3 : CategoryTheory.NormalEpi.{u1, u2} C _inst_1 X Y _inst_2 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.NormalEpi.W.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.NormalEpi.W.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) X W (CategoryTheory.NormalEpi.g.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) k) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.NormalEpi.W.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) 0 (Zero.toOfNat0.{u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.NormalEpi.W.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) (CategoryTheory.Limits.HasZeroMorphisms.Zero.{u1, u2} C _inst_1 _inst_2 (CategoryTheory.NormalEpi.W.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W)))) -> (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.normal_epi.desc' CategoryTheory.NormalEpi.desc'ₓ'. -/
 /-- If `f` is a normal epi, then every morphism `k : X ⟶ W` satisfying `normal_epi.g ≫ k = 0`
     induces `l : Y ⟶ W` such that `f ≫ l = k`. -/
 def NormalEpi.desc' {W : C} (f : X ⟶ Y) [NormalEpi f] (k : X ⟶ W) (h : NormalEpi.g ≫ k = 0) :

69c6a5a1

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -166,10 +166,7 @@ def normalMonoOfMono [NormalMonoCategory C] (f : X ⟶ Y) [Mono f] : NormalMono
 #print CategoryTheory.regularMonoCategoryOfNormalMonoCategory /-
 instance (priority := 100) regularMonoCategoryOfNormalMonoCategory [NormalMonoCategory C] :
     RegularMonoCategory C
-    where regularMonoOfMono _ _ f _ :=
-    by
-    haveI := normal_mono_of_mono f
-    infer_instance
+    where regularMonoOfMono _ _ f _ := by haveI := normal_mono_of_mono f; infer_instance
 #align category_theory.regular_mono_category_of_normal_mono_category CategoryTheory.regularMonoCategoryOfNormalMonoCategory
 -/
 
@@ -351,10 +348,7 @@ def normalEpiOfEpi [NormalEpiCategory C] (f : X ⟶ Y) [Epi f] : NormalEpi f :=
 #print CategoryTheory.regularEpiCategoryOfNormalEpiCategory /-
 instance (priority := 100) regularEpiCategoryOfNormalEpiCategory [NormalEpiCategory C] :
     RegularEpiCategory C
-    where regularEpiOfEpi _ _ f _ :=
-    by
-    haveI := normal_epi_of_epi f
-    infer_instance
+    where regularEpiOfEpi _ _ f _ := by haveI := normal_epi_of_epi f; infer_instance
 #align category_theory.regular_epi_category_of_normal_epi_category CategoryTheory.regularEpiCategoryOfNormalEpiCategory
 -/

69c6a5a1

bump to nightly-2023-03-14-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

d4b38a42

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.normal_mono.basic
-! leanprover-community/mathlib commit bbe25d4d92565a5fd773e52e041a90387eee3c93
+! leanprover-community/mathlib commit 69c6a5a12d8a2b159f20933e60115a4f2de62b58
 ! 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.Preserves.Basic
 /-!
 # Definitions and basic properties of normal monomorphisms and epimorphisms.
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 A normal monomorphism is a morphism that is the kernel of some other morphism.
 
 We give the construction `normal_mono → regular_mono` (`category_theory.normal_mono.regular_mono`)

bbe25d4d

bump to nightly-2023-03-08-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

fb83156a

Diff

@@ -45,6 +45,7 @@ section
 
 variable [HasZeroMorphisms C]
 
+#print CategoryTheory.NormalMono /-
 /-- A normal monomorphism is a morphism which is the kernel of some morphism. -/
 class NormalMono (f : X ⟶ Y) where
   z : C
@@ -52,6 +53,7 @@ class NormalMono (f : X ⟶ Y) where
   w : f ≫ g = 0
   IsLimit : IsLimit (KernelFork.ofι f w)
 #align category_theory.normal_mono CategoryTheory.NormalMono
+-/
 
 section
 
@@ -59,6 +61,12 @@ attribute [local instance] fully_faithful_reflects_limits
 
 attribute [local instance] equivalence.ess_surj_of_equivalence
 
+/- warning: category_theory.equivalence_reflects_normal_mono -> CategoryTheory.equivalenceReflectsNormalMono is a dubious translation:
+lean 3 declaration is
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {D : Type.{u3}} [_inst_3 : CategoryTheory.Category.{u1, u3} D] [_inst_4 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u3} D _inst_3] (F : CategoryTheory.Functor.{u1, u1, u2, u3} C _inst_1 D _inst_3) [_inst_5 : CategoryTheory.IsEquivalence.{u1, u1, u2, u3} C _inst_1 D _inst_3 F] {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y}, (CategoryTheory.NormalMono.{u1, u3} D _inst_3 (CategoryTheory.Functor.obj.{u1, u1, u2, u3} C _inst_1 D _inst_3 F X) (CategoryTheory.Functor.obj.{u1, u1, u2, u3} C _inst_1 D _inst_3 F Y) _inst_4 (CategoryTheory.Functor.map.{u1, u1, u2, u3} C _inst_1 D _inst_3 F X Y f)) -> (CategoryTheory.NormalMono.{u1, u2} C _inst_1 X Y _inst_2 f)
+but is expected to have type
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {D : Type.{u3}} [_inst_3 : CategoryTheory.Category.{u1, u3} D] [_inst_4 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u3} D _inst_3] (F : CategoryTheory.Functor.{u1, u1, u2, u3} C _inst_1 D _inst_3) [_inst_5 : CategoryTheory.IsEquivalence.{u1, u1, u2, u3} C _inst_1 D _inst_3 F] {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y}, (CategoryTheory.NormalMono.{u1, u3} D _inst_3 (Prefunctor.obj.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) X) (Prefunctor.obj.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) Y) _inst_4 (Prefunctor.map.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) X Y f)) -> (CategoryTheory.NormalMono.{u1, u2} C _inst_1 X Y _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align category_theory.equivalence_reflects_normal_mono CategoryTheory.equivalenceReflectsNormalMonoₓ'. -/
 /-- If `F` is an equivalence and `F.map f` is a normal mono, then `f` is a normal mono. -/
 def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMorphisms D] (F : C ⥤ D)
     [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalMono (F.map f)) : NormalMono f
@@ -78,6 +86,7 @@ def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMo
 
 end
 
+#print CategoryTheory.NormalMono.regularMono /-
 /-- Every normal monomorphism is a regular monomorphism. -/
 instance (priority := 100) NormalMono.regularMono (f : X ⟶ Y) [I : NormalMono f] : RegularMono f :=
   { I with
@@ -85,14 +94,18 @@ instance (priority := 100) NormalMono.regularMono (f : X ⟶ Y) [I : NormalMono
     right := 0
     w := by simpa using I.w }
 #align category_theory.normal_mono.regular_mono CategoryTheory.NormalMono.regularMono
+-/
 
+#print CategoryTheory.NormalMono.lift' /-
 /-- If `f` is a normal mono, then any map `k : W ⟶ Y` such that `k ≫ normal_mono.g = 0` induces
     a morphism `l : W ⟶ X` such that `l ≫ f = k`. -/
 def NormalMono.lift' {W : C} (f : X ⟶ Y) [NormalMono f] (k : W ⟶ Y) (h : k ≫ NormalMono.g = 0) :
     { l : W ⟶ X // l ≫ f = k } :=
   KernelFork.IsLimit.lift' NormalMono.isLimit _ h
 #align category_theory.normal_mono.lift' CategoryTheory.NormalMono.lift'
+-/
 
+#print CategoryTheory.normalOfIsPullbackSndOfNormal /-
 /-- The second leg of a pullback cone is a normal monomorphism if the right component is too.
 
 See also `pullback.snd_of_mono` for the basic monomorphism version, and
@@ -111,7 +124,9 @@ def normalOfIsPullbackSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
     dsimp only [kernel_fork.of_ι, fork.of_ι]
     congr ; exact q; exact q; exact q; apply proof_irrel_heq
 #align category_theory.normal_of_is_pullback_snd_of_normal CategoryTheory.normalOfIsPullbackSndOfNormal
+-/
 
+#print CategoryTheory.normalOfIsPullbackFstOfNormal /-
 /-- The first leg of a pullback cone is a normal monomorphism if the left component is too.
 
 See also `pullback.fst_of_mono` for the basic monomorphism version, and
@@ -122,24 +137,30 @@ def normalOfIsPullbackFstOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
     NormalMono f :=
   normalOfIsPullbackSndOfNormal comm.symm (PullbackCone.flipIsLimit t)
 #align category_theory.normal_of_is_pullback_fst_of_normal CategoryTheory.normalOfIsPullbackFstOfNormal
+-/
 
 section
 
 variable (C)
 
+#print CategoryTheory.NormalMonoCategory /-
 /-- A normal mono category is a category in which every monomorphism is normal. -/
 class NormalMonoCategory where
   normalMonoOfMono : ∀ {X Y : C} (f : X ⟶ Y) [Mono f], NormalMono f
 #align category_theory.normal_mono_category CategoryTheory.NormalMonoCategory
+-/
 
 end
 
+#print CategoryTheory.normalMonoOfMono /-
 /-- In a category in which every monomorphism is normal, we can express every monomorphism as
     a kernel. This is not an instance because it would create an instance loop. -/
 def normalMonoOfMono [NormalMonoCategory C] (f : X ⟶ Y) [Mono f] : NormalMono f :=
   NormalMonoCategory.normalMonoOfMono _
 #align category_theory.normal_mono_of_mono CategoryTheory.normalMonoOfMono
+-/
 
+#print CategoryTheory.regularMonoCategoryOfNormalMonoCategory /-
 instance (priority := 100) regularMonoCategoryOfNormalMonoCategory [NormalMonoCategory C] :
     RegularMonoCategory C
     where regularMonoOfMono _ _ f _ :=
@@ -147,6 +168,7 @@ instance (priority := 100) regularMonoCategoryOfNormalMonoCategory [NormalMonoCa
     haveI := normal_mono_of_mono f
     infer_instance
 #align category_theory.regular_mono_category_of_normal_mono_category CategoryTheory.regularMonoCategoryOfNormalMonoCategory
+-/
 
 end
 
@@ -154,6 +176,7 @@ section
 
 variable [HasZeroMorphisms C]
 
+#print CategoryTheory.NormalEpi /-
 /-- A normal epimorphism is a morphism which is the cokernel of some morphism. -/
 class NormalEpi (f : X ⟶ Y) where
   w : C
@@ -161,6 +184,7 @@ class NormalEpi (f : X ⟶ Y) where
   w : g ≫ f = 0
   IsColimit : IsColimit (CokernelCofork.ofπ f w)
 #align category_theory.normal_epi CategoryTheory.NormalEpi
+-/
 
 section
 
@@ -168,6 +192,12 @@ attribute [local instance] fully_faithful_reflects_colimits
 
 attribute [local instance] equivalence.ess_surj_of_equivalence
 
+/- warning: category_theory.equivalence_reflects_normal_epi -> CategoryTheory.equivalenceReflectsNormalEpi is a dubious translation:
+lean 3 declaration is
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {D : Type.{u3}} [_inst_3 : CategoryTheory.Category.{u1, u3} D] [_inst_4 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u3} D _inst_3] (F : CategoryTheory.Functor.{u1, u1, u2, u3} C _inst_1 D _inst_3) [_inst_5 : CategoryTheory.IsEquivalence.{u1, u1, u2, u3} C _inst_1 D _inst_3 F] {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y}, (CategoryTheory.NormalEpi.{u1, u3} D _inst_3 (CategoryTheory.Functor.obj.{u1, u1, u2, u3} C _inst_1 D _inst_3 F X) (CategoryTheory.Functor.obj.{u1, u1, u2, u3} C _inst_1 D _inst_3 F Y) _inst_4 (CategoryTheory.Functor.map.{u1, u1, u2, u3} C _inst_1 D _inst_3 F X Y f)) -> (CategoryTheory.NormalEpi.{u1, u2} C _inst_1 X Y _inst_2 f)
+but is expected to have type
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {D : Type.{u3}} [_inst_3 : CategoryTheory.Category.{u1, u3} D] [_inst_4 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u3} D _inst_3] (F : CategoryTheory.Functor.{u1, u1, u2, u3} C _inst_1 D _inst_3) [_inst_5 : CategoryTheory.IsEquivalence.{u1, u1, u2, u3} C _inst_1 D _inst_3 F] {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) X Y}, (CategoryTheory.NormalEpi.{u1, u3} D _inst_3 (Prefunctor.obj.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) X) (Prefunctor.obj.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) Y) _inst_4 (Prefunctor.map.{succ u1, succ u1, u2, u3} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u3} D (CategoryTheory.Category.toCategoryStruct.{u1, u3} D _inst_3)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u3} C _inst_1 D _inst_3 F) X Y f)) -> (CategoryTheory.NormalEpi.{u1, u2} C _inst_1 X Y _inst_2 f)
+Case conversion may be inaccurate. Consider using '#align category_theory.equivalence_reflects_normal_epi CategoryTheory.equivalenceReflectsNormalEpiₓ'. -/
 /-- If `F` is an equivalence and `F.map f` is a normal epi, then `f` is a normal epi. -/
 def equivalenceReflectsNormalEpi {D : Type u₂} [Category.{v₁} D] [HasZeroMorphisms D] (F : C ⥤ D)
     [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalEpi (F.map f)) : NormalEpi f
@@ -187,6 +217,7 @@ def equivalenceReflectsNormalEpi {D : Type u₂} [Category.{v₁} D] [HasZeroMor
 
 end
 
+#print CategoryTheory.NormalEpi.regularEpi /-
 /-- Every normal epimorphism is a regular epimorphism. -/
 instance (priority := 100) NormalEpi.regularEpi (f : X ⟶ Y) [I : NormalEpi f] : RegularEpi f :=
   { I with
@@ -194,7 +225,14 @@ instance (priority := 100) NormalEpi.regularEpi (f : X ⟶ Y) [I : NormalEpi f]
     right := 0
     w := by simpa using I.w }
 #align category_theory.normal_epi.regular_epi CategoryTheory.NormalEpi.regularEpi
+-/
 
+/- warning: category_theory.normal_epi.desc' -> CategoryTheory.NormalEpi.desc' is a dubious translation:
+lean 3 declaration is
+  forall {C : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} C] {X : C} {Y : C} [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {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_3 : CategoryTheory.NormalEpi.{u1, u2} C _inst_1 X Y _inst_2 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.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) X W (CategoryTheory.NormalEpi.g.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) k) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) 0 (OfNat.mk.{u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) 0 (Zero.zero.{u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) (CategoryTheory.Limits.HasZeroMorphisms.hasZero.{u1, u2} C _inst_1 _inst_2 (CategoryTheory.NormalEpi.w.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W))))) -> (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} [_inst_2 : CategoryTheory.Limits.HasZeroMorphisms.{u1, u2} C _inst_1] {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_3 : CategoryTheory.NormalEpi.{u1, u2} C _inst_1 X Y _inst_2 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.NormalEpi.W.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1) (CategoryTheory.NormalEpi.W.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) X W (CategoryTheory.NormalEpi.g.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) k) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.NormalEpi.W.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) 0 (Zero.toOfNat0.{u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_1)) (CategoryTheory.NormalEpi.W.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W) (CategoryTheory.Limits.HasZeroMorphisms.Zero.{u1, u2} C _inst_1 _inst_2 (CategoryTheory.NormalEpi.W.{u1, u2} C _inst_1 X Y _inst_2 f _inst_3) W)))) -> (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.normal_epi.desc' CategoryTheory.NormalEpi.desc'ₓ'. -/
 /-- If `f` is a normal epi, then every morphism `k : X ⟶ W` satisfying `normal_epi.g ≫ k = 0`
     induces `l : Y ⟶ W` such that `f ≫ l = k`. -/
 def NormalEpi.desc' {W : C} (f : X ⟶ Y) [NormalEpi f] (k : X ⟶ W) (h : NormalEpi.g ≫ k = 0) :
@@ -202,6 +240,7 @@ def NormalEpi.desc' {W : C} (f : X ⟶ Y) [NormalEpi f] (k : X ⟶ W) (h : Norma
   CokernelCofork.IsColimit.desc' NormalEpi.isColimit _ h
 #align category_theory.normal_epi.desc' CategoryTheory.NormalEpi.desc'
 
+#print CategoryTheory.normalOfIsPushoutSndOfNormal /-
 /-- The second leg of a pushout cocone is a normal epimorphism if the right component is too.
 
 See also `pushout.snd_of_epi` for the basic epimorphism version, and
@@ -220,7 +259,9 @@ def normalOfIsPushoutSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
     dsimp only [cokernel_cofork.of_π, cofork.of_π]
     congr ; exact q; exact q; exact q; apply proof_irrel_heq
 #align category_theory.normal_of_is_pushout_snd_of_normal CategoryTheory.normalOfIsPushoutSndOfNormal
+-/
 
+#print CategoryTheory.normalOfIsPushoutFstOfNormal /-
 /-- The first leg of a pushout cocone is a normal epimorphism if the left component is too.
 
 See also `pushout.fst_of_epi` for the basic epimorphism version, and
@@ -231,6 +272,7 @@ def normalOfIsPushoutFstOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
     NormalEpi k :=
   normalOfIsPushoutSndOfNormal comm.symm (PushoutCocone.flipIsColimit t)
 #align category_theory.normal_of_is_pushout_fst_of_normal CategoryTheory.normalOfIsPushoutFstOfNormal
+-/
 
 end
 
@@ -238,6 +280,7 @@ open Opposite
 
 variable [HasZeroMorphisms C]
 
+#print CategoryTheory.normalEpiOfNormalMonoUnop /-
 /-- A normal mono becomes a normal epi in the opposite category. -/
 def normalEpiOfNormalMonoUnop {X Y : Cᵒᵖ} (f : X ⟶ Y) (m : NormalMono f.unop) : NormalEpi f
     where
@@ -257,7 +300,9 @@ def normalEpiOfNormalMonoUnop {X Y : Cᵒᵖ} (f : X ⟶ Y) (m : NormalMono f.un
         apply m.is_limit.uniq (kernel_fork.of_ι (m'.unop ≫ f.unop) _) m'.unop
         rintro (⟨⟩ | ⟨⟩) <;> simp)
 #align category_theory.normal_epi_of_normal_mono_unop CategoryTheory.normalEpiOfNormalMonoUnop
+-/
 
+#print CategoryTheory.normalMonoOfNormalEpiUnop /-
 /-- A normal epi becomes a normal mono in the opposite category. -/
 def normalMonoOfNormalEpiUnop {X Y : Cᵒᵖ} (f : X ⟶ Y) (m : NormalEpi f.unop) : NormalMono f
     where
@@ -277,24 +322,30 @@ def normalMonoOfNormalEpiUnop {X Y : Cᵒᵖ} (f : X ⟶ Y) (m : NormalEpi f.uno
         apply m.is_colimit.uniq (cokernel_cofork.of_π (f.unop ≫ m'.unop) _) m'.unop
         rintro (⟨⟩ | ⟨⟩) <;> simp)
 #align category_theory.normal_mono_of_normal_epi_unop CategoryTheory.normalMonoOfNormalEpiUnop
+-/
 
 section
 
 variable (C)
 
+#print CategoryTheory.NormalEpiCategory /-
 /-- A normal epi category is a category in which every epimorphism is normal. -/
 class NormalEpiCategory where
   normalEpiOfEpi : ∀ {X Y : C} (f : X ⟶ Y) [Epi f], NormalEpi f
 #align category_theory.normal_epi_category CategoryTheory.NormalEpiCategory
+-/
 
 end
 
+#print CategoryTheory.normalEpiOfEpi /-
 /-- In a category in which every epimorphism is normal, we can express every epimorphism as
     a kernel. This is not an instance because it would create an instance loop. -/
 def normalEpiOfEpi [NormalEpiCategory C] (f : X ⟶ Y) [Epi f] : NormalEpi f :=
   NormalEpiCategory.normalEpiOfEpi _
 #align category_theory.normal_epi_of_epi CategoryTheory.normalEpiOfEpi
+-/
 
+#print CategoryTheory.regularEpiCategoryOfNormalEpiCategory /-
 instance (priority := 100) regularEpiCategoryOfNormalEpiCategory [NormalEpiCategory C] :
     RegularEpiCategory C
     where regularEpiOfEpi _ _ f _ :=
@@ -302,6 +353,7 @@ instance (priority := 100) regularEpiCategoryOfNormalEpiCategory [NormalEpiCateg
     haveI := normal_epi_of_epi f
     infer_instance
 #align category_theory.regular_epi_category_of_normal_epi_category CategoryTheory.regularEpiCategoryOfNormalEpiCategory
+-/
 
 end CategoryTheory

bbe25d4d

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

bbe25d4d

chore(CategoryTheory): make Functor.Full a Prop (#12449)

Before this PR, Functor.Full contained the data of the preimage of maps by a full functor F. This PR makes Functor.Full a proposition. This is to prevent any diamond to appear.

The lemma Functor.image_preimage is also renamed Functor.map_preimage.

Co-authored-by: Joël Riou <37772949+joelriou@users.noreply.github.com>

ce289a0e

Diff

@@ -71,7 +71,7 @@ def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMo
         IsLimit.ofIsoLimit
           (IsLimit.ofIsoLimit
             (IsKernel.ofCompIso _ _ (F.objObjPreimageIso hf.Z) (by
-              simp only [Functor.image_preimage, Category.assoc, Iso.inv_hom_id, Category.comp_id])
+              simp only [Functor.map_preimage, Category.assoc, Iso.inv_hom_id, Category.comp_id])
             hf.isLimit)
             (ofιCongr (Category.comp_id _).symm))
         <| by apply Iso.symm; apply isoOfι  -- Porting note: very fiddly unification here

bbe25d4d

chore(CategoryTheory): move Full, Faithful, EssSurj, IsEquivalence and ReflectsIsomorphisms to the Functor namespace (#11985)

These notions on functors are now Functor.Full, Functor.Faithful, Functor.EssSurj, Functor.IsEquivalence, Functor.ReflectsIsomorphisms. Deprecated aliases are introduced for the previous names.

65b7affc

Diff

@@ -58,9 +58,9 @@ attribute [local instance] Equivalence.essSurj_of_equivalence
 
 /-- If `F` is an equivalence and `F.map f` is a normal mono, then `f` is a normal mono. -/
 def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMorphisms D] (F : C ⥤ D)
-    [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalMono (F.map f)) : NormalMono f where
+    [F.IsEquivalence] {X Y : C} {f : X ⟶ Y} (hf : NormalMono (F.map f)) : NormalMono f where
   Z := F.objPreimage hf.Z
-  g := Full.preimage (hf.g ≫ (F.objObjPreimageIso hf.Z).inv)
+  g := F.preimage (hf.g ≫ (F.objObjPreimageIso hf.Z).inv)
   w := F.map_injective <| by
     have reassoc' {W : D} (h : hf.Z ⟶ W) : F.map f ≫ hf.g ≫ h = 0 ≫ h := by
       rw [← Category.assoc, eq_whisker hf.w]
@@ -71,7 +71,7 @@ def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMo
         IsLimit.ofIsoLimit
           (IsLimit.ofIsoLimit
             (IsKernel.ofCompIso _ _ (F.objObjPreimageIso hf.Z) (by
-              simp only [Full.witness, Category.assoc, Iso.inv_hom_id, Category.comp_id])
+              simp only [Functor.image_preimage, Category.assoc, Iso.inv_hom_id, Category.comp_id])
             hf.isLimit)
             (ofιCongr (Category.comp_id _).symm))
         <| by apply Iso.symm; apply isoOfι  -- Porting note: very fiddly unification here
@@ -175,9 +175,9 @@ attribute [local instance] Equivalence.essSurj_of_equivalence
 
 /-- If `F` is an equivalence and `F.map f` is a normal epi, then `f` is a normal epi. -/
 def equivalenceReflectsNormalEpi {D : Type u₂} [Category.{v₁} D] [HasZeroMorphisms D] (F : C ⥤ D)
-    [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalEpi (F.map f)) : NormalEpi f where
+    [F.IsEquivalence] {X Y : C} {f : X ⟶ Y} (hf : NormalEpi (F.map f)) : NormalEpi f where
   W := F.objPreimage hf.W
-  g := Full.preimage ((F.objObjPreimageIso hf.W).hom ≫ hf.g)
+  g := F.preimage ((F.objObjPreimageIso hf.W).hom ≫ hf.g)
   w := F.map_injective <| by simp [hf.w]
   isColimit :=
     ReflectsColimit.reflects <|

bbe25d4d

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

@@ -35,7 +35,6 @@ open CategoryTheory.Limits
 universe v₁ v₂ u₁ u₂
 
 variable {C : Type u₁} [Category.{v₁} C]
-
 variable {X Y : C}
 
 section

bbe25d4d

chore: make fullyFaithfulReflects(Co)Limits instances (#8462)

Co-authored-by: Junyan Xu <junyanxu.math@gmail.com>

af527f21

Diff

@@ -55,8 +55,6 @@ attribute [inherit_doc NormalMono] NormalMono.Z NormalMono.g NormalMono.w Normal
 
 section
 
-attribute [local instance] fullyFaithfulReflectsLimits
-
 attribute [local instance] Equivalence.essSurj_of_equivalence
 
 /-- If `F` is an equivalence and `F.map f` is a normal mono, then `f` is a normal mono. -/
@@ -174,8 +172,6 @@ attribute [inherit_doc NormalEpi] NormalEpi.W NormalEpi.g NormalEpi.w NormalEpi.
 
 section
 
-attribute [local instance] fullyFaithfulReflectsColimits
-
 attribute [local instance] Equivalence.essSurj_of_equivalence
 
 /-- If `F` is an equivalence and `F.map f` is a normal epi, then `f` is a normal epi. -/

bbe25d4d

chore: fix some cases in names (#7469)

And fix some names in comments where this revealed issues

be0d066c

Diff

@@ -204,7 +204,7 @@ instance (priority := 100) NormalEpi.regularEpi (f : X ⟶ Y) [I : NormalEpi f]
     w := by simpa using I.w }
 #align category_theory.normal_epi.regular_epi CategoryTheory.NormalEpi.regularEpi
 
-/-- If `f` is a normal epi, then every morphism `k : X ⟶ W` satisfying `normal_epi.g ≫ k = 0`
+/-- If `f` is a normal epi, then every morphism `k : X ⟶ W` satisfying `NormalEpi.g ≫ k = 0`
     induces `l : Y ⟶ W` such that `f ≫ l = k`. -/
 def NormalEpi.desc' {W : C} (f : X ⟶ Y) [nef : NormalEpi f] (k : X ⟶ W) (h : nef.g ≫ k = 0) :
     { l : Y ⟶ W // f ≫ l = k } :=

bbe25d4d

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) 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.normal_mono.basic
-! leanprover-community/mathlib commit bbe25d4d92565a5fd773e52e041a90387eee3c93
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Limits.Shapes.RegularMono
 import Mathlib.CategoryTheory.Limits.Shapes.Kernels
 import Mathlib.CategoryTheory.Limits.Preserves.Basic
 
+#align_import category_theory.limits.shapes.normal_mono.basic from "leanprover-community/mathlib"@"bbe25d4d92565a5fd773e52e041a90387eee3c93"
+
 /-!
 # Definitions and basic properties of normal monomorphisms and epimorphisms.

bbe25d4d

chore: cleanup whitespace (#5988)

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

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

12343aa5

Diff

@@ -68,7 +68,7 @@ def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMo
   Z := F.objPreimage hf.Z
   g := Full.preimage (hf.g ≫ (F.objObjPreimageIso hf.Z).inv)
   w := F.map_injective <| by
-    have reassoc' {W : D} (h : hf.Z ⟶  W) : F.map f ≫ hf.g ≫ h = 0 ≫ h := by
+    have reassoc' {W : D} (h : hf.Z ⟶ W) : F.map f ≫ hf.g ≫ h = 0 ≫ h := by
       rw [← Category.assoc, eq_whisker hf.w]
     simp [reassoc']
   isLimit :=
@@ -111,7 +111,7 @@ def normalOfIsPullbackSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
   Z := hn.Z
   g := k ≫ hn.g
   w := by
-    have reassoc' {W : C} (h' : S ⟶  W) : f ≫ h ≫ h' = g ≫ k ≫ h' := by
+    have reassoc' {W : C} (h' : S ⟶ W) : f ≫ h ≫ h' = g ≫ k ≫ h' := by
       simp only [← Category.assoc, eq_whisker comm]
     rw [← reassoc', hn.w, HasZeroMorphisms.comp_zero]
   isLimit := by
@@ -225,7 +225,7 @@ def normalOfIsPushoutSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
   W := gn.W
   g := gn.g ≫ f
   w := by
-    have reassoc' {W : C} (h' : R ⟶  W) :  gn.g ≫ g ≫ h' = 0 ≫ h' := by
+    have reassoc' {W : C} (h' : R ⟶ W) :  gn.g ≫ g ≫ h' = 0 ≫ h' := by
       rw [← Category.assoc, eq_whisker gn.w]
     rw [Category.assoc, comm, reassoc', zero_comp]
   isColimit := by

bbe25d4d

chore: formatting issues (#4947)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

5068808d

Diff

@@ -209,7 +209,7 @@ instance (priority := 100) NormalEpi.regularEpi (f : X ⟶ Y) [I : NormalEpi f]
 
 /-- If `f` is a normal epi, then every morphism `k : X ⟶ W` satisfying `normal_epi.g ≫ k = 0`
     induces `l : Y ⟶ W` such that `f ≫ l = k`. -/
-def NormalEpi.desc' {W : C} (f : X ⟶ Y) [nef: NormalEpi f] (k : X ⟶ W) (h : nef.g ≫ k = 0) :
+def NormalEpi.desc' {W : C} (f : X ⟶ Y) [nef : NormalEpi f] (k : X ⟶ W) (h : nef.g ≫ k = 0) :
     { l : Y ⟶ W // f ≫ l = k } :=
   CokernelCofork.IsColimit.desc' NormalEpi.isColimit _ h
 #align category_theory.normal_epi.desc' CategoryTheory.NormalEpi.desc'

bbe25d4d

chore: fix many typos (#4967)

These are all doc fixes

6f9e51c3

Diff

@@ -20,7 +20,7 @@ A normal monomorphism is a morphism that is the kernel of some other morphism.
 We give the construction `NormalMono → RegularMono` (`CategoryTheory.NormalMono.regularMono`)
 as well as the dual construction for normal epimorphisms. We show equivalences reflect normal
 monomorphisms (`CategoryTheory.equivalenceReflectsNormalMono`), and that the pullback of a
-normal monomorphism is normal (`CategoryTheoCy.normalOfIsPullbackSndOfNormal`).
+normal monomorphism is normal (`CategoryTheory.normalOfIsPullbackSndOfNormal`).
 
 We also define classes `NormalMonoCategory` and `NormalEpiCategory` for classes in which
 every monomorphism or epimorphism is normal, and deduce that these categories are

bbe25d4d

feat: improvements to congr! and convert (#2606)

There is now configuration for congr!, convert, and convert_to to control parts of the congruence algorithm, in particular transparency settings when applying congruence lemmas.
congr! now applies congruence lemmas with reducible transparency by default. This prevents it from unfolding definitions when applying congruence lemmas. It also now tries both the LHS-biased and RHS-biased simp congruence lemmas, with a configuration option to set which it should try first.
There is now a new HEq congruence lemma generator that gives each hypothesis access to the proofs of previous hypotheses. This means that if you have an equality ⊢ ⟨a, x⟩ = ⟨b, y⟩ of sigma types, congr! turns this into goals ⊢ a = b and ⊢ a = b → HEq x y (note that congr! will also auto-introduce a = b for you in the second goal). This congruence lemma generator applies to more cases than the simp congruence lemma generator does.
congr! (and hence convert) are more careful about applying lemmas that don't force definitions to unfold. There were a number of cases in mathlib where the implementation of congr was being abused to unfold definitions.
With set_option trace.congr! true you can see what congr! sees when it is deciding on congruence lemmas.
There is also a bug fix in convert_to to do using 1 when there is no using clause, to match its documentation.

Note that congr! is more capable than congr at finding a way to equate left-hand sides and right-hand sides, so you will frequently need to limit its depth with a using clause. However, there is also a new heuristic to prevent considering unlikely-to-be-provable type equalities (controlled by the typeEqs option), which can help limit the depth automatically.

There is also a predefined configuration that you can invoke with, for example, convert (config := .unfoldSameFun) h, that causes it to behave more like congr, including using default transparency when unfolding.

61ca0ea8

Diff

@@ -118,8 +118,6 @@ def normalOfIsPullbackSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
     letI gr := regularOfIsPullbackSndOfRegular comm t
     have q := (HasZeroMorphisms.comp_zero k hn.Z).symm
     convert gr.isLimit
-    dsimp only [KernelFork.ofι, Fork.ofι]
-    congr; apply proof_irrel_heq
 #align category_theory.normal_of_is_pullback_snd_of_normal CategoryTheory.normalOfIsPullbackSndOfNormal
 
 /-- The first leg of a pullback cone is a normal monomorphism if the left component is too.
@@ -234,8 +232,6 @@ def normalOfIsPushoutSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
     letI hn := regularOfIsPushoutSndOfRegular comm t
     have q := (@zero_comp _ _ _ gn.W _ _ f).symm
     convert hn.isColimit
-    dsimp only [CokernelCofork.ofπ, Cofork.ofπ]
-    congr; apply proof_irrel_heq
 #align category_theory.normal_of_is_pushout_snd_of_normal CategoryTheory.normalOfIsPushoutSndOfNormal
 
 /-- The first leg of a pushout cocone is a normal epimorphism if the left component is too.

bbe25d4d

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

@@ -67,20 +67,20 @@ def equivalenceReflectsNormalMono {D : Type u₂} [Category.{v₁} D] [HasZeroMo
     [IsEquivalence F] {X Y : C} {f : X ⟶ Y} (hf : NormalMono (F.map f)) : NormalMono f where
   Z := F.objPreimage hf.Z
   g := Full.preimage (hf.g ≫ (F.objObjPreimageIso hf.Z).inv)
-  w := F.map_injective <| by 
-    have reassoc' {W : D} (h : hf.Z ⟶  W) : F.map f ≫ hf.g ≫ h = 0 ≫ h := by 
+  w := F.map_injective <| by
+    have reassoc' {W : D} (h : hf.Z ⟶  W) : F.map f ≫ hf.g ≫ h = 0 ≫ h := by
       rw [← Category.assoc, eq_whisker hf.w]
     simp [reassoc']
-  isLimit := 
+  isLimit :=
     @ReflectsLimit.reflects C _ D _ _ _ _ F _ _ <|
       IsLimit.ofConeEquiv (Cones.postcomposeEquivalence (@compNatIso C _ _ _ _ _ D _ _ F _)) <|
-        IsLimit.ofIsoLimit 
-          (IsLimit.ofIsoLimit  
-            (IsKernel.ofCompIso _ _ (F.objObjPreimageIso hf.Z) (by 
-              simp only [Full.witness, Category.assoc, Iso.inv_hom_id, Category.comp_id]) 
+        IsLimit.ofIsoLimit
+          (IsLimit.ofIsoLimit
+            (IsKernel.ofCompIso _ _ (F.objObjPreimageIso hf.Z) (by
+              simp only [Full.witness, Category.assoc, Iso.inv_hom_id, Category.comp_id])
             hf.isLimit)
             (ofιCongr (Category.comp_id _).symm))
-        <| by apply Iso.symm; apply isoOfι  -- Porting note: very fiddly unification here 
+        <| by apply Iso.symm; apply isoOfι  -- Porting note: very fiddly unification here
 #align category_theory.equivalence_reflects_normal_mono CategoryTheory.equivalenceReflectsNormalMono
 
 end
@@ -110,8 +110,8 @@ def normalOfIsPullbackSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
     NormalMono g where
   Z := hn.Z
   g := k ≫ hn.g
-  w := by 
-    have reassoc' {W : C} (h' : S ⟶  W) : f ≫ h ≫ h' = g ≫ k ≫ h' := by 
+  w := by
+    have reassoc' {W : C} (h' : S ⟶  W) : f ≫ h ≫ h' = g ≫ k ≫ h' := by
       simp only [← Category.assoc, eq_whisker comm]
     rw [← reassoc', hn.w, HasZeroMorphisms.comp_zero]
   isLimit := by
@@ -154,7 +154,7 @@ def normalMonoOfMono [NormalMonoCategory C] (f : X ⟶ Y) [Mono f] : NormalMono
 #align category_theory.normal_mono_of_mono CategoryTheory.normalMonoOfMono
 
 instance (priority := 100) regularMonoCategoryOfNormalMonoCategory [NormalMonoCategory C] :
-    RegularMonoCategory C where 
+    RegularMonoCategory C where
   regularMonoOfMono f _ := by
     haveI := normalMonoOfMono f
     infer_instance
@@ -196,7 +196,7 @@ def equivalenceReflectsNormalEpi {D : Type u₂} [Category.{v₁} D] [HasZeroMor
           (IsColimit.ofIsoColimit
             (IsCokernel.ofIsoComp _ _ (F.objObjPreimageIso hf.W).symm (by simp) hf.isColimit)
             (ofπCongr (Category.id_comp _).symm))
-          <| by apply Iso.symm; apply isoOfπ  
+          <| by apply Iso.symm; apply isoOfπ
 #align category_theory.equivalence_reflects_normal_epi CategoryTheory.equivalenceReflectsNormalEpi
 
 end
@@ -226,8 +226,8 @@ def normalOfIsPushoutSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h :
     NormalEpi h where
   W := gn.W
   g := gn.g ≫ f
-  w := by 
-    have reassoc' {W : C} (h' : R ⟶  W) :  gn.g ≫ g ≫ h' = 0 ≫ h' := by 
+  w := by
+    have reassoc' {W : C} (h' : R ⟶  W) :  gn.g ≫ g ≫ h' = 0 ≫ h' := by
       rw [← Category.assoc, eq_whisker gn.w]
     rw [Category.assoc, comm, reassoc', zero_comp]
   isColimit := by
@@ -316,11 +316,10 @@ def normalEpiOfEpi [NormalEpiCategory C] (f : X ⟶ Y) [Epi f] : NormalEpi f :=
 #align category_theory.normal_epi_of_epi CategoryTheory.normalEpiOfEpi
 
 instance (priority := 100) regularEpiCategoryOfNormalEpiCategory [NormalEpiCategory C] :
-    RegularEpiCategory C where 
+    RegularEpiCategory C where
   regularEpiOfEpi f _ := by
     haveI := normalEpiOfEpi f
     infer_instance
 #align category_theory.regular_epi_category_of_normal_epi_category CategoryTheory.regularEpiCategoryOfNormalEpiCategory
 
 end CategoryTheory
-

bbe25d4d

feat: port CategoryTheory.Limits.Shapes.NormalMono.Basic (#2732)

0f2df18d

`category_theory.limits.shapes.normal_mono.basic` ⟷ `Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 122

category_theory.limits.shapes.normal_mono.basic ⟷ Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 122

`category_theory.limits.shapes.normal_mono.basic` ⟷ `Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic`