File: Mathlib/CategoryTheory/Limits/Shapes/NormalMono/Basic.lean

full_name: CategoryTheory.NormalMono.Z
code: /-- A normal monomorphism is a morphism which is the kernel of some morphism. -/
class NormalMono (f : X ⟶ Y) where
  Z : C -- Porting note: violates naming convention but can't think of a better one
  g : Y ⟶ Z
  w : f ≫ g = 0
  isLimit : IsLimit (KernelFork.ofι f w)
goal: C

full_name: CategoryTheory.NormalMono.isLimit
code: /-- A normal monomorphism is a morphism which is the kernel of some morphism. -/
class NormalMono (f : X ⟶ Y) where
  Z : C -- Porting note: violates naming convention but can't think of a better one
  g : Y ⟶ Z
  w : f ≫ g = 0
  isLimit : IsLimit (KernelFork.ofι f w)
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι f ⋯)

full_name: CategoryTheory.NormalMono.w
code: /-- A normal monomorphism is a morphism which is the kernel of some morphism. -/
class NormalMono (f : X ⟶ Y) where
  Z : C -- Porting note: violates naming convention but can't think of a better one
  g : Y ⟶ Z
  w : f ≫ g = 0
  isLimit : IsLimit (KernelFork.ofι f w)
goal: CategoryTheory.CategoryStruct.comp f CategoryTheory.NormalMono.g = 0

full_name: CategoryTheory.NormalMono.g
code: /-- A normal monomorphism is a morphism which is the kernel of some morphism. -/
class NormalMono (f : X ⟶ Y) where
  Z : C -- Porting note: violates naming convention but can't think of a better one
  g : Y ⟶ Z
  w : f ≫ g = 0
  isLimit : IsLimit (KernelFork.ofι f w)
goal: Y ⟶ CategoryTheory.NormalMono.Z f

full_name: CategoryTheory.NormalMono
code: /-- A normal monomorphism is a morphism which is the kernel of some morphism. -/
class NormalMono (f : X ⟶ Y) where
  Z : C -- Porting note: violates naming convention but can't think of a better one
  g : Y ⟶ Z
  w : f ≫ g = 0
  isLimit : IsLimit (KernelFork.ofι f w)
goal: Type (max u₁ v₁)

full_name: CategoryTheory.equivalenceReflectsNormalMono
code: /-- 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)
    [F.IsEquivalence] {X Y : C} {f : X ⟶ Y} (hf : NormalMono (F.map f)) : NormalMono f 
goal: CategoryTheory.NormalMono f

full_name: CategoryTheory.NormalMono.regularMono
code: /-- Every normal monomorphism is a regular monomorphism. -/
instance (priority := 100) NormalMono.regularMono (f : X ⟶ Y) [I : NormalMono f] : RegularMono f 
goal: CategoryTheory.RegularMono f

full_name: CategoryTheory.NormalMono.lift'
code: /-- 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) [hf : NormalMono f] (k : W ⟶ Y) (h : k ≫ hf.g = 0) :
    { l : W ⟶ X // l ≫ f = k } 
goal: { l // CategoryTheory.CategoryStruct.comp l f = k }

full_name: CategoryTheory.normalOfIsPullbackSndOfNormal
code: /-- The second leg of a pullback cone is a normal monomorphism if the right component is too.

See also `pullback.sndOfMono` for the basic monomorphism version, and
`normalOfIsPullbackFstOfNormal` for the flipped version.
-/
def normalOfIsPullbackSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S}
    [hn : NormalMono h] (comm : f ≫ h = g ≫ k) (t : IsLimit (PullbackCone.mk _ _ comm)) :
    NormalMono g 
goal: CategoryTheory.NormalMono g

full_name: CategoryTheory.normalOfIsPullbackFstOfNormal
code: /-- The first leg of a pullback cone is a normal monomorphism if the left component is too.

See also `pullback.fstOfMono` for the basic monomorphism version, and
`normalOfIsPullbackSndOfNormal` for the flipped version.
-/
def normalOfIsPullbackFstOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S}
    [NormalMono k] (comm : f ≫ h = g ≫ k) (t : IsLimit (PullbackCone.mk _ _ comm)) :
    NormalMono f 
goal: CategoryTheory.NormalMono f

full_name: CategoryTheory.NormalMonoCategory.normalMonoOfMono
code: /-- 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
goal: CategoryTheory.NormalMono f

full_name: CategoryTheory.NormalMonoCategory
code: /-- 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
goal: Type (max u₁ v₁)

full_name: CategoryTheory.normalMonoOfMono
code: /-- 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 
goal: CategoryTheory.NormalMono f

full_name: CategoryTheory.regularMonoCategoryOfNormalMonoCategory
code: instance (priority := 100) regularMonoCategoryOfNormalMonoCategory [NormalMonoCategory C] :
    RegularMonoCategory C 
goal: CategoryTheory.RegularMonoCategory C

full_name: CategoryTheory.NormalEpi.w
code: /-- A normal epimorphism is a morphism which is the cokernel of some morphism. -/
class NormalEpi (f : X ⟶ Y) where
  W : C
  g : W ⟶ X
  w : g ≫ f = 0
  isColimit : IsColimit (CokernelCofork.ofπ f w)
goal: CategoryTheory.CategoryStruct.comp CategoryTheory.NormalEpi.g f = 0

full_name: CategoryTheory.NormalEpi.g
code: /-- A normal epimorphism is a morphism which is the cokernel of some morphism. -/
class NormalEpi (f : X ⟶ Y) where
  W : C
  g : W ⟶ X
  w : g ≫ f = 0
  isColimit : IsColimit (CokernelCofork.ofπ f w)
goal: CategoryTheory.NormalEpi.W f ⟶ X

full_name: CategoryTheory.NormalEpi.isColimit
code: /-- A normal epimorphism is a morphism which is the cokernel of some morphism. -/
class NormalEpi (f : X ⟶ Y) where
  W : C
  g : W ⟶ X
  w : g ≫ f = 0
  isColimit : IsColimit (CokernelCofork.ofπ f w)
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ f ⋯)

full_name: CategoryTheory.NormalEpi.W
code: /-- A normal epimorphism is a morphism which is the cokernel of some morphism. -/
class NormalEpi (f : X ⟶ Y) where
  W : C
  g : W ⟶ X
  w : g ≫ f = 0
  isColimit : IsColimit (CokernelCofork.ofπ f w)
goal: C

full_name: CategoryTheory.NormalEpi
code: /-- A normal epimorphism is a morphism which is the cokernel of some morphism. -/
class NormalEpi (f : X ⟶ Y) where
  W : C
  g : W ⟶ X
  w : g ≫ f = 0
  isColimit : IsColimit (CokernelCofork.ofπ f w)
goal: Type (max u₁ v₁)

full_name: CategoryTheory.equivalenceReflectsNormalEpi
code: /-- 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)
    [F.IsEquivalence] {X Y : C} {f : X ⟶ Y} (hf : NormalEpi (F.map f)) : NormalEpi f 
goal: CategoryTheory.NormalEpi f

full_name: CategoryTheory.NormalEpi.regularEpi
code: /-- Every normal epimorphism is a regular epimorphism. -/
instance (priority := 100) NormalEpi.regularEpi (f : X ⟶ Y) [I : NormalEpi f] : RegularEpi f 
goal: CategoryTheory.RegularEpi f

full_name: CategoryTheory.NormalEpi.desc'
code: /-- 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 } 
goal: { l // CategoryTheory.CategoryStruct.comp f l = k }

full_name: CategoryTheory.normalOfIsPushoutSndOfNormal
code: /-- The second leg of a pushout cocone is a normal epimorphism if the right component is too.

See also `pushout.sndOfEpi` for the basic epimorphism version, and
`normalOfIsPushoutFstOfNormal` for the flipped version.
-/
def normalOfIsPushoutSndOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S}
    [gn : NormalEpi g] (comm : f ≫ h = g ≫ k) (t : IsColimit (PushoutCocone.mk _ _ comm)) :
    NormalEpi h 
goal: CategoryTheory.NormalEpi h

full_name: CategoryTheory.normalOfIsPushoutFstOfNormal
code: /-- The first leg of a pushout cocone is a normal epimorphism if the left component is too.

See also `pushout.fstOfEpi` for the basic epimorphism version, and
`normalOfIsPushoutSndOfNormal` for the flipped version.
-/
def normalOfIsPushoutFstOfNormal {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S}
    [NormalEpi f] (comm : f ≫ h = g ≫ k) (t : IsColimit (PushoutCocone.mk _ _ comm)) :
    NormalEpi k 
goal: CategoryTheory.NormalEpi k

full_name: CategoryTheory.normalEpiOfNormalMonoUnop
code: /-- 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 
goal: CategoryTheory.NormalEpi f

full_name: CategoryTheory.normalMonoOfNormalEpiUnop
code: /-- 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 
goal: CategoryTheory.NormalMono f

full_name: CategoryTheory.NormalEpiCategory
code: /-- 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
goal: Type (max u₁ v₁)

full_name: CategoryTheory.NormalEpiCategory.normalEpiOfEpi
code: /-- 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
goal: CategoryTheory.NormalEpi f

full_name: CategoryTheory.normalEpiOfEpi
code: /-- 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 
goal: CategoryTheory.NormalEpi f

full_name: CategoryTheory.regularEpiCategoryOfNormalEpiCategory
code: instance (priority := 100) regularEpiCategoryOfNormalEpiCategory [NormalEpiCategory C] :
    RegularEpiCategory C 
goal: CategoryTheory.RegularEpiCategory C