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

full_name: OrderAddMonoidHom.monotone'
code: /-- `α →+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`. -/
structure OrderAddMonoidHom (α β : Type*) [Preorder α] [Preorder β] [AddZeroClass α]
  [AddZeroClass β] extends α →+ β where
  /-- An `OrderAddMonoidHom` is a monotone function. -/
  monotone' : Monotone toFun
goal: Monotone (↑self.toAddMonoidHom).toFun

full_name: OrderAddMonoidHom
code: /-- `α →+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`. -/
structure OrderAddMonoidHom (α β : Type*) [Preorder α] [Preorder β] [AddZeroClass α]
  [AddZeroClass β] extends α →+ β where
  /-- An `OrderAddMonoidHom` is a monotone function. -/
  monotone' : Monotone toFun
goal: Type (max u_6 u_7)

full_name: «_aux_Mathlib_Algebra_Order_Hom_Monoid___macroRules_term_→+o__1»
code: /-- Infix notation for `OrderAddMonoidHom`. -/
infixr:25 " →+o " => OrderAddMonoidHom
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Order_Hom_Monoid___unexpand_OrderAddMonoidHom_1
code: /-- Infix notation for `OrderAddMonoidHom`. -/
infixr:25 " →+o " => OrderAddMonoidHom
goal: Lean.PrettyPrinter.Unexpander

full_name: OrderMonoidHom
code: /-- `α →*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`. -/
@[to_additive]
structure OrderMonoidHom (α β : Type*) [Preorder α] [Preorder β] [MulOneClass α]
  [MulOneClass β] extends α →* β where
  /-- An `OrderMonoidHom` is a monotone function. -/
  monotone' : Monotone toFun
goal: Type (max u_6 u_7)

full_name: OrderMonoidHom.monotone'
code: /-- `α →*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`. -/
@[to_additive]
structure OrderMonoidHom (α β : Type*) [Preorder α] [Preorder β] [MulOneClass α]
  [MulOneClass β] extends α →* β where
  /-- An `OrderMonoidHom` is a monotone function. -/
  monotone' : Monotone toFun
goal: Monotone (↑self.toMonoidHom).toFun

full_name: _aux_Mathlib_Algebra_Order_Hom_Monoid___unexpand_OrderMonoidHom_1
code: /-- Infix notation for `OrderMonoidHom`. -/
infixr:25 " →*o " => OrderMonoidHom
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Order_Hom_Monoid___macroRules_term_→*o__1»
code: /-- Infix notation for `OrderMonoidHom`. -/
infixr:25 " →*o " => OrderMonoidHom
goal: Lean.Macro

full_name: OrderMonoidHomClass.toOrderMonoidHom
code: /-- 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 β`. -/
@[to_additive (attr := coe)
  "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 [OrderHomClass F α β] [MonoidHomClass F α β] (f : F) :
    α →*o β 
goal: α →*o β

full_name: OrderMonoidHomClass.toOrderAddMonoidHom
code: /-- 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 β`. -/
@[to_additive (attr := coe)
  "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 [OrderHomClass F α β] [MonoidHomClass F α β] (f : F) :
    α →*o β 
goal: α →+o β

full_name: instCoeTCOrderAddMonoidHomOfOrderHomClassOfAddMonoidHomClass
code: /-- Any type satisfying `OrderMonoidHomClass` can be cast into `OrderMonoidHom` via
  `OrderMonoidHomClass.toOrderMonoidHom`. -/
@[to_additive "Any type satisfying `OrderAddMonoidHomClass` can be cast into `OrderAddMonoidHom` via
  `OrderAddMonoidHomClass.toOrderAddMonoidHom`"]
instance [OrderHomClass F α β] [MonoidHomClass F α β] : CoeTC F (α →*o β) 
goal: CoeTC F (α →+o β)

full_name: instCoeTCOrderMonoidHomOfOrderHomClassOfMonoidHomClass
code: /-- Any type satisfying `OrderMonoidHomClass` can be cast into `OrderMonoidHom` via
  `OrderMonoidHomClass.toOrderMonoidHom`. -/
@[to_additive "Any type satisfying `OrderAddMonoidHomClass` can be cast into `OrderAddMonoidHom` via
  `OrderAddMonoidHomClass.toOrderAddMonoidHom`"]
instance [OrderHomClass F α β] [MonoidHomClass F α β] : CoeTC F (α →*o β) 
goal: CoeTC F (α →*o β)

full_name: OrderMonoidWithZeroHom.monotone'
code: /-- `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`. -/
structure OrderMonoidWithZeroHom (α β : Type*) [Preorder α] [Preorder β] [MulZeroOneClass α]
  [MulZeroOneClass β] extends α →*₀ β where
  /-- An `OrderMonoidWithZeroHom` is a monotone function. -/
  monotone' : Monotone toFun
goal: Monotone (↑self.toMonoidWithZeroHom).toFun

full_name: OrderMonoidWithZeroHom
code: /-- `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`. -/
structure OrderMonoidWithZeroHom (α β : Type*) [Preorder α] [Preorder β] [MulZeroOneClass α]
  [MulZeroOneClass β] extends α →*₀ β where
  /-- An `OrderMonoidWithZeroHom` is a monotone function. -/
  monotone' : Monotone toFun
goal: Type (max u_6 u_7)

full_name: «_aux_Mathlib_Algebra_Order_Hom_Monoid___macroRules_term_→*₀o__1»
code: /-- Infix notation for `OrderMonoidWithZeroHom`. -/
infixr:25 " →*₀o " => OrderMonoidWithZeroHom
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Order_Hom_Monoid___unexpand_OrderMonoidWithZeroHom_1
code: /-- Infix notation for `OrderMonoidWithZeroHom`. -/
infixr:25 " →*₀o " => OrderMonoidWithZeroHom
goal: Lean.PrettyPrinter.Unexpander

full_name: OrderMonoidWithZeroHomClass.toOrderMonoidWithZeroHom
code: /-- 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 β`. -/
@[coe]
def OrderMonoidWithZeroHomClass.toOrderMonoidWithZeroHom [OrderHomClass F α β]
    [MonoidWithZeroHomClass F α β] (f : F) : α →*₀o β 
goal: α →*₀o β

full_name: instCoeTCOrderMonoidWithZeroHomOfOrderHomClassOfMonoidWithZeroHomClass
code: instance [OrderHomClass F α β] [MonoidWithZeroHomClass F α β] : CoeTC F (α →*₀o β) 
goal: CoeTC F (α →*₀o β)

full_name: map_nonneg
code: /-- See also `NonnegHomClass.apply_nonneg`. -/
theorem map_nonneg (ha : 0 ≤ a) : 0 ≤ f a 
goal: 0 ≤ f a

full_name: map_nonpos
code: theorem map_nonpos (ha : a ≤ 0) : f a ≤ 0 
goal: f a ≤ 0

full_name: monotone_iff_map_nonneg
code: theorem monotone_iff_map_nonneg [iamhc : AddMonoidHomClass F α β] :
    Monotone (f : α → β) ↔ ∀ a, 0 ≤ a → 0 ≤ f a 
goal: Monotone ⇑f ↔ ∀ (a : α), 0 ≤ a → 0 ≤ f a

full_name: antitone_iff_map_nonpos
code: theorem antitone_iff_map_nonpos : Antitone (f : α → β) ↔ ∀ a, 0 ≤ a → f a ≤ 0 
goal: Antitone ⇑f ↔ ∀ (a : α), 0 ≤ a → f a ≤ 0

full_name: monotone_iff_map_nonpos
code: theorem monotone_iff_map_nonpos : Monotone (f : α → β) ↔ ∀ a ≤ 0, f a ≤ 0 
goal: Monotone ⇑f ↔ ∀ (a : α), a ≤ 0 → f a ≤ 0

full_name: antitone_iff_map_nonneg
code: theorem antitone_iff_map_nonneg : Antitone (f : α → β) ↔ ∀ a ≤ 0, 0 ≤ f a 
goal: Antitone ⇑f ↔ ∀ (a : α), a ≤ 0 → 0 ≤ f a

full_name: strictMono_iff_map_pos
code: theorem strictMono_iff_map_pos [iamhc : AddMonoidHomClass F α β]  :
    StrictMono (f : α → β) ↔ ∀ a, 0 < a → 0 < f a 
goal: StrictMono ⇑f ↔ ∀ (a : α), 0 < a → 0 < f a

full_name: strictAnti_iff_map_neg
code: theorem strictAnti_iff_map_neg : StrictAnti (f : α → β) ↔ ∀ a, 0 < a → f a < 0 
goal: StrictAnti ⇑f ↔ ∀ (a : α), 0 < a → f a < 0

full_name: strictMono_iff_map_neg
code: theorem strictMono_iff_map_neg : StrictMono (f : α → β) ↔ ∀ a < 0, f a < 0 
goal: StrictMono ⇑f ↔ ∀ (a : α), a < 0 → f a < 0

full_name: strictAnti_iff_map_pos
code: theorem strictAnti_iff_map_pos : StrictAnti (f : α → β) ↔ ∀ a < 0, 0 < f a 
goal: StrictAnti ⇑f ↔ ∀ (a : α), a < 0 → 0 < f a

full_name: OrderMonoidHom.instFunLike
code: @[to_additive]
instance : FunLike (α →*o β) α β 
goal: FunLike (α →*o β) α β

full_name: OrderAddMonoidHom.instFunLike
code: @[to_additive]
instance : FunLike (α →*o β) α β 
goal: FunLike (α →+o β) α β

full_name: OrderAddMonoidHom.instOrderHomClass
code: @[to_additive]
instance : OrderHomClass (α →*o β) α β 
goal: OrderHomClass (α →+o β) α β

full_name: OrderMonoidHom.instOrderHomClass
code: @[to_additive]
instance : OrderHomClass (α →*o β) α β 
goal: OrderHomClass (α →*o β) α β

full_name: OrderAddMonoidHom.instAddMonoidHomClass
code: @[to_additive]
instance : MonoidHomClass (α →*o β) α β 
goal: AddMonoidHomClass (α →+o β) α β

full_name: OrderMonoidHom.instMonoidHomClass
code: @[to_additive]
instance : MonoidHomClass (α →*o β) α β 
goal: MonoidHomClass (α →*o β) α β

full_name: OrderAddMonoidHom.ext
code: @[to_additive (attr := ext)]
theorem ext (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: OrderMonoidHom.ext
code: @[to_additive (attr := ext)]
theorem ext (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: OrderAddMonoidHom.toFun_eq_coe
code: @[to_additive]
theorem toFun_eq_coe (f : α →*o β) : f.toFun = (f : α → β) 
goal: (↑f.toAddMonoidHom).toFun = ⇑f

full_name: OrderMonoidHom.toFun_eq_coe
code: @[to_additive]
theorem toFun_eq_coe (f : α →*o β) : f.toFun = (f : α → β) 
goal: (↑f.toMonoidHom).toFun = ⇑f

full_name: OrderAddMonoidHom.coe_mk
code: @[to_additive (attr := simp)]
theorem coe_mk (f : α →* β) (h) : (OrderMonoidHom.mk f h : α → β) = f 
goal: ⇑{ toAddMonoidHom := f, monotone' := h } = ⇑f

full_name: OrderMonoidHom.coe_mk
code: @[to_additive (attr := simp)]
theorem coe_mk (f : α →* β) (h) : (OrderMonoidHom.mk f h : α → β) = f 
goal: ⇑{ toMonoidHom := f, monotone' := h } = ⇑f

full_name: OrderAddMonoidHom.mk_coe
code: @[to_additive (attr := simp)]
theorem mk_coe (f : α →*o β) (h) : OrderMonoidHom.mk (f : α →* β) h = f 
goal: { toAddMonoidHom := ↑f, monotone' := h } = f

full_name: OrderMonoidHom.mk_coe
code: @[to_additive (attr := simp)]
theorem mk_coe (f : α →*o β) (h) : OrderMonoidHom.mk (f : α →* β) h = f 
goal: { toMonoidHom := ↑f, monotone' := h } = f

full_name: OrderMonoidHom.toOrderHom
code: /-- Reinterpret an ordered monoid homomorphism as an order homomorphism. -/
@[to_additive "Reinterpret an ordered additive monoid homomorphism as an order homomorphism."]
def toOrderHom (f : α →*o β) : α →o β 
goal: α →o β

full_name: OrderAddMonoidHom.toOrderHom
code: /-- Reinterpret an ordered monoid homomorphism as an order homomorphism. -/
@[to_additive "Reinterpret an ordered additive monoid homomorphism as an order homomorphism."]
def toOrderHom (f : α →*o β) : α →o β 
goal: α →o β

full_name: OrderAddMonoidHom.coe_addMonoidHom
code: @[to_additive (attr := simp)]
theorem coe_monoidHom (f : α →*o β) : ((f : α →* β) : α → β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderMonoidHom.coe_monoidHom
code: @[to_additive (attr := simp)]
theorem coe_monoidHom (f : α →*o β) : ((f : α →* β) : α → β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderMonoidHom.coe_orderHom
code: @[to_additive (attr := simp)]
theorem coe_orderHom (f : α →*o β) : ((f : α →o β) : α → β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderAddMonoidHom.coe_orderHom
code: @[to_additive (attr := simp)]
theorem coe_orderHom (f : α →*o β) : ((f : α →o β) : α → β) = f 
goal: ⇑↑f = ⇑f

full_name: OrderMonoidHom.toMonoidHom_injective
code: @[to_additive]
theorem toMonoidHom_injective : Injective (toMonoidHom : _ → α →* β) 
goal: Function.Injective OrderMonoidHom.toMonoidHom

full_name: OrderAddMonoidHom.toAddMonoidHom_injective
code: @[to_additive]
theorem toMonoidHom_injective : Injective (toMonoidHom : _ → α →* β) 
goal: Function.Injective OrderAddMonoidHom.toAddMonoidHom

full_name: OrderMonoidHom.toOrderHom_injective
code: @[to_additive]
theorem toOrderHom_injective : Injective (toOrderHom : _ → α →o β) 
goal: Function.Injective OrderMonoidHom.toOrderHom

full_name: OrderAddMonoidHom.toOrderHom_injective
code: @[to_additive]
theorem toOrderHom_injective : Injective (toOrderHom : _ → α →o β) 
goal: Function.Injective OrderAddMonoidHom.toOrderHom

full_name: OrderAddMonoidHom.copy
code: /-- Copy of an `OrderMonoidHom` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. -/
@[to_additive "Copy of an `OrderAddMonoidHom` with a new `toFun` equal to the old one. Useful to fix
definitional equalities."]
protected def copy (f : α →*o β) (f' : α → β) (h : f' = f) : α →*o β 
goal: α →+o β

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

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

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

full_name: OrderMonoidHom.copy_eq
code: @[to_additive]
theorem copy_eq (f : α →*o β) (f' : α → β) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: OrderAddMonoidHom.copy_eq
code: @[to_additive]
theorem copy_eq (f : α →*o β) (f' : α → β) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: OrderAddMonoidHom.id
code: /-- The identity map as an ordered monoid homomorphism. -/
@[to_additive "The identity map as an ordered additive monoid homomorphism."]
protected def id : α →*o α 
goal: α →+o α

full_name: OrderMonoidHom.id
code: /-- The identity map as an ordered monoid homomorphism. -/
@[to_additive "The identity map as an ordered additive monoid homomorphism."]
protected def id : α →*o α 
goal: α →*o α

full_name: OrderAddMonoidHom.coe_id
code: @[to_additive (attr := simp)]
theorem coe_id : ⇑(OrderMonoidHom.id α) = id 
goal: ⇑(OrderAddMonoidHom.id α) = id

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

full_name: OrderMonoidHom.instInhabited
code: @[to_additive]
instance : Inhabited (α →*o α) 
goal: Inhabited (α →*o α)

full_name: OrderAddMonoidHom.instInhabited
code: @[to_additive]
instance : Inhabited (α →*o α) 
goal: Inhabited (α →+o α)

full_name: OrderAddMonoidHom.comp
code: /-- Composition of `OrderMonoidHom`s as an `OrderMonoidHom`. -/
@[to_additive "Composition of `OrderAddMonoidHom`s as an `OrderAddMonoidHom`"]
def comp (f : β →*o γ) (g : α →*o β) : α →*o γ 
goal: α →+o γ

full_name: OrderMonoidHom.comp
code: /-- Composition of `OrderMonoidHom`s as an `OrderMonoidHom`. -/
@[to_additive "Composition of `OrderAddMonoidHom`s as an `OrderAddMonoidHom`"]
def comp (f : β →*o γ) (g : α →*o β) : α →*o γ 
goal: α →*o γ

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

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

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

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

full_name: OrderAddMonoidHom.coe_comp_addMonoidHom
code: @[to_additive]
theorem coe_comp_monoidHom (f : β →*o γ) (g : α →*o β) :
    (f.comp g : α →* γ) = (f : β →* γ).comp g 
goal: ↑(f.comp g) = (↑f).comp ↑g

full_name: OrderMonoidHom.coe_comp_monoidHom
code: @[to_additive]
theorem coe_comp_monoidHom (f : β →*o γ) (g : α →*o β) :
    (f.comp g : α →* γ) = (f : β →* γ).comp g 
goal: ↑(f.comp g) = (↑f).comp ↑g

full_name: OrderAddMonoidHom.coe_comp_orderHom
code: @[to_additive]
theorem coe_comp_orderHom (f : β →*o γ) (g : α →*o β) :
    (f.comp g : α →o γ) = (f : β →o γ).comp g 
goal: ↑(f.comp g) = (↑f).comp ↑g

full_name: OrderMonoidHom.coe_comp_orderHom
code: @[to_additive]
theorem coe_comp_orderHom (f : β →*o γ) (g : α →*o β) :
    (f.comp g : α →o γ) = (f : β →o γ).comp g 
goal: ↑(f.comp g) = (↑f).comp ↑g

full_name: OrderMonoidHom.comp_assoc
code: @[to_additive (attr := simp)]
theorem comp_assoc (f : γ →*o δ) (g : β →*o γ) (h : α →*o β) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: OrderAddMonoidHom.comp_assoc
code: @[to_additive (attr := simp)]
theorem comp_assoc (f : γ →*o δ) (g : β →*o γ) (h : α →*o β) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: OrderAddMonoidHom.comp_id
code: @[to_additive (attr := simp)]
theorem comp_id (f : α →*o β) : f.comp (OrderMonoidHom.id α) = f 
goal: f.comp (OrderAddMonoidHom.id α) = f

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

full_name: OrderAddMonoidHom.id_comp
code: @[to_additive (attr := simp)]
theorem id_comp (f : α →*o β) : (OrderMonoidHom.id β).comp f = f 
goal: (OrderAddMonoidHom.id β).comp f = f

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

full_name: OrderMonoidHom.cancel_right
code: @[to_additive (attr := simp)]
theorem cancel_right {g₁ g₂ : β →*o γ} {f : α →*o β} (hf : Function.Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: OrderAddMonoidHom.cancel_right
code: @[to_additive (attr := simp)]
theorem cancel_right {g₁ g₂ : β →*o γ} {f : α →*o β} (hf : Function.Surjective f) :
    g₁.comp f = g₂.comp f ↔ g₁ = g₂ 
goal: g₁.comp f = g₂.comp f ↔ g₁ = g₂

full_name: OrderMonoidHom.cancel_left
code: @[to_additive (attr := simp)]
theorem cancel_left {g : β →*o γ} {f₁ f₂ : α →*o β} (hg : Function.Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: OrderAddMonoidHom.cancel_left
code: @[to_additive (attr := simp)]
theorem cancel_left {g : β →*o γ} {f₁ f₂ : α →*o β} (hg : Function.Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂ 
goal: g.comp f₁ = g.comp f₂ ↔ f₁ = f₂

full_name: OrderMonoidHom.instOne
code: /-- `1` is the homomorphism sending all elements to `1`. -/
@[to_additive "`0` is the homomorphism sending all elements to `0`."]
instance : One (α →*o β) 
goal: One (α →*o β)

full_name: OrderAddMonoidHom.instZero
code: /-- `1` is the homomorphism sending all elements to `1`. -/
@[to_additive "`0` is the homomorphism sending all elements to `0`."]
instance : One (α →*o β) 
goal: Zero (α →+o β)

full_name: OrderMonoidHom.coe_one
code: @[to_additive (attr := simp)]
theorem coe_one : ⇑(1 : α →*o β) = 1 
goal: ⇑1 = 1

full_name: OrderAddMonoidHom.coe_zero
code: @[to_additive (attr := simp)]
theorem coe_one : ⇑(1 : α →*o β) = 1 
goal: ⇑0 = 0

full_name: OrderMonoidHom.one_apply
code: @[to_additive (attr := simp)]
theorem one_apply (a : α) : (1 : α →*o β) a = 1 
goal: 1 a = 1

full_name: OrderAddMonoidHom.zero_apply
code: @[to_additive (attr := simp)]
theorem one_apply (a : α) : (1 : α →*o β) a = 1 
goal: 0 a = 0

full_name: OrderMonoidHom.one_comp
code: @[to_additive (attr := simp)]
theorem one_comp (f : α →*o β) : (1 : β →*o γ).comp f = 1 
goal: OrderMonoidHom.comp 1 f = 1

full_name: OrderAddMonoidHom.zero_comp
code: @[to_additive (attr := simp)]
theorem one_comp (f : α →*o β) : (1 : β →*o γ).comp f = 1 
goal: OrderAddMonoidHom.comp 0 f = 0

full_name: OrderAddMonoidHom.comp_zero
code: @[to_additive (attr := simp)]
theorem comp_one (f : β →*o γ) : f.comp (1 : α →*o β) = 1 
goal: f.comp 0 = 0

full_name: OrderMonoidHom.comp_one
code: @[to_additive (attr := simp)]
theorem comp_one (f : β →*o γ) : f.comp (1 : α →*o β) = 1 
goal: f.comp 1 = 1

full_name: OrderMonoidHom.instMul
code: /-- For two ordered monoid morphisms `f` and `g`, their product is the ordered monoid morphism
sending `a` to `f a * g a`. -/
@[to_additive "For two ordered additive monoid morphisms `f` and `g`, their product is the ordered
additive monoid morphism sending `a` to `f a + g a`."]
instance : Mul (α →*o β) 
goal: Mul (α →*o β)

full_name: OrderAddMonoidHom.instAdd
code: /-- For two ordered monoid morphisms `f` and `g`, their product is the ordered monoid morphism
sending `a` to `f a * g a`. -/
@[to_additive "For two ordered additive monoid morphisms `f` and `g`, their product is the ordered
additive monoid morphism sending `a` to `f a + g a`."]
instance : Mul (α →*o β) 
goal: Add (α →+o β)

full_name: OrderMonoidHom.coe_mul
code: @[to_additive (attr := simp)]
theorem coe_mul (f g : α →*o β) : ⇑(f * g) = f * g 
goal: ⇑(f * g) = ⇑f * ⇑g

full_name: OrderAddMonoidHom.coe_add
code: @[to_additive (attr := simp)]
theorem coe_mul (f g : α →*o β) : ⇑(f * g) = f * g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: OrderMonoidHom.mul_apply
code: @[to_additive (attr := simp)]
theorem mul_apply (f g : α →*o β) (a : α) : (f * g) a = f a * g a 
goal: (f * g) a = f a * g a

full_name: OrderAddMonoidHom.add_apply
code: @[to_additive (attr := simp)]
theorem mul_apply (f g : α →*o β) (a : α) : (f * g) a = f a * g a 
goal: (f + g) a = f a + g a

full_name: OrderAddMonoidHom.add_comp
code: @[to_additive]
theorem mul_comp (g₁ g₂ : β →*o γ) (f : α →*o β) : (g₁ * g₂).comp f = g₁.comp f * g₂.comp f 
goal: (g₁ + g₂).comp f = g₁.comp f + g₂.comp f

full_name: OrderMonoidHom.mul_comp
code: @[to_additive]
theorem mul_comp (g₁ g₂ : β →*o γ) (f : α →*o β) : (g₁ * g₂).comp f = g₁.comp f * g₂.comp f 
goal: (g₁ * g₂).comp f = g₁.comp f * g₂.comp f

full_name: OrderAddMonoidHom.comp_add
code: @[to_additive]
theorem comp_mul (g : β →*o γ) (f₁ f₂ : α →*o β) : g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂ 
goal: g.comp (f₁ + f₂) = g.comp f₁ + g.comp f₂

full_name: OrderMonoidHom.comp_mul
code: @[to_additive]
theorem comp_mul (g : β →*o γ) (f₁ f₂ : α →*o β) : g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂ 
goal: g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂

full_name: OrderMonoidHom.toMonoidHom_eq_coe
code: @[to_additive (attr := simp)]
theorem toMonoidHom_eq_coe (f : α →*o β) : f.toMonoidHom = f 
goal: f.toMonoidHom = ↑f

full_name: OrderAddMonoidHom.toAddMonoidHom_eq_coe
code: @[to_additive (attr := simp)]
theorem toMonoidHom_eq_coe (f : α →*o β) : f.toMonoidHom = f 
goal: f.toAddMonoidHom = ↑f

full_name: OrderAddMonoidHom.toOrderHom_eq_coe
code: @[to_additive (attr := simp)]
theorem toOrderHom_eq_coe (f : α →*o β) : f.toOrderHom = f 
goal: f.toOrderHom = ↑f

full_name: OrderMonoidHom.toOrderHom_eq_coe
code: @[to_additive (attr := simp)]
theorem toOrderHom_eq_coe (f : α →*o β) : f.toOrderHom = f 
goal: f.toOrderHom = ↑f

full_name: OrderAddMonoidHom.mk'
code: /-- Makes an ordered group homomorphism from a proof that the map preserves multiplication. -/
@[to_additive
      "Makes an ordered additive group homomorphism from a proof that the map preserves
      addition."]
def mk' (f : α → β) (hf : Monotone f) (map_mul : ∀ a b : α, f (a * b) = f a * f b) : α →*o β 
goal: α →+o β

full_name: OrderMonoidHom.mk'
code: /-- Makes an ordered group homomorphism from a proof that the map preserves multiplication. -/
@[to_additive
      "Makes an ordered additive group homomorphism from a proof that the map preserves
      addition."]
def mk' (f : α → β) (hf : Monotone f) (map_mul : ∀ a b : α, f (a * b) = f a * f b) : α →*o β 
goal: α →*o β

full_name: OrderMonoidWithZeroHom.instFunLike
code: instance : FunLike (α →*₀o β) α β 
goal: FunLike (α →*₀o β) α β

full_name: OrderMonoidWithZeroHom.instMonoidWithZeroHomClass
code: instance : MonoidWithZeroHomClass (α →*₀o β) α β 
goal: MonoidWithZeroHomClass (α →*₀o β) α β

full_name: OrderMonoidWithZeroHom.instOrderHomClass
code: instance : OrderHomClass (α →*₀o β) α β 
goal: OrderHomClass (α →*₀o β) α β

full_name: OrderMonoidWithZeroHom.ext
code: @[ext]
theorem ext (h : ∀ a, f a = g a) : f = g 
goal: f = g

full_name: OrderMonoidWithZeroHom.toFun_eq_coe
code: theorem toFun_eq_coe (f : α →*₀o β) : f.toFun = (f : α → β) 
goal: (↑f.toMonoidWithZeroHom).toFun = ⇑f

full_name: OrderMonoidWithZeroHom.coe_mk
code: @[simp]
theorem coe_mk (f : α →*₀ β) (h) : (OrderMonoidWithZeroHom.mk f h : α → β) = f 
goal: ⇑{ toMonoidWithZeroHom := f, monotone' := h } = ⇑f

full_name: OrderMonoidWithZeroHom.mk_coe
code: @[simp]
theorem mk_coe (f : α →*₀o β) (h) : OrderMonoidWithZeroHom.mk (f : α →*₀ β) h = f 
goal: { toMonoidWithZeroHom := ↑f, monotone' := h } = f

full_name: OrderMonoidWithZeroHom.toOrderMonoidHom
code: /-- Reinterpret an ordered monoid with zero homomorphism as an order monoid homomorphism. -/
def toOrderMonoidHom (f : α →*₀o β) : α →*o β 
goal: α →*o β

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

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

full_name: OrderMonoidWithZeroHom.toOrderMonoidHom_injective
code: theorem toOrderMonoidHom_injective : Injective (toOrderMonoidHom : _ → α →*o β) 
goal: Function.Injective OrderMonoidWithZeroHom.toOrderMonoidHom

full_name: OrderMonoidWithZeroHom.toMonoidWithZeroHom_injective
code: theorem toMonoidWithZeroHom_injective : Injective (toMonoidWithZeroHom : _ → α →*₀ β) 
goal: Function.Injective OrderMonoidWithZeroHom.toMonoidWithZeroHom

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

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

full_name: OrderMonoidWithZeroHom.copy_eq
code: theorem copy_eq (f : α →*₀o β) (f' : α → β) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = ↑f

full_name: OrderMonoidWithZeroHom.id
code: /-- The identity map as an ordered monoid with zero homomorphism. -/
protected def id : α →*₀o α 
goal: α →*₀o α

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

full_name: OrderMonoidWithZeroHom.instInhabited
code: instance : Inhabited (α →*₀o α) 
goal: Inhabited (α →*₀o α)

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

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

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

full_name: OrderMonoidWithZeroHom.coe_comp_monoidWithZeroHom
code: theorem coe_comp_monoidWithZeroHom (f : β →*₀o γ) (g : α →*₀o β) :
    (f.comp g : α →*₀ γ) = (f : β →*₀ γ).comp g 
goal: ↑(f.comp g) = (↑f).comp ↑g

full_name: OrderMonoidWithZeroHom.coe_comp_orderMonoidHom
code: theorem coe_comp_orderMonoidHom (f : β →*₀o γ) (g : α →*₀o β) :
    (f.comp g : α →*o γ) = (f : β →*o γ).comp g 
goal: ↑(f.comp g) = (↑f).comp ↑g

full_name: OrderMonoidWithZeroHom.comp_assoc
code: @[simp]
theorem comp_assoc (f : γ →*₀o δ) (g : β →*₀o γ) (h : α →*₀o β) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

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

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

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

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

full_name: OrderMonoidWithZeroHom.instMul
code: /-- For two ordered monoid morphisms `f` and `g`, their product is the ordered monoid morphism
sending `a` to `f a * g a`. -/
instance : Mul (α →*₀o β) 
goal: Mul (α →*₀o β)

full_name: OrderMonoidWithZeroHom.coe_mul
code: @[simp]
theorem coe_mul (f g : α →*₀o β) : ⇑(f * g) = f * g 
goal: ⇑(f * g) = ⇑f * ⇑g

full_name: OrderMonoidWithZeroHom.mul_apply
code: @[simp]
theorem mul_apply (f g : α →*₀o β) (a : α) : (f * g) a = f a * g a 
goal: (f * g) a = f a * g a

full_name: OrderMonoidWithZeroHom.mul_comp
code: theorem mul_comp (g₁ g₂ : β →*₀o γ) (f : α →*₀o β) : (g₁ * g₂).comp f = g₁.comp f * g₂.comp f 
goal: (g₁ * g₂).comp f = g₁.comp f * g₂.comp f

full_name: OrderMonoidWithZeroHom.comp_mul
code: theorem comp_mul (g : β →*₀o γ) (f₁ f₂ : α →*₀o β) : g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂ 
goal: g.comp (f₁ * f₂) = g.comp f₁ * g.comp f₂

full_name: OrderMonoidWithZeroHom.toMonoidWithZeroHom_eq_coe
code: @[simp]
theorem toMonoidWithZeroHom_eq_coe (f : α →*₀o β) : f.toMonoidWithZeroHom = f 
goal: f.toMonoidWithZeroHom = ↑f

full_name: OrderMonoidWithZeroHom.toOrderMonoidHom_eq_coe
code: @[simp]
theorem toOrderMonoidHom_eq_coe (f : α →*₀o β) : f.toOrderMonoidHom = f 
goal: f.toOrderMonoidHom = ↑f