Linearly ordered commutative groups and monoids with a zero element adjoined

This file sets up a special class of linearly ordered commutative monoids that show up as the target of so-called “valuations” in algebraic number theory.

Usually, in the informal literature, these objects are constructed by taking a linearly ordered commutative group Γ and formally adjoining a zero element: Γ ∪ {0}.

The disadvantage is that a type such as NNReal is not of that form, whereas it is a very common target for valuations. The solutions is to use a typeclass, and that is exactly what we do in this file.

class LinearOrderedCommMonoidWithZero (α : Type u_2) extends LinearOrderedCommMonoid α, CommMonoidWithZero α : Type u_2

A linearly ordered commutative monoid with a zero element.

• mul : α → α → α
• mul_assoc (a b c : α) : a * b * c = a * (b * c)
• one : α
• one_mul (a : α) : 1 * a = a
• mul_one (a : α) : a * 1 = a
• npow : ℕ → α → α
• npow_zero (x : α) : Monoid.npow 0 x = 1
• npow_succ (n : ℕ) (x : α) : Monoid.npow (n + 1) x = Monoid.npow n x * x
• mul_comm (a b : α) : a * b = b * a
• le : α → α → Prop
• lt : α → α → Prop
• le_refl (a : α) : a ≤ a
• le_trans (a b c : α) : a ≤ b → b ≤ c → a ≤ c
• lt_iff_le_not_le (a b : α) : a < b ↔ a ≤ b ∧ ¬b ≤ a
• le_antisymm (a b : α) : a ≤ b → b ≤ a → a = b
• mul_le_mul_left (a b : α) : a ≤ b → ∀ (c : α), c * a ≤ c * b
• min : α → α → α
• max : α → α → α
• compare : α → α → Ordering
• le_total (a b : α) : a ≤ b ∨ b ≤ a
• decidableLE : DecidableRel fun (x1 x2 : α) => x1 ≤ x2
• decidableEq : DecidableEq α
• decidableLT : DecidableRel fun (x1 x2 : α) => x1 < x2
• min_def (a b : α) : a ⊓ b = if a ≤ b then a else b
• max_def (a b : α) : a ⊔ b = if a ≤ b then b else a
• compare_eq_compareOfLessAndEq (a b : α) : compare a b = compareOfLessAndEq a b
• zero : α
• zero_mul (a : α) : 0 * a = 0
• mul_zero (a : α) : a * 0 = 0
• zero_le_one : 0 ≤ 1

  0 ≤ 1 in any linearly ordered commutative monoid.

Instances

• Nat.instLinearOrderedCommMonoidWithZero
• Nonneg.linearOrderedCommMonoidWithZero
• WithZero.instLinearOrderedCommMonoidWithZero
• instLinearOrderedCommMonoidWithZeroMultiplicativeOrderDual

class LinearOrderedCommGroupWithZero (α : Type u_2) extends LinearOrderedCommMonoidWithZero α, CommGroupWithZero α : Type u_2

A linearly ordered commutative group with a zero element.

• mul : α → α → α
• mul_assoc (a b c : α) : a * b * c = a * (b * c)
• one : α
• one_mul (a : α) : 1 * a = a
• mul_one (a : α) : a * 1 = a
• npow : ℕ → α → α
• npow_zero (x : α) : Monoid.npow 0 x = 1
• npow_succ (n : ℕ) (x : α) : Monoid.npow (n + 1) x = Monoid.npow n x * x
• mul_comm (a b : α) : a * b = b * a
• le : α → α → Prop
• lt : α → α → Prop
• le_refl (a : α) : a ≤ a
• le_trans (a b c : α) : a ≤ b → b ≤ c → a ≤ c
• lt_iff_le_not_le (a b : α) : a < b ↔ a ≤ b ∧ ¬b ≤ a
• le_antisymm (a b : α) : a ≤ b → b ≤ a → a = b
• mul_le_mul_left (a b : α) : a ≤ b → ∀ (c : α), c * a ≤ c * b
• min : α → α → α
• max : α → α → α
• compare : α → α → Ordering
• le_total (a b : α) : a ≤ b ∨ b ≤ a
• decidableLE : DecidableRel fun (x1 x2 : α) => x1 ≤ x2
• decidableEq : DecidableEq α
• decidableLT : DecidableRel fun (x1 x2 : α) => x1 < x2
• min_def (a b : α) : a ⊓ b = if a ≤ b then a else b
• max_def (a b : α) : a ⊔ b = if a ≤ b then b else a
• compare_eq_compareOfLessAndEq (a b : α) : compare a b = compareOfLessAndEq a b
• zero : α
• zero_mul (a : α) : 0 * a = 0
• mul_zero (a : α) : a * 0 = 0
• zero_le_one : 0 ≤ 1
• inv : α → α
• div : α → α → α
• div_eq_mul_inv (a b : α) : a / b = a * b⁻¹
• zpow : ℤ → α → α
• zpow_zero' (a : α) : LinearOrderedCommGroupWithZero.zpow 0 a = 1
• zpow_succ' (n : ℕ) (a : α) : LinearOrderedCommGroupWithZero.zpow (↑n.succ) a = LinearOrderedCommGroupWithZero.zpow (↑n) a * a
• zpow_neg' (n : ℕ) (a : α) : LinearOrderedCommGroupWithZero.zpow (Int.negSucc n) a = (LinearOrderedCommGroupWithZero.zpow (↑n.succ) a)⁻¹
• exists_pair_ne : ∃ (x : α), ∃ (y : α), x ≠ y
• inv_zero : 0⁻¹ = 0
• mul_inv_cancel (a : α) : a ≠ 0 → a * a⁻¹ = 1

Instances

• Nonneg.linearOrderedCommGroupWithZero
• WithZero.instLinearOrderedCommGroupWithZero
• instLinearOrderedCommGroupWithZeroMultiplicativeOrderDualOfLinearOrderedAddCommGroupWithTop
• instNNRatLinearOrderedCommGroupWithZero

@[instance 100]

instance LinearOrderedCommMonoidWithZero.toZeroLeOneClass {α : Type u_1} [LinearOrderedCommMonoidWithZero α] : ZeroLEOneClass α

@[instance 100]

instance CanonicallyOrderedAdd.toZeroLeOneClass {α : Type u_1} [AddZeroClass α] [LE α] [CanonicallyOrderedAdd α] [One α] : ZeroLEOneClass α

@[reducible, inline]

abbrev Function.Injective.linearOrderedCommMonoidWithZero {α : Type u_1} [LinearOrderedCommMonoidWithZero α] {β : Type u_2} [Zero β] [One β] [Mul β] [Pow β ℕ] [Max β] [Min β] (f : β → α) (hf : Injective f) (zero : f 0 = 0) (one : f 1 = 1) (mul : ∀ (x y : β), f (x * y) = f x * f y) (npow : ∀ (x : β) (n : ℕ), f (x ^ n) = f x ^ n) (hsup : ∀ (x y : β), f (x ⊔ y) = f x ⊔ f y) (hinf : ∀ (x y : β), f (x ⊓ y) = f x ⊓ f y) : LinearOrderedCommMonoidWithZero β

Pullback a LinearOrderedCommMonoidWithZero under an injective map. See note [reducible non-instances].

Equations

• Function.Injective.linearOrderedCommMonoidWithZero f hf zero one mul npow hsup hinf = LinearOrderedCommMonoidWithZero.mk ⋯ ⋯ ⋯

@[simp]

theorem zero_le' {α : Type u_1} [LinearOrderedCommMonoidWithZero α] {a : α} : 0 ≤ a

@[simp]

theorem not_lt_zero' {α : Type u_1} [LinearOrderedCommMonoidWithZero α] {a : α} : ¬a < 0

@[simp]

theorem le_zero_iff {α : Type u_1} [LinearOrderedCommMonoidWithZero α] {a : α} : a ≤ 0 ↔ a = 0

theorem zero_lt_iff {α : Type u_1} [LinearOrderedCommMonoidWithZero α] {a : α} : 0 < a ↔ a ≠ 0

theorem ne_zero_of_lt {α : Type u_1} [LinearOrderedCommMonoidWithZero α] {a b : α} (h : b < a) : a ≠ 0

instance instLinearOrderedAddCommMonoidWithTopAdditiveOrderDual {α : Type u_1} [LinearOrderedCommMonoidWithZero α] : LinearOrderedAddCommMonoidWithTop (Additive αᵒᵈ)

Equations

• instLinearOrderedAddCommMonoidWithTopAdditiveOrderDual = LinearOrderedAddCommMonoidWithTop.mk ⋯

instance instLinearOrderedAddCommMonoidWithTopOrderDualAdditive {α : Type u_1} [LinearOrderedCommMonoidWithZero α] : LinearOrderedAddCommMonoidWithTop (Additive α)ᵒᵈ

Equations

• instLinearOrderedAddCommMonoidWithTopOrderDualAdditive = LinearOrderedAddCommMonoidWithTop.mk ⋯

theorem pow_pos_iff {α : Type u_1} [LinearOrderedCommMonoidWithZero α] {a : α} {n : ℕ} [NoZeroDivisors α] (hn : n ≠ 0) : 0 < a ^ n ↔ 0 < a

@[instance 100]

instance LinearOrderedCommGroupWithZero.toMulPosMono {α : Type u_1} [LinearOrderedCommGroupWithZero α] : MulPosMono α

@[instance 100]

instance LinearOrderedCommGroupWithZero.toPosMulMono {α : Type u_1} [LinearOrderedCommGroupWithZero α] : PosMulMono α

@[instance 100]

instance LinearOrderedCommGroupWithZero.toPosMulReflectLE {α : Type u_1} [LinearOrderedCommGroupWithZero α] : PosMulReflectLE α

@[instance 100]

instance LinearOrderedCommGroupWithZero.toMulPosReflectLE {α : Type u_1} [LinearOrderedCommGroupWithZero α] : MulPosReflectLE α

@[instance 100]

instance LinearOrderedCommGroupWithZero.toPosMulReflectLT {α : Type u_1} [LinearOrderedCommGroupWithZero α] : PosMulReflectLT α

@[instance 100]

instance LinearOrderedCommGroupWithZero.toPosMulStrictMono {α : Type u_1} [LinearOrderedCommGroupWithZero α] : PosMulStrictMono α

@[instance 100]

instance LinearOrderedCommGroupWithZero.toMulPosStrictMono {α : Type u_1} [LinearOrderedCommGroupWithZero α] : MulPosStrictMono α

@[deprecated mul_inv_le_of_le_mul₀ (since := "2024-11-18")]

theorem mul_inv_le_of_le_mul {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a b c : α} (hab : a ≤ b * c) : a * c⁻¹ ≤ b

@[simp]

theorem Units.zero_lt {α : Type u_1} [LinearOrderedCommGroupWithZero α] (u : αˣ) : 0 < ↑u

@[deprecated mul_lt_mul_of_le_of_lt_of_nonneg_of_pos (since := "2024-11-18")]

theorem mul_lt_mul_of_lt_of_le₀ {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a b c d : α} (hab : a ≤ b) (hb : b ≠ 0) (hcd : c < d) : a * c < b * d

@[deprecated mul_lt_mul'' (since := "2024-11-18")]

theorem mul_lt_mul₀ {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a b c d : α} (hab : a < b) (hcd : c < d) : a * c < b * d

theorem mul_inv_lt_of_lt_mul₀ {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a b c : α} (h : a < b * c) : a * c⁻¹ < b

theorem inv_mul_lt_of_lt_mul₀ {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a b c : α} (h : a < b * c) : b⁻¹ * a < c

theorem lt_of_mul_lt_mul_of_le₀ {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a b c d : α} (h : a * b < c * d) (hc : 0 < c) (hh : c ≤ a) : b < d

@[deprecated div_le_div_iff_of_pos_right (since := "2024-11-18")]

theorem div_le_div_right₀ {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a b c : α} (hc : c ≠ 0) : a / c ≤ b / c ↔ a ≤ b

@[deprecated div_le_div_iff_of_pos_left (since := "2024-11-18")]

theorem div_le_div_left₀ {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a b c : α} (ha : a ≠ 0) (hb : b ≠ 0) (hc : c ≠ 0) : a / b ≤ a / c ↔ c ≤ b

@[deprecated OrderIso.mulLeft₀ (since := "2024-11-18")]

def OrderIso.mulLeft₀' {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a : α} (ha : a ≠ 0) : α ≃o α

Equiv.mulLeft₀ as an OrderIso on a LinearOrderedCommGroupWithZero..

Equations

• OrderIso.mulLeft₀' ha = OrderIso.mulLeft₀ a ⋯

@[simp]

theorem OrderIso.mulLeft₀'_apply {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a : α} (ha : a ≠ 0) (x : α) : (mulLeft₀' ha) x = a * x

@[simp]

theorem OrderIso.mulLeft₀'_toEquiv {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a : α} (ha : a ≠ 0) : (mulLeft₀' ha).toEquiv = Equiv.mulLeft₀ a ⋯

@[deprecated OrderIso.mulLeft₀_symm (since := "2024-11-18")]

theorem OrderIso.mulLeft₀'_symm {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a : α} (ha : a ≠ 0) : (mulLeft₀' ha).symm = mulLeft₀' ⋯

@[deprecated OrderIso.mulRight₀ (since := "2024-11-18")]

def OrderIso.mulRight₀' {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a : α} (ha : a ≠ 0) : α ≃o α

Equiv.mulRight₀ as an OrderIso on a LinearOrderedCommGroupWithZero..

Equations

• OrderIso.mulRight₀' ha = OrderIso.mulRight₀ a ⋯

@[simp]

theorem OrderIso.mulRight₀'_apply {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a : α} (ha : a ≠ 0) (x : α) : (mulRight₀' ha) x = x * a

@[simp]

theorem OrderIso.mulRight₀'_toEquiv {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a : α} (ha : a ≠ 0) : (mulRight₀' ha).toEquiv = Equiv.mulRight₀ a ⋯

@[deprecated OrderIso.mulRight₀_symm (since := "2024-11-18")]

theorem OrderIso.mulRight₀'_symm {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a : α} (ha : a ≠ 0) : (mulRight₀' ha).symm = mulRight₀' ⋯

instance instLinearOrderedAddCommGroupWithTopAdditiveOrderDual {α : Type u_1} [LinearOrderedCommGroupWithZero α] : LinearOrderedAddCommGroupWithTop (Additive αᵒᵈ)

Equations

• instLinearOrderedAddCommGroupWithTopAdditiveOrderDual = LinearOrderedAddCommGroupWithTop.mk ⋯ SubNegMonoid.zsmul ⋯ ⋯ ⋯ ⋯ ⋯

instance instLinearOrderedAddCommGroupWithTopOrderDualAdditive {α : Type u_1} [LinearOrderedCommGroupWithZero α] : LinearOrderedAddCommGroupWithTop (Additive α)ᵒᵈ

Equations

• instLinearOrderedAddCommGroupWithTopOrderDualAdditive = LinearOrderedAddCommGroupWithTop.mk ⋯ SubNegMonoid.zsmul ⋯ ⋯ ⋯ ⋯ ⋯

@[deprecated pow_lt_pow_right₀ (since := "2024-11-18")]

theorem pow_lt_pow_succ {α : Type u_1} [LinearOrderedCommGroupWithZero α] {a : α} {n : ℕ} (ha : 1 < a) : a ^ n < a ^ n.succ

instance instLinearOrderedCommMonoidWithZeroMultiplicativeOrderDual {α : Type u_1} [LinearOrderedAddCommMonoidWithTop α] : LinearOrderedCommMonoidWithZero (Multiplicative αᵒᵈ)

Equations

• instLinearOrderedCommMonoidWithZeroMultiplicativeOrderDual = LinearOrderedCommMonoidWithZero.mk ⋯ ⋯ ⋯

@[simp]

theorem ofAdd_toDual_eq_zero_iff {α : Type u_1} [LinearOrderedAddCommMonoidWithTop α] (x : α) : Multiplicative.ofAdd (OrderDual.toDual x) = 0 ↔ x = ⊤

@[simp]

theorem ofDual_toAdd_eq_top_iff {α : Type u_1} [LinearOrderedAddCommMonoidWithTop α] (x : Multiplicative αᵒᵈ) : OrderDual.ofDual (Multiplicative.toAdd x) = ⊤ ↔ x = 0

@[simp]

theorem ofAdd_bot {α : Type u_1} [LinearOrderedAddCommMonoidWithTop α] : Multiplicative.ofAdd ⊥ = 0

@[simp]

theorem ofDual_toAdd_zero {α : Type u_1} [LinearOrderedAddCommMonoidWithTop α] : OrderDual.ofDual (Multiplicative.toAdd 0) = ⊤

instance instLinearOrderedCommGroupWithZeroMultiplicativeOrderDualOfLinearOrderedAddCommGroupWithTop {α : Type u_1} [LinearOrderedAddCommGroupWithTop α] : LinearOrderedCommGroupWithZero (Multiplicative αᵒᵈ)

Equations

• instLinearOrderedCommGroupWithZeroMultiplicativeOrderDualOfLinearOrderedAddCommGroupWithTop = LinearOrderedCommGroupWithZero.mk ⋯ DivInvMonoid.zpow ⋯ ⋯ ⋯ ⋯ ⋯

instance WithZero.preorder {α : Type u_1} [Preorder α] : Preorder (WithZero α)

Equations

• WithZero.preorder = WithBot.preorder

instance WithZero.orderBot {α : Type u_1} [Preorder α] : OrderBot (WithZero α)

Equations

• WithZero.orderBot = WithBot.orderBot

theorem WithZero.zero_le {α : Type u_1} [Preorder α] (a : WithZero α) : 0 ≤ a

theorem WithZero.zero_lt_coe {α : Type u_1} [Preorder α] (a : α) : 0 < ↑a

theorem WithZero.zero_eq_bot {α : Type u_1} [Preorder α] : 0 = ⊥

@[simp]

theorem WithZero.coe_lt_coe {α : Type u_1} [Preorder α] {a b : α} : ↑a < ↑b ↔ a < b

@[simp]

theorem WithZero.coe_le_coe {α : Type u_1} [Preorder α] {a b : α} : ↑a ≤ ↑b ↔ a ≤ b

@[simp]

theorem WithZero.one_lt_coe {α : Type u_1} [Preorder α] {a : α} [One α] : 1 < ↑a ↔ 1 < a

@[simp]

theorem WithZero.one_le_coe {α : Type u_1} [Preorder α] {a : α} [One α] : 1 ≤ ↑a ↔ 1 ≤ a

@[simp]

theorem WithZero.coe_lt_one {α : Type u_1} [Preorder α] {a : α} [One α] : ↑a < 1 ↔ a < 1

@[simp]

theorem WithZero.coe_le_one {α : Type u_1} [Preorder α] {a : α} [One α] : ↑a ≤ 1 ↔ a ≤ 1

theorem WithZero.coe_le_iff {α : Type u_1} [Preorder α] {a : α} {x : WithZero α} : ↑a ≤ x ↔ ∃ (b : α), x = ↑b ∧ a ≤ b

@[simp]

theorem WithZero.unzero_le_unzero {α : Type u_1} [Preorder α] {a b : WithZero α} (ha : a ≠ 0) (hb : b ≠ 0) : unzero ha ≤ unzero hb ↔ a ≤ b

instance WithZero.mulLeftMono {α : Type u_1} [Preorder α] [Mul α] [MulLeftMono α] : MulLeftMono (WithZero α)

theorem WithZero.addLeftMono {α : Type u_1} [Preorder α] [AddZeroClass α] [AddLeftMono α] (h : ∀ (a : α), 0 ≤ a) : AddLeftMono (WithZero α)

instance WithZero.existsAddOfLE {α : Type u_1} [Preorder α] [Add α] [ExistsAddOfLE α] : ExistsAddOfLE (WithZero α)

instance WithZero.partialOrder {α : Type u_1} [PartialOrder α] : PartialOrder (WithZero α)

Equations

• WithZero.partialOrder = WithBot.partialOrder

instance WithZero.mulLeftReflectLT {α : Type u_1} [PartialOrder α] [Mul α] [MulLeftReflectLT α] : MulLeftReflectLT (WithZero α)

instance WithZero.lattice {α : Type u_1} [Lattice α] : Lattice (WithZero α)

Equations

• WithZero.lattice = WithBot.lattice

instance WithZero.linearOrder {α : Type u_1} [LinearOrder α] : LinearOrder (WithZero α)

Equations

• WithZero.linearOrder = WithBot.linearOrder

theorem WithZero.le_max_iff {α : Type u_1} [LinearOrder α] {a b c : α} : ↑a ≤ ↑b ⊔ ↑c ↔ a ≤ b ⊔ c

theorem WithZero.min_le_iff {α : Type u_1} [LinearOrder α] {a b c : α} : ↑a ⊓ ↑b ≤ ↑c ↔ a ⊓ b ≤ c

instance WithZero.orderedCommMonoid {α : Type u_1} [OrderedCommMonoid α] : OrderedCommMonoid (WithZero α)

Equations

• WithZero.orderedCommMonoid = OrderedCommMonoid.mk ⋯

@[reducible, inline]

abbrev WithZero.orderedAddCommMonoid {α : Type u_1} [OrderedAddCommMonoid α] (zero_le : ∀ (a : α), 0 ≤ a) : OrderedAddCommMonoid (WithZero α)

If 0 is the least element in α, then WithZero α is an OrderedAddCommMonoid.

Equations

• WithZero.orderedAddCommMonoid zero_le = OrderedAddCommMonoid.mk ⋯

instance WithZero.canonicallyOrderedAdd {α : Type u_1} [AddZeroClass α] [Preorder α] [CanonicallyOrderedAdd α] : CanonicallyOrderedAdd (WithZero α)

Adding a new zero to a canonically ordered additive monoid produces another one.

instance WithZero.instLinearOrderedCommMonoidWithZero {α : Type u_1} [LinearOrderedCommMonoid α] : LinearOrderedCommMonoidWithZero (WithZero α)

Equations

• WithZero.instLinearOrderedCommMonoidWithZero = LinearOrderedCommMonoidWithZero.mk ⋯ ⋯ ⋯

instance WithZero.instLinearOrderedCommGroupWithZero {α : Type u_1} [LinearOrderedCommGroup α] : LinearOrderedCommGroupWithZero (WithZero α)

Equations

• WithZero.instLinearOrderedCommGroupWithZero = LinearOrderedCommGroupWithZero.mk ⋯ CommGroupWithZero.zpow ⋯ ⋯ ⋯ ⋯ ⋯

def Multiplicative.termℕₘ₀ : Lean.ParserDescr

Notation for WithZero (Multiplicative ℕ)

Equations

• Multiplicative.termℕₘ₀ = Lean.ParserDescr.node `Multiplicative.termℕₘ₀ 1024 (Lean.ParserDescr.symbol "ℕₘ₀")

def Multiplicative.termℤₘ₀ : Lean.ParserDescr

Notation for WithZero (Multiplicative ℤ)

Equations

• Multiplicative.termℤₘ₀ = Lean.ParserDescr.node `Multiplicative.termℤₘ₀ 1024 (Lean.ParserDescr.symbol "ℤₘ₀")