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)

α →+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.

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

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

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

You should also extend this typeclass when you extend OrderAddMonoidHom.

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

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

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

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

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

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

You should also extend this typeclass when you extend OrderMonoidHom.

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

def OrderAddMonoidHomClass.toOrderAddMonoidHom {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] [FunLike F α β] [OrderAddMonoidHomClass F α β] (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 β.

Equations

• ↑f = let src := ↑f; { toAddMonoidHom := src, monotone' := (_ : Monotone ⇑f) }

def OrderMonoidHomClass.toOrderMonoidHom {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] [FunLike F α β] [OrderMonoidHomClass F α β] (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 β.

Equations

• ↑f = let src := ↑f; { toMonoidHom := src, monotone' := (_ : Monotone ⇑f) }

instance OrderAddMonoidHomClass.toOrderHomClass {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] [FunLike F α β] [OrderAddMonoidHomClass F α β] : OrderHomClass F α β

Equations

• (_ : OrderHomClass F α β) = (_ : RelHomClass F (fun (x x_1 : α) => x ≤ x_1) fun (x x_1 : β) => x ≤ x_1)

instance OrderMonoidHomClass.toOrderHomClass {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] [FunLike F α β] [OrderMonoidHomClass F α β] : OrderHomClass F α β

Equations

• (_ : OrderHomClass F α β) = (_ : RelHomClass F (fun (x x_1 : α) => x ≤ x_1) fun (x x_1 : β) => x ≤ x_1)

instance instCoeTCOrderAddMonoidHom {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] [FunLike F α β] [OrderAddMonoidHomClass F α β] : CoeTC F (α →+o β)

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

Equations

• instCoeTCOrderAddMonoidHom = { coe := OrderAddMonoidHomClass.toOrderAddMonoidHom }

instance instCoeTCOrderMonoidHom {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulOneClass α] [MulOneClass β] [FunLike F α β] [OrderMonoidHomClass F α β] : CoeTC F (α →*o β)

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

Equations

• instCoeTCOrderMonoidHom = { coe := OrderMonoidHomClass.toOrderMonoidHom }

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

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

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

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

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

You should also extend this typeclass when you extend OrderMonoidWithZeroHom.

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

def OrderMonoidWithZeroHomClass.toOrderMonoidWithZeroHom {F : Type u_1} {α : Type u_2} {β : Type u_3} [Preorder α] [Preorder β] [MulZeroOneClass α] [MulZeroOneClass β] [FunLike F α β] [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 β.

Equations

• ↑f = let src := ↑f; { toMonoidWithZeroHom := src, monotone' := (_ : Monotone ⇑f) }

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

Equations

• (_ : OrderMonoidHomClass F α β) = (_ : OrderMonoidHomClass F α β)

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

Equations

• instCoeTCOrderMonoidWithZeroHom = { coe := OrderMonoidWithZeroHomClass.toOrderMonoidWithZeroHom }

theorem map_nonneg {F : Type u_1} {α : Type u_2} {β : Type u_3} [FunLike F α β] [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} [FunLike F α β] [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 β] [i : FunLike F α β] [iamhc : 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 β] [i : FunLike F α β] [iamhc : 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 β] [i : FunLike F α β] [iamhc : 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 β] [i : FunLike F α β] [iamhc : 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 β] [i : FunLike F α β] [iamhc : 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 β] [i : FunLike F α β] [iamhc : 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 β] [i : FunLike F α β] [iamhc : 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 β] [i : FunLike F α β] [iamhc : 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.instFunLikeOrderAddMonoidHom.proof_1 {α : Type u_2} {β : Type u_1} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] (f : α →+o β) (g : α →+o β) (h : (fun (f : α →+o β) => f.toFun) f = (fun (f : α →+o β) => f.toFun) g) : f = g

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• (_ : OrderAddMonoidHomClass (α →+o β) α β) = (_ : OrderAddMonoidHomClass (α →+o β) α β)

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

Equations

• (_ : OrderMonoidHomClass (α →*o β) α β) = (_ : 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.

Equations

• OrderAddMonoidHom.toOrderHom f = { toFun := f.toFun, monotone' := (_ : Monotone f.toFun) }

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

• OrderMonoidHom.toOrderHom f = { toFun := f.toFun, monotone' := (_ : Monotone f.toFun) }

@[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) : (↑(AddMonoidHom.copy f.toAddMonoidHom f' h)).toFun 0 = 0

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

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

• One or more equations did not get rendered due to their size.

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

• One or more equations did not get rendered due to their size.

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

Equations

• OrderAddMonoidHom.id α = let src := AddMonoidHom.id α; let src_1 := OrderHom.id; { toAddMonoidHom := src, monotone' := (_ : Monotone src_1.toFun) }

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

The identity map as an ordered monoid homomorphism.

Equations

• OrderMonoidHom.id α = let src := MonoidHom.id α; let src_1 := OrderHom.id; { toMonoidHom := src, monotone' := (_ : Monotone src_1.toFun) }

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

Equations

• OrderAddMonoidHom.instInhabitedOrderAddMonoidHom α = { default := OrderAddMonoidHom.id α }

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

Equations

• OrderMonoidHom.instInhabitedOrderMonoidHom α = { default := OrderMonoidHom.id α }

theorem OrderAddMonoidHom.comp.proof_2 {α : Type u_2} {β : Type u_1} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] : OrderHomClass (α →+o β) α β

theorem OrderAddMonoidHom.comp.proof_1 {α : Type u_2} {β : Type u_1} [Preorder α] [Preorder β] [AddZeroClass α] [AddZeroClass β] : AddMonoidHomClass (α →+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

Equations

• One or more equations did not get rendered due to their size.

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

• One or more equations did not get rendered due to their size.

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

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

0 is the homomorphism sending all elements to 0.

Equations

• OrderAddMonoidHom.instZeroOrderAddMonoidHom = { zero := let src := 0; { toAddMonoidHom := src, monotone' := (_ : Monotone fun (x : α) => AddZeroClass.toZero.1) } }

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

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

1 is the homomorphism sending all elements to 1.

Equations

• OrderMonoidHom.instOneOrderMonoidHom = { one := let src := 1; { toMonoidHom := src, monotone' := (_ : Monotone fun (x : α) => MulOneClass.toOne.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_2 {α : Type u_1} {β : Type u_2} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] (f : α →+o β) (g : α →+o β) : Monotone fun (x : α) => (↑f.toAddMonoidHom).toFun x + ↑g x

theorem OrderAddMonoidHom.instAddOrderAddMonoidHomToPreorderToPartialOrderToPreorderToPartialOrderToAddZeroClassToAddMonoidToAddCommMonoidToAddZeroClassToAddMonoidToAddCommMonoid.proof_1 {α : Type u_2} {β : Type u_1} [OrderedAddCommMonoid α] [OrderedAddCommMonoid β] : AddMonoidHomClass (α →+o β) α β

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.

Equations

• One or more equations did not get rendered due to their size.

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.

Equations

• One or more equations did not get rendered due to their size.

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

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 = let src := AddMonoidHom.mk' f map_mul; { toAddMonoidHom := src, 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 = let src := MonoidHom.mk' f map_mul; { toMonoidHom := src, monotone' := hf }

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

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• (_ : OrderMonoidWithZeroHomClass (α →*₀o β) α β) = (_ : 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.

Equations

• One or more equations did not get rendered due to their size.

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

• One or more equations did not get rendered due to their size.

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

Equations

• OrderMonoidWithZeroHom.id α = let src := MonoidWithZeroHom.id α; let src_1 := OrderHom.id; { toMonoidWithZeroHom := src, monotone' := (_ : Monotone src_1.toFun) }

@[simp]

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

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

Equations

• OrderMonoidWithZeroHom.instInhabitedOrderMonoidWithZeroHom α = { 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 β) : α →*₀o γ

Composition of OrderMonoidWithZeroHoms as an OrderMonoidWithZeroHom.

Equations

• One or more equations did not get rendered due to their size.

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

Equations

• One or more equations did not get rendered due to their size.

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