File: Mathlib/Order/OrdContinuous.lean

full_name: LeftOrdContinuous
code: /-- A function `f` between preorders is left order continuous if it preserves all suprema.  We
define it using `IsLUB` instead of `sSup` so that the proof works both for complete lattices and
conditionally complete lattices. -/
def LeftOrdContinuous [Preorder α] [Preorder β] (f : α → β) 
goal: Prop

full_name: RightOrdContinuous
code: /-- A function `f` between preorders is right order continuous if it preserves all infima.  We
define it using `IsGLB` instead of `sInf` so that the proof works both for complete lattices and
conditionally complete lattices. -/
def RightOrdContinuous [Preorder α] [Preorder β] (f : α → β) 
goal: Prop

full_name: LeftOrdContinuous.id
code: protected theorem id : LeftOrdContinuous (id : α → α) 
goal: LeftOrdContinuous id

full_name: LeftOrdContinuous.order_dual
code: protected theorem order_dual : LeftOrdContinuous f → RightOrdContinuous (toDual ∘ f ∘ ofDual) 
goal: LeftOrdContinuous f → RightOrdContinuous (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual)

full_name: LeftOrdContinuous.map_isGreatest
code: theorem map_isGreatest (hf : LeftOrdContinuous f) {s : Set α} {x : α} (h : IsGreatest s x) :
    IsGreatest (f '' s) (f x) 
goal: IsGreatest (f '' s) (f x)

full_name: LeftOrdContinuous.mono
code: theorem mono (hf : LeftOrdContinuous f) : Monotone f 
goal: Monotone f

full_name: LeftOrdContinuous.comp
code: theorem comp (hg : LeftOrdContinuous g) (hf : LeftOrdContinuous f) : LeftOrdContinuous (g ∘ f) 
goal: LeftOrdContinuous (g ∘ f)

full_name: LeftOrdContinuous.iterate
code: protected theorem iterate {f : α → α} (hf : LeftOrdContinuous f) (n : ℕ) :
    LeftOrdContinuous f^[n] 
goal: LeftOrdContinuous f^[n]

full_name: LeftOrdContinuous.map_sup
code: theorem map_sup (hf : LeftOrdContinuous f) (x y : α) : f (x ⊔ y) = f x ⊔ f y 
goal: f (x ⊔ y) = f x ⊔ f y

full_name: LeftOrdContinuous.le_iff
code: theorem le_iff (hf : LeftOrdContinuous f) (h : Injective f) {x y} : f x ≤ f y ↔ x ≤ y 
goal: f x ≤ f y ↔ x ≤ y

full_name: LeftOrdContinuous.lt_iff
code: theorem lt_iff (hf : LeftOrdContinuous f) (h : Injective f) {x y} : f x < f y ↔ x < y 
goal: f x < f y ↔ x < y

full_name: LeftOrdContinuous.toOrderEmbedding
code: /-- Convert an injective left order continuous function to an order embedding. -/
def toOrderEmbedding (hf : LeftOrdContinuous f) (h : Injective f) : α ↪o β 
goal: α ↪o β

full_name: LeftOrdContinuous.coe_toOrderEmbedding
code: @[simp]
theorem coe_toOrderEmbedding (hf : LeftOrdContinuous f) (h : Injective f) :
    ⇑(hf.toOrderEmbedding f h) = f 
goal: ⇑(LeftOrdContinuous.toOrderEmbedding f hf h) = f

full_name: LeftOrdContinuous.map_sSup'
code: theorem map_sSup' (hf : LeftOrdContinuous f) (s : Set α) : f (sSup s) = sSup (f '' s) 
goal: f (sSup s) = sSup (f '' s)

full_name: LeftOrdContinuous.map_sSup
code: theorem map_sSup (hf : LeftOrdContinuous f) (s : Set α) : f (sSup s) = ⨆ x ∈ s, f x 
goal: f (sSup s) = ⨆ x ∈ s, f x

full_name: LeftOrdContinuous.map_iSup
code: theorem map_iSup (hf : LeftOrdContinuous f) (g : ι → α) : f (⨆ i, g i) = ⨆ i, f (g i) 
goal: f (⨆ i, g i) = ⨆ i, f (g i)

full_name: LeftOrdContinuous.map_csSup
code: theorem map_csSup (hf : LeftOrdContinuous f) {s : Set α} (sne : s.Nonempty) (sbdd : BddAbove s) :
    f (sSup s) = sSup (f '' s) 
goal: f (sSup s) = sSup (f '' s)

full_name: LeftOrdContinuous.map_ciSup
code: theorem map_ciSup (hf : LeftOrdContinuous f) {g : ι → α} (hg : BddAbove (range g)) :
    f (⨆ i, g i) = ⨆ i, f (g i) 
goal: f (⨆ i, g i) = ⨆ i, f (g i)

full_name: RightOrdContinuous.id
code: protected theorem id : RightOrdContinuous (id : α → α) 
goal: RightOrdContinuous id

full_name: RightOrdContinuous.orderDual
code: protected theorem orderDual : RightOrdContinuous f → LeftOrdContinuous (toDual ∘ f ∘ ofDual) 
goal: RightOrdContinuous f → LeftOrdContinuous (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual)

full_name: RightOrdContinuous.map_isLeast
code: theorem map_isLeast (hf : RightOrdContinuous f) {s : Set α} {x : α} (h : IsLeast s x) :
    IsLeast (f '' s) (f x) 
goal: IsLeast (f '' s) (f x)

full_name: RightOrdContinuous.mono
code: theorem mono (hf : RightOrdContinuous f) : Monotone f 
goal: Monotone f

full_name: RightOrdContinuous.comp
code: theorem comp (hg : RightOrdContinuous g) (hf : RightOrdContinuous f) : RightOrdContinuous (g ∘ f) 
goal: RightOrdContinuous (g ∘ f)

full_name: RightOrdContinuous.iterate
code: protected theorem iterate {f : α → α} (hf : RightOrdContinuous f) (n : ℕ) :
    RightOrdContinuous f^[n] 
goal: RightOrdContinuous f^[n]

full_name: RightOrdContinuous.map_inf
code: theorem map_inf (hf : RightOrdContinuous f) (x y : α) : f (x ⊓ y) = f x ⊓ f y 
goal: f (x ⊓ y) = f x ⊓ f y

full_name: RightOrdContinuous.le_iff
code: theorem le_iff (hf : RightOrdContinuous f) (h : Injective f) {x y} : f x ≤ f y ↔ x ≤ y 
goal: f x ≤ f y ↔ x ≤ y

full_name: RightOrdContinuous.lt_iff
code: theorem lt_iff (hf : RightOrdContinuous f) (h : Injective f) {x y} : f x < f y ↔ x < y 
goal: f x < f y ↔ x < y

full_name: RightOrdContinuous.toOrderEmbedding
code: /-- Convert an injective left order continuous function to an `OrderEmbedding`. -/
def toOrderEmbedding (hf : RightOrdContinuous f) (h : Injective f) : α ↪o β 
goal: α ↪o β

full_name: RightOrdContinuous.coe_toOrderEmbedding
code: @[simp]
theorem coe_toOrderEmbedding (hf : RightOrdContinuous f) (h : Injective f) :
    ⇑(hf.toOrderEmbedding f h) = f 
goal: ⇑(RightOrdContinuous.toOrderEmbedding f hf h) = f

full_name: RightOrdContinuous.map_sInf'
code: theorem map_sInf' (hf : RightOrdContinuous f) (s : Set α) : f (sInf s) = sInf (f '' s) 
goal: f (sInf s) = sInf (f '' s)

full_name: RightOrdContinuous.map_sInf
code: theorem map_sInf (hf : RightOrdContinuous f) (s : Set α) : f (sInf s) = ⨅ x ∈ s, f x 
goal: f (sInf s) = ⨅ x ∈ s, f x

full_name: RightOrdContinuous.map_iInf
code: theorem map_iInf (hf : RightOrdContinuous f) (g : ι → α) : f (⨅ i, g i) = ⨅ i, f (g i) 
goal: f (⨅ i, g i) = ⨅ i, f (g i)

full_name: RightOrdContinuous.map_csInf
code: theorem map_csInf (hf : RightOrdContinuous f) {s : Set α} (sne : s.Nonempty) (sbdd : BddBelow s) :
    f (sInf s) = sInf (f '' s) 
goal: f (sInf s) = sInf (f '' s)

full_name: RightOrdContinuous.map_ciInf
code: theorem map_ciInf (hf : RightOrdContinuous f) {g : ι → α} (hg : BddBelow (range g)) :
    f (⨅ i, g i) = ⨅ i, f (g i) 
goal: f (⨅ i, g i) = ⨅ i, f (g i)

full_name: OrderIso.leftOrdContinuous
code: protected theorem leftOrdContinuous : LeftOrdContinuous e 
goal: LeftOrdContinuous ⇑e

full_name: OrderIso.rightOrdContinuous
code: protected theorem rightOrdContinuous : RightOrdContinuous e 
goal: RightOrdContinuous ⇑e