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

full_name: CategoryTheory.Limits.isLimitMapConeEmptyConeEquiv
code: /-- The map of an empty cone is a limit iff the mapped object is terminal.
-/
def isLimitMapConeEmptyConeEquiv :
    IsLimit (G.mapCone (asEmptyCone X)) ≃ IsTerminal (G.obj X) 
goal: CategoryTheory.Limits.IsLimit (G.mapCone (CategoryTheory.Limits.asEmptyCone X)) ≃
  CategoryTheory.Limits.IsTerminal (G.obj X)

full_name: CategoryTheory.Limits.IsTerminal.isTerminalObj
code: /-- The property of preserving terminal objects expressed in terms of `IsTerminal`. -/
def IsTerminal.isTerminalObj [PreservesLimit (Functor.empty.{0} C) G] (l : IsTerminal X) :
    IsTerminal (G.obj X) 
goal: CategoryTheory.Limits.IsTerminal (G.obj X)

full_name: CategoryTheory.Limits.IsTerminal.isTerminalOfObj
code: /-- The property of reflecting terminal objects expressed in terms of `IsTerminal`. -/
def IsTerminal.isTerminalOfObj [ReflectsLimit (Functor.empty.{0} C) G] (l : IsTerminal (G.obj X)) :
    IsTerminal X 
goal: CategoryTheory.Limits.IsTerminal X

full_name: CategoryTheory.Limits.IsTerminal.isTerminalIffObj
code: /-- A functor that preserves and reflects terminal objects induces an equivalence on
`IsTerminal`. -/
def IsTerminal.isTerminalIffObj [PreservesLimit (Functor.empty.{0} C) G]
    [ReflectsLimit (Functor.empty.{0} C) G] (X : C) :
    IsTerminal X ≃ IsTerminal (G.obj X) 
goal: CategoryTheory.Limits.IsTerminal X ≃ CategoryTheory.Limits.IsTerminal (G.obj X)

full_name: CategoryTheory.Limits.preservesLimitsOfShapePemptyOfPreservesTerminal
code: /-- Preserving the terminal object implies preserving all limits of the empty diagram. -/
def preservesLimitsOfShapePemptyOfPreservesTerminal [PreservesLimit (Functor.empty.{0} C) G] :
    PreservesLimitsOfShape (Discrete PEmpty) G 
goal: CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete PEmpty.{1}) G

full_name: CategoryTheory.Limits.isLimitOfHasTerminalOfPreservesLimit
code: /--
If `G` preserves the terminal object and `C` has a terminal object, then the image of the terminal
object is terminal.
-/
def isLimitOfHasTerminalOfPreservesLimit [PreservesLimit (Functor.empty.{0} C) G] :
    IsTerminal (G.obj (⊤_ C)) 
goal: CategoryTheory.Limits.IsTerminal (G.obj (⊤_ C))

full_name: CategoryTheory.Limits.hasTerminal_of_hasTerminal_of_preservesLimit
code: /-- If `C` has a terminal object and `G` preserves terminal objects, then `D` has a terminal object
also.
Note this property is somewhat unique to (co)limits of the empty diagram: for general `J`, if `C`
has limits of shape `J` and `G` preserves them, then `D` does not necessarily have limits of shape
`J`.
-/
theorem hasTerminal_of_hasTerminal_of_preservesLimit [PreservesLimit (Functor.empty.{0} C) G] :
    HasTerminal D 
goal: CategoryTheory.Limits.HasTerminal D

full_name: CategoryTheory.Limits.PreservesTerminal.ofIsoComparison
code: /-- If the terminal comparison map for `G` is an isomorphism, then `G` preserves terminal objects.
-/
def PreservesTerminal.ofIsoComparison [i : IsIso (terminalComparison G)] :
    PreservesLimit (Functor.empty C) G 
goal: CategoryTheory.Limits.PreservesLimit (CategoryTheory.Functor.empty C) G

full_name: CategoryTheory.Limits.preservesTerminalOfIsIso
code: /-- If there is any isomorphism `G.obj ⊤ ⟶ ⊤`, then `G` preserves terminal objects. -/
def preservesTerminalOfIsIso (f : G.obj (⊤_ C) ⟶ ⊤_ D) [i : IsIso f] :
    PreservesLimit (Functor.empty C) G 
goal: CategoryTheory.Limits.PreservesLimit (CategoryTheory.Functor.empty C) G

full_name: CategoryTheory.Limits.preservesTerminalOfIso
code: /-- If there is any isomorphism `G.obj ⊤ ≅ ⊤`, then `G` preserves terminal objects. -/
def preservesTerminalOfIso (f : G.obj (⊤_ C) ≅ ⊤_ D) : PreservesLimit (Functor.empty C) G 
goal: CategoryTheory.Limits.PreservesLimit (CategoryTheory.Functor.empty C) G

full_name: CategoryTheory.Limits.PreservesTerminal.iso
code: /-- If `G` preserves terminal objects, then the terminal comparison map for `G` is an isomorphism.
-/
def PreservesTerminal.iso : G.obj (⊤_ C) ≅ ⊤_ D 
goal: G.obj (⊤_ C) ≅ ⊤_ D

full_name: CategoryTheory.Limits.PreservesTerminal.iso_hom
code: @[simp]
theorem PreservesTerminal.iso_hom : (PreservesTerminal.iso G).hom = terminalComparison G 
goal: (CategoryTheory.Limits.PreservesTerminal.iso G).hom = CategoryTheory.Limits.terminalComparison G

full_name: CategoryTheory.Limits.instIsIsoTerminalComparison
code: instance : IsIso (terminalComparison G) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.terminalComparison G)

full_name: CategoryTheory.Limits.isColimitMapCoconeEmptyCoconeEquiv
code: /-- The map of an empty cocone is a colimit iff the mapped object is initial.
-/
def isColimitMapCoconeEmptyCoconeEquiv :
    IsColimit (G.mapCocone (asEmptyCocone.{v₁} X)) ≃ IsInitial (G.obj X) 
goal: CategoryTheory.Limits.IsColimit (G.mapCocone (CategoryTheory.Limits.asEmptyCocone X)) ≃
  CategoryTheory.Limits.IsInitial (G.obj X)

full_name: CategoryTheory.Limits.IsInitial.isInitialObj
code: /-- The property of preserving initial objects expressed in terms of `IsInitial`. -/
def IsInitial.isInitialObj [PreservesColimit (Functor.empty.{0} C) G] (l : IsInitial X) :
    IsInitial (G.obj X) 
goal: CategoryTheory.Limits.IsInitial (G.obj X)

full_name: CategoryTheory.Limits.IsInitial.isInitialOfObj
code: /-- The property of reflecting initial objects expressed in terms of `IsInitial`. -/
def IsInitial.isInitialOfObj [ReflectsColimit (Functor.empty.{0} C) G] (l : IsInitial (G.obj X)) :
    IsInitial X 
goal: CategoryTheory.Limits.IsInitial X

full_name: CategoryTheory.Limits.IsInitial.isInitialIffObj
code: /-- A functor that preserves and reflects initial objects induces an equivalence on `IsInitial`. -/
def IsInitial.isInitialIffObj [PreservesColimit (Functor.empty.{0} C) G]
    [ReflectsColimit (Functor.empty.{0} C) G] (X : C) :
    IsInitial X ≃ IsInitial (G.obj X) 
goal: CategoryTheory.Limits.IsInitial X ≃ CategoryTheory.Limits.IsInitial (G.obj X)

full_name: CategoryTheory.Limits.preservesColimitsOfShapePemptyOfPreservesInitial
code: /-- Preserving the initial object implies preserving all colimits of the empty diagram. -/
def preservesColimitsOfShapePemptyOfPreservesInitial [PreservesColimit (Functor.empty.{0} C) G] :
    PreservesColimitsOfShape (Discrete PEmpty) G 
goal: CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete PEmpty.{1}) G

full_name: CategoryTheory.Limits.isColimitOfHasInitialOfPreservesColimit
code: /-- If `G` preserves the initial object and `C` has an initial object, then the image of the initial
object is initial.
-/
def isColimitOfHasInitialOfPreservesColimit [PreservesColimit (Functor.empty.{0} C) G] :
    IsInitial (G.obj (⊥_ C)) 
goal: CategoryTheory.Limits.IsInitial (G.obj (⊥_ C))

full_name: CategoryTheory.Limits.hasInitial_of_hasInitial_of_preservesColimit
code: /-- If `C` has an initial object and `G` preserves initial objects, then `D` has an initial object
also.
Note this property is somewhat unique to colimits of the empty diagram: for general `J`, if `C`
has colimits of shape `J` and `G` preserves them, then `D` does not necessarily have colimits of
shape `J`.
-/
theorem hasInitial_of_hasInitial_of_preservesColimit [PreservesColimit (Functor.empty.{0} C) G] :
    HasInitial D 
goal: CategoryTheory.Limits.HasInitial D

full_name: CategoryTheory.Limits.PreservesInitial.ofIsoComparison
code: /-- If the initial comparison map for `G` is an isomorphism, then `G` preserves initial objects.
-/
def PreservesInitial.ofIsoComparison [i : IsIso (initialComparison G)] :
    PreservesColimit (Functor.empty C) G 
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C) G

full_name: CategoryTheory.Limits.preservesInitialOfIsIso
code: /-- If there is any isomorphism `⊥ ⟶ G.obj ⊥`, then `G` preserves initial objects. -/
def preservesInitialOfIsIso (f : ⊥_ D ⟶ G.obj (⊥_ C)) [i : IsIso f] :
    PreservesColimit (Functor.empty C) G 
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C) G

full_name: CategoryTheory.Limits.preservesInitialOfIso
code: /-- If there is any isomorphism `⊥ ≅ G.obj ⊥`, then `G` preserves initial objects. -/
def preservesInitialOfIso (f : ⊥_ D ≅ G.obj (⊥_ C)) : PreservesColimit (Functor.empty C) G 
goal: CategoryTheory.Limits.PreservesColimit (CategoryTheory.Functor.empty C) G

full_name: CategoryTheory.Limits.PreservesInitial.iso
code: /-- If `G` preserves initial objects, then the initial comparison map for `G` is an isomorphism. -/
def PreservesInitial.iso : G.obj (⊥_ C) ≅ ⊥_ D 
goal: G.obj (⊥_ C) ≅ ⊥_ D

full_name: CategoryTheory.Limits.PreservesInitial.iso_hom
code: @[simp]
theorem PreservesInitial.iso_hom : (PreservesInitial.iso G).inv = initialComparison G 
goal: (CategoryTheory.Limits.PreservesInitial.iso G).inv = CategoryTheory.Limits.initialComparison G

full_name: CategoryTheory.Limits.instIsIsoInitialComparison
code: instance : IsIso (initialComparison G) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.initialComparison G)