Documentation

Mathlib.Algebra.Order.Hom.Monoid

Ordered monoid and group homomorphisms #

This file defines morphisms between (additive) ordered monoids.

Types of morphisms #

OrderAddMonoidHom: Ordered additive monoid homomorphisms.
OrderMonoidHom: Ordered monoid homomorphisms.
OrderMonoidWithZeroHom: Ordered monoid with zero homomorphisms.
OrderAddMonoidIso: Ordered additive monoid isomorphisms.
OrderMonoidIso: Ordered monoid isomorphisms.

Notation #

→+o: Bundled ordered additive monoid homs. Also use for additive group homs.
→*o: Bundled ordered monoid homs. Also use for group homs.
→*₀o: Bundled ordered monoid with zero homs. Also use for group with zero homs.
≃+o: Bundled ordered additive monoid isos. Also use for additive group isos.
≃*o: Bundled ordered monoid isos. Also use for group isos.
≃*₀o: Bundled ordered monoid with zero isos. Also use for group with zero isos.

Implementation notes #

There's a coercion from bundled homs to fun, and the canonical notation is to use the bundled hom as a function via this coercion.

There is no OrderGroupHom -- the idea is that OrderMonoidHom is used. The constructor for OrderMonoidHom needs a proof of map_one as well as map_mul; a separate constructor OrderMonoidHom.mk' will construct ordered group homs (i.e. ordered monoid homs between ordered groups) given only a proof that multiplication is preserved,

Implicit {} brackets are often used instead of type class [] brackets. This is done when the instances can be inferred because they are implicit arguments to the type OrderMonoidHom. When they can be inferred from the type it is faster to use this method than to use type class inference.

Removed typeclasses #

This file used to define typeclasses for order-preserving (additive) monoid homomorphisms: OrderAddMonoidHomClass, OrderMonoidHomClass, and OrderMonoidWithZeroHomClass.

In #10544 we migrated from these typeclasses to assumptions like [FunLike F M N] [MonoidHomClass F M N] [OrderHomClass F M N], making some definitions and lemmas irrelevant.

Tags #

ordered monoid, ordered group, monoid with zero

structure OrderAddMonoidHom (α : Type u_6) (β : Type u_7) [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] extends AddMonoidHom :

Type (max u_6 u_7)

α →+o β is the type of monotone functions α → β that preserve the OrderedAddCommMonoid structure.

OrderAddMonoidHom is also used for ordered group homomorphisms.

When possible, instead of parametrizing results over (f : α →+o β), you should parametrize over (F : Type*) [FunLike F M N] [MonoidHomClass F M N] [OrderHomClass F M N] (f : F).

toFun : α → β
map_zero' : (↑self.toAddMonoidHom).toFun 0 = 0
map_add' : ∀ (x y : α), (↑self.toAddMonoidHom).toFun (x + y) = (↑self.toAddMonoidHom).toFun x + (↑self.toAddMonoidHom).toFun y
monotone' : Monotone (↑self.toAddMonoidHom).toFun
An OrderAddMonoidHom is a monotone function.

Instances For

theorem OrderAddMonoidHom.monotone' {α : Type u_6} {β : Type u_7} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (self : α →+o β) :

Monotone (↑self.toAddMonoidHom).toFun

An OrderAddMonoidHom is a monotone function.

def «term_→+o_» :

Lean.TrailingParserDescr

Infix notation for OrderAddMonoidHom.

Equations

«term_→+o_» = Lean.ParserDescr.trailingNode `term_→+o_ 25 26 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " →+o ") (Lean.ParserDescr.cat `term 25))

structure OrderAddMonoidIso (α : Type u_6) (β : Type u_7) [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] extends AddEquiv :

Type (max u_6 u_7)

α ≃+o β is the type of monotone isomorphisms α ≃ β that preserve the OrderedAddCommMonoid structure.

OrderAddMonoidIso is also used for ordered group isomorphisms.

When possible, instead of parametrizing results over (f : α ≃+o β), you should parametrize over (F : Type*) [FunLike F M N] [AddEquivClass F M N] [OrderIsoClass F M N] (f : F).

toFun : α → β
invFun : β → α
left_inv : Function.LeftInverse self.invFun self.toFun
right_inv : Function.RightInverse self.invFun self.toFun
map_add' : ∀ (x y : α), self.toFun (x + y) = self.toFun x + self.toFun y
map_le_map_iff' : ∀ {a b : α}, self.toFun a ≤ self.toFun b ↔ a ≤ b
An OrderAddMonoidIso respects ≤.

Instances For

theorem OrderAddMonoidIso.map_le_map_iff' {α : Type u_6} {β : Type u_7} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (self : α ≃+o β) {a : α} {b : α} :

self.toFun a ≤ self.toFun b ↔ a ≤ b

An OrderAddMonoidIso respects ≤.

def «term_≃+o_» :

Lean.TrailingParserDescr

Infix notation for OrderAddMonoidIso.

Equations

«term_≃+o_» = Lean.ParserDescr.trailingNode `term_≃+o_ 25 26 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " ≃+o ") (Lean.ParserDescr.cat `term 25))

structure OrderMonoidHom (α : Type u_6) (β : Type u_7) [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] extends MonoidHom :

Type (max u_6 u_7)

α →*o β is the type of functions α → β that preserve the OrderedCommMonoid structure.

OrderMonoidHom is also used for ordered group homomorphisms.

When possible, instead of parametrizing results over (f : α →*o β), you should parametrize over (F : Type*) [FunLike F M N] [MonoidHomClass F M N] [OrderHomClass F M N] (f : F).

toFun : α → β
map_one' : (↑self.toMonoidHom).toFun 1 = 1
map_mul' : ∀ (x y : α), (↑self.toMonoidHom).toFun (x * y) = (↑self.toMonoidHom).toFun x * (↑self.toMonoidHom).toFun y
monotone' : Monotone (↑self.toMonoidHom).toFun
An OrderMonoidHom is a monotone function.

Instances For

theorem OrderMonoidHom.monotone' {α : Type u_6} {β : Type u_7} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (self : α →*o β) :

Monotone (↑self.toMonoidHom).toFun

An OrderMonoidHom is a monotone function.

def «term_→*o_» :

Lean.TrailingParserDescr

Infix notation for OrderMonoidHom.

Equations

«term_→*o_» = Lean.ParserDescr.trailingNode `term_→*o_ 25 26 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " →*o ") (Lean.ParserDescr.cat `term 25))

def OrderMonoidHomClass.toOrderAddMonoidHom {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] [FunLike F α β] [OrderHomClass F α β] [AddMonoidHomClass F α β] (f : F) :

α →+o β

Turn an element of a type F satisfying OrderHomClass F α β and AddMonoidHomClass F α β into an actual OrderAddMonoidHom. This is declared as the default coercion from F to α →+o β.

Equations

↑f = { toAddMonoidHom := ↑f, monotone' := ⋯ }

def OrderMonoidHomClass.toOrderMonoidHom {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] [FunLike F α β] [OrderHomClass F α β] [MonoidHomClass F α β] (f : F) :

α →*o β

Turn an element of a type F satisfying OrderHomClass F α β and MonoidHomClass F α β into an actual OrderMonoidHom. This is declared as the default coercion from F to α →*o β.

Equations

↑f = { toMonoidHom := ↑f, monotone' := ⋯ }

instance instCoeTCOrderAddMonoidHomOfOrderHomClassOfAddMonoidHomClass {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] [FunLike F α β] [OrderHomClass F α β] [AddMonoidHomClass F α β] :

CoeTC F (α →+o β)

Any type satisfying OrderAddMonoidHomClass can be cast into OrderAddMonoidHom via OrderAddMonoidHomClass.toOrderAddMonoidHom

Equations

instCoeTCOrderAddMonoidHomOfOrderHomClassOfAddMonoidHomClass = { coe := OrderMonoidHomClass.toOrderAddMonoidHom }

instance instCoeTCOrderMonoidHomOfOrderHomClassOfMonoidHomClass {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] [FunLike F α β] [OrderHomClass F α β] [MonoidHomClass F α β] :

CoeTC F (α →*o β)

Any type satisfying OrderMonoidHomClass can be cast into OrderMonoidHom via OrderMonoidHomClass.toOrderMonoidHom.

Equations

instCoeTCOrderMonoidHomOfOrderHomClassOfMonoidHomClass = { coe := OrderMonoidHomClass.toOrderMonoidHom }

structure OrderMonoidIso (α : Type u_6) (β : Type u_7) [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] extends MulEquiv :

Type (max u_6 u_7)

α ≃*o β is the type of isomorphisms α ≃ β that preserve the OrderedCommMonoid structure.

OrderMonoidIso is also used for ordered group isomorphisms.

When possible, instead of parametrizing results over (f : α ≃*o β), you should parametrize over (F : Type*) [FunLike F M N] [MulEquivClass F M N] [OrderIsoClass F M N] (f : F).

toFun : α → β
invFun : β → α
left_inv : Function.LeftInverse self.invFun self.toFun
right_inv : Function.RightInverse self.invFun self.toFun
map_mul' : ∀ (x y : α), self.toFun (x * y) = self.toFun x * self.toFun y
map_le_map_iff' : ∀ {a b : α}, self.toFun a ≤ self.toFun b ↔ a ≤ b
An OrderMonoidIso respects ≤.

Instances For

theorem OrderMonoidIso.map_le_map_iff' {α : Type u_6} {β : Type u_7} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (self : α ≃*o β) {a : α} {b : α} :

self.toFun a ≤ self.toFun b ↔ a ≤ b

An OrderMonoidIso respects ≤.

def «term_≃*o_» :

Lean.TrailingParserDescr

Infix notation for OrderMonoidIso.

Equations

«term_≃*o_» = Lean.ParserDescr.trailingNode `term_≃*o_ 25 26 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " ≃*o ") (Lean.ParserDescr.cat `term 25))

theorem OrderMonoidIsoClass.toOrderAddMonoidIso.proof_1 {F : Type u_2} {α : Type u_3} {β : Type u_1} [Preorder α] [Preorder β] [EquivLike F α β] [OrderIsoClass F α β] (f : F) :

∀ {a b : α}, f a ≤ f b ↔ a ≤ b

def OrderMonoidIsoClass.toOrderAddMonoidIso {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] [EquivLike F α β] [OrderIsoClass F α β] [AddEquivClass F α β] (f : F) :

α ≃+o β

Turn an element of a type F satisfying OrderIsoClass F α β and AddEquivClass F α β into an actual OrderAddMonoidIso. This is declared as the default coercion from F to α ≃+o β.

Equations

↑f = { toAddEquiv := ↑f, map_le_map_iff' := ⋯ }

def OrderMonoidIsoClass.toOrderMonoidIso {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] [EquivLike F α β] [OrderIsoClass F α β] [MulEquivClass F α β] (f : F) :

α ≃*o β

Turn an element of a type F satisfying OrderIsoClass F α β and MulEquivClass F α β into an actual OrderMonoidIso. This is declared as the default coercion from F to α ≃*o β.

Equations

↑f = { toMulEquiv := ↑f, map_le_map_iff' := ⋯ }

instance instCoeTCOrderAddMonoidHomOfOrderHomClassOfAddMonoidHomClass_1 {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] [FunLike F α β] [OrderHomClass F α β] [AddMonoidHomClass F α β] :

CoeTC F (α →+o β)

Any type satisfying OrderAddMonoidHomClass can be cast into OrderAddMonoidHom via OrderAddMonoidHomClass.toOrderAddMonoidHom

Equations

instCoeTCOrderAddMonoidHomOfOrderHomClassOfAddMonoidHomClass_1 = { coe := OrderMonoidHomClass.toOrderAddMonoidHom }

instance instCoeTCOrderMonoidHomOfOrderHomClassOfMonoidHomClass_1 {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] [FunLike F α β] [OrderHomClass F α β] [MonoidHomClass F α β] :

CoeTC F (α →*o β)

Any type satisfying OrderMonoidHomClass can be cast into OrderMonoidHom via OrderMonoidHomClass.toOrderMonoidHom.

Equations

instCoeTCOrderMonoidHomOfOrderHomClassOfMonoidHomClass_1 = { coe := OrderMonoidHomClass.toOrderMonoidHom }

instance instCoeTCOrderAddMonoidIsoOfOrderIsoClassOfAddEquivClass {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] [EquivLike F α β] [OrderIsoClass F α β] [AddEquivClass F α β] :

CoeTC F (α ≃+o β)

Any type satisfying OrderAddMonoidIsoClass can be cast into OrderAddMonoidIso via OrderAddMonoidIsoClass.toOrderAddMonoidIso

Equations

instCoeTCOrderAddMonoidIsoOfOrderIsoClassOfAddEquivClass = { coe := OrderMonoidIsoClass.toOrderAddMonoidIso }

instance instCoeTCOrderMonoidIsoOfOrderIsoClassOfMulEquivClass {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] [EquivLike F α β] [OrderIsoClass F α β] [MulEquivClass F α β] :

CoeTC F (α ≃*o β)

Any type satisfying OrderMonoidIsoClass can be cast into OrderMonoidIso via OrderMonoidIsoClass.toOrderMonoidIso.

Equations

instCoeTCOrderMonoidIsoOfOrderIsoClassOfMulEquivClass = { coe := OrderMonoidIsoClass.toOrderMonoidIso }

structure OrderMonoidWithZeroHom (α : Type u_6) (β : Type u_7) [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] extends MonoidWithZeroHom :

Type (max u_6 u_7)

OrderMonoidWithZeroHom α β is the type of functions α → β that preserve the MonoidWithZero structure.

OrderMonoidWithZeroHom is also used for group homomorphisms.

When possible, instead of parametrizing results over (f : α →+ β), you should parameterize over (F : Type*) [FunLike F M N] [MonoidWithZeroHomClass F M N] [OrderHomClass F M N] (f : F).

toFun : α → β
map_zero' : (↑self.toMonoidWithZeroHom).toFun 0 = 0
map_one' : (↑self.toMonoidWithZeroHom).toFun 1 = 1
map_mul' : ∀ (x y : α), (↑self.toMonoidWithZeroHom).toFun (x * y) = (↑self.toMonoidWithZeroHom).toFun x * (↑self.toMonoidWithZeroHom).toFun y
monotone' : Monotone (↑self.toMonoidWithZeroHom).toFun
An OrderMonoidWithZeroHom is a monotone function.

Instances For

theorem OrderMonoidWithZeroHom.monotone' {α : Type u_6} {β : Type u_7} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (self : α →*₀o β) :

Monotone (↑self.toMonoidWithZeroHom).toFun

An OrderMonoidWithZeroHom is a monotone function.

def «term_→*₀o_» :

Lean.TrailingParserDescr

Infix notation for OrderMonoidWithZeroHom.

Equations

«term_→*₀o_» = Lean.ParserDescr.trailingNode `term_→*₀o_ 25 26 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " →*₀o ") (Lean.ParserDescr.cat `term 25))

def OrderMonoidWithZeroHomClass.toOrderMonoidWithZeroHom {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] [FunLike F α β] [OrderHomClass F α β] [MonoidWithZeroHomClass F α β] (f : F) :

Turn an element of a type F satisfying OrderHomClass F α β and MonoidWithZeroHomClass F α β into an actual OrderMonoidWithZeroHom. This is declared as the default coercion from F to α →+*₀o β.

Equations

↑f = { toMonoidWithZeroHom := ↑f, monotone' := ⋯ }

instance instCoeTCOrderMonoidWithZeroHomOfOrderHomClassOfMonoidWithZeroHomClass {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] [FunLike F α β] [OrderHomClass F α β] [MonoidWithZeroHomClass F α β] :

CoeTC F (α →*₀o β)

Equations

instCoeTCOrderMonoidWithZeroHomOfOrderHomClassOfMonoidWithZeroHomClass = { coe := OrderMonoidWithZeroHomClass.toOrderMonoidWithZeroHom }

theorem map_nonneg {F : Type u_1} {α : Type u_2} {β : Type u_3} [FunLike F α β] [Preorder α] [Zero α] [Preorder β] [Zero β] [OrderHomClass F α β] [ZeroHomClass F α β] (f : F) {a : α} (ha : 0 ≤ a) :

0 ≤ f a

See also NonnegHomClass.apply_nonneg.

theorem map_nonpos {F : Type u_1} {α : Type u_2} {β : Type u_3} [FunLike F α β] [Preorder α] [Zero α] [Preorder β] [Zero β] [OrderHomClass F α β] [ZeroHomClass F α β] (f : F) {a : α} (ha : a ≤ 0) :

f a ≤ 0

theorem monotone_iff_map_nonneg {F : Type u_1} {α : Type u_2} {β : Type u_3} [OrderedAddCommGroup α] [OrderedAddCommMonoid β] [i : FunLike F α β] (f : F) [iamhc : AddMonoidHomClass F α β] :

Monotone ⇑f ↔ ∀ (a : α), 0 ≤ a → 0 ≤ f a

theorem antitone_iff_map_nonpos {F : Type u_1} {α : Type u_2} {β : Type u_3} [OrderedAddCommGroup α] [OrderedAddCommMonoid β] [i : FunLike F α β] (f : F) [iamhc : AddMonoidHomClass F α β] :

Antitone ⇑f ↔ ∀ (a : α), 0 ≤ a → f a ≤ 0

theorem monotone_iff_map_nonpos {F : Type u_1} {α : Type u_2} {β : Type u_3} [OrderedAddCommGroup α] [OrderedAddCommMonoid β] [i : FunLike F α β] (f : F) [iamhc : AddMonoidHomClass F α β] :

Monotone ⇑f ↔ ∀ (a : α), a ≤ 0 → f a ≤ 0

theorem antitone_iff_map_nonneg {F : Type u_1} {α : Type u_2} {β : Type u_3} [OrderedAddCommGroup α] [OrderedAddCommMonoid β] [i : FunLike F α β] (f : F) [iamhc : AddMonoidHomClass F α β] :

Antitone ⇑f ↔ ∀ (a : α), a ≤ 0 → 0 ≤ f a

theorem strictMono_iff_map_pos {F : Type u_1} {α : Type u_2} {β : Type u_3} [OrderedAddCommGroup α] [OrderedAddCommMonoid β] [i : FunLike F α β] (f : F) [iamhc : AddMonoidHomClass F α β] [CovariantClass β β (fun (x1 x2 : β) => x1 + x2) fun (x1 x2 : β) => x1 < x2] :

StrictMono ⇑f ↔ ∀ (a : α), 0 < a → 0 < f a

theorem strictAnti_iff_map_neg {F : Type u_1} {α : Type u_2} {β : Type u_3} [OrderedAddCommGroup α] [OrderedAddCommMonoid β] [i : FunLike F α β] (f : F) [iamhc : AddMonoidHomClass F α β] [CovariantClass β β (fun (x1 x2 : β) => x1 + x2) fun (x1 x2 : β) => x1 < x2] :

StrictAnti ⇑f ↔ ∀ (a : α), 0 < a → f a < 0

theorem strictMono_iff_map_neg {F : Type u_1} {α : Type u_2} {β : Type u_3} [OrderedAddCommGroup α] [OrderedAddCommMonoid β] [i : FunLike F α β] (f : F) [iamhc : AddMonoidHomClass F α β] [CovariantClass β β (fun (x1 x2 : β) => x1 + x2) fun (x1 x2 : β) => x1 < x2] :

StrictMono ⇑f ↔ ∀ (a : α), a < 0 → f a < 0

theorem strictAnti_iff_map_pos {F : Type u_1} {α : Type u_2} {β : Type u_3} [OrderedAddCommGroup α] [OrderedAddCommMonoid β] [i : FunLike F α β] (f : F) [iamhc : AddMonoidHomClass F α β] [CovariantClass β β (fun (x1 x2 : β) => x1 + x2) fun (x1 x2 : β) => x1 < x2] :

StrictAnti ⇑f ↔ ∀ (a : α), a < 0 → 0 < f a

theorem OrderAddMonoidHom.instFunLike.proof_1 {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) (g : α →+o β) (h : (fun (f : α →+o β) => (↑f.toAddMonoidHom).toFun) f = (fun (f : α →+o β) => (↑f.toAddMonoidHom).toFun) g) :

f = g

instance OrderAddMonoidHom.instFunLike {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

FunLike (α →+o β) α β

Equations

OrderAddMonoidHom.instFunLike = { coe := fun (f : α →+o β) => (↑f.toAddMonoidHom).toFun, coe_injective' := ⋯ }

instance OrderMonoidHom.instFunLike {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

FunLike (α →*o β) α β

Equations

OrderMonoidHom.instFunLike = { coe := fun (f : α →*o β) => (↑f.toMonoidHom).toFun, coe_injective' := ⋯ }

instance OrderAddMonoidHom.instOrderHomClass {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

OrderHomClass (α →+o β) α β

Equations

⋯ = ⋯

instance OrderMonoidHom.instOrderHomClass {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

OrderHomClass (α →*o β) α β

Equations

⋯ = ⋯

instance OrderAddMonoidHom.instAddMonoidHomClass {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

AddMonoidHomClass (α →+o β) α β

Equations

⋯ = ⋯

instance OrderMonoidHom.instMonoidHomClass {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

MonoidHomClass (α →*o β) α β

Equations

⋯ = ⋯

theorem OrderAddMonoidHom.ext {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] {f : α →+o β} {g : α →+o β} (h : ∀ (a : α), f a = g a) :

f = g

theorem OrderMonoidHom.ext_iff {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] {f : α →*o β} {g : α →*o β} :

f = g ↔ ∀ (a : α), f a = g a

theorem OrderAddMonoidHom.ext_iff {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] {f : α →+o β} {g : α →+o β} :

f = g ↔ ∀ (a : α), f a = g a

theorem OrderMonoidHom.ext {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] {f : α →*o β} {g : α →*o β} (h : ∀ (a : α), f a = g a) :

f = g

theorem OrderAddMonoidHom.toFun_eq_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) :

(↑f.toAddMonoidHom).toFun = ⇑f

theorem OrderMonoidHom.toFun_eq_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) :

(↑f.toMonoidHom).toFun = ⇑f

@[simp]

theorem OrderAddMonoidHom.coe_mk {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+ β) (h : Monotone (↑f).toFun) :

⇑{ toAddMonoidHom := f, monotone' := h } = ⇑f

@[simp]

theorem OrderMonoidHom.coe_mk {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →* β) (h : Monotone (↑f).toFun) :

⇑{ toMonoidHom := f, monotone' := h } = ⇑f

@[simp]

theorem OrderAddMonoidHom.mk_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) (h : Monotone (↑↑f).toFun) :

{ toAddMonoidHom := ↑f, monotone' := h } = f

@[simp]

theorem OrderMonoidHom.mk_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) (h : Monotone (↑↑f).toFun) :

{ toMonoidHom := ↑f, monotone' := h } = f

def OrderAddMonoidHom.toOrderHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) :

α →o β

Reinterpret an ordered additive monoid homomorphism as an order homomorphism.

Equations

f.toOrderHom = { toFun := (↑f.toAddMonoidHom).toFun, monotone' := ⋯ }

def OrderMonoidHom.toOrderHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) :

α →o β

Reinterpret an ordered monoid homomorphism as an order homomorphism.

Equations

f.toOrderHom = { toFun := (↑f.toMonoidHom).toFun, monotone' := ⋯ }

@[simp]

theorem OrderAddMonoidHom.coe_addMonoidHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) :

⇑↑f = ⇑f

@[simp]

theorem OrderMonoidHom.coe_monoidHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) :

⇑↑f = ⇑f

@[simp]

theorem OrderAddMonoidHom.coe_orderHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) :

⇑↑f = ⇑f

@[simp]

theorem OrderMonoidHom.coe_orderHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) :

⇑↑f = ⇑f

theorem OrderAddMonoidHom.toAddMonoidHom_injective {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

Function.Injective OrderAddMonoidHom.toAddMonoidHom

theorem OrderMonoidHom.toMonoidHom_injective {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

Function.Injective OrderMonoidHom.toMonoidHom

theorem OrderAddMonoidHom.toOrderHom_injective {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

Function.Injective OrderAddMonoidHom.toOrderHom

theorem OrderMonoidHom.toOrderHom_injective {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

Function.Injective OrderMonoidHom.toOrderHom

def OrderAddMonoidHom.copy {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) (f' : α → β) (h : f' = ⇑f) :

α →+o β

Copy of an OrderAddMonoidHom with a new toFun equal to the old one. Useful to fix definitional equalities.

Equations

f.copy f' h = { toFun := f', map_zero' := ⋯, map_add' := ⋯, monotone' := ⋯ }

theorem OrderAddMonoidHom.copy.proof_2 {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) (f' : α → β) (h : f' = ⇑f) :

theorem OrderAddMonoidHom.copy.proof_1 {α : Type u_2} {β : Type u_1} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) (f' : α → β) (h : f' = ⇑f) :

(↑(f.copy f' h)).toFun 0 = 0

def OrderMonoidHom.copy {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) (f' : α → β) (h : f' = ⇑f) :

α →*o β

Copy of an OrderMonoidHom with a new toFun equal to the old one. Useful to fix definitional equalities.

Equations

f.copy f' h = { toFun := f', map_one' := ⋯, map_mul' := ⋯, monotone' := ⋯ }

@[simp]

theorem OrderAddMonoidHom.coe_copy {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) (f' : α → β) (h : f' = ⇑f) :

⇑(f.copy f' h) = f'

@[simp]

theorem OrderMonoidHom.coe_copy {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) (f' : α → β) (h : f' = ⇑f) :

⇑(f.copy f' h) = f'

theorem OrderAddMonoidHom.copy_eq {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) (f' : α → β) (h : f' = ⇑f) :

f.copy f' h = f

theorem OrderMonoidHom.copy_eq {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) (f' : α → β) (h : f' = ⇑f) :

f.copy f' h = f

def OrderAddMonoidHom.id (α : Type u_2) [Preorder α] [AddZeroClass α] :

α →+o α

The identity map as an ordered additive monoid homomorphism.

Equations

OrderAddMonoidHom.id α = { toAddMonoidHom := AddMonoidHom.id α, monotone' := ⋯ }

def OrderMonoidHom.id (α : Type u_2) [Preorder α] [MulOneClass α] :

α →*o α

The identity map as an ordered monoid homomorphism.

Equations

OrderMonoidHom.id α = { toMonoidHom := MonoidHom.id α, monotone' := ⋯ }

@[simp]

theorem OrderAddMonoidHom.coe_id (α : Type u_2) [Preorder α] [AddZeroClass α] :

⇑(OrderAddMonoidHom.id α) = id

@[simp]

theorem OrderMonoidHom.coe_id (α : Type u_2) [Preorder α] [MulOneClass α] :

⇑(OrderMonoidHom.id α) = id

instance OrderAddMonoidHom.instInhabited (α : Type u_2) [Preorder α] [AddZeroClass α] :

Inhabited (α →+o α)

Equations

OrderAddMonoidHom.instInhabited α = { default := OrderAddMonoidHom.id α }

instance OrderMonoidHom.instInhabited (α : Type u_2) [Preorder α] [MulOneClass α] :

Inhabited (α →*o α)

Equations

OrderMonoidHom.instInhabited α = { default := OrderMonoidHom.id α }

def OrderAddMonoidHom.comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : β →+o γ) (g : α →+o β) :

α →+o γ

Composition of OrderAddMonoidHoms as an OrderAddMonoidHom

Equations

f.comp g = { toAddMonoidHom := f.comp ↑g, monotone' := ⋯ }

def OrderMonoidHom.comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : β →*o γ) (g : α →*o β) :

α →*o γ

Composition of OrderMonoidHoms as an OrderMonoidHom.

Equations

f.comp g = { toMonoidHom := f.comp ↑g, monotone' := ⋯ }

@[simp]

theorem OrderAddMonoidHom.coe_comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : β →+o γ) (g : α →+o β) :

⇑(f.comp g) = ⇑f ∘ ⇑g

@[simp]

theorem OrderMonoidHom.coe_comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : β →*o γ) (g : α →*o β) :

⇑(f.comp g) = ⇑f ∘ ⇑g

@[simp]

theorem OrderAddMonoidHom.comp_apply {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : β →+o γ) (g : α →+o β) (a : α) :

(f.comp g) a = f (g a)

@[simp]

theorem OrderMonoidHom.comp_apply {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : β →*o γ) (g : α →*o β) (a : α) :

(f.comp g) a = f (g a)

theorem OrderAddMonoidHom.coe_comp_addMonoidHom {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : β →+o γ) (g : α →+o β) :

↑(f.comp g) = (↑f).comp ↑g

theorem OrderMonoidHom.coe_comp_monoidHom {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : β →*o γ) (g : α →*o β) :

↑(f.comp g) = (↑f).comp ↑g

theorem OrderAddMonoidHom.coe_comp_orderHom {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : β →+o γ) (g : α →+o β) :

↑(f.comp g) = (↑f).comp ↑g

theorem OrderMonoidHom.coe_comp_orderHom {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : β →*o γ) (g : α →*o β) :

↑(f.comp g) = (↑f).comp ↑g

@[simp]

theorem OrderAddMonoidHom.comp_assoc {α : Type u_2} {β : Type u_3} {γ : Type u_4} {δ : Type u_5} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] [AddZeroClass δ] (f : γ →+o δ) (g : β →+o γ) (h : α →+o β) :

(f.comp g).comp h = f.comp (g.comp h)

@[simp]

theorem OrderMonoidHom.comp_assoc {α : Type u_2} {β : Type u_3} {γ : Type u_4} {δ : Type u_5} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] [MulOneClass δ] (f : γ →*o δ) (g : β →*o γ) (h : α →*o β) :

(f.comp g).comp h = f.comp (g.comp h)

@[simp]

theorem OrderAddMonoidHom.comp_id {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) :

f.comp (OrderAddMonoidHom.id α) = f

@[simp]

theorem OrderMonoidHom.comp_id {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) :

f.comp (OrderMonoidHom.id α) = f

@[simp]

theorem OrderAddMonoidHom.id_comp {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) :

(OrderAddMonoidHom.id β).comp f = f

@[simp]

theorem OrderMonoidHom.id_comp {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) :

(OrderMonoidHom.id β).comp f = f

@[simp]

theorem OrderAddMonoidHom.cancel_right {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] {g₁ : β →+o γ} {g₂ : β →+o γ} {f : α →+o β} (hf : Function.Surjective ⇑f) :

g₁.comp f = g₂.comp f ↔ g₁ = g₂

@[simp]

theorem OrderMonoidHom.cancel_right {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] {g₁ : β →*o γ} {g₂ : β →*o γ} {f : α →*o β} (hf : Function.Surjective ⇑f) :

g₁.comp f = g₂.comp f ↔ g₁ = g₂

@[simp]

theorem OrderAddMonoidHom.cancel_left {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] {g : β →+o γ} {f₁ : α →+o β} {f₂ : α →+o β} (hg : Function.Injective ⇑g) :

g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

@[simp]

theorem OrderMonoidHom.cancel_left {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] {g : β →*o γ} {f₁ : α →*o β} {f₂ : α →*o β} (hg : Function.Injective ⇑g) :

g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

instance OrderAddMonoidHom.instZero {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

Zero (α →+o β)

0 is the homomorphism sending all elements to 0.

Equations

OrderAddMonoidHom.instZero = { zero := let __src := 0; { toAddMonoidHom := __src, monotone' := ⋯ } }

theorem OrderAddMonoidHom.instZero.proof_1 {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [AddZeroClass β] :

Monotone fun (x : α) => AddZeroClass.toZero.1

instance OrderMonoidHom.instOne {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

One (α →*o β)

1 is the homomorphism sending all elements to 1.

Equations

OrderMonoidHom.instOne = { one := let __src := 1; { toMonoidHom := __src, monotone' := ⋯ } }

@[simp]

theorem OrderAddMonoidHom.coe_zero {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

⇑0 = 0

@[simp]

theorem OrderMonoidHom.coe_one {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

⇑1 = 1

@[simp]

theorem OrderAddMonoidHom.zero_apply {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (a : α) :

0 a = 0

@[simp]

theorem OrderMonoidHom.one_apply {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (a : α) :

1 a = 1

@[simp]

theorem OrderAddMonoidHom.zero_comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : α →+o β) :

OrderAddMonoidHom.comp 0 f = 0

@[simp]

theorem OrderMonoidHom.one_comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : α →*o β) :

OrderMonoidHom.comp 1 f = 1

@[simp]

theorem OrderAddMonoidHom.comp_zero {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : β →+o γ) :

f.comp 0 = 0

@[simp]

theorem OrderMonoidHom.comp_one {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : β →*o γ) :

f.comp 1 = 1

theorem OrderAddMonoidHom.instAdd.proof_1 {α : Type u_2} {β : Type u_1} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] :

AddMonoidHomClass (α →+o β) α β

theorem OrderAddMonoidHom.instAdd.proof_2 {α : Type u_1} {β : Type u_2} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] (f : α →+o β) (g : α →+o β) :

Monotone fun (x : α) => (↑f.toAddMonoidHom).toFun x + ↑g x

instance OrderAddMonoidHom.instAdd {α : Type u_2} {β : Type u_3} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] :

Add (α →+o β)

For two ordered additive monoid morphisms f and g, their product is the ordered additive monoid morphism sending a to f a + g a.

Equations

OrderAddMonoidHom.instAdd = { add := fun (f g : α →+o β) => let __src := ↑f + ↑g; { toAddMonoidHom := __src, monotone' := ⋯ } }

instance OrderMonoidHom.instMul {α : Type u_2} {β : Type u_3} [OrderedCommMonoid α] [OrderedCommMonoid β] :

Mul (α →*o β)

For two ordered monoid morphisms f and g, their product is the ordered monoid morphism sending a to f a * g a.

Equations

OrderMonoidHom.instMul = { mul := fun (f g : α →*o β) => let __src := ↑f * ↑g; { toMonoidHom := __src, monotone' := ⋯ } }

@[simp]

theorem OrderAddMonoidHom.coe_add {α : Type u_2} {β : Type u_3} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] (f : α →+o β) (g : α →+o β) :

⇑(f + g) = ⇑f + ⇑g

@[simp]

theorem OrderMonoidHom.coe_mul {α : Type u_2} {β : Type u_3} [OrderedCommMonoid α] [OrderedCommMonoid β] (f : α →*o β) (g : α →*o β) :

⇑(f * g) = ⇑f * ⇑g

@[simp]

theorem OrderAddMonoidHom.add_apply {α : Type u_2} {β : Type u_3} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] (f : α →+o β) (g : α →+o β) (a : α) :

(f + g) a = f a + g a

@[simp]

theorem OrderMonoidHom.mul_apply {α : Type u_2} {β : Type u_3} [OrderedCommMonoid α] [OrderedCommMonoid β] (f : α →*o β) (g : α →*o β) (a : α) :

(f * g) a = f a * g a

theorem OrderAddMonoidHom.add_comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] [OrderedAddCommMonoid γ] (g₁ : β →+o γ) (g₂ : β →+o γ) (f : α →+o β) :

(g₁ + g₂).comp f = g₁.comp f + g₂.comp f

theorem OrderMonoidHom.mul_comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [OrderedCommMonoid α] [OrderedCommMonoid β] [OrderedCommMonoid γ] (g₁ : β →*o γ) (g₂ : β →*o γ) (f : α →*o β) :

(g₁ * g₂).comp f = g₁.comp f * g₂.comp f

theorem OrderAddMonoidHom.comp_add {α : Type u_2} {β : Type u_3} {γ : Type u_4} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] [OrderedAddCommMonoid γ] (g : β →+o γ) (f₁ : α →+o β) (f₂ : α →+o β) :

g.comp (f₁ + f₂) = g.comp f₁ + g.comp f₂

theorem OrderMonoidHom.comp_mul {α : Type u_2} {β : Type u_3} {γ : Type u_4} [OrderedCommMonoid α] [OrderedCommMonoid β] [OrderedCommMonoid γ] (g : β →*o γ) (f₁ : α →*o β) (f₂ : α →*o β) :

g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂

@[simp]

theorem OrderAddMonoidHom.toAddMonoidHom_eq_coe {α : Type u_2} {β : Type u_3} {hα : OrderedAddCommMonoid α} {hβ : OrderedAddCommMonoid β} (f : α →+o β) :

f.toAddMonoidHom = ↑f

@[simp]

theorem OrderMonoidHom.toMonoidHom_eq_coe {α : Type u_2} {β : Type u_3} {hα : OrderedCommMonoid α} {hβ : OrderedCommMonoid β} (f : α →*o β) :

f.toMonoidHom = ↑f

@[simp]

theorem OrderAddMonoidHom.toOrderHom_eq_coe {α : Type u_2} {β : Type u_3} {hα : OrderedAddCommMonoid α} {hβ : OrderedAddCommMonoid β} (f : α →+o β) :

f.toOrderHom = ↑f

@[simp]

theorem OrderMonoidHom.toOrderHom_eq_coe {α : Type u_2} {β : Type u_3} {hα : OrderedCommMonoid α} {hβ : OrderedCommMonoid β} (f : α →*o β) :

f.toOrderHom = ↑f

def OrderAddMonoidHom.mk' {α : Type u_2} {β : Type u_3} {hα : OrderedAddCommGroup α} {hβ : OrderedAddCommGroup β} (f : α → β) (hf : Monotone f) (map_mul : ∀ (a b : α), f (a + b) = f a + f b) :

α →+o β

Makes an ordered additive group homomorphism from a proof that the map preserves addition.

Equations

OrderAddMonoidHom.mk' f hf map_mul = { toAddMonoidHom := AddMonoidHom.mk' f map_mul, monotone' := hf }

def OrderMonoidHom.mk' {α : Type u_2} {β : Type u_3} {hα : OrderedCommGroup α} {hβ : OrderedCommGroup β} (f : α → β) (hf : Monotone f) (map_mul : ∀ (a b : α), f (a * b) = f a * f b) :

α →*o β

Makes an ordered group homomorphism from a proof that the map preserves multiplication.

Equations

OrderMonoidHom.mk' f hf map_mul = { toMonoidHom := MonoidHom.mk' f map_mul, monotone' := hf }

theorem OrderAddMonoidIso.instEquivLike.proof_2 {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

Function.RightInverse f.invFun f.toFun

theorem OrderAddMonoidIso.instEquivLike.proof_3 {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) (g : α ≃+o β) (h₁ : (fun (f : α ≃+o β) => f.toFun) f = (fun (f : α ≃+o β) => f.toFun) g) (h₂ : (fun (f : α ≃+o β) => f.invFun) f = (fun (f : α ≃+o β) => f.invFun) g) :

f = g

instance OrderAddMonoidIso.instEquivLike {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

EquivLike (α ≃+o β) α β

Equations

OrderAddMonoidIso.instEquivLike = { coe := fun (f : α ≃+o β) => f.toFun, inv := fun (f : α ≃+o β) => f.invFun, left_inv := ⋯, right_inv := ⋯, coe_injective' := ⋯ }

theorem OrderAddMonoidIso.instEquivLike.proof_1 {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

Function.LeftInverse f.invFun f.toFun

instance OrderMonoidIso.instEquivLike {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

EquivLike (α ≃*o β) α β

Equations

OrderMonoidIso.instEquivLike = { coe := fun (f : α ≃*o β) => f.toFun, inv := fun (f : α ≃*o β) => f.invFun, left_inv := ⋯, right_inv := ⋯, coe_injective' := ⋯ }

instance OrderAddMonoidIso.instOrderIsoClass {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

OrderIsoClass (α ≃+o β) α β

Equations

⋯ = ⋯

instance OrderMonoidIso.instOrderIsoClass {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

OrderIsoClass (α ≃*o β) α β

Equations

⋯ = ⋯

instance OrderAddMonoidIso.instAddEquivClass {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

AddEquivClass (α ≃+o β) α β

Equations

⋯ = ⋯

instance OrderMonoidIso.instMulEquivClass {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

MulEquivClass (α ≃*o β) α β

Equations

⋯ = ⋯

theorem OrderAddMonoidIso.ext {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] {f : α ≃+o β} {g : α ≃+o β} (h : ∀ (a : α), f a = g a) :

f = g

theorem OrderMonoidIso.ext_iff {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] {f : α ≃*o β} {g : α ≃*o β} :

f = g ↔ ∀ (a : α), f a = g a

theorem OrderAddMonoidIso.ext_iff {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] {f : α ≃+o β} {g : α ≃+o β} :

f = g ↔ ∀ (a : α), f a = g a

theorem OrderMonoidIso.ext {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] {f : α ≃*o β} {g : α ≃*o β} (h : ∀ (a : α), f a = g a) :

f = g

theorem OrderAddMonoidIso.toFun_eq_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

f.toFun = ⇑f

theorem OrderMonoidIso.toFun_eq_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) :

f.toFun = ⇑f

@[simp]

theorem OrderAddMonoidIso.coe_mk {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+ β) (h : ∀ {a b : α}, f.toFun a ≤ f.toFun b ↔ a ≤ b) :

⇑{ toAddEquiv := f, map_le_map_iff' := h } = ⇑f

@[simp]

theorem OrderMonoidIso.coe_mk {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃* β) (h : ∀ {a b : α}, f.toFun a ≤ f.toFun b ↔ a ≤ b) :

⇑{ toMulEquiv := f, map_le_map_iff' := h } = ⇑f

@[simp]

theorem OrderAddMonoidIso.mk_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) (h : ∀ {a b : α}, (↑f).toFun a ≤ (↑f).toFun b ↔ a ≤ b) :

{ toAddEquiv := ↑f, map_le_map_iff' := h } = f

@[simp]

theorem OrderMonoidIso.mk_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) (h : ∀ {a b : α}, (↑f).toFun a ≤ (↑f).toFun b ↔ a ≤ b) :

{ toMulEquiv := ↑f, map_le_map_iff' := h } = f

theorem OrderAddMonoidIso.toOrderIso.proof_1 {α : Type u_2} {β : Type u_1} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

∀ {a b : α}, f a ≤ f b ↔ a ≤ b

def OrderAddMonoidIso.toOrderIso {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

α ≃o β

Reinterpret an ordered additive monoid isomomorphism as an order isomomorphism.

Equations

f.toOrderIso = { toEquiv := f.toEquiv, map_rel_iff' := ⋯ }

def OrderMonoidIso.toOrderIso {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) :

α ≃o β

Reinterpret an ordered monoid isomorphism as an order isomorphism.

Equations

f.toOrderIso = { toEquiv := f.toEquiv, map_rel_iff' := ⋯ }

@[simp]

theorem OrderAddMonoidIso.coe_addEquiv {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

⇑↑f = ⇑f

@[simp]

theorem OrderMonoidIso.coe_mulEquiv {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) :

⇑↑f = ⇑f

@[simp]

theorem OrderAddMonoidIso.coe_orderIso {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

⇑↑f = ⇑f

@[simp]

theorem OrderMonoidIso.coe_orderIso {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) :

⇑↑f = ⇑f

theorem OrderAddMonoidIso.toAddEquiv_injective {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

Function.Injective OrderAddMonoidIso.toAddEquiv

theorem OrderMonoidIso.toMulEquiv_injective {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

Function.Injective OrderMonoidIso.toMulEquiv

theorem OrderAddMonoidIso.toOrderIso_injective {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] :

Function.Injective OrderAddMonoidIso.toOrderIso

theorem OrderMonoidIso.toOrderIso_injective {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] :

Function.Injective OrderMonoidIso.toOrderIso

def OrderAddMonoidIso.refl (α : Type u_2) [Preorder α] [AddZeroClass α] :

α ≃+o α

The identity map as an ordered additive monoid isomorphism.

Equations

OrderAddMonoidIso.refl α = { toAddEquiv := AddEquiv.refl α, map_le_map_iff' := ⋯ }

theorem OrderAddMonoidIso.refl.proof_1 (α : Type u_1) [Preorder α] (a : α) (a : α) :

a✝ ≤ a ↔ a✝ ≤ a

def OrderMonoidIso.refl (α : Type u_2) [Preorder α] [MulOneClass α] :

α ≃*o α

The identity map as an ordered monoid isomorphism.

Equations

OrderMonoidIso.refl α = { toMulEquiv := MulEquiv.refl α, map_le_map_iff' := ⋯ }

@[simp]

theorem OrderAddMonoidIso.coe_refl (α : Type u_2) [Preorder α] [AddZeroClass α] :

⇑(OrderAddMonoidIso.refl α) = id

@[simp]

theorem OrderMonoidIso.coe_refl (α : Type u_2) [Preorder α] [MulOneClass α] :

⇑(OrderMonoidIso.refl α) = id

instance OrderAddMonoidIso.instInhabited (α : Type u_2) [Preorder α] [AddZeroClass α] :

Inhabited (α ≃+o α)

Equations

OrderAddMonoidIso.instInhabited α = { default := OrderAddMonoidIso.refl α }

instance OrderMonoidIso.instInhabited (α : Type u_2) [Preorder α] [MulOneClass α] :

Inhabited (α ≃*o α)

Equations

OrderMonoidIso.instInhabited α = { default := OrderMonoidIso.refl α }

theorem OrderAddMonoidIso.trans.proof_1 {α : Type u_3} {β : Type u_2} {γ : Type u_1} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : α ≃+o β) (g : β ≃+o γ) (a : α) (a : α) :

g (f a✝) ≤ g (f a) ↔ a✝ ≤ a

def OrderAddMonoidIso.trans {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : α ≃+o β) (g : β ≃+o γ) :

α ≃+o γ

Transitivity of addition-preserving order isomorphisms

Equations

f.trans g = { toAddEquiv := (↑f).trans ↑g, map_le_map_iff' := ⋯ }

def OrderMonoidIso.trans {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : α ≃*o β) (g : β ≃*o γ) :

α ≃*o γ

Transitivity of multiplication-preserving order isomorphisms

Equations

f.trans g = { toMulEquiv := (↑f).trans ↑g, map_le_map_iff' := ⋯ }

@[simp]

theorem OrderAddMonoidIso.coe_trans {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : α ≃+o β) (g : β ≃+o γ) :

⇑(f.trans g) = ⇑g ∘ ⇑f

@[simp]

theorem OrderMonoidIso.coe_trans {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : α ≃*o β) (g : β ≃*o γ) :

⇑(f.trans g) = ⇑g ∘ ⇑f

@[simp]

theorem OrderAddMonoidIso.trans_apply {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : α ≃+o β) (g : β ≃+o γ) (a : α) :

(f.trans g) a = g (f a)

@[simp]

theorem OrderMonoidIso.trans_apply {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : α ≃*o β) (g : β ≃*o γ) (a : α) :

(f.trans g) a = g (f a)

theorem OrderAddMonoidIso.coe_trans_addEquiv {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : α ≃+o β) (g : β ≃+o γ) :

↑(f.trans g) = (↑f).trans ↑g

theorem OrderMonoidIso.coe_trans_mulEquiv {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : α ≃*o β) (g : β ≃*o γ) :

↑(f.trans g) = (↑f).trans ↑g

theorem OrderAddMonoidIso.coe_trans_orderIso {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : α ≃+o β) (g : β ≃+o γ) :

↑(f.trans g) = (↑f).trans ↑g

theorem OrderMonoidIso.coe_trans_orderIso {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] (f : α ≃*o β) (g : β ≃*o γ) :

↑(f.trans g) = (↑f).trans ↑g

@[simp]

theorem OrderAddMonoidIso.trans_assoc {α : Type u_2} {β : Type u_3} {γ : Type u_4} {δ : Type u_5} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] [AddZeroClass δ] (f : α ≃+o β) (g : β ≃+o γ) (h : γ ≃+o δ) :

(f.trans g).trans h = f.trans (g.trans h)

@[simp]

theorem OrderMonoidIso.trans_assoc {α : Type u_2} {β : Type u_3} {γ : Type u_4} {δ : Type u_5} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] [MulOneClass δ] (f : α ≃*o β) (g : β ≃*o γ) (h : γ ≃*o δ) :

(f.trans g).trans h = f.trans (g.trans h)

@[simp]

theorem OrderAddMonoidIso.trans_refl {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

f.trans (OrderAddMonoidIso.refl β) = f

@[simp]

theorem OrderMonoidIso.trans_refl {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) :

f.trans (OrderMonoidIso.refl β) = f

@[simp]

theorem OrderAddMonoidIso.refl_trans {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

(OrderAddMonoidIso.refl α).trans f = f

@[simp]

theorem OrderMonoidIso.refl_trans {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) :

(OrderMonoidIso.refl α).trans f = f

@[simp]

theorem OrderAddMonoidIso.cancel_right {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] {g₁ : α ≃+o β} {g₂ : α ≃+o β} {f : β ≃+o γ} (hf : Function.Injective ⇑f) :

g₁.trans f = g₂.trans f ↔ g₁ = g₂

@[simp]

theorem OrderMonoidIso.cancel_right {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] {g₁ : α ≃*o β} {g₂ : α ≃*o β} {f : β ≃*o γ} (hf : Function.Injective ⇑f) :

g₁.trans f = g₂.trans f ↔ g₁ = g₂

@[simp]

theorem OrderAddMonoidIso.cancel_left {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] {g : α ≃+o β} {f₁ : β ≃+o γ} {f₂ : β ≃+o γ} (hg : Function.Surjective ⇑g) :

g.trans f₁ = g.trans f₂ ↔ f₁ = f₂

@[simp]

theorem OrderMonoidIso.cancel_left {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulOneClass α] [MulOneClass β] [MulOneClass γ] {g : α ≃*o β} {f₁ : β ≃*o γ} {f₂ : β ≃*o γ} (hg : Function.Surjective ⇑g) :

g.trans f₁ = g.trans f₂ ↔ f₁ = f₂

@[simp]

theorem OrderAddMonoidIso.toAddEquiv_eq_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

f.toAddEquiv = ↑f

@[simp]

theorem OrderMonoidIso.toMulEquiv_eq_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) :

f.toMulEquiv = ↑f

@[simp]

theorem OrderAddMonoidIso.toOrderIso_eq_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

f.toOrderIso = ↑f

@[simp]

theorem OrderMonoidIso.toOrderIso_eq_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) :

f.toOrderIso = ↑f

theorem OrderAddMonoidIso.strictMono {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

StrictMono ⇑f

theorem OrderMonoidIso.strictMono {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) :

StrictMono ⇑f

theorem OrderAddMonoidIso.strictMono_symm {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α ≃+o β) :

StrictMono ⇑f.symm

theorem OrderMonoidIso.strictMono_symm {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α ≃*o β) :

StrictMono ⇑f.symm

def OrderAddMonoidIso.mk' {α : Type u_2} {β : Type u_3} {hα : OrderedAddCommGroup α} {hβ : OrderedAddCommGroup β} (f : α ≃ β) (hf : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b) (map_mul : ∀ (a b : α), f (a + b) = f a + f b) :

α ≃+o β

Makes an ordered additive group isomorphism from a proof that the map preserves addition.

Equations

OrderAddMonoidIso.mk' f hf map_mul = { toAddEquiv := AddEquiv.mk' f map_mul, map_le_map_iff' := ⋯ }

def OrderMonoidIso.mk' {α : Type u_2} {β : Type u_3} {hα : OrderedCommGroup α} {hβ : OrderedCommGroup β} (f : α ≃ β) (hf : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b) (map_mul : ∀ (a b : α), f (a * b) = f a * f b) :

α ≃*o β

Makes an ordered group isomorphism from a proof that the map preserves multiplication.

Equations

OrderMonoidIso.mk' f hf map_mul = { toMulEquiv := MulEquiv.mk' f map_mul, map_le_map_iff' := ⋯ }

instance OrderMonoidWithZeroHom.instFunLike {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] :

FunLike (α →*₀o β) α β

Equations

OrderMonoidWithZeroHom.instFunLike = { coe := fun (f : α →*₀o β) => (↑f.toMonoidWithZeroHom).toFun, coe_injective' := ⋯ }

instance OrderMonoidWithZeroHom.instMonoidWithZeroHomClass {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] :

MonoidWithZeroHomClass (α →*₀o β) α β

Equations

⋯ = ⋯

instance OrderMonoidWithZeroHom.instOrderHomClass {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] :

OrderHomClass (α →*₀o β) α β

Equations

⋯ = ⋯

theorem OrderMonoidWithZeroHom.ext_iff {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] {f : α →*₀o β} {g : α →*₀o β} :

f = g ↔ ∀ (a : α), f a = g a

theorem OrderMonoidWithZeroHom.ext {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] {f : α →*₀o β} {g : α →*₀o β} (h : ∀ (a : α), f a = g a) :

f = g

theorem OrderMonoidWithZeroHom.toFun_eq_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) :

(↑f.toMonoidWithZeroHom).toFun = ⇑f

@[simp]

theorem OrderMonoidWithZeroHom.coe_mk {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀ β) (h : Monotone (↑f).toFun) :

⇑{ toMonoidWithZeroHom := f, monotone' := h } = ⇑f

@[simp]

theorem OrderMonoidWithZeroHom.mk_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) (h : Monotone (↑↑f).toFun) :

{ toMonoidWithZeroHom := ↑f, monotone' := h } = f

def OrderMonoidWithZeroHom.toOrderMonoidHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) :

α →*o β

Reinterpret an ordered monoid with zero homomorphism as an order monoid homomorphism.

Equations

f.toOrderMonoidHom = { toFun := (↑f.toMonoidWithZeroHom).toFun, map_one' := ⋯, map_mul' := ⋯, monotone' := ⋯ }

@[simp]

theorem OrderMonoidWithZeroHom.coe_monoidWithZeroHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) :

⇑↑f = ⇑f

@[simp]

theorem OrderMonoidWithZeroHom.coe_orderMonoidHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) :

⇑↑f = ⇑f

theorem OrderMonoidWithZeroHom.toOrderMonoidHom_injective {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] :

Function.Injective OrderMonoidWithZeroHom.toOrderMonoidHom

theorem OrderMonoidWithZeroHom.toMonoidWithZeroHom_injective {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] :

Function.Injective OrderMonoidWithZeroHom.toMonoidWithZeroHom

def OrderMonoidWithZeroHom.copy {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) (f' : α → β) (h : f' = ⇑f) :

α →*o β

Copy of an OrderMonoidWithZeroHom with a new toFun equal to the old one. Useful to fix definitional equalities.

Equations

f.copy f' h = { toFun := f', map_one' := ⋯, map_mul' := ⋯, monotone' := ⋯ }

@[simp]

theorem OrderMonoidWithZeroHom.coe_copy {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) (f' : α → β) (h : f' = ⇑f) :

⇑(f.copy f' h) = f'

theorem OrderMonoidWithZeroHom.copy_eq {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) (f' : α → β) (h : f' = ⇑f) :

f.copy f' h = ↑f

def OrderMonoidWithZeroHom.id (α : Type u_2) [Preorder α] [MulZeroOneClass α] :

The identity map as an ordered monoid with zero homomorphism.

Equations

OrderMonoidWithZeroHom.id α = { toMonoidWithZeroHom := MonoidWithZeroHom.id α, monotone' := ⋯ }

@[simp]

theorem OrderMonoidWithZeroHom.coe_id (α : Type u_2) [Preorder α] [MulZeroOneClass α] :

⇑(OrderMonoidWithZeroHom.id α) = id

instance OrderMonoidWithZeroHom.instInhabited (α : Type u_2) [Preorder α] [MulZeroOneClass α] :

Inhabited (α →*₀o α)

Equations

OrderMonoidWithZeroHom.instInhabited α = { default := OrderMonoidWithZeroHom.id α }

def OrderMonoidWithZeroHom.comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] (f : β →*₀o γ) (g : α →*₀o β) :

Composition of OrderMonoidWithZeroHoms as an OrderMonoidWithZeroHom.

Equations

f.comp g = { toMonoidWithZeroHom := f.comp ↑g, monotone' := ⋯ }

@[simp]

theorem OrderMonoidWithZeroHom.coe_comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] (f : β →*₀o γ) (g : α →*₀o β) :

⇑(f.comp g) = ⇑f ∘ ⇑g

@[simp]

theorem OrderMonoidWithZeroHom.comp_apply {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] (f : β →*₀o γ) (g : α →*₀o β) (a : α) :

(f.comp g) a = f (g a)

theorem OrderMonoidWithZeroHom.coe_comp_monoidWithZeroHom {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] (f : β →*₀o γ) (g : α →*₀o β) :

↑(f.comp g) = (↑f).comp ↑g

theorem OrderMonoidWithZeroHom.coe_comp_orderMonoidHom {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] (f : β →*₀o γ) (g : α →*₀o β) :

↑(f.comp g) = (↑f).comp ↑g

@[simp]

theorem OrderMonoidWithZeroHom.comp_assoc {α : Type u_2} {β : Type u_3} {γ : Type u_4} {δ : Type u_5} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ] [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] [MulZeroOneClass δ] (f : γ →*₀o δ) (g : β →*₀o γ) (h : α →*₀o β) :

(f.comp g).comp h = f.comp (g.comp h)

@[simp]

theorem OrderMonoidWithZeroHom.comp_id {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) :

f.comp (OrderMonoidWithZeroHom.id α) = f

@[simp]

theorem OrderMonoidWithZeroHom.id_comp {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) :

(OrderMonoidWithZeroHom.id β).comp f = f

@[simp]

theorem OrderMonoidWithZeroHom.cancel_right {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] {g₁ : β →*₀o γ} {g₂ : β →*₀o γ} {f : α →*₀o β} (hf : Function.Surjective ⇑f) :

g₁.comp f = g₂.comp f ↔ g₁ = g₂

@[simp]

theorem OrderMonoidWithZeroHom.cancel_left {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] {g : β →*₀o γ} {f₁ : α →*₀o β} {f₂ : α →*₀o β} (hg : Function.Injective ⇑g) :

g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

instance OrderMonoidWithZeroHom.instMul {α : Type u_2} {β : Type u_3} [LinearOrderedCommMonoidWithZero α] [LinearOrderedCommMonoidWithZero β] :

Mul (α →*₀o β)

For two ordered monoid morphisms f and g, their product is the ordered monoid morphism sending a to f a * g a.

Equations

OrderMonoidWithZeroHom.instMul = { mul := fun (f g : α →*₀o β) => let __src := ↑f * ↑g; { toMonoidWithZeroHom := __src, monotone' := ⋯ } }

@[simp]

theorem OrderMonoidWithZeroHom.coe_mul {α : Type u_2} {β : Type u_3} [LinearOrderedCommMonoidWithZero α] [LinearOrderedCommMonoidWithZero β] (f : α →*₀o β) (g : α →*₀o β) :

⇑(f * g) = ⇑f * ⇑g

@[simp]

theorem OrderMonoidWithZeroHom.mul_apply {α : Type u_2} {β : Type u_3} [LinearOrderedCommMonoidWithZero α] [LinearOrderedCommMonoidWithZero β] (f : α →*₀o β) (g : α →*₀o β) (a : α) :

(f * g) a = f a * g a

theorem OrderMonoidWithZeroHom.mul_comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [LinearOrderedCommMonoidWithZero α] [LinearOrderedCommMonoidWithZero β] [LinearOrderedCommMonoidWithZero γ] (g₁ : β →*₀o γ) (g₂ : β →*₀o γ) (f : α →*₀o β) :

(g₁ * g₂).comp f = g₁.comp f * g₂.comp f

theorem OrderMonoidWithZeroHom.comp_mul {α : Type u_2} {β : Type u_3} {γ : Type u_4} [LinearOrderedCommMonoidWithZero α] [LinearOrderedCommMonoidWithZero β] [LinearOrderedCommMonoidWithZero γ] (g : β →*₀o γ) (f₁ : α →*₀o β) (f₂ : α →*₀o β) :

g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂

@[simp]

theorem OrderMonoidWithZeroHom.toMonoidWithZeroHom_eq_coe {α : Type u_2} {β : Type u_3} {hα : Preorder α} {hα' : MulZeroOneClass α} {hβ : Preorder β} {hβ' : MulZeroOneClass β} (f : α →*₀o β) :

f.toMonoidWithZeroHom = ↑f

@[simp]

theorem OrderMonoidWithZeroHom.toOrderMonoidHom_eq_coe {α : Type u_2} {β : Type u_3} {hα : Preorder α} {hα' : MulZeroOneClass α} {hβ : Preorder β} {hβ' : MulZeroOneClass β} (f : α →*₀o β) :

f.toOrderMonoidHom = ↑f