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

full_name: CategoryTheory.Limits.asEmptyCone_π_app
code: /-- Construct a cone for the empty diagram given an object. -/
@[simps]
def asEmptyCone (X : C) : Cone (Functor.empty.{0} C) 
goal: (CategoryTheory.Limits.asEmptyCone X).π.app X_1 = id (CategoryTheory.Discrete.casesOn X_1 fun as => ⋯.elim)

full_name: CategoryTheory.Limits.asEmptyCone
code: /-- Construct a cone for the empty diagram given an object. -/
@[simps]
def asEmptyCone (X : C) : Cone (Functor.empty.{0} C) 
goal: CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty C)

full_name: CategoryTheory.Limits.asEmptyCone_pt
code: /-- Construct a cone for the empty diagram given an object. -/
@[simps]
def asEmptyCone (X : C) : Cone (Functor.empty.{0} C) 
goal: (CategoryTheory.Limits.asEmptyCone X).pt = X

full_name: CategoryTheory.Limits.asEmptyCocone_pt
code: /-- Construct a cocone for the empty diagram given an object. -/
@[simps]
def asEmptyCocone (X : C) : Cocone (Functor.empty.{0} C) 
goal: (CategoryTheory.Limits.asEmptyCocone X).pt = X

full_name: CategoryTheory.Limits.asEmptyCocone
code: /-- Construct a cocone for the empty diagram given an object. -/
@[simps]
def asEmptyCocone (X : C) : Cocone (Functor.empty.{0} C) 
goal: CategoryTheory.Limits.Cocone (CategoryTheory.Functor.empty C)

full_name: CategoryTheory.Limits.asEmptyCocone_ι_app
code: /-- Construct a cocone for the empty diagram given an object. -/
@[simps]
def asEmptyCocone (X : C) : Cocone (Functor.empty.{0} C) 
goal: (CategoryTheory.Limits.asEmptyCocone X).ι.app X_1 = id (CategoryTheory.Discrete.casesOn X_1 fun as => ⋯.elim)

full_name: CategoryTheory.Limits.IsTerminal
code: /-- `X` is terminal if the cone it induces on the empty diagram is limiting. -/
abbrev IsTerminal (X : C) 
goal: Type (max u₁ v₁)

full_name: CategoryTheory.Limits.IsInitial
code: /-- `X` is initial if the cocone it induces on the empty diagram is colimiting. -/
abbrev IsInitial (X : C) 
goal: Type (max u₁ v₁)

full_name: CategoryTheory.Limits.isTerminalEquivUnique
code: /-- An object `Y` is terminal iff for every `X` there is a unique morphism `X ⟶ Y`. -/
def isTerminalEquivUnique (F : Discrete.{0} PEmpty.{1} ⥤ C) (Y : C) :
    IsLimit (⟨Y, by aesop_cat, by aesop_cat⟩ : Cone F) ≃ ∀ X : C, Unique (X ⟶ Y) 
goal: CategoryTheory.Limits.IsLimit
    { pt := Y, π := { app := fun X => id (CategoryTheory.Discrete.casesOn X fun as => ⋯.elim), naturality := ⋯ } } ≃
  ((X : C) → Unique (X ⟶ Y))

full_name: CategoryTheory.Limits.IsTerminal.ofUnique
code: /-- An object `Y` is terminal if for every `X` there is a unique morphism `X ⟶ Y`
    (as an instance). -/
def IsTerminal.ofUnique (Y : C) [h : ∀ X : C, Unique (X ⟶ Y)] : IsTerminal Y 
goal: CategoryTheory.Limits.IsTerminal Y

full_name: CategoryTheory.Limits.IsTerminal.ofUniqueHom
code: /-- An object `Y` is terminal if for every `X` there is a unique morphism `X ⟶ Y`
    (as explicit arguments). -/
def IsTerminal.ofUniqueHom {Y : C} (h : ∀ X : C, X ⟶ Y) (uniq : ∀ (X : C) (m : X ⟶ Y), m = h X) :
    IsTerminal Y 
goal: CategoryTheory.Limits.IsTerminal Y

full_name: CategoryTheory.Limits.isTerminalTop
code: /-- If `α` is a preorder with top, then `⊤` is a terminal object. -/
def isTerminalTop {α : Type*} [Preorder α] [OrderTop α] : IsTerminal (⊤ : α) 
goal: CategoryTheory.Limits.IsTerminal ⊤

full_name: CategoryTheory.Limits.IsTerminal.ofIso
code: /-- Transport a term of type `IsTerminal` across an isomorphism. -/
def IsTerminal.ofIso {Y Z : C} (hY : IsTerminal Y) (i : Y ≅ Z) : IsTerminal Z 
goal: CategoryTheory.Limits.IsTerminal Z

full_name: CategoryTheory.Limits.IsTerminal.equivOfIso
code: /-- If `X` and `Y` are isomorphic, then `X` is terminal iff `Y` is. -/
def IsTerminal.equivOfIso {X Y : C} (e : X ≅ Y) :
    IsTerminal X ≃ IsTerminal Y 
goal: CategoryTheory.Limits.IsTerminal X ≃ CategoryTheory.Limits.IsTerminal Y

full_name: CategoryTheory.Limits.isInitialEquivUnique
code: /-- An object `X` is initial iff for every `Y` there is a unique morphism `X ⟶ Y`. -/
def isInitialEquivUnique (F : Discrete.{0} PEmpty.{1} ⥤ C) (X : C) :
    IsColimit (⟨X, ⟨by aesop_cat, by aesop_cat⟩⟩ : Cocone F) ≃ ∀ Y : C, Unique (X ⟶ Y) 
goal: CategoryTheory.Limits.IsColimit
    { pt := X, ι := { app := fun X_1 => id (CategoryTheory.Discrete.casesOn X_1 fun as => ⋯.elim), naturality := ⋯ } } ≃
  ((Y : C) → Unique (X ⟶ Y))

full_name: CategoryTheory.Limits.IsInitial.ofUnique
code: /-- An object `X` is initial if for every `Y` there is a unique morphism `X ⟶ Y`
    (as an instance). -/
def IsInitial.ofUnique (X : C) [h : ∀ Y : C, Unique (X ⟶ Y)] : IsInitial X 
goal: CategoryTheory.Limits.IsInitial X

full_name: CategoryTheory.Limits.IsInitial.ofUniqueHom
code: /-- An object `X` is initial if for every `Y` there is a unique morphism `X ⟶ Y`
    (as explicit arguments). -/
def IsInitial.ofUniqueHom {X : C} (h : ∀ Y : C, X ⟶ Y) (uniq : ∀ (Y : C) (m : X ⟶ Y), m = h Y) :
    IsInitial X 
goal: CategoryTheory.Limits.IsInitial X

full_name: CategoryTheory.Limits.isInitialBot
code: /-- If `α` is a preorder with bot, then `⊥` is an initial object. -/
def isInitialBot {α : Type*} [Preorder α] [OrderBot α] : IsInitial (⊥ : α) 
goal: CategoryTheory.Limits.IsInitial ⊥

full_name: CategoryTheory.Limits.IsInitial.ofIso
code: /-- Transport a term of type `is_initial` across an isomorphism. -/
def IsInitial.ofIso {X Y : C} (hX : IsInitial X) (i : X ≅ Y) : IsInitial Y 
goal: CategoryTheory.Limits.IsInitial Y

full_name: CategoryTheory.Limits.IsInitial.equivOfIso
code: /-- If `X` and `Y` are isomorphic, then `X` is initial iff `Y` is. -/
def IsInitial.equivOfIso {X Y : C} (e : X ≅ Y) :
    IsInitial X ≃ IsInitial Y 
goal: CategoryTheory.Limits.IsInitial X ≃ CategoryTheory.Limits.IsInitial Y

full_name: CategoryTheory.Limits.IsTerminal.from
code: /-- Give the morphism to a terminal object from any other. -/
def IsTerminal.from {X : C} (t : IsTerminal X) (Y : C) : Y ⟶ X 
goal: Y ⟶ X

full_name: CategoryTheory.Limits.IsTerminal.hom_ext
code: /-- Any two morphisms to a terminal object are equal. -/
theorem IsTerminal.hom_ext {X Y : C} (t : IsTerminal X) (f g : Y ⟶ X) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.IsTerminal.comp_from
code: @[simp]
theorem IsTerminal.comp_from {Z : C} (t : IsTerminal Z) {X Y : C} (f : X ⟶ Y) :
    f ≫ t.from Y = t.from X 
goal: f ≫ t.from Y = t.from X

full_name: CategoryTheory.Limits.IsTerminal.from_self
code: @[simp]
theorem IsTerminal.from_self {X : C} (t : IsTerminal X) : t.from X = 𝟙 X 
goal: t.from X = 𝟙 X

full_name: CategoryTheory.Limits.IsInitial.to
code: /-- Give the morphism from an initial object to any other. -/
def IsInitial.to {X : C} (t : IsInitial X) (Y : C) : X ⟶ Y 
goal: X ⟶ Y

full_name: CategoryTheory.Limits.IsInitial.hom_ext
code: /-- Any two morphisms from an initial object are equal. -/
theorem IsInitial.hom_ext {X Y : C} (t : IsInitial X) (f g : X ⟶ Y) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.IsInitial.to_comp
code: @[simp]
theorem IsInitial.to_comp {X : C} (t : IsInitial X) {Y Z : C} (f : Y ⟶ Z) : t.to Y ≫ f = t.to Z 
goal: t.to Y ≫ f = t.to Z

full_name: CategoryTheory.Limits.IsInitial.to_self
code: @[simp]
theorem IsInitial.to_self {X : C} (t : IsInitial X) : t.to X = 𝟙 X 
goal: t.to X = 𝟙 X

full_name: CategoryTheory.Limits.IsTerminal.isSplitMono_from
code: /-- Any morphism from a terminal object is split mono. -/
theorem IsTerminal.isSplitMono_from {X Y : C} (t : IsTerminal X) (f : X ⟶ Y) : IsSplitMono f 
goal: CategoryTheory.IsSplitMono f

full_name: CategoryTheory.Limits.IsInitial.isSplitEpi_to
code: /-- Any morphism to an initial object is split epi. -/
theorem IsInitial.isSplitEpi_to {X Y : C} (t : IsInitial X) (f : Y ⟶ X) : IsSplitEpi f 
goal: CategoryTheory.IsSplitEpi f

full_name: CategoryTheory.Limits.IsTerminal.mono_from
code: /-- Any morphism from a terminal object is mono. -/
theorem IsTerminal.mono_from {X Y : C} (t : IsTerminal X) (f : X ⟶ Y) : Mono f 
goal: CategoryTheory.Mono f

full_name: CategoryTheory.Limits.IsInitial.epi_to
code: /-- Any morphism to an initial object is epi. -/
theorem IsInitial.epi_to {X Y : C} (t : IsInitial X) (f : Y ⟶ X) : Epi f 
goal: CategoryTheory.Epi f

full_name: CategoryTheory.Limits.IsTerminal.uniqueUpToIso_inv
code: /-- If `T` and `T'` are terminal, they are isomorphic. -/
@[simps]
def IsTerminal.uniqueUpToIso {T T' : C} (hT : IsTerminal T) (hT' : IsTerminal T') : T ≅ T' 
goal: (hT.uniqueUpToIso hT').inv = hT.from T'

full_name: CategoryTheory.Limits.IsTerminal.uniqueUpToIso
code: /-- If `T` and `T'` are terminal, they are isomorphic. -/
@[simps]
def IsTerminal.uniqueUpToIso {T T' : C} (hT : IsTerminal T) (hT' : IsTerminal T') : T ≅ T' 
goal: T ≅ T'

full_name: CategoryTheory.Limits.IsTerminal.uniqueUpToIso_hom
code: /-- If `T` and `T'` are terminal, they are isomorphic. -/
@[simps]
def IsTerminal.uniqueUpToIso {T T' : C} (hT : IsTerminal T) (hT' : IsTerminal T') : T ≅ T' 
goal: (hT.uniqueUpToIso hT').hom = hT'.from T

full_name: CategoryTheory.Limits.IsInitial.uniqueUpToIso_hom
code: /-- If `I` and `I'` are initial, they are isomorphic. -/
@[simps]
def IsInitial.uniqueUpToIso {I I' : C} (hI : IsInitial I) (hI' : IsInitial I') : I ≅ I' 
goal: (hI.uniqueUpToIso hI').hom = hI.to I'

full_name: CategoryTheory.Limits.IsInitial.uniqueUpToIso
code: /-- If `I` and `I'` are initial, they are isomorphic. -/
@[simps]
def IsInitial.uniqueUpToIso {I I' : C} (hI : IsInitial I) (hI' : IsInitial I') : I ≅ I' 
goal: I ≅ I'

full_name: CategoryTheory.Limits.IsInitial.uniqueUpToIso_inv
code: /-- If `I` and `I'` are initial, they are isomorphic. -/
@[simps]
def IsInitial.uniqueUpToIso {I I' : C} (hI : IsInitial I) (hI' : IsInitial I') : I ≅ I' 
goal: (hI.uniqueUpToIso hI').inv = hI'.to I

full_name: CategoryTheory.Limits.HasTerminal
code: /-- A category has a terminal object if it has a limit over the empty diagram.
Use `hasTerminal_of_unique` to construct instances.
-/
abbrev HasTerminal 
goal: Prop

full_name: CategoryTheory.Limits.HasInitial
code: /-- A category has an initial object if it has a colimit over the empty diagram.
Use `hasInitial_of_unique` to construct instances.
-/
abbrev HasInitial 
goal: Prop

full_name: CategoryTheory.Limits.isLimitChangeEmptyCone
code: /-- Being terminal is independent of the empty diagram, its universe, and the cone over it,
    as long as the cone points are isomorphic. -/
def isLimitChangeEmptyCone {c₁ : Cone F₁} (hl : IsLimit c₁) (c₂ : Cone F₂) (hi : c₁.pt ≅ c₂.pt) :
    IsLimit c₂ 
goal: CategoryTheory.Limits.IsLimit c₂

full_name: CategoryTheory.Limits.isLimitEmptyConeEquiv
code: /-- Replacing an empty cone in `IsLimit` by another with the same cone point
    is an equivalence. -/
def isLimitEmptyConeEquiv (c₁ : Cone F₁) (c₂ : Cone F₂) (h : c₁.pt ≅ c₂.pt) :
    IsLimit c₁ ≃ IsLimit c₂ 
goal: CategoryTheory.Limits.IsLimit c₁ ≃ CategoryTheory.Limits.IsLimit c₂

full_name: CategoryTheory.Limits.hasTerminalChangeDiagram
code: theorem hasTerminalChangeDiagram (h : HasLimit F₁) : HasLimit F₂ 
goal: CategoryTheory.Limits.HasLimit F₂

full_name: CategoryTheory.Limits.hasTerminalChangeUniverse
code: theorem hasTerminalChangeUniverse [h : HasLimitsOfShape (Discrete.{w} PEmpty) C] :
    HasLimitsOfShape (Discrete.{w'} PEmpty) C 
goal: CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete PEmpty.{w' + 1}) C

full_name: CategoryTheory.Limits.isColimitChangeEmptyCocone
code: /-- Being initial is independent of the empty diagram, its universe, and the cocone over it,
    as long as the cocone points are isomorphic. -/
def isColimitChangeEmptyCocone {c₁ : Cocone F₁} (hl : IsColimit c₁) (c₂ : Cocone F₂)
    (hi : c₁.pt ≅ c₂.pt) : IsColimit c₂ 
goal: CategoryTheory.Limits.IsColimit c₂

full_name: CategoryTheory.Limits.isColimitEmptyCoconeEquiv
code: /-- Replacing an empty cocone in `IsColimit` by another with the same cocone point
    is an equivalence. -/
def isColimitEmptyCoconeEquiv (c₁ : Cocone F₁) (c₂ : Cocone F₂) (h : c₁.pt ≅ c₂.pt) :
    IsColimit c₁ ≃ IsColimit c₂ 
goal: CategoryTheory.Limits.IsColimit c₁ ≃ CategoryTheory.Limits.IsColimit c₂

full_name: CategoryTheory.Limits.hasInitialChangeDiagram
code: theorem hasInitialChangeDiagram (h : HasColimit F₁) : HasColimit F₂ 
goal: CategoryTheory.Limits.HasColimit F₂

full_name: CategoryTheory.Limits.hasInitialChangeUniverse
code: theorem hasInitialChangeUniverse [h : HasColimitsOfShape (Discrete.{w} PEmpty) C] :
    HasColimitsOfShape (Discrete.{w'} PEmpty) C 
goal: CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete PEmpty.{w' + 1}) C

full_name: CategoryTheory.Limits.terminal
code: /-- An arbitrary choice of terminal object, if one exists.
You can use the notation `⊤_ C`.
This object is characterized by having a unique morphism from any object.
-/
abbrev terminal [HasTerminal C] : C 
goal: C

full_name: CategoryTheory.Limits.initial
code: /-- An arbitrary choice of initial object, if one exists.
You can use the notation `⊥_ C`.
This object is characterized by having a unique morphism to any object.
-/
abbrev initial [HasInitial C] : C 
goal: C

full_name: CategoryTheory.Limits.«_aux_Mathlib_CategoryTheory_Limits_Shapes_Terminal___macroRules_CategoryTheory_Limits_term⊤___1»
code: /-- Notation for the terminal object in `C` -/
notation "⊤_ " C:20 => terminal C
goal: Lean.Macro

full_name: CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Terminal___unexpand_CategoryTheory_Limits_terminal_1
code: /-- Notation for the terminal object in `C` -/
notation "⊤_ " C:20 => terminal C
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Terminal___unexpand_CategoryTheory_Limits_initial_1
code: /-- Notation for the initial object in `C` -/
notation "⊥_ " C:20 => initial C
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Limits.«_aux_Mathlib_CategoryTheory_Limits_Shapes_Terminal___macroRules_CategoryTheory_Limits_term⊥___1»
code: /-- Notation for the initial object in `C` -/
notation "⊥_ " C:20 => initial C
goal: Lean.Macro

full_name: CategoryTheory.Limits.hasTerminal_of_unique
code: /-- We can more explicitly show that a category has a terminal object by specifying the object,
and showing there is a unique morphism to it from any other object. -/
theorem hasTerminal_of_unique (X : C) [h : ∀ Y : C, Unique (Y ⟶ X)] : HasTerminal C 
goal: CategoryTheory.Limits.HasTerminal C

full_name: CategoryTheory.Limits.IsTerminal.hasTerminal
code: theorem IsTerminal.hasTerminal {X : C} (h : IsTerminal X) : HasTerminal C 
goal: CategoryTheory.Limits.HasTerminal C

full_name: CategoryTheory.Limits.hasInitial_of_unique
code: /-- We can more explicitly show that a category has an initial object by specifying the object,
and showing there is a unique morphism from it to any other object. -/
theorem hasInitial_of_unique (X : C) [h : ∀ Y : C, Unique (X ⟶ Y)] : HasInitial C 
goal: CategoryTheory.Limits.HasInitial C

full_name: CategoryTheory.Limits.IsInitial.hasInitial
code: theorem IsInitial.hasInitial {X : C} (h : IsInitial X) : HasInitial C 
goal: CategoryTheory.Limits.HasInitial C

full_name: CategoryTheory.Limits.terminal.from
code: /-- The map from an object to the terminal object. -/
abbrev terminal.from [HasTerminal C] (P : C) : P ⟶ ⊤_ C 
goal: P ⟶ ⊤_ C

full_name: CategoryTheory.Limits.initial.to
code: /-- The map to an object from the initial object. -/
abbrev initial.to [HasInitial C] (P : C) : ⊥_ C ⟶ P 
goal: ⊥_ C ⟶ P

full_name: CategoryTheory.Limits.terminalIsTerminal
code: /-- A terminal object is terminal. -/
def terminalIsTerminal [HasTerminal C] : IsTerminal (⊤_ C) 
goal: CategoryTheory.Limits.IsTerminal (⊤_ C)

full_name: CategoryTheory.Limits.initialIsInitial
code: /-- An initial object is initial. -/
def initialIsInitial [HasInitial C] : IsInitial (⊥_ C) 
goal: CategoryTheory.Limits.IsInitial (⊥_ C)

full_name: CategoryTheory.Limits.uniqueToTerminal
code: instance uniqueToTerminal [HasTerminal C] (P : C) : Unique (P ⟶ ⊤_ C) 
goal: Unique (P ⟶ ⊤_ C)

full_name: CategoryTheory.Limits.uniqueFromInitial
code: instance uniqueFromInitial [HasInitial C] (P : C) : Unique (⊥_ C ⟶ P) 
goal: Unique (⊥_ C ⟶ P)

full_name: CategoryTheory.Limits.terminal.hom_ext
code: @[ext] theorem terminal.hom_ext [HasTerminal C] {P : C} (f g : P ⟶ ⊤_ C) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.initial.hom_ext
code: @[ext] theorem initial.hom_ext [HasInitial C] {P : C} (f g : ⊥_ C ⟶ P) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.terminal.comp_from
code: @[simp]
theorem terminal.comp_from [HasTerminal C] {P Q : C} (f : P ⟶ Q) :
    f ≫ terminal.from Q = terminal.from P 
goal: f ≫ CategoryTheory.Limits.terminal.from Q = CategoryTheory.Limits.terminal.from P

full_name: CategoryTheory.Limits.initial.to_comp
code: @[simp]
theorem initial.to_comp [HasInitial C] {P Q : C} (f : P ⟶ Q) : initial.to P ≫ f = initial.to Q 
goal: CategoryTheory.Limits.initial.to P ≫ f = CategoryTheory.Limits.initial.to Q

full_name: CategoryTheory.Limits.initialIsoIsInitial
code: /-- The (unique) isomorphism between the chosen initial object and any other initial object. -/
@[simp]
def initialIsoIsInitial [HasInitial C] {P : C} (t : IsInitial P) : ⊥_ C ≅ P 
goal: ⊥_ C ≅ P

full_name: CategoryTheory.Limits.terminalIsoIsTerminal
code: /-- The (unique) isomorphism between the chosen terminal object and any other terminal object. -/
@[simp]
def terminalIsoIsTerminal [HasTerminal C] {P : C} (t : IsTerminal P) : ⊤_ C ≅ P 
goal: ⊤_ C ≅ P

full_name: CategoryTheory.Limits.terminal.isSplitMono_from
code: /-- Any morphism from a terminal object is split mono. -/
instance terminal.isSplitMono_from {Y : C} [HasTerminal C] (f : ⊤_ C ⟶ Y) : IsSplitMono f 
goal: CategoryTheory.IsSplitMono f

full_name: CategoryTheory.Limits.initial.isSplitEpi_to
code: /-- Any morphism to an initial object is split epi. -/
instance initial.isSplitEpi_to {Y : C} [HasInitial C] (f : Y ⟶ ⊥_ C) : IsSplitEpi f 
goal: CategoryTheory.IsSplitEpi f

full_name: CategoryTheory.Limits.terminalOpOfInitial
code: /-- An initial object is terminal in the opposite category. -/
def terminalOpOfInitial {X : C} (t : IsInitial X) : IsTerminal (Opposite.op X) 
goal: CategoryTheory.Limits.IsTerminal (Opposite.op X)

full_name: CategoryTheory.Limits.terminalUnopOfInitial
code: /-- An initial object in the opposite category is terminal in the original category. -/
def terminalUnopOfInitial {X : Cᵒᵖ} (t : IsInitial X) : IsTerminal X.unop 
goal: CategoryTheory.Limits.IsTerminal (Opposite.unop X)

full_name: CategoryTheory.Limits.initialOpOfTerminal
code: /-- A terminal object is initial in the opposite category. -/
def initialOpOfTerminal {X : C} (t : IsTerminal X) : IsInitial (Opposite.op X) 
goal: CategoryTheory.Limits.IsInitial (Opposite.op X)

full_name: CategoryTheory.Limits.initialUnopOfTerminal
code: /-- A terminal object in the opposite category is initial in the original category. -/
def initialUnopOfTerminal {X : Cᵒᵖ} (t : IsTerminal X) : IsInitial X.unop 
goal: CategoryTheory.Limits.IsInitial (Opposite.unop X)

full_name: CategoryTheory.Limits.hasInitial_op_of_hasTerminal
code: instance hasInitial_op_of_hasTerminal [HasTerminal C] : HasInitial Cᵒᵖ 
goal: CategoryTheory.Limits.HasInitial Cᵒᵖ

full_name: CategoryTheory.Limits.hasTerminal_op_of_hasInitial
code: instance hasTerminal_op_of_hasInitial [HasInitial C] : HasTerminal Cᵒᵖ 
goal: CategoryTheory.Limits.HasTerminal Cᵒᵖ

full_name: CategoryTheory.Limits.hasTerminal_of_hasInitial_op
code: theorem hasTerminal_of_hasInitial_op [HasInitial Cᵒᵖ] : HasTerminal C 
goal: CategoryTheory.Limits.HasTerminal C

full_name: CategoryTheory.Limits.hasInitial_of_hasTerminal_op
code: theorem hasInitial_of_hasTerminal_op [HasTerminal Cᵒᵖ] : HasInitial C 
goal: CategoryTheory.Limits.HasInitial C

full_name: CategoryTheory.Limits.instHasLimitObjFunctorConstTerminal
code: instance {J : Type*} [Category J] {C : Type*} [Category C] [HasTerminal C] :
    HasLimit ((CategoryTheory.Functor.const J).obj (⊤_ C)) 
goal: CategoryTheory.Limits.HasLimit ((CategoryTheory.Functor.const J).obj (⊤_ C))

full_name: CategoryTheory.Limits.limitConstTerminal_hom
code: /-- The limit of the constant `⊤_ C` functor is `⊤_ C`. -/
@[simps hom]
def limitConstTerminal {J : Type*} [Category J] {C : Type*} [Category C] [HasTerminal C] :
    limit ((CategoryTheory.Functor.const J).obj (⊤_ C)) ≅ ⊤_ C 
goal: CategoryTheory.Limits.limitConstTerminal.hom =
  CategoryTheory.Limits.terminal.from (CategoryTheory.Limits.limit ((CategoryTheory.Functor.const J).obj (⊤_ C)))

full_name: CategoryTheory.Limits.limitConstTerminal
code: /-- The limit of the constant `⊤_ C` functor is `⊤_ C`. -/
@[simps hom]
def limitConstTerminal {J : Type*} [Category J] {C : Type*} [Category C] [HasTerminal C] :
    limit ((CategoryTheory.Functor.const J).obj (⊤_ C)) ≅ ⊤_ C 
goal: CategoryTheory.Limits.limit ((CategoryTheory.Functor.const J).obj (⊤_ C)) ≅ ⊤_ C

full_name: CategoryTheory.Limits.limitConstTerminal_inv_π
code: @[reassoc (attr := simp)]
theorem limitConstTerminal_inv_π {J : Type*} [Category J] {C : Type*} [Category C] [HasTerminal C]
    {j : J} :
    limitConstTerminal.inv ≫ limit.π ((CategoryTheory.Functor.const J).obj (⊤_ C)) j =
      terminal.from _ 
goal: CategoryTheory.Limits.limitConstTerminal.inv ≫
    CategoryTheory.Limits.limit.π ((CategoryTheory.Functor.const J).obj (⊤_ C)) j =
  CategoryTheory.Limits.terminal.from (⊤_ C)

full_name: CategoryTheory.Limits.instHasColimitObjFunctorConstInitial
code: instance {J : Type*} [Category J] {C : Type*} [Category C] [HasInitial C] :
    HasColimit ((CategoryTheory.Functor.const J).obj (⊥_ C)) 
goal: CategoryTheory.Limits.HasColimit ((CategoryTheory.Functor.const J).obj (⊥_ C))

full_name: CategoryTheory.Limits.colimitConstInitial_inv
code: /-- The colimit of the constant `⊥_ C` functor is `⊥_ C`. -/
@[simps inv]
def colimitConstInitial {J : Type*} [Category J] {C : Type*} [Category C] [HasInitial C] :
    colimit ((CategoryTheory.Functor.const J).obj (⊥_ C)) ≅ ⊥_ C 
goal: CategoryTheory.Limits.colimitConstInitial.inv =
  CategoryTheory.Limits.initial.to (CategoryTheory.Limits.colimit ((CategoryTheory.Functor.const J).obj (⊥_ C)))

full_name: CategoryTheory.Limits.colimitConstInitial
code: /-- The colimit of the constant `⊥_ C` functor is `⊥_ C`. -/
@[simps inv]
def colimitConstInitial {J : Type*} [Category J] {C : Type*} [Category C] [HasInitial C] :
    colimit ((CategoryTheory.Functor.const J).obj (⊥_ C)) ≅ ⊥_ C 
goal: CategoryTheory.Limits.colimit ((CategoryTheory.Functor.const J).obj (⊥_ C)) ≅ ⊥_ C

full_name: CategoryTheory.Limits.ι_colimitConstInitial_hom
code: @[reassoc (attr := simp)]
theorem ι_colimitConstInitial_hom {J : Type*} [Category J] {C : Type*} [Category C] [HasInitial C]
    {j : J} :
    colimit.ι ((CategoryTheory.Functor.const J).obj (⊥_ C)) j ≫ colimitConstInitial.hom =
      initial.to _ 
goal: CategoryTheory.Limits.colimit.ι ((CategoryTheory.Functor.const J).obj (⊥_ C)) j ≫
    CategoryTheory.Limits.colimitConstInitial.hom =
  CategoryTheory.Limits.initial.to (⊥_ C)

full_name: CategoryTheory.Limits.InitialMonoClass
code: /-- A category is an `InitialMonoClass` if the canonical morphism of an initial object is a
monomorphism.  In practice, this is most useful when given an arbitrary morphism out of the chosen
initial object, see `initial.mono_from`.
Given a terminal object, this is equivalent to the assumption that the unique morphism from initial
to terminal is a monomorphism, which is the second of Freyd's axioms for an AT category.

TODO: This is a condition satisfied by categories with zero objects and morphisms.
-/
class InitialMonoClass (C : Type u₁) [Category.{v₁} C] : Prop where
  /-- The map from the (any as stated) initial object to any other object is a
    monomorphism -/
  isInitial_mono_from : ∀ {I} (X : C) (hI : IsInitial I), Mono (hI.to X)
goal: Prop

full_name: CategoryTheory.Limits.InitialMonoClass.isInitial_mono_from
code: /-- A category is an `InitialMonoClass` if the canonical morphism of an initial object is a
monomorphism.  In practice, this is most useful when given an arbitrary morphism out of the chosen
initial object, see `initial.mono_from`.
Given a terminal object, this is equivalent to the assumption that the unique morphism from initial
to terminal is a monomorphism, which is the second of Freyd's axioms for an AT category.

TODO: This is a condition satisfied by categories with zero objects and morphisms.
-/
class InitialMonoClass (C : Type u₁) [Category.{v₁} C] : Prop where
  /-- The map from the (any as stated) initial object to any other object is a
    monomorphism -/
  isInitial_mono_from : ∀ {I} (X : C) (hI : IsInitial I), Mono (hI.to X)
goal: CategoryTheory.Mono (hI.to X)

full_name: CategoryTheory.Limits.IsInitial.mono_from
code: theorem IsInitial.mono_from [InitialMonoClass C] {I} {X : C} (hI : IsInitial I) (f : I ⟶ X) :
    Mono f 
goal: CategoryTheory.Mono f

full_name: CategoryTheory.Limits.initial.mono_from
code: instance (priority := 100) initial.mono_from [HasInitial C] [InitialMonoClass C] (X : C)
    (f : ⊥_ C ⟶ X) : Mono f 
goal: CategoryTheory.Mono f

full_name: CategoryTheory.Limits.InitialMonoClass.of_isInitial
code: /-- To show a category is an `InitialMonoClass` it suffices to give an initial object such that
every morphism out of it is a monomorphism. -/
theorem InitialMonoClass.of_isInitial {I : C} (hI : IsInitial I) (h : ∀ X, Mono (hI.to X)) :
    InitialMonoClass C 
goal: CategoryTheory.Limits.InitialMonoClass C

full_name: CategoryTheory.Limits.InitialMonoClass.of_initial
code: /-- To show a category is an `InitialMonoClass` it suffices to show every morphism out of the
initial object is a monomorphism. -/
theorem InitialMonoClass.of_initial [HasInitial C] (h : ∀ X : C, Mono (initial.to X)) :
    InitialMonoClass C 
goal: CategoryTheory.Limits.InitialMonoClass C

full_name: CategoryTheory.Limits.InitialMonoClass.of_isTerminal
code: /-- To show a category is an `InitialMonoClass` it suffices to show the unique morphism from an
initial object to a terminal object is a monomorphism. -/
theorem InitialMonoClass.of_isTerminal {I T : C} (hI : IsInitial I) (hT : IsTerminal T)
    (_ : Mono (hI.to T)) : InitialMonoClass C 
goal: CategoryTheory.Mono (hI.to T) → CategoryTheory.Limits.InitialMonoClass C

full_name: CategoryTheory.Limits.InitialMonoClass.of_terminal
code: /-- To show a category is an `InitialMonoClass` it suffices to show the unique morphism from the
initial object to a terminal object is a monomorphism. -/
theorem InitialMonoClass.of_terminal [HasInitial C] [HasTerminal C] (h : Mono (initial.to (⊤_ C))) :
    InitialMonoClass C 
goal: CategoryTheory.Limits.InitialMonoClass C

full_name: CategoryTheory.Limits.terminalComparison
code: /-- The comparison morphism from the image of a terminal object to the terminal object in the target
category.
This is an isomorphism iff `G` preserves terminal objects, see
`CategoryTheory.Limits.PreservesTerminal.ofIsoComparison`.
-/
def terminalComparison [HasTerminal C] [HasTerminal D] : G.obj (⊤_ C) ⟶ ⊤_ D 
goal: G.obj (⊤_ C) ⟶ ⊤_ D

full_name: CategoryTheory.Limits.initialComparison
code: /--
The comparison morphism from the initial object in the target category to the image of the initial
object.
-/
def initialComparison [HasInitial C] [HasInitial D] : ⊥_ D ⟶ G.obj (⊥_ C) 
goal: ⊥_ D ⟶ G.obj (⊥_ C)

full_name: CategoryTheory.Limits.coneOfDiagramInitial
code: /-- From a functor `F : J ⥤ C`, given an initial object of `J`, construct a cone for `J`.
In `limitOfDiagramInitial` we show it is a limit cone. -/
@[simps]
def coneOfDiagramInitial {X : J} (tX : IsInitial X) (F : J ⥤ C) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.coneOfDiagramInitial_pt
code: /-- From a functor `F : J ⥤ C`, given an initial object of `J`, construct a cone for `J`.
In `limitOfDiagramInitial` we show it is a limit cone. -/
@[simps]
def coneOfDiagramInitial {X : J} (tX : IsInitial X) (F : J ⥤ C) : Cone F 
goal: (CategoryTheory.Limits.coneOfDiagramInitial tX F).pt = F.obj X

full_name: CategoryTheory.Limits.coneOfDiagramInitial_π_app
code: /-- From a functor `F : J ⥤ C`, given an initial object of `J`, construct a cone for `J`.
In `limitOfDiagramInitial` we show it is a limit cone. -/
@[simps]
def coneOfDiagramInitial {X : J} (tX : IsInitial X) (F : J ⥤ C) : Cone F 
goal: (CategoryTheory.Limits.coneOfDiagramInitial tX F).π.app j = F.map (tX.to j)

full_name: CategoryTheory.Limits.limitOfDiagramInitial
code: /-- From a functor `F : J ⥤ C`, given an initial object of `J`, show the cone
`coneOfDiagramInitial` is a limit. -/
def limitOfDiagramInitial {X : J} (tX : IsInitial X) (F : J ⥤ C) :
    IsLimit (coneOfDiagramInitial tX F) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfDiagramInitial tX F)

full_name: CategoryTheory.Limits.hasLimit_of_domain_hasInitial
code: instance hasLimit_of_domain_hasInitial [HasInitial J] {F : J ⥤ C} : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.limitOfInitial
code: /-- For a functor `F : J ⥤ C`, if `J` has an initial object then the image of it is isomorphic
to the limit of `F`. -/
abbrev limitOfInitial (F : J ⥤ C) [HasInitial J] : limit F ≅ F.obj (⊥_ J) 
goal: CategoryTheory.Limits.limit F ≅ F.obj (⊥_ J)

full_name: CategoryTheory.Limits.coneOfDiagramTerminal_π_app
code: /-- From a functor `F : J ⥤ C`, given a terminal object of `J`, construct a cone for `J`,
provided that the morphisms in the diagram are isomorphisms.
In `limitOfDiagramTerminal` we show it is a limit cone. -/
@[simps]
def coneOfDiagramTerminal {X : J} (hX : IsTerminal X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cone F 
goal: (CategoryTheory.Limits.coneOfDiagramTerminal hX F).π.app i = CategoryTheory.inv (F.map (hX.from i))

full_name: CategoryTheory.Limits.coneOfDiagramTerminal_pt
code: /-- From a functor `F : J ⥤ C`, given a terminal object of `J`, construct a cone for `J`,
provided that the morphisms in the diagram are isomorphisms.
In `limitOfDiagramTerminal` we show it is a limit cone. -/
@[simps]
def coneOfDiagramTerminal {X : J} (hX : IsTerminal X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cone F 
goal: (CategoryTheory.Limits.coneOfDiagramTerminal hX F).pt = F.obj X

full_name: CategoryTheory.Limits.coneOfDiagramTerminal
code: /-- From a functor `F : J ⥤ C`, given a terminal object of `J`, construct a cone for `J`,
provided that the morphisms in the diagram are isomorphisms.
In `limitOfDiagramTerminal` we show it is a limit cone. -/
@[simps]
def coneOfDiagramTerminal {X : J} (hX : IsTerminal X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.limitOfDiagramTerminal
code: /-- From a functor `F : J ⥤ C`, given a terminal object of `J` and that the morphisms in the
diagram are isomorphisms, show the cone `coneOfDiagramTerminal` is a limit. -/
def limitOfDiagramTerminal {X : J} (hX : IsTerminal X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : IsLimit (coneOfDiagramTerminal hX F) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfDiagramTerminal hX F)

full_name: CategoryTheory.Limits.hasLimit_of_domain_hasTerminal
code: instance hasLimit_of_domain_hasTerminal [HasTerminal J] {F : J ⥤ C}
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.limitOfTerminal
code: /-- For a functor `F : J ⥤ C`, if `J` has a terminal object and all the morphisms in the diagram
are isomorphisms, then the image of the terminal object is isomorphic to the limit of `F`. -/
abbrev limitOfTerminal (F : J ⥤ C) [HasTerminal J] [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] :
    limit F ≅ F.obj (⊤_ J) 
goal: CategoryTheory.Limits.limit F ≅ F.obj (⊤_ J)

full_name: CategoryTheory.Limits.coconeOfDiagramTerminal
code: /-- From a functor `F : J ⥤ C`, given a terminal object of `J`, construct a cocone for `J`.
In `colimitOfDiagramTerminal` we show it is a colimit cocone. -/
@[simps]
def coconeOfDiagramTerminal {X : J} (tX : IsTerminal X) (F : J ⥤ C) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.coconeOfDiagramTerminal_ι_app
code: /-- From a functor `F : J ⥤ C`, given a terminal object of `J`, construct a cocone for `J`.
In `colimitOfDiagramTerminal` we show it is a colimit cocone. -/
@[simps]
def coconeOfDiagramTerminal {X : J} (tX : IsTerminal X) (F : J ⥤ C) : Cocone F 
goal: (CategoryTheory.Limits.coconeOfDiagramTerminal tX F).ι.app j = F.map (tX.from j)

full_name: CategoryTheory.Limits.coconeOfDiagramTerminal_pt
code: /-- From a functor `F : J ⥤ C`, given a terminal object of `J`, construct a cocone for `J`.
In `colimitOfDiagramTerminal` we show it is a colimit cocone. -/
@[simps]
def coconeOfDiagramTerminal {X : J} (tX : IsTerminal X) (F : J ⥤ C) : Cocone F 
goal: (CategoryTheory.Limits.coconeOfDiagramTerminal tX F).pt = F.obj X

full_name: CategoryTheory.Limits.colimitOfDiagramTerminal
code: /-- From a functor `F : J ⥤ C`, given a terminal object of `J`, show the cocone
`coconeOfDiagramTerminal` is a colimit. -/
def colimitOfDiagramTerminal {X : J} (tX : IsTerminal X) (F : J ⥤ C) :
    IsColimit (coconeOfDiagramTerminal tX F) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.coconeOfDiagramTerminal tX F)

full_name: CategoryTheory.Limits.hasColimit_of_domain_hasTerminal
code: instance hasColimit_of_domain_hasTerminal [HasTerminal J] {F : J ⥤ C} : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.IsColimit.isIso_ι_app_of_isTerminal
code: lemma IsColimit.isIso_ι_app_of_isTerminal {F : J ⥤ C} {c : Cocone F} (hc : IsColimit c)
    (X : J) (hX : IsTerminal X) :
    IsIso (c.ι.app X) 
goal: CategoryTheory.IsIso (c.ι.app X)

full_name: CategoryTheory.Limits.colimitOfTerminal
code: /-- For a functor `F : J ⥤ C`, if `J` has a terminal object then the image of it is isomorphic
to the colimit of `F`. -/
abbrev colimitOfTerminal (F : J ⥤ C) [HasTerminal J] : colimit F ≅ F.obj (⊤_ J) 
goal: CategoryTheory.Limits.colimit F ≅ F.obj (⊤_ J)

full_name: CategoryTheory.Limits.coconeOfDiagramInitial
code: /-- From a functor `F : J ⥤ C`, given an initial object of `J`, construct a cocone for `J`,
provided that the morphisms in the diagram are isomorphisms.
In `colimitOfDiagramInitial` we show it is a colimit cocone. -/
@[simps]
def coconeOfDiagramInitial {X : J} (hX : IsInitial X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.coconeOfDiagramInitial_ι_app
code: /-- From a functor `F : J ⥤ C`, given an initial object of `J`, construct a cocone for `J`,
provided that the morphisms in the diagram are isomorphisms.
In `colimitOfDiagramInitial` we show it is a colimit cocone. -/
@[simps]
def coconeOfDiagramInitial {X : J} (hX : IsInitial X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cocone F 
goal: (CategoryTheory.Limits.coconeOfDiagramInitial hX F).ι.app i = CategoryTheory.inv (F.map (hX.to i))

full_name: CategoryTheory.Limits.coconeOfDiagramInitial_pt
code: /-- From a functor `F : J ⥤ C`, given an initial object of `J`, construct a cocone for `J`,
provided that the morphisms in the diagram are isomorphisms.
In `colimitOfDiagramInitial` we show it is a colimit cocone. -/
@[simps]
def coconeOfDiagramInitial {X : J} (hX : IsInitial X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : Cocone F 
goal: (CategoryTheory.Limits.coconeOfDiagramInitial hX F).pt = F.obj X

full_name: CategoryTheory.Limits.colimitOfDiagramInitial
code: /-- From a functor `F : J ⥤ C`, given an initial object of `J` and that the morphisms in the
diagram are isomorphisms, show the cone `coconeOfDiagramInitial` is a colimit. -/
def colimitOfDiagramInitial {X : J} (hX : IsInitial X) (F : J ⥤ C)
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : IsColimit (coconeOfDiagramInitial hX F) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.coconeOfDiagramInitial hX F)

full_name: CategoryTheory.Limits.hasColimit_of_domain_hasInitial
code: instance hasColimit_of_domain_hasInitial [HasInitial J] {F : J ⥤ C}
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.IsLimit.isIso_π_app_of_isInitial
code: lemma IsLimit.isIso_π_app_of_isInitial {F : J ⥤ C} {c : Cone F} (hc : IsLimit c)
    (X : J) (hX : IsInitial X) :
    IsIso (c.π.app X) 
goal: CategoryTheory.IsIso (c.π.app X)

full_name: CategoryTheory.Limits.colimitOfInitial
code: /-- For a functor `F : J ⥤ C`, if `J` has an initial object and all the morphisms in the diagram
are isomorphisms, then the image of the initial object is isomorphic to the colimit of `F`. -/
abbrev colimitOfInitial (F : J ⥤ C) [HasInitial J] [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] :
    colimit F ≅ F.obj (⊥_ J) 
goal: CategoryTheory.Limits.colimit F ≅ F.obj (⊥_ J)

full_name: CategoryTheory.Limits.isIso_π_of_isInitial
code: /-- If `j` is initial in the index category, then the map `limit.π F j` is an isomorphism.
-/
theorem isIso_π_of_isInitial {j : J} (I : IsInitial j) (F : J ⥤ C) [HasLimit F] :
    IsIso (limit.π F j) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.limit.π F j)

full_name: CategoryTheory.Limits.isIso_π_initial
code: instance isIso_π_initial [HasInitial J] (F : J ⥤ C) : IsIso (limit.π F (⊥_ J)) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.limit.π F (⊥_ J))

full_name: CategoryTheory.Limits.isIso_π_of_isTerminal
code: theorem isIso_π_of_isTerminal {j : J} (I : IsTerminal j) (F : J ⥤ C) [HasLimit F]
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : IsIso (limit.π F j) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.limit.π F j)

full_name: CategoryTheory.Limits.isIso_π_terminal
code: instance isIso_π_terminal [HasTerminal J] (F : J ⥤ C) [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] :
    IsIso (limit.π F (⊤_ J)) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.limit.π F (⊤_ J))

full_name: CategoryTheory.Limits.isIso_ι_of_isTerminal
code: /-- If `j` is terminal in the index category, then the map `colimit.ι F j` is an isomorphism.
-/
theorem isIso_ι_of_isTerminal {j : J} (I : IsTerminal j) (F : J ⥤ C) [HasColimit F] :
    IsIso (colimit.ι F j) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.colimit.ι F j)

full_name: CategoryTheory.Limits.isIso_ι_terminal
code: instance isIso_ι_terminal [HasTerminal J] (F : J ⥤ C) : IsIso (colimit.ι F (⊤_ J)) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.colimit.ι F (⊤_ J))

full_name: CategoryTheory.Limits.isIso_ι_of_isInitial
code: theorem isIso_ι_of_isInitial {j : J} (I : IsInitial j) (F : J ⥤ C) [HasColimit F]
    [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] : IsIso (colimit.ι F j) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.colimit.ι F j)

full_name: CategoryTheory.Limits.isIso_ι_initial
code: instance isIso_ι_initial [HasInitial J] (F : J ⥤ C) [∀ (i j : J) (f : i ⟶ j), IsIso (F.map f)] :
    IsIso (colimit.ι F (⊥_ J)) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.colimit.ι F (⊥_ J))

full_name: CategoryTheory.Limits.isIso_of_isTerminal
code: /-- Any morphism between terminal objects is an isomorphism. -/
lemma isIso_of_isTerminal {X Y : C} (hX : IsTerminal X) (hY : IsTerminal Y) (f : X ⟶ Y) :
    IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.Limits.isIso_of_isInitial
code: /-- Any morphism between initial objects is an isomorphism. -/
lemma isIso_of_isInitial {X Y : C} (hX : IsInitial X) (hY : IsInitial Y) (f : X ⟶ Y) :
    IsIso f 
goal: CategoryTheory.IsIso f