File: Mathlib/Topology/Category/TopCat/Limits/Basic.lean

full_name: TopCat._aux_Mathlib_Topology_Category_TopCat_Limits_Basic___unexpand_CategoryTheory_forget_1
code: local notation "forget" => forget TopCat
goal: Lean.PrettyPrinter.Unexpander

full_name: TopCat._aux_Mathlib_Topology_Category_TopCat_Limits_Basic___macroRules_TopCat_termForget_1
code: local notation "forget" => forget TopCat
goal: Lean.Macro

full_name: TopCat.limitCone
code: /-- A choice of limit cone for a functor `F : J ⥤ TopCat`.
Generally you should just use `limit.cone F`, unless you need the actual definition
(which is in terms of `Types.limitCone`).
-/
def limitCone (F : J ⥤ TopCat.{max v u}) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: TopCat.limitConeInfi
code: /-- A choice of limit cone for a functor `F : J ⥤ TopCat` whose topology is defined as an
infimum of topologies infimum.
Generally you should just use `limit.cone F`, unless you need the actual definition
(which is in terms of `Types.limitCone`).
-/
def limitConeInfi (F : J ⥤ TopCat.{max v u}) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: TopCat.limitConeIsLimit
code: /-- The chosen cone `TopCat.limitCone F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeIsLimit (F : J ⥤ TopCat.{max v u}) : IsLimit (limitCone.{v,u} F) 
goal: CategoryTheory.Limits.IsLimit (TopCat.limitCone F)

full_name: TopCat.limitConeInfiIsLimit
code: /-- The chosen cone `TopCat.limitConeInfi F` for a functor `F : J ⥤ TopCat` is a limit cone.
Generally you should just use `limit.isLimit F`, unless you need the actual definition
(which is in terms of `Types.limitConeIsLimit`).
-/
def limitConeInfiIsLimit (F : J ⥤ TopCat.{max v u}) : IsLimit (limitConeInfi.{v,u} F) 
goal: CategoryTheory.Limits.IsLimit (TopCat.limitConeInfi F)

full_name: TopCat.topCat_hasLimitsOfSize
code: instance topCat_hasLimitsOfSize : HasLimitsOfSize.{v, v} TopCat.{max v u} 
goal: CategoryTheory.Limits.HasLimitsOfSize.{v, v, max u v, max (u + 1) (v + 1)} TopCat

full_name: TopCat.topCat_hasLimits
code: instance topCat_hasLimits : HasLimits TopCat.{u} 
goal: CategoryTheory.Limits.HasLimits TopCat

full_name: TopCat.forgetPreservesLimitsOfSize
code: instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize forget 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, max u v, max u v, (max u v) + 1, (max u v) + 1}
  (CategoryTheory.forget TopCat)

full_name: TopCat.forgetPreservesLimits
code: instance forgetPreservesLimits : PreservesLimits forget 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget TopCat)

full_name: TopCat.colimitCocone
code: /-- A choice of colimit cocone for a functor `F : J ⥤ TopCat`.
Generally you should just use `colimit.cocone F`, unless you need the actual definition
(which is in terms of `Types.colimitCocone`).
-/
def colimitCocone (F : J ⥤ TopCat.{max v u}) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: TopCat.colimitCoconeIsColimit
code: /-- The chosen cocone `TopCat.colimitCocone F` for a functor `F : J ⥤ TopCat` is a colimit cocone.
Generally you should just use `colimit.isColimit F`, unless you need the actual definition
(which is in terms of `Types.colimitCoconeIsColimit`).
-/
def colimitCoconeIsColimit (F : J ⥤ TopCat.{max v u}) : IsColimit (colimitCocone F) 
goal: CategoryTheory.Limits.IsColimit (TopCat.colimitCocone F)

full_name: TopCat.topCat_hasColimitsOfSize
code: instance topCat_hasColimitsOfSize : HasColimitsOfSize.{v,v} TopCat.{max v u} 
goal: CategoryTheory.Limits.HasColimitsOfSize.{v, v, max u v, max (u + 1) (v + 1)} TopCat

full_name: TopCat.topCat_hasColimits
code: instance topCat_hasColimits : HasColimits TopCat.{u} 
goal: CategoryTheory.Limits.HasColimits TopCat

full_name: TopCat.forgetPreservesColimitsOfSize
code: instance forgetPreservesColimitsOfSize :
    PreservesColimitsOfSize.{v, v} forget 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{v, v, max v u_1, max v u_1, (max v u_1) + 1, (max v u_1) + 1}
  (CategoryTheory.forget TopCat)

full_name: TopCat.forgetPreservesColimits
code: instance forgetPreservesColimits : PreservesColimits (forget : TopCat.{u} ⥤ Type u) 
goal: CategoryTheory.Limits.PreservesColimits (CategoryTheory.forget TopCat)

full_name: TopCat.isTerminalPUnit
code: /-- The terminal object of `Top` is `PUnit`. -/
def isTerminalPUnit : IsTerminal (TopCat.of PUnit.{u + 1}) 
goal: CategoryTheory.Limits.IsTerminal (TopCat.of PUnit.{u + 1})

full_name: TopCat.terminalIsoPUnit
code: /-- The terminal object of `Top` is `PUnit`. -/
def terminalIsoPUnit : ⊤_ TopCat.{u} ≅ TopCat.of PUnit 
goal: ⊤_ TopCat ≅ TopCat.of PUnit.{u + 1}

full_name: TopCat.isInitialPEmpty
code: /-- The initial object of `Top` is `PEmpty`. -/
def isInitialPEmpty : IsInitial (TopCat.of PEmpty.{u + 1}) 
goal: CategoryTheory.Limits.IsInitial (TopCat.of PEmpty.{u + 1})

full_name: TopCat.initialIsoPEmpty
code: /-- The initial object of `Top` is `PEmpty`. -/
def initialIsoPEmpty : ⊥_ TopCat.{u} ≅ TopCat.of PEmpty 
goal: ⊥_ TopCat ≅ TopCat.of PEmpty.{u + 1}