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

full_name: zero_cpow_eq_nhds
code: theorem zero_cpow_eq_nhds {b : ℂ} (hb : b ≠ 0) : (fun x : ℂ => (0 : ℂ) ^ x) =ᶠ[𝓝 b] 0 
goal: (fun x => 0 ^ x) =ᶠ[𝓝 b] 0

full_name: cpow_eq_nhds
code: theorem cpow_eq_nhds {a b : ℂ} (ha : a ≠ 0) :
    (fun x => x ^ b) =ᶠ[𝓝 a] fun x => exp (log x * b) 
goal: (fun x => x ^ b) =ᶠ[𝓝 a] fun x => Complex.exp (Complex.log x * b)

full_name: cpow_eq_nhds'
code: theorem cpow_eq_nhds' {p : ℂ × ℂ} (hp_fst : p.fst ≠ 0) :
    (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => exp (log x.1 * x.2) 
goal: (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => Complex.exp (Complex.log x.1 * x.2)

full_name: continuousAt_const_cpow
code: theorem continuousAt_const_cpow {a b : ℂ} (ha : a ≠ 0) : ContinuousAt (fun x : ℂ => a ^ x) b 
goal: ContinuousAt (fun x => a ^ x) b

full_name: continuousAt_const_cpow'
code: theorem continuousAt_const_cpow' {a b : ℂ} (h : b ≠ 0) : ContinuousAt (fun x : ℂ => a ^ x) b 
goal: ContinuousAt (fun x => a ^ x) b

full_name: continuousAt_cpow
code: /-- The function `z ^ w` is continuous in `(z, w)` provided that `z` does not belong to the interval
`(-∞, 0]` on the real line. See also `Complex.continuousAt_cpow_zero_of_re_pos` for a version that
works for `z = 0` but assumes `0 < re w`. -/
theorem continuousAt_cpow {p : ℂ × ℂ} (hp_fst : p.fst ∈ slitPlane) :
    ContinuousAt (fun x : ℂ × ℂ => x.1 ^ x.2) p 
goal: ContinuousAt (fun x => x.1 ^ x.2) p

full_name: continuousAt_cpow_const
code: theorem continuousAt_cpow_const {a b : ℂ} (ha : a ∈ slitPlane) :
    ContinuousAt (· ^ b) a 
goal: ContinuousAt (fun x => x ^ b) a

full_name: Filter.Tendsto.cpow
code: theorem Filter.Tendsto.cpow {l : Filter α} {f g : α → ℂ} {a b : ℂ} (hf : Tendsto f l (𝓝 a))
    (hg : Tendsto g l (𝓝 b)) (ha : a ∈ slitPlane) :
    Tendsto (fun x => f x ^ g x) l (𝓝 (a ^ b)) 
goal: Filter.Tendsto (fun x => f x ^ g x) l (𝓝 (a ^ b))

full_name: Filter.Tendsto.const_cpow
code: theorem Filter.Tendsto.const_cpow {l : Filter α} {f : α → ℂ} {a b : ℂ} (hf : Tendsto f l (𝓝 b))
    (h : a ≠ 0 ∨ b ≠ 0) : Tendsto (fun x => a ^ f x) l (𝓝 (a ^ b)) 
goal: Filter.Tendsto (fun x => a ^ f x) l (𝓝 (a ^ b))

full_name: ContinuousWithinAt.cpow
code: nonrec theorem ContinuousWithinAt.cpow (hf : ContinuousWithinAt f s a)
    (hg : ContinuousWithinAt g s a) (h0 : f a ∈ slitPlane) :
    ContinuousWithinAt (fun x => f x ^ g x) s a 
goal: ContinuousWithinAt (fun x => f x ^ g x) s a

full_name: ContinuousWithinAt.const_cpow
code: nonrec theorem ContinuousWithinAt.const_cpow {b : ℂ} (hf : ContinuousWithinAt f s a)
    (h : b ≠ 0 ∨ f a ≠ 0) : ContinuousWithinAt (fun x => b ^ f x) s a 
goal: ContinuousWithinAt (fun x => b ^ f x) s a

full_name: ContinuousAt.cpow
code: nonrec theorem ContinuousAt.cpow (hf : ContinuousAt f a) (hg : ContinuousAt g a)
    (h0 : f a ∈ slitPlane) : ContinuousAt (fun x => f x ^ g x) a 
goal: ContinuousAt (fun x => f x ^ g x) a

full_name: ContinuousAt.const_cpow
code: nonrec theorem ContinuousAt.const_cpow {b : ℂ} (hf : ContinuousAt f a) (h : b ≠ 0 ∨ f a ≠ 0) :
    ContinuousAt (fun x => b ^ f x) a 
goal: ContinuousAt (fun x => b ^ f x) a

full_name: ContinuousOn.cpow
code: theorem ContinuousOn.cpow (hf : ContinuousOn f s) (hg : ContinuousOn g s)
    (h0 : ∀ a ∈ s, f a ∈ slitPlane) : ContinuousOn (fun x => f x ^ g x) s 
goal: ContinuousOn (fun x => f x ^ g x) s

full_name: ContinuousOn.const_cpow
code: theorem ContinuousOn.const_cpow {b : ℂ} (hf : ContinuousOn f s) (h : b ≠ 0 ∨ ∀ a ∈ s, f a ≠ 0) :
    ContinuousOn (fun x => b ^ f x) s 
goal: ContinuousOn (fun x => b ^ f x) s

full_name: Continuous.cpow
code: theorem Continuous.cpow (hf : Continuous f) (hg : Continuous g)
    (h0 : ∀ a, f a ∈ slitPlane) : Continuous fun x => f x ^ g x 
goal: Continuous fun x => f x ^ g x

full_name: Continuous.const_cpow
code: theorem Continuous.const_cpow {b : ℂ} (hf : Continuous f) (h : b ≠ 0 ∨ ∀ a, f a ≠ 0) :
    Continuous fun x => b ^ f x 
goal: Continuous fun x => b ^ f x

full_name: ContinuousOn.cpow_const
code: theorem ContinuousOn.cpow_const {b : ℂ} (hf : ContinuousOn f s)
    (h : ∀ a : α, a ∈ s → f a ∈ slitPlane) : ContinuousOn (fun x => f x ^ b) s 
goal: ContinuousOn (fun x => f x ^ b) s

full_name: Real.continuousAt_const_rpow
code: theorem continuousAt_const_rpow {a b : ℝ} (h : a ≠ 0) : ContinuousAt (a ^ ·) b 
goal: ContinuousAt (fun x => a ^ x) b

full_name: Real.continuousAt_const_rpow'
code: theorem continuousAt_const_rpow' {a b : ℝ} (h : b ≠ 0) : ContinuousAt (a ^ ·) b 
goal: ContinuousAt (fun x => a ^ x) b

full_name: Real.rpow_eq_nhds_of_neg
code: theorem rpow_eq_nhds_of_neg {p : ℝ × ℝ} (hp_fst : p.fst < 0) :
    (fun x : ℝ × ℝ => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => exp (log x.1 * x.2) * cos (x.2 * π) 
goal: (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => rexp (Real.log x.1 * x.2) * Real.cos (x.2 * π)

full_name: Real.rpow_eq_nhds_of_pos
code: theorem rpow_eq_nhds_of_pos {p : ℝ × ℝ} (hp_fst : 0 < p.fst) :
    (fun x : ℝ × ℝ => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => exp (log x.1 * x.2) 
goal: (fun x => x.1 ^ x.2) =ᶠ[𝓝 p] fun x => rexp (Real.log x.1 * x.2)

full_name: Real.continuousAt_rpow_of_ne
code: theorem continuousAt_rpow_of_ne (p : ℝ × ℝ) (hp : p.1 ≠ 0) :
    ContinuousAt (fun p : ℝ × ℝ => p.1 ^ p.2) p 
goal: ContinuousAt (fun p => p.1 ^ p.2) p

full_name: Real.continuousAt_rpow_of_pos
code: theorem continuousAt_rpow_of_pos (p : ℝ × ℝ) (hp : 0 < p.2) :
    ContinuousAt (fun p : ℝ × ℝ => p.1 ^ p.2) p 
goal: ContinuousAt (fun p => p.1 ^ p.2) p

full_name: Real.continuousAt_rpow
code: theorem continuousAt_rpow (p : ℝ × ℝ) (h : p.1 ≠ 0 ∨ 0 < p.2) :
    ContinuousAt (fun p : ℝ × ℝ => p.1 ^ p.2) p 
goal: ContinuousAt (fun p => p.1 ^ p.2) p

full_name: Real.continuousAt_rpow_const
code: @[fun_prop]
theorem continuousAt_rpow_const (x : ℝ) (q : ℝ) (h : x ≠ 0 ∨ 0 ≤ q) :
    ContinuousAt (fun x : ℝ => x ^ q) x 
goal: ContinuousAt (fun x => x ^ q) x

full_name: Real.continuous_rpow_const
code: @[fun_prop]
theorem continuous_rpow_const {q : ℝ} (h : 0 ≤ q) : Continuous (fun x : ℝ => x ^ q) 
goal: Continuous fun x => x ^ q

full_name: Filter.Tendsto.rpow
code: theorem Filter.Tendsto.rpow {l : Filter α} {f g : α → ℝ} {x y : ℝ} (hf : Tendsto f l (𝓝 x))
    (hg : Tendsto g l (𝓝 y)) (h : x ≠ 0 ∨ 0 < y) : Tendsto (fun t => f t ^ g t) l (𝓝 (x ^ y)) 
goal: Filter.Tendsto (fun t => f t ^ g t) l (𝓝 (x ^ y))

full_name: Filter.Tendsto.rpow_const
code: theorem Filter.Tendsto.rpow_const {l : Filter α} {f : α → ℝ} {x p : ℝ} (hf : Tendsto f l (𝓝 x))
    (h : x ≠ 0 ∨ 0 ≤ p) : Tendsto (fun a => f a ^ p) l (𝓝 (x ^ p)) 
goal: Filter.Tendsto (fun a => f a ^ p) l (𝓝 (x ^ p))

full_name: ContinuousAt.rpow
code: nonrec theorem ContinuousAt.rpow (hf : ContinuousAt f x) (hg : ContinuousAt g x)
    (h : f x ≠ 0 ∨ 0 < g x) : ContinuousAt (fun t => f t ^ g t) x 
goal: ContinuousAt (fun t => f t ^ g t) x

full_name: ContinuousWithinAt.rpow
code: nonrec theorem ContinuousWithinAt.rpow (hf : ContinuousWithinAt f s x)
    (hg : ContinuousWithinAt g s x) (h : f x ≠ 0 ∨ 0 < g x) :
    ContinuousWithinAt (fun t => f t ^ g t) s x 
goal: ContinuousWithinAt (fun t => f t ^ g t) s x

full_name: ContinuousOn.rpow
code: theorem ContinuousOn.rpow (hf : ContinuousOn f s) (hg : ContinuousOn g s)
    (h : ∀ x ∈ s, f x ≠ 0 ∨ 0 < g x) : ContinuousOn (fun t => f t ^ g t) s 
goal: ContinuousOn (fun t => f t ^ g t) s

full_name: Continuous.rpow
code: theorem Continuous.rpow (hf : Continuous f) (hg : Continuous g) (h : ∀ x, f x ≠ 0 ∨ 0 < g x) :
    Continuous fun x => f x ^ g x 
goal: Continuous fun x => f x ^ g x

full_name: ContinuousWithinAt.rpow_const
code: nonrec theorem ContinuousWithinAt.rpow_const (hf : ContinuousWithinAt f s x) (h : f x ≠ 0 ∨ 0 ≤ p) :
    ContinuousWithinAt (fun x => f x ^ p) s x 
goal: ContinuousWithinAt (fun x => f x ^ p) s x

full_name: ContinuousAt.rpow_const
code: nonrec theorem ContinuousAt.rpow_const (hf : ContinuousAt f x) (h : f x ≠ 0 ∨ 0 ≤ p) :
    ContinuousAt (fun x => f x ^ p) x 
goal: ContinuousAt (fun x => f x ^ p) x

full_name: ContinuousOn.rpow_const
code: theorem ContinuousOn.rpow_const (hf : ContinuousOn f s) (h : ∀ x ∈ s, f x ≠ 0 ∨ 0 ≤ p) :
    ContinuousOn (fun x => f x ^ p) s 
goal: ContinuousOn (fun x => f x ^ p) s

full_name: Continuous.rpow_const
code: theorem Continuous.rpow_const (hf : Continuous f) (h : ∀ x, f x ≠ 0 ∨ 0 ≤ p) :
    Continuous fun x => f x ^ p 
goal: Continuous fun x => f x ^ p

full_name: Complex.continuousAt_cpow_zero_of_re_pos
code: /-- See also `continuousAt_cpow` and `Complex.continuousAt_cpow_of_re_pos`. -/
theorem continuousAt_cpow_zero_of_re_pos {z : ℂ} (hz : 0 < z.re) :
    ContinuousAt (fun x : ℂ × ℂ => x.1 ^ x.2) (0, z) 
goal: ContinuousAt (fun x => x.1 ^ x.2) (0, z)

full_name: Complex.continuousAt_cpow_of_re_pos
code: /-- See also `continuousAt_cpow` for a version that assumes `p.1 ≠ 0` but makes no
assumptions about `p.2`. -/
theorem continuousAt_cpow_of_re_pos {p : ℂ × ℂ} (h₁ : 0 ≤ p.1.re ∨ p.1.im ≠ 0) (h₂ : 0 < p.2.re) :
    ContinuousAt (fun x : ℂ × ℂ => x.1 ^ x.2) p 
goal: ContinuousAt (fun x => x.1 ^ x.2) p

full_name: Complex.continuousAt_cpow_const_of_re_pos
code: /-- See also `continuousAt_cpow_const` for a version that assumes `z ≠ 0` but makes no
assumptions about `w`. -/
theorem continuousAt_cpow_const_of_re_pos {z w : ℂ} (hz : 0 ≤ re z ∨ im z ≠ 0) (hw : 0 < re w) :
    ContinuousAt (fun x => x ^ w) z 
goal: ContinuousAt (fun x => x ^ w) z

full_name: Complex.continuousAt_ofReal_cpow
code: /-- Continuity of `(x, y) ↦ x ^ y` as a function on `ℝ × ℂ`. -/
theorem continuousAt_ofReal_cpow (x : ℝ) (y : ℂ) (h : 0 < y.re ∨ x ≠ 0) :
    ContinuousAt (fun p => (p.1 : ℂ) ^ p.2 : ℝ × ℂ → ℂ) (x, y) 
goal: ContinuousAt (fun p => ↑p.1 ^ p.2) (x, y)

full_name: Complex.continuousAt_ofReal_cpow_const
code: theorem continuousAt_ofReal_cpow_const (x : ℝ) (y : ℂ) (h : 0 < y.re ∨ x ≠ 0) :
    ContinuousAt (fun a => (a : ℂ) ^ y : ℝ → ℂ) x 
goal: ContinuousAt (fun a => ↑a ^ y) x

full_name: Complex.continuous_ofReal_cpow_const
code: theorem continuous_ofReal_cpow_const {y : ℂ} (hs : 0 < y.re) :
    Continuous (fun x => (x : ℂ) ^ y : ℝ → ℂ) 
goal: Continuous fun x => ↑x ^ y

full_name: NNReal.continuousAt_rpow
code: theorem continuousAt_rpow {x : ℝ≥0} {y : ℝ} (h : x ≠ 0 ∨ 0 < y) :
    ContinuousAt (fun p : ℝ≥0 × ℝ => p.1 ^ p.2) (x, y) 
goal: ContinuousAt (fun p => p.1 ^ p.2) (x, y)

full_name: NNReal.eventually_pow_one_div_le
code: theorem eventually_pow_one_div_le (x : ℝ≥0) {y : ℝ≥0} (hy : 1 < y) :
    ∀ᶠ n : ℕ in atTop, x ^ (1 / n : ℝ) ≤ y 
goal: ∀ᶠ (n : ℕ) in Filter.atTop, x ^ (1 / ↑n) ≤ y

full_name: Filter.Tendsto.nnrpow
code: theorem Filter.Tendsto.nnrpow {α : Type*} {f : Filter α} {u : α → ℝ≥0} {v : α → ℝ} {x : ℝ≥0}
    {y : ℝ} (hx : Tendsto u f (𝓝 x)) (hy : Tendsto v f (𝓝 y)) (h : x ≠ 0 ∨ 0 < y) :
    Tendsto (fun a => u a ^ v a) f (𝓝 (x ^ y)) 
goal: Filter.Tendsto (fun a => u a ^ v a) f (𝓝 (x ^ y))

full_name: NNReal.continuousAt_rpow_const
code: theorem continuousAt_rpow_const {x : ℝ≥0} {y : ℝ} (h : x ≠ 0 ∨ 0 ≤ y) :
    ContinuousAt (fun z => z ^ y) x 
goal: ContinuousAt (fun z => z ^ y) x

full_name: NNReal.continuous_rpow_const
code: @[fun_prop]
theorem continuous_rpow_const {y : ℝ} (h : 0 ≤ y) : Continuous fun x : ℝ≥0 => x ^ y 
goal: Continuous fun x => x ^ y

full_name: ENNReal.eventually_pow_one_div_le
code: theorem eventually_pow_one_div_le {x : ℝ≥0∞} (hx : x ≠ ∞) {y : ℝ≥0∞} (hy : 1 < y) :
    ∀ᶠ n : ℕ in atTop, x ^ (1 / n : ℝ) ≤ y 
goal: ∀ᶠ (n : ℕ) in Filter.atTop, x ^ (1 / ↑n) ≤ y

full_name: _private.Mathlib.Analysis.SpecialFunctions.Pow.Continuity.0.ENNReal.continuousAt_rpow_const_of_pos
code: private theorem continuousAt_rpow_const_of_pos {x : ℝ≥0∞} {y : ℝ} (h : 0 < y) :
    ContinuousAt (fun a : ℝ≥0∞ => a ^ y) x 
goal: ContinuousAt (fun a => a ^ y) x

full_name: ENNReal.continuous_rpow_const
code: @[continuity, fun_prop]
theorem continuous_rpow_const {y : ℝ} : Continuous fun a : ℝ≥0∞ => a ^ y 
goal: Continuous fun a => a ^ y

full_name: ENNReal.tendsto_const_mul_rpow_nhds_zero_of_pos
code: theorem tendsto_const_mul_rpow_nhds_zero_of_pos {c : ℝ≥0∞} (hc : c ≠ ∞) {y : ℝ} (hy : 0 < y) :
    Tendsto (fun x : ℝ≥0∞ => c * x ^ y) (𝓝 0) (𝓝 0) 
goal: Filter.Tendsto (fun x => c * x ^ y) (𝓝 0) (𝓝 0)

full_name: Filter.Tendsto.ennrpow_const
code: theorem Filter.Tendsto.ennrpow_const {α : Type*} {f : Filter α} {m : α → ℝ≥0∞} {a : ℝ≥0∞} (r : ℝ)
    (hm : Tendsto m f (𝓝 a)) : Tendsto (fun x => m x ^ r) f (𝓝 (a ^ r)) 
goal: Filter.Tendsto (fun x => m x ^ r) f (𝓝 (a ^ r))