File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

full_name: CategoryTheory.Limits.HasZeroMorphisms
code: /-- A category "has zero morphisms" if there is a designated "zero morphism" in each morphism space,
and compositions of zero morphisms with anything give the zero morphism. -/
class HasZeroMorphisms where
  /-- Every morphism space has zero -/
  [zero : ∀ X Y : C, Zero (X ⟶ Y)]
  /-- `f` composed with `0` is `0` -/
  comp_zero : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ (0 : Y ⟶ Z) = (0 : X ⟶ Z) := by aesop_cat
  /-- `0` composed with `f` is `0` -/
  zero_comp : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), (0 : X ⟶ Y) ≫ f = (0 : X ⟶ Z) := by aesop_cat
goal: Type (max u v)

full_name: CategoryTheory.Limits.HasZeroMorphisms.zero
code: /-- A category "has zero morphisms" if there is a designated "zero morphism" in each morphism space,
and compositions of zero morphisms with anything give the zero morphism. -/
class HasZeroMorphisms where
  /-- Every morphism space has zero -/
  [zero : ∀ X Y : C, Zero (X ⟶ Y)]
  /-- `f` composed with `0` is `0` -/
  comp_zero : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ (0 : Y ⟶ Z) = (0 : X ⟶ Z) := by aesop_cat
  /-- `0` composed with `f` is `0` -/
  zero_comp : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), (0 : X ⟶ Y) ≫ f = (0 : X ⟶ Z) := by aesop_cat
goal: Zero (X ⟶ Y)

full_name: CategoryTheory.Limits.HasZeroMorphisms.zero_comp
code: /-- A category "has zero morphisms" if there is a designated "zero morphism" in each morphism space,
and compositions of zero morphisms with anything give the zero morphism. -/
class HasZeroMorphisms where
  /-- Every morphism space has zero -/
  [zero : ∀ X Y : C, Zero (X ⟶ Y)]
  /-- `f` composed with `0` is `0` -/
  comp_zero : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ (0 : Y ⟶ Z) = (0 : X ⟶ Z) := by aesop_cat
  /-- `0` composed with `f` is `0` -/
  zero_comp : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), (0 : X ⟶ Y) ≫ f = (0 : X ⟶ Z) := by aesop_cat
goal: 0 ≫ f = 0

full_name: CategoryTheory.Limits.HasZeroMorphisms.comp_zero
code: /-- A category "has zero morphisms" if there is a designated "zero morphism" in each morphism space,
and compositions of zero morphisms with anything give the zero morphism. -/
class HasZeroMorphisms where
  /-- Every morphism space has zero -/
  [zero : ∀ X Y : C, Zero (X ⟶ Y)]
  /-- `f` composed with `0` is `0` -/
  comp_zero : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ (0 : Y ⟶ Z) = (0 : X ⟶ Z) := by aesop_cat
  /-- `0` composed with `f` is `0` -/
  zero_comp : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), (0 : X ⟶ Y) ≫ f = (0 : X ⟶ Z) := by aesop_cat
goal: f ≫ 0 = 0

full_name: CategoryTheory.Limits.comp_zero
code: @[simp]
theorem comp_zero [HasZeroMorphisms C] {X Y : C} {f : X ⟶ Y} {Z : C} :
    f ≫ (0 : Y ⟶ Z) = (0 : X ⟶ Z) 
goal: f ≫ 0 = 0

full_name: CategoryTheory.Limits.zero_comp
code: @[simp]
theorem zero_comp [HasZeroMorphisms C] {X : C} {Y Z : C} {f : Y ⟶ Z} :
    (0 : X ⟶ Y) ≫ f = (0 : X ⟶ Z) 
goal: 0 ≫ f = 0

full_name: CategoryTheory.Limits.hasZeroMorphismsPEmpty
code: instance hasZeroMorphismsPEmpty : HasZeroMorphisms (Discrete PEmpty) 
goal: CategoryTheory.Limits.HasZeroMorphisms (CategoryTheory.Discrete PEmpty.{u_1 + 1})

full_name: CategoryTheory.Limits.hasZeroMorphismsPUnit
code: instance hasZeroMorphismsPUnit : HasZeroMorphisms (Discrete PUnit) 
goal: CategoryTheory.Limits.HasZeroMorphisms (CategoryTheory.Discrete PUnit.{u_1 + 1})

full_name: _private.Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms.0.CategoryTheory.Limits.HasZeroMorphisms.ext_aux
code: /-- This lemma will be immediately superseded by `ext`, below. -/
private theorem ext_aux (I J : HasZeroMorphisms C)
    (w : ∀ X Y : C, (I.zero X Y).zero = (J.zero X Y).zero) : I = J 
goal: I = J

full_name: CategoryTheory.Limits.HasZeroMorphisms.ext
code: /-- If you're tempted to use this lemma "in the wild", you should probably
carefully consider whether you've made a mistake in allowing two
instances of `HasZeroMorphisms` to exist at all.

See, particularly, the note on `zeroMorphismsOfZeroObject` below.
-/
theorem ext (I J : HasZeroMorphisms C) : I = J 
goal: I = J

full_name: CategoryTheory.Limits.HasZeroMorphisms.instSubsingleton
code: instance : Subsingleton (HasZeroMorphisms C) 
goal: Subsingleton (CategoryTheory.Limits.HasZeroMorphisms C)

full_name: CategoryTheory.Limits.hasZeroMorphismsOpposite
code: instance hasZeroMorphismsOpposite [HasZeroMorphisms C] : HasZeroMorphisms Cᵒᵖ 
goal: CategoryTheory.Limits.HasZeroMorphisms Cᵒᵖ

full_name: CategoryTheory.Limits.op_zero
code: @[simp] lemma op_zero (X Y : C) : (0 : X ⟶ Y).op = 0 
goal: Quiver.Hom.op 0 = 0

full_name: CategoryTheory.Limits.unop_zero
code: @[simp] lemma unop_zero (X Y : Cᵒᵖ) : (0 : X ⟶ Y).unop = 0 
goal: Quiver.Hom.unop 0 = 0

full_name: CategoryTheory.Limits.zero_of_comp_mono
code: theorem zero_of_comp_mono {X Y Z : C} {f : X ⟶ Y} (g : Y ⟶ Z) [Mono g] (h : f ≫ g = 0) : f = 0 
goal: f = 0

full_name: CategoryTheory.Limits.zero_of_epi_comp
code: theorem zero_of_epi_comp {X Y Z : C} (f : X ⟶ Y) {g : Y ⟶ Z} [Epi f] (h : f ≫ g = 0) : g = 0 
goal: g = 0

full_name: CategoryTheory.Limits.eq_zero_of_image_eq_zero
code: theorem eq_zero_of_image_eq_zero {X Y : C} {f : X ⟶ Y} [HasImage f] (w : image.ι f = 0) :
    f = 0 
goal: f = 0

full_name: CategoryTheory.Limits.nonzero_image_of_nonzero
code: theorem nonzero_image_of_nonzero {X Y : C} {f : X ⟶ Y} [HasImage f] (w : f ≠ 0) : image.ι f ≠ 0 
goal: CategoryTheory.Limits.image.ι f ≠ 0

full_name: CategoryTheory.Limits.instHasZeroMorphismsFunctor
code: instance : HasZeroMorphisms (C ⥤ D) 
goal: CategoryTheory.Limits.HasZeroMorphisms (C ⥤ D)

full_name: CategoryTheory.Limits.zero_app
code: @[simp]
theorem zero_app (F G : C ⥤ D) (j : C) : (0 : F ⟶ G).app j = 0 
goal: CategoryTheory.NatTrans.app 0 j = 0

full_name: CategoryTheory.Limits.IsZero.eq_zero_of_src
code: theorem eq_zero_of_src {X Y : C} (o : IsZero X) (f : X ⟶ Y) : f = 0 
goal: f = 0

full_name: CategoryTheory.Limits.IsZero.eq_zero_of_tgt
code: theorem eq_zero_of_tgt {X Y : C} (o : IsZero Y) (f : X ⟶ Y) : f = 0 
goal: f = 0

full_name: CategoryTheory.Limits.IsZero.iff_id_eq_zero
code: theorem iff_id_eq_zero (X : C) : IsZero X ↔ 𝟙 X = 0 
goal: CategoryTheory.Limits.IsZero X ↔ 𝟙 X = 0

full_name: CategoryTheory.Limits.IsZero.of_mono_zero
code: theorem of_mono_zero (X Y : C) [Mono (0 : X ⟶ Y)] : IsZero X 
goal: CategoryTheory.Limits.IsZero X

full_name: CategoryTheory.Limits.IsZero.of_epi_zero
code: theorem of_epi_zero (X Y : C) [Epi (0 : X ⟶ Y)] : IsZero Y 
goal: CategoryTheory.Limits.IsZero Y

full_name: CategoryTheory.Limits.IsZero.of_mono_eq_zero
code: theorem of_mono_eq_zero {X Y : C} (f : X ⟶ Y) [Mono f] (h : f = 0) : IsZero X 
goal: CategoryTheory.Limits.IsZero X

full_name: CategoryTheory.Limits.IsZero.of_epi_eq_zero
code: theorem of_epi_eq_zero {X Y : C} (f : X ⟶ Y) [Epi f] (h : f = 0) : IsZero Y 
goal: CategoryTheory.Limits.IsZero Y

full_name: CategoryTheory.Limits.IsZero.iff_isSplitMono_eq_zero
code: theorem iff_isSplitMono_eq_zero {X Y : C} (f : X ⟶ Y) [IsSplitMono f] : IsZero X ↔ f = 0 
goal: CategoryTheory.Limits.IsZero X ↔ f = 0

full_name: CategoryTheory.Limits.IsZero.iff_isSplitEpi_eq_zero
code: theorem iff_isSplitEpi_eq_zero {X Y : C} (f : X ⟶ Y) [IsSplitEpi f] : IsZero Y ↔ f = 0 
goal: CategoryTheory.Limits.IsZero Y ↔ f = 0

full_name: CategoryTheory.Limits.IsZero.of_mono
code: theorem of_mono {X Y : C} (f : X ⟶ Y) [Mono f] (i : IsZero Y) : IsZero X 
goal: CategoryTheory.Limits.IsZero X

full_name: CategoryTheory.Limits.IsZero.of_epi
code: theorem of_epi {X Y : C} (f : X ⟶ Y) [Epi f] (i : IsZero X) : IsZero Y 
goal: CategoryTheory.Limits.IsZero Y

full_name: CategoryTheory.Limits.IsZero.hasZeroMorphisms
code: /-- A category with a zero object has zero morphisms.

    It is rarely a good idea to use this. Many categories that have a zero object have zero
    morphisms for some other reason, for example from additivity. Library code that uses
    `zeroMorphismsOfZeroObject` will then be incompatible with these categories because
    the `HasZeroMorphisms` instances will not be definitionally equal. For this reason library
    code should generally ask for an instance of `HasZeroMorphisms` separately, even if it already
    asks for an instance of `HasZeroObjects`. -/
def IsZero.hasZeroMorphisms {O : C} (hO : IsZero O) : HasZeroMorphisms C 
goal: CategoryTheory.Limits.HasZeroMorphisms C

full_name: CategoryTheory.Limits.HasZeroObject.zeroMorphismsOfZeroObject
code: /-- A category with a zero object has zero morphisms.

    It is rarely a good idea to use this. Many categories that have a zero object have zero
    morphisms for some other reason, for example from additivity. Library code that uses
    `zeroMorphismsOfZeroObject` will then be incompatible with these categories because
    the `has_zero_morphisms` instances will not be definitionally equal. For this reason library
    code should generally ask for an instance of `HasZeroMorphisms` separately, even if it already
    asks for an instance of `HasZeroObjects`. -/
def zeroMorphismsOfZeroObject : HasZeroMorphisms C 
goal: CategoryTheory.Limits.HasZeroMorphisms C

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoIsInitial_hom
code: @[simp]
theorem zeroIsoIsInitial_hom {X : C} (t : IsInitial X) : (zeroIsoIsInitial t).hom = 0 
goal: (CategoryTheory.Limits.HasZeroObject.zeroIsoIsInitial t).hom = 0

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoIsInitial_inv
code: @[simp]
theorem zeroIsoIsInitial_inv {X : C} (t : IsInitial X) : (zeroIsoIsInitial t).inv = 0 
goal: (CategoryTheory.Limits.HasZeroObject.zeroIsoIsInitial t).inv = 0

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoIsTerminal_hom
code: @[simp]
theorem zeroIsoIsTerminal_hom {X : C} (t : IsTerminal X) : (zeroIsoIsTerminal t).hom = 0 
goal: (CategoryTheory.Limits.HasZeroObject.zeroIsoIsTerminal t).hom = 0

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoIsTerminal_inv
code: @[simp]
theorem zeroIsoIsTerminal_inv {X : C} (t : IsTerminal X) : (zeroIsoIsTerminal t).inv = 0 
goal: (CategoryTheory.Limits.HasZeroObject.zeroIsoIsTerminal t).inv = 0

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoInitial_hom
code: @[simp]
theorem zeroIsoInitial_hom [HasInitial C] : zeroIsoInitial.hom = (0 : 0 ⟶ ⊥_ C) 
goal: CategoryTheory.Limits.HasZeroObject.zeroIsoInitial.hom = 0

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoInitial_inv
code: @[simp]
theorem zeroIsoInitial_inv [HasInitial C] : zeroIsoInitial.inv = (0 : ⊥_ C ⟶ 0) 
goal: CategoryTheory.Limits.HasZeroObject.zeroIsoInitial.inv = 0

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoTerminal_hom
code: @[simp]
theorem zeroIsoTerminal_hom [HasTerminal C] : zeroIsoTerminal.hom = (0 : 0 ⟶ ⊤_ C) 
goal: CategoryTheory.Limits.HasZeroObject.zeroIsoTerminal.hom = 0

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoTerminal_inv
code: @[simp]
theorem zeroIsoTerminal_inv [HasTerminal C] : zeroIsoTerminal.inv = (0 : ⊤_ C ⟶ 0) 
goal: CategoryTheory.Limits.HasZeroObject.zeroIsoTerminal.inv = 0

full_name: CategoryTheory.Limits.HasZeroObject.instFunctor
code: instance {B : Type*} [Category B] : HasZeroObject (B ⥤ C) 
goal: CategoryTheory.Limits.HasZeroObject (B ⥤ C)

full_name: CategoryTheory.Limits.IsZero.map
code: @[simp]
theorem IsZero.map [HasZeroObject D] [HasZeroMorphisms D] {F : C ⥤ D} (hF : IsZero F) {X Y : C}
    (f : X ⟶ Y) : F.map f = 0 
goal: F.map f = 0

full_name: CategoryTheory.Functor.zero_obj
code: @[simp]
theorem _root_.CategoryTheory.Functor.zero_obj [HasZeroObject D] (X : C) :
    IsZero ((0 : C ⥤ D).obj X) 
goal: CategoryTheory.Limits.IsZero ((CategoryTheory.Functor.toPrefunctor 0).obj X)

full_name: CategoryTheory.zero_map
code: @[simp]
theorem _root_.CategoryTheory.zero_map [HasZeroObject D] [HasZeroMorphisms D] {X Y : C}
    (f : X ⟶ Y) : (0 : C ⥤ D).map f = 0 
goal: (CategoryTheory.Functor.toPrefunctor 0).map f = 0

full_name: CategoryTheory.Limits.id_zero
code: @[simp]
theorem id_zero : 𝟙 (0 : C) = (0 : (0 : C) ⟶ 0) 
goal: 𝟙 0 = 0

full_name: CategoryTheory.Limits.zero_of_to_zero
code: /-- An arrow ending in the zero object is zero -/
theorem zero_of_to_zero {X : C} (f : X ⟶ 0) : f = 0 
goal: f = 0

full_name: CategoryTheory.Limits.zero_of_target_iso_zero
code: theorem zero_of_target_iso_zero {X Y : C} (f : X ⟶ Y) (i : Y ≅ 0) : f = 0 
goal: f = 0

full_name: CategoryTheory.Limits.zero_of_from_zero
code: /-- An arrow starting at the zero object is zero -/
theorem zero_of_from_zero {X : C} (f : 0 ⟶ X) : f = 0 
goal: f = 0

full_name: CategoryTheory.Limits.zero_of_source_iso_zero
code: theorem zero_of_source_iso_zero {X Y : C} (f : X ⟶ Y) (i : X ≅ 0) : f = 0 
goal: f = 0

full_name: CategoryTheory.Limits.zero_of_source_iso_zero'
code: theorem zero_of_source_iso_zero' {X Y : C} (f : X ⟶ Y) (i : IsIsomorphic X 0) : f = 0 
goal: f = 0

full_name: CategoryTheory.Limits.zero_of_target_iso_zero'
code: theorem zero_of_target_iso_zero' {X Y : C} (f : X ⟶ Y) (i : IsIsomorphic Y 0) : f = 0 
goal: f = 0

full_name: CategoryTheory.Limits.mono_of_source_iso_zero
code: theorem mono_of_source_iso_zero {X Y : C} (f : X ⟶ Y) (i : X ≅ 0) : Mono f 
goal: CategoryTheory.Mono f

full_name: CategoryTheory.Limits.epi_of_target_iso_zero
code: theorem epi_of_target_iso_zero {X Y : C} (f : X ⟶ Y) (i : Y ≅ 0) : Epi f 
goal: CategoryTheory.Epi f

full_name: CategoryTheory.Limits.idZeroEquivIsoZero
code: /-- An object `X` has `𝟙 X = 0` if and only if it is isomorphic to the zero object.

Because `X ≅ 0` contains data (even if a subsingleton), we express this `↔` as an `≃`.
-/
def idZeroEquivIsoZero (X : C) : 𝟙 X = 0 ≃ (X ≅ 0) 
goal: 𝟙 X = 0 ≃ (X ≅ 0)

full_name: CategoryTheory.Limits.idZeroEquivIsoZero_apply_hom
code: @[simp]
theorem idZeroEquivIsoZero_apply_hom (X : C) (h : 𝟙 X = 0) : ((idZeroEquivIsoZero X) h).hom = 0 
goal: ((CategoryTheory.Limits.idZeroEquivIsoZero X) h).hom = 0

full_name: CategoryTheory.Limits.idZeroEquivIsoZero_apply_inv
code: @[simp]
theorem idZeroEquivIsoZero_apply_inv (X : C) (h : 𝟙 X = 0) : ((idZeroEquivIsoZero X) h).inv = 0 
goal: ((CategoryTheory.Limits.idZeroEquivIsoZero X) h).inv = 0

full_name: CategoryTheory.Limits.isoZeroOfMonoZero_hom
code: /-- If `0 : X ⟶ Y` is a monomorphism, then `X ≅ 0`. -/
@[simps]
def isoZeroOfMonoZero {X Y : C} (h : Mono (0 : X ⟶ Y)) : X ≅ 0 
goal: (CategoryTheory.Limits.isoZeroOfMonoZero h).hom = 0

full_name: CategoryTheory.Limits.isoZeroOfMonoZero_inv
code: /-- If `0 : X ⟶ Y` is a monomorphism, then `X ≅ 0`. -/
@[simps]
def isoZeroOfMonoZero {X Y : C} (h : Mono (0 : X ⟶ Y)) : X ≅ 0 
goal: (CategoryTheory.Limits.isoZeroOfMonoZero h).inv = 0

full_name: CategoryTheory.Limits.isoZeroOfMonoZero
code: /-- If `0 : X ⟶ Y` is a monomorphism, then `X ≅ 0`. -/
@[simps]
def isoZeroOfMonoZero {X Y : C} (h : Mono (0 : X ⟶ Y)) : X ≅ 0 
goal: X ≅ 0

full_name: CategoryTheory.Limits.isoZeroOfEpiZero_inv
code: /-- If `0 : X ⟶ Y` is an epimorphism, then `Y ≅ 0`. -/
@[simps]
def isoZeroOfEpiZero {X Y : C} (h : Epi (0 : X ⟶ Y)) : Y ≅ 0 
goal: (CategoryTheory.Limits.isoZeroOfEpiZero h).inv = 0

full_name: CategoryTheory.Limits.isoZeroOfEpiZero
code: /-- If `0 : X ⟶ Y` is an epimorphism, then `Y ≅ 0`. -/
@[simps]
def isoZeroOfEpiZero {X Y : C} (h : Epi (0 : X ⟶ Y)) : Y ≅ 0 
goal: Y ≅ 0

full_name: CategoryTheory.Limits.isoZeroOfEpiZero_hom
code: /-- If `0 : X ⟶ Y` is an epimorphism, then `Y ≅ 0`. -/
@[simps]
def isoZeroOfEpiZero {X Y : C} (h : Epi (0 : X ⟶ Y)) : Y ≅ 0 
goal: (CategoryTheory.Limits.isoZeroOfEpiZero h).hom = 0

full_name: CategoryTheory.Limits.isoZeroOfMonoEqZero
code: /-- If a monomorphism out of `X` is zero, then `X ≅ 0`. -/
def isoZeroOfMonoEqZero {X Y : C} {f : X ⟶ Y} [Mono f] (h : f = 0) : X ≅ 0 
goal: X ≅ 0

full_name: CategoryTheory.Limits.isoZeroOfEpiEqZero
code: /-- If an epimorphism in to `Y` is zero, then `Y ≅ 0`. -/
def isoZeroOfEpiEqZero {X Y : C} {f : X ⟶ Y} [Epi f] (h : f = 0) : Y ≅ 0 
goal: Y ≅ 0

full_name: CategoryTheory.Limits.isoOfIsIsomorphicZero
code: /-- If an object `X` is isomorphic to 0, there's no need to use choice to construct
an explicit isomorphism: the zero morphism suffices. -/
def isoOfIsIsomorphicZero {X : C} (P : IsIsomorphic X 0) : X ≅ 0 
goal: X ≅ 0

full_name: CategoryTheory.Limits.isIsoZeroEquiv
code: /-- A zero morphism `0 : X ⟶ Y` is an isomorphism if and only if
the identities on both `X` and `Y` are zero.
-/
@[simps]
def isIsoZeroEquiv (X Y : C) : IsIso (0 : X ⟶ Y) ≃ 𝟙 X = 0 ∧ 𝟙 Y = 0 
goal: CategoryTheory.IsIso 0 ≃ 𝟙 X = 0 ∧ 𝟙 Y = 0

full_name: CategoryTheory.Limits.isIsoZeroEquiv_apply
code: /-- A zero morphism `0 : X ⟶ Y` is an isomorphism if and only if
the identities on both `X` and `Y` are zero.
-/
@[simps]
def isIsoZeroEquiv (X Y : C) : IsIso (0 : X ⟶ Y) ≃ 𝟙 X = 0 ∧ 𝟙 Y = 0 
goal: ⋯ = ⋯

full_name: CategoryTheory.Limits.isIsoZeroEquiv_symm_apply
code: /-- A zero morphism `0 : X ⟶ Y` is an isomorphism if and only if
the identities on both `X` and `Y` are zero.
-/
@[simps]
def isIsoZeroEquiv (X Y : C) : IsIso (0 : X ⟶ Y) ≃ 𝟙 X = 0 ∧ 𝟙 Y = 0 
goal: ⋯ = ⋯

full_name: CategoryTheory.Limits.isIsoZeroSelfEquiv
code: /-- A zero morphism `0 : X ⟶ X` is an isomorphism if and only if
the identity on `X` is zero.
-/
def isIsoZeroSelfEquiv (X : C) : IsIso (0 : X ⟶ X) ≃ 𝟙 X = 0 
goal: CategoryTheory.IsIso 0 ≃ 𝟙 X = 0

full_name: CategoryTheory.Limits.isIsoZeroEquivIsoZero
code: /-- A zero morphism `0 : X ⟶ Y` is an isomorphism if and only if
`X` and `Y` are isomorphic to the zero object.
-/
def isIsoZeroEquivIsoZero (X Y : C) : IsIso (0 : X ⟶ Y) ≃ (X ≅ 0) × (Y ≅ 0) 
goal: CategoryTheory.IsIso 0 ≃ (X ≅ 0) × (Y ≅ 0)

full_name: CategoryTheory.Limits.isIso_of_source_target_iso_zero
code: theorem isIso_of_source_target_iso_zero {X Y : C} (f : X ⟶ Y) (i : X ≅ 0) (j : Y ≅ 0) :
    IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.Limits.isIsoZeroSelfEquivIsoZero
code: /-- A zero morphism `0 : X ⟶ X` is an isomorphism if and only if
`X` is isomorphic to the zero object.
-/
def isIsoZeroSelfEquivIsoZero (X : C) : IsIso (0 : X ⟶ X) ≃ (X ≅ 0) 
goal: CategoryTheory.IsIso 0 ≃ (X ≅ 0)

full_name: CategoryTheory.Limits.hasZeroObject_of_hasInitial_object
code: /-- If there are zero morphisms, any initial object is a zero object. -/
theorem hasZeroObject_of_hasInitial_object [HasZeroMorphisms C] [HasInitial C] :
    HasZeroObject C 
goal: CategoryTheory.Limits.HasZeroObject C

full_name: CategoryTheory.Limits.hasZeroObject_of_hasTerminal_object
code: /-- If there are zero morphisms, any terminal object is a zero object. -/
theorem hasZeroObject_of_hasTerminal_object [HasZeroMorphisms C] [HasTerminal C] :
    HasZeroObject C 
goal: CategoryTheory.Limits.HasZeroObject C

full_name: CategoryTheory.Limits.image_ι_comp_eq_zero
code: theorem image_ι_comp_eq_zero {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} [HasImage f]
    [Epi (factorThruImage f)] (h : f ≫ g = 0) : image.ι f ≫ g = 0 
goal: CategoryTheory.Limits.image.ι f ≫ g = 0

full_name: CategoryTheory.Limits.comp_factorThruImage_eq_zero
code: theorem comp_factorThruImage_eq_zero {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z} [HasImage g]
    (h : f ≫ g = 0) : f ≫ factorThruImage g = 0 
goal: f ≫ CategoryTheory.Limits.factorThruImage g = 0

full_name: CategoryTheory.Limits.monoFactorisationZero_m
code: /-- The zero morphism has a `MonoFactorisation` through the zero object.
-/
@[simps]
def monoFactorisationZero (X Y : C) : MonoFactorisation (0 : X ⟶ Y) 
goal: (CategoryTheory.Limits.monoFactorisationZero X Y).m = 0

full_name: CategoryTheory.Limits.monoFactorisationZero
code: /-- The zero morphism has a `MonoFactorisation` through the zero object.
-/
@[simps]
def monoFactorisationZero (X Y : C) : MonoFactorisation (0 : X ⟶ Y) 
goal: CategoryTheory.Limits.MonoFactorisation 0

full_name: CategoryTheory.Limits.monoFactorisationZero_e
code: /-- The zero morphism has a `MonoFactorisation` through the zero object.
-/
@[simps]
def monoFactorisationZero (X Y : C) : MonoFactorisation (0 : X ⟶ Y) 
goal: (CategoryTheory.Limits.monoFactorisationZero X Y).e = 0

full_name: CategoryTheory.Limits.monoFactorisationZero_I
code: /-- The zero morphism has a `MonoFactorisation` through the zero object.
-/
@[simps]
def monoFactorisationZero (X Y : C) : MonoFactorisation (0 : X ⟶ Y) 
goal: (CategoryTheory.Limits.monoFactorisationZero X Y).I = 0

full_name: CategoryTheory.Limits.imageFactorisationZero
code: /-- The factorisation through the zero object is an image factorisation.
-/
def imageFactorisationZero (X Y : C) : ImageFactorisation (0 : X ⟶ Y) 
goal: CategoryTheory.Limits.ImageFactorisation 0

full_name: CategoryTheory.Limits.hasImage_zero
code: instance hasImage_zero {X Y : C} : HasImage (0 : X ⟶ Y) 
goal: CategoryTheory.Limits.HasImage 0

full_name: CategoryTheory.Limits.imageZero
code: /-- The image of a zero morphism is the zero object. -/
def imageZero {X Y : C} : image (0 : X ⟶ Y) ≅ 0 
goal: CategoryTheory.Limits.image 0 ≅ 0

full_name: CategoryTheory.Limits.imageZero'
code: /-- The image of a morphism which is equal to zero is the zero object. -/
def imageZero' {X Y : C} {f : X ⟶ Y} (h : f = 0) [HasImage f] : image f ≅ 0 
goal: CategoryTheory.Limits.image f ≅ 0

full_name: CategoryTheory.Limits.image.ι_zero
code: @[simp]
theorem image.ι_zero {X Y : C} [HasImage (0 : X ⟶ Y)] : image.ι (0 : X ⟶ Y) = 0 
goal: CategoryTheory.Limits.image.ι 0 = 0

full_name: CategoryTheory.Limits.image.ι_zero'
code: /-- If we know `f = 0`,
it requires a little work to conclude `image.ι f = 0`,
because `f = g` only implies `image f ≅ image g`.
-/
@[simp]
theorem image.ι_zero' [HasEqualizers C] {X Y : C} {f : X ⟶ Y} (h : f = 0) [HasImage f] :
    image.ι f = 0 
goal: CategoryTheory.Limits.image.ι f = 0

full_name: CategoryTheory.Limits.isSplitMono_sigma_ι
code: /-- In the presence of zero morphisms, coprojections into a coproduct are (split) monomorphisms. -/
instance isSplitMono_sigma_ι {β : Type u'} [HasZeroMorphisms C] (f : β → C)
    [HasColimit (Discrete.functor f)] (b : β) : IsSplitMono (Sigma.ι f b) 
goal: CategoryTheory.IsSplitMono (CategoryTheory.Limits.Sigma.ι f b)

full_name: CategoryTheory.Limits.isSplitEpi_pi_π
code: /-- In the presence of zero morphisms, projections into a product are (split) epimorphisms. -/
instance isSplitEpi_pi_π {β : Type u'} [HasZeroMorphisms C] (f : β → C)
    [HasLimit (Discrete.functor f)] (b : β) : IsSplitEpi (Pi.π f b) 
goal: CategoryTheory.IsSplitEpi (CategoryTheory.Limits.Pi.π f b)

full_name: CategoryTheory.Limits.isSplitMono_coprod_inl
code: /-- In the presence of zero morphisms, coprojections into a coproduct are (split) monomorphisms. -/
instance isSplitMono_coprod_inl [HasZeroMorphisms C] {X Y : C} [HasColimit (pair X Y)] :
    IsSplitMono (coprod.inl : X ⟶ X ⨿ Y) 
goal: CategoryTheory.IsSplitMono CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.Limits.isSplitMono_coprod_inr
code: /-- In the presence of zero morphisms, coprojections into a coproduct are (split) monomorphisms. -/
instance isSplitMono_coprod_inr [HasZeroMorphisms C] {X Y : C} [HasColimit (pair X Y)] :
    IsSplitMono (coprod.inr : Y ⟶ X ⨿ Y) 
goal: CategoryTheory.IsSplitMono CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.Limits.isSplitEpi_prod_fst
code: /-- In the presence of zero morphisms, projections into a product are (split) epimorphisms. -/
instance isSplitEpi_prod_fst [HasZeroMorphisms C] {X Y : C} [HasLimit (pair X Y)] :
    IsSplitEpi (prod.fst : X ⨯ Y ⟶ X) 
goal: CategoryTheory.IsSplitEpi CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Limits.isSplitEpi_prod_snd
code: /-- In the presence of zero morphisms, projections into a product are (split) epimorphisms. -/
instance isSplitEpi_prod_snd [HasZeroMorphisms C] {X Y : C} [HasLimit (pair X Y)] :
    IsSplitEpi (prod.snd : X ⨯ Y ⟶ Y) 
goal: CategoryTheory.IsSplitEpi CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Limits.IsLimit.ofIsZero
code: /-- If a functor `F` is zero, then any cone for `F` with a zero point is limit. -/
def IsLimit.ofIsZero (c : Cone F) (hF : IsZero F) (hc : IsZero c.pt) : IsLimit c 
goal: CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.IsColimit.ofIsZero
code: /-- If a functor `F` is zero, then any cocone for `F` with a zero point is colimit. -/
def IsColimit.ofIsZero (c : Cocone F) (hF : IsZero F) (hc : IsZero c.pt) : IsColimit c 
goal: CategoryTheory.Limits.IsColimit c

full_name: CategoryTheory.Limits.IsLimit.isZero_pt
code: lemma IsLimit.isZero_pt {c : Cone F} (hc : IsLimit c) (hF : IsZero F) : IsZero c.pt 
goal: CategoryTheory.Limits.IsZero c.pt

full_name: CategoryTheory.Limits.IsColimit.isZero_pt
code: lemma IsColimit.isZero_pt {c : Cocone F} (hc : IsColimit c) (hF : IsZero F) : IsZero c.pt 
goal: CategoryTheory.Limits.IsZero c.pt

full_name: CategoryTheory.Limits.IsTerminal.isZero
code: lemma IsTerminal.isZero {X : C} (hX : IsTerminal X) : IsZero X 
goal: CategoryTheory.Limits.IsZero X

full_name: CategoryTheory.Limits.IsInitial.isZero
code: lemma IsInitial.isZero {X : C} (hX : IsInitial X) : IsZero X 
goal: CategoryTheory.Limits.IsZero X