File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

full_name: LinearOrderedCommMonoidWithZero.zero_le_one
code: /-- A linearly ordered commutative monoid with a zero element. -/
class LinearOrderedCommMonoidWithZero (α : Type*) extends LinearOrderedCommMonoid α,
  CommMonoidWithZero α where
  /-- `0 ≤ 1` in any linearly ordered commutative monoid. -/
  zero_le_one : (0 : α) ≤ 1
goal: 0 ≤ 1

full_name: LinearOrderedCommMonoidWithZero
code: /-- A linearly ordered commutative monoid with a zero element. -/
class LinearOrderedCommMonoidWithZero (α : Type*) extends LinearOrderedCommMonoid α,
  CommMonoidWithZero α where
  /-- `0 ≤ 1` in any linearly ordered commutative monoid. -/
  zero_le_one : (0 : α) ≤ 1
goal: Type u_2

full_name: LinearOrderedCommGroupWithZero
code: /-- A linearly ordered commutative group with a zero element. -/
class LinearOrderedCommGroupWithZero (α : Type*) extends LinearOrderedCommMonoidWithZero α,
  CommGroupWithZero α
goal: Type u_2

full_name: LinearOrderedCommMonoidWithZero.toZeroLeOneClass
code: instance (priority := 100) LinearOrderedCommMonoidWithZero.toZeroLeOneClass
    [LinearOrderedCommMonoidWithZero α] : ZeroLEOneClass α 
goal: ZeroLEOneClass α

full_name: canonicallyOrderedAddCommMonoid.toZeroLeOneClass
code: instance (priority := 100) canonicallyOrderedAddCommMonoid.toZeroLeOneClass
    [CanonicallyOrderedAddCommMonoid α] [One α] : ZeroLEOneClass α 
goal: ZeroLEOneClass α

full_name: Function.Injective.linearOrderedCommMonoidWithZero
code: /-- Pullback a `LinearOrderedCommMonoidWithZero` under an injective map.
See note [reducible non-instances]. -/
abbrev Function.Injective.linearOrderedCommMonoidWithZero {β : Type*} [Zero β] [One β] [Mul β]
    [Pow β ℕ] [Sup β] [Inf β] (f : β → α) (hf : Function.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) = max (f x) (f y)) (hinf : ∀ x y, f (x ⊓ y) = min (f x) (f y)) :
    LinearOrderedCommMonoidWithZero β 
goal: LinearOrderedCommMonoidWithZero β

full_name: zero_le'
code: @[simp] lemma zero_le' : 0 ≤ a 
goal: 0 ≤ a

full_name: not_lt_zero'
code: @[simp]
theorem not_lt_zero' : ¬a < 0 
goal: ¬a < 0

full_name: le_zero_iff
code: @[simp]
theorem le_zero_iff : a ≤ 0 ↔ a = 0 
goal: a ≤ 0 ↔ a = 0

full_name: zero_lt_iff
code: theorem zero_lt_iff : 0 < a ↔ a ≠ 0 
goal: 0 < a ↔ a ≠ 0

full_name: ne_zero_of_lt
code: theorem ne_zero_of_lt (h : b < a) : a ≠ 0 
goal: a ≠ 0

full_name: instLinearOrderedAddCommMonoidWithTopAdditiveOrderDual
code: instance instLinearOrderedAddCommMonoidWithTopAdditiveOrderDual :
    LinearOrderedAddCommMonoidWithTop (Additive αᵒᵈ) 
goal: LinearOrderedAddCommMonoidWithTop (Additive αᵒᵈ)

full_name: pow_pos_iff
code: lemma pow_pos_iff (hn : n ≠ 0) : 0 < a ^ n ↔ 0 < a 
goal: 0 < a ^ n ↔ 0 < a

full_name: mul_le_one₀
code: /-- Alias of `mul_le_one'` for unification. -/
theorem mul_le_one₀ (ha : a ≤ 1) (hb : b ≤ 1) : a * b ≤ 1 
goal: a * b ≤ 1

full_name: one_le_mul₀
code: /-- Alias of `one_le_mul'` for unification. -/
theorem one_le_mul₀ (ha : 1 ≤ a) (hb : 1 ≤ b) : 1 ≤ a * b 
goal: 1 ≤ a * b

full_name: le_of_le_mul_right
code: theorem le_of_le_mul_right (h : c ≠ 0) (hab : a * c ≤ b * c) : a ≤ b 
goal: a ≤ b

full_name: le_mul_inv_of_mul_le
code: theorem le_mul_inv_of_mul_le (h : c ≠ 0) (hab : a * c ≤ b) : a ≤ b * c⁻¹ 
goal: a ≤ b * c⁻¹

full_name: mul_inv_le_of_le_mul
code: theorem mul_inv_le_of_le_mul (hab : a ≤ b * c) : a * c⁻¹ ≤ b 
goal: a * c⁻¹ ≤ b

full_name: inv_le_one₀
code: theorem inv_le_one₀ (ha : a ≠ 0) : a⁻¹ ≤ 1 ↔ 1 ≤ a 
goal: a⁻¹ ≤ 1 ↔ 1 ≤ a

full_name: one_le_inv₀
code: theorem one_le_inv₀ (ha : a ≠ 0) : 1 ≤ a⁻¹ ↔ a ≤ 1 
goal: 1 ≤ a⁻¹ ↔ a ≤ 1

full_name: le_mul_inv_iff₀
code: theorem le_mul_inv_iff₀ (hc : c ≠ 0) : a ≤ b * c⁻¹ ↔ a * c ≤ b 
goal: a ≤ b * c⁻¹ ↔ a * c ≤ b

full_name: mul_inv_le_iff₀
code: theorem mul_inv_le_iff₀ (hc : c ≠ 0) : a * c⁻¹ ≤ b ↔ a ≤ b * c 
goal: a * c⁻¹ ≤ b ↔ a ≤ b * c

full_name: div_le_div₀
code: theorem div_le_div₀ (a b c d : α) (hb : b ≠ 0) (hd : d ≠ 0) :
    a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b 
goal: a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b

full_name: Units.zero_lt
code: @[simp]
theorem Units.zero_lt (u : αˣ) : (0 : α) < u 
goal: 0 < ↑u

full_name: mul_lt_mul_of_lt_of_le₀
code: theorem mul_lt_mul_of_lt_of_le₀ (hab : a ≤ b) (hb : b ≠ 0) (hcd : c < d) : a * c < b * d 
goal: a * c < b * d

full_name: mul_lt_mul₀
code: theorem mul_lt_mul₀ (hab : a < b) (hcd : c < d) : a * c < b * d 
goal: a * c < b * d

full_name: mul_inv_lt_of_lt_mul₀
code: theorem mul_inv_lt_of_lt_mul₀ (h : a < b * c) : a * c⁻¹ < b 
goal: a * c⁻¹ < b

full_name: inv_mul_lt_of_lt_mul₀
code: theorem inv_mul_lt_of_lt_mul₀ (h : a < b * c) : b⁻¹ * a < c 
goal: b⁻¹ * a < c

full_name: mul_lt_right₀
code: theorem mul_lt_right₀ (c : α) (h : a < b) (hc : c ≠ 0) : a * c < b * c 
goal: a * c < b * c

full_name: inv_lt_one₀
code: theorem inv_lt_one₀ (ha : a ≠ 0) : a⁻¹ < 1 ↔ 1 < a 
goal: a⁻¹ < 1 ↔ 1 < a

full_name: one_lt_inv₀
code: theorem one_lt_inv₀ (ha : a ≠ 0) : 1 < a⁻¹ ↔ a < 1 
goal: 1 < a⁻¹ ↔ a < 1

full_name: inv_lt_inv₀
code: theorem inv_lt_inv₀ (ha : a ≠ 0) (hb : b ≠ 0) : a⁻¹ < b⁻¹ ↔ b < a 
goal: a⁻¹ < b⁻¹ ↔ b < a

full_name: inv_le_inv₀
code: theorem inv_le_inv₀ (ha : a ≠ 0) (hb : b ≠ 0) : a⁻¹ ≤ b⁻¹ ↔ b ≤ a 
goal: a⁻¹ ≤ b⁻¹ ↔ b ≤ a

full_name: lt_of_mul_lt_mul_of_le₀
code: theorem lt_of_mul_lt_mul_of_le₀ (h : a * b < c * d) (hc : 0 < c) (hh : c ≤ a) : b < d 
goal: b < d

full_name: mul_le_mul_right₀
code: theorem mul_le_mul_right₀ (hc : c ≠ 0) : a * c ≤ b * c ↔ a ≤ b 
goal: a * c ≤ b * c ↔ a ≤ b

full_name: mul_le_mul_left₀
code: theorem mul_le_mul_left₀ (ha : a ≠ 0) : a * b ≤ a * c ↔ b ≤ c 
goal: a * b ≤ a * c ↔ b ≤ c

full_name: div_le_div_right₀
code: theorem div_le_div_right₀ (hc : c ≠ 0) : a / c ≤ b / c ↔ a ≤ b 
goal: a / c ≤ b / c ↔ a ≤ b

full_name: div_le_div_left₀
code: theorem div_le_div_left₀ (ha : a ≠ 0) (hb : b ≠ 0) (hc : c ≠ 0) : a / b ≤ a / c ↔ c ≤ b 
goal: a / b ≤ a / c ↔ c ≤ b

full_name: le_div_iff₀
code: theorem le_div_iff₀ (hc : c ≠ 0) : a ≤ b / c ↔ a * c ≤ b 
goal: a ≤ b / c ↔ a * c ≤ b

full_name: div_le_iff₀
code: theorem div_le_iff₀ (hc : c ≠ 0) : a / c ≤ b ↔ a ≤ b * c 
goal: a / c ≤ b ↔ a ≤ b * c

full_name: OrderIso.mulLeft₀'_toEquiv
code: /-- `Equiv.mulLeft₀` as an `OrderIso` on a `LinearOrderedCommGroupWithZero.`.

Note that `OrderIso.mulLeft₀` refers to the `LinearOrderedField` version. -/
@[simps! (config := { simpRhs := true }) apply toEquiv]
def OrderIso.mulLeft₀' {a : α} (ha : a ≠ 0) : α ≃o α 
goal: (OrderIso.mulLeft₀' ha).toEquiv = Equiv.mulLeft₀ a ha

full_name: OrderIso.mulLeft₀'
code: /-- `Equiv.mulLeft₀` as an `OrderIso` on a `LinearOrderedCommGroupWithZero.`.

Note that `OrderIso.mulLeft₀` refers to the `LinearOrderedField` version. -/
@[simps! (config := { simpRhs := true }) apply toEquiv]
def OrderIso.mulLeft₀' {a : α} (ha : a ≠ 0) : α ≃o α 
goal: α ≃o α

full_name: OrderIso.mulLeft₀'_apply
code: /-- `Equiv.mulLeft₀` as an `OrderIso` on a `LinearOrderedCommGroupWithZero.`.

Note that `OrderIso.mulLeft₀` refers to the `LinearOrderedField` version. -/
@[simps! (config := { simpRhs := true }) apply toEquiv]
def OrderIso.mulLeft₀' {a : α} (ha : a ≠ 0) : α ≃o α 
goal: (OrderIso.mulLeft₀' ha) x = a * x

full_name: OrderIso.mulLeft₀'_symm
code: theorem OrderIso.mulLeft₀'_symm {a : α} (ha : a ≠ 0) :
    (OrderIso.mulLeft₀' ha).symm = OrderIso.mulLeft₀' (inv_ne_zero ha) 
goal: (OrderIso.mulLeft₀' ha).symm = OrderIso.mulLeft₀' ⋯

full_name: OrderIso.mulRight₀'_toEquiv
code: /-- `Equiv.mulRight₀` as an `OrderIso` on a `LinearOrderedCommGroupWithZero.`.

Note that `OrderIso.mulRight₀` refers to the `LinearOrderedField` version. -/
@[simps! (config := { simpRhs := true }) apply toEquiv]
def OrderIso.mulRight₀' {a : α} (ha : a ≠ 0) : α ≃o α 
goal: (OrderIso.mulRight₀' ha).toEquiv = Equiv.mulRight₀ a ha

full_name: OrderIso.mulRight₀'
code: /-- `Equiv.mulRight₀` as an `OrderIso` on a `LinearOrderedCommGroupWithZero.`.

Note that `OrderIso.mulRight₀` refers to the `LinearOrderedField` version. -/
@[simps! (config := { simpRhs := true }) apply toEquiv]
def OrderIso.mulRight₀' {a : α} (ha : a ≠ 0) : α ≃o α 
goal: α ≃o α

full_name: OrderIso.mulRight₀'_apply
code: /-- `Equiv.mulRight₀` as an `OrderIso` on a `LinearOrderedCommGroupWithZero.`.

Note that `OrderIso.mulRight₀` refers to the `LinearOrderedField` version. -/
@[simps! (config := { simpRhs := true }) apply toEquiv]
def OrderIso.mulRight₀' {a : α} (ha : a ≠ 0) : α ≃o α 
goal: (OrderIso.mulRight₀' ha) x = x * a

full_name: OrderIso.mulRight₀'_symm
code: theorem OrderIso.mulRight₀'_symm {a : α} (ha : a ≠ 0) :
    (OrderIso.mulRight₀' ha).symm = OrderIso.mulRight₀' (inv_ne_zero ha) 
goal: (OrderIso.mulRight₀' ha).symm = OrderIso.mulRight₀' ⋯

full_name: instLinearOrderedAddCommGroupWithTopAdditiveOrderDual
code: instance : LinearOrderedAddCommGroupWithTop (Additive αᵒᵈ) 
goal: LinearOrderedAddCommGroupWithTop (Additive αᵒᵈ)

full_name: pow_lt_pow_succ
code: lemma pow_lt_pow_succ (ha : 1 < a) : a ^ n < a ^ n.succ 
goal: a ^ n < a ^ n.succ

full_name: pow_lt_pow_right₀
code: lemma pow_lt_pow_right₀ (ha : 1 < a) (hmn : m < n) : a ^ m < a ^ n 
goal: a ^ m < a ^ n

full_name: instLinearOrderedCommMonoidWithZeroMultiplicativeOrderDual
code: instance instLinearOrderedCommMonoidWithZeroMultiplicativeOrderDual
    [LinearOrderedAddCommMonoidWithTop α] :
    LinearOrderedCommMonoidWithZero (Multiplicative αᵒᵈ) 
goal: LinearOrderedCommMonoidWithZero (Multiplicative αᵒᵈ)

full_name: instLinearOrderedCommGroupWithZeroMultiplicativeOrderDualOfLinearOrderedAddCommGroupWithTop
code: instance [LinearOrderedAddCommGroupWithTop α] :
    LinearOrderedCommGroupWithZero (Multiplicative αᵒᵈ) 
goal: LinearOrderedCommGroupWithZero (Multiplicative αᵒᵈ)

full_name: WithZero.preorder
code: instance preorder : Preorder (WithZero α) 
goal: Preorder (WithZero α)

full_name: WithZero.orderBot
code: instance orderBot : OrderBot (WithZero α) 
goal: OrderBot (WithZero α)

full_name: WithZero.zero_le
code: lemma zero_le (a : WithZero α) : 0 ≤ a 
goal: 0 ≤ a

full_name: WithZero.zero_lt_coe
code: lemma zero_lt_coe (a : α) : (0 : WithZero α) < a 
goal: 0 < ↑a

full_name: WithZero.zero_eq_bot
code: lemma zero_eq_bot : (0 : WithZero α) = ⊥ 
goal: 0 = ⊥

full_name: WithZero.coe_lt_coe
code: @[simp, norm_cast] lemma coe_lt_coe : (a : WithZero α) < b ↔ a < b 
goal: ↑a < ↑b ↔ a < b

full_name: WithZero.coe_le_coe
code: @[simp, norm_cast] lemma coe_le_coe : (a : WithZero α) ≤ b ↔ a ≤ b 
goal: ↑a ≤ ↑b ↔ a ≤ b

full_name: WithZero.one_lt_coe
code: @[simp, norm_cast] lemma one_lt_coe [One α] : 1 < (a : WithZero α) ↔ 1 < a 
goal: 1 < ↑a ↔ 1 < a

full_name: WithZero.one_le_coe
code: @[simp, norm_cast] lemma one_le_coe [One α] : 1 ≤ (a : WithZero α) ↔ 1 ≤ a 
goal: 1 ≤ ↑a ↔ 1 ≤ a

full_name: WithZero.coe_lt_one
code: @[simp, norm_cast] lemma coe_lt_one [One α] : (a : WithZero α) < 1 ↔ a < 1 
goal: ↑a < 1 ↔ a < 1

full_name: WithZero.coe_le_one
code: @[simp, norm_cast] lemma coe_le_one [One α] : (a : WithZero α) ≤ 1 ↔ a ≤ 1 
goal: ↑a ≤ 1 ↔ a ≤ 1

full_name: WithZero.coe_le_iff
code: theorem coe_le_iff {x : WithZero α} : (a : WithZero α) ≤ x ↔ ∃ b : α, x = b ∧ a ≤ b 
goal: ↑a ≤ x ↔ ∃ b, x = ↑b ∧ a ≤ b

full_name: WithZero.covariantClass_mul_le
code: instance covariantClass_mul_le [Mul α] [CovariantClass α α (· * ·) (· ≤ ·)] :
    CovariantClass (WithZero α) (WithZero α) (· * ·) (· ≤ ·) 
goal: CovariantClass (WithZero α) (WithZero α) (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1

full_name: WithZero.covariantClass_add_le
code: protected lemma covariantClass_add_le [AddZeroClass α] [CovariantClass α α (· + ·) (· ≤ ·)]
    (h : ∀ a : α, 0 ≤ a) : CovariantClass (WithZero α) (WithZero α) (· + ·) (· ≤ ·) 
goal: CovariantClass (WithZero α) (WithZero α) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: WithZero.existsAddOfLE
code: instance existsAddOfLE [Add α] [ExistsAddOfLE α] : ExistsAddOfLE (WithZero α) 
goal: ExistsAddOfLE (WithZero α)

full_name: WithZero.partialOrder
code: instance partialOrder : PartialOrder (WithZero α) 
goal: PartialOrder (WithZero α)

full_name: WithZero.contravariantClass_mul_lt
code: instance contravariantClass_mul_lt [Mul α] [ContravariantClass α α (· * ·) (· < ·)] :
    ContravariantClass (WithZero α) (WithZero α) (· * ·) (· < ·) 
goal: ContravariantClass (WithZero α) (WithZero α) (fun x x_1 => x * x_1) fun x x_1 => x < x_1

full_name: WithZero.lattice
code: instance lattice [Lattice α] : Lattice (WithZero α) 
goal: Lattice (WithZero α)

full_name: WithZero.linearOrder
code: instance linearOrder : LinearOrder (WithZero α) 
goal: LinearOrder (WithZero α)

full_name: WithZero.le_max_iff
code: protected lemma le_max_iff : (a : WithZero α) ≤ max (b : WithZero α) c ↔ a ≤ max b c 
goal: ↑a ≤ max ↑b ↑c ↔ a ≤ max b c

full_name: WithZero.min_le_iff
code: protected lemma min_le_iff : min (a : WithZero α) b ≤ c ↔ min a b ≤ c 
goal: min ↑a ↑b ≤ ↑c ↔ min a b ≤ c

full_name: WithZero.orderedCommMonoid
code: instance orderedCommMonoid [OrderedCommMonoid α] : OrderedCommMonoid (WithZero α) 
goal: OrderedCommMonoid (WithZero α)

full_name: WithZero.orderedAddCommMonoid
code: /-- If `0` is the least element in `α`, then `WithZero α` is an `OrderedAddCommMonoid`. -/
-- See note [reducible non-instances]
protected abbrev orderedAddCommMonoid [OrderedAddCommMonoid α] (zero_le : ∀ a : α, 0 ≤ a) :
    OrderedAddCommMonoid (WithZero α) 
goal: OrderedAddCommMonoid (WithZero α)

full_name: WithZero.canonicallyOrderedAddCommMonoid
code: /-- Adding a new zero to a canonically ordered additive monoid produces another one. -/
instance canonicallyOrderedAddCommMonoid [CanonicallyOrderedAddCommMonoid α] :
    CanonicallyOrderedAddCommMonoid (WithZero α) 
goal: CanonicallyOrderedAddCommMonoid (WithZero α)

full_name: WithZero.canonicallyLinearOrderedAddCommMonoid
code: instance canonicallyLinearOrderedAddCommMonoid [CanonicallyLinearOrderedAddCommMonoid α] :
    CanonicallyLinearOrderedAddCommMonoid (WithZero α) 
goal: CanonicallyLinearOrderedAddCommMonoid (WithZero α)

full_name: WithZero.instLinearOrderedCommMonoidWithZero
code: instance instLinearOrderedCommMonoidWithZero [LinearOrderedCommMonoid α] :
    LinearOrderedCommMonoidWithZero (WithZero α) 
goal: LinearOrderedCommMonoidWithZero (WithZero α)

full_name: WithZero.instLinearOrderedCommGroupWithZero
code: instance instLinearOrderedCommGroupWithZero [LinearOrderedCommGroup α] :
    LinearOrderedCommGroupWithZero (WithZero α) 
goal: LinearOrderedCommGroupWithZero (WithZero α)