File: Mathlib/Algebra/Order/Hom/Ring.lean

full_name: OrderRingHom
code: /-- `OrderRingHom α β` is the type of monotone semiring homomorphisms from `α` to `β`.

When possible, instead of parametrizing results over `(f : OrderRingHom α β)`,
you should parametrize over `(F : Type*) [OrderRingHomClass F α β] (f : F)`.

When you extend this structure, make sure to extend `OrderRingHomClass`. -/
structure OrderRingHom (α β : Type*) [NonAssocSemiring α] [Preorder α] [NonAssocSemiring β]
  [Preorder β] extends α →+* β where
  /-- The proposition that the function preserves the order. -/
  monotone' : Monotone toFun
goal: Type (max u_6 u_7)

full_name: OrderRingHom.monotone'
code: /-- `OrderRingHom α β` is the type of monotone semiring homomorphisms from `α` to `β`.

When possible, instead of parametrizing results over `(f : OrderRingHom α β)`,
you should parametrize over `(F : Type*) [OrderRingHomClass F α β] (f : F)`.

When you extend this structure, make sure to extend `OrderRingHomClass`. -/
structure OrderRingHom (α β : Type*) [NonAssocSemiring α] [Preorder α] [NonAssocSemiring β]
  [Preorder β] extends α →+* β where
  /-- The proposition that the function preserves the order. -/
  monotone' : Monotone toFun
goal: Monotone (↑↑self.toRingHom).toFun

full_name: _aux_Mathlib_Algebra_Order_Hom_Ring___unexpand_OrderRingHom_1
code: @[inherit_doc]
infixl:25 " →+*o " => OrderRingHom
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Order_Hom_Ring___macroRules_term_→+*o__1»
code: @[inherit_doc]
infixl:25 " →+*o " => OrderRingHom
goal: Lean.Macro

full_name: OrderRingIso
code: /-- `OrderRingHom α β` is the type of order-preserving semiring isomorphisms between `α` and `β`.

When possible, instead of parametrizing results over `(f : OrderRingIso α β)`,
you should parametrize over `(F : Type*) [OrderRingIsoClass F α β] (f : F)`.

When you extend this structure, make sure to extend `OrderRingIsoClass`. -/
structure OrderRingIso (α β : Type*) [Mul α] [Mul β] [Add α] [Add β] [LE α] [LE β] extends
  α ≃+* β where
  /-- The proposition that the function preserves the order bijectively. -/
  map_le_map_iff' {a b : α} : toFun a ≤ toFun b ↔ a ≤ b
goal: Type (max u_6 u_7)

full_name: OrderRingIso.map_le_map_iff'
code: /-- `OrderRingHom α β` is the type of order-preserving semiring isomorphisms between `α` and `β`.

When possible, instead of parametrizing results over `(f : OrderRingIso α β)`,
you should parametrize over `(F : Type*) [OrderRingIsoClass F α β] (f : F)`.

When you extend this structure, make sure to extend `OrderRingIsoClass`. -/
structure OrderRingIso (α β : Type*) [Mul α] [Mul β] [Add α] [Add β] [LE α] [LE β] extends
  α ≃+* β where
  /-- The proposition that the function preserves the order bijectively. -/
  map_le_map_iff' {a b : α} : toFun a ≤ toFun b ↔ a ≤ b
goal: self.toFun a ≤ self.toFun b ↔ a ≤ b

full_name: _aux_Mathlib_Algebra_Order_Hom_Ring___unexpand_OrderRingIso_1
code: @[inherit_doc]
infixl:25 " ≃+*o " => OrderRingIso
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Order_Hom_Ring___macroRules_term_≃+*o__1»
code: @[inherit_doc]
infixl:25 " ≃+*o " => OrderRingIso
goal: Lean.Macro

full_name: OrderRingHomClass.toOrderRingHom
code: /-- Turn an element of a type `F` satisfying `OrderHomClass F α β` and `RingHomClass F α β`
into an actual `OrderRingHom`.
This is declared as the default coercion from `F` to `α →+*o β`. -/
@[coe]
def OrderRingHomClass.toOrderRingHom [NonAssocSemiring α] [Preorder α] [NonAssocSemiring β]
    [Preorder β] [OrderHomClass F α β] [RingHomClass F α β] (f : F) : α →+*o β 
goal: α →+*o β

full_name: instCoeTCOrderRingHomOfOrderHomClassOfRingHomClass
code: /-- Any type satisfying `OrderRingHomClass` can be cast into `OrderRingHom` via
  `OrderRingHomClass.toOrderRingHom`. -/
instance [NonAssocSemiring α] [Preorder α] [NonAssocSemiring β] [Preorder β]
    [OrderHomClass F α β] [RingHomClass F α β] : CoeTC F (α →+*o β) 
goal: CoeTC F (α →+*o β)

full_name: OrderRingIsoClass.toOrderRingIso
code: /-- Turn an element of a type `F` satisfying `OrderIsoClass F α β` and `RingEquivClass F α β`
into an actual `OrderRingIso`.
This is declared as the default coercion from `F` to `α ≃+*o β`. -/
@[coe]
def OrderRingIsoClass.toOrderRingIso [Mul α] [Add α] [LE α] [Mul β] [Add β] [LE β]
    [OrderIsoClass F α β] [RingEquivClass F α β] (f : F) : α ≃+*o β 
goal: α ≃+*o β

full_name: instCoeTCOrderRingIsoOfOrderIsoClassOfRingEquivClass
code: /-- Any type satisfying `OrderRingIsoClass` can be cast into `OrderRingIso` via
  `OrderRingIsoClass.toOrderRingIso`. -/
instance [Mul α] [Add α] [LE α] [Mul β] [Add β] [LE β] [OrderIsoClass F α β]
    [RingEquivClass F α β] : CoeTC F (α ≃+*o β) 
goal: CoeTC F (α ≃+*o β)

full_name: OrderRingHom.toOrderAddMonoidHom
code: /-- Reinterpret an ordered ring homomorphism as an ordered additive monoid homomorphism. -/
def toOrderAddMonoidHom (f : α →+*o β) : α →+o β 
goal: α →+o β

full_name: OrderRingHom.toOrderMonoidWithZeroHom
code: /-- Reinterpret an ordered ring homomorphism as an order homomorphism. -/
def toOrderMonoidWithZeroHom (f : α →+*o β) : α →*₀o β 
goal: α →*₀o β

full_name: OrderRingHom.instFunLike
code: instance : FunLike (α →+*o β) α β 
goal: FunLike (α →+*o β) α β

full_name: OrderRingHom.instOrderHomClass
code: instance : OrderHomClass (α →+*o β) α β 
goal: OrderHomClass (α →+*o β) α β

full_name: OrderRingHom.instRingHomClass
code: instance : RingHomClass (α →+*o β) α β 
goal: RingHomClass (α →+*o β) α β

full_name: OrderRingHom.toFun_eq_coe
code: theorem toFun_eq_coe (f : α →+*o β) : f.toFun = f 
goal: (↑↑f.toRingHom).toFun = ⇑f

full_name: OrderRingHom.ext
code: @[ext]
theorem ext {f g : α →+*o β} (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: OrderRingHom.toRingHom_eq_coe
code: @[simp]
theorem toRingHom_eq_coe (f : α →+*o β) : f.toRingHom = f 
goal: f.toRingHom = ↑f

full_name: OrderRingHom.toOrderAddMonoidHom_eq_coe
code: @[simp]
theorem toOrderAddMonoidHom_eq_coe (f : α →+*o β) : f.toOrderAddMonoidHom = f 
goal: f.toOrderAddMonoidHom = ↑f

full_name: OrderRingHom.toOrderMonoidWithZeroHom_eq_coe
code: @[simp]
theorem toOrderMonoidWithZeroHom_eq_coe (f : α →+*o β) : f.toOrderMonoidWithZeroHom = f 
goal: f.toOrderMonoidWithZeroHom = ↑f

full_name: OrderRingHom.coe_coe_ringHom
code: @[simp]
theorem coe_coe_ringHom (f : α →+*o β) : ⇑(f : α →+* β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderRingHom.coe_coe_orderAddMonoidHom
code: @[simp]
theorem coe_coe_orderAddMonoidHom (f : α →+*o β) : ⇑(f : α →+o β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderRingHom.coe_coe_orderMonoidWithZeroHom
code: @[simp]
theorem coe_coe_orderMonoidWithZeroHom (f : α →+*o β) : ⇑(f : α →*₀o β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderRingHom.coe_ringHom_apply
code: @[norm_cast]
theorem coe_ringHom_apply (f : α →+*o β) (a : α) : (f : α →+* β) a = f a 
goal: ↑f a = f a

full_name: OrderRingHom.coe_orderAddMonoidHom_apply
code: @[norm_cast]
theorem coe_orderAddMonoidHom_apply (f : α →+*o β) (a : α) : (f : α →+o β) a = f a 
goal: ↑f a = f a

full_name: OrderRingHom.coe_orderMonoidWithZeroHom_apply
code: @[norm_cast]
theorem coe_orderMonoidWithZeroHom_apply (f : α →+*o β) (a : α) : (f : α →*₀o β) a = f a 
goal: ↑f a = f a

full_name: OrderRingHom.copy
code: /-- Copy of an `OrderRingHom` 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: OrderRingHom.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: OrderRingHom.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: OrderRingHom.id
code: /-- The identity as an ordered ring homomorphism. -/
protected def id : α →+*o α 
goal: α →+*o α

full_name: OrderRingHom.instInhabited
code: instance : Inhabited (α →+*o α) 
goal: Inhabited (α →+*o α)

full_name: OrderRingHom.coe_id
code: @[simp]
theorem coe_id : ⇑(OrderRingHom.id α) = id 
goal: ⇑(OrderRingHom.id α) = id

full_name: OrderRingHom.id_apply
code: @[simp]
theorem id_apply (a : α) : OrderRingHom.id α a = a 
goal: (OrderRingHom.id α) a = a

full_name: OrderRingHom.coe_ringHom_id
code: @[simp]
theorem coe_ringHom_id : (OrderRingHom.id α : α →+* α) = RingHom.id α 
goal: ↑(OrderRingHom.id α) = RingHom.id α

full_name: OrderRingHom.coe_orderAddMonoidHom_id
code: @[simp]
theorem coe_orderAddMonoidHom_id : (OrderRingHom.id α : α →+o α) = OrderAddMonoidHom.id α 
goal: ↑(OrderRingHom.id α) = OrderAddMonoidHom.id α

full_name: OrderRingHom.coe_orderMonoidWithZeroHom_id
code: @[simp]
theorem coe_orderMonoidWithZeroHom_id :
    (OrderRingHom.id α : α →*₀o α) = OrderMonoidWithZeroHom.id α 
goal: ↑(OrderRingHom.id α) = OrderMonoidWithZeroHom.id α

full_name: OrderRingHom.comp
code: /-- Composition of two `OrderRingHom`s as an `OrderRingHom`. -/
protected def comp (f : β →+*o γ) (g : α →+*o β) : α →+*o γ 
goal: α →+*o γ

full_name: OrderRingHom.coe_comp
code: @[simp]
theorem coe_comp (f : β →+*o γ) (g : α →+*o β) : ⇑(f.comp g) = f ∘ g 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: OrderRingHom.comp_apply
code: @[simp]
theorem comp_apply (f : β →+*o γ) (g : α →+*o β) (a : α) : f.comp g a = f (g a) 
goal: (f.comp g) a = f (g a)

full_name: OrderRingHom.comp_assoc
code: theorem comp_assoc (f : γ →+*o δ) (g : β →+*o γ) (h : α →+*o β) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

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

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

full_name: OrderRingHom.cancel_right
code: @[simp]
theorem cancel_right {f₁ f₂ : β →+*o γ} {g : α →+*o β} (hg : Surjective g) :
    f₁.comp g = f₂.comp g ↔ f₁ = f₂ 
goal: f₁.comp g = f₂.comp g ↔ f₁ = f₂

full_name: OrderRingHom.cancel_left
code: @[simp]
theorem cancel_left {f : β →+*o γ} {g₁ g₂ : α →+*o β} (hf : Injective f) :
    f.comp g₁ = f.comp g₂ ↔ g₁ = g₂ 
goal: f.comp g₁ = f.comp g₂ ↔ g₁ = g₂

full_name: OrderRingHom.instPreorder
code: instance [Preorder β] : Preorder (OrderRingHom α β) 
goal: Preorder (α →+*o β)

full_name: OrderRingHom.instPartialOrder
code: instance [PartialOrder β] : PartialOrder (OrderRingHom α β) 
goal: PartialOrder (α →+*o β)

full_name: OrderRingIso.toOrderIso
code: /-- Reinterpret an ordered ring isomorphism as an order isomorphism. -/
-- Porting note: Added @[coe] attribute
@[coe]
def toOrderIso (f : α ≃+*o β) : α ≃o β 
goal: α ≃o β

full_name: OrderRingIso.instEquivLike
code: instance : EquivLike (α ≃+*o β) α β 
goal: EquivLike (α ≃+*o β) α β

full_name: OrderRingIso.instOrderIsoClass
code: instance : OrderIsoClass (α ≃+*o β) α β 
goal: OrderIsoClass (α ≃+*o β) α β

full_name: OrderRingIso.instRingEquivClass
code: instance : RingEquivClass (α ≃+*o β) α β 
goal: RingEquivClass (α ≃+*o β) α β

full_name: OrderRingIso.toFun_eq_coe
code: theorem toFun_eq_coe (f : α ≃+*o β) : f.toFun = f 
goal: f.toFun = ⇑f

full_name: OrderRingIso.ext
code: @[ext]
theorem ext {f g : α ≃+*o β} (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: OrderRingIso.coe_mk
code: @[simp]
theorem coe_mk (e : α ≃+* β) (h) : ⇑(⟨e, h⟩ : α ≃+*o β) = e 
goal: ⇑{ toRingEquiv := e, map_le_map_iff' := h } = ⇑e

full_name: OrderRingIso.mk_coe
code: @[simp]
theorem mk_coe (e : α ≃+*o β) (h) : (⟨e, h⟩ : α ≃+*o β) = e 
goal: { toRingEquiv := ↑e, map_le_map_iff' := h } = e

full_name: OrderRingIso.toRingEquiv_eq_coe
code: @[simp]
theorem toRingEquiv_eq_coe (f : α ≃+*o β) : f.toRingEquiv = f 
goal: f.toRingEquiv = ↑f

full_name: OrderRingIso.toOrderIso_eq_coe
code: @[simp]
theorem toOrderIso_eq_coe (f : α ≃+*o β) : f.toOrderIso = f 
goal: ↑f = ↑f

full_name: OrderRingIso.coe_toRingEquiv
code: @[simp, norm_cast]
theorem coe_toRingEquiv (f : α ≃+*o β) : ⇑(f : α ≃+* β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderRingIso.coe_toOrderIso
code: @[simp, norm_cast]
theorem coe_toOrderIso (f : α ≃+*o β) : DFunLike.coe (f : α ≃o β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderRingIso.refl
code: /-- The identity map as an ordered ring isomorphism. -/
@[refl]
protected def refl : α ≃+*o α 
goal: α ≃+*o α

full_name: OrderRingIso.instInhabited
code: instance : Inhabited (α ≃+*o α) 
goal: Inhabited (α ≃+*o α)

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

full_name: OrderRingIso.coe_ringEquiv_refl
code: @[simp]
theorem coe_ringEquiv_refl : (OrderRingIso.refl α : α ≃+* α) = RingEquiv.refl α 
goal: ↑(OrderRingIso.refl α) = RingEquiv.refl α

full_name: OrderRingIso.coe_orderIso_refl
code: @[simp]
theorem coe_orderIso_refl : (OrderRingIso.refl α : α ≃o α) = OrderIso.refl α 
goal: ↑(OrderRingIso.refl α) = OrderIso.refl α

full_name: OrderRingIso.symm
code: /-- The inverse of an ordered ring isomorphism as an ordered ring isomorphism. -/
@[symm]
protected def symm (e : α ≃+*o β) : β ≃+*o α 
goal: β ≃+*o α

full_name: OrderRingIso.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply (e : α ≃+*o β) : β → α 
goal: β → α

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

full_name: OrderRingIso.trans
code: /-- Composition of `OrderRingIso`s as an `OrderRingIso`. -/
@[trans]
protected def trans (f : α ≃+*o β) (g : β ≃+*o γ) : α ≃+*o γ 
goal: α ≃+*o γ

full_name: OrderRingIso.trans_toRingEquiv
code: theorem trans_toRingEquiv (f : α ≃+*o β) (g : β ≃+*o γ) :
    (OrderRingIso.trans f g).toRingEquiv = RingEquiv.trans f.toRingEquiv g.toRingEquiv 
goal: (f.trans g).toRingEquiv = f.trans g.toRingEquiv

full_name: OrderRingIso.trans_toRingEquiv_aux
code: @[simp]
theorem trans_toRingEquiv_aux (f : α ≃+*o β) (g : β ≃+*o γ) :
    RingEquivClass.toRingEquiv (OrderRingIso.trans f g)
      = RingEquiv.trans f.toRingEquiv g.toRingEquiv 
goal: ↑(f.trans g) = f.trans g.toRingEquiv

full_name: OrderRingIso.trans_apply
code: @[simp]
theorem trans_apply (f : α ≃+*o β) (g : β ≃+*o γ) (a : α) : f.trans g a = g (f a) 
goal: (f.trans g) a = g (f a)

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

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

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

full_name: OrderRingIso.toOrderRingHom
code: /-- Reinterpret an ordered ring isomorphism as an ordered ring homomorphism. -/
def toOrderRingHom (f : α ≃+*o β) : α →+*o β 
goal: α →+*o β

full_name: OrderRingIso.toOrderRingHom_eq_coe
code: @[simp]
theorem toOrderRingHom_eq_coe (f : α ≃+*o β) : f.toOrderRingHom = f 
goal: f.toOrderRingHom = ↑f

full_name: OrderRingIso.coe_toOrderRingHom
code: @[simp, norm_cast]
theorem coe_toOrderRingHom (f : α ≃+*o β) : ⇑(f : α →+*o β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderRingIso.coe_toOrderRingHom_refl
code: @[simp]
theorem coe_toOrderRingHom_refl : (OrderRingIso.refl α : α →+*o α) = OrderRingHom.id α 
goal: ↑(OrderRingIso.refl α) = OrderRingHom.id α

full_name: OrderRingIso.toOrderRingHom_injective
code: theorem toOrderRingHom_injective : Injective (toOrderRingHom : α ≃+*o β → α →+*o β) 
goal: Function.Injective OrderRingIso.toOrderRingHom

full_name: OrderRingHom.subsingleton
code: /-- There is at most one ordered ring homomorphism from a linear ordered field to an archimedean
linear ordered field. -/
instance OrderRingHom.subsingleton [LinearOrderedField α] [LinearOrderedField β] [Archimedean β] :
    Subsingleton (α →+*o β) 
goal: Subsingleton (α →+*o β)

full_name: OrderRingIso.subsingleton_right
code: /-- There is at most one ordered ring isomorphism between a linear ordered field and an archimedean
linear ordered field. -/
instance OrderRingIso.subsingleton_right [LinearOrderedField α] [LinearOrderedField β]
    [Archimedean β] : Subsingleton (α ≃+*o β) 
goal: Subsingleton (α ≃+*o β)

full_name: OrderRingIso.subsingleton_left
code: /-- There is at most one ordered ring isomorphism between an archimedean linear ordered field and a
linear ordered field. -/
instance OrderRingIso.subsingleton_left [LinearOrderedField α] [Archimedean α]
    [LinearOrderedField β] : Subsingleton (α ≃+*o β) 
goal: Subsingleton (α ≃+*o β)