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

full_name: CategoryTheory.Limits.binaryFanZeroLeft
code: /-- The limit cone for the product with a zero object. -/
def binaryFanZeroLeft (X : C) : BinaryFan (0 : C) X 
goal: CategoryTheory.Limits.BinaryFan 0 X

full_name: CategoryTheory.Limits.binaryFanZeroLeftIsLimit
code: /-- The limit cone for the product with a zero object is limiting. -/
def binaryFanZeroLeftIsLimit (X : C) : IsLimit (binaryFanZeroLeft X) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.binaryFanZeroLeft X)

full_name: CategoryTheory.Limits.hasBinaryProduct_zero_left
code: instance hasBinaryProduct_zero_left (X : C) : HasBinaryProduct (0 : C) X 
goal: CategoryTheory.Limits.HasBinaryProduct 0 X

full_name: CategoryTheory.Limits.zeroProdIso
code: /-- A zero object is a left unit for categorical product. -/
def zeroProdIso (X : C) : (0 : C) ⨯ X ≅ X 
goal: 0 ⨯ X ≅ X

full_name: CategoryTheory.Limits.zeroProdIso_hom
code: @[simp]
theorem zeroProdIso_hom (X : C) : (zeroProdIso X).hom = prod.snd 
goal: (CategoryTheory.Limits.zeroProdIso X).hom = CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Limits.zeroProdIso_inv_snd
code: @[simp]
theorem zeroProdIso_inv_snd (X : C) : (zeroProdIso X).inv ≫ prod.snd = 𝟙 X 
goal: (CategoryTheory.Limits.zeroProdIso X).inv ≫ CategoryTheory.Limits.prod.snd = 𝟙 X

full_name: CategoryTheory.Limits.binaryFanZeroRight
code: /-- The limit cone for the product with a zero object. -/
def binaryFanZeroRight (X : C) : BinaryFan X (0 : C) 
goal: CategoryTheory.Limits.BinaryFan X 0

full_name: CategoryTheory.Limits.binaryFanZeroRightIsLimit
code: /-- The limit cone for the product with a zero object is limiting. -/
def binaryFanZeroRightIsLimit (X : C) : IsLimit (binaryFanZeroRight X) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.binaryFanZeroRight X)

full_name: CategoryTheory.Limits.hasBinaryProduct_zero_right
code: instance hasBinaryProduct_zero_right (X : C) : HasBinaryProduct X (0 : C) 
goal: CategoryTheory.Limits.HasBinaryProduct X 0

full_name: CategoryTheory.Limits.prodZeroIso
code: /-- A zero object is a right unit for categorical product. -/
def prodZeroIso (X : C) : X ⨯ (0 : C) ≅ X 
goal: X ⨯ 0 ≅ X

full_name: CategoryTheory.Limits.prodZeroIso_hom
code: @[simp]
theorem prodZeroIso_hom (X : C) : (prodZeroIso X).hom = prod.fst 
goal: (CategoryTheory.Limits.prodZeroIso X).hom = CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Limits.prodZeroIso_iso_inv_snd
code: @[simp]
theorem prodZeroIso_iso_inv_snd (X : C) : (prodZeroIso X).inv ≫ prod.fst = 𝟙 X 
goal: (CategoryTheory.Limits.prodZeroIso X).inv ≫ CategoryTheory.Limits.prod.fst = 𝟙 X

full_name: CategoryTheory.Limits.binaryCofanZeroLeft
code: /-- The colimit cocone for the coproduct with a zero object. -/
def binaryCofanZeroLeft (X : C) : BinaryCofan (0 : C) X 
goal: CategoryTheory.Limits.BinaryCofan 0 X

full_name: CategoryTheory.Limits.binaryCofanZeroLeftIsColimit
code: /-- The colimit cocone for the coproduct with a zero object is colimiting. -/
def binaryCofanZeroLeftIsColimit (X : C) : IsColimit (binaryCofanZeroLeft X) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.binaryCofanZeroLeft X)

full_name: CategoryTheory.Limits.hasBinaryCoproduct_zero_left
code: instance hasBinaryCoproduct_zero_left (X : C) : HasBinaryCoproduct (0 : C) X 
goal: CategoryTheory.Limits.HasBinaryCoproduct 0 X

full_name: CategoryTheory.Limits.zeroCoprodIso
code: /-- A zero object is a left unit for categorical coproduct. -/
def zeroCoprodIso (X : C) : (0 : C) ⨿ X ≅ X 
goal: 0 ⨿ X ≅ X

full_name: CategoryTheory.Limits.inr_zeroCoprodIso_hom
code: @[simp]
theorem inr_zeroCoprodIso_hom (X : C) : coprod.inr ≫ (zeroCoprodIso X).hom = 𝟙 X 
goal: CategoryTheory.Limits.coprod.inr ≫ (CategoryTheory.Limits.zeroCoprodIso X).hom = 𝟙 X

full_name: CategoryTheory.Limits.zeroCoprodIso_inv
code: @[simp]
theorem zeroCoprodIso_inv (X : C) : (zeroCoprodIso X).inv = coprod.inr 
goal: (CategoryTheory.Limits.zeroCoprodIso X).inv = CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.Limits.binaryCofanZeroRight
code: /-- The colimit cocone for the coproduct with a zero object. -/
def binaryCofanZeroRight (X : C) : BinaryCofan X (0 : C) 
goal: CategoryTheory.Limits.BinaryCofan X 0

full_name: CategoryTheory.Limits.binaryCofanZeroRightIsColimit
code: /-- The colimit cocone for the coproduct with a zero object is colimiting. -/
def binaryCofanZeroRightIsColimit (X : C) : IsColimit (binaryCofanZeroRight X) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.binaryCofanZeroRight X)

full_name: CategoryTheory.Limits.hasBinaryCoproduct_zero_right
code: instance hasBinaryCoproduct_zero_right (X : C) : HasBinaryCoproduct X (0 : C) 
goal: CategoryTheory.Limits.HasBinaryCoproduct X 0

full_name: CategoryTheory.Limits.coprodZeroIso
code: /-- A zero object is a right unit for categorical coproduct. -/
def coprodZeroIso (X : C) : X ⨿ (0 : C) ≅ X 
goal: X ⨿ 0 ≅ X

full_name: CategoryTheory.Limits.inr_coprodZeroIso_hom
code: @[simp]
theorem inr_coprodZeroIso_hom (X : C) : coprod.inl ≫ (coprodZeroIso X).hom = 𝟙 X 
goal: CategoryTheory.Limits.coprod.inl ≫ (CategoryTheory.Limits.coprodZeroIso X).hom = 𝟙 X

full_name: CategoryTheory.Limits.coprodZeroIso_inv
code: @[simp]
theorem coprodZeroIso_inv (X : C) : (coprodZeroIso X).inv = coprod.inl 
goal: (CategoryTheory.Limits.coprodZeroIso X).inv = CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.Limits.hasPullback_over_zero
code: instance hasPullback_over_zero (X Y : C) [HasBinaryProduct X Y] :
    HasPullback (0 : X ⟶ 0) (0 : Y ⟶ 0) 
goal: CategoryTheory.Limits.HasPullback 0 0

full_name: CategoryTheory.Limits.pullbackZeroZeroIso
code: /-- The pullback over the zero object is the product. -/
def pullbackZeroZeroIso (X Y : C) [HasBinaryProduct X Y] :
    pullback (0 : X ⟶ 0) (0 : Y ⟶ 0) ≅ X ⨯ Y 
goal: CategoryTheory.Limits.pullback 0 0 ≅ X ⨯ Y

full_name: CategoryTheory.Limits.pullbackZeroZeroIso_inv_fst
code: @[simp]
theorem pullbackZeroZeroIso_inv_fst (X Y : C) [HasBinaryProduct X Y] :
    (pullbackZeroZeroIso X Y).inv ≫ pullback.fst 0 0 = prod.fst 
goal: (CategoryTheory.Limits.pullbackZeroZeroIso X Y).inv ≫ CategoryTheory.Limits.pullback.fst 0 0 =
  CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Limits.pullbackZeroZeroIso_inv_snd
code: @[simp]
theorem pullbackZeroZeroIso_inv_snd (X Y : C) [HasBinaryProduct X Y] :
    (pullbackZeroZeroIso X Y).inv ≫ pullback.snd 0 0 = prod.snd 
goal: (CategoryTheory.Limits.pullbackZeroZeroIso X Y).inv ≫ CategoryTheory.Limits.pullback.snd 0 0 =
  CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Limits.pullbackZeroZeroIso_hom_fst
code: @[simp]
theorem pullbackZeroZeroIso_hom_fst (X Y : C) [HasBinaryProduct X Y] :
    (pullbackZeroZeroIso X Y).hom ≫ prod.fst = pullback.fst 0 0 
goal: (CategoryTheory.Limits.pullbackZeroZeroIso X Y).hom ≫ CategoryTheory.Limits.prod.fst =
  CategoryTheory.Limits.pullback.fst 0 0

full_name: CategoryTheory.Limits.pullbackZeroZeroIso_hom_snd
code: @[simp]
theorem pullbackZeroZeroIso_hom_snd (X Y : C) [HasBinaryProduct X Y] :
    (pullbackZeroZeroIso X Y).hom ≫ prod.snd = pullback.snd 0 0 
goal: (CategoryTheory.Limits.pullbackZeroZeroIso X Y).hom ≫ CategoryTheory.Limits.prod.snd =
  CategoryTheory.Limits.pullback.snd 0 0

full_name: CategoryTheory.Limits.hasPushout_over_zero
code: instance hasPushout_over_zero (X Y : C) [HasBinaryCoproduct X Y] :
    HasPushout (0 : 0 ⟶ X) (0 : 0 ⟶ Y) 
goal: CategoryTheory.Limits.HasPushout 0 0

full_name: CategoryTheory.Limits.pushoutZeroZeroIso
code: /-- The pushout over the zero object is the coproduct. -/
def pushoutZeroZeroIso (X Y : C) [HasBinaryCoproduct X Y] :
    pushout (0 : 0 ⟶ X) (0 : 0 ⟶ Y) ≅ X ⨿ Y 
goal: CategoryTheory.Limits.pushout 0 0 ≅ X ⨿ Y

full_name: CategoryTheory.Limits.inl_pushoutZeroZeroIso_hom
code: @[simp]
theorem inl_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
    pushout.inl _ _ ≫ (pushoutZeroZeroIso X Y).hom = coprod.inl 
goal: CategoryTheory.Limits.pushout.inl 0 0 ≫ (CategoryTheory.Limits.pushoutZeroZeroIso X Y).hom =
  CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.Limits.inr_pushoutZeroZeroIso_hom
code: @[simp]
theorem inr_pushoutZeroZeroIso_hom (X Y : C) [HasBinaryCoproduct X Y] :
    pushout.inr _ _ ≫ (pushoutZeroZeroIso X Y).hom = coprod.inr 
goal: CategoryTheory.Limits.pushout.inr 0 0 ≫ (CategoryTheory.Limits.pushoutZeroZeroIso X Y).hom =
  CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.Limits.inl_pushoutZeroZeroIso_inv
code: @[simp]
theorem inl_pushoutZeroZeroIso_inv (X Y : C) [HasBinaryCoproduct X Y] :
    coprod.inl ≫ (pushoutZeroZeroIso X Y).inv = pushout.inl _ _ 
goal: CategoryTheory.Limits.coprod.inl ≫ (CategoryTheory.Limits.pushoutZeroZeroIso X Y).inv =
  CategoryTheory.Limits.pushout.inl 0 0

full_name: CategoryTheory.Limits.inr_pushoutZeroZeroIso_inv
code: @[simp]
theorem inr_pushoutZeroZeroIso_inv (X Y : C) [HasBinaryCoproduct X Y] :
    coprod.inr ≫ (pushoutZeroZeroIso X Y).inv = pushout.inr _ _ 
goal: CategoryTheory.Limits.coprod.inr ≫ (CategoryTheory.Limits.pushoutZeroZeroIso X Y).inv =
  CategoryTheory.Limits.pushout.inr 0 0