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

full_name: CategoryTheory.Limits.IsZero.unique_from
code: /-- An object `X` in a category is a *zero object* if for every object `Y`
there is a unique morphism `to : X → Y` and a unique morphism `from : Y → X`.

This is a characteristic predicate for `has_zero_object`. -/
structure IsZero (X : C) : Prop where
  /-- there are unique morphisms to the object -/
  unique_to : ∀ Y, Nonempty (Unique (X ⟶ Y))
  /-- there are unique morphisms from the object -/
  unique_from : ∀ Y, Nonempty (Unique (Y ⟶ X))
goal: Nonempty (Unique (Y ⟶ X))

full_name: CategoryTheory.Limits.IsZero.unique_to
code: /-- An object `X` in a category is a *zero object* if for every object `Y`
there is a unique morphism `to : X → Y` and a unique morphism `from : Y → X`.

This is a characteristic predicate for `has_zero_object`. -/
structure IsZero (X : C) : Prop where
  /-- there are unique morphisms to the object -/
  unique_to : ∀ Y, Nonempty (Unique (X ⟶ Y))
  /-- there are unique morphisms from the object -/
  unique_from : ∀ Y, Nonempty (Unique (Y ⟶ X))
goal: Nonempty (Unique (X ⟶ Y))

full_name: CategoryTheory.Limits.IsZero
code: /-- An object `X` in a category is a *zero object* if for every object `Y`
there is a unique morphism `to : X → Y` and a unique morphism `from : Y → X`.

This is a characteristic predicate for `has_zero_object`. -/
structure IsZero (X : C) : Prop where
  /-- there are unique morphisms to the object -/
  unique_to : ∀ Y, Nonempty (Unique (X ⟶ Y))
  /-- there are unique morphisms from the object -/
  unique_from : ∀ Y, Nonempty (Unique (Y ⟶ X))
goal: Prop

full_name: CategoryTheory.Limits.IsZero.to_
code: /-- If `h : IsZero X`, then `h.to_ Y` is a choice of unique morphism `X → Y`. -/
protected def to_ (h : IsZero X) (Y : C) : X ⟶ Y 
goal: X ⟶ Y

full_name: CategoryTheory.Limits.IsZero.eq_to
code: theorem eq_to (h : IsZero X) (f : X ⟶ Y) : f = h.to_ Y 
goal: f = h.to_ Y

full_name: CategoryTheory.Limits.IsZero.to_eq
code: theorem to_eq (h : IsZero X) (f : X ⟶ Y) : h.to_ Y = f 
goal: h.to_ Y = f

full_name: CategoryTheory.Limits.IsZero.from_
code: /-- If `h : is_zero X`, then `h.from_ Y` is a choice of unique morphism `Y → X`. -/
protected def from_ (h : IsZero X) (Y : C) : Y ⟶ X 
goal: Y ⟶ X

full_name: CategoryTheory.Limits.IsZero.eq_from
code: theorem eq_from (h : IsZero X) (f : Y ⟶ X) : f = h.from_ Y 
goal: f = h.from_ Y

full_name: CategoryTheory.Limits.IsZero.from_eq
code: theorem from_eq (h : IsZero X) (f : Y ⟶ X) : h.from_ Y = f 
goal: h.from_ Y = f

full_name: CategoryTheory.Limits.IsZero.eq_of_src
code: theorem eq_of_src (hX : IsZero X) (f g : X ⟶ Y) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.IsZero.eq_of_tgt
code: theorem eq_of_tgt (hX : IsZero X) (f g : Y ⟶ X) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.IsZero.iso
code: /-- Any two zero objects are isomorphic. -/
def iso (hX : IsZero X) (hY : IsZero Y) : X ≅ Y 
goal: X ≅ Y

full_name: CategoryTheory.Limits.IsZero.isInitial
code: /-- A zero object is in particular initial. -/
protected def isInitial (hX : IsZero X) : IsInitial X 
goal: CategoryTheory.Limits.IsInitial X

full_name: CategoryTheory.Limits.IsZero.isTerminal
code: /-- A zero object is in particular terminal. -/
protected def isTerminal (hX : IsZero X) : IsTerminal X 
goal: CategoryTheory.Limits.IsTerminal X

full_name: CategoryTheory.Limits.IsZero.isoIsInitial
code: /-- The (unique) isomorphism between any initial object and the zero object. -/
def isoIsInitial (hX : IsZero X) (hY : IsInitial Y) : X ≅ Y 
goal: X ≅ Y

full_name: CategoryTheory.Limits.IsZero.isoIsTerminal
code: /-- The (unique) isomorphism between any terminal object and the zero object. -/
def isoIsTerminal (hX : IsZero X) (hY : IsTerminal Y) : X ≅ Y 
goal: X ≅ Y

full_name: CategoryTheory.Limits.IsZero.of_iso
code: theorem of_iso (hY : IsZero Y) (e : X ≅ Y) : IsZero X 
goal: CategoryTheory.Limits.IsZero X

full_name: CategoryTheory.Limits.IsZero.op
code: theorem op (h : IsZero X) : IsZero (Opposite.op X) 
goal: CategoryTheory.Limits.IsZero (Opposite.op X)

full_name: CategoryTheory.Limits.IsZero.unop
code: theorem unop {X : Cᵒᵖ} (h : IsZero X) : IsZero (Opposite.unop X) 
goal: CategoryTheory.Limits.IsZero (Opposite.unop X)

full_name: CategoryTheory.Iso.isZero_iff
code: theorem Iso.isZero_iff {X Y : C} (e : X ≅ Y) : IsZero X ↔ IsZero Y 
goal: CategoryTheory.Limits.IsZero X ↔ CategoryTheory.Limits.IsZero Y

full_name: CategoryTheory.Functor.isZero
code: theorem Functor.isZero (F : C ⥤ D) (hF : ∀ X, IsZero (F.obj X)) : IsZero F 
goal: CategoryTheory.Limits.IsZero F

full_name: CategoryTheory.Limits.HasZeroObject.zero
code: /-- A category "has a zero object" if it has an object which is both initial and terminal. -/
class HasZeroObject : Prop where
  /-- there exists a zero object -/
  zero : ∃ X : C, IsZero X
goal: ∃ X, CategoryTheory.Limits.IsZero X

full_name: CategoryTheory.Limits.HasZeroObject
code: /-- A category "has a zero object" if it has an object which is both initial and terminal. -/
class HasZeroObject : Prop where
  /-- there exists a zero object -/
  zero : ∃ X : C, IsZero X
goal: Prop

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

full_name: CategoryTheory.Limits.HasZeroObject.zero'
code: /-- Construct a `Zero C` for a category with a zero object.
This can not be a global instance as it will trigger for every `Zero C` typeclass search.
-/
protected def HasZeroObject.zero' : Zero C 
goal: Zero C

full_name: CategoryTheory.Limits.isZero_zero
code: theorem isZero_zero : IsZero (0 : C) 
goal: CategoryTheory.Limits.IsZero 0

full_name: CategoryTheory.Limits.hasZeroObject_op
code: instance hasZeroObject_op : HasZeroObject Cᵒᵖ 
goal: CategoryTheory.Limits.HasZeroObject Cᵒᵖ

full_name: CategoryTheory.Limits.hasZeroObject_unop
code: theorem hasZeroObject_unop [HasZeroObject Cᵒᵖ] : HasZeroObject C 
goal: CategoryTheory.Limits.HasZeroObject C

full_name: CategoryTheory.Limits.IsZero.hasZeroObject
code: theorem IsZero.hasZeroObject {X : C} (hX : IsZero X) : HasZeroObject C 
goal: CategoryTheory.Limits.HasZeroObject C

full_name: CategoryTheory.Limits.IsZero.isoZero
code: /-- Every zero object is isomorphic to *the* zero object. -/
def IsZero.isoZero [HasZeroObject C] {X : C} (hX : IsZero X) : X ≅ 0 
goal: X ≅ 0

full_name: CategoryTheory.Limits.IsZero.obj
code: theorem IsZero.obj [HasZeroObject D] {F : C ⥤ D} (hF : IsZero F) (X : C) : IsZero (F.obj X) 
goal: CategoryTheory.Limits.IsZero (F.obj X)

full_name: CategoryTheory.Limits.HasZeroObject.uniqueTo
code: /-- There is a unique morphism from the zero object to any object `X`. -/
protected def uniqueTo (X : C) : Unique (0 ⟶ X) 
goal: Unique (0 ⟶ X)

full_name: CategoryTheory.Limits.HasZeroObject.uniqueFrom
code: /-- There is a unique morphism from any object `X` to the zero object. -/
protected def uniqueFrom (X : C) : Unique (X ⟶ 0) 
goal: Unique (X ⟶ 0)

full_name: CategoryTheory.Limits.HasZeroObject.to_zero_ext
code: @[ext]
theorem to_zero_ext {X : C} (f g : X ⟶ 0) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.HasZeroObject.from_zero_ext
code: @[ext]
theorem from_zero_ext {X : C} (f g : 0 ⟶ X) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.HasZeroObject.instSubsingletonIsoOfNat
code: instance (X : C) : Subsingleton (X ≅ 0) 
goal: Subsingleton (X ≅ 0)

full_name: CategoryTheory.Limits.HasZeroObject.instMono
code: instance {X : C} (f : 0 ⟶ X) : Mono f 
goal: CategoryTheory.Mono f

full_name: CategoryTheory.Limits.HasZeroObject.instEpi
code: instance {X : C} (f : X ⟶ 0) : Epi f 
goal: CategoryTheory.Epi f

full_name: CategoryTheory.Limits.HasZeroObject.zero_to_zero_isIso
code: instance zero_to_zero_isIso (f : (0 : C) ⟶ 0) : IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsInitial
code: /-- A zero object is in particular initial. -/
def zeroIsInitial : IsInitial (0 : C) 
goal: CategoryTheory.Limits.IsInitial 0

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsTerminal
code: /-- A zero object is in particular terminal. -/
def zeroIsTerminal : IsTerminal (0 : C) 
goal: CategoryTheory.Limits.IsTerminal 0

full_name: CategoryTheory.Limits.HasZeroObject.hasInitial
code: /-- A zero object is in particular initial. -/
instance (priority := 10) hasInitial : HasInitial C 
goal: CategoryTheory.Limits.HasInitial C

full_name: CategoryTheory.Limits.HasZeroObject.hasTerminal
code: /-- A zero object is in particular terminal. -/
instance (priority := 10) hasTerminal : HasTerminal C 
goal: CategoryTheory.Limits.HasTerminal C

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoIsInitial
code: /-- The (unique) isomorphism between any initial object and the zero object. -/
def zeroIsoIsInitial {X : C} (t : IsInitial X) : 0 ≅ X 
goal: 0 ≅ X

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoIsTerminal
code: /-- The (unique) isomorphism between any terminal object and the zero object. -/
def zeroIsoIsTerminal {X : C} (t : IsTerminal X) : 0 ≅ X 
goal: 0 ≅ X

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoInitial
code: /-- The (unique) isomorphism between the chosen initial object and the chosen zero object. -/
def zeroIsoInitial [HasInitial C] : 0 ≅ ⊥_ C 
goal: 0 ≅ ⊥_ C

full_name: CategoryTheory.Limits.HasZeroObject.zeroIsoTerminal
code: /-- The (unique) isomorphism between the chosen terminal object and the chosen zero object. -/
def zeroIsoTerminal [HasTerminal C] : 0 ≅ ⊤_ C 
goal: 0 ≅ ⊤_ C

full_name: CategoryTheory.Limits.HasZeroObject.initialMonoClass
code: instance (priority := 100) initialMonoClass : InitialMonoClass C 
goal: CategoryTheory.Limits.InitialMonoClass C

full_name: CategoryTheory.Functor.isZero_iff
code: theorem Functor.isZero_iff [HasZeroObject D] (F : C ⥤ D) : IsZero F ↔ ∀ X, IsZero (F.obj X) 
goal: CategoryTheory.Limits.IsZero F ↔ ∀ (X : C), CategoryTheory.Limits.IsZero (F.obj X)