File: Mathlib/Order/Hom/Basic.lean

full_name: OrderHom.monotone'
code: /-- Bundled monotone (aka, increasing) function -/
structure OrderHom (α β : Type*) [Preorder α] [Preorder β] where
  /-- The underlying function of an `OrderHom`. -/
  toFun : α → β
  /-- The underlying function of an `OrderHom` is monotone. -/
  monotone' : Monotone toFun
goal: Monotone self.toFun

full_name: OrderHom.toFun
code: /-- Bundled monotone (aka, increasing) function -/
structure OrderHom (α β : Type*) [Preorder α] [Preorder β] where
  /-- The underlying function of an `OrderHom`. -/
  toFun : α → β
  /-- The underlying function of an `OrderHom` is monotone. -/
  monotone' : Monotone toFun
goal: α → β

full_name: OrderHom
code: /-- Bundled monotone (aka, increasing) function -/
structure OrderHom (α β : Type*) [Preorder α] [Preorder β] where
  /-- The underlying function of an `OrderHom`. -/
  toFun : α → β
  /-- The underlying function of an `OrderHom` is monotone. -/
  monotone' : Monotone toFun
goal: Type (max u_6 u_7)

full_name: «_aux_Mathlib_Order_Hom_Basic___macroRules_term_→o__1»
code: /-- Notation for an `OrderHom`. -/
infixr:25 " →o " => OrderHom
goal: Lean.Macro

full_name: _aux_Mathlib_Order_Hom_Basic___unexpand_OrderHom_1
code: /-- Notation for an `OrderHom`. -/
infixr:25 " →o " => OrderHom
goal: Lean.PrettyPrinter.Unexpander

full_name: OrderEmbedding
code: /-- An order embedding is an embedding `f : α ↪ β` such that `a ≤ b ↔ (f a) ≤ (f b)`.
This definition is an abbreviation of `RelEmbedding (≤) (≤)`. -/
abbrev OrderEmbedding (α β : Type*) [LE α] [LE β] 
goal: Type (max u_6 u_7)

full_name: «_aux_Mathlib_Order_Hom_Basic___macroRules_term_↪o__1»
code: /-- Notation for an `OrderEmbedding`. -/
infixl:25 " ↪o " => OrderEmbedding
goal: Lean.Macro

full_name: _aux_Mathlib_Order_Hom_Basic___unexpand_OrderEmbedding_1
code: /-- Notation for an `OrderEmbedding`. -/
infixl:25 " ↪o " => OrderEmbedding
goal: Lean.PrettyPrinter.Unexpander

full_name: OrderIso
code: /-- An order isomorphism is an equivalence such that `a ≤ b ↔ (f a) ≤ (f b)`.
This definition is an abbreviation of `RelIso (≤) (≤)`. -/
abbrev OrderIso (α β : Type*) [LE α] [LE β] 
goal: Type (max u_6 u_7)

full_name: _aux_Mathlib_Order_Hom_Basic___unexpand_OrderIso_1
code: /-- Notation for an `OrderIso`. -/
infixl:25 " ≃o " => OrderIso
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Order_Hom_Basic___macroRules_term_≃o__1»
code: /-- Notation for an `OrderIso`. -/
infixl:25 " ≃o " => OrderIso
goal: Lean.Macro

full_name: OrderHomClass
code: /-- `OrderHomClass F α b` asserts that `F` is a type of `≤`-preserving morphisms. -/
abbrev OrderHomClass (F : Type*) (α β : outParam Type*) [LE α] [LE β] [FunLike F α β] 
goal: Prop

full_name: OrderIsoClass.map_le_map_iff
code: /-- `OrderIsoClass F α β` states that `F` is a type of order isomorphisms.

You should extend this class when you extend `OrderIso`. -/
class OrderIsoClass (F α β : Type*) [LE α] [LE β] [EquivLike F α β] : Prop where
  /-- An order isomorphism respects `≤`. -/
  map_le_map_iff (f : F) {a b : α} : f a ≤ f b ↔ a ≤ b
goal: f a ≤ f b ↔ a ≤ b

full_name: OrderIsoClass
code: /-- `OrderIsoClass F α β` states that `F` is a type of order isomorphisms.

You should extend this class when you extend `OrderIso`. -/
class OrderIsoClass (F α β : Type*) [LE α] [LE β] [EquivLike F α β] : Prop where
  /-- An order isomorphism respects `≤`. -/
  map_le_map_iff (f : F) {a b : α} : f a ≤ f b ↔ a ≤ b
goal: Prop

full_name: OrderIsoClass.toOrderIso
code: /-- Turn an element of a type `F` satisfying `OrderIsoClass F α β` into an actual
`OrderIso`. This is declared as the default coercion from `F` to `α ≃o β`. -/
@[coe]
def OrderIsoClass.toOrderIso [LE α] [LE β] [EquivLike F α β] [OrderIsoClass F α β] (f : F) :
    α ≃o β 
goal: α ≃o β

full_name: instCoeTCOrderIsoOfOrderIsoClass
code: /-- Any type satisfying `OrderIsoClass` can be cast into `OrderIso` via
`OrderIsoClass.toOrderIso`. -/
instance [LE α] [LE β] [EquivLike F α β] [OrderIsoClass F α β] : CoeTC F (α ≃o β) 
goal: CoeTC F (α ≃o β)

full_name: OrderIsoClass.toOrderHomClass
code: instance (priority := 100) OrderIsoClass.toOrderHomClass [LE α] [LE β]
    [EquivLike F α β] [OrderIsoClass F α β] : OrderHomClass F α β 
goal: OrderHomClass F α β

full_name: OrderHomClass.monotone
code: protected theorem monotone (f : F) : Monotone f 
goal: Monotone ⇑f

full_name: OrderHomClass.mono
code: protected theorem mono (f : F) : Monotone f 
goal: Monotone ⇑f

full_name: OrderHomClass.toOrderHom
code: /-- Turn an element of a type `F` satisfying `OrderHomClass F α β` into an actual
`OrderHom`. This is declared as the default coercion from `F` to `α →o β`. -/
@[coe]
def toOrderHom (f : F) : α →o β 
goal: α →o β

full_name: OrderHomClass.instCoeTCOrderHom
code: /-- Any type satisfying `OrderHomClass` can be cast into `OrderHom` via
`OrderHomClass.toOrderHom`. -/
instance : CoeTC F (α →o β) 
goal: CoeTC F (α →o β)

full_name: map_inv_le_iff
code: @[simp]
theorem map_inv_le_iff (f : F) {a : α} {b : β} : EquivLike.inv f b ≤ a ↔ b ≤ f a 
goal: EquivLike.inv f b ≤ a ↔ b ≤ f a

full_name: le_map_inv_iff
code: @[simp]
theorem le_map_inv_iff (f : F) {a : α} {b : β} : a ≤ EquivLike.inv f b ↔ f a ≤ b 
goal: a ≤ EquivLike.inv f b ↔ f a ≤ b

full_name: map_lt_map_iff
code: theorem map_lt_map_iff (f : F) {a b : α} : f a < f b ↔ a < b 
goal: f a < f b ↔ a < b

full_name: map_inv_lt_iff
code: @[simp]
theorem map_inv_lt_iff (f : F) {a : α} {b : β} : EquivLike.inv f b < a ↔ b < f a 
goal: EquivLike.inv f b < a ↔ b < f a

full_name: lt_map_inv_iff
code: @[simp]
theorem lt_map_inv_iff (f : F) {a : α} {b : β} : a < EquivLike.inv f b ↔ f a < b 
goal: a < EquivLike.inv f b ↔ f a < b

full_name: OrderHom.instFunLike
code: instance : FunLike (α →o β) α β 
goal: FunLike (α →o β) α β

full_name: OrderHom.instOrderHomClass
code: instance : OrderHomClass (α →o β) α β 
goal: OrderHomClass (α →o β) α β

full_name: OrderHom.coe_mk
code: @[simp] theorem coe_mk (f : α → β) (hf : Monotone f) : ⇑(mk f hf) = f 
goal: ⇑{ toFun := f, monotone' := hf } = f

full_name: OrderHom.monotone
code: protected theorem monotone (f : α →o β) : Monotone f 
goal: Monotone ⇑f

full_name: OrderHom.mono
code: protected theorem mono (f : α →o β) : Monotone f 
goal: Monotone ⇑f

full_name: OrderHom.Simps.coe
code: /-- See Note [custom simps projection]. We give this manually so that we use `toFun` as the
projection directly instead. -/
def Simps.coe (f : α →o β) : α → β 
goal: α → β

full_name: OrderHom.toFun_eq_coe
code: @[simp] theorem toFun_eq_coe (f : α →o β) : f.toFun = f 
goal: f.toFun = ⇑f

full_name: OrderHom.ext
code: @[ext]
theorem ext (f g : α →o β) (h : (f : α → β) = g) : f = g 
goal: f = g

full_name: OrderHom.coe_eq
code: @[simp] theorem coe_eq (f : α →o β) : OrderHomClass.toOrderHom f = f 
goal: ↑f = f

full_name: OrderHomClass.coe_coe
code: @[simp] theorem _root_.OrderHomClass.coe_coe {F} [FunLike F α β] [OrderHomClass F α β] (f : F) :
    ⇑(f : α →o β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderHom.canLift
code: /-- One can lift an unbundled monotone function to a bundled one. -/
protected instance canLift : CanLift (α → β) (α →o β) (↑) Monotone 
goal: CanLift (α → β) (α →o β) DFunLike.coe Monotone

full_name: OrderHom.copy
code: /-- Copy of an `OrderHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
protected def copy (f : α →o β) (f' : α → β) (h : f' = f) : α →o β 
goal: α →o β

full_name: OrderHom.coe_copy
code: @[simp]
theorem coe_copy (f : α →o β) (f' : α → β) (h : f' = f) : (f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: OrderHom.copy_eq
code: theorem copy_eq (f : α →o β) (f' : α → β) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: OrderHom.id_coe
code: /-- The identity function as bundled monotone function. -/
@[simps (config := .asFn)]
def id : α →o α 
goal: ⇑OrderHom.id = id

full_name: OrderHom.id
code: /-- The identity function as bundled monotone function. -/
@[simps (config := .asFn)]
def id : α →o α 
goal: α →o α

full_name: OrderHom.instInhabited
code: instance : Inhabited (α →o α) 
goal: Inhabited (α →o α)

full_name: OrderHom.instPreorder
code: /-- The preorder structure of `α →o β` is pointwise inequality: `f ≤ g ↔ ∀ a, f a ≤ g a`. -/
instance : Preorder (α →o β) 
goal: Preorder (α →o β)

full_name: OrderHom.instPartialOrder
code: instance {β : Type*} [PartialOrder β] : PartialOrder (α →o β) 
goal: PartialOrder (α →o β)

full_name: OrderHom.le_def
code: theorem le_def {f g : α →o β} : f ≤ g ↔ ∀ x, f x ≤ g x 
goal: f ≤ g ↔ ∀ (x : α), f x ≤ g x

full_name: OrderHom.coe_le_coe
code: @[simp, norm_cast]
theorem coe_le_coe {f g : α →o β} : (f : α → β) ≤ g ↔ f ≤ g 
goal: ⇑f ≤ ⇑g ↔ f ≤ g

full_name: OrderHom.mk_le_mk
code: @[simp]
theorem mk_le_mk {f g : α → β} {hf hg} : mk f hf ≤ mk g hg ↔ f ≤ g 
goal: { toFun := f, monotone' := hf } ≤ { toFun := g, monotone' := hg } ↔ f ≤ g

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

full_name: OrderHom.curry
code: /-- Curry/uncurry as an order isomorphism between `α × β →o γ` and `α →o β →o γ`. -/
def curry : (α × β →o γ) ≃o (α →o β →o γ) 
goal: (α × β →o γ) ≃o (α →o β →o γ)

full_name: OrderHom.curry_apply
code: @[simp]
theorem curry_apply (f : α × β →o γ) (x : α) (y : β) : curry f x y = f (x, y) 
goal: ((OrderHom.curry f) x) y = f (x, y)

full_name: OrderHom.curry_symm_apply
code: @[simp]
theorem curry_symm_apply (f : α →o β →o γ) (x : α × β) : curry.symm f x = f x.1 x.2 
goal: ((RelIso.symm OrderHom.curry) f) x = (f x.1) x.2

full_name: OrderHom.comp
code: /-- The composition of two bundled monotone functions. -/
@[simps (config := .asFn)]
def comp (g : β →o γ) (f : α →o β) : α →o γ 
goal: α →o γ

full_name: OrderHom.comp_coe
code: /-- The composition of two bundled monotone functions. -/
@[simps (config := .asFn)]
def comp (g : β →o γ) (f : α →o β) : α →o γ 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: OrderHom.comp_mono
code: @[mono]
theorem comp_mono ⦃g₁ g₂ : β →o γ⦄ (hg : g₁ ≤ g₂) ⦃f₁ f₂ : α →o β⦄ (hf : f₁ ≤ f₂) :
    g₁.comp f₁ ≤ g₂.comp f₂ 
goal: g₁.comp f₁ ≤ g₂.comp f₂

full_name: OrderHom.mk_comp_mk
code: @[simp] lemma mk_comp_mk (g : β → γ) (f : α → β) (hg hf) :
    comp ⟨g, hg⟩ ⟨f, hf⟩ = ⟨g ∘ f, hg.comp hf⟩ 
goal: { toFun := g, monotone' := hg }.comp { toFun := f, monotone' := hf } = { toFun := g ∘ f, monotone' := ⋯ }

full_name: OrderHom.compₘ_coe_coe_coe
code: /-- The composition of two bundled monotone functions, a fully bundled version. -/
@[simps! (config := .asFn)]
def compₘ : (β →o γ) →o (α →o β) →o α →o γ 
goal: ∀ (a : α →o β), ⇑((OrderHom.compₘ x) a) = ⇑x ∘ ⇑a

full_name: OrderHom.compₘ
code: /-- The composition of two bundled monotone functions, a fully bundled version. -/
@[simps! (config := .asFn)]
def compₘ : (β →o γ) →o (α →o β) →o α →o γ 
goal: (β →o γ) →o (α →o β) →o α →o γ

full_name: OrderHom.comp_id
code: @[simp]
theorem comp_id (f : α →o β) : comp f id = f 
goal: f.comp OrderHom.id = f

full_name: OrderHom.id_comp
code: @[simp]
theorem id_comp (f : α →o β) : comp id f = f 
goal: OrderHom.id.comp f = f

full_name: OrderHom.const
code: /-- Constant function bundled as an `OrderHom`. -/
@[simps (config := .asFn)]
def const (α : Type*) [Preorder α] {β : Type*} [Preorder β] : β →o α →o β 
goal: β →o α →o β

full_name: OrderHom.const_coe_coe
code: /-- Constant function bundled as an `OrderHom`. -/
@[simps (config := .asFn)]
def const (α : Type*) [Preorder α] {β : Type*} [Preorder β] : β →o α →o β 
goal: ⇑((OrderHom.const α) b) = Function.const α b

full_name: OrderHom.const_comp
code: @[simp]
theorem const_comp (f : α →o β) (c : γ) : (const β c).comp f = const α c 
goal: ((OrderHom.const β) c).comp f = (OrderHom.const α) c

full_name: OrderHom.comp_const
code: @[simp]
theorem comp_const (γ : Type*) [Preorder γ] (f : α →o β) (c : α) :
    f.comp (const γ c) = const γ (f c) 
goal: f.comp ((OrderHom.const γ) c) = (OrderHom.const γ) (f c)

full_name: OrderHom.prod
code: /-- Given two bundled monotone maps `f`, `g`, `f.prod g` is the map `x ↦ (f x, g x)` bundled as a
`OrderHom`. -/
@[simps]
protected def prod (f : α →o β) (g : α →o γ) : α →o β × γ 
goal: α →o β × γ

full_name: OrderHom.prod_coe
code: /-- Given two bundled monotone maps `f`, `g`, `f.prod g` is the map `x ↦ (f x, g x)` bundled as a
`OrderHom`. -/
@[simps]
protected def prod (f : α →o β) (g : α →o γ) : α →o β × γ 
goal: (f.prod g) x = (f x, g x)

full_name: OrderHom.prod_mono
code: @[mono]
theorem prod_mono {f₁ f₂ : α →o β} (hf : f₁ ≤ f₂) {g₁ g₂ : α →o γ} (hg : g₁ ≤ g₂) :
    f₁.prod g₁ ≤ f₂.prod g₂ 
goal: f₁.prod g₁ ≤ f₂.prod g₂

full_name: OrderHom.comp_prod_comp_same
code: theorem comp_prod_comp_same (f₁ f₂ : β →o γ) (g : α →o β) :
    (f₁.comp g).prod (f₂.comp g) = (f₁.prod f₂).comp g 
goal: (f₁.comp g).prod (f₂.comp g) = (f₁.prod f₂).comp g

full_name: OrderHom.prodₘ_coe_coe_coe
code: /-- Given two bundled monotone maps `f`, `g`, `f.prod g` is the map `x ↦ (f x, g x)` bundled as a
`OrderHom`. This is a fully bundled version. -/
@[simps!]
def prodₘ : (α →o β) →o (α →o γ) →o α →o β × γ 
goal: ∀ (a : α →o γ) (x_1 : α), ((OrderHom.prodₘ x) a) x_1 = (x x_1, a x_1)

full_name: OrderHom.prodₘ
code: /-- Given two bundled monotone maps `f`, `g`, `f.prod g` is the map `x ↦ (f x, g x)` bundled as a
`OrderHom`. This is a fully bundled version. -/
@[simps!]
def prodₘ : (α →o β) →o (α →o γ) →o α →o β × γ 
goal: (α →o β) →o (α →o γ) →o α →o β × γ

full_name: OrderHom.diag_coe
code: /-- Diagonal embedding of `α` into `α × α` as an `OrderHom`. -/
@[simps!]
def diag : α →o α × α 
goal: OrderHom.diag x = (x, x)

full_name: OrderHom.diag
code: /-- Diagonal embedding of `α` into `α × α` as an `OrderHom`. -/
@[simps!]
def diag : α →o α × α 
goal: α →o α × α

full_name: OrderHom.onDiag_coe
code: /-- Restriction of `f : α →o α →o β` to the diagonal. -/
@[simps! (config := { simpRhs := true })]
def onDiag (f : α →o α →o β) : α →o β 
goal: ∀ (a : α), f.onDiag a = (f a) a

full_name: OrderHom.onDiag
code: /-- Restriction of `f : α →o α →o β` to the diagonal. -/
@[simps! (config := { simpRhs := true })]
def onDiag (f : α →o α →o β) : α →o β 
goal: α →o β

full_name: OrderHom.fst
code: /-- `Prod.fst` as an `OrderHom`. -/
@[simps]
def fst : α × β →o α 
goal: α × β →o α

full_name: OrderHom.fst_coe
code: /-- `Prod.fst` as an `OrderHom`. -/
@[simps]
def fst : α × β →o α 
goal: OrderHom.fst self = self.1

full_name: OrderHom.snd
code: /-- `Prod.snd` as an `OrderHom`. -/
@[simps]
def snd : α × β →o β 
goal: α × β →o β

full_name: OrderHom.snd_coe
code: /-- `Prod.snd` as an `OrderHom`. -/
@[simps]
def snd : α × β →o β 
goal: OrderHom.snd self = self.2

full_name: OrderHom.fst_prod_snd
code: @[simp]
theorem fst_prod_snd : (fst : α × β →o α).prod snd = id 
goal: OrderHom.fst.prod OrderHom.snd = OrderHom.id

full_name: OrderHom.fst_comp_prod
code: @[simp]
theorem fst_comp_prod (f : α →o β) (g : α →o γ) : fst.comp (f.prod g) = f 
goal: OrderHom.fst.comp (f.prod g) = f

full_name: OrderHom.snd_comp_prod
code: @[simp]
theorem snd_comp_prod (f : α →o β) (g : α →o γ) : snd.comp (f.prod g) = g 
goal: OrderHom.snd.comp (f.prod g) = g

full_name: OrderHom.prodIso_apply
code: /-- Order isomorphism between the space of monotone maps to `β × γ` and the product of the spaces
of monotone maps to `β` and `γ`. -/
@[simps]
def prodIso : (α →o β × γ) ≃o (α →o β) × (α →o γ) 
goal: OrderHom.prodIso f = (OrderHom.fst.comp f, OrderHom.snd.comp f)

full_name: OrderHom.prodIso_symm_apply
code: /-- Order isomorphism between the space of monotone maps to `β × γ` and the product of the spaces
of monotone maps to `β` and `γ`. -/
@[simps]
def prodIso : (α →o β × γ) ≃o (α →o β) × (α →o γ) 
goal: (RelIso.symm OrderHom.prodIso) f = f.1.prod f.2

full_name: OrderHom.prodIso
code: /-- Order isomorphism between the space of monotone maps to `β × γ` and the product of the spaces
of monotone maps to `β` and `γ`. -/
@[simps]
def prodIso : (α →o β × γ) ≃o (α →o β) × (α →o γ) 
goal: (α →o β × γ) ≃o (α →o β) × (α →o γ)

full_name: OrderHom.prodMap_coe
code: /-- `Prod.map` of two `OrderHom`s as an `OrderHom`. -/
@[simps]
def prodMap (f : α →o β) (g : γ →o δ) : α × γ →o β × δ 
goal: ∀ (a : α × γ), (f.prodMap g) a = Prod.map (⇑f) (⇑g) a

full_name: OrderHom.prodMap
code: /-- `Prod.map` of two `OrderHom`s as an `OrderHom`. -/
@[simps]
def prodMap (f : α →o β) (g : γ →o δ) : α × γ →o β × δ 
goal: α × γ →o β × δ

full_name: Pi.evalOrderHom
code: /-- Evaluation of an unbundled function at a point (`Function.eval`) as an `OrderHom`. -/
@[simps (config := .asFn)]
def _root_.Pi.evalOrderHom (i : ι) : (∀ j, π j) →o π i 
goal: ((j : ι) → π j) →o π i

full_name: Pi.evalOrderHom_coe
code: /-- Evaluation of an unbundled function at a point (`Function.eval`) as an `OrderHom`. -/
@[simps (config := .asFn)]
def _root_.Pi.evalOrderHom (i : ι) : (∀ j, π j) →o π i 
goal: ⇑(Pi.evalOrderHom i) = Function.eval i

full_name: OrderHom.coeFnHom
code: /-- The "forgetful functor" from `α →o β` to `α → β` that takes the underlying function,
is monotone. -/
@[simps (config := .asFn)]
def coeFnHom : (α →o β) →o α → β 
goal: (α →o β) →o α → β

full_name: OrderHom.coeFnHom_coe
code: /-- The "forgetful functor" from `α →o β` to `α → β` that takes the underlying function,
is monotone. -/
@[simps (config := .asFn)]
def coeFnHom : (α →o β) →o α → β 
goal: ⇑OrderHom.coeFnHom = fun f => ⇑f

full_name: OrderHom.apply
code: /-- Function application `fun f => f a` (for fixed `a`) is a monotone function from the
monotone function space `α →o β` to `β`. See also `Pi.evalOrderHom`.  -/
@[simps! (config := .asFn)]
def apply (x : α) : (α →o β) →o β 
goal: (α →o β) →o β

full_name: OrderHom.apply_coe
code: /-- Function application `fun f => f a` (for fixed `a`) is a monotone function from the
monotone function space `α →o β` to `β`. See also `Pi.evalOrderHom`.  -/
@[simps! (config := .asFn)]
def apply (x : α) : (α →o β) →o β 
goal: ⇑(OrderHom.apply x) = Function.eval x ∘ fun f => ⇑f

full_name: OrderHom.pi_coe
code: /-- Construct a bundled monotone map `α →o Π i, π i` from a family of monotone maps
`f i : α →o π i`. -/
@[simps]
def pi (f : ∀ i, α →o π i) : α →o ∀ i, π i 
goal: (OrderHom.pi f) x i = (f i) x

full_name: OrderHom.pi
code: /-- Construct a bundled monotone map `α →o Π i, π i` from a family of monotone maps
`f i : α →o π i`. -/
@[simps]
def pi (f : ∀ i, α →o π i) : α →o ∀ i, π i 
goal: α →o (i : ι) → π i

full_name: OrderHom.piIso_apply
code: /-- Order isomorphism between bundled monotone maps `α →o Π i, π i` and families of bundled monotone
maps `Π i, α →o π i`. -/
@[simps]
def piIso : (α →o ∀ i, π i) ≃o ∀ i, α →o π i 
goal: OrderHom.piIso f i = (Pi.evalOrderHom i).comp f

full_name: OrderHom.piIso
code: /-- Order isomorphism between bundled monotone maps `α →o Π i, π i` and families of bundled monotone
maps `Π i, α →o π i`. -/
@[simps]
def piIso : (α →o ∀ i, π i) ≃o ∀ i, α →o π i 
goal: (α →o (i : ι) → π i) ≃o ((i : ι) → α →o π i)

full_name: OrderHom.piIso_symm_apply
code: /-- Order isomorphism between bundled monotone maps `α →o Π i, π i` and families of bundled monotone
maps `Π i, α →o π i`. -/
@[simps]
def piIso : (α →o ∀ i, π i) ≃o ∀ i, α →o π i 
goal: (RelIso.symm OrderHom.piIso) f = OrderHom.pi f

full_name: OrderHom.Subtype.val
code: /-- `Subtype.val` as a bundled monotone function.  -/
@[simps (config := .asFn)]
def Subtype.val (p : α → Prop) : Subtype p →o α 
goal: Subtype p →o α

full_name: OrderHom.Subtype.val_coe
code: /-- `Subtype.val` as a bundled monotone function.  -/
@[simps (config := .asFn)]
def Subtype.val (p : α → Prop) : Subtype p →o α 
goal: ⇑(OrderHom.Subtype.val p) = Subtype.val

full_name: Subtype.orderEmbedding_apply_coe
code: /-- `Subtype.impEmbedding` as an order embedding. -/
@[simps!]
def _root_.Subtype.orderEmbedding {p q : α → Prop} (h : ∀ a, p a → q a) :
    {x // p x} ↪o {x // q x} 
goal: ↑((Subtype.orderEmbedding h) x) = ↑x

full_name: Subtype.orderEmbedding
code: /-- `Subtype.impEmbedding` as an order embedding. -/
@[simps!]
def _root_.Subtype.orderEmbedding {p q : α → Prop} (h : ∀ a, p a → q a) :
    {x // p x} ↪o {x // q x} 
goal: { x // p x } ↪o { x // q x }

full_name: OrderHom.unique
code: /-- There is a unique monotone map from a subsingleton to itself. -/
instance unique [Subsingleton α] : Unique (α →o α) 
goal: Unique (α →o α)

full_name: OrderHom.orderHom_eq_id
code: theorem orderHom_eq_id [Subsingleton α] (g : α →o α) : g = OrderHom.id 
goal: g = OrderHom.id

full_name: OrderHom.dual
code: /-- Reinterpret a bundled monotone function as a monotone function between dual orders. -/
@[simps]
protected def dual : (α →o β) ≃ (αᵒᵈ →o βᵒᵈ) 
goal: (α →o β) ≃ (αᵒᵈ →o βᵒᵈ)

full_name: OrderHom.dual_symm_apply_coe
code: /-- Reinterpret a bundled monotone function as a monotone function between dual orders. -/
@[simps]
protected def dual : (α →o β) ≃ (αᵒᵈ →o βᵒᵈ) 
goal: ∀ (a : α), (OrderHom.dual.symm f) a = (⇑OrderDual.ofDual ∘ ⇑f ∘ ⇑OrderDual.toDual) a

full_name: OrderHom.dual_apply_coe
code: /-- Reinterpret a bundled monotone function as a monotone function between dual orders. -/
@[simps]
protected def dual : (α →o β) ≃ (αᵒᵈ →o βᵒᵈ) 
goal: ∀ (a : αᵒᵈ), (OrderHom.dual f) a = (⇑OrderDual.toDual ∘ ⇑f ∘ ⇑OrderDual.ofDual) a

full_name: OrderHom.dual_id
code: @[simp]
theorem dual_id : OrderHom.dual (OrderHom.id : α →o α) = OrderHom.id 
goal: OrderHom.dual OrderHom.id = OrderHom.id

full_name: OrderHom.dual_comp
code: @[simp]
theorem dual_comp (g : β →o γ) (f : α →o β) :
    OrderHom.dual (g.comp f) = (OrderHom.dual g).comp (OrderHom.dual f) 
goal: OrderHom.dual (g.comp f) = (OrderHom.dual g).comp (OrderHom.dual f)

full_name: OrderHom.symm_dual_id
code: @[simp]
theorem symm_dual_id : OrderHom.dual.symm OrderHom.id = (OrderHom.id : α →o α) 
goal: OrderHom.dual.symm OrderHom.id = OrderHom.id

full_name: OrderHom.symm_dual_comp
code: @[simp]
theorem symm_dual_comp (g : βᵒᵈ →o γᵒᵈ) (f : αᵒᵈ →o βᵒᵈ) :
    OrderHom.dual.symm (g.comp f) = (OrderHom.dual.symm g).comp (OrderHom.dual.symm f) 
goal: OrderHom.dual.symm (g.comp f) = (OrderHom.dual.symm g).comp (OrderHom.dual.symm f)

full_name: OrderHom.dualIso
code: /-- `OrderHom.dual` as an order isomorphism. -/
def dualIso (α β : Type*) [Preorder α] [Preorder β] : (α →o β) ≃o (αᵒᵈ →o βᵒᵈ)ᵒᵈ 
goal: (α →o β) ≃o (αᵒᵈ →o βᵒᵈ)ᵒᵈ

full_name: OrderHom.withBotMap_coe
code: /-- Lift an order homomorphism `f : α →o β` to an order homomorphism `WithBot α →o WithBot β`. -/
@[simps (config := .asFn)]
protected def withBotMap (f : α →o β) : WithBot α →o WithBot β 
goal: ⇑f.withBotMap = WithBot.map ⇑f

full_name: OrderHom.withBotMap
code: /-- Lift an order homomorphism `f : α →o β` to an order homomorphism `WithBot α →o WithBot β`. -/
@[simps (config := .asFn)]
protected def withBotMap (f : α →o β) : WithBot α →o WithBot β 
goal: WithBot α →o WithBot β

full_name: OrderHom.withTopMap
code: /-- Lift an order homomorphism `f : α →o β` to an order homomorphism `WithTop α →o WithTop β`. -/
@[simps (config := .asFn)]
protected def withTopMap (f : α →o β) : WithTop α →o WithTop β 
goal: WithTop α →o WithTop β

full_name: OrderHom.withTopMap_coe
code: /-- Lift an order homomorphism `f : α →o β` to an order homomorphism `WithTop α →o WithTop β`. -/
@[simps (config := .asFn)]
protected def withTopMap (f : α →o β) : WithTop α →o WithTop β 
goal: ⇑f.withTopMap = WithTop.map ⇑f

full_name: RelEmbedding.orderEmbeddingOfLTEmbedding
code: /-- Embeddings of partial orders that preserve `<` also preserve `≤`. -/
def RelEmbedding.orderEmbeddingOfLTEmbedding [PartialOrder α] [PartialOrder β]
    (f : ((· < ·) : α → α → Prop) ↪r ((· < ·) : β → β → Prop)) : α ↪o β 
goal: α ↪o β

full_name: RelEmbedding.orderEmbeddingOfLTEmbedding_apply
code: @[simp]
theorem RelEmbedding.orderEmbeddingOfLTEmbedding_apply [PartialOrder α] [PartialOrder β]
    {f : ((· < ·) : α → α → Prop) ↪r ((· < ·) : β → β → Prop)} {x : α} :
    RelEmbedding.orderEmbeddingOfLTEmbedding f x = f x 
goal: f.orderEmbeddingOfLTEmbedding x = f x

full_name: OrderEmbedding.ltEmbedding
code: /-- `<` is preserved by order embeddings of preorders. -/
def ltEmbedding : ((· < ·) : α → α → Prop) ↪r ((· < ·) : β → β → Prop) 
goal: (fun x x_1 => x < x_1) ↪r fun x x_1 => x < x_1

full_name: OrderEmbedding.ltEmbedding_apply
code: @[simp]
theorem ltEmbedding_apply (x : α) : f.ltEmbedding x = f x 
goal: f.ltEmbedding x = f x

full_name: OrderEmbedding.le_iff_le
code: @[simp]
theorem le_iff_le {a b} : f a ≤ f b ↔ a ≤ b 
goal: f a ≤ f b ↔ a ≤ b

full_name: OrderEmbedding.lt_iff_lt
code: @[simp]
theorem lt_iff_lt {a b} : f a < f b ↔ a < b 
goal: f a < f b ↔ a < b

full_name: OrderEmbedding.eq_iff_eq
code: theorem eq_iff_eq {a b} : f a = f b ↔ a = b 
goal: f a = f b ↔ a = b

full_name: OrderEmbedding.monotone
code: protected theorem monotone : Monotone f 
goal: Monotone ⇑f

full_name: OrderEmbedding.strictMono
code: protected theorem strictMono : StrictMono f 
goal: StrictMono ⇑f

full_name: OrderEmbedding.acc
code: protected theorem acc (a : α) : Acc (· < ·) (f a) → Acc (· < ·) a 
goal: Acc (fun x x_1 => x < x_1) (f a) → Acc (fun x x_1 => x < x_1) a

full_name: OrderEmbedding.wellFounded
code: protected theorem wellFounded (f : α ↪o β) :
    WellFounded ((· < ·) : β → β → Prop) → WellFounded ((· < ·) : α → α → Prop) 
goal: (WellFounded fun x x_1 => x < x_1) → WellFounded fun x x_1 => x < x_1

full_name: OrderEmbedding.isWellOrder
code: protected theorem isWellOrder [IsWellOrder β (· < ·)] (f : α ↪o β) : IsWellOrder α (· < ·) 
goal: IsWellOrder α fun x x_1 => x < x_1

full_name: OrderEmbedding.dual
code: /-- An order embedding is also an order embedding between dual orders. -/
protected def dual : αᵒᵈ ↪o βᵒᵈ 
goal: αᵒᵈ ↪o βᵒᵈ

full_name: OrderEmbedding.wellFoundedLT
code: /-- A preorder which embeds into a well-founded preorder is itself well-founded. -/
protected theorem wellFoundedLT [WellFoundedLT β] (f : α ↪o β) : WellFoundedLT α 
goal: WellFoundedLT α

full_name: OrderEmbedding.wellFoundedGT
code: /-- A preorder which embeds into a preorder in which `(· > ·)` is well-founded
also has `(· > ·)` well-founded. -/
protected theorem wellFoundedGT [WellFoundedGT β] (f : α ↪o β) : WellFoundedGT α 
goal: WellFoundedGT α

full_name: OrderEmbedding.withBotMap
code: /-- A version of `WithBot.map` for order embeddings. -/
@[simps (config := .asFn)]
protected def withBotMap (f : α ↪o β) : WithBot α ↪o WithBot β 
goal: WithBot α ↪o WithBot β

full_name: OrderEmbedding.withBotMap_apply
code: /-- A version of `WithBot.map` for order embeddings. -/
@[simps (config := .asFn)]
protected def withBotMap (f : α ↪o β) : WithBot α ↪o WithBot β 
goal: ⇑f.withBotMap = WithBot.map ⇑f

full_name: OrderEmbedding.withTopMap_apply
code: /-- A version of `WithTop.map` for order embeddings. -/
@[simps (config := .asFn)]
protected def withTopMap (f : α ↪o β) : WithTop α ↪o WithTop β 
goal: ⇑f.withTopMap = WithTop.map ⇑f

full_name: OrderEmbedding.withTopMap
code: /-- A version of `WithTop.map` for order embeddings. -/
@[simps (config := .asFn)]
protected def withTopMap (f : α ↪o β) : WithTop α ↪o WithTop β 
goal: WithTop α ↪o WithTop β

full_name: OrderEmbedding.ofMapLEIff
code: /-- To define an order embedding from a partial order to a preorder it suffices to give a function
together with a proof that it satisfies `f a ≤ f b ↔ a ≤ b`.
-/
def ofMapLEIff {α β} [PartialOrder α] [Preorder β] (f : α → β) (hf : ∀ a b, f a ≤ f b ↔ a ≤ b) :
    α ↪o β 
goal: α ↪o β

full_name: OrderEmbedding.coe_ofMapLEIff
code: @[simp]
theorem coe_ofMapLEIff {α β} [PartialOrder α] [Preorder β] {f : α → β} (h) :
    ⇑(ofMapLEIff f h) = f 
goal: ⇑(OrderEmbedding.ofMapLEIff f h) = f

full_name: OrderEmbedding.ofStrictMono
code: /-- A strictly monotone map from a linear order is an order embedding. -/
def ofStrictMono {α β} [LinearOrder α] [Preorder β] (f : α → β) (h : StrictMono f) : α ↪o β 
goal: α ↪o β

full_name: OrderEmbedding.coe_ofStrictMono
code: @[simp]
theorem coe_ofStrictMono {α β} [LinearOrder α] [Preorder β] {f : α → β} (h : StrictMono f) :
    ⇑(ofStrictMono f h) = f 
goal: ⇑(OrderEmbedding.ofStrictMono f h) = f

full_name: OrderEmbedding.subtype
code: /-- Embedding of a subtype into the ambient type as an `OrderEmbedding`. -/
@[simps! (config := .asFn)]
def subtype (p : α → Prop) : Subtype p ↪o α 
goal: Subtype p ↪o α

full_name: OrderEmbedding.subtype_apply
code: /-- Embedding of a subtype into the ambient type as an `OrderEmbedding`. -/
@[simps! (config := .asFn)]
def subtype (p : α → Prop) : Subtype p ↪o α 
goal: ⇑(OrderEmbedding.subtype p) = Subtype.val

full_name: OrderEmbedding.toOrderHom_coe
code: /-- Convert an `OrderEmbedding` to an `OrderHom`. -/
@[simps (config := .asFn)]
def toOrderHom {X Y : Type*} [Preorder X] [Preorder Y] (f : X ↪o Y) : X →o Y 
goal: ⇑f.toOrderHom = ⇑f

full_name: OrderEmbedding.toOrderHom
code: /-- Convert an `OrderEmbedding` to an `OrderHom`. -/
@[simps (config := .asFn)]
def toOrderHom {X Y : Type*} [Preorder X] [Preorder Y] (f : X ↪o Y) : X →o Y 
goal: X →o Y

full_name: OrderEmbedding.ofIsEmpty
code: /-- The trivial embedding from an empty preorder to another preorder -/
@[simps] def ofIsEmpty [IsEmpty α] : α ↪o β 
goal: α ↪o β

full_name: OrderEmbedding.ofIsEmpty_apply
code: /-- The trivial embedding from an empty preorder to another preorder -/
@[simps] def ofIsEmpty [IsEmpty α] : α ↪o β 
goal: OrderEmbedding.ofIsEmpty a = isEmptyElim a

full_name: OrderEmbedding.coe_ofIsEmpty
code: @[simp, norm_cast]
lemma coe_ofIsEmpty [IsEmpty α] : (ofIsEmpty : α ↪o β) = (isEmptyElim : α → β) 
goal: ⇑OrderEmbedding.ofIsEmpty = fun a => isEmptyElim a

full_name: Disjoint.of_orderEmbedding
code: /-- If the images by an order embedding of two elements are disjoint,
then they are themselves disjoint. -/
lemma Disjoint.of_orderEmbedding [OrderBot α] [OrderBot β] {a₁ a₂ : α} :
    Disjoint (f a₁) (f a₂) → Disjoint a₁ a₂ 
goal: Disjoint (f a₁) (f a₂) → Disjoint a₁ a₂

full_name: Codisjoint.of_orderEmbedding
code: /-- If the images by an order embedding of two elements are codisjoint,
then they are themselves codisjoint. -/
lemma Codisjoint.of_orderEmbedding [OrderTop α] [OrderTop β] {a₁ a₂ : α} :
    Codisjoint (f a₁) (f a₂) → Codisjoint a₁ a₂ 
goal: Codisjoint (f a₁) (f a₂) → Codisjoint a₁ a₂

full_name: IsCompl.of_orderEmbedding
code: /-- If the images by an order embedding of two elements are complements,
then they are themselves complements. -/
lemma IsCompl.of_orderEmbedding [BoundedOrder α] [BoundedOrder β] {a₁ a₂ : α} :
    IsCompl (f a₁) (f a₂) → IsCompl a₁ a₂ 
goal: IsCompl (f a₁) (f a₂) → IsCompl a₁ a₂

full_name: RelHom.toOrderHom_coe
code: /-- A bundled expression of the fact that a map between partial orders that is strictly monotone
is weakly monotone. -/
@[simps (config := .asFn)]
def toOrderHom : α →o β 
goal: ⇑f.toOrderHom = ⇑f

full_name: RelHom.toOrderHom
code: /-- A bundled expression of the fact that a map between partial orders that is strictly monotone
is weakly monotone. -/
@[simps (config := .asFn)]
def toOrderHom : α →o β 
goal: α →o β

full_name: RelEmbedding.toOrderHom_injective
code: theorem RelEmbedding.toOrderHom_injective
    (f : ((· < ·) : α → α → Prop) ↪r ((· < ·) : β → β → Prop)) :
    Function.Injective (f : ((· < ·) : α → α → Prop) →r ((· < ·) : β → β → Prop)).toOrderHom 
goal: Function.Injective ⇑f.toRelHom.toOrderHom

full_name: OrderIso.instEquivLike
code: instance : EquivLike (α ≃o β) α β 
goal: EquivLike (α ≃o β) α β

full_name: OrderIso.instOrderIsoClass
code: instance : OrderIsoClass (α ≃o β) α β 
goal: OrderIsoClass (α ≃o β) α β

full_name: OrderIso.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe {f : α ≃o β} : f.toFun = f 
goal: f.toFun = ⇑f

full_name: OrderIso.ext
code: @[ext]
theorem ext {f g : α ≃o β} (h : (f : α → β) = g) : f = g 
goal: f = g

full_name: OrderIso.toOrderEmbedding
code: /-- Reinterpret an order isomorphism as an order embedding. -/
def toOrderEmbedding (e : α ≃o β) : α ↪o β 
goal: α ↪o β

full_name: OrderIso.coe_toOrderEmbedding
code: @[simp]
theorem coe_toOrderEmbedding (e : α ≃o β) : ⇑e.toOrderEmbedding = e 
goal: ⇑e.toOrderEmbedding = ⇑e

full_name: OrderIso.bijective
code: protected theorem bijective (e : α ≃o β) : Function.Bijective e 
goal: Function.Bijective ⇑e

full_name: OrderIso.injective
code: protected theorem injective (e : α ≃o β) : Function.Injective e 
goal: Function.Injective ⇑e

full_name: OrderIso.surjective
code: protected theorem surjective (e : α ≃o β) : Function.Surjective e 
goal: Function.Surjective ⇑e

full_name: OrderIso.apply_eq_iff_eq
code: theorem apply_eq_iff_eq (e : α ≃o β) {x y : α} : e x = e y ↔ x = y 
goal: e x = e y ↔ x = y

full_name: OrderIso.refl
code: /-- Identity order isomorphism. -/
def refl (α : Type*) [LE α] : α ≃o α 
goal: α ≃o α

full_name: OrderIso.coe_refl
code: @[simp]
theorem coe_refl : ⇑(refl α) = id 
goal: ⇑(OrderIso.refl α) = id

full_name: OrderIso.refl_apply
code: @[simp]
theorem refl_apply (x : α) : refl α x = x 
goal: (OrderIso.refl α) x = x

full_name: OrderIso.refl_toEquiv
code: @[simp]
theorem refl_toEquiv : (refl α).toEquiv = Equiv.refl α 
goal: (OrderIso.refl α).toEquiv = Equiv.refl α

full_name: OrderIso.symm
code: /-- Inverse of an order isomorphism. -/
def symm (e : α ≃o β) : β ≃o α 
goal: β ≃o α

full_name: OrderIso.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (e : α ≃o β) (x : β) : e (e.symm x) = x 
goal: e (e.symm x) = x

full_name: OrderIso.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (e : α ≃o β) (x : α) : e.symm (e x) = x 
goal: e.symm (e x) = x

full_name: OrderIso.symm_refl
code: @[simp]
theorem symm_refl (α : Type*) [LE α] : (refl α).symm = refl α 
goal: (OrderIso.refl α).symm = OrderIso.refl α

full_name: OrderIso.apply_eq_iff_eq_symm_apply
code: theorem apply_eq_iff_eq_symm_apply (e : α ≃o β) (x : α) (y : β) : e x = y ↔ x = e.symm y 
goal: e x = y ↔ x = e.symm y

full_name: OrderIso.symm_apply_eq
code: theorem symm_apply_eq (e : α ≃o β) {x : α} {y : β} : e.symm y = x ↔ y = e x 
goal: e.symm y = x ↔ y = e x

full_name: OrderIso.symm_symm
code: @[simp]
theorem symm_symm (e : α ≃o β) : e.symm.symm = e 
goal: e.symm.symm = e

full_name: OrderIso.symm_bijective
code: theorem symm_bijective : Function.Bijective (OrderIso.symm : (α ≃o β) → β ≃o α) 
goal: Function.Bijective OrderIso.symm

full_name: OrderIso.symm_injective
code: theorem symm_injective : Function.Injective (symm : α ≃o β → β ≃o α) 
goal: Function.Injective OrderIso.symm

full_name: OrderIso.toEquiv_symm
code: @[simp]
theorem toEquiv_symm (e : α ≃o β) : e.toEquiv.symm = e.symm.toEquiv 
goal: e.symm = e.symm.toEquiv

full_name: OrderIso.trans
code: /-- Composition of two order isomorphisms is an order isomorphism. -/
@[trans]
def trans (e : α ≃o β) (e' : β ≃o γ) : α ≃o γ 
goal: α ≃o γ

full_name: OrderIso.coe_trans
code: @[simp]
theorem coe_trans (e : α ≃o β) (e' : β ≃o γ) : ⇑(e.trans e') = e' ∘ e 
goal: ⇑(e.trans e') = ⇑e' ∘ ⇑e

full_name: OrderIso.trans_apply
code: @[simp]
theorem trans_apply (e : α ≃o β) (e' : β ≃o γ) (x : α) : e.trans e' x = e' (e x) 
goal: (e.trans e') x = e' (e x)

full_name: OrderIso.refl_trans
code: @[simp]
theorem refl_trans (e : α ≃o β) : (refl α).trans e = e 
goal: (OrderIso.refl α).trans e = e

full_name: OrderIso.trans_refl
code: @[simp]
theorem trans_refl (e : α ≃o β) : e.trans (refl β) = e 
goal: e.trans (OrderIso.refl β) = e

full_name: OrderIso.symm_trans_apply
code: @[simp]
theorem symm_trans_apply (e₁ : α ≃o β) (e₂ : β ≃o γ) (c : γ) :
    (e₁.trans e₂).symm c = e₁.symm (e₂.symm c) 
goal: (e₁.trans e₂).symm c = e₁.symm (e₂.symm c)

full_name: OrderIso.symm_trans
code: theorem symm_trans (e₁ : α ≃o β) (e₂ : β ≃o γ) : (e₁.trans e₂).symm = e₂.symm.trans e₁.symm 
goal: (e₁.trans e₂).symm = e₂.symm.trans e₁.symm

full_name: OrderIso.self_trans_symm
code: @[simp]
theorem self_trans_symm (e : α ≃o β) : e.trans e.symm = OrderIso.refl α 
goal: e.trans e.symm = OrderIso.refl α

full_name: OrderIso.symm_trans_self
code: @[simp]
theorem symm_trans_self (e : α ≃o β) : e.symm.trans e = OrderIso.refl β 
goal: e.symm.trans e = OrderIso.refl β

full_name: OrderIso.arrowCongr_symm_apply
code: /-- An order isomorphism between the domains and codomains of two prosets of
order homomorphisms gives an order isomorphism between the two function prosets. -/
@[simps apply symm_apply]
def arrowCongr {α β γ δ} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ]
    (f : α ≃o γ) (g : β ≃o δ) : (α →o β) ≃o (γ →o δ) 
goal: (RelIso.symm (f.arrowCongr g)) p = (↑g.symm).comp (p.comp ↑f)

full_name: OrderIso.arrowCongr_apply
code: /-- An order isomorphism between the domains and codomains of two prosets of
order homomorphisms gives an order isomorphism between the two function prosets. -/
@[simps apply symm_apply]
def arrowCongr {α β γ δ} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ]
    (f : α ≃o γ) (g : β ≃o δ) : (α →o β) ≃o (γ →o δ) 
goal: (f.arrowCongr g) p = (↑g).comp (p.comp ↑f.symm)

full_name: OrderIso.arrowCongr
code: /-- An order isomorphism between the domains and codomains of two prosets of
order homomorphisms gives an order isomorphism between the two function prosets. -/
@[simps apply symm_apply]
def arrowCongr {α β γ δ} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ]
    (f : α ≃o γ) (g : β ≃o δ) : (α →o β) ≃o (γ →o δ) 
goal: (α →o β) ≃o (γ →o δ)

full_name: OrderIso.conj
code: /-- If `α` and `β` are order-isomorphic then the two orders of order-homomorphisms
from `α` and `β` to themselves are order-isomorphic. -/
@[simps! apply symm_apply]
def conj {α β} [Preorder α] [Preorder β] (f : α ≃o β) : (α →o α) ≃ (β →o β) 
goal: (α →o α) ≃ (β →o β)

full_name: OrderIso.conj_apply
code: /-- If `α` and `β` are order-isomorphic then the two orders of order-homomorphisms
from `α` and `β` to themselves are order-isomorphic. -/
@[simps! apply symm_apply]
def conj {α β} [Preorder α] [Preorder β] (f : α ≃o β) : (α →o α) ≃ (β →o β) 
goal: f.conj a = (↑f).comp (a.comp ↑f.symm)

full_name: OrderIso.conj_symm_apply
code: /-- If `α` and `β` are order-isomorphic then the two orders of order-homomorphisms
from `α` and `β` to themselves are order-isomorphic. -/
@[simps! apply symm_apply]
def conj {α β} [Preorder α] [Preorder β] (f : α ≃o β) : (α →o α) ≃ (β →o β) 
goal: ∀ (a : β →o β), f.conj.symm a = EquivLike.inv (f.arrowCongr f) a

full_name: OrderIso.prodComm
code: /-- `Prod.swap` as an `OrderIso`. -/
def prodComm : α × β ≃o β × α 
goal: α × β ≃o β × α

full_name: OrderIso.coe_prodComm
code: @[simp]
theorem coe_prodComm : ⇑(prodComm : α × β ≃o β × α) = Prod.swap 
goal: ⇑OrderIso.prodComm = Prod.swap

full_name: OrderIso.prodComm_symm
code: @[simp]
theorem prodComm_symm : (prodComm : α × β ≃o β × α).symm = prodComm 
goal: OrderIso.prodComm.symm = OrderIso.prodComm

full_name: OrderIso.dualDual
code: /-- The order isomorphism between a type and its double dual. -/
def dualDual : α ≃o αᵒᵈᵒᵈ 
goal: α ≃o αᵒᵈᵒᵈ

full_name: OrderIso.coe_dualDual
code: @[simp]
theorem coe_dualDual : ⇑(dualDual α) = toDual ∘ toDual 
goal: ⇑(OrderIso.dualDual α) = ⇑OrderDual.toDual ∘ ⇑OrderDual.toDual

full_name: OrderIso.coe_dualDual_symm
code: @[simp]
theorem coe_dualDual_symm : ⇑(dualDual α).symm = ofDual ∘ ofDual 
goal: ⇑(OrderIso.dualDual α).symm = ⇑OrderDual.ofDual ∘ ⇑OrderDual.ofDual

full_name: OrderIso.dualDual_apply
code: @[simp]
theorem dualDual_apply (a : α) : dualDual α a = toDual (toDual a) 
goal: (OrderIso.dualDual α) a = OrderDual.toDual (OrderDual.toDual a)

full_name: OrderIso.dualDual_symm_apply
code: @[simp]
theorem dualDual_symm_apply (a : αᵒᵈᵒᵈ) : (dualDual α).symm a = ofDual (ofDual a) 
goal: (OrderIso.dualDual α).symm a = OrderDual.ofDual (OrderDual.ofDual a)

full_name: OrderIso.le_iff_le
code: theorem le_iff_le (e : α ≃o β) {x y : α} : e x ≤ e y ↔ x ≤ y 
goal: e x ≤ e y ↔ x ≤ y

full_name: OrderIso.le_symm_apply
code: theorem le_symm_apply (e : α ≃o β) {x : α} {y : β} : x ≤ e.symm y ↔ e x ≤ y 
goal: x ≤ e.symm y ↔ e x ≤ y

full_name: OrderIso.symm_apply_le
code: theorem symm_apply_le (e : α ≃o β) {x : α} {y : β} : e.symm y ≤ x ↔ y ≤ e x 
goal: e.symm y ≤ x ↔ y ≤ e x

full_name: OrderIso.monotone
code: protected theorem monotone (e : α ≃o β) : Monotone e 
goal: Monotone ⇑e

full_name: OrderIso.strictMono
code: protected theorem strictMono (e : α ≃o β) : StrictMono e 
goal: StrictMono ⇑e

full_name: OrderIso.lt_iff_lt
code: @[simp]
theorem lt_iff_lt (e : α ≃o β) {x y : α} : e x < e y ↔ x < y 
goal: e x < e y ↔ x < y

full_name: OrderIso.toRelIsoLT
code: /-- Converts an `OrderIso` into a `RelIso (<) (<)`. -/
def toRelIsoLT (e : α ≃o β) : ((· < ·) : α → α → Prop) ≃r ((· < ·) : β → β → Prop) 
goal: (fun x x_1 => x < x_1) ≃r fun x x_1 => x < x_1

full_name: OrderIso.toRelIsoLT_apply
code: @[simp]
theorem toRelIsoLT_apply (e : α ≃o β) (x : α) : e.toRelIsoLT x = e x 
goal: e.toRelIsoLT x = e x

full_name: OrderIso.toRelIsoLT_symm
code: @[simp]
theorem toRelIsoLT_symm (e : α ≃o β) : e.toRelIsoLT.symm = e.symm.toRelIsoLT 
goal: e.toRelIsoLT.symm = e.symm.toRelIsoLT

full_name: OrderIso.ofRelIsoLT
code: /-- Converts a `RelIso (<) (<)` into an `OrderIso`. -/
def ofRelIsoLT {α β} [PartialOrder α] [PartialOrder β]
    (e : ((· < ·) : α → α → Prop) ≃r ((· < ·) : β → β → Prop)) : α ≃o β 
goal: α ≃o β

full_name: OrderIso.ofRelIsoLT_apply
code: @[simp]
theorem ofRelIsoLT_apply {α β} [PartialOrder α] [PartialOrder β]
    (e : ((· < ·) : α → α → Prop) ≃r ((· < ·) : β → β → Prop)) (x : α) : ofRelIsoLT e x = e x 
goal: (OrderIso.ofRelIsoLT e) x = e x

full_name: OrderIso.ofRelIsoLT_symm
code: @[simp]
theorem ofRelIsoLT_symm {α β} [PartialOrder α] [PartialOrder β]
    (e : ((· < ·) : α → α → Prop) ≃r ((· < ·) : β → β → Prop)) :
    (ofRelIsoLT e).symm = ofRelIsoLT e.symm 
goal: (OrderIso.ofRelIsoLT e).symm = OrderIso.ofRelIsoLT e.symm

full_name: OrderIso.ofRelIsoLT_toRelIsoLT
code: @[simp]
theorem ofRelIsoLT_toRelIsoLT {α β} [PartialOrder α] [PartialOrder β] (e : α ≃o β) :
    ofRelIsoLT (toRelIsoLT e) = e 
goal: OrderIso.ofRelIsoLT e.toRelIsoLT = e

full_name: OrderIso.toRelIsoLT_ofRelIsoLT
code: @[simp]
theorem toRelIsoLT_ofRelIsoLT {α β} [PartialOrder α] [PartialOrder β]
    (e : ((· < ·) : α → α → Prop) ≃r ((· < ·) : β → β → Prop)) : toRelIsoLT (ofRelIsoLT e) = e 
goal: (OrderIso.ofRelIsoLT e).toRelIsoLT = e

full_name: OrderIso.ofCmpEqCmp
code: /-- To show that `f : α → β`, `g : β → α` make up an order isomorphism of linear orders,
    it suffices to prove `cmp a (g b) = cmp (f a) b`. -/
def ofCmpEqCmp {α β} [LinearOrder α] [LinearOrder β] (f : α → β) (g : β → α)
    (h : ∀ (a : α) (b : β), cmp a (g b) = cmp (f a) b) : α ≃o β 
goal: α ≃o β

full_name: OrderIso.ofHomInv
code: /-- To show that `f : α →o β` and `g : β →o α` make up an order isomorphism it is enough to show
    that `g` is the inverse of `f`-/
def ofHomInv {F G : Type*} [FunLike F α β] [OrderHomClass F α β] [FunLike G β α]
    [OrderHomClass G β α] (f : F) (g : G)
    (h₁ : (f : α →o β).comp (g : β →o α) = OrderHom.id)
    (h₂ : (g : β →o α).comp (f : α →o β) = OrderHom.id) :
    α ≃o β 
goal: α ≃o β

full_name: OrderIso.funUnique_toEquiv
code: /-- Order isomorphism between `α → β` and `β`, where `α` has a unique element. -/
@[simps! toEquiv apply]
def funUnique (α β : Type*) [Unique α] [Preorder β] : (α → β) ≃o β 
goal: (OrderIso.funUnique α β).toEquiv = Equiv.funUnique α β

full_name: OrderIso.funUnique
code: /-- Order isomorphism between `α → β` and `β`, where `α` has a unique element. -/
@[simps! toEquiv apply]
def funUnique (α β : Type*) [Unique α] [Preorder β] : (α → β) ≃o β 
goal: (α → β) ≃o β

full_name: OrderIso.funUnique_apply
code: /-- Order isomorphism between `α → β` and `β`, where `α` has a unique element. -/
@[simps! toEquiv apply]
def funUnique (α β : Type*) [Unique α] [Preorder β] : (α → β) ≃o β 
goal: (OrderIso.funUnique α β) f = f default

full_name: OrderIso.funUnique_symm_apply
code: @[simp]
theorem funUnique_symm_apply {α β : Type*} [Unique α] [Preorder β] :
    ((funUnique α β).symm : β → α → β) = Function.const α 
goal: ⇑(OrderIso.funUnique α β).symm = Function.const α

full_name: Equiv.toOrderIso
code: /-- If `e` is an equivalence with monotone forward and inverse maps, then `e` is an
order isomorphism. -/
def toOrderIso (e : α ≃ β) (h₁ : Monotone e) (h₂ : Monotone e.symm) : α ≃o β 
goal: α ≃o β

full_name: Equiv.coe_toOrderIso
code: @[simp]
theorem coe_toOrderIso (e : α ≃ β) (h₁ : Monotone e) (h₂ : Monotone e.symm) :
    ⇑(e.toOrderIso h₁ h₂) = e 
goal: ⇑(e.toOrderIso h₁ h₂) = ⇑e

full_name: Equiv.toOrderIso_toEquiv
code: @[simp]
theorem toOrderIso_toEquiv (e : α ≃ β) (h₁ : Monotone e) (h₂ : Monotone e.symm) :
    (e.toOrderIso h₁ h₂).toEquiv = e 
goal: (e.toOrderIso h₁ h₂).toEquiv = e

full_name: StrictMono.orderIsoOfRightInverse
code: /-- A strictly monotone function with a right inverse is an order isomorphism. -/
@[simps (config := .asFn)]
def orderIsoOfRightInverse (g : β → α) (hg : Function.RightInverse g f) : α ≃o β 
goal: α ≃o β

full_name: StrictMono.orderIsoOfRightInverse_apply
code: /-- A strictly monotone function with a right inverse is an order isomorphism. -/
@[simps (config := .asFn)]
def orderIsoOfRightInverse (g : β → α) (hg : Function.RightInverse g f) : α ≃o β 
goal: ⇑(StrictMono.orderIsoOfRightInverse f h_mono g hg) = f

full_name: StrictMono.orderIsoOfRightInverse_symm_apply
code: /-- A strictly monotone function with a right inverse is an order isomorphism. -/
@[simps (config := .asFn)]
def orderIsoOfRightInverse (g : β → α) (hg : Function.RightInverse g f) : α ≃o β 
goal: ⇑(RelIso.symm (StrictMono.orderIsoOfRightInverse f h_mono g hg)) = g

full_name: OrderIso.dual
code: /-- An order isomorphism is also an order isomorphism between dual orders. -/
protected def OrderIso.dual [LE α] [LE β] (f : α ≃o β) : αᵒᵈ ≃o βᵒᵈ 
goal: αᵒᵈ ≃o βᵒᵈ

full_name: OrderIso.map_bot'
code: theorem OrderIso.map_bot' [LE α] [PartialOrder β] (f : α ≃o β) {x : α} {y : β} (hx : ∀ x', x ≤ x')
    (hy : ∀ y', y ≤ y') : f x = y 
goal: f x = y

full_name: OrderIso.map_bot
code: theorem OrderIso.map_bot [LE α] [PartialOrder β] [OrderBot α] [OrderBot β] (f : α ≃o β) : f ⊥ = ⊥ 
goal: f ⊥ = ⊥

full_name: OrderIso.map_top'
code: theorem OrderIso.map_top' [LE α] [PartialOrder β] (f : α ≃o β) {x : α} {y : β} (hx : ∀ x', x' ≤ x)
    (hy : ∀ y', y' ≤ y) : f x = y 
goal: f x = y

full_name: OrderIso.map_top
code: theorem OrderIso.map_top [LE α] [PartialOrder β] [OrderTop α] [OrderTop β] (f : α ≃o β) : f ⊤ = ⊤ 
goal: f ⊤ = ⊤

full_name: OrderEmbedding.map_inf_le
code: theorem OrderEmbedding.map_inf_le [SemilatticeInf α] [SemilatticeInf β] (f : α ↪o β) (x y : α) :
    f (x ⊓ y) ≤ f x ⊓ f y 
goal: f (x ⊓ y) ≤ f x ⊓ f y

full_name: OrderEmbedding.le_map_sup
code: theorem OrderEmbedding.le_map_sup [SemilatticeSup α] [SemilatticeSup β] (f : α ↪o β) (x y : α) :
    f x ⊔ f y ≤ f (x ⊔ y) 
goal: f x ⊔ f y ≤ f (x ⊔ y)

full_name: OrderIso.map_inf
code: theorem OrderIso.map_inf [SemilatticeInf α] [SemilatticeInf β] (f : α ≃o β) (x y : α) :
    f (x ⊓ y) = f x ⊓ f y 
goal: f (x ⊓ y) = f x ⊓ f y

full_name: OrderIso.map_sup
code: theorem OrderIso.map_sup [SemilatticeSup α] [SemilatticeSup β] (f : α ≃o β) (x y : α) :
    f (x ⊔ y) = f x ⊔ f y 
goal: f (x ⊔ y) = f x ⊔ f y

full_name: Disjoint.map_orderIso
code: /-- Note that this goal could also be stated `(Disjoint on f) a b` -/
theorem Disjoint.map_orderIso [SemilatticeInf α] [OrderBot α] [SemilatticeInf β] [OrderBot β]
    {a b : α} (f : α ≃o β) (ha : Disjoint a b) : Disjoint (f a) (f b) 
goal: Disjoint (f a) (f b)

full_name: Codisjoint.map_orderIso
code: /-- Note that this goal could also be stated `(Codisjoint on f) a b` -/
theorem Codisjoint.map_orderIso [SemilatticeSup α] [OrderTop α] [SemilatticeSup β] [OrderTop β]
    {a b : α} (f : α ≃o β) (ha : Codisjoint a b) : Codisjoint (f a) (f b) 
goal: Codisjoint (f a) (f b)

full_name: disjoint_map_orderIso_iff
code: @[simp]
theorem disjoint_map_orderIso_iff [SemilatticeInf α] [OrderBot α] [SemilatticeInf β] [OrderBot β]
    {a b : α} (f : α ≃o β) : Disjoint (f a) (f b) ↔ Disjoint a b 
goal: Disjoint (f a) (f b) ↔ Disjoint a b

full_name: codisjoint_map_orderIso_iff
code: @[simp]
theorem codisjoint_map_orderIso_iff [SemilatticeSup α] [OrderTop α] [SemilatticeSup β] [OrderTop β]
    {a b : α} (f : α ≃o β) : Codisjoint (f a) (f b) ↔ Codisjoint a b 
goal: Codisjoint (f a) (f b) ↔ Codisjoint a b

full_name: WithBot.toDualTopEquiv
code: /-- Taking the dual then adding `⊥` is the same as adding `⊤` then taking the dual.
This is the order iso form of `WithBot.ofDual`, as proven by `coe_toDualTopEquiv_eq`.
-/
protected def toDualTopEquiv [LE α] : WithBot αᵒᵈ ≃o (WithTop α)ᵒᵈ 
goal: WithBot αᵒᵈ ≃o (WithTop α)ᵒᵈ

full_name: WithBot.toDualTopEquiv_coe
code: @[simp]
theorem toDualTopEquiv_coe [LE α] (a : α) :
    WithBot.toDualTopEquiv ↑(toDual a) = toDual (a : WithTop α) 
goal: WithBot.toDualTopEquiv ↑(OrderDual.toDual a) = OrderDual.toDual ↑a

full_name: WithBot.toDualTopEquiv_symm_coe
code: @[simp]
theorem toDualTopEquiv_symm_coe [LE α] (a : α) :
    WithBot.toDualTopEquiv.symm (toDual (a : WithTop α)) = ↑(toDual a) 
goal: WithBot.toDualTopEquiv.symm (OrderDual.toDual ↑a) = ↑(OrderDual.toDual a)

full_name: WithBot.toDualTopEquiv_bot
code: @[simp]
theorem toDualTopEquiv_bot [LE α] : WithBot.toDualTopEquiv (⊥ : WithBot αᵒᵈ) = ⊥ 
goal: WithBot.toDualTopEquiv ⊥ = ⊥

full_name: WithBot.toDualTopEquiv_symm_bot
code: @[simp]
theorem toDualTopEquiv_symm_bot [LE α] : WithBot.toDualTopEquiv.symm (⊥ : (WithTop α)ᵒᵈ) = ⊥ 
goal: WithBot.toDualTopEquiv.symm ⊥ = ⊥

full_name: WithBot.coe_toDualTopEquiv_eq
code: theorem coe_toDualTopEquiv_eq [LE α] :
    (WithBot.toDualTopEquiv : WithBot αᵒᵈ → (WithTop α)ᵒᵈ) = toDual ∘ WithBot.ofDual 
goal: ⇑WithBot.toDualTopEquiv = ⇑OrderDual.toDual ∘ ⇑WithBot.ofDual

full_name: WithTop.toDualBotEquiv
code: /-- Taking the dual then adding `⊤` is the same as adding `⊥` then taking the dual.
This is the order iso form of `WithTop.ofDual`, as proven by `coe_toDualBotEquiv_eq`. -/
protected def toDualBotEquiv [LE α] : WithTop αᵒᵈ ≃o (WithBot α)ᵒᵈ 
goal: WithTop αᵒᵈ ≃o (WithBot α)ᵒᵈ

full_name: WithTop.toDualBotEquiv_coe
code: @[simp]
theorem toDualBotEquiv_coe [LE α] (a : α) :
    WithTop.toDualBotEquiv ↑(toDual a) = toDual (a : WithBot α) 
goal: WithTop.toDualBotEquiv ↑(OrderDual.toDual a) = OrderDual.toDual ↑a

full_name: WithTop.toDualBotEquiv_symm_coe
code: @[simp]
theorem toDualBotEquiv_symm_coe [LE α] (a : α) :
    WithTop.toDualBotEquiv.symm (toDual (a : WithBot α)) = ↑(toDual a) 
goal: WithTop.toDualBotEquiv.symm (OrderDual.toDual ↑a) = ↑(OrderDual.toDual a)

full_name: WithTop.toDualBotEquiv_top
code: @[simp]
theorem toDualBotEquiv_top [LE α] : WithTop.toDualBotEquiv (⊤ : WithTop αᵒᵈ) = ⊤ 
goal: WithTop.toDualBotEquiv ⊤ = ⊤

full_name: WithTop.toDualBotEquiv_symm_top
code: @[simp]
theorem toDualBotEquiv_symm_top [LE α] : WithTop.toDualBotEquiv.symm (⊤ : (WithBot α)ᵒᵈ) = ⊤ 
goal: WithTop.toDualBotEquiv.symm ⊤ = ⊤

full_name: WithTop.coe_toDualBotEquiv
code: theorem coe_toDualBotEquiv [LE α] :
    (WithTop.toDualBotEquiv : WithTop αᵒᵈ → (WithBot α)ᵒᵈ) = toDual ∘ WithTop.ofDual 
goal: ⇑WithTop.toDualBotEquiv = ⇑OrderDual.toDual ∘ ⇑WithTop.ofDual

full_name: OrderIso.withTopCongr_apply
code: /-- A version of `Equiv.optionCongr` for `WithTop`. -/
@[simps! apply]
def withTopCongr (e : α ≃o β) : WithTop α ≃o WithTop β 
goal: ∀ (a : Option α), e.withTopCongr a = Option.map (⇑e) a

full_name: OrderIso.withTopCongr
code: /-- A version of `Equiv.optionCongr` for `WithTop`. -/
@[simps! apply]
def withTopCongr (e : α ≃o β) : WithTop α ≃o WithTop β 
goal: WithTop α ≃o WithTop β

full_name: OrderIso.withTopCongr_refl
code: @[simp]
theorem withTopCongr_refl : (OrderIso.refl α).withTopCongr = OrderIso.refl _ 
goal: (OrderIso.refl α).withTopCongr = OrderIso.refl (WithTop α)

full_name: OrderIso.withTopCongr_symm
code: @[simp]
theorem withTopCongr_symm (e : α ≃o β) : e.withTopCongr.symm = e.symm.withTopCongr 
goal: e.withTopCongr.symm = e.symm.withTopCongr

full_name: OrderIso.withTopCongr_trans
code: @[simp]
theorem withTopCongr_trans (e₁ : α ≃o β) (e₂ : β ≃o γ) :
    e₁.withTopCongr.trans e₂.withTopCongr = (e₁.trans e₂).withTopCongr 
goal: e₁.withTopCongr.trans e₂.withTopCongr = (e₁.trans e₂).withTopCongr

full_name: OrderIso.withBotCongr
code: /-- A version of `Equiv.optionCongr` for `WithBot`. -/
@[simps! apply]
def withBotCongr (e : α ≃o β) : WithBot α ≃o WithBot β 
goal: WithBot α ≃o WithBot β

full_name: OrderIso.withBotCongr_apply
code: /-- A version of `Equiv.optionCongr` for `WithBot`. -/
@[simps! apply]
def withBotCongr (e : α ≃o β) : WithBot α ≃o WithBot β 
goal: ∀ (a : Option α), e.withBotCongr a = Option.map (⇑e) a

full_name: OrderIso.withBotCongr_refl
code: @[simp]
theorem withBotCongr_refl : (OrderIso.refl α).withBotCongr = OrderIso.refl _ 
goal: (OrderIso.refl α).withBotCongr = OrderIso.refl (WithBot α)

full_name: OrderIso.withBotCongr_symm
code: @[simp]
theorem withBotCongr_symm (e : α ≃o β) : e.withBotCongr.symm = e.symm.withBotCongr 
goal: e.withBotCongr.symm = e.symm.withBotCongr

full_name: OrderIso.withBotCongr_trans
code: @[simp]
theorem withBotCongr_trans (e₁ : α ≃o β) (e₂ : β ≃o γ) :
    e₁.withBotCongr.trans e₂.withBotCongr = (e₁.trans e₂).withBotCongr 
goal: e₁.withBotCongr.trans e₂.withBotCongr = (e₁.trans e₂).withBotCongr

full_name: OrderIso.isCompl
code: theorem OrderIso.isCompl {x y : α} (h : IsCompl x y) : IsCompl (f x) (f y) 
goal: IsCompl (f x) (f y)

full_name: OrderIso.isCompl_iff
code: theorem OrderIso.isCompl_iff {x y : α} : IsCompl x y ↔ IsCompl (f x) (f y) 
goal: IsCompl x y ↔ IsCompl (f x) (f y)

full_name: OrderIso.complementedLattice
code: theorem OrderIso.complementedLattice [ComplementedLattice α] (f : α ≃o β) : ComplementedLattice β 
goal: ComplementedLattice β

full_name: OrderIso.complementedLattice_iff
code: theorem OrderIso.complementedLattice_iff (f : α ≃o β) :
    ComplementedLattice α ↔ ComplementedLattice β 
goal: ComplementedLattice α ↔ ComplementedLattice β