File: Mathlib/Algebra/Order/Group/Abs.lean

full_name: abs_nsmul
code: @[to_additive] lemma mabs_pow (n : ℕ) (a : α) : |a ^ n|ₘ = |a|ₘ ^ n 
goal: |n • a| = n • |a|

full_name: mabs_pow
code: @[to_additive] lemma mabs_pow (n : ℕ) (a : α) : |a ^ n|ₘ = |a|ₘ ^ n 
goal: mabs (a ^ n) = mabs a ^ n

full_name: _private.Mathlib.Algebra.Order.Group.Abs.0.abs_add_eq_add_abs_le
code: @[to_additive] private lemma mabs_mul_eq_mul_mabs_le (hab : a ≤ b) :
    |a * b|ₘ = |a|ₘ * |b|ₘ ↔ 1 ≤ a ∧ 1 ≤ b ∨ a ≤ 1 ∧ b ≤ 1 
goal: |a + b| = |a| + |b| ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0

full_name: _private.Mathlib.Algebra.Order.Group.Abs.0.mabs_mul_eq_mul_mabs_le
code: @[to_additive] private lemma mabs_mul_eq_mul_mabs_le (hab : a ≤ b) :
    |a * b|ₘ = |a|ₘ * |b|ₘ ↔ 1 ≤ a ∧ 1 ≤ b ∨ a ≤ 1 ∧ b ≤ 1 
goal: mabs (a * b) = mabs a * mabs b ↔ 1 ≤ a ∧ 1 ≤ b ∨ a ≤ 1 ∧ b ≤ 1

full_name: mabs_mul_eq_mul_mabs_iff
code: @[to_additive] lemma mabs_mul_eq_mul_mabs_iff (a b : α) :
    |a * b|ₘ = |a|ₘ * |b|ₘ ↔ 1 ≤ a ∧ 1 ≤ b ∨ a ≤ 1 ∧ b ≤ 1 
goal: mabs (a * b) = mabs a * mabs b ↔ 1 ≤ a ∧ 1 ≤ b ∨ a ≤ 1 ∧ b ≤ 1

full_name: abs_add_eq_add_abs_iff
code: @[to_additive] lemma mabs_mul_eq_mul_mabs_iff (a b : α) :
    |a * b|ₘ = |a|ₘ * |b|ₘ ↔ 1 ≤ a ∧ 1 ≤ b ∨ a ≤ 1 ∧ b ≤ 1 
goal: |a + b| = |a| + |b| ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0

full_name: abs_le
code: theorem abs_le : |a| ≤ b ↔ -b ≤ a ∧ a ≤ b 
goal: |a| ≤ b ↔ -b ≤ a ∧ a ≤ b

full_name: le_abs'
code: theorem le_abs' : a ≤ |b| ↔ b ≤ -a ∨ a ≤ b 
goal: a ≤ |b| ↔ b ≤ -a ∨ a ≤ b

full_name: neg_le_of_abs_le
code: theorem neg_le_of_abs_le (h : |a| ≤ b) : -b ≤ a 
goal: -b ≤ a

full_name: le_of_abs_le
code: theorem le_of_abs_le (h : |a| ≤ b) : a ≤ b 
goal: a ≤ b

full_name: apply_abs_le_mul_of_one_le'
code: @[to_additive]
theorem apply_abs_le_mul_of_one_le' {β : Type*} [MulOneClass β] [Preorder β]
    [CovariantClass β β (· * ·) (· ≤ ·)] [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {f : α → β}
    {a : α} (h₁ : 1 ≤ f a) (h₂ : 1 ≤ f (-a)) : f |a| ≤ f a * f (-a) 
goal: f |a| ≤ f a * f (-a)

full_name: apply_abs_le_add_of_nonneg'
code: @[to_additive]
theorem apply_abs_le_mul_of_one_le' {β : Type*} [MulOneClass β] [Preorder β]
    [CovariantClass β β (· * ·) (· ≤ ·)] [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {f : α → β}
    {a : α} (h₁ : 1 ≤ f a) (h₂ : 1 ≤ f (-a)) : f |a| ≤ f a * f (-a) 
goal: f |a| ≤ f a + f (-a)

full_name: apply_abs_le_mul_of_one_le
code: @[to_additive]
theorem apply_abs_le_mul_of_one_le {β : Type*} [MulOneClass β] [Preorder β]
    [CovariantClass β β (· * ·) (· ≤ ·)] [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {f : α → β}
    (h : ∀ x, 1 ≤ f x) (a : α) : f |a| ≤ f a * f (-a) 
goal: f |a| ≤ f a * f (-a)

full_name: apply_abs_le_add_of_nonneg
code: @[to_additive]
theorem apply_abs_le_mul_of_one_le {β : Type*} [MulOneClass β] [Preorder β]
    [CovariantClass β β (· * ·) (· ≤ ·)] [CovariantClass β β (swap (· * ·)) (· ≤ ·)] {f : α → β}
    (h : ∀ x, 1 ≤ f x) (a : α) : f |a| ≤ f a * f (-a) 
goal: f |a| ≤ f a + f (-a)

full_name: abs_add
code: /-- The **triangle inequality** in `LinearOrderedAddCommGroup`s. -/
theorem abs_add (a b : α) : |a + b| ≤ |a| + |b| 
goal: |a + b| ≤ |a| + |b|

full_name: abs_add'
code: theorem abs_add' (a b : α) : |a| ≤ |b| + |b + a| 
goal: |a| ≤ |b| + |b + a|

full_name: abs_sub
code: theorem abs_sub (a b : α) : |a - b| ≤ |a| + |b| 
goal: |a - b| ≤ |a| + |b|

full_name: abs_sub_le_iff
code: theorem abs_sub_le_iff : |a - b| ≤ c ↔ a - b ≤ c ∧ b - a ≤ c 
goal: |a - b| ≤ c ↔ a - b ≤ c ∧ b - a ≤ c

full_name: abs_sub_lt_iff
code: theorem abs_sub_lt_iff : |a - b| < c ↔ a - b < c ∧ b - a < c 
goal: |a - b| < c ↔ a - b < c ∧ b - a < c

full_name: sub_le_of_abs_sub_le_left
code: theorem sub_le_of_abs_sub_le_left (h : |a - b| ≤ c) : b - c ≤ a 
goal: b - c ≤ a

full_name: sub_le_of_abs_sub_le_right
code: theorem sub_le_of_abs_sub_le_right (h : |a - b| ≤ c) : a - c ≤ b 
goal: a - c ≤ b

full_name: sub_lt_of_abs_sub_lt_left
code: theorem sub_lt_of_abs_sub_lt_left (h : |a - b| < c) : b - c < a 
goal: b - c < a

full_name: sub_lt_of_abs_sub_lt_right
code: theorem sub_lt_of_abs_sub_lt_right (h : |a - b| < c) : a - c < b 
goal: a - c < b

full_name: abs_sub_abs_le_abs_sub
code: theorem abs_sub_abs_le_abs_sub (a b : α) : |a| - |b| ≤ |a - b| 
goal: |a| - |b| ≤ |a - b|

full_name: abs_abs_sub_abs_le_abs_sub
code: theorem abs_abs_sub_abs_le_abs_sub (a b : α) : |(|a| - |b|)| ≤ |a - b| 
goal: ||a| - |b|| ≤ |a - b|

full_name: abs_sub_le_of_nonneg_of_le
code: /-- `|a - b| ≤ n` if `0 ≤ a ≤ n` and `0 ≤ b ≤ n`. -/
theorem abs_sub_le_of_nonneg_of_le {a b n : α} (a_nonneg : 0 ≤ a) (a_le_n : a ≤ n)
    (b_nonneg : 0 ≤ b) (b_le_n : b ≤ n) : |a - b| ≤ n 
goal: |a - b| ≤ n

full_name: abs_sub_lt_of_nonneg_of_lt
code: /-- `|a - b| < n` if `0 ≤ a < n` and `0 ≤ b < n`. -/
theorem abs_sub_lt_of_nonneg_of_lt {a b n : α} (a_nonneg : 0 ≤ a) (a_lt_n : a < n)
    (b_nonneg : 0 ≤ b) (b_lt_n : b < n) : |a - b| < n 
goal: |a - b| < n

full_name: abs_eq
code: theorem abs_eq (hb : 0 ≤ b) : |a| = b ↔ a = b ∨ a = -b 
goal: |a| = b ↔ a = b ∨ a = -b

full_name: abs_le_max_abs_abs
code: theorem abs_le_max_abs_abs (hab : a ≤ b) (hbc : b ≤ c) : |b| ≤ max |a| |c| 
goal: |b| ≤ max |a| |c|

full_name: min_abs_abs_le_abs_max
code: theorem min_abs_abs_le_abs_max : min |a| |b| ≤ |max a b| 
goal: min |a| |b| ≤ |max a b|

full_name: min_abs_abs_le_abs_min
code: theorem min_abs_abs_le_abs_min : min |a| |b| ≤ |min a b| 
goal: min |a| |b| ≤ |min a b|

full_name: abs_max_le_max_abs_abs
code: theorem abs_max_le_max_abs_abs : |max a b| ≤ max |a| |b| 
goal: |max a b| ≤ max |a| |b|

full_name: abs_min_le_max_abs_abs
code: theorem abs_min_le_max_abs_abs : |min a b| ≤ max |a| |b| 
goal: |min a b| ≤ max |a| |b|

full_name: eq_of_abs_sub_eq_zero
code: theorem eq_of_abs_sub_eq_zero {a b : α} (h : |a - b| = 0) : a = b 
goal: a = b

full_name: abs_sub_le
code: theorem abs_sub_le (a b c : α) : |a - c| ≤ |a - b| + |b - c| 
goal: |a - c| ≤ |a - b| + |b - c|

full_name: abs_add_three
code: theorem abs_add_three (a b c : α) : |a + b + c| ≤ |a| + |b| + |c| 
goal: |a + b + c| ≤ |a| + |b| + |c|

full_name: dist_bdd_within_interval
code: theorem dist_bdd_within_interval {a b lb ub : α} (hal : lb ≤ a) (hau : a ≤ ub) (hbl : lb ≤ b)
    (hbu : b ≤ ub) : |a - b| ≤ ub - lb 
goal: |a - b| ≤ ub - lb

full_name: eq_of_abs_sub_nonpos
code: theorem eq_of_abs_sub_nonpos (h : |a - b| ≤ 0) : a = b 
goal: a = b

full_name: abs_sub_nonpos
code: theorem abs_sub_nonpos : |a - b| ≤ 0 ↔ a = b 
goal: |a - b| ≤ 0 ↔ a = b

full_name: abs_sub_pos
code: theorem abs_sub_pos : 0 < |a - b| ↔ a ≠ b 
goal: 0 < |a - b| ↔ a ≠ b

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

full_name: abs_eq_neg_self
code: @[simp]
theorem abs_eq_neg_self : |a| = -a ↔ a ≤ 0 
goal: |a| = -a ↔ a ≤ 0

full_name: abs_cases
code: /-- For an element `a` of a linear ordered ring, either `abs a = a` and `0 ≤ a`,
    or `abs a = -a` and `a < 0`.
    Use cases on this lemma to automate linarith in inequalities -/
theorem abs_cases (a : α) : |a| = a ∧ 0 ≤ a ∨ |a| = -a ∧ a < 0 
goal: |a| = a ∧ 0 ≤ a ∨ |a| = -a ∧ a < 0

full_name: max_zero_add_max_neg_zero_eq_abs_self
code: @[simp]
theorem max_zero_add_max_neg_zero_eq_abs_self (a : α) : max a 0 + max (-a) 0 = |a| 
goal: max a 0 + max (-a) 0 = |a|