File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

full_name: CanonicallyOrderedAddCommMonoid
code: /-- A canonically ordered additive monoid is an ordered commutative additive monoid
  in which the ordering coincides with the subtractibility relation,
  which is to say, `a ≤ b` iff there exists `c` with `b = a + c`.
  This is satisfied by the natural numbers, for example, but not
  the integers or other nontrivial `OrderedAddCommGroup`s. -/
class CanonicallyOrderedAddCommMonoid (α : Type*) extends OrderedAddCommMonoid α, OrderBot α where
  /-- For `a ≤ b`, there is a `c` so `b = a + c`. -/
  protected exists_add_of_le : ∀ {a b : α}, a ≤ b → ∃ c, b = a + c
  /-- For any `a` and `b`, `a ≤ a + b` -/
  protected le_self_add : ∀ a b : α, a ≤ a + b
goal: Type u_1

full_name: CanonicallyOrderedAddCommMonoid.exists_add_of_le
code: /-- A canonically ordered additive monoid is an ordered commutative additive monoid
  in which the ordering coincides with the subtractibility relation,
  which is to say, `a ≤ b` iff there exists `c` with `b = a + c`.
  This is satisfied by the natural numbers, for example, but not
  the integers or other nontrivial `OrderedAddCommGroup`s. -/
class CanonicallyOrderedAddCommMonoid (α : Type*) extends OrderedAddCommMonoid α, OrderBot α where
  /-- For `a ≤ b`, there is a `c` so `b = a + c`. -/
  protected exists_add_of_le : ∀ {a b : α}, a ≤ b → ∃ c, b = a + c
  /-- For any `a` and `b`, `a ≤ a + b` -/
  protected le_self_add : ∀ a b : α, a ≤ a + b
goal: a ≤ b → ∃ c, b = a + c

full_name: CanonicallyOrderedAddCommMonoid.le_self_add
code: /-- A canonically ordered additive monoid is an ordered commutative additive monoid
  in which the ordering coincides with the subtractibility relation,
  which is to say, `a ≤ b` iff there exists `c` with `b = a + c`.
  This is satisfied by the natural numbers, for example, but not
  the integers or other nontrivial `OrderedAddCommGroup`s. -/
class CanonicallyOrderedAddCommMonoid (α : Type*) extends OrderedAddCommMonoid α, OrderBot α where
  /-- For `a ≤ b`, there is a `c` so `b = a + c`. -/
  protected exists_add_of_le : ∀ {a b : α}, a ≤ b → ∃ c, b = a + c
  /-- For any `a` and `b`, `a ≤ a + b` -/
  protected le_self_add : ∀ a b : α, a ≤ a + b
goal: a ≤ a + b

full_name: CanonicallyOrderedCommMonoid.le_self_mul
code: /-- A canonically ordered monoid is an ordered commutative monoid
  in which the ordering coincides with the divisibility relation,
  which is to say, `a ≤ b` iff there exists `c` with `b = a * c`.
  Examples seem rare; it seems more likely that the `OrderDual`
  of a naturally-occurring lattice satisfies this than the lattice
  itself (for example, dual of the lattice of ideals of a PID or
  Dedekind domain satisfy this; collections of all things ≤ 1 seem to
  be more natural that collections of all things ≥ 1).
-/
@[to_additive]
class CanonicallyOrderedCommMonoid (α : Type*) extends OrderedCommMonoid α, OrderBot α where
  /-- For `a ≤ b`, there is a `c` so `b = a * c`. -/
  protected exists_mul_of_le : ∀ {a b : α}, a ≤ b → ∃ c, b = a * c
  /-- For any `a` and `b`, `a ≤ a * b` -/
  protected le_self_mul : ∀ a b : α, a ≤ a * b
goal: a ≤ a * b

full_name: CanonicallyOrderedCommMonoid.exists_mul_of_le
code: /-- A canonically ordered monoid is an ordered commutative monoid
  in which the ordering coincides with the divisibility relation,
  which is to say, `a ≤ b` iff there exists `c` with `b = a * c`.
  Examples seem rare; it seems more likely that the `OrderDual`
  of a naturally-occurring lattice satisfies this than the lattice
  itself (for example, dual of the lattice of ideals of a PID or
  Dedekind domain satisfy this; collections of all things ≤ 1 seem to
  be more natural that collections of all things ≥ 1).
-/
@[to_additive]
class CanonicallyOrderedCommMonoid (α : Type*) extends OrderedCommMonoid α, OrderBot α where
  /-- For `a ≤ b`, there is a `c` so `b = a * c`. -/
  protected exists_mul_of_le : ∀ {a b : α}, a ≤ b → ∃ c, b = a * c
  /-- For any `a` and `b`, `a ≤ a * b` -/
  protected le_self_mul : ∀ a b : α, a ≤ a * b
goal: a ≤ b → ∃ c, b = a * c

full_name: CanonicallyOrderedCommMonoid
code: /-- A canonically ordered monoid is an ordered commutative monoid
  in which the ordering coincides with the divisibility relation,
  which is to say, `a ≤ b` iff there exists `c` with `b = a * c`.
  Examples seem rare; it seems more likely that the `OrderDual`
  of a naturally-occurring lattice satisfies this than the lattice
  itself (for example, dual of the lattice of ideals of a PID or
  Dedekind domain satisfy this; collections of all things ≤ 1 seem to
  be more natural that collections of all things ≥ 1).
-/
@[to_additive]
class CanonicallyOrderedCommMonoid (α : Type*) extends OrderedCommMonoid α, OrderBot α where
  /-- For `a ≤ b`, there is a `c` so `b = a * c`. -/
  protected exists_mul_of_le : ∀ {a b : α}, a ≤ b → ∃ c, b = a * c
  /-- For any `a` and `b`, `a ≤ a * b` -/
  protected le_self_mul : ∀ a b : α, a ≤ a * b
goal: Type u_1

full_name: CanonicallyOrderedCommMonoid.existsMulOfLE
code: @[to_additive]
instance (priority := 100) CanonicallyOrderedCommMonoid.existsMulOfLE (α : Type u)
    [h : CanonicallyOrderedCommMonoid α] : ExistsMulOfLE α 
goal: ExistsMulOfLE α

full_name: CanonicallyOrderedAddCommMonoid.existsAddOfLE
code: @[to_additive]
instance (priority := 100) CanonicallyOrderedCommMonoid.existsMulOfLE (α : Type u)
    [h : CanonicallyOrderedCommMonoid α] : ExistsMulOfLE α 
goal: ExistsAddOfLE α

full_name: le_self_mul
code: @[to_additive]
theorem le_self_mul : a ≤ a * c 
goal: a ≤ a * c

full_name: le_self_add
code: @[to_additive]
theorem le_self_mul : a ≤ a * c 
goal: a ≤ a + c

full_name: le_add_self
code: @[to_additive]
theorem le_mul_self : a ≤ b * a 
goal: a ≤ b + a

full_name: le_mul_self
code: @[to_additive]
theorem le_mul_self : a ≤ b * a 
goal: a ≤ b * a

full_name: self_le_mul_right
code: @[to_additive (attr := simp)]
theorem self_le_mul_right (a b : α) : a ≤ a * b 
goal: a ≤ a * b

full_name: self_le_add_right
code: @[to_additive (attr := simp)]
theorem self_le_mul_right (a b : α) : a ≤ a * b 
goal: a ≤ a + b

full_name: self_le_add_left
code: @[to_additive (attr := simp)]
theorem self_le_mul_left (a b : α) : a ≤ b * a 
goal: a ≤ b + a

full_name: self_le_mul_left
code: @[to_additive (attr := simp)]
theorem self_le_mul_left (a b : α) : a ≤ b * a 
goal: a ≤ b * a

full_name: le_of_mul_le_left
code: @[to_additive]
theorem le_of_mul_le_left : a * b ≤ c → a ≤ c 
goal: a * b ≤ c → a ≤ c

full_name: le_of_add_le_left
code: @[to_additive]
theorem le_of_mul_le_left : a * b ≤ c → a ≤ c 
goal: a + b ≤ c → a ≤ c

full_name: le_of_add_le_right
code: @[to_additive]
theorem le_of_mul_le_right : a * b ≤ c → b ≤ c 
goal: a + b ≤ c → b ≤ c

full_name: le_of_mul_le_right
code: @[to_additive]
theorem le_of_mul_le_right : a * b ≤ c → b ≤ c 
goal: a * b ≤ c → b ≤ c

full_name: le_mul_of_le_left
code: @[to_additive]
theorem le_mul_of_le_left : a ≤ b → a ≤ b * c 
goal: a ≤ b → a ≤ b * c

full_name: le_add_of_le_left
code: @[to_additive]
theorem le_mul_of_le_left : a ≤ b → a ≤ b * c 
goal: a ≤ b → a ≤ b + c

full_name: le_add_of_le_right
code: @[to_additive]
theorem le_mul_of_le_right : a ≤ c → a ≤ b * c 
goal: a ≤ c → a ≤ b + c

full_name: le_mul_of_le_right
code: @[to_additive]
theorem le_mul_of_le_right : a ≤ c → a ≤ b * c 
goal: a ≤ c → a ≤ b * c

full_name: le_iff_exists_mul
code: @[to_additive]
theorem le_iff_exists_mul : a ≤ b ↔ ∃ c, b = a * c 
goal: a ≤ b ↔ ∃ c, b = a * c

full_name: le_iff_exists_add
code: @[to_additive]
theorem le_iff_exists_mul : a ≤ b ↔ ∃ c, b = a * c 
goal: a ≤ b ↔ ∃ c, b = a + c

full_name: le_iff_exists_add'
code: @[to_additive]
theorem le_iff_exists_mul' : a ≤ b ↔ ∃ c, b = c * a 
goal: a ≤ b ↔ ∃ c, b = c + a

full_name: le_iff_exists_mul'
code: @[to_additive]
theorem le_iff_exists_mul' : a ≤ b ↔ ∃ c, b = c * a 
goal: a ≤ b ↔ ∃ c, b = c * a

full_name: one_le
code: @[to_additive (attr := simp) zero_le]
theorem one_le (a : α) : 1 ≤ a 
goal: 1 ≤ a

full_name: zero_le
code: @[to_additive (attr := simp) zero_le]
theorem one_le (a : α) : 1 ≤ a 
goal: 0 ≤ a

full_name: bot_eq_one
code: @[to_additive]
theorem bot_eq_one : (⊥ : α) = 1 
goal: ⊥ = 1

full_name: bot_eq_zero
code: @[to_additive]
theorem bot_eq_one : (⊥ : α) = 1 
goal: ⊥ = 0

full_name: add_eq_zero_iff
code: @[to_additive (attr := simp)]
theorem mul_eq_one_iff : a * b = 1 ↔ a = 1 ∧ b = 1 
goal: a + b = 0 ↔ a = 0 ∧ b = 0

full_name: mul_eq_one_iff
code: @[to_additive (attr := simp)]
theorem mul_eq_one_iff : a * b = 1 ↔ a = 1 ∧ b = 1 
goal: a * b = 1 ↔ a = 1 ∧ b = 1

full_name: le_one_iff_eq_one
code: @[to_additive (attr := simp)]
theorem le_one_iff_eq_one : a ≤ 1 ↔ a = 1 
goal: a ≤ 1 ↔ a = 1

full_name: nonpos_iff_eq_zero
code: @[to_additive (attr := simp)]
theorem le_one_iff_eq_one : a ≤ 1 ↔ a = 1 
goal: a ≤ 0 ↔ a = 0

full_name: pos_iff_ne_zero
code: @[to_additive]
theorem one_lt_iff_ne_one : 1 < a ↔ a ≠ 1 
goal: 0 < a ↔ a ≠ 0

full_name: one_lt_iff_ne_one
code: @[to_additive]
theorem one_lt_iff_ne_one : 1 < a ↔ a ≠ 1 
goal: 1 < a ↔ a ≠ 1

full_name: eq_zero_or_pos
code: @[to_additive]
theorem eq_one_or_one_lt (a : α) : a = 1 ∨ 1 < a 
goal: a = 0 ∨ 0 < a

full_name: eq_one_or_one_lt
code: @[to_additive]
theorem eq_one_or_one_lt (a : α) : a = 1 ∨ 1 < a 
goal: a = 1 ∨ 1 < a

full_name: add_pos_iff
code: @[to_additive (attr := simp) add_pos_iff]
theorem one_lt_mul_iff : 1 < a * b ↔ 1 < a ∨ 1 < b 
goal: 0 < a + b ↔ 0 < a ∨ 0 < b

full_name: one_lt_mul_iff
code: @[to_additive (attr := simp) add_pos_iff]
theorem one_lt_mul_iff : 1 < a * b ↔ 1 < a ∨ 1 < b 
goal: 1 < a * b ↔ 1 < a ∨ 1 < b

full_name: exists_pos_add_of_lt
code: @[to_additive]
theorem exists_one_lt_mul_of_lt (h : a < b) : ∃ (c : _) (_ : 1 < c), a * c = b 
goal: ∃ c x, a + c = b

full_name: exists_one_lt_mul_of_lt
code: @[to_additive]
theorem exists_one_lt_mul_of_lt (h : a < b) : ∃ (c : _) (_ : 1 < c), a * c = b 
goal: ∃ c x, a * c = b

full_name: le_add_left
code: @[to_additive]
theorem le_mul_left (h : a ≤ c) : a ≤ b * c 
goal: a ≤ b + c

full_name: le_mul_left
code: @[to_additive]
theorem le_mul_left (h : a ≤ c) : a ≤ b * c 
goal: a ≤ b * c

full_name: le_mul_right
code: @[to_additive]
theorem le_mul_right (h : a ≤ b) : a ≤ b * c 
goal: a ≤ b * c

full_name: le_add_right
code: @[to_additive]
theorem le_mul_right (h : a ≤ b) : a ≤ b * c 
goal: a ≤ b + c

full_name: lt_iff_exists_mul
code: @[to_additive]
theorem lt_iff_exists_mul [CovariantClass α α (· * ·) (· < ·)] : a < b ↔ ∃ c > 1, b = a * c 
goal: a < b ↔ ∃ c, c > 1 ∧ b = a * c

full_name: lt_iff_exists_add
code: @[to_additive]
theorem lt_iff_exists_mul [CovariantClass α α (· * ·) (· < ·)] : a < b ↔ ∃ c > 1, b = a * c 
goal: a < b ↔ ∃ c, c > 0 ∧ b = a + c

full_name: pos_of_gt
code: theorem pos_of_gt {M : Type*} [CanonicallyOrderedAddCommMonoid M] {n m : M} (h : n < m) : 0 < m 
goal: 0 < m

full_name: NeZero.pos
code: theorem pos {M} (a : M) [CanonicallyOrderedAddCommMonoid M] [NeZero a] : 0 < a 
goal: 0 < a

full_name: NeZero.of_gt
code: theorem of_gt {M} [CanonicallyOrderedAddCommMonoid M] {x y : M} (h : x < y) : NeZero y 
goal: NeZero y

full_name: NeZero.of_gt'
code: instance (priority := 10) of_gt' {M : Type*} [CanonicallyOrderedAddCommMonoid M] [One M] {y : M}
  -- Porting note: Fact.out has different type signature from mathlib3
  [Fact (1 < y)] : NeZero y 
goal: NeZero y

full_name: CanonicallyLinearOrderedAddCommMonoid
code: /-- A canonically linear-ordered additive monoid is a canonically ordered additive monoid
    whose ordering is a linear order. -/
class CanonicallyLinearOrderedAddCommMonoid (α : Type*)
  extends CanonicallyOrderedAddCommMonoid α, LinearOrderedAddCommMonoid α
goal: Type u_1

full_name: CanonicallyLinearOrderedCommMonoid
code: /-- A canonically linear-ordered monoid is a canonically ordered monoid
    whose ordering is a linear order. -/
@[to_additive]
class CanonicallyLinearOrderedCommMonoid (α : Type*)
  extends CanonicallyOrderedCommMonoid α, LinearOrderedCommMonoid α
goal: Type u_1

full_name: CanonicallyLinearOrderedAddCommMonoid.semilatticeSup
code: @[to_additive]
instance (priority := 100) CanonicallyLinearOrderedCommMonoid.semilatticeSup : SemilatticeSup α 
goal: SemilatticeSup α

full_name: CanonicallyLinearOrderedCommMonoid.semilatticeSup
code: @[to_additive]
instance (priority := 100) CanonicallyLinearOrderedCommMonoid.semilatticeSup : SemilatticeSup α 
goal: SemilatticeSup α

full_name: min_add_distrib
code: @[to_additive]
theorem min_mul_distrib (a b c : α) : min a (b * c) = min a (min a b * min a c) 
goal: min a (b + c) = min a (min a b + min a c)

full_name: min_mul_distrib
code: @[to_additive]
theorem min_mul_distrib (a b c : α) : min a (b * c) = min a (min a b * min a c) 
goal: min a (b * c) = min a (min a b * min a c)

full_name: min_add_distrib'
code: @[to_additive]
theorem min_mul_distrib' (a b c : α) : min (a * b) c = min (min a c * min b c) c 
goal: min (a + b) c = min (min a c + min b c) c

full_name: min_mul_distrib'
code: @[to_additive]
theorem min_mul_distrib' (a b c : α) : min (a * b) c = min (min a c * min b c) c 
goal: min (a * b) c = min (min a c * min b c) c

full_name: zero_min
code: @[to_additive]
theorem one_min (a : α) : min 1 a = 1 
goal: min 0 a = 0

full_name: one_min
code: @[to_additive]
theorem one_min (a : α) : min 1 a = 1 
goal: min 1 a = 1

full_name: min_one
code: @[to_additive]
theorem min_one (a : α) : min a 1 = 1 
goal: min a 1 = 1

full_name: min_zero
code: @[to_additive]
theorem min_one (a : α) : min a 1 = 1 
goal: min a 0 = 0

full_name: bot_eq_one'
code: /-- In a linearly ordered monoid, we are happy for `bot_eq_one` to be a `@[simp]` lemma. -/
@[to_additive (attr := simp)
  "In a linearly ordered monoid, we are happy for `bot_eq_zero` to be a `@[simp]` lemma"]
theorem bot_eq_one' : (⊥ : α) = 1 
goal: ⊥ = 1

full_name: bot_eq_zero'
code: /-- In a linearly ordered monoid, we are happy for `bot_eq_one` to be a `@[simp]` lemma. -/
@[to_additive (attr := simp)
  "In a linearly ordered monoid, we are happy for `bot_eq_zero` to be a `@[simp]` lemma"]
theorem bot_eq_one' : (⊥ : α) = 1 
goal: ⊥ = 0