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.

Typeclasses

• OrderAddMonoidHomClass
• OrderMonoidHomClass
• OrderMonoidWithZeroHomClass

Notation

• →+o: Bundled ordered additive monoid homs. Also use for additive groups homs.
• →*o: Bundled ordered monoid homs. Also use for groups homs.
• →*₀o: Bundled ordered monoid with zero homs. Also use for groups with zero homs.

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.

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)

• toFun : α → β
• map_zero' : ZeroHom.toFun (↑s.toAddMonoidHom) 0 = 0
• map_add' : ∀ (x y : α), ZeroHom.toFun (↑s.toAddMonoidHom) (x + y) = ZeroHom.toFun (↑s.toAddMonoidHom) x + ZeroHom.toFun (↑s.toAddMonoidHom) y
• monotone' : Monotone s.toFun

  An OrderAddMonoidHom is a monotone function.

α →+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*) [OrderAddMonoidHomClass F α β] (f : F).

When you extend this structure, make sure to extend OrderAddMonoidHomClass.

def «term_→+o_» : Lean.TrailingParserDescr

Infix notation for OrderAddMonoidHom.

class OrderAddMonoidHomClass (F : Type u_6) (α : outParam (Type u_7)) (β : outParam (Type u_8)) [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] extends AddMonoidHomClass : Type (max (max u_6 u_7) u_8)

• coe : F → α → β
• coe_injective' : Function.Injective FunLike.coe
• map_add : ∀ (f : F) (x y : α), ↑f (x + y) = ↑f x + ↑f y
• map_zero : ∀ (f : F), ↑f 0 = 0
• monotone : ∀ (f : F), Monotone ↑f

  An OrderAddMonoidHom is a monotone function.

OrderAddMonoidHomClass F α β states that F is a type of ordered monoid homomorphisms.

You should also extend this typeclass when you extend OrderAddMonoidHom.

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

• toFun : α → β
• map_one' : OneHom.toFun (↑s.toMonoidHom) 1 = 1
• map_mul' : ∀ (x y : α), OneHom.toFun (↑s.toMonoidHom) (x * y) = OneHom.toFun (↑s.toMonoidHom) x * OneHom.toFun (↑s.toMonoidHom) y
• monotone' : Monotone s.toFun

  An OrderMonoidHom is a monotone function.

α →*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*) [OrderMonoidHomClass F α β] (f : F).

When you extend this structure, make sure to extend OrderMonoidHomClass.

def «term_→*o_» : Lean.TrailingParserDescr

Infix notation for OrderMonoidHom.

class OrderMonoidHomClass (F : Type u_6) (α : outParam (Type u_7)) (β : outParam (Type u_8)) [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] extends MonoidHomClass : Type (max (max u_6 u_7) u_8)

• coe : F → α → β
• coe_injective' : Function.Injective FunLike.coe
• map_mul : ∀ (f : F) (x y : α), ↑f (x * y) = ↑f x * ↑f y
• map_one : ∀ (f : F), ↑f 1 = 1
• monotone : ∀ (f : F), Monotone ↑f

  An OrderMonoidHom is a monotone function.

OrderMonoidHomClass F α β states that F is a type of ordered monoid homomorphisms.

You should also extend this typeclass when you extend OrderMonoidHom.

def OrderAddMonoidHomClass.toOrderAddMonoidHom {F : Type u_1} {α : Type u_2} {β : Type u_3} : {x : Preorder α} → {x_1 : Preorder β} → {x_2 : AddZeroClass α} → {x_3 : AddZeroClass β} → [inst : OrderAddMonoidHomClass F α β] → F → α →+o β

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

def OrderMonoidHomClass.toOrderMonoidHom {F : Type u_1} {α : Type u_2} {β : Type u_3} : {x : Preorder α} → {x_1 : Preorder β} → {x_2 : MulOneClass α} → {x_3 : MulOneClass β} → [inst : OrderMonoidHomClass F α β] → F → α →*o β

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

instance OrderAddMonoidHomClass.toOrderHomClass {F : Type u_1} {α : Type u_2} {β : Type u_3} : {x : Preorder α} → {x_1 : Preorder β} → {x_2 : AddZeroClass α} → {x_3 : AddZeroClass β} → [inst : OrderAddMonoidHomClass F α β] → OrderHomClass F α β

instance OrderMonoidHomClass.toOrderHomClass {F : Type u_1} {α : Type u_2} {β : Type u_3} : {x : Preorder α} → {x_1 : Preorder β} → {x_2 : MulOneClass α} → {x_3 : MulOneClass β} → [inst : OrderMonoidHomClass F α β] → OrderHomClass F α β

instance instCoeTCOrderAddMonoidHom {F : Type u_1} {α : Type u_2} {β : Type u_3} : {x : Preorder α} → {x_1 : Preorder β} → {x_2 : AddZeroClass α} → {x_3 : AddZeroClass β} → [inst : OrderAddMonoidHomClass F α β] → CoeTC F (α →+o β)

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

instance instCoeTCOrderMonoidHom {F : Type u_1} {α : Type u_2} {β : Type u_3} : {x : Preorder α} → {x_1 : Preorder β} → {x_2 : MulOneClass α} → {x_3 : MulOneClass β} → [inst : OrderMonoidHomClass F α β] → CoeTC F (α →*o β)

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

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

• toFun : α → β
• map_zero' : ZeroHom.toFun (↑s.toMonoidWithZeroHom) 0 = 0
• map_one' : ZeroHom.toFun (↑s.toMonoidWithZeroHom) 1 = 1
• map_mul' : ∀ (x y : α), ZeroHom.toFun (↑s.toMonoidWithZeroHom) (x * y) = ZeroHom.toFun (↑s.toMonoidWithZeroHom) x * ZeroHom.toFun (↑s.toMonoidWithZeroHom) y
• monotone' : Monotone s.toFun

  An OrderMonoidWithZeroHom is a monotone function.

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 parametrize over (F : Type*) [OrderMonoidWithZeroHomClass F α β] (f : F).

When you extend this structure, make sure to extend OrderMonoidWithZeroHomClass.

def «term_→*₀o_» : Lean.TrailingParserDescr

Infix notation for OrderMonoidWithZeroHom.

class OrderMonoidWithZeroHomClass (F : Type u_6) (α : outParam (Type u_7)) (β : outParam (Type u_8)) [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] extends MonoidWithZeroHomClass : Type (max (max u_6 u_7) u_8)

• coe : F → α → β
• coe_injective' : Function.Injective FunLike.coe
• map_mul : ∀ (f : F) (x y : α), ↑f (x * y) = ↑f x * ↑f y
• map_one : ∀ (f : F), ↑f 1 = 1
• map_zero : ∀ (f : F), ↑f 0 = 0
• monotone : ∀ (f : F), Monotone ↑f

  An OrderMonoidWithZeroHom is a monotone function.

OrderMonoidWithZeroHomClass F α β states that F is a type of ordered monoid with zero homomorphisms.

You should also extend this typeclass when you extend OrderMonoidWithZeroHom.

def OrderMonoidWithZeroHomClass.toOrderMonoidWithZeroHom {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] [OrderMonoidWithZeroHomClass F α β] (f : F) : α →*₀o β

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

instance OrderMonoidWithZeroHomClass.toOrderMonoidHomClass {F : Type u_1} {α : Type u_2} {β : Type u_3} : {x : Preorder α} → {x_1 : Preorder β} → {x_2 : MulZeroOneClass α} → {x_3 : MulZeroOneClass β} → [inst : OrderMonoidWithZeroHomClass F α β] → OrderMonoidHomClass F α β

instance instCoeTCOrderMonoidWithZeroHom {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] [OrderMonoidWithZeroHomClass F α β] : CoeTC F (α →*₀o β)

theorem map_nonneg {F : Type u_1} {α : Type u_2} {β : Type u_3} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] [OrderAddMonoidHomClass F α β] (f : F) {a : α} (ha : 0 ≤ a) : 0 ≤ ↑f a

theorem map_nonpos {F : Type u_1} {α : Type u_2} {β : Type u_3} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] [OrderAddMonoidHomClass 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 β] [AddMonoidHomClass F α β] (f : 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 β] [AddMonoidHomClass F α β] (f : 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 β] [AddMonoidHomClass F α β] (f : 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 β] [AddMonoidHomClass F α β] (f : 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 β] [AddMonoidHomClass F α β] (f : F) [CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1] : 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 β] [AddMonoidHomClass F α β] (f : F) [CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1] : 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 β] [AddMonoidHomClass F α β] (f : F) [CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1] : 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 β] [AddMonoidHomClass F α β] (f : F) [CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1] : StrictAnti ↑f ↔ ∀ (a : α), a < 0 → 0 < ↑f a

theorem OrderAddMonoidHom.instOrderAddMonoidHomClassOrderAddMonoidHom.proof_2 {α : Type u_2} {β : Type u_1} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) (x : α) (y : α) : ZeroHom.toFun (↑f.toAddMonoidHom) (x + y) = ZeroHom.toFun (↑f.toAddMonoidHom) x + ZeroHom.toFun (↑f.toAddMonoidHom) y

theorem OrderAddMonoidHom.instOrderAddMonoidHomClassOrderAddMonoidHom.proof_3 {α : Type u_2} {β : Type u_1} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) : ZeroHom.toFun (↑f.toAddMonoidHom) 0 = 0

instance OrderAddMonoidHom.instOrderAddMonoidHomClassOrderAddMonoidHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] : OrderAddMonoidHomClass (α →+o β) α β

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

instance OrderMonoidHom.instOrderMonoidHomClassOrderMonoidHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] : OrderMonoidHomClass (α →*o β) α β

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 {α : 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.toFun = ↑f

theorem OrderMonoidHom.toFun_eq_coe {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) : f.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.

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.

@[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

theorem OrderAddMonoidHom.copy.proof_1 {α : Type u_2} {β : Type u_1} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) (f' : α → β) (h : f' = ↑f) : ZeroHom.toFun (↑(AddMonoidHom.copy f.toAddMonoidHom f' h)) 0 = 0

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.

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

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.

@[simp]

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

@[simp]

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

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

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

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

The identity map as an ordered additive monoid homomorphism.

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

The identity map as an ordered monoid homomorphism.

@[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.instInhabitedOrderAddMonoidHom (α : Type u_2) [Preorder α] [AddZeroClass α] : Inhabited (α →+o α)

instance OrderMonoidHom.instInhabitedOrderMonoidHom (α : Type u_2) [Preorder α] [MulOneClass α] : Inhabited (α →*o α)

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

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.

@[simp]

theorem OrderAddMonoidHom.coe_comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [AddZeroClass α] [AddZeroClass β] [AddZeroClass γ] (f : β →+o γ) (g : α →+o β) : ↑(OrderAddMonoidHom.comp f 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 β) : ↑(OrderMonoidHom.comp f 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 : α) : ↑(OrderAddMonoidHom.comp f 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 : α) : ↑(OrderMonoidHom.comp f 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 β) : ↑(OrderAddMonoidHom.comp f g) = AddMonoidHom.comp ↑f ↑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 β) : ↑(OrderMonoidHom.comp f g) = MonoidHom.comp ↑f ↑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 β) : ↑(OrderAddMonoidHom.comp f g) = OrderHom.comp ↑f ↑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 β) : ↑(OrderMonoidHom.comp f g) = OrderHom.comp ↑f ↑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 β) : OrderAddMonoidHom.comp (OrderAddMonoidHom.comp f g) h = OrderAddMonoidHom.comp f (OrderAddMonoidHom.comp g 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 β) : OrderMonoidHom.comp (OrderMonoidHom.comp f g) h = OrderMonoidHom.comp f (OrderMonoidHom.comp g h)

@[simp]

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

@[simp]

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

@[simp]

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

@[simp]

theorem OrderMonoidHom.id_comp {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] (f : α →*o β) : OrderMonoidHom.comp (OrderMonoidHom.id β) 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) : OrderAddMonoidHom.comp g₁ f = OrderAddMonoidHom.comp g₂ 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) : OrderMonoidHom.comp g₁ f = OrderMonoidHom.comp g₂ 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) : OrderAddMonoidHom.comp g f₁ = OrderAddMonoidHom.comp g 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) : OrderMonoidHom.comp g f₁ = OrderMonoidHom.comp g f₂ ↔ f₁ = f₂

theorem OrderAddMonoidHom.instZeroOrderAddMonoidHom.proof_1 {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [AddZeroClass β] : Monotone fun x => AddZeroClass.toZero.1

instance OrderAddMonoidHom.instZeroOrderAddMonoidHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] : Zero (α →+o β)

0 is the homomorphism sending all elements to 0.

instance OrderMonoidHom.instOneOrderMonoidHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] : One (α →*o β)

1 is the homomorphism sending all elements to 1.

@[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 γ) : OrderAddMonoidHom.comp f 0 = 0

@[simp]

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

theorem OrderAddMonoidHom.instAddOrderAddMonoidHomToPreorderToPartialOrderToPreorderToPartialOrderToAddZeroClassToAddMonoidToAddCommMonoidToAddZeroClassToAddMonoidToAddCommMonoid.proof_1 {α : Type u_2} {β : Type u_1} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] (f : α →+o β) (g : α →+o β) (x : α) (y : α) : ZeroHom.toFun (↑(↑f + ↑g)) (x + y) = ZeroHom.toFun (↑(↑f + ↑g)) x + ZeroHom.toFun (↑(↑f + ↑g)) y

instance OrderAddMonoidHom.instAddOrderAddMonoidHomToPreorderToPartialOrderToPreorderToPartialOrderToAddZeroClassToAddMonoidToAddCommMonoidToAddZeroClassToAddMonoidToAddCommMonoid {α : 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.

theorem OrderAddMonoidHom.instAddOrderAddMonoidHomToPreorderToPartialOrderToPreorderToPartialOrderToAddZeroClassToAddMonoidToAddCommMonoidToAddZeroClassToAddMonoidToAddCommMonoid.proof_2 {α : Type u_1} {β : Type u_2} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] (f : α →+o β) (g : α →+o β) : Monotone fun x => ZeroHom.toFun (↑f.toAddMonoidHom) x + ↑↑g x

instance OrderMonoidHom.instMulOrderMonoidHomToPreorderToPartialOrderToPreorderToPartialOrderToMulOneClassToMonoidToCommMonoidToMulOneClassToMonoidToCommMonoid {α : 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.

@[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 β) : OrderAddMonoidHom.comp (g₁ + g₂) f = OrderAddMonoidHom.comp g₁ f + OrderAddMonoidHom.comp g₂ f

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

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

theorem OrderMonoidHom.comp_mul {α : Type u_2} {β : Type u_3} {γ : Type u_4} [OrderedCommMonoid α] [OrderedCommMonoid β] [OrderedCommMonoid γ] (g : β →*o γ) (f₁ : α →*o β) (f₂ : α →*o β) : OrderMonoidHom.comp g (f₁ * f₂) = OrderMonoidHom.comp g f₁ * OrderMonoidHom.comp g 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 β) : OrderAddMonoidHom.toOrderHom f = ↑f

@[simp]

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

theorem OrderAddMonoidHom.mk'.proof_1 {α : Type u_2} {β : Type u_1} {hα : OrderedAddCommGroup α} {hβ : OrderedAddCommGroup β} (f : α → β) (map_mul : ∀ (a b : α), f (a + b) = f a + f b) (x : α) (y : α) : ZeroHom.toFun (↑(AddMonoidHom.mk' f map_mul)) (x + y) = ZeroHom.toFun (↑(AddMonoidHom.mk' f map_mul)) x + ZeroHom.toFun (↑(AddMonoidHom.mk' f map_mul)) y

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.

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.

instance OrderMonoidWithZeroHom.instOrderMonoidWithZeroHomClassOrderMonoidWithZeroHom {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] : OrderMonoidWithZeroHomClass (α →*₀o β) α β

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.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.

@[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.

@[simp]

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

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

def OrderMonoidWithZeroHom.id (α : Type u_2) [Preorder α] [MulZeroOneClass α] : α →*₀o α

The identity map as an ordered monoid with zero homomorphism.

@[simp]

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

instance OrderMonoidWithZeroHom.instInhabitedOrderMonoidWithZeroHom (α : Type u_2) [Preorder α] [MulZeroOneClass α] : Inhabited (α →*₀o α)

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

Composition of OrderMonoidWithZeroHoms as an OrderMonoidWithZeroHom.

@[simp]

theorem OrderMonoidWithZeroHom.coe_comp {α : Type u_2} {β : Type u_3} {γ : Type u_4} [Preorder α] [Preorder β] [Preorder γ] [MulZeroOneClass α] [MulZeroOneClass β] [MulZeroOneClass γ] (f : β →*₀o γ) (g : α →*₀o β) : ↑(OrderMonoidWithZeroHom.comp f 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 : α) : ↑(OrderMonoidWithZeroHom.comp f 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 β) : ↑(OrderMonoidWithZeroHom.comp f g) = MonoidWithZeroHom.comp ↑f ↑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 β) : ↑(OrderMonoidWithZeroHom.comp f g) = OrderMonoidHom.comp ↑f ↑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 β) : OrderMonoidWithZeroHom.comp (OrderMonoidWithZeroHom.comp f g) h = OrderMonoidWithZeroHom.comp f (OrderMonoidWithZeroHom.comp g h)

@[simp]

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

@[simp]

theorem OrderMonoidWithZeroHom.id_comp {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] (f : α →*₀o β) : OrderMonoidWithZeroHom.comp (OrderMonoidWithZeroHom.id β) 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) : OrderMonoidWithZeroHom.comp g₁ f = OrderMonoidWithZeroHom.comp g₂ 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) : OrderMonoidWithZeroHom.comp g f₁ = OrderMonoidWithZeroHom.comp g f₂ ↔ f₁ = f₂

instance OrderMonoidWithZeroHom.instMulOrderMonoidWithZeroHomToPreorderToPartialOrderToOrderedCommMonoidToLinearOrderedCommMonoidToPreorderToPartialOrderToOrderedCommMonoidToLinearOrderedCommMonoidToMulZeroOneClassToMonoidWithZeroToCommMonoidWithZeroToMulZeroOneClassToMonoidWithZeroToCommMonoidWithZero {α : 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.

@[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 β) : OrderMonoidWithZeroHom.comp (g₁ * g₂) f = OrderMonoidWithZeroHom.comp g₁ f * OrderMonoidWithZeroHom.comp g₂ f

theorem OrderMonoidWithZeroHom.comp_mul {α : Type u_2} {β : Type u_3} {γ : Type u_4} [LinearOrderedCommMonoidWithZero α] [LinearOrderedCommMonoidWithZero β] [LinearOrderedCommMonoidWithZero γ] (g : β →*₀o γ) (f₁ : α →*₀o β) (f₂ : α →*₀o β) : OrderMonoidWithZeroHom.comp g (f₁ * f₂) = OrderMonoidWithZeroHom.comp g f₁ * OrderMonoidWithZeroHom.comp g 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 β) : OrderMonoidWithZeroHom.toOrderMonoidHom f = ↑f