File: Mathlib/Order/OmegaCompletePartialOrder.lean

full_name: OmegaCompletePartialOrder.Chain
code: /-- A chain is a monotone sequence.

See the definition on page 114 of [gunter1992]. -/
def Chain (α : Type u) [Preorder α] 
goal: Type u

full_name: OmegaCompletePartialOrder.Chain.instFunLikeNat
code: instance : FunLike (Chain α) ℕ α 
goal: FunLike (OmegaCompletePartialOrder.Chain α) ℕ α

full_name: OmegaCompletePartialOrder.Chain.instOrderHomClassNat
code: instance : OrderHomClass (Chain α) ℕ α 
goal: OrderHomClass (OmegaCompletePartialOrder.Chain α) ℕ α

full_name: OmegaCompletePartialOrder.Chain.instCoeFunForallNat
code: instance : CoeFun (Chain α) fun _ => ℕ → α 
goal: CoeFun (OmegaCompletePartialOrder.Chain α) fun x => ℕ → α

full_name: OmegaCompletePartialOrder.Chain.instInhabited
code: instance [Inhabited α] : Inhabited (Chain α) 
goal: Inhabited (OmegaCompletePartialOrder.Chain α)

full_name: OmegaCompletePartialOrder.Chain.instMembership
code: instance : Membership α (Chain α) 
goal: Membership α (OmegaCompletePartialOrder.Chain α)

full_name: OmegaCompletePartialOrder.Chain.instLE
code: instance : LE (Chain α) 
goal: LE (OmegaCompletePartialOrder.Chain α)

full_name: OmegaCompletePartialOrder.Chain.isChain_range
code: lemma isChain_range : IsChain (· ≤ ·) (Set.range c) 
goal: IsChain (fun x x_1 => x ≤ x_1) (Set.range ⇑c)

full_name: OmegaCompletePartialOrder.Chain.directed
code: lemma directed : Directed (· ≤ ·) c 
goal: Directed (fun x x_1 => x ≤ x_1) ⇑c

full_name: OmegaCompletePartialOrder.Chain.map
code: /-- `map` function for `Chain` -/
-- Porting note: `simps` doesn't work with type synonyms
-- @[simps! (config := .asFn)]
def map : Chain β 
goal: OmegaCompletePartialOrder.Chain β

full_name: OmegaCompletePartialOrder.Chain.map_coe
code: @[simp] theorem map_coe : ⇑(map c f) = f ∘ c 
goal: ⇑(c.map f) = ⇑f ∘ ⇑c

full_name: OmegaCompletePartialOrder.Chain.mem_map
code: theorem mem_map (x : α) : x ∈ c → f x ∈ Chain.map c f 
goal: x ∈ c → f x ∈ c.map f

full_name: OmegaCompletePartialOrder.Chain.exists_of_mem_map
code: theorem exists_of_mem_map {b : β} : b ∈ c.map f → ∃ a, a ∈ c ∧ f a = b 
goal: b ∈ c.map f → ∃ a ∈ c, f a = b

full_name: OmegaCompletePartialOrder.Chain.mem_map_iff
code: @[simp]
theorem mem_map_iff {b : β} : b ∈ c.map f ↔ ∃ a, a ∈ c ∧ f a = b 
goal: b ∈ c.map f ↔ ∃ a ∈ c, f a = b

full_name: OmegaCompletePartialOrder.Chain.map_id
code: @[simp]
theorem map_id : c.map OrderHom.id = c 
goal: c.map OrderHom.id = c

full_name: OmegaCompletePartialOrder.Chain.map_comp
code: theorem map_comp : (c.map f).map g = c.map (g.comp f) 
goal: (c.map f).map g = c.map (g.comp f)

full_name: OmegaCompletePartialOrder.Chain.map_le_map
code: @[mono]
theorem map_le_map {g : α →o β} (h : f ≤ g) : c.map f ≤ c.map g 
goal: c.map f ≤ c.map g

full_name: OmegaCompletePartialOrder.Chain.zip
code: /-- `OmegaCompletePartialOrder.Chain.zip` pairs up the elements of two chains
that have the same index. -/
-- Porting note: `simps` doesn't work with type synonyms
-- @[simps!]
def zip (c₀ : Chain α) (c₁ : Chain β) : Chain (α × β) 
goal: OmegaCompletePartialOrder.Chain (α × β)

full_name: OmegaCompletePartialOrder.Chain.zip_coe
code: @[simp] theorem zip_coe (c₀ : Chain α) (c₁ : Chain β) (n : ℕ) : c₀.zip c₁ n = (c₀ n, c₁ n) 
goal: (c₀.zip c₁) n = (c₀ n, c₁ n)

full_name: OmegaCompletePartialOrder
code: /-- An omega-complete partial order is a partial order with a supremum
operation on increasing sequences indexed by natural numbers (which we
call `ωSup`). In this sense, it is strictly weaker than join complete
semi-lattices as only ω-sized totally ordered sets have a supremum.

See the definition on page 114 of [gunter1992]. -/
class OmegaCompletePartialOrder (α : Type*) extends PartialOrder α where
  /-- The supremum of an increasing sequence -/
  ωSup : Chain α → α
  /-- `ωSup` is an upper bound of the increasing sequence -/
  le_ωSup : ∀ c : Chain α, ∀ i, c i ≤ ωSup c
  /-- `ωSup` is a lower bound of the set of upper bounds of the increasing sequence -/
  ωSup_le : ∀ (c : Chain α) (x), (∀ i, c i ≤ x) → ωSup c ≤ x
goal: Type u_1

full_name: OmegaCompletePartialOrder.le_ωSup
code: /-- An omega-complete partial order is a partial order with a supremum
operation on increasing sequences indexed by natural numbers (which we
call `ωSup`). In this sense, it is strictly weaker than join complete
semi-lattices as only ω-sized totally ordered sets have a supremum.

See the definition on page 114 of [gunter1992]. -/
class OmegaCompletePartialOrder (α : Type*) extends PartialOrder α where
  /-- The supremum of an increasing sequence -/
  ωSup : Chain α → α
  /-- `ωSup` is an upper bound of the increasing sequence -/
  le_ωSup : ∀ c : Chain α, ∀ i, c i ≤ ωSup c
  /-- `ωSup` is a lower bound of the set of upper bounds of the increasing sequence -/
  ωSup_le : ∀ (c : Chain α) (x), (∀ i, c i ≤ x) → ωSup c ≤ x
goal: c i ≤ OmegaCompletePartialOrder.ωSup c

full_name: OmegaCompletePartialOrder.ωSup_le
code: /-- An omega-complete partial order is a partial order with a supremum
operation on increasing sequences indexed by natural numbers (which we
call `ωSup`). In this sense, it is strictly weaker than join complete
semi-lattices as only ω-sized totally ordered sets have a supremum.

See the definition on page 114 of [gunter1992]. -/
class OmegaCompletePartialOrder (α : Type*) extends PartialOrder α where
  /-- The supremum of an increasing sequence -/
  ωSup : Chain α → α
  /-- `ωSup` is an upper bound of the increasing sequence -/
  le_ωSup : ∀ c : Chain α, ∀ i, c i ≤ ωSup c
  /-- `ωSup` is a lower bound of the set of upper bounds of the increasing sequence -/
  ωSup_le : ∀ (c : Chain α) (x), (∀ i, c i ≤ x) → ωSup c ≤ x
goal: (∀ (i : ℕ), c i ≤ x) → OmegaCompletePartialOrder.ωSup c ≤ x

full_name: OmegaCompletePartialOrder.ωSup
code: /-- An omega-complete partial order is a partial order with a supremum
operation on increasing sequences indexed by natural numbers (which we
call `ωSup`). In this sense, it is strictly weaker than join complete
semi-lattices as only ω-sized totally ordered sets have a supremum.

See the definition on page 114 of [gunter1992]. -/
class OmegaCompletePartialOrder (α : Type*) extends PartialOrder α where
  /-- The supremum of an increasing sequence -/
  ωSup : Chain α → α
  /-- `ωSup` is an upper bound of the increasing sequence -/
  le_ωSup : ∀ c : Chain α, ∀ i, c i ≤ ωSup c
  /-- `ωSup` is a lower bound of the set of upper bounds of the increasing sequence -/
  ωSup_le : ∀ (c : Chain α) (x), (∀ i, c i ≤ x) → ωSup c ≤ x
goal: OmegaCompletePartialOrder.Chain α → α

full_name: OmegaCompletePartialOrder.lift
code: /-- Transfer an `OmegaCompletePartialOrder` on `β` to an `OmegaCompletePartialOrder` on `α`
using a strictly monotone function `f : β →o α`, a definition of ωSup and a proof that `f` is
continuous with regard to the provided `ωSup` and the ωCPO on `α`. -/
protected abbrev lift [PartialOrder β] (f : β →o α) (ωSup₀ : Chain β → β)
    (h : ∀ x y, f x ≤ f y → x ≤ y) (h' : ∀ c, f (ωSup₀ c) = ωSup (c.map f)) :
    OmegaCompletePartialOrder β 
goal: OmegaCompletePartialOrder β

full_name: OmegaCompletePartialOrder.le_ωSup_of_le
code: theorem le_ωSup_of_le {c : Chain α} {x : α} (i : ℕ) (h : x ≤ c i) : x ≤ ωSup c 
goal: x ≤ OmegaCompletePartialOrder.ωSup c

full_name: OmegaCompletePartialOrder.ωSup_total
code: theorem ωSup_total {c : Chain α} {x : α} (h : ∀ i, c i ≤ x ∨ x ≤ c i) : ωSup c ≤ x ∨ x ≤ ωSup c 
goal: OmegaCompletePartialOrder.ωSup c ≤ x ∨ x ≤ OmegaCompletePartialOrder.ωSup c

full_name: OmegaCompletePartialOrder.ωSup_le_ωSup_of_le
code: @[mono]
theorem ωSup_le_ωSup_of_le {c₀ c₁ : Chain α} (h : c₀ ≤ c₁) : ωSup c₀ ≤ ωSup c₁ 
goal: OmegaCompletePartialOrder.ωSup c₀ ≤ OmegaCompletePartialOrder.ωSup c₁

full_name: OmegaCompletePartialOrder.ωSup_le_iff
code: theorem ωSup_le_iff (c : Chain α) (x : α) : ωSup c ≤ x ↔ ∀ i, c i ≤ x 
goal: OmegaCompletePartialOrder.ωSup c ≤ x ↔ ∀ (i : ℕ), c i ≤ x

full_name: OmegaCompletePartialOrder.isLUB_range_ωSup
code: lemma isLUB_range_ωSup (c : Chain α) : IsLUB (Set.range c) (ωSup c) 
goal: IsLUB (Set.range ⇑c) (OmegaCompletePartialOrder.ωSup c)

full_name: OmegaCompletePartialOrder.ωSup_eq_of_isLUB
code: lemma ωSup_eq_of_isLUB {c : Chain α} {a : α} (h : IsLUB (Set.range c) a) : a = ωSup c 
goal: a = OmegaCompletePartialOrder.ωSup c

full_name: OmegaCompletePartialOrder.subtype
code: /-- A subset `p : α → Prop` of the type closed under `ωSup` induces an
`OmegaCompletePartialOrder` on the subtype `{a : α // p a}`. -/
def subtype {α : Type*} [OmegaCompletePartialOrder α] (p : α → Prop)
    (hp : ∀ c : Chain α, (∀ i ∈ c, p i) → p (ωSup c)) : OmegaCompletePartialOrder (Subtype p) 
goal: OmegaCompletePartialOrder (Subtype p)

full_name: OmegaCompletePartialOrder.Continuous
code: /-- A monotone function `f : α →o β` is continuous if it distributes over ωSup.

In order to distinguish it from the (more commonly used) continuity from topology
(see `Mathlib/Topology/Basic.lean`), the present definition is often referred to as
"Scott-continuity" (referring to Dana Scott). It corresponds to continuity
in Scott topological spaces (not defined here). -/
def Continuous (f : α →o β) : Prop 
goal: Prop

full_name: OmegaCompletePartialOrder.Continuous'
code: /-- `Continuous' f` asserts that `f` is both monotone and continuous. -/
def Continuous' (f : α → β) : Prop 
goal: Prop

full_name: OmegaCompletePartialOrder.isLUB_of_scottContinuous
code: lemma isLUB_of_scottContinuous {c : Chain α} {f : α → β} (hf : ScottContinuous f) :
    IsLUB (Set.range (Chain.map c ⟨f, (ScottContinuous.monotone hf)⟩)) (f (ωSup c)) 
goal: IsLUB (Set.range ⇑(c.map { toFun := f, monotone' := ⋯ })) (f (OmegaCompletePartialOrder.ωSup c))

full_name: OmegaCompletePartialOrder.ScottContinuous.continuous'
code: lemma ScottContinuous.continuous' {f : α → β} (hf : ScottContinuous f) : Continuous' f 
goal: OmegaCompletePartialOrder.Continuous' f

full_name: OmegaCompletePartialOrder.Continuous'.to_monotone
code: theorem Continuous'.to_monotone {f : α → β} (hf : Continuous' f) : Monotone f 
goal: Monotone f

full_name: OmegaCompletePartialOrder.Continuous.of_bundled
code: theorem Continuous.of_bundled (f : α → β) (hf : Monotone f) (hf' : Continuous ⟨f, hf⟩) :
    Continuous' f 
goal: OmegaCompletePartialOrder.Continuous' f

full_name: OmegaCompletePartialOrder.Continuous.of_bundled'
code: theorem Continuous.of_bundled' (f : α →o β) (hf' : Continuous f) : Continuous' f 
goal: OmegaCompletePartialOrder.Continuous' ⇑f

full_name: OmegaCompletePartialOrder.Continuous'.to_bundled
code: theorem Continuous'.to_bundled (f : α → β) (hf : Continuous' f) : Continuous ⟨f, hf.to_monotone⟩ 
goal: OmegaCompletePartialOrder.Continuous { toFun := f, monotone' := ⋯ }

full_name: OmegaCompletePartialOrder.continuous'_coe
code: @[simp, norm_cast]
theorem continuous'_coe : ∀ {f : α →o β}, Continuous' f ↔ Continuous f
  
goal: OmegaCompletePartialOrder.Continuous' ⇑f ↔ OmegaCompletePartialOrder.Continuous f

full_name: OmegaCompletePartialOrder.continuous_id
code: theorem continuous_id : Continuous (@OrderHom.id α _) 
goal: OmegaCompletePartialOrder.Continuous OrderHom.id

full_name: OmegaCompletePartialOrder.continuous_comp
code: theorem continuous_comp (hfc : Continuous f) (hgc : Continuous g) : Continuous (g.comp f) 
goal: OmegaCompletePartialOrder.Continuous (g.comp f)

full_name: OmegaCompletePartialOrder.id_continuous'
code: theorem id_continuous' : Continuous' (@id α) 
goal: OmegaCompletePartialOrder.Continuous' id

full_name: OmegaCompletePartialOrder.continuous_const
code: theorem continuous_const (x : β) : Continuous (OrderHom.const α x) 
goal: OmegaCompletePartialOrder.Continuous ((OrderHom.const α) x)

full_name: OmegaCompletePartialOrder.const_continuous'
code: theorem const_continuous' (x : β) : Continuous' (Function.const α x) 
goal: OmegaCompletePartialOrder.Continuous' (Function.const α x)

full_name: Part.eq_of_chain
code: theorem eq_of_chain {c : Chain (Part α)} {a b : α} (ha : some a ∈ c) (hb : some b ∈ c) : a = b 
goal: a = b

full_name: Part.ωSup
code: /-- The (noncomputable) `ωSup` definition for the `ω`-CPO structure on `Part α`. -/
protected noncomputable def ωSup (c : Chain (Part α)) : Part α 
goal: Part α

full_name: Part.ωSup_eq_some
code: theorem ωSup_eq_some {c : Chain (Part α)} {a : α} (h : some a ∈ c) : Part.ωSup c = some a 
goal: Part.ωSup c = Part.some a

full_name: Part.ωSup_eq_none
code: theorem ωSup_eq_none {c : Chain (Part α)} (h : ¬∃ a, some a ∈ c) : Part.ωSup c = none 
goal: Part.ωSup c = Part.none

full_name: Part.mem_chain_of_mem_ωSup
code: theorem mem_chain_of_mem_ωSup {c : Chain (Part α)} {a : α} (h : a ∈ Part.ωSup c) : some a ∈ c 
goal: Part.some a ∈ c

full_name: Part.omegaCompletePartialOrder
code: noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) 
goal: OmegaCompletePartialOrder (Part α)

full_name: Part.mem_ωSup
code: theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c 
goal: x ∈ OmegaCompletePartialOrder.ωSup c ↔ Part.some x ∈ c

full_name: Pi.instOmegaCompletePartialOrderForall
code: instance [∀ a, OmegaCompletePartialOrder (β a)] :
    OmegaCompletePartialOrder (∀ a, β a) 
goal: OmegaCompletePartialOrder ((a : α) → β a)

full_name: Pi.OmegaCompletePartialOrder.flip₁_continuous'
code: theorem flip₁_continuous' (f : ∀ x : α, γ → β x) (a : α) (hf : Continuous' fun x y => f y x) :
    Continuous' (f a) 
goal: OmegaCompletePartialOrder.Continuous' (f a)

full_name: Pi.OmegaCompletePartialOrder.flip₂_continuous'
code: theorem flip₂_continuous' (f : γ → ∀ x, β x) (hf : ∀ x, Continuous' fun g => f g x) :
    Continuous' f 
goal: OmegaCompletePartialOrder.Continuous' f

full_name: Prod.ωSup_snd
code: /-- The supremum of a chain in the product `ω`-CPO. -/
@[simps]
protected def ωSup (c : Chain (α × β)) : α × β 
goal: (Prod.ωSup c).2 = OmegaCompletePartialOrder.ωSup (c.map OrderHom.snd)

full_name: Prod.ωSup_fst
code: /-- The supremum of a chain in the product `ω`-CPO. -/
@[simps]
protected def ωSup (c : Chain (α × β)) : α × β 
goal: (Prod.ωSup c).1 = OmegaCompletePartialOrder.ωSup (c.map OrderHom.fst)

full_name: Prod.ωSup
code: /-- The supremum of a chain in the product `ω`-CPO. -/
@[simps]
protected def ωSup (c : Chain (α × β)) : α × β 
goal: α × β

full_name: Prod.instOmegaCompletePartialOrder
code: @[simps! ωSup_fst ωSup_snd]
instance : OmegaCompletePartialOrder (α × β) 
goal: OmegaCompletePartialOrder (α × β)

full_name: Prod.instOmegaCompletePartialOrder_ωSup_fst
code: @[simps! ωSup_fst ωSup_snd]
instance : OmegaCompletePartialOrder (α × β) 
goal: (OmegaCompletePartialOrder.ωSup c).1 = OmegaCompletePartialOrder.ωSup (c.map OrderHom.fst)

full_name: Prod.instOmegaCompletePartialOrder_ωSup_snd
code: @[simps! ωSup_fst ωSup_snd]
instance : OmegaCompletePartialOrder (α × β) 
goal: (OmegaCompletePartialOrder.ωSup c).2 = OmegaCompletePartialOrder.ωSup (c.map OrderHom.snd)

full_name: Prod.ωSup_zip
code: theorem ωSup_zip (c₀ : Chain α) (c₁ : Chain β) : ωSup (c₀.zip c₁) = (ωSup c₀, ωSup c₁) 
goal: OmegaCompletePartialOrder.ωSup (c₀.zip c₁) = (OmegaCompletePartialOrder.ωSup c₀, OmegaCompletePartialOrder.ωSup c₁)

full_name: CompleteLattice.instOmegaCompletePartialOrder
code: /-- Any complete lattice has an `ω`-CPO structure where the countable supremum is a special case
of arbitrary suprema. -/
instance (priority := 100) [CompleteLattice α] : OmegaCompletePartialOrder α 
goal: OmegaCompletePartialOrder α

full_name: CompleteLattice.sSup_continuous
code: theorem sSup_continuous (s : Set <| α →o β) (hs : ∀ f ∈ s, Continuous f) : Continuous (sSup s) 
goal: OmegaCompletePartialOrder.Continuous (sSup s)

full_name: CompleteLattice.iSup_continuous
code: theorem iSup_continuous {ι : Sort*} {f : ι → α →o β} (h : ∀ i, Continuous (f i)) :
    Continuous (⨆ i, f i) 
goal: OmegaCompletePartialOrder.Continuous (⨆ i, f i)

full_name: CompleteLattice.sSup_continuous'
code: theorem sSup_continuous' (s : Set (α → β)) (hc : ∀ f ∈ s, Continuous' f) :
    Continuous' (sSup s) 
goal: OmegaCompletePartialOrder.Continuous' (sSup s)

full_name: CompleteLattice.sup_continuous
code: theorem sup_continuous {f g : α →o β} (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊔ g) 
goal: OmegaCompletePartialOrder.Continuous (f ⊔ g)

full_name: CompleteLattice.top_continuous
code: theorem top_continuous : Continuous (⊤ : α →o β) 
goal: OmegaCompletePartialOrder.Continuous ⊤

full_name: CompleteLattice.bot_continuous
code: theorem bot_continuous : Continuous (⊥ : α →o β) 
goal: OmegaCompletePartialOrder.Continuous ⊥

full_name: CompleteLattice.inf_continuous
code: theorem inf_continuous (f g : α →o β) (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊓ g) 
goal: OmegaCompletePartialOrder.Continuous (f ⊓ g)

full_name: CompleteLattice.inf_continuous'
code: theorem inf_continuous' {f g : α → β} (hf : Continuous' f) (hg : Continuous' g) :
    Continuous' (f ⊓ g) 
goal: OmegaCompletePartialOrder.Continuous' (f ⊓ g)

full_name: OmegaCompletePartialOrder.OrderHom.ωSup_coe
code: /-- The `ωSup` operator for monotone functions. -/
@[simps]
protected def ωSup (c : Chain (α →o β)) : α →o β 
goal: (OmegaCompletePartialOrder.OrderHom.ωSup c) a = OmegaCompletePartialOrder.ωSup (c.map (OrderHom.apply a))

full_name: OmegaCompletePartialOrder.OrderHom.ωSup
code: /-- The `ωSup` operator for monotone functions. -/
@[simps]
protected def ωSup (c : Chain (α →o β)) : α →o β 
goal: α →o β

full_name: OmegaCompletePartialOrder.OrderHom.omegaCompletePartialOrder
code: @[simps! ωSup_coe]
instance omegaCompletePartialOrder : OmegaCompletePartialOrder (α →o β) 
goal: OmegaCompletePartialOrder (α →o β)

full_name: OmegaCompletePartialOrder.OrderHom.omegaCompletePartialOrder_ωSup_coe
code: @[simps! ωSup_coe]
instance omegaCompletePartialOrder : OmegaCompletePartialOrder (α →o β) 
goal: (OmegaCompletePartialOrder.ωSup c) a = OmegaCompletePartialOrder.ωSup (c.map (OrderHom.apply a))

full_name: OmegaCompletePartialOrder.ContinuousHom.cont
code: /-- A monotone function on `ω`-continuous partial orders is said to be continuous
if for every chain `c : chain α`, `f (⊔ i, c i) = ⊔ i, f (c i)`.
This is just the bundled version of `OrderHom.continuous`. -/
structure ContinuousHom extends OrderHom α β where
  /-- The underlying function of a `ContinuousHom` is continuous, i.e. it preserves `ωSup` -/
  cont : Continuous toOrderHom
goal: OmegaCompletePartialOrder.Continuous self.toOrderHom

full_name: OmegaCompletePartialOrder.ContinuousHom
code: /-- A monotone function on `ω`-continuous partial orders is said to be continuous
if for every chain `c : chain α`, `f (⊔ i, c i) = ⊔ i, f (c i)`.
This is just the bundled version of `OrderHom.continuous`. -/
structure ContinuousHom extends OrderHom α β where
  /-- The underlying function of a `ContinuousHom` is continuous, i.e. it preserves `ωSup` -/
  cont : Continuous toOrderHom
goal: Type (max u v)

full_name: OmegaCompletePartialOrder.«_aux_Mathlib_Order_OmegaCompletePartialOrder___macroRules_OmegaCompletePartialOrder_term_→𝒄__1»
code: @[inherit_doc] infixr:25 " →𝒄 " => ContinuousHom
goal: Lean.Macro

full_name: OmegaCompletePartialOrder._aux_Mathlib_Order_OmegaCompletePartialOrder___unexpand_OmegaCompletePartialOrder_ContinuousHom_1
code: @[inherit_doc] infixr:25 " →𝒄 " => ContinuousHom
goal: Lean.PrettyPrinter.Unexpander

full_name: OmegaCompletePartialOrder.instFunLikeContinuousHom
code: instance : FunLike (α →𝒄 β) α β 
goal: FunLike (α →𝒄 β) α β

full_name: OmegaCompletePartialOrder.instOrderHomClassContinuousHom
code: instance : OrderHomClass (α →𝒄 β) α β 
goal: OrderHomClass (α →𝒄 β) α β

full_name: OmegaCompletePartialOrder.instPartialOrderContinuousHom
code: instance : PartialOrder (α →𝒄 β) 
goal: PartialOrder (α →𝒄 β)

full_name: OmegaCompletePartialOrder.ContinuousHom.toOrderHom_eq_coe
code: theorem toOrderHom_eq_coe (f : α →𝒄 β) : f.1 = f 
goal: f.toOrderHom = ↑f

full_name: OmegaCompletePartialOrder.ContinuousHom.coe_mk
code: @[simp] theorem coe_mk (f : α →o β) (hf : Continuous f) : ⇑(mk f hf) = f 
goal: ⇑{ toOrderHom := f, cont := hf } = ⇑f

full_name: OmegaCompletePartialOrder.ContinuousHom.coe_toOrderHom
code: @[simp] theorem coe_toOrderHom (f : α →𝒄 β) : ⇑f.1 = f 
goal: ⇑f.toOrderHom = ⇑f

full_name: OmegaCompletePartialOrder.ContinuousHom.Simps.apply
code: /-- See Note [custom simps projection]. We specify this explicitly because we don't have a DFunLike
instance.
-/
def Simps.apply (h : α →𝒄 β) : α → β 
goal: α → β

full_name: OmegaCompletePartialOrder.ContinuousHom.congr_fun
code: protected theorem congr_fun {f g : α →𝒄 β} (h : f = g) (x : α) : f x = g x 
goal: f x = g x

full_name: OmegaCompletePartialOrder.ContinuousHom.congr_arg
code: protected theorem congr_arg (f : α →𝒄 β) {x y : α} (h : x = y) : f x = f y 
goal: f x = f y

full_name: OmegaCompletePartialOrder.ContinuousHom.monotone
code: protected theorem monotone (f : α →𝒄 β) : Monotone f 
goal: Monotone ⇑f

full_name: OmegaCompletePartialOrder.ContinuousHom.apply_mono
code: @[mono]
theorem apply_mono {f g : α →𝒄 β} {x y : α} (h₁ : f ≤ g) (h₂ : x ≤ y) : f x ≤ g y 
goal: f x ≤ g y

full_name: OmegaCompletePartialOrder.ContinuousHom.ite_continuous'
code: theorem ite_continuous' {p : Prop} [hp : Decidable p] (f g : α → β) (hf : Continuous' f)
    (hg : Continuous' g) : Continuous' fun x => if p then f x else g x 
goal: OmegaCompletePartialOrder.Continuous' fun x => if p then f x else g x

full_name: OmegaCompletePartialOrder.ContinuousHom.ωSup_bind
code: theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.partBind g)) = ωSup (c.map f) >>= ωSup (c.map g) 
goal: OmegaCompletePartialOrder.ωSup (c.map (f.partBind g)) =
  OmegaCompletePartialOrder.ωSup (c.map f) >>= OmegaCompletePartialOrder.ωSup (c.map g)

full_name: OmegaCompletePartialOrder.ContinuousHom.bind_continuous'
code: theorem bind_continuous' {β γ : Type v} (f : α → Part β) (g : α → β → Part γ) :
    Continuous' f → Continuous' g → Continuous' fun x => f x >>= g x
  
goal: OmegaCompletePartialOrder.Continuous' f →
  OmegaCompletePartialOrder.Continuous' g → OmegaCompletePartialOrder.Continuous' fun x => f x >>= g x

full_name: OmegaCompletePartialOrder.ContinuousHom.map_continuous'
code: theorem map_continuous' {β γ : Type v} (f : β → γ) (g : α → Part β) (hg : Continuous' g) :
    Continuous' fun x => f <$> g x 
goal: OmegaCompletePartialOrder.Continuous' fun x => f <$> g x

full_name: OmegaCompletePartialOrder.ContinuousHom.seq_continuous'
code: theorem seq_continuous' {β γ : Type v} (f : α → Part (β → γ)) (g : α → Part β) (hf : Continuous' f)
    (hg : Continuous' g) : Continuous' fun x => f x <*> g x 
goal: OmegaCompletePartialOrder.Continuous' fun x => Seq.seq (f x) fun x_1 => g x

full_name: OmegaCompletePartialOrder.ContinuousHom.continuous
code: theorem continuous (F : α →𝒄 β) (C : Chain α) : F (ωSup C) = ωSup (C.map F) 
goal: F (OmegaCompletePartialOrder.ωSup C) = OmegaCompletePartialOrder.ωSup (C.map ↑F)

full_name: OmegaCompletePartialOrder.ContinuousHom.copy
code: /-- Construct a continuous function from a bare function, a continuous function, and a proof that
they are equal. -/
-- Porting note: removed `@[reducible]`
@[simps!]
def copy (f : α → β) (g : α →𝒄 β) (h : f = g) : α →𝒄 β 
goal: α →𝒄 β

full_name: OmegaCompletePartialOrder.ContinuousHom.copy_apply
code: /-- Construct a continuous function from a bare function, a continuous function, and a proof that
they are equal. -/
-- Porting note: removed `@[reducible]`
@[simps!]
def copy (f : α → β) (g : α →𝒄 β) (h : f = g) : α →𝒄 β 
goal: ∀ (a : α), (OmegaCompletePartialOrder.ContinuousHom.copy f g h) a = f a

full_name: OmegaCompletePartialOrder.ContinuousHom.id_apply
code: /-- The identity as a continuous function. -/
@[simps!]
def id : α →𝒄 α 
goal: OmegaCompletePartialOrder.ContinuousHom.id a = a

full_name: OmegaCompletePartialOrder.ContinuousHom.id
code: /-- The identity as a continuous function. -/
@[simps!]
def id : α →𝒄 α 
goal: α →𝒄 α

full_name: OmegaCompletePartialOrder.ContinuousHom.comp
code: /-- The composition of continuous functions. -/
@[simps!]
def comp (f : β →𝒄 γ) (g : α →𝒄 β) : α →𝒄 γ 
goal: α →𝒄 γ

full_name: OmegaCompletePartialOrder.ContinuousHom.comp_apply
code: /-- The composition of continuous functions. -/
@[simps!]
def comp (f : β →𝒄 γ) (g : α →𝒄 β) : α →𝒄 γ 
goal: ∀ (a : α), (f.comp g) a = f (g a)

full_name: OmegaCompletePartialOrder.ContinuousHom.ext
code: @[ext]
protected theorem ext (f g : α →𝒄 β) (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: OmegaCompletePartialOrder.ContinuousHom.coe_inj
code: protected theorem coe_inj (f g : α →𝒄 β) (h : (f : α → β) = g) : f = g 
goal: f = g

full_name: OmegaCompletePartialOrder.ContinuousHom.comp_id
code: @[simp]
theorem comp_id (f : β →𝒄 γ) : f.comp id = f 
goal: f.comp OmegaCompletePartialOrder.ContinuousHom.id = f

full_name: OmegaCompletePartialOrder.ContinuousHom.id_comp
code: @[simp]
theorem id_comp (f : β →𝒄 γ) : id.comp f = f 
goal: OmegaCompletePartialOrder.ContinuousHom.id.comp f = f

full_name: OmegaCompletePartialOrder.ContinuousHom.comp_assoc
code: @[simp]
theorem comp_assoc (f : γ →𝒄 φ) (g : β →𝒄 γ) (h : α →𝒄 β) : f.comp (g.comp h) = (f.comp g).comp h 
goal: f.comp (g.comp h) = (f.comp g).comp h

full_name: OmegaCompletePartialOrder.ContinuousHom.coe_apply
code: @[simp]
theorem coe_apply (a : α) (f : α →𝒄 β) : (f : α →o β) a = f a 
goal: ↑f a = f a

full_name: OmegaCompletePartialOrder.ContinuousHom.const_apply
code: /-- `Function.const` is a continuous function. -/
@[simps!]
def const (x : β) : α →𝒄 β 
goal: ∀ (a : α), (OmegaCompletePartialOrder.ContinuousHom.const x) a = x

full_name: OmegaCompletePartialOrder.ContinuousHom.const
code: /-- `Function.const` is a continuous function. -/
@[simps!]
def const (x : β) : α →𝒄 β 
goal: α →𝒄 β

full_name: OmegaCompletePartialOrder.ContinuousHom.instInhabited
code: instance [Inhabited β] : Inhabited (α →𝒄 β) 
goal: Inhabited (α →𝒄 β)

full_name: OmegaCompletePartialOrder.ContinuousHom.toMono_coe
code: /-- The map from continuous functions to monotone functions is itself a monotone function. -/
@[simps]
def toMono : (α →𝒄 β) →o α →o β 
goal: OmegaCompletePartialOrder.ContinuousHom.toMono f = ↑f

full_name: OmegaCompletePartialOrder.ContinuousHom.toMono
code: /-- The map from continuous functions to monotone functions is itself a monotone function. -/
@[simps]
def toMono : (α →𝒄 β) →o α →o β 
goal: (α →𝒄 β) →o α →o β

full_name: OmegaCompletePartialOrder.ContinuousHom.forall_forall_merge
code: /-- When proving that a chain of applications is below a bound `z`, it suffices to consider the
functions and values being selected from the same index in the chains.

This lemma is more specific than necessary, i.e. `c₀` only needs to be a
chain of monotone functions, but it is only used with continuous functions. -/
@[simp]
theorem forall_forall_merge (c₀ : Chain (α →𝒄 β)) (c₁ : Chain α) (z : β) :
    (∀ i j : ℕ, (c₀ i) (c₁ j) ≤ z) ↔ ∀ i : ℕ, (c₀ i) (c₁ i) ≤ z 
goal: (∀ (i j : ℕ), (c₀ i) (c₁ j) ≤ z) ↔ ∀ (i : ℕ), (c₀ i) (c₁ i) ≤ z

full_name: OmegaCompletePartialOrder.ContinuousHom.forall_forall_merge'
code: @[simp]
theorem forall_forall_merge' (c₀ : Chain (α →𝒄 β)) (c₁ : Chain α) (z : β) :
    (∀ j i : ℕ, (c₀ i) (c₁ j) ≤ z) ↔ ∀ i : ℕ, (c₀ i) (c₁ i) ≤ z 
goal: (∀ (j i : ℕ), (c₀ i) (c₁ j) ≤ z) ↔ ∀ (i : ℕ), (c₀ i) (c₁ i) ≤ z

full_name: OmegaCompletePartialOrder.ContinuousHom.ωSup
code: /-- The `ωSup` operator for continuous functions, which takes the pointwise countable supremum
of the functions in the `ω`-chain. -/
@[simps!]
protected def ωSup (c : Chain (α →𝒄 β)) : α →𝒄 β 
goal: α →𝒄 β

full_name: OmegaCompletePartialOrder.ContinuousHom.ωSup_apply
code: /-- The `ωSup` operator for continuous functions, which takes the pointwise countable supremum
of the functions in the `ω`-chain. -/
@[simps!]
protected def ωSup (c : Chain (α →𝒄 β)) : α →𝒄 β 
goal: (OmegaCompletePartialOrder.ContinuousHom.ωSup c) a =
  OmegaCompletePartialOrder.ωSup ((c.map OmegaCompletePartialOrder.ContinuousHom.toMono).map (OrderHom.apply a))

full_name: OmegaCompletePartialOrder.ContinuousHom.inst
code: @[simps ωSup]
instance : OmegaCompletePartialOrder (α →𝒄 β) 
goal: OmegaCompletePartialOrder (α →𝒄 β)

full_name: OmegaCompletePartialOrder.ContinuousHom.inst_ωSup
code: @[simps ωSup]
instance : OmegaCompletePartialOrder (α →𝒄 β) 
goal: OmegaCompletePartialOrder.ωSup c = OmegaCompletePartialOrder.ContinuousHom.ωSup c

full_name: OmegaCompletePartialOrder.ContinuousHom.Prod.apply
code: /-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β 
goal: (α →𝒄 β) × α →𝒄 β

full_name: OmegaCompletePartialOrder.ContinuousHom.Prod.apply_apply
code: /-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β 
goal: OmegaCompletePartialOrder.ContinuousHom.Prod.apply f = f.1 f.2

full_name: OmegaCompletePartialOrder.ContinuousHom.ωSup_def
code: theorem ωSup_def (c : Chain (α →𝒄 β)) (x : α) : ωSup c x = ContinuousHom.ωSup c x 
goal: (OmegaCompletePartialOrder.ωSup c) x = (OmegaCompletePartialOrder.ContinuousHom.ωSup c) x

full_name: OmegaCompletePartialOrder.ContinuousHom.ωSup_apply_ωSup
code: theorem ωSup_apply_ωSup (c₀ : Chain (α →𝒄 β)) (c₁ : Chain α) :
    ωSup c₀ (ωSup c₁) = Prod.apply (ωSup (c₀.zip c₁)) 
goal: (OmegaCompletePartialOrder.ωSup c₀) (OmegaCompletePartialOrder.ωSup c₁) =
  OmegaCompletePartialOrder.ContinuousHom.Prod.apply (OmegaCompletePartialOrder.ωSup (c₀.zip c₁))

full_name: OmegaCompletePartialOrder.ContinuousHom.flip
code: /-- A family of continuous functions yields a continuous family of functions. -/
@[simps]
def flip {α : Type*} (f : α → β →𝒄 γ) : β →𝒄 α → γ 
goal: β →𝒄 α → γ

full_name: OmegaCompletePartialOrder.ContinuousHom.flip_apply
code: /-- A family of continuous functions yields a continuous family of functions. -/
@[simps]
def flip {α : Type*} (f : α → β →𝒄 γ) : β →𝒄 α → γ 
goal: (OmegaCompletePartialOrder.ContinuousHom.flip f) x y = (f y) x

full_name: OmegaCompletePartialOrder.ContinuousHom.bind_apply
code: /-- `Part.bind` as a continuous function. -/
@[simps! apply] -- Porting note: removed `(config := { rhsMd := reducible })`
noncomputable def bind {β γ : Type v} (f : α →𝒄 Part β) (g : α →𝒄 β → Part γ) : α →𝒄 Part γ 
goal: (f.bind g) x = (f x).bind (g x)

full_name: OmegaCompletePartialOrder.ContinuousHom.bind
code: /-- `Part.bind` as a continuous function. -/
@[simps! apply] -- Porting note: removed `(config := { rhsMd := reducible })`
noncomputable def bind {β γ : Type v} (f : α →𝒄 Part β) (g : α →𝒄 β → Part γ) : α →𝒄 Part γ 
goal: α →𝒄 Part γ

full_name: OmegaCompletePartialOrder.ContinuousHom.map_apply
code: /-- `Part.map` as a continuous function. -/
@[simps! apply] -- Porting note: removed `(config := { rhsMd := reducible })`
noncomputable def map {β γ : Type v} (f : β → γ) (g : α →𝒄 Part β) : α →𝒄 Part γ 
goal: (OmegaCompletePartialOrder.ContinuousHom.map f g) x = Part.map f (g x)

full_name: OmegaCompletePartialOrder.ContinuousHom.map
code: /-- `Part.map` as a continuous function. -/
@[simps! apply] -- Porting note: removed `(config := { rhsMd := reducible })`
noncomputable def map {β γ : Type v} (f : β → γ) (g : α →𝒄 Part β) : α →𝒄 Part γ 
goal: α →𝒄 Part γ

full_name: OmegaCompletePartialOrder.ContinuousHom.seq
code: /-- `Part.seq` as a continuous function. -/
@[simps! apply] -- Porting note: removed `(config := { rhsMd := reducible })`
noncomputable def seq {β γ : Type v} (f : α →𝒄 Part (β → γ)) (g : α →𝒄 Part β) : α →𝒄 Part γ 
goal: α →𝒄 Part γ

full_name: OmegaCompletePartialOrder.ContinuousHom.seq_apply
code: /-- `Part.seq` as a continuous function. -/
@[simps! apply] -- Porting note: removed `(config := { rhsMd := reducible })`
noncomputable def seq {β γ : Type v} (f : α →𝒄 Part (β → γ)) (g : α →𝒄 Part β) : α →𝒄 Part γ 
goal: (f.seq g) x = Seq.seq (f x) fun x_1 => g x