File: Mathlib/CategoryTheory/Limits/Comma.lean

full_name: CategoryTheory.Comma.limitAuxiliaryCone_π_app
code: /-- (Implementation). An auxiliary cone which is useful in order to construct limits
in the comma category. -/
@[simps!]
def limitAuxiliaryCone (c₁ : Cone (F ⋙ fst L R)) : Cone ((F ⋙ snd L R) ⋙ R) 
goal: (CategoryTheory.Comma.limitAuxiliaryCone F c₁).π.app X =
  CategoryTheory.CategoryStruct.comp (L.map (c₁.π.app X)) (F.obj X).hom

full_name: CategoryTheory.Comma.limitAuxiliaryCone
code: /-- (Implementation). An auxiliary cone which is useful in order to construct limits
in the comma category. -/
@[simps!]
def limitAuxiliaryCone (c₁ : Cone (F ⋙ fst L R)) : Cone ((F ⋙ snd L R) ⋙ R) 
goal: CategoryTheory.Limits.Cone ((F.comp (CategoryTheory.Comma.snd L R)).comp R)

full_name: CategoryTheory.Comma.limitAuxiliaryCone_pt
code: /-- (Implementation). An auxiliary cone which is useful in order to construct limits
in the comma category. -/
@[simps!]
def limitAuxiliaryCone (c₁ : Cone (F ⋙ fst L R)) : Cone ((F ⋙ snd L R) ⋙ R) 
goal: (CategoryTheory.Comma.limitAuxiliaryCone F c₁).pt = L.obj c₁.pt

full_name: CategoryTheory.Comma.coneOfPreserves_pt_right
code: /-- If `R` preserves the appropriate limit, then given a cone for `F ⋙ fst L R : J ⥤ L` and a
limit cone for `F ⋙ snd L R : J ⥤ R` we can build a cone for `F` which will turn out to be a limit
cone.
-/
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
goal: (CategoryTheory.Comma.coneOfPreserves F c₁ t₂).pt.right = c₂.pt

full_name: CategoryTheory.Comma.coneOfPreserves
code: /-- If `R` preserves the appropriate limit, then given a cone for `F ⋙ fst L R : J ⥤ L` and a
limit cone for `F ⋙ snd L R : J ⥤ R` we can build a cone for `F` which will turn out to be a limit
cone.
-/
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Comma.coneOfPreserves_pt_left
code: /-- If `R` preserves the appropriate limit, then given a cone for `F ⋙ fst L R : J ⥤ L` and a
limit cone for `F ⋙ snd L R : J ⥤ R` we can build a cone for `F` which will turn out to be a limit
cone.
-/
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
goal: (CategoryTheory.Comma.coneOfPreserves F c₁ t₂).pt.left = c₁.pt

full_name: CategoryTheory.Comma.coneOfPreserves_pt_hom
code: /-- If `R` preserves the appropriate limit, then given a cone for `F ⋙ fst L R : J ⥤ L` and a
limit cone for `F ⋙ snd L R : J ⥤ R` we can build a cone for `F` which will turn out to be a limit
cone.
-/
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
goal: (CategoryTheory.Comma.coneOfPreserves F c₁ t₂).pt.hom =
  (CategoryTheory.Limits.isLimitOfPreserves R t₂).lift (CategoryTheory.Comma.limitAuxiliaryCone F c₁)

full_name: CategoryTheory.Comma.coneOfPreserves_π_app_left
code: /-- If `R` preserves the appropriate limit, then given a cone for `F ⋙ fst L R : J ⥤ L` and a
limit cone for `F ⋙ snd L R : J ⥤ R` we can build a cone for `F` which will turn out to be a limit
cone.
-/
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
goal: ((CategoryTheory.Comma.coneOfPreserves F c₁ t₂).π.app j).left = c₁.π.app j

full_name: CategoryTheory.Comma.coneOfPreserves_π_app_right
code: /-- If `R` preserves the appropriate limit, then given a cone for `F ⋙ fst L R : J ⥤ L` and a
limit cone for `F ⋙ snd L R : J ⥤ R` we can build a cone for `F` which will turn out to be a limit
cone.
-/
@[simps]
def coneOfPreserves [PreservesLimit (F ⋙ snd L R) R] (c₁ : Cone (F ⋙ fst L R))
    {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) : Cone F 
goal: ((CategoryTheory.Comma.coneOfPreserves F c₁ t₂).π.app j).right = c₂.π.app j

full_name: CategoryTheory.Comma.coneOfPreservesIsLimit
code: /-- Provided that `R` preserves the appropriate limit, then the cone in `coneOfPreserves` is a
limit. -/
def coneOfPreservesIsLimit [PreservesLimit (F ⋙ snd L R) R] {c₁ : Cone (F ⋙ fst L R)}
    (t₁ : IsLimit c₁) {c₂ : Cone (F ⋙ snd L R)} (t₂ : IsLimit c₂) :
    IsLimit (coneOfPreserves F c₁ t₂) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Comma.coneOfPreserves F c₁ t₂)

full_name: CategoryTheory.Comma.colimitAuxiliaryCocone_ι_app
code: /-- (Implementation). An auxiliary cocone which is useful in order to construct colimits
in the comma category. -/
@[simps!]
def colimitAuxiliaryCocone (c₂ : Cocone (F ⋙ snd L R)) : Cocone ((F ⋙ fst L R) ⋙ L) 
goal: (CategoryTheory.Comma.colimitAuxiliaryCocone F c₂).ι.app X =
  CategoryTheory.CategoryStruct.comp (F.obj X).hom (R.map (c₂.ι.app X))

full_name: CategoryTheory.Comma.colimitAuxiliaryCocone
code: /-- (Implementation). An auxiliary cocone which is useful in order to construct colimits
in the comma category. -/
@[simps!]
def colimitAuxiliaryCocone (c₂ : Cocone (F ⋙ snd L R)) : Cocone ((F ⋙ fst L R) ⋙ L) 
goal: CategoryTheory.Limits.Cocone ((F.comp (CategoryTheory.Comma.fst L R)).comp L)

full_name: CategoryTheory.Comma.colimitAuxiliaryCocone_pt
code: /-- (Implementation). An auxiliary cocone which is useful in order to construct colimits
in the comma category. -/
@[simps!]
def colimitAuxiliaryCocone (c₂ : Cocone (F ⋙ snd L R)) : Cocone ((F ⋙ fst L R) ⋙ L) 
goal: (CategoryTheory.Comma.colimitAuxiliaryCocone F c₂).pt = R.obj c₂.pt

full_name: CategoryTheory.Comma.coconeOfPreserves
code: /--
If `L` preserves the appropriate colimit, then given a colimit cocone for `F ⋙ fst L R : J ⥤ L` and
a cocone for `F ⋙ snd L R : J ⥤ R` we can build a cocone for `F` which will turn out to be a
colimit cocone.
-/
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Comma.coconeOfPreserves_pt_right
code: /--
If `L` preserves the appropriate colimit, then given a colimit cocone for `F ⋙ fst L R : J ⥤ L` and
a cocone for `F ⋙ snd L R : J ⥤ R` we can build a cocone for `F` which will turn out to be a
colimit cocone.
-/
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
goal: (CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).pt.right = c₂.pt

full_name: CategoryTheory.Comma.coconeOfPreserves_pt_left
code: /--
If `L` preserves the appropriate colimit, then given a colimit cocone for `F ⋙ fst L R : J ⥤ L` and
a cocone for `F ⋙ snd L R : J ⥤ R` we can build a cocone for `F` which will turn out to be a
colimit cocone.
-/
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
goal: (CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).pt.left = c₁.pt

full_name: CategoryTheory.Comma.coconeOfPreserves_ι_app_left
code: /--
If `L` preserves the appropriate colimit, then given a colimit cocone for `F ⋙ fst L R : J ⥤ L` and
a cocone for `F ⋙ snd L R : J ⥤ R` we can build a cocone for `F` which will turn out to be a
colimit cocone.
-/
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
goal: ((CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).ι.app j).left = c₁.ι.app j

full_name: CategoryTheory.Comma.coconeOfPreserves_pt_hom
code: /--
If `L` preserves the appropriate colimit, then given a colimit cocone for `F ⋙ fst L R : J ⥤ L` and
a cocone for `F ⋙ snd L R : J ⥤ R` we can build a cocone for `F` which will turn out to be a
colimit cocone.
-/
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
goal: (CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).pt.hom =
  (CategoryTheory.Limits.isColimitOfPreserves L t₁).desc (CategoryTheory.Comma.colimitAuxiliaryCocone F c₂)

full_name: CategoryTheory.Comma.coconeOfPreserves_ι_app_right
code: /--
If `L` preserves the appropriate colimit, then given a colimit cocone for `F ⋙ fst L R : J ⥤ L` and
a cocone for `F ⋙ snd L R : J ⥤ R` we can build a cocone for `F` which will turn out to be a
colimit cocone.
-/
@[simps]
def coconeOfPreserves [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) (c₂ : Cocone (F ⋙ snd L R)) : Cocone F 
goal: ((CategoryTheory.Comma.coconeOfPreserves F t₁ c₂).ι.app j).right = c₂.ι.app j

full_name: CategoryTheory.Comma.coconeOfPreservesIsColimit
code: /-- Provided that `L` preserves the appropriate colimit, then the cocone in `coconeOfPreserves` is
a colimit. -/
def coconeOfPreservesIsColimit [PreservesColimit (F ⋙ fst L R) L] {c₁ : Cocone (F ⋙ fst L R)}
    (t₁ : IsColimit c₁) {c₂ : Cocone (F ⋙ snd L R)} (t₂ : IsColimit c₂) :
    IsColimit (coconeOfPreserves F t₁ c₂) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Comma.coconeOfPreserves F t₁ c₂)

full_name: CategoryTheory.Comma.hasLimit
code: instance hasLimit (F : J ⥤ Comma L R) [HasLimit (F ⋙ fst L R)] [HasLimit (F ⋙ snd L R)]
    [PreservesLimit (F ⋙ snd L R) R] : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Comma.hasLimitsOfShape
code: instance hasLimitsOfShape [HasLimitsOfShape J A] [HasLimitsOfShape J B]
    [PreservesLimitsOfShape J R] : HasLimitsOfShape J (Comma L R) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Comma L R)

full_name: CategoryTheory.Comma.hasLimitsOfSize
code: instance hasLimitsOfSize [HasLimitsOfSize.{w, w'} A] [HasLimitsOfSize.{w, w'} B]
    [PreservesLimitsOfSize.{w, w'} R] : HasLimitsOfSize.{w, w'} (Comma L R) 
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, w', max v₁ v₂, max (max u₂ u₁) v₃} (CategoryTheory.Comma L R)

full_name: CategoryTheory.Comma.hasColimit
code: instance hasColimit (F : J ⥤ Comma L R) [HasColimit (F ⋙ fst L R)] [HasColimit (F ⋙ snd L R)]
    [PreservesColimit (F ⋙ fst L R) L] : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Comma.hasColimitsOfShape
code: instance hasColimitsOfShape [HasColimitsOfShape J A] [HasColimitsOfShape J B]
    [PreservesColimitsOfShape J L] : HasColimitsOfShape J (Comma L R) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.Comma L R)

full_name: CategoryTheory.Comma.hasColimitsOfSize
code: instance hasColimitsOfSize [HasColimitsOfSize.{w, w'} A] [HasColimitsOfSize.{w, w'} B]
    [PreservesColimitsOfSize.{w, w'} L] : HasColimitsOfSize.{w, w'} (Comma L R) 
goal: CategoryTheory.Limits.HasColimitsOfSize.{w, w', max v₁ v₂, max (max u₂ u₁) v₃} (CategoryTheory.Comma L R)

full_name: CategoryTheory.Arrow.hasLimit
code: instance hasLimit (F : J ⥤ Arrow T) [i₁ : HasLimit (F ⋙ leftFunc)] [i₂ : HasLimit (F ⋙ rightFunc)] :
    HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Arrow.hasLimitsOfShape
code: instance hasLimitsOfShape [HasLimitsOfShape J T] : HasLimitsOfShape J (Arrow T) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Arrow T)

full_name: CategoryTheory.Arrow.hasLimits
code: instance hasLimits [HasLimits T] : HasLimits (Arrow T) 
goal: CategoryTheory.Limits.HasLimits (CategoryTheory.Arrow T)

full_name: CategoryTheory.Arrow.hasColimit
code: instance hasColimit (F : J ⥤ Arrow T) [i₁ : HasColimit (F ⋙ leftFunc)]
    [i₂ : HasColimit (F ⋙ rightFunc)] : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Arrow.hasColimitsOfShape
code: instance hasColimitsOfShape [HasColimitsOfShape J T] : HasColimitsOfShape J (Arrow T) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.Arrow T)

full_name: CategoryTheory.Arrow.hasColimits
code: instance hasColimits [HasColimits T] : HasColimits (Arrow T) 
goal: CategoryTheory.Limits.HasColimits (CategoryTheory.Arrow T)

full_name: CategoryTheory.StructuredArrow.hasLimit
code: instance hasLimit [i₁ : HasLimit (F ⋙ proj X G)] [i₂ : PreservesLimit (F ⋙ proj X G) G] :
    HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.StructuredArrow.hasLimitsOfShape
code: instance hasLimitsOfShape [HasLimitsOfShape J A] [PreservesLimitsOfShape J G] :
    HasLimitsOfShape J (StructuredArrow X G) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.StructuredArrow X G)

full_name: CategoryTheory.StructuredArrow.hasLimitsOfSize
code: instance hasLimitsOfSize [HasLimitsOfSize.{w, w'} A] [PreservesLimitsOfSize.{w, w'} G] :
    HasLimitsOfSize.{w, w'} (StructuredArrow X G) 
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, w', v₁, max u₁ v₃} (CategoryTheory.StructuredArrow X G)

full_name: CategoryTheory.StructuredArrow.createsLimit
code: noncomputable instance createsLimit [i : PreservesLimit (F ⋙ proj X G) G] :
    CreatesLimit F (proj X G) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.StructuredArrow.proj X G)

full_name: CategoryTheory.StructuredArrow.createsLimitsOfShape
code: noncomputable instance createsLimitsOfShape [PreservesLimitsOfShape J G] :
    CreatesLimitsOfShape J (proj X G) 
goal: CategoryTheory.CreatesLimitsOfShape J (CategoryTheory.StructuredArrow.proj X G)

full_name: CategoryTheory.StructuredArrow.createsLimitsOfSize
code: noncomputable instance createsLimitsOfSize [PreservesLimitsOfSize.{w, w'} G] :
    CreatesLimitsOfSize.{w, w'} (proj X G : _) 
goal: CategoryTheory.CreatesLimitsOfSize.{w, w', v₁, v₁, max u₁ v₃, u₁} (CategoryTheory.StructuredArrow.proj X G)

full_name: CategoryTheory.StructuredArrow.mono_right_of_mono
code: instance mono_right_of_mono [HasPullbacks A] [PreservesLimitsOfShape WalkingCospan G]
    {Y Z : StructuredArrow X G} (f : Y ⟶ Z) [Mono f] : Mono f.right 
goal: CategoryTheory.Mono f.right

full_name: CategoryTheory.StructuredArrow.mono_iff_mono_right
code: theorem mono_iff_mono_right [HasPullbacks A] [PreservesLimitsOfShape WalkingCospan G]
    {Y Z : StructuredArrow X G} (f : Y ⟶ Z) : Mono f ↔ Mono f.right 
goal: CategoryTheory.Mono f ↔ CategoryTheory.Mono f.right

full_name: CategoryTheory.CostructuredArrow.hasColimit
code: instance hasColimit [i₁ : HasColimit (F ⋙ proj G X)] [i₂ : PreservesColimit (F ⋙ proj G X) G] :
    HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.CostructuredArrow.hasColimitsOfShape
code: instance hasColimitsOfShape [HasColimitsOfShape J A] [PreservesColimitsOfShape J G] :
    HasColimitsOfShape J (CostructuredArrow G X) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.CostructuredArrow G X)

full_name: CategoryTheory.CostructuredArrow.hasColimitsOfSize
code: instance hasColimitsOfSize [HasColimitsOfSize.{w, w'} A] [PreservesColimitsOfSize.{w, w'} G] :
    HasColimitsOfSize.{w, w'} (CostructuredArrow G X) 
goal: CategoryTheory.Limits.HasColimitsOfSize.{w, w', v₁, max u₁ v₃} (CategoryTheory.CostructuredArrow G X)

full_name: CategoryTheory.CostructuredArrow.createsColimit
code: noncomputable instance createsColimit [i : PreservesColimit (F ⋙ proj G X) G] :
    CreatesColimit F (proj G X) 
goal: CategoryTheory.CreatesColimit F (CategoryTheory.CostructuredArrow.proj G X)

full_name: CategoryTheory.CostructuredArrow.createsColimitsOfShape
code: noncomputable instance createsColimitsOfShape [PreservesColimitsOfShape J G] :
    CreatesColimitsOfShape J (proj G X) 
goal: CategoryTheory.CreatesColimitsOfShape J (CategoryTheory.CostructuredArrow.proj G X)

full_name: CategoryTheory.CostructuredArrow.createsColimitsOfSize
code: noncomputable instance createsColimitsOfSize [PreservesColimitsOfSize.{w, w'} G] :
    CreatesColimitsOfSize.{w, w'} (proj G X : _) 
goal: CategoryTheory.CreatesColimitsOfSize.{w, w', v₁, v₁, max u₁ v₃, u₁} (CategoryTheory.CostructuredArrow.proj G X)

full_name: CategoryTheory.CostructuredArrow.epi_left_of_epi
code: instance epi_left_of_epi [HasPushouts A] [PreservesColimitsOfShape WalkingSpan G]
    {Y Z : CostructuredArrow G X} (f : Y ⟶ Z) [Epi f] : Epi f.left 
goal: CategoryTheory.Epi f.left

full_name: CategoryTheory.CostructuredArrow.epi_iff_epi_left
code: theorem epi_iff_epi_left [HasPushouts A] [PreservesColimitsOfShape WalkingSpan G]
    {Y Z : CostructuredArrow G X} (f : Y ⟶ Z) : Epi f ↔ Epi f.left 
goal: CategoryTheory.Epi f ↔ CategoryTheory.Epi f.left