File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

full_name: Real.rpow
code: /-- The real power function `x ^ y`, defined as the real part of the complex power function.
For `x > 0`, it is equal to `exp (y log x)`. For `x = 0`, one sets `0 ^ 0=1` and `0 ^ y=0` for
`y ≠ 0`. For `x < 0`, the definition is somewhat arbitrary as it depends on the choice of a complex
determination of the logarithm. With our conventions, it is equal to `exp (y log x) cos (π y)`. -/
noncomputable def rpow (x y : ℝ) 
goal: ℝ

full_name: Real.instPow
code: noncomputable instance : Pow ℝ ℝ 
goal: Pow ℝ ℝ

full_name: Real.rpow_eq_pow
code: @[simp]
theorem rpow_eq_pow (x y : ℝ) : rpow x y = x ^ y 
goal: x.rpow y = x ^ y

full_name: Real.rpow_def
code: theorem rpow_def (x y : ℝ) : x ^ y = ((x : ℂ) ^ (y : ℂ)).re 
goal: x ^ y = (↑x ^ ↑y).re

full_name: Real.rpow_def_of_nonneg
code: theorem rpow_def_of_nonneg {x : ℝ} (hx : 0 ≤ x) (y : ℝ) :
    x ^ y = if x = 0 then if y = 0 then 1 else 0 else exp (log x * y) 
goal: x ^ y = if x = 0 then if y = 0 then 1 else 0 else rexp (Real.log x * y)

full_name: Real.rpow_def_of_pos
code: theorem rpow_def_of_pos {x : ℝ} (hx : 0 < x) (y : ℝ) : x ^ y = exp (log x * y) 
goal: x ^ y = rexp (Real.log x * y)

full_name: Real.exp_mul
code: theorem exp_mul (x y : ℝ) : exp (x * y) = exp x ^ y 
goal: rexp (x * y) = rexp x ^ y

full_name: Real.rpow_intCast
code: @[simp, norm_cast]
theorem rpow_intCast (x : ℝ) (n : ℤ) : x ^ (n : ℝ) = x ^ n 
goal: x ^ ↑n = x ^ n

full_name: Real.rpow_natCast
code: @[simp, norm_cast]
theorem rpow_natCast (x : ℝ) (n : ℕ) : x ^ (n : ℝ) = x ^ n 
goal: x ^ ↑n = x ^ n

full_name: Real.exp_one_rpow
code: @[simp]
theorem exp_one_rpow (x : ℝ) : exp 1 ^ x = exp x 
goal: rexp 1 ^ x = rexp x

full_name: Real.exp_one_pow
code: @[simp] lemma exp_one_pow (n : ℕ) : exp 1 ^ n = exp n 
goal: rexp 1 ^ n = rexp ↑n

full_name: Real.rpow_eq_zero_iff_of_nonneg
code: theorem rpow_eq_zero_iff_of_nonneg (hx : 0 ≤ x) : x ^ y = 0 ↔ x = 0 ∧ y ≠ 0 
goal: x ^ y = 0 ↔ x = 0 ∧ y ≠ 0

full_name: Real.rpow_eq_zero
code: @[simp]
lemma rpow_eq_zero (hx : 0 ≤ x) (hy : y ≠ 0) : x ^ y = 0 ↔ x = 0 
goal: x ^ y = 0 ↔ x = 0

full_name: Real.rpow_ne_zero
code: @[simp]
lemma rpow_ne_zero (hx : 0 ≤ x) (hy : y ≠ 0) : x ^ y ≠ 0 ↔ x ≠ 0 
goal: x ^ y ≠ 0 ↔ x ≠ 0

full_name: Real.rpow_def_of_neg
code: theorem rpow_def_of_neg {x : ℝ} (hx : x < 0) (y : ℝ) : x ^ y = exp (log x * y) * cos (y * π) 
goal: x ^ y = rexp (Real.log x * y) * Real.cos (y * π)

full_name: Real.rpow_def_of_nonpos
code: theorem rpow_def_of_nonpos {x : ℝ} (hx : x ≤ 0) (y : ℝ) :
    x ^ y = if x = 0 then if y = 0 then 1 else 0 else exp (log x * y) * cos (y * π) 
goal: x ^ y = if x = 0 then if y = 0 then 1 else 0 else rexp (Real.log x * y) * Real.cos (y * π)

full_name: Real.rpow_pos_of_pos
code: theorem rpow_pos_of_pos {x : ℝ} (hx : 0 < x) (y : ℝ) : 0 < x ^ y 
goal: 0 < x ^ y

full_name: Real.rpow_zero
code: @[simp]
theorem rpow_zero (x : ℝ) : x ^ (0 : ℝ) = 1 
goal: x ^ 0 = 1

full_name: Real.rpow_zero_pos
code: theorem rpow_zero_pos (x : ℝ) : 0 < x ^ (0 : ℝ) 
goal: 0 < x ^ 0

full_name: Real.zero_rpow
code: @[simp]
theorem zero_rpow {x : ℝ} (h : x ≠ 0) : (0 : ℝ) ^ x = 0 
goal: 0 ^ x = 0

full_name: Real.zero_rpow_eq_iff
code: theorem zero_rpow_eq_iff {x : ℝ} {a : ℝ} : 0 ^ x = a ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1 
goal: 0 ^ x = a ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

full_name: Real.eq_zero_rpow_iff
code: theorem eq_zero_rpow_iff {x : ℝ} {a : ℝ} : a = 0 ^ x ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1 
goal: a = 0 ^ x ↔ x ≠ 0 ∧ a = 0 ∨ x = 0 ∧ a = 1

full_name: Real.rpow_one
code: @[simp]
theorem rpow_one (x : ℝ) : x ^ (1 : ℝ) = x 
goal: x ^ 1 = x

full_name: Real.one_rpow
code: @[simp]
theorem one_rpow (x : ℝ) : (1 : ℝ) ^ x = 1 
goal: 1 ^ x = 1

full_name: Real.zero_rpow_le_one
code: theorem zero_rpow_le_one (x : ℝ) : (0 : ℝ) ^ x ≤ 1 
goal: 0 ^ x ≤ 1

full_name: Real.zero_rpow_nonneg
code: theorem zero_rpow_nonneg (x : ℝ) : 0 ≤ (0 : ℝ) ^ x 
goal: 0 ≤ 0 ^ x

full_name: Real.rpow_nonneg
code: theorem rpow_nonneg {x : ℝ} (hx : 0 ≤ x) (y : ℝ) : 0 ≤ x ^ y 
goal: 0 ≤ x ^ y

full_name: Real.abs_rpow_of_nonneg
code: theorem abs_rpow_of_nonneg {x y : ℝ} (hx_nonneg : 0 ≤ x) : |x ^ y| = |x| ^ y 
goal: |x ^ y| = |x| ^ y

full_name: Real.abs_rpow_le_abs_rpow
code: theorem abs_rpow_le_abs_rpow (x y : ℝ) : |x ^ y| ≤ |x| ^ y 
goal: |x ^ y| ≤ |x| ^ y

full_name: Real.abs_rpow_le_exp_log_mul
code: theorem abs_rpow_le_exp_log_mul (x y : ℝ) : |x ^ y| ≤ exp (log x * y) 
goal: |x ^ y| ≤ rexp (Real.log x * y)

full_name: Real.norm_rpow_of_nonneg
code: theorem norm_rpow_of_nonneg {x y : ℝ} (hx_nonneg : 0 ≤ x) : ‖x ^ y‖ = ‖x‖ ^ y 
goal: ‖x ^ y‖ = ‖x‖ ^ y

full_name: Real.rpow_add
code: theorem rpow_add (hx : 0 < x) (y z : ℝ) : x ^ (y + z) = x ^ y * x ^ z 
goal: x ^ (y + z) = x ^ y * x ^ z

full_name: Real.rpow_add'
code: theorem rpow_add' (hx : 0 ≤ x) (h : y + z ≠ 0) : x ^ (y + z) = x ^ y * x ^ z 
goal: x ^ (y + z) = x ^ y * x ^ z

full_name: Real.rpow_of_add_eq
code: /-- Variant of `Real.rpow_add'` that avoids having to prove `y + z = w` twice. -/
lemma rpow_of_add_eq (hx : 0 ≤ x) (hw : w ≠ 0) (h : y + z = w) : x ^ w = x ^ y * x ^ z 
goal: x ^ w = x ^ y * x ^ z

full_name: Real.rpow_add_of_nonneg
code: theorem rpow_add_of_nonneg (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 ≤ z) :
    x ^ (y + z) = x ^ y * x ^ z 
goal: x ^ (y + z) = x ^ y * x ^ z

full_name: Real.le_rpow_add
code: /-- For `0 ≤ x`, the only problematic case in the equality `x ^ y * x ^ z = x ^ (y + z)` is for
`x = 0` and `y + z = 0`, where the right hand side is `1` while the left hand side can vanish.
The inequality is always true, though, and given in this lemma. -/
theorem le_rpow_add {x : ℝ} (hx : 0 ≤ x) (y z : ℝ) : x ^ y * x ^ z ≤ x ^ (y + z) 
goal: x ^ y * x ^ z ≤ x ^ (y + z)

full_name: Real.rpow_sum_of_pos
code: theorem rpow_sum_of_pos {ι : Type*} {a : ℝ} (ha : 0 < a) (f : ι → ℝ) (s : Finset ι) :
    (a ^ ∑ x ∈ s, f x) = ∏ x ∈ s, a ^ f x 
goal: a ^ ∑ x ∈ s, f x = ∏ x ∈ s, a ^ f x

full_name: Real.rpow_sum_of_nonneg
code: theorem rpow_sum_of_nonneg {ι : Type*} {a : ℝ} (ha : 0 ≤ a) {s : Finset ι} {f : ι → ℝ}
    (h : ∀ x ∈ s, 0 ≤ f x) : (a ^ ∑ x ∈ s, f x) = ∏ x ∈ s, a ^ f x 
goal: a ^ ∑ x ∈ s, f x = ∏ x ∈ s, a ^ f x

full_name: Real.rpow_neg
code: theorem rpow_neg {x : ℝ} (hx : 0 ≤ x) (y : ℝ) : x ^ (-y) = (x ^ y)⁻¹ 
goal: x ^ (-y) = (x ^ y)⁻¹

full_name: Real.rpow_sub
code: theorem rpow_sub {x : ℝ} (hx : 0 < x) (y z : ℝ) : x ^ (y - z) = x ^ y / x ^ z 
goal: x ^ (y - z) = x ^ y / x ^ z

full_name: Real.rpow_sub'
code: theorem rpow_sub' {x : ℝ} (hx : 0 ≤ x) {y z : ℝ} (h : y - z ≠ 0) : x ^ (y - z) = x ^ y / x ^ z 
goal: x ^ (y - z) = x ^ y / x ^ z

full_name: HasCompactSupport.rpow_const
code: protected theorem _root_.HasCompactSupport.rpow_const {α : Type*} [TopologicalSpace α] {f : α → ℝ}
    (hf : HasCompactSupport f) {r : ℝ} (hr : r ≠ 0) : HasCompactSupport (fun x ↦ f x ^ r) 
goal: HasCompactSupport fun x => f x ^ r

full_name: Complex.ofReal_cpow
code: theorem ofReal_cpow {x : ℝ} (hx : 0 ≤ x) (y : ℝ) : ((x ^ y : ℝ) : ℂ) = (x : ℂ) ^ (y : ℂ) 
goal: ↑(x ^ y) = ↑x ^ ↑y

full_name: Complex.ofReal_cpow_of_nonpos
code: theorem ofReal_cpow_of_nonpos {x : ℝ} (hx : x ≤ 0) (y : ℂ) :
    (x : ℂ) ^ y = (-x : ℂ) ^ y * exp (π * I * y) 
goal: ↑x ^ y = (-↑x) ^ y * Complex.exp (↑π * Complex.I * y)

full_name: Complex.cpow_ofReal
code: lemma cpow_ofReal (x : ℂ) (y : ℝ) :
    x ^ (y : ℂ) = ↑(abs x ^ y) * (Real.cos (arg x * y) + Real.sin (arg x * y) * I) 
goal: x ^ ↑y = ↑(Complex.abs x ^ y) * (↑(Real.cos (x.arg * y)) + ↑(Real.sin (x.arg * y)) * Complex.I)

full_name: Complex.cpow_ofReal_re
code: lemma cpow_ofReal_re (x : ℂ) (y : ℝ) : (x ^ (y : ℂ)).re = (abs x) ^ y * Real.cos (arg x * y) 
goal: (x ^ ↑y).re = Complex.abs x ^ y * Real.cos (x.arg * y)

full_name: Complex.cpow_ofReal_im
code: lemma cpow_ofReal_im (x : ℂ) (y : ℝ) : (x ^ (y : ℂ)).im = (abs x) ^ y * Real.sin (arg x * y) 
goal: (x ^ ↑y).im = Complex.abs x ^ y * Real.sin (x.arg * y)

full_name: Complex.abs_cpow_of_ne_zero
code: theorem abs_cpow_of_ne_zero {z : ℂ} (hz : z ≠ 0) (w : ℂ) :
    abs (z ^ w) = abs z ^ w.re / Real.exp (arg z * im w) 
goal: Complex.abs (z ^ w) = Complex.abs z ^ w.re / rexp (z.arg * w.im)

full_name: Complex.abs_cpow_of_imp
code: theorem abs_cpow_of_imp {z w : ℂ} (h : z = 0 → w.re = 0 → w = 0) :
    abs (z ^ w) = abs z ^ w.re / Real.exp (arg z * im w) 
goal: Complex.abs (z ^ w) = Complex.abs z ^ w.re / rexp (z.arg * w.im)

full_name: Complex.abs_cpow_le
code: theorem abs_cpow_le (z w : ℂ) : abs (z ^ w) ≤ abs z ^ w.re / Real.exp (arg z * im w) 
goal: Complex.abs (z ^ w) ≤ Complex.abs z ^ w.re / rexp (z.arg * w.im)

full_name: Complex.abs_cpow_real
code: @[simp]
theorem abs_cpow_real (x : ℂ) (y : ℝ) : abs (x ^ (y : ℂ)) = Complex.abs x ^ y 
goal: Complex.abs (x ^ ↑y) = Complex.abs x ^ y

full_name: Complex.abs_cpow_inv_nat
code: @[simp]
theorem abs_cpow_inv_nat (x : ℂ) (n : ℕ) : abs (x ^ (n⁻¹ : ℂ)) = Complex.abs x ^ (n⁻¹ : ℝ) 
goal: Complex.abs (x ^ (↑n)⁻¹) = Complex.abs x ^ (↑n)⁻¹

full_name: Complex.abs_cpow_eq_rpow_re_of_pos
code: theorem abs_cpow_eq_rpow_re_of_pos {x : ℝ} (hx : 0 < x) (y : ℂ) : abs (x ^ y) = x ^ y.re 
goal: Complex.abs (↑x ^ y) = x ^ y.re

full_name: Complex.abs_cpow_eq_rpow_re_of_nonneg
code: theorem abs_cpow_eq_rpow_re_of_nonneg {x : ℝ} (hx : 0 ≤ x) {y : ℂ} (hy : re y ≠ 0) :
    abs (x ^ y) = x ^ re y 
goal: Complex.abs (↑x ^ y) = x ^ y.re

full_name: Complex.norm_natCast_cpow_of_re_ne_zero
code: lemma norm_natCast_cpow_of_re_ne_zero (n : ℕ) {s : ℂ} (hs : s.re ≠ 0) :
    ‖(n : ℂ) ^ s‖ = (n : ℝ) ^ (s.re) 
goal: ‖↑n ^ s‖ = ↑n ^ s.re

full_name: Complex.norm_natCast_cpow_of_pos
code: lemma norm_natCast_cpow_of_pos {n : ℕ} (hn : 0 < n) (s : ℂ) :
    ‖(n : ℂ) ^ s‖ = (n : ℝ) ^ (s.re) 
goal: ‖↑n ^ s‖ = ↑n ^ s.re

full_name: Complex.norm_natCast_cpow_pos_of_pos
code: lemma norm_natCast_cpow_pos_of_pos {n : ℕ} (hn : 0 < n) (s : ℂ) : 0 < ‖(n : ℂ) ^ s‖ 
goal: 0 < ‖↑n ^ s‖

full_name: Complex.cpow_mul_ofReal_nonneg
code: theorem cpow_mul_ofReal_nonneg {x : ℝ} (hx : 0 ≤ x) (y : ℝ) (z : ℂ) :
    (x : ℂ) ^ (↑y * z) = (↑(x ^ y) : ℂ) ^ z 
goal: ↑x ^ (↑y * z) = ↑(x ^ y) ^ z

full_name: Mathlib.Meta.Positivity.evalRpowZero
code: /-- Extension for the `positivity` tactic: exponentiation by a real number is positive (namely 1)
when the exponent is zero. The other cases are done in `evalRpow`. -/
@[positivity (_ : ℝ) ^ (0 : ℝ)]
def evalRpowZero : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalRpow
code: /-- Extension for the `positivity` tactic: exponentiation by a real number is nonnegative when
the base is nonnegative and positive when the base is positive. -/
@[positivity (_ : ℝ) ^ (_ : ℝ)]
def evalRpow : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Real.rpow_mul
code: theorem rpow_mul {x : ℝ} (hx : 0 ≤ x) (y z : ℝ) : x ^ (y * z) = (x ^ y) ^ z 
goal: x ^ (y * z) = (x ^ y) ^ z

full_name: Real.rpow_add_int
code: theorem rpow_add_int {x : ℝ} (hx : x ≠ 0) (y : ℝ) (n : ℤ) : x ^ (y + n) = x ^ y * x ^ n 
goal: x ^ (y + ↑n) = x ^ y * x ^ n

full_name: Real.rpow_add_nat
code: theorem rpow_add_nat {x : ℝ} (hx : x ≠ 0) (y : ℝ) (n : ℕ) : x ^ (y + n) = x ^ y * x ^ n 
goal: x ^ (y + ↑n) = x ^ y * x ^ n

full_name: Real.rpow_sub_int
code: theorem rpow_sub_int {x : ℝ} (hx : x ≠ 0) (y : ℝ) (n : ℕ) : x ^ (y - n) = x ^ y / x ^ n 
goal: x ^ (y - ↑n) = x ^ y / x ^ n

full_name: Real.rpow_sub_nat
code: theorem rpow_sub_nat {x : ℝ} (hx : x ≠ 0) (y : ℝ) (n : ℕ) : x ^ (y - n) = x ^ y / x ^ n 
goal: x ^ (y - ↑n) = x ^ y / x ^ n

full_name: Real.rpow_add_int'
code: lemma rpow_add_int' (hx : 0 ≤ x) {n : ℤ} (h : y + n ≠ 0) : x ^ (y + n) = x ^ y * x ^ n 
goal: x ^ (y + ↑n) = x ^ y * x ^ n

full_name: Real.rpow_add_nat'
code: lemma rpow_add_nat' (hx : 0 ≤ x) (h : y + n ≠ 0) : x ^ (y + n) = x ^ y * x ^ n 
goal: x ^ (y + ↑n) = x ^ y * x ^ n

full_name: Real.rpow_sub_int'
code: lemma rpow_sub_int' (hx : 0 ≤ x) {n : ℤ} (h : y - n ≠ 0) : x ^ (y - n) = x ^ y / x ^ n 
goal: x ^ (y - ↑n) = x ^ y / x ^ n

full_name: Real.rpow_sub_nat'
code: lemma rpow_sub_nat' (hx : 0 ≤ x) (h : y - n ≠ 0) : x ^ (y - n) = x ^ y / x ^ n 
goal: x ^ (y - ↑n) = x ^ y / x ^ n

full_name: Real.rpow_add_one
code: theorem rpow_add_one {x : ℝ} (hx : x ≠ 0) (y : ℝ) : x ^ (y + 1) = x ^ y * x 
goal: x ^ (y + 1) = x ^ y * x

full_name: Real.rpow_sub_one
code: theorem rpow_sub_one {x : ℝ} (hx : x ≠ 0) (y : ℝ) : x ^ (y - 1) = x ^ y / x 
goal: x ^ (y - 1) = x ^ y / x

full_name: Real.rpow_add_one'
code: lemma rpow_add_one' (hx : 0 ≤ x) (h : y + 1 ≠ 0) : x ^ (y + 1) = x ^ y * x 
goal: x ^ (y + 1) = x ^ y * x

full_name: Real.rpow_one_add'
code: lemma rpow_one_add' (hx : 0 ≤ x) (h : 1 + y ≠ 0) : x ^ (1 + y) = x * x ^ y 
goal: x ^ (1 + y) = x * x ^ y

full_name: Real.rpow_sub_one'
code: lemma rpow_sub_one' (hx : 0 ≤ x) (h : y - 1 ≠ 0) : x ^ (y - 1) = x ^ y / x 
goal: x ^ (y - 1) = x ^ y / x

full_name: Real.rpow_one_sub'
code: lemma rpow_one_sub' (hx : 0 ≤ x) (h : 1 - y ≠ 0) : x ^ (1 - y) = x / x ^ y 
goal: x ^ (1 - y) = x / x ^ y

full_name: Real.rpow_two
code: @[simp]
theorem rpow_two (x : ℝ) : x ^ (2 : ℝ) = x ^ 2 
goal: x ^ 2 = x ^ 2

full_name: Real.rpow_neg_one
code: theorem rpow_neg_one (x : ℝ) : x ^ (-1 : ℝ) = x⁻¹ 
goal: x ^ (-1) = x⁻¹

full_name: Real.mul_rpow
code: theorem mul_rpow (hx : 0 ≤ x) (hy : 0 ≤ y) : (x * y) ^ z = x ^ z * y ^ z 
goal: (x * y) ^ z = x ^ z * y ^ z

full_name: Real.inv_rpow
code: theorem inv_rpow (hx : 0 ≤ x) (y : ℝ) : x⁻¹ ^ y = (x ^ y)⁻¹ 
goal: x⁻¹ ^ y = (x ^ y)⁻¹

full_name: Real.div_rpow
code: theorem div_rpow (hx : 0 ≤ x) (hy : 0 ≤ y) (z : ℝ) : (x / y) ^ z = x ^ z / y ^ z 
goal: (x / y) ^ z = x ^ z / y ^ z

full_name: Real.log_rpow
code: theorem log_rpow {x : ℝ} (hx : 0 < x) (y : ℝ) : log (x ^ y) = y * log x 
goal: Real.log (x ^ y) = y * Real.log x

full_name: Real.mul_log_eq_log_iff
code: theorem mul_log_eq_log_iff {x y z : ℝ} (hx : 0 < x) (hz : 0 < z) :
    y * log x = log z ↔ x ^ y = z 
goal: y * Real.log x = Real.log z ↔ x ^ y = z

full_name: Real.rpow_rpow_inv
code: @[simp] lemma rpow_rpow_inv (hx : 0 ≤ x) (hy : y ≠ 0) : (x ^ y) ^ y⁻¹ = x 
goal: (x ^ y) ^ y⁻¹ = x

full_name: Real.rpow_inv_rpow
code: @[simp] lemma rpow_inv_rpow (hx : 0 ≤ x) (hy : y ≠ 0) : (x ^ y⁻¹) ^ y = x 
goal: (x ^ y⁻¹) ^ y = x

full_name: Real.pow_rpow_inv_natCast
code: theorem pow_rpow_inv_natCast (hx : 0 ≤ x) (hn : n ≠ 0) : (x ^ n) ^ (n⁻¹ : ℝ) = x 
goal: (x ^ n) ^ (↑n)⁻¹ = x

full_name: Real.rpow_inv_natCast_pow
code: theorem rpow_inv_natCast_pow (hx : 0 ≤ x) (hn : n ≠ 0) : (x ^ (n⁻¹ : ℝ)) ^ n = x 
goal: (x ^ (↑n)⁻¹) ^ n = x

full_name: Real.rpow_natCast_mul
code: lemma rpow_natCast_mul (hx : 0 ≤ x) (n : ℕ) (z : ℝ) : x ^ (n * z) = (x ^ n) ^ z 
goal: x ^ (↑n * z) = (x ^ n) ^ z

full_name: Real.rpow_mul_natCast
code: lemma rpow_mul_natCast (hx : 0 ≤ x) (y : ℝ) (n : ℕ) : x ^ (y * n) = (x ^ y) ^ n 
goal: x ^ (y * ↑n) = (x ^ y) ^ n

full_name: Real.rpow_intCast_mul
code: lemma rpow_intCast_mul (hx : 0 ≤ x) (n : ℤ) (z : ℝ) : x ^ (n * z) = (x ^ n) ^ z 
goal: x ^ (↑n * z) = (x ^ n) ^ z

full_name: Real.rpow_mul_intCast
code: lemma rpow_mul_intCast (hx : 0 ≤ x) (y : ℝ) (n : ℤ) : x ^ (y * n) = (x ^ y) ^ n 
goal: x ^ (y * ↑n) = (x ^ y) ^ n

full_name: Real.rpow_lt_rpow
code: @[gcongr]
theorem rpow_lt_rpow (hx : 0 ≤ x) (hxy : x < y) (hz : 0 < z) : x ^ z < y ^ z 
goal: x ^ z < y ^ z

full_name: Real.strictMonoOn_rpow_Ici_of_exponent_pos
code: theorem strictMonoOn_rpow_Ici_of_exponent_pos {r : ℝ} (hr : 0 < r) :
    StrictMonoOn (fun (x : ℝ) => x ^ r) (Set.Ici 0) 
goal: StrictMonoOn (fun x => x ^ r) (Set.Ici 0)

full_name: Real.rpow_le_rpow
code: @[gcongr]
theorem rpow_le_rpow {x y z : ℝ} (h : 0 ≤ x) (h₁ : x ≤ y) (h₂ : 0 ≤ z) : x ^ z ≤ y ^ z 
goal: x ^ z ≤ y ^ z

full_name: Real.monotoneOn_rpow_Ici_of_exponent_nonneg
code: theorem monotoneOn_rpow_Ici_of_exponent_nonneg {r : ℝ} (hr : 0 ≤ r) :
    MonotoneOn (fun (x : ℝ) => x ^ r) (Set.Ici 0) 
goal: MonotoneOn (fun x => x ^ r) (Set.Ici 0)

full_name: Real.rpow_lt_rpow_of_neg
code: lemma rpow_lt_rpow_of_neg (hx : 0 < x) (hxy : x < y) (hz : z < 0) : y ^ z < x ^ z 
goal: y ^ z < x ^ z

full_name: Real.rpow_le_rpow_of_nonpos
code: lemma rpow_le_rpow_of_nonpos (hx : 0 < x) (hxy : x ≤ y) (hz : z ≤ 0) : y ^ z ≤ x ^ z 
goal: y ^ z ≤ x ^ z

full_name: Real.rpow_lt_rpow_iff
code: theorem rpow_lt_rpow_iff (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ^ z < y ^ z ↔ x < y 
goal: x ^ z < y ^ z ↔ x < y

full_name: Real.rpow_le_rpow_iff
code: theorem rpow_le_rpow_iff (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ^ z ≤ y ^ z ↔ x ≤ y 
goal: x ^ z ≤ y ^ z ↔ x ≤ y

full_name: Real.rpow_lt_rpow_iff_of_neg
code: lemma rpow_lt_rpow_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) : x ^ z < y ^ z ↔ y < x 
goal: x ^ z < y ^ z ↔ y < x

full_name: Real.rpow_le_rpow_iff_of_neg
code: lemma rpow_le_rpow_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) : x ^ z ≤ y ^ z ↔ y ≤ x 
goal: x ^ z ≤ y ^ z ↔ y ≤ x

full_name: Real.le_rpow_inv_iff_of_pos
code: lemma le_rpow_inv_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y 
goal: x ≤ y ^ z⁻¹ ↔ x ^ z ≤ y

full_name: Real.rpow_inv_le_iff_of_pos
code: lemma rpow_inv_le_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z 
goal: x ^ z⁻¹ ≤ y ↔ x ≤ y ^ z

full_name: Real.lt_rpow_inv_iff_of_pos
code: lemma lt_rpow_inv_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x < y ^ z⁻¹ ↔ x ^ z < y 
goal: x < y ^ z⁻¹ ↔ x ^ z < y

full_name: Real.rpow_inv_lt_iff_of_pos
code: lemma rpow_inv_lt_iff_of_pos (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : 0 < z) : x ^ z⁻¹ < y ↔ x < y ^ z 
goal: x ^ z⁻¹ < y ↔ x < y ^ z

full_name: Real.le_rpow_inv_iff_of_neg
code: theorem le_rpow_inv_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z 
goal: x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z

full_name: Real.lt_rpow_inv_iff_of_neg
code: theorem lt_rpow_inv_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x < y ^ z⁻¹ ↔ y < x ^ z 
goal: x < y ^ z⁻¹ ↔ y < x ^ z

full_name: Real.rpow_inv_lt_iff_of_neg
code: theorem rpow_inv_lt_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ^ z⁻¹ < y ↔ y ^ z < x 
goal: x ^ z⁻¹ < y ↔ y ^ z < x

full_name: Real.rpow_inv_le_iff_of_neg
code: theorem rpow_inv_le_iff_of_neg (hx : 0 < x) (hy : 0 < y) (hz : z < 0) :
    x ^ z⁻¹ ≤ y ↔ y ^ z ≤ x 
goal: x ^ z⁻¹ ≤ y ↔ y ^ z ≤ x

full_name: Real.rpow_lt_rpow_of_exponent_lt
code: theorem rpow_lt_rpow_of_exponent_lt (hx : 1 < x) (hyz : y < z) : x ^ y < x ^ z 
goal: x ^ y < x ^ z

full_name: Real.rpow_le_rpow_of_exponent_le
code: @[gcongr]
theorem rpow_le_rpow_of_exponent_le (hx : 1 ≤ x) (hyz : y ≤ z) : x ^ y ≤ x ^ z 
goal: x ^ y ≤ x ^ z

full_name: Real.rpow_lt_rpow_of_exponent_neg
code: theorem rpow_lt_rpow_of_exponent_neg {x y z : ℝ} (hy : 0 < y) (hxy : y < x) (hz : z < 0) :
    x ^ z < y ^ z 
goal: x ^ z < y ^ z

full_name: Real.strictAntiOn_rpow_Ioi_of_exponent_neg
code: theorem strictAntiOn_rpow_Ioi_of_exponent_neg {r : ℝ} (hr : r < 0) :
    StrictAntiOn (fun (x : ℝ) => x ^ r) (Set.Ioi 0) 
goal: StrictAntiOn (fun x => x ^ r) (Set.Ioi 0)

full_name: Real.rpow_le_rpow_of_exponent_nonpos
code: theorem rpow_le_rpow_of_exponent_nonpos {x y : ℝ} (hy : 0 < y) (hxy : y ≤ x) (hz : z ≤ 0) :
    x ^ z ≤ y ^ z 
goal: x ^ z ≤ y ^ z

full_name: Real.antitoneOn_rpow_Ioi_of_exponent_nonpos
code: theorem antitoneOn_rpow_Ioi_of_exponent_nonpos {r : ℝ} (hr : r ≤ 0) :
    AntitoneOn (fun (x : ℝ) => x ^ r) (Set.Ioi 0) 
goal: AntitoneOn (fun x => x ^ r) (Set.Ioi 0)

full_name: Real.rpow_le_rpow_left_iff
code: @[simp]
theorem rpow_le_rpow_left_iff (hx : 1 < x) : x ^ y ≤ x ^ z ↔ y ≤ z 
goal: x ^ y ≤ x ^ z ↔ y ≤ z

full_name: Real.rpow_lt_rpow_left_iff
code: @[simp]
theorem rpow_lt_rpow_left_iff (hx : 1 < x) : x ^ y < x ^ z ↔ y < z 
goal: x ^ y < x ^ z ↔ y < z

full_name: Real.rpow_lt_rpow_of_exponent_gt
code: theorem rpow_lt_rpow_of_exponent_gt (hx0 : 0 < x) (hx1 : x < 1) (hyz : z < y) : x ^ y < x ^ z 
goal: x ^ y < x ^ z

full_name: Real.rpow_le_rpow_of_exponent_ge
code: theorem rpow_le_rpow_of_exponent_ge (hx0 : 0 < x) (hx1 : x ≤ 1) (hyz : z ≤ y) : x ^ y ≤ x ^ z 
goal: x ^ y ≤ x ^ z

full_name: Real.rpow_le_rpow_left_iff_of_base_lt_one
code: @[simp]
theorem rpow_le_rpow_left_iff_of_base_lt_one (hx0 : 0 < x) (hx1 : x < 1) :
    x ^ y ≤ x ^ z ↔ z ≤ y 
goal: x ^ y ≤ x ^ z ↔ z ≤ y

full_name: Real.rpow_lt_rpow_left_iff_of_base_lt_one
code: @[simp]
theorem rpow_lt_rpow_left_iff_of_base_lt_one (hx0 : 0 < x) (hx1 : x < 1) :
    x ^ y < x ^ z ↔ z < y 
goal: x ^ y < x ^ z ↔ z < y

full_name: Real.rpow_lt_one
code: theorem rpow_lt_one {x z : ℝ} (hx1 : 0 ≤ x) (hx2 : x < 1) (hz : 0 < z) : x ^ z < 1 
goal: x ^ z < 1

full_name: Real.rpow_le_one
code: theorem rpow_le_one {x z : ℝ} (hx1 : 0 ≤ x) (hx2 : x ≤ 1) (hz : 0 ≤ z) : x ^ z ≤ 1 
goal: x ^ z ≤ 1

full_name: Real.rpow_lt_one_of_one_lt_of_neg
code: theorem rpow_lt_one_of_one_lt_of_neg {x z : ℝ} (hx : 1 < x) (hz : z < 0) : x ^ z < 1 
goal: x ^ z < 1

full_name: Real.rpow_le_one_of_one_le_of_nonpos
code: theorem rpow_le_one_of_one_le_of_nonpos {x z : ℝ} (hx : 1 ≤ x) (hz : z ≤ 0) : x ^ z ≤ 1 
goal: x ^ z ≤ 1

full_name: Real.one_lt_rpow
code: theorem one_lt_rpow {x z : ℝ} (hx : 1 < x) (hz : 0 < z) : 1 < x ^ z 
goal: 1 < x ^ z

full_name: Real.one_le_rpow
code: theorem one_le_rpow {x z : ℝ} (hx : 1 ≤ x) (hz : 0 ≤ z) : 1 ≤ x ^ z 
goal: 1 ≤ x ^ z

full_name: Real.one_lt_rpow_of_pos_of_lt_one_of_neg
code: theorem one_lt_rpow_of_pos_of_lt_one_of_neg (hx1 : 0 < x) (hx2 : x < 1) (hz : z < 0) :
    1 < x ^ z 
goal: 1 < x ^ z

full_name: Real.one_le_rpow_of_pos_of_le_one_of_nonpos
code: theorem one_le_rpow_of_pos_of_le_one_of_nonpos (hx1 : 0 < x) (hx2 : x ≤ 1) (hz : z ≤ 0) :
    1 ≤ x ^ z 
goal: 1 ≤ x ^ z

full_name: Real.rpow_lt_one_iff_of_pos
code: theorem rpow_lt_one_iff_of_pos (hx : 0 < x) : x ^ y < 1 ↔ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y 
goal: x ^ y < 1 ↔ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y

full_name: Real.rpow_lt_one_iff
code: theorem rpow_lt_one_iff (hx : 0 ≤ x) :
    x ^ y < 1 ↔ x = 0 ∧ y ≠ 0 ∨ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y 
goal: x ^ y < 1 ↔ x = 0 ∧ y ≠ 0 ∨ 1 < x ∧ y < 0 ∨ x < 1 ∧ 0 < y

full_name: Real.rpow_lt_one_iff'
code: theorem rpow_lt_one_iff' {x y : ℝ} (hx : 0 ≤ x) (hy : 0 < y) :
    x ^ y < 1 ↔ x < 1 
goal: x ^ y < 1 ↔ x < 1

full_name: Real.one_lt_rpow_iff_of_pos
code: theorem one_lt_rpow_iff_of_pos (hx : 0 < x) : 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ x < 1 ∧ y < 0 
goal: 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ x < 1 ∧ y < 0

full_name: Real.one_lt_rpow_iff
code: theorem one_lt_rpow_iff (hx : 0 ≤ x) : 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0 
goal: 1 < x ^ y ↔ 1 < x ∧ 0 < y ∨ 0 < x ∧ x < 1 ∧ y < 0

full_name: Real.rpow_le_rpow_of_exponent_ge'
code: theorem rpow_le_rpow_of_exponent_ge' (hx0 : 0 ≤ x) (hx1 : x ≤ 1) (hz : 0 ≤ z) (hyz : z ≤ y) :
    x ^ y ≤ x ^ z 
goal: x ^ y ≤ x ^ z

full_name: Real.rpow_left_injOn
code: theorem rpow_left_injOn {x : ℝ} (hx : x ≠ 0) : InjOn (fun y : ℝ => y ^ x) { y : ℝ | 0 ≤ y } 
goal: Set.InjOn (fun y => y ^ x) {y | 0 ≤ y}

full_name: Real.rpow_left_inj
code: lemma rpow_left_inj (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : z ≠ 0) : x ^ z = y ^ z ↔ x = y 
goal: x ^ z = y ^ z ↔ x = y

full_name: Real.rpow_inv_eq
code: lemma rpow_inv_eq (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : z ≠ 0) : x ^ z⁻¹ = y ↔ x = y ^ z 
goal: x ^ z⁻¹ = y ↔ x = y ^ z

full_name: Real.eq_rpow_inv
code: lemma eq_rpow_inv (hx : 0 ≤ x) (hy : 0 ≤ y) (hz : z ≠ 0) : x = y ^ z⁻¹ ↔ x ^ z = y 
goal: x = y ^ z⁻¹ ↔ x ^ z = y

full_name: Real.le_rpow_iff_log_le
code: theorem le_rpow_iff_log_le (hx : 0 < x) (hy : 0 < y) : x ≤ y ^ z ↔ Real.log x ≤ z * Real.log y 
goal: x ≤ y ^ z ↔ Real.log x ≤ z * Real.log y

full_name: Real.le_rpow_of_log_le
code: theorem le_rpow_of_log_le (hx : 0 ≤ x) (hy : 0 < y) (h : Real.log x ≤ z * Real.log y) :
    x ≤ y ^ z 
goal: x ≤ y ^ z

full_name: Real.lt_rpow_iff_log_lt
code: theorem lt_rpow_iff_log_lt (hx : 0 < x) (hy : 0 < y) : x < y ^ z ↔ Real.log x < z * Real.log y 
goal: x < y ^ z ↔ Real.log x < z * Real.log y

full_name: Real.lt_rpow_of_log_lt
code: theorem lt_rpow_of_log_lt (hx : 0 ≤ x) (hy : 0 < y) (h : Real.log x < z * Real.log y) :
    x < y ^ z 
goal: x < y ^ z

full_name: Real.rpow_le_one_iff_of_pos
code: theorem rpow_le_one_iff_of_pos (hx : 0 < x) : x ^ y ≤ 1 ↔ 1 ≤ x ∧ y ≤ 0 ∨ x ≤ 1 ∧ 0 ≤ y 
goal: x ^ y ≤ 1 ↔ 1 ≤ x ∧ y ≤ 0 ∨ x ≤ 1 ∧ 0 ≤ y

full_name: Real.abs_log_mul_self_rpow_lt
code: /-- Bound for `|log x * x ^ t|` in the interval `(0, 1]`, for positive real `t`. -/
theorem abs_log_mul_self_rpow_lt (x t : ℝ) (h1 : 0 < x) (h2 : x ≤ 1) (ht : 0 < t) :
    |log x * x ^ t| < 1 / t 
goal: |Real.log x * x ^ t| < 1 / t

full_name: Real.log_le_rpow_div
code: /-- `log x` is bounded above by a multiple of every power of `x` with positive exponent. -/
lemma log_le_rpow_div {x ε : ℝ} (hx : 0 ≤ x) (hε : 0 < ε) : log x ≤ x ^ ε / ε 
goal: Real.log x ≤ x ^ ε / ε

full_name: Real.log_natCast_le_rpow_div
code: /-- The (real) logarithm of a natural number `n` is bounded by a multiple of every power of `n`
with positive exponent. -/
lemma log_natCast_le_rpow_div (n : ℕ) {ε : ℝ} (hε : 0 < ε) : log n ≤ n ^ ε / ε 
goal: Real.log ↑n ≤ ↑n ^ ε / ε

full_name: Real.strictMono_rpow_of_base_gt_one
code: lemma strictMono_rpow_of_base_gt_one {b : ℝ} (hb : 1 < b) :
    StrictMono (b ^ · : ℝ → ℝ) 
goal: StrictMono fun x => b ^ x

full_name: Real.monotone_rpow_of_base_ge_one
code: lemma monotone_rpow_of_base_ge_one {b : ℝ} (hb : 1 ≤ b) :
    Monotone (b ^ · : ℝ → ℝ) 
goal: Monotone fun x => b ^ x

full_name: Real.strictAnti_rpow_of_base_lt_one
code: lemma strictAnti_rpow_of_base_lt_one {b : ℝ} (hb₀ : 0 < b) (hb₁ : b < 1) :
    StrictAnti (b ^ · : ℝ → ℝ) 
goal: StrictAnti fun x => b ^ x

full_name: Real.antitone_rpow_of_base_le_one
code: lemma antitone_rpow_of_base_le_one {b : ℝ} (hb₀ : 0 < b) (hb₁ : b ≤ 1) :
    Antitone (b ^ · : ℝ → ℝ) 
goal: Antitone fun x => b ^ x

full_name: Complex.norm_prime_cpow_le_one_half
code: lemma norm_prime_cpow_le_one_half (p : Nat.Primes) {s : ℂ} (hs : 1 < s.re) :
    ‖(p : ℂ) ^ (-s)‖ ≤ 1 / 2 
goal: ‖↑↑p ^ (-s)‖ ≤ 1 / 2

full_name: Complex.one_sub_prime_cpow_ne_zero
code: lemma one_sub_prime_cpow_ne_zero {p : ℕ} (hp : p.Prime) {s : ℂ} (hs : 1 < s.re) :
    1 - (p : ℂ) ^ (-s) ≠ 0 
goal: 1 - ↑p ^ (-s) ≠ 0

full_name: Complex.norm_natCast_cpow_le_norm_natCast_cpow_of_pos
code: lemma norm_natCast_cpow_le_norm_natCast_cpow_of_pos {n : ℕ} (hn : 0 < n) {w z : ℂ}
    (h : w.re ≤ z.re) :
    ‖(n : ℂ) ^ w‖ ≤ ‖(n : ℂ) ^ z‖ 
goal: ‖↑n ^ w‖ ≤ ‖↑n ^ z‖

full_name: Complex.norm_natCast_cpow_le_norm_natCast_cpow_iff
code: lemma norm_natCast_cpow_le_norm_natCast_cpow_iff {n : ℕ} (hn : 1 < n) {w z : ℂ} :
    ‖(n : ℂ) ^ w‖ ≤ ‖(n : ℂ) ^ z‖ ↔ w.re ≤ z.re 
goal: ‖↑n ^ w‖ ≤ ‖↑n ^ z‖ ↔ w.re ≤ z.re

full_name: Complex.norm_log_natCast_le_rpow_div
code: lemma norm_log_natCast_le_rpow_div (n : ℕ) {ε : ℝ} (hε : 0 < ε) : ‖log n‖ ≤ n ^ ε / ε 
goal: ‖Complex.log ↑n‖ ≤ ↑n ^ ε / ε

full_name: Real.sqrt_eq_rpow
code: theorem sqrt_eq_rpow (x : ℝ) : √x = x ^ (1 / (2 : ℝ)) 
goal: √x = x ^ (1 / 2)

full_name: Real.rpow_div_two_eq_sqrt
code: theorem rpow_div_two_eq_sqrt {x : ℝ} (r : ℝ) (hx : 0 ≤ x) : x ^ (r / 2) = √x ^ r 
goal: x ^ (r / 2) = √x ^ r

full_name: Real.exists_rat_pow_btwn_rat_aux
code: theorem exists_rat_pow_btwn_rat_aux (hn : n ≠ 0) (x y : ℝ) (h : x < y) (hy : 0 < y) :
    ∃ q : ℚ, 0 < q ∧ x < (q : ℝ) ^ n ∧ (q : ℝ) ^ n < y 
goal: ∃ q, 0 < q ∧ x < ↑q ^ n ∧ ↑q ^ n < y

full_name: Real.exists_rat_pow_btwn_rat
code: theorem exists_rat_pow_btwn_rat (hn : n ≠ 0) {x y : ℚ} (h : x < y) (hy : 0 < y) :
    ∃ q : ℚ, 0 < q ∧ x < q ^ n ∧ q ^ n < y 
goal: ∃ q, 0 < q ∧ x < q ^ n ∧ q ^ n < y

full_name: Real.exists_rat_pow_btwn
code: /-- There is a rational power between any two positive elements of an archimedean ordered field. -/
theorem exists_rat_pow_btwn {α : Type*} [LinearOrderedField α] [Archimedean α] (hn : n ≠ 0)
    {x y : α} (h : x < y) (hy : 0 < y) : ∃ q : ℚ, 0 < q ∧ x < (q : α) ^ n ∧ (q : α) ^ n < y 
goal: ∃ q, 0 < q ∧ x < ↑q ^ n ∧ ↑q ^ n < y

full_name: Complex.cpow_inv_two_re
code: lemma cpow_inv_two_re (x : ℂ) : (x ^ (2⁻¹ : ℂ)).re = sqrt ((abs x + x.re) / 2) 
goal: (x ^ 2⁻¹).re = √((Complex.abs x + x.re) / 2)

full_name: Complex.cpow_inv_two_im_eq_sqrt
code: lemma cpow_inv_two_im_eq_sqrt {x : ℂ} (hx : 0 ≤ x.im) :
    (x ^ (2⁻¹ : ℂ)).im = sqrt ((abs x - x.re) / 2) 
goal: (x ^ 2⁻¹).im = √((Complex.abs x - x.re) / 2)

full_name: Complex.cpow_inv_two_im_eq_neg_sqrt
code: lemma cpow_inv_two_im_eq_neg_sqrt {x : ℂ} (hx : x.im < 0) :
    (x ^ (2⁻¹ : ℂ)).im = -sqrt ((abs x - x.re) / 2) 
goal: (x ^ 2⁻¹).im = -√((Complex.abs x - x.re) / 2)

full_name: Complex.abs_cpow_inv_two_im
code: lemma abs_cpow_inv_two_im (x : ℂ) : |(x ^ (2⁻¹ : ℂ)).im| = sqrt ((abs x - x.re) / 2) 
goal: |(x ^ 2⁻¹).im| = √((Complex.abs x - x.re) / 2)

full_name: Mathlib.Meta.NormNum.isNat_rpow_pos
code: theorem isNat_rpow_pos {a b : ℝ} {nb ne : ℕ}
    (pb : IsNat b nb) (pe' : IsNat (a ^ nb) ne) :
    IsNat (a ^ b) ne 
goal: Mathlib.Meta.NormNum.IsNat (a ^ b) ne

full_name: Mathlib.Meta.NormNum.isNat_rpow_neg
code: theorem isNat_rpow_neg {a b : ℝ} {nb ne : ℕ}
    (pb : IsInt b (Int.negOfNat nb)) (pe' : IsNat (a ^ (Int.negOfNat nb)) ne) :
    IsNat (a ^ b) ne 
goal: Mathlib.Meta.NormNum.IsNat (a ^ b) ne

full_name: Mathlib.Meta.NormNum.isInt_rpow_pos
code: theorem isInt_rpow_pos {a b : ℝ} {nb ne : ℕ}
    (pb : IsNat b nb) (pe' : IsInt (a ^ nb) (Int.negOfNat ne)) :
    IsInt (a ^ b) (Int.negOfNat ne) 
goal: Mathlib.Meta.NormNum.IsInt (a ^ b) (Int.negOfNat ne)

full_name: Mathlib.Meta.NormNum.isInt_rpow_neg
code: theorem isInt_rpow_neg {a b : ℝ} {nb ne : ℕ}
    (pb : IsInt b (Int.negOfNat nb)) (pe' : IsInt (a ^ (Int.negOfNat nb)) (Int.negOfNat ne)) :
    IsInt (a ^ b) (Int.negOfNat ne) 
goal: Mathlib.Meta.NormNum.IsInt (a ^ b) (Int.negOfNat ne)

full_name: Mathlib.Meta.NormNum.isRat_rpow_pos
code: theorem isRat_rpow_pos {a b : ℝ} {nb : ℕ}
    {num : ℤ} {den : ℕ}
    (pb : IsNat b nb) (pe' : IsRat (a ^ nb) num den) :
    IsRat (a ^ b) num den 
goal: Mathlib.Meta.NormNum.IsRat (a ^ b) num den

full_name: Mathlib.Meta.NormNum.isRat_rpow_neg
code: theorem isRat_rpow_neg {a b : ℝ} {nb : ℕ}
    {num : ℤ} {den : ℕ}
    (pb : IsInt b (Int.negOfNat nb)) (pe' : IsRat (a ^ (Int.negOfNat nb)) num den) :
    IsRat (a ^ b) num den 
goal: Mathlib.Meta.NormNum.IsRat (a ^ b) num den

full_name: Mathlib.Meta.NormNum.evalRPow
code: /-- Evaluates expressions of the form `a ^ b` when `a` and `b` are both reals. -/
@[norm_num (_ : ℝ) ^ (_ : ℝ)]
def evalRPow : NormNumExt 
goal: Mathlib.Meta.NormNum.NormNumExt