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

full_name: Complex.cpow
code: /-- The complex power function `x ^ y`, given by `x ^ y = exp(y log x)` (where `log` is the
principal determination of the logarithm), unless `x = 0` where one sets `0 ^ 0 = 1` and
`0 ^ y = 0` for `y ≠ 0`. -/
noncomputable def cpow (x y : ℂ) : ℂ 
goal: ℂ

full_name: Complex.instPow
code: noncomputable instance : Pow ℂ ℂ 
goal: Pow ℂ ℂ

full_name: Complex.cpow_eq_pow
code: @[simp]
theorem cpow_eq_pow (x y : ℂ) : cpow x y = x ^ y 
goal: x.cpow y = x ^ y

full_name: Complex.cpow_def
code: theorem cpow_def (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 Complex.exp (Complex.log x * y)

full_name: Complex.cpow_def_of_ne_zero
code: theorem cpow_def_of_ne_zero {x : ℂ} (hx : x ≠ 0) (y : ℂ) : x ^ y = exp (log x * y) 
goal: x ^ y = Complex.exp (Complex.log x * y)

full_name: Complex.cpow_zero
code: @[simp]
theorem cpow_zero (x : ℂ) : x ^ (0 : ℂ) = 1 
goal: x ^ 0 = 1

full_name: Complex.cpow_eq_zero_iff
code: @[simp]
theorem cpow_eq_zero_iff (x y : ℂ) : x ^ y = 0 ↔ x = 0 ∧ y ≠ 0 
goal: x ^ y = 0 ↔ x = 0 ∧ y ≠ 0

full_name: Complex.zero_cpow
code: @[simp]
theorem zero_cpow {x : ℂ} (h : x ≠ 0) : (0 : ℂ) ^ x = 0 
goal: 0 ^ x = 0

full_name: Complex.zero_cpow_eq_iff
code: theorem zero_cpow_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: Complex.eq_zero_cpow_iff
code: theorem eq_zero_cpow_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: Complex.cpow_one
code: @[simp]
theorem cpow_one (x : ℂ) : x ^ (1 : ℂ) = x 
goal: x ^ 1 = x

full_name: Complex.one_cpow
code: @[simp]
theorem one_cpow (x : ℂ) : (1 : ℂ) ^ x = 1 
goal: 1 ^ x = 1

full_name: Complex.cpow_add
code: theorem cpow_add {x : ℂ} (y z : ℂ) (hx : x ≠ 0) : x ^ (y + z) = x ^ y * x ^ z 
goal: x ^ (y + z) = x ^ y * x ^ z

full_name: Complex.cpow_mul
code: theorem cpow_mul {x y : ℂ} (z : ℂ) (h₁ : -π < (log x * y).im) (h₂ : (log x * y).im ≤ π) :
    x ^ (y * z) = (x ^ y) ^ z 
goal: x ^ (y * z) = (x ^ y) ^ z

full_name: Complex.cpow_neg
code: theorem cpow_neg (x y : ℂ) : x ^ (-y) = (x ^ y)⁻¹ 
goal: x ^ (-y) = (x ^ y)⁻¹

full_name: Complex.cpow_sub
code: theorem cpow_sub {x : ℂ} (y z : ℂ) (hx : x ≠ 0) : x ^ (y - z) = x ^ y / x ^ z 
goal: x ^ (y - z) = x ^ y / x ^ z

full_name: Complex.cpow_neg_one
code: theorem cpow_neg_one (x : ℂ) : x ^ (-1 : ℂ) = x⁻¹ 
goal: x ^ (-1) = x⁻¹

full_name: Complex.cpow_int_mul
code: /-- See also `Complex.cpow_int_mul'`. -/
lemma cpow_int_mul (x : ℂ) (n : ℤ) (y : ℂ) : x ^ (n * y) = (x ^ y) ^ n 
goal: x ^ (↑n * y) = (x ^ y) ^ n

full_name: Complex.cpow_mul_int
code: lemma cpow_mul_int (x y : ℂ) (n : ℤ) : x ^ (y * n) = (x ^ y) ^ n 
goal: x ^ (y * ↑n) = (x ^ y) ^ n

full_name: Complex.cpow_nat_mul
code: lemma cpow_nat_mul (x : ℂ) (n : ℕ) (y : ℂ) : x ^ (n * y) = (x ^ y) ^ n 
goal: x ^ (↑n * y) = (x ^ y) ^ n

full_name: Complex.cpow_ofNat_mul
code: /-- See Note [no_index around OfNat.ofNat] -/
lemma cpow_ofNat_mul (x : ℂ) (n : ℕ) [n.AtLeastTwo] (y : ℂ) :
    x ^ (no_index (OfNat.ofNat n) * y) = (x ^ y) ^ (OfNat.ofNat n : ℕ) 
goal: x ^ (OfNat.ofNat n * y) = (x ^ y) ^ OfNat.ofNat n

full_name: Complex.cpow_mul_nat
code: lemma cpow_mul_nat (x y : ℂ) (n : ℕ) : x ^ (y * n) = (x ^ y) ^ n 
goal: x ^ (y * ↑n) = (x ^ y) ^ n

full_name: Complex.cpow_mul_ofNat
code: /-- See Note [no_index around OfNat.ofNat] -/
lemma cpow_mul_ofNat (x y : ℂ) (n : ℕ) [n.AtLeastTwo] :
    x ^ (y * no_index (OfNat.ofNat n)) = (x ^ y) ^ (OfNat.ofNat n : ℕ) 
goal: x ^ (y * OfNat.ofNat n) = (x ^ y) ^ OfNat.ofNat n

full_name: Complex.cpow_natCast
code: @[simp, norm_cast]
theorem cpow_natCast (x : ℂ) (n : ℕ) : x ^ (n : ℂ) = x ^ n 
goal: x ^ ↑n = x ^ n

full_name: Complex.cpow_ofNat
code: /-- See Note [no_index around OfNat.ofNat] -/
@[simp]
lemma cpow_ofNat (x : ℂ) (n : ℕ) [n.AtLeastTwo] :
    x ^ (no_index (OfNat.ofNat n) : ℂ) = x ^ (OfNat.ofNat n : ℕ) 
goal: x ^ OfNat.ofNat n = x ^ OfNat.ofNat n

full_name: Complex.cpow_two
code: theorem cpow_two (x : ℂ) : x ^ (2 : ℂ) = x ^ (2 : ℕ) 
goal: x ^ 2 = x ^ 2

full_name: Complex.cpow_intCast
code: @[simp, norm_cast]
theorem cpow_intCast (x : ℂ) (n : ℤ) : x ^ (n : ℂ) = x ^ n 
goal: x ^ ↑n = x ^ n

full_name: Complex.cpow_nat_inv_pow
code: @[simp]
theorem cpow_nat_inv_pow (x : ℂ) {n : ℕ} (hn : n ≠ 0) : (x ^ (n⁻¹ : ℂ)) ^ n = x 
goal: (x ^ (↑n)⁻¹) ^ n = x

full_name: Complex.cpow_ofNat_inv_pow
code: /-- See Note [no_index around OfNat.ofNat] -/
@[simp]
lemma cpow_ofNat_inv_pow (x : ℂ) (n : ℕ) [n.AtLeastTwo] :
    (x ^ ((no_index (OfNat.ofNat n) : ℂ)⁻¹)) ^ (no_index (OfNat.ofNat n) : ℕ) = x 
goal: (x ^ (OfNat.ofNat n)⁻¹) ^ OfNat.ofNat n = x

full_name: Complex.cpow_int_mul'
code: /-- A version of `Complex.cpow_int_mul` with RHS that matches `Complex.cpow_mul`.

The assumptions on the arguments are needed
because the equality fails, e.g., for `x = -I`, `n = 2`, `y = 1/2`. -/
lemma cpow_int_mul' {x : ℂ} {n : ℤ} (hlt : -π < n * x.arg) (hle : n * x.arg ≤ π) (y : ℂ) :
    x ^ (n * y) = (x ^ n) ^ y 
goal: x ^ (↑n * y) = (x ^ n) ^ y

full_name: Complex.cpow_nat_mul'
code: /-- A version of `Complex.cpow_nat_mul` with RHS that matches `Complex.cpow_mul`.

The assumptions on the arguments are needed
because the equality fails, e.g., for `x = -I`, `n = 2`, `y = 1/2`. -/
lemma cpow_nat_mul' {x : ℂ} {n : ℕ} (hlt : -π < n * x.arg) (hle : n * x.arg ≤ π) (y : ℂ) :
    x ^ (n * y) = (x ^ n) ^ y 
goal: x ^ (↑n * y) = (x ^ n) ^ y

full_name: Complex.cpow_ofNat_mul'
code: lemma cpow_ofNat_mul' {x : ℂ} {n : ℕ} [n.AtLeastTwo] (hlt : -π < OfNat.ofNat n * x.arg)
    (hle : OfNat.ofNat n * x.arg ≤ π) (y : ℂ) :
    x ^ (OfNat.ofNat n * y) = (x ^ (OfNat.ofNat n : ℕ)) ^ y 
goal: x ^ (OfNat.ofNat n * y) = (x ^ OfNat.ofNat n) ^ y

full_name: Complex.pow_cpow_nat_inv
code: lemma pow_cpow_nat_inv {x : ℂ} {n : ℕ} (h₀ : n ≠ 0) (hlt : -(π / n) < x.arg) (hle : x.arg ≤ π / n) :
    (x ^ n) ^ (n⁻¹ : ℂ) = x 
goal: (x ^ n) ^ (↑n)⁻¹ = x

full_name: Complex.pow_cpow_ofNat_inv
code: lemma pow_cpow_ofNat_inv {x : ℂ} {n : ℕ} [n.AtLeastTwo] (hlt : -(π / OfNat.ofNat n) < x.arg)
    (hle : x.arg ≤ π / OfNat.ofNat n) :
    (x ^ (OfNat.ofNat n : ℕ)) ^ ((OfNat.ofNat n : ℂ)⁻¹) = x 
goal: (x ^ OfNat.ofNat n) ^ (OfNat.ofNat n)⁻¹ = x

full_name: Complex.sq_cpow_two_inv
code: /-- See also `Complex.pow_cpow_ofNat_inv` for a version that also works for `x * I`, `0 ≤ x`. -/
lemma sq_cpow_two_inv {x : ℂ} (hx : 0 < x.re) : (x ^ (2 : ℕ)) ^ (2⁻¹ : ℂ) = x 
goal: (x ^ 2) ^ 2⁻¹ = x

full_name: Complex.mul_cpow_ofReal_nonneg
code: theorem mul_cpow_ofReal_nonneg {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) (r : ℂ) :
    ((a : ℂ) * (b : ℂ)) ^ r = (a : ℂ) ^ r * (b : ℂ) ^ r 
goal: (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r

full_name: Complex.natCast_mul_natCast_cpow
code: lemma natCast_mul_natCast_cpow (m n : ℕ) (s : ℂ) : (m * n : ℂ) ^ s = m ^ s * n ^ s 
goal: (↑m * ↑n) ^ s = ↑m ^ s * ↑n ^ s

full_name: Complex.natCast_cpow_natCast_mul
code: lemma natCast_cpow_natCast_mul (n m : ℕ) (z : ℂ) : (n : ℂ) ^ (m * z) = ((n : ℂ) ^ m) ^ z 
goal: ↑n ^ (↑m * z) = (↑n ^ m) ^ z

full_name: Complex.inv_cpow_eq_ite
code: theorem inv_cpow_eq_ite (x : ℂ) (n : ℂ) :
    x⁻¹ ^ n = if x.arg = π then conj (x ^ conj n)⁻¹ else (x ^ n)⁻¹ 
goal: x⁻¹ ^ n = if x.arg = π then (starRingEnd ℂ) (x ^ (starRingEnd ℂ) n)⁻¹ else (x ^ n)⁻¹

full_name: Complex.inv_cpow
code: theorem inv_cpow (x : ℂ) (n : ℂ) (hx : x.arg ≠ π) : x⁻¹ ^ n = (x ^ n)⁻¹ 
goal: x⁻¹ ^ n = (x ^ n)⁻¹

full_name: Complex.inv_cpow_eq_ite'
code: /-- `Complex.inv_cpow_eq_ite` with the `ite` on the other side. -/
theorem inv_cpow_eq_ite' (x : ℂ) (n : ℂ) :
    (x ^ n)⁻¹ = if x.arg = π then conj (x⁻¹ ^ conj n) else x⁻¹ ^ n 
goal: (x ^ n)⁻¹ = if x.arg = π then (starRingEnd ℂ) (x⁻¹ ^ (starRingEnd ℂ) n) else x⁻¹ ^ n

full_name: Complex.conj_cpow_eq_ite
code: theorem conj_cpow_eq_ite (x : ℂ) (n : ℂ) :
    conj x ^ n = if x.arg = π then x ^ n else conj (x ^ conj n) 
goal: (starRingEnd ℂ) x ^ n = if x.arg = π then x ^ n else (starRingEnd ℂ) (x ^ (starRingEnd ℂ) n)

full_name: Complex.conj_cpow
code: theorem conj_cpow (x : ℂ) (n : ℂ) (hx : x.arg ≠ π) : conj x ^ n = conj (x ^ conj n) 
goal: (starRingEnd ℂ) x ^ n = (starRingEnd ℂ) (x ^ (starRingEnd ℂ) n)

full_name: Complex.cpow_conj
code: theorem cpow_conj (x : ℂ) (n : ℂ) (hx : x.arg ≠ π) : x ^ conj n = conj (conj x ^ n) 
goal: x ^ (starRingEnd ℂ) n = (starRingEnd ℂ) ((starRingEnd ℂ) x ^ n)