File: Mathlib/Order/Category/OmegaCompletePartialOrder.lean

full_name: ωCPO
code: /-- The category of types with an omega complete partial order. -/
def ωCPO : Type (u + 1) 
goal: Type (u + 1)

full_name: ωCPO.instBundledHomOmegaCompletePartialOrderContinuousHom
code: instance : BundledHom @ContinuousHom 
goal: CategoryTheory.BundledHom OmegaCompletePartialOrder.ContinuousHom

full_name: ωCPO.instConcreteCategory
code: instance : ConcreteCategory ωCPO 
goal: CategoryTheory.ConcreteCategory ωCPO

full_name: ωCPO.instCoeSortType
code: instance : CoeSort ωCPO Type* 
goal: CoeSort ωCPO (Type u_1)

full_name: ωCPO.of
code: /-- Construct a bundled ωCPO from the underlying type and typeclass. -/
def of (α : Type*) [OmegaCompletePartialOrder α] : ωCPO 
goal: ωCPO

full_name: ωCPO.coe_of
code: @[simp]
theorem coe_of (α : Type*) [OmegaCompletePartialOrder α] : ↥(of α) = α 
goal: ↑(ωCPO.of α) = α

full_name: ωCPO.instInhabited
code: instance : Inhabited ωCPO 
goal: Inhabited ωCPO

full_name: ωCPO.instOmegaCompletePartialOrderα
code: instance (α : ωCPO) : OmegaCompletePartialOrder α 
goal: OmegaCompletePartialOrder ↑α

full_name: ωCPO.HasProducts.product
code: /-- The pi-type gives a cone for a product. -/
def product {J : Type v} (f : J → ωCPO.{v}) : Fan f 
goal: CategoryTheory.Limits.Fan f

full_name: ωCPO.HasProducts.isProduct
code: /-- The pi-type is a limit cone for the product. -/
def isProduct (J : Type v) (f : J → ωCPO) : IsLimit (product f) 
goal: CategoryTheory.Limits.IsLimit (ωCPO.HasProducts.product f)

full_name: ωCPO.HasProducts.instHasProduct
code: instance (J : Type v) (f : J → ωCPO.{v}) : HasProduct f 
goal: CategoryTheory.Limits.HasProduct f

full_name: ωCPO.omegaCompletePartialOrderEqualizer
code: instance omegaCompletePartialOrderEqualizer {α β : Type*} [OmegaCompletePartialOrder α]
    [OmegaCompletePartialOrder β] (f g : α →𝒄 β) :
    OmegaCompletePartialOrder { a : α // f a = g a } 
goal: OmegaCompletePartialOrder { a // f a = g a }

full_name: ωCPO.HasEqualizers.equalizerι
code: /-- The equalizer inclusion function as a `ContinuousHom`. -/
def equalizerι {α β : Type*} [OmegaCompletePartialOrder α] [OmegaCompletePartialOrder β]
    (f g : α →𝒄 β) : { a : α // f a = g a } →𝒄 α 
goal: { a // f a = g a } →𝒄 α

full_name: ωCPO.HasEqualizers.equalizer
code: /-- A construction of the equalizer fork. -/
-- Porting note: Changed `{ a // f a = g a }` to `{ a // f.toFun a = g.toFun a }`
def equalizer {X Y : ωCPO.{v}} (f g : X ⟶ Y) : Fork f g 
goal: CategoryTheory.Limits.Fork f g

full_name: ωCPO.HasEqualizers.isEqualizer
code: /-- The equalizer fork is a limit. -/
def isEqualizer {X Y : ωCPO.{v}} (f g : X ⟶ Y) : IsLimit (equalizer f g) 
goal: CategoryTheory.Limits.IsLimit (ωCPO.HasEqualizers.equalizer f g)

full_name: ωCPO.instHasProducts
code: instance : HasProducts.{v} ωCPO.{v} 
goal: CategoryTheory.Limits.HasProducts ωCPO

full_name: ωCPO.instHasLimitWalkingParallelPairParallelPair
code: instance {X Y : ωCPO.{v}} (f g : X ⟶ Y) : HasLimit (parallelPair f g) 
goal: CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.parallelPair f g)

full_name: ωCPO.instHasEqualizers
code: instance : HasEqualizers ωCPO.{v} 
goal: CategoryTheory.Limits.HasEqualizers ωCPO

full_name: ωCPO.instHasLimits
code: instance : HasLimits ωCPO.{v} 
goal: CategoryTheory.Limits.HasLimits ωCPO