File: Mathlib/Algebra/Order/Ring/Basic.lean

full_name: MonoidHom.map_neg_one
code: theorem map_neg_one : f (-1) = 1 
goal: f (-1) = 1

full_name: MonoidHom.map_neg
code: @[simp]
theorem map_neg (x : R) : f (-x) = f x 
goal: f (-x) = f x

full_name: MonoidHom.map_sub_swap
code: theorem map_sub_swap (x y : R) : f (x - y) = f (y - x) 
goal: f (x - y) = f (y - x)

full_name: zero_pow_le_one
code: theorem zero_pow_le_one : ∀ n : ℕ, (0 : R) ^ n ≤ 1
  
goal: 0 ^ n ≤ 1

full_name: pow_add_pow_le
code: theorem pow_add_pow_le (hx : 0 ≤ x) (hy : 0 ≤ y) (hn : n ≠ 0) : x ^ n + y ^ n ≤ (x + y) ^ n 
goal: x ^ n + y ^ n ≤ (x + y) ^ n

full_name: pow_le_one
code: theorem pow_le_one : ∀ n : ℕ, 0 ≤ a → a ≤ 1 → a ^ n ≤ 1
  
goal: 0 ≤ a → a ≤ 1 → a ^ n ≤ 1

full_name: pow_lt_one
code: theorem pow_lt_one (h₀ : 0 ≤ a) (h₁ : a < 1) : ∀ {n : ℕ}, n ≠ 0 → a ^ n < 1
  
goal: n ≠ 0 → a ^ n < 1

full_name: one_le_pow_of_one_le
code: theorem one_le_pow_of_one_le (H : 1 ≤ a) : ∀ n : ℕ, 1 ≤ a ^ n
  
goal: 1 ≤ a ^ n

full_name: pow_right_mono
code: theorem pow_right_mono (h : 1 ≤ a) : Monotone (a ^ ·) 
goal: Monotone fun x => a ^ x

full_name: pow_le_pow_right
code: @[gcongr]
theorem pow_le_pow_right (ha : 1 ≤ a) (h : n ≤ m) : a ^ n ≤ a ^ m 
goal: a ^ n ≤ a ^ m

full_name: le_self_pow
code: theorem le_self_pow (ha : 1 ≤ a) (h : m ≠ 0) : a ≤ a ^ m 
goal: a ≤ a ^ m

full_name: pow_le_pow_left
code: @[mono, gcongr]
theorem pow_le_pow_left {a b : R} (ha : 0 ≤ a) (hab : a ≤ b) : ∀ n, a ^ n ≤ b ^ n
  
goal: a ^ n ≤ b ^ n

full_name: one_lt_pow
code: theorem one_lt_pow (ha : 1 < a) : ∀ {n : ℕ} (_ : n ≠ 0), 1 < a ^ n
  
goal: n ≠ 0 → 1 < a ^ n

full_name: pow_add_pow_le'
code: lemma pow_add_pow_le' (ha : 0 ≤ a) (hb : 0 ≤ b) : a ^ n + b ^ n ≤ 2 * (a + b) ^ n 
goal: a ^ n + b ^ n ≤ 2 * (a + b) ^ n

full_name: pow_lt_pow_left
code: @[gcongr]
theorem pow_lt_pow_left (h : x < y) (hx : 0 ≤ x) : ∀ {n : ℕ}, n ≠ 0 → x ^ n < y ^ n
  
goal: n ≠ 0 → x ^ n < y ^ n

full_name: pow_left_strictMonoOn
code: /-- See also `pow_left_strictMono` and `Nat.pow_left_strictMono`. -/
lemma pow_left_strictMonoOn (hn : n ≠ 0) : StrictMonoOn (· ^ n : R → R) {a | 0 ≤ a} 
goal: StrictMonoOn (fun x => x ^ n) {a | 0 ≤ a}

full_name: pow_right_strictMono
code: /-- See also `pow_right_strictMono'`. -/
lemma pow_right_strictMono (h : 1 < a) : StrictMono (a ^ ·) 
goal: StrictMono fun x => a ^ x

full_name: pow_lt_pow_right
code: @[gcongr]
theorem pow_lt_pow_right (h : 1 < a) (hmn : m < n) : a ^ m < a ^ n 
goal: a ^ m < a ^ n

full_name: pow_lt_pow_iff_right
code: lemma pow_lt_pow_iff_right (h : 1 < a) : a ^ n < a ^ m ↔ n < m 
goal: a ^ n < a ^ m ↔ n < m

full_name: pow_le_pow_iff_right
code: lemma pow_le_pow_iff_right (h : 1 < a) : a ^ n ≤ a ^ m ↔ n ≤ m 
goal: a ^ n ≤ a ^ m ↔ n ≤ m

full_name: lt_self_pow
code: theorem lt_self_pow (h : 1 < a) (hm : 1 < m) : a < a ^ m 
goal: a < a ^ m

full_name: pow_right_strictAnti
code: theorem pow_right_strictAnti (h₀ : 0 < a) (h₁ : a < 1) : StrictAnti (a ^ ·) 
goal: StrictAnti fun x => a ^ x

full_name: pow_lt_pow_iff_right_of_lt_one
code: theorem pow_lt_pow_iff_right_of_lt_one (h₀ : 0 < a) (h₁ : a < 1) : a ^ m < a ^ n ↔ n < m 
goal: a ^ m < a ^ n ↔ n < m

full_name: pow_lt_pow_right_of_lt_one
code: theorem pow_lt_pow_right_of_lt_one (h₀ : 0 < a) (h₁ : a < 1) (hmn : m < n) : a ^ n < a ^ m 
goal: a ^ n < a ^ m

full_name: pow_lt_self_of_lt_one
code: theorem pow_lt_self_of_lt_one (h₀ : 0 < a) (h₁ : a < 1) (hn : 1 < n) : a ^ n < a 
goal: a ^ n < a

full_name: sq_pos_of_pos
code: theorem sq_pos_of_pos (ha : 0 < a) : 0 < a ^ 2 
goal: 0 < a ^ 2

full_name: sq_pos_of_neg
code: lemma sq_pos_of_neg (ha : a < 0) : 0 < a ^ 2 
goal: 0 < a ^ 2

full_name: pow_le_pow_iff_left
code: lemma pow_le_pow_iff_left (ha : 0 ≤ a) (hb : 0 ≤ b) (hn : n ≠ 0) : a ^ n ≤ b ^ n ↔ a ≤ b 
goal: a ^ n ≤ b ^ n ↔ a ≤ b

full_name: pow_lt_pow_iff_left
code: lemma pow_lt_pow_iff_left (ha : 0 ≤ a) (hb : 0 ≤ b) (hn : n ≠ 0) : a ^ n < b ^ n ↔ a < b 
goal: a ^ n < b ^ n ↔ a < b

full_name: pow_left_inj
code: @[simp]
lemma pow_left_inj (ha : 0 ≤ a) (hb : 0 ≤ b) (hn : n ≠ 0) : a ^ n = b ^ n ↔ a = b 
goal: a ^ n = b ^ n ↔ a = b

full_name: pow_right_injective
code: lemma pow_right_injective (ha₀ : 0 < a) (ha₁ : a ≠ 1) : Injective (a ^ ·) 
goal: Function.Injective fun x => a ^ x

full_name: pow_right_inj
code: @[simp]
lemma pow_right_inj (ha₀ : 0 < a) (ha₁ : a ≠ 1) : a ^ m = a ^ n ↔ m = n 
goal: a ^ m = a ^ n ↔ m = n

full_name: pow_le_one_iff_of_nonneg
code: theorem pow_le_one_iff_of_nonneg (ha : 0 ≤ a) (hn : n ≠ 0) : a ^ n ≤ 1 ↔ a ≤ 1 
goal: a ^ n ≤ 1 ↔ a ≤ 1

full_name: one_le_pow_iff_of_nonneg
code: theorem one_le_pow_iff_of_nonneg (ha : 0 ≤ a) (hn : n ≠ 0) : 1 ≤ a ^ n ↔ 1 ≤ a 
goal: 1 ≤ a ^ n ↔ 1 ≤ a

full_name: pow_lt_one_iff_of_nonneg
code: theorem pow_lt_one_iff_of_nonneg (ha : 0 ≤ a) (hn : n ≠ 0) : a ^ n < 1 ↔ a < 1 
goal: a ^ n < 1 ↔ a < 1

full_name: one_lt_pow_iff_of_nonneg
code: theorem one_lt_pow_iff_of_nonneg (ha : 0 ≤ a) (hn : n ≠ 0) : 1 < a ^ n ↔ 1 < a 
goal: 1 < a ^ n ↔ 1 < a

full_name: pow_eq_one_iff_of_nonneg
code: lemma pow_eq_one_iff_of_nonneg (ha : 0 ≤ a) (hn : n ≠ 0) : a ^ n = 1 ↔ a = 1 
goal: a ^ n = 1 ↔ a = 1

full_name: sq_le_one_iff
code: theorem sq_le_one_iff {a : R} (ha : 0 ≤ a) : a ^ 2 ≤ 1 ↔ a ≤ 1 
goal: a ^ 2 ≤ 1 ↔ a ≤ 1

full_name: sq_lt_one_iff
code: theorem sq_lt_one_iff {a : R} (ha : 0 ≤ a) : a ^ 2 < 1 ↔ a < 1 
goal: a ^ 2 < 1 ↔ a < 1

full_name: one_le_sq_iff
code: theorem one_le_sq_iff {a : R} (ha : 0 ≤ a) : 1 ≤ a ^ 2 ↔ 1 ≤ a 
goal: 1 ≤ a ^ 2 ↔ 1 ≤ a

full_name: one_lt_sq_iff
code: theorem one_lt_sq_iff {a : R} (ha : 0 ≤ a) : 1 < a ^ 2 ↔ 1 < a 
goal: 1 < a ^ 2 ↔ 1 < a

full_name: lt_of_pow_lt_pow_left
code: theorem lt_of_pow_lt_pow_left (n : ℕ) (hb : 0 ≤ b) (h : a ^ n < b ^ n) : a < b 
goal: a < b

full_name: le_of_pow_le_pow_left
code: theorem le_of_pow_le_pow_left (hn : n ≠ 0) (hb : 0 ≤ b) (h : a ^ n ≤ b ^ n) : a ≤ b 
goal: a ≤ b

full_name: sq_eq_sq
code: @[simp]
theorem sq_eq_sq {a b : R} (ha : 0 ≤ a) (hb : 0 ≤ b) : a ^ 2 = b ^ 2 ↔ a = b 
goal: a ^ 2 = b ^ 2 ↔ a = b

full_name: lt_of_mul_self_lt_mul_self
code: theorem lt_of_mul_self_lt_mul_self (hb : 0 ≤ b) : a * a < b * b → a < b 
goal: a * a < b * b → a < b

full_name: add_sq_le
code: lemma add_sq_le : (a + b) ^ 2 ≤ 2 * (a ^ 2 + b ^ 2) 
goal: (a + b) ^ 2 ≤ 2 * (a ^ 2 + b ^ 2)

full_name: add_pow_le
code: lemma add_pow_le (ha : 0 ≤ a) (hb : 0 ≤ b) : ∀ n, (a + b) ^ n ≤ 2 ^ (n - 1) * (a ^ n + b ^ n)
  
goal: (a + b) ^ n ≤ 2 ^ (n - 1) * (a ^ n + b ^ n)

full_name: Even.add_pow_le
code: protected lemma Even.add_pow_le (hn : Even n) :
    (a + b) ^ n ≤ 2 ^ (n - 1) * (a ^ n + b ^ n) 
goal: (a + b) ^ n ≤ 2 ^ (n - 1) * (a ^ n + b ^ n)

full_name: Even.pow_nonneg
code: lemma Even.pow_nonneg (hn : Even n) (a : R) : 0 ≤ a ^ n 
goal: 0 ≤ a ^ n

full_name: Even.pow_pos
code: lemma Even.pow_pos (hn : Even n) (ha : a ≠ 0) : 0 < a ^ n 
goal: 0 < a ^ n

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

full_name: Odd.pow_neg_iff
code: lemma Odd.pow_neg_iff (hn : Odd n) : a ^ n < 0 ↔ a < 0 
goal: a ^ n < 0 ↔ a < 0

full_name: Odd.pow_nonneg_iff
code: lemma Odd.pow_nonneg_iff (hn : Odd n) : 0 ≤ a ^ n ↔ 0 ≤ a 
goal: 0 ≤ a ^ n ↔ 0 ≤ a

full_name: Odd.pow_nonpos_iff
code: lemma Odd.pow_nonpos_iff (hn : Odd n) : a ^ n ≤ 0 ↔ a ≤ 0 
goal: a ^ n ≤ 0 ↔ a ≤ 0

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

full_name: Odd.strictMono_pow
code: lemma Odd.strictMono_pow (hn : Odd n) : StrictMono fun a : R => a ^ n 
goal: StrictMono fun a => a ^ n

full_name: sq_pos_iff
code: lemma sq_pos_iff {a : R} : 0 < a ^ 2 ↔ a ≠ 0 
goal: 0 < a ^ 2 ↔ a ≠ 0

full_name: pow_four_le_pow_two_of_pow_two_le
code: lemma pow_four_le_pow_two_of_pow_two_le (h : a ^ 2 ≤ b) : a ^ 4 ≤ b ^ 2 
goal: a ^ 4 ≤ b ^ 2