File: Mathlib/Algebra/Order/Field/Power.lean

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

full_name: zpow_le_one_of_nonpos
code: theorem zpow_le_one_of_nonpos (ha : 1 ≤ a) (hn : n ≤ 0) : a ^ n ≤ 1 
goal: a ^ n ≤ 1

full_name: one_le_zpow_of_nonneg
code: theorem one_le_zpow_of_nonneg (ha : 1 ≤ a) (hn : 0 ≤ n) : 1 ≤ a ^ n 
goal: 1 ≤ a ^ n

full_name: Nat.zpow_pos_of_pos
code: protected theorem Nat.zpow_pos_of_pos {a : ℕ} (h : 0 < a) (n : ℤ) : 0 < (a : α) ^ n 
goal: 0 < ↑a ^ n

full_name: Nat.zpow_ne_zero_of_pos
code: theorem Nat.zpow_ne_zero_of_pos {a : ℕ} (h : 0 < a) (n : ℤ) : (a : α) ^ n ≠ 0 
goal: ↑a ^ n ≠ 0

full_name: one_lt_zpow
code: theorem one_lt_zpow (ha : 1 < a) : ∀ n : ℤ, 0 < n → 1 < a ^ n
  
goal: 0 < n → 1 < a ^ n

full_name: zpow_strictMono
code: theorem zpow_strictMono (hx : 1 < a) : StrictMono (a ^ · : ℤ → α) 
goal: StrictMono fun x => a ^ x

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

full_name: zpow_lt_iff_lt
code: @[simp]
theorem zpow_lt_iff_lt (hx : 1 < a) : a ^ m < a ^ n ↔ m < n 
goal: a ^ m < a ^ n ↔ m < n

full_name: zpow_le_iff_le
code: @[simp]
theorem zpow_le_iff_le (hx : 1 < a) : a ^ m ≤ a ^ n ↔ m ≤ n 
goal: a ^ m ≤ a ^ n ↔ m ≤ n

full_name: div_pow_le
code: @[simp]
theorem div_pow_le (ha : 0 ≤ a) (hb : 1 ≤ b) (k : ℕ) : a / b ^ k ≤ a 
goal: a / b ^ k ≤ a

full_name: zpow_injective
code: theorem zpow_injective (h₀ : 0 < a) (h₁ : a ≠ 1) : Injective (a ^ · : ℤ → α) 
goal: Function.Injective fun x => a ^ x

full_name: zpow_inj
code: @[simp]
theorem zpow_inj (h₀ : 0 < a) (h₁ : a ≠ 1) : a ^ m = a ^ n ↔ m = n 
goal: a ^ m = a ^ n ↔ m = n

full_name: zpow_le_max_of_min_le
code: theorem zpow_le_max_of_min_le {x : α} (hx : 1 ≤ x) {a b c : ℤ} (h : min a b ≤ c) :
    x ^ (-c) ≤ max (x ^ (-a)) (x ^ (-b)) 
goal: x ^ (-c) ≤ max (x ^ (-a)) (x ^ (-b))

full_name: zpow_le_max_iff_min_le
code: theorem zpow_le_max_iff_min_le {x : α} (hx : 1 < x) {a b c : ℤ} :
    x ^ (-c) ≤ max (x ^ (-a)) (x ^ (-b)) ↔ min a b ≤ c 
goal: x ^ (-c) ≤ max (x ^ (-a)) (x ^ (-b)) ↔ min a b ≤ c

full_name: Even.zpow_nonneg
code: protected theorem Even.zpow_nonneg (hn : Even n) (a : α) : 0 ≤ a ^ n 
goal: 0 ≤ a ^ n

full_name: zpow_two_nonneg
code: lemma zpow_two_nonneg (a : α) : 0 ≤ a ^ (2 : ℤ) 
goal: 0 ≤ a ^ 2

full_name: zpow_neg_two_nonneg
code: lemma zpow_neg_two_nonneg (a : α) : 0 ≤ a ^ (-2 : ℤ) 
goal: 0 ≤ a ^ (-2)

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

full_name: zpow_two_pos_of_ne_zero
code: lemma zpow_two_pos_of_ne_zero (ha : a ≠ 0) : 0 < a ^ (2 : ℤ) 
goal: 0 < a ^ 2

full_name: Even.zpow_pos_iff
code: theorem Even.zpow_pos_iff (hn : Even n) (h : n ≠ 0) : 0 < a ^ n ↔ a ≠ 0 
goal: 0 < a ^ n ↔ a ≠ 0

full_name: Odd.zpow_neg_iff
code: theorem Odd.zpow_neg_iff (hn : Odd n) : a ^ n < 0 ↔ a < 0 
goal: a ^ n < 0 ↔ a < 0

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

full_name: Odd.zpow_nonpos_iff
code: theorem Odd.zpow_nonpos_iff (hn : Odd n) : a ^ n ≤ 0 ↔ a ≤ 0 
goal: a ^ n ≤ 0 ↔ a ≤ 0

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

full_name: Even.zpow_abs
code: theorem Even.zpow_abs {p : ℤ} (hp : Even p) (a : α) : |a| ^ p = a ^ p 
goal: |a| ^ p = a ^ p

full_name: Nat.cast_le_pow_sub_div_sub
code: /-- Bernoulli's inequality reformulated to estimate `(n : α)`. -/
theorem Nat.cast_le_pow_sub_div_sub (H : 1 < a) (n : ℕ) : (n : α) ≤ (a ^ n - 1) / (a - 1) 
goal: ↑n ≤ (a ^ n - 1) / (a - 1)

full_name: Nat.cast_le_pow_div_sub
code: /-- For any `a > 1` and a natural `n` we have `n ≤ a ^ n / (a - 1)`. See also
`Nat.cast_le_pow_sub_div_sub` for a stronger inequality with `a ^ n - 1` in the numerator. -/
theorem Nat.cast_le_pow_div_sub (H : 1 < a) (n : ℕ) : (n : α) ≤ a ^ n / (a - 1) 
goal: ↑n ≤ a ^ n / (a - 1)

full_name: Mathlib.Meta.Positivity.evalZPow
code: /-- The `positivity` extension which identifies expressions of the form `a ^ (b : ℤ)`,
such that `positivity` successfully recognises both `a` and `b`. -/
@[positivity _ ^ (_ : ℤ), Pow.pow _ (_ : ℤ)]
def evalZPow : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt