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

full_name: tendsto_rpow_atTop
code: /-- The function `x ^ y` tends to `+∞` at `+∞` for any positive real `y`. -/
theorem tendsto_rpow_atTop {y : ℝ} (hy : 0 < y) : Tendsto (fun x : ℝ => x ^ y) atTop atTop 
goal: Filter.Tendsto (fun x => x ^ y) Filter.atTop Filter.atTop

full_name: tendsto_rpow_neg_atTop
code: /-- The function `x ^ (-y)` tends to `0` at `+∞` for any positive real `y`. -/
theorem tendsto_rpow_neg_atTop {y : ℝ} (hy : 0 < y) : Tendsto (fun x : ℝ => x ^ (-y)) atTop (𝓝 0) 
goal: Filter.Tendsto (fun x => x ^ (-y)) Filter.atTop (𝓝 0)

full_name: tendsto_rpow_atTop_of_base_lt_one
code: lemma tendsto_rpow_atTop_of_base_lt_one (b : ℝ) (hb₀ : -1 < b) (hb₁ : b < 1) :
    Tendsto (b ^ · : ℝ → ℝ) atTop (𝓝 (0 : ℝ)) 
goal: Filter.Tendsto (fun x => b ^ x) Filter.atTop (𝓝 0)

full_name: tendsto_rpow_atTop_of_base_gt_one
code: lemma tendsto_rpow_atTop_of_base_gt_one (b : ℝ) (hb : 1 < b) :
    Tendsto (b ^ · : ℝ → ℝ) atBot (𝓝 (0 : ℝ)) 
goal: Filter.Tendsto (fun x => b ^ x) Filter.atBot (𝓝 0)

full_name: tendsto_rpow_atBot_of_base_lt_one
code: lemma tendsto_rpow_atBot_of_base_lt_one (b : ℝ) (hb₀ : 0 < b) (hb₁ : b < 1) :
    Tendsto (b ^ · : ℝ → ℝ) atBot atTop 
goal: Filter.Tendsto (fun x => b ^ x) Filter.atBot Filter.atTop

full_name: tendsto_rpow_atBot_of_base_gt_one
code: lemma tendsto_rpow_atBot_of_base_gt_one (b : ℝ) (hb : 1 < b) :
    Tendsto (b ^ · : ℝ → ℝ) atBot (𝓝 0) 
goal: Filter.Tendsto (fun x => b ^ x) Filter.atBot (𝓝 0)

full_name: tendsto_rpow_div_mul_add
code: /-- The function `x ^ (a / (b * x + c))` tends to `1` at `+∞`, for any real numbers `a`, `b`, and
`c` such that `b` is nonzero. -/
theorem tendsto_rpow_div_mul_add (a b c : ℝ) (hb : 0 ≠ b) :
    Tendsto (fun x => x ^ (a / (b * x + c))) atTop (𝓝 1) 
goal: Filter.Tendsto (fun x => x ^ (a / (b * x + c))) Filter.atTop (𝓝 1)

full_name: tendsto_rpow_div
code: /-- The function `x ^ (1 / x)` tends to `1` at `+∞`. -/
theorem tendsto_rpow_div : Tendsto (fun x => x ^ ((1 : ℝ) / x)) atTop (𝓝 1) 
goal: Filter.Tendsto (fun x => x ^ (1 / x)) Filter.atTop (𝓝 1)

full_name: tendsto_rpow_neg_div
code: /-- The function `x ^ (-1 / x)` tends to `1` at `+∞`. -/
theorem tendsto_rpow_neg_div : Tendsto (fun x => x ^ (-(1 : ℝ) / x)) atTop (𝓝 1) 
goal: Filter.Tendsto (fun x => x ^ (-1 / x)) Filter.atTop (𝓝 1)

full_name: tendsto_exp_div_rpow_atTop
code: /-- The function `exp(x) / x ^ s` tends to `+∞` at `+∞`, for any real number `s`. -/
theorem tendsto_exp_div_rpow_atTop (s : ℝ) : Tendsto (fun x : ℝ => exp x / x ^ s) atTop atTop 
goal: Filter.Tendsto (fun x => rexp x / x ^ s) Filter.atTop Filter.atTop

full_name: tendsto_exp_mul_div_rpow_atTop
code: /-- The function `exp (b * x) / x ^ s` tends to `+∞` at `+∞`, for any real `s` and `b > 0`. -/
theorem tendsto_exp_mul_div_rpow_atTop (s : ℝ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun x : ℝ => exp (b * x) / x ^ s) atTop atTop 
goal: Filter.Tendsto (fun x => rexp (b * x) / x ^ s) Filter.atTop Filter.atTop

full_name: tendsto_rpow_mul_exp_neg_mul_atTop_nhds_zero
code: /-- The function `x ^ s * exp (-b * x)` tends to `0` at `+∞`, for any real `s` and `b > 0`. -/
theorem tendsto_rpow_mul_exp_neg_mul_atTop_nhds_zero (s : ℝ) (b : ℝ) (hb : 0 < b) :
    Tendsto (fun x : ℝ => x ^ s * exp (-b * x)) atTop (𝓝 0) 
goal: Filter.Tendsto (fun x => x ^ s * rexp (-b * x)) Filter.atTop (𝓝 0)

full_name: NNReal.tendsto_rpow_atTop
code: nonrec theorem NNReal.tendsto_rpow_atTop {y : ℝ} (hy : 0 < y) :
    Tendsto (fun x : ℝ≥0 => x ^ y) atTop atTop 
goal: Filter.Tendsto (fun x => x ^ y) Filter.atTop Filter.atTop

full_name: ENNReal.tendsto_rpow_at_top
code: theorem ENNReal.tendsto_rpow_at_top {y : ℝ} (hy : 0 < y) :
    Tendsto (fun x : ℝ≥0∞ => x ^ y) (𝓝 ⊤) (𝓝 ⊤) 
goal: Filter.Tendsto (fun x => x ^ y) (𝓝 ⊤) (𝓝 ⊤)

full_name: Complex.isTheta_exp_arg_mul_im
code: theorem isTheta_exp_arg_mul_im (hl : IsBoundedUnder (· ≤ ·) l fun x => |(g x).im|) :
    (fun x => Real.exp (arg (f x) * im (g x))) =Θ[l] fun _ => (1 : ℝ) 
goal: (fun x => rexp ((f x).arg * (g x).im)) =Θ[l] fun x => 1

full_name: Complex.isBigO_cpow_rpow
code: theorem isBigO_cpow_rpow (hl : IsBoundedUnder (· ≤ ·) l fun x => |(g x).im|) :
    (fun x => f x ^ g x) =O[l] fun x => abs (f x) ^ (g x).re 
goal: (fun x => f x ^ g x) =O[l] fun x => Complex.abs (f x) ^ (g x).re

full_name: Complex.isTheta_cpow_rpow
code: theorem isTheta_cpow_rpow (hl_im : IsBoundedUnder (· ≤ ·) l fun x => |(g x).im|)
    (hl : ∀ᶠ x in l, f x = 0 → re (g x) = 0 → g x = 0) :
    (fun x => f x ^ g x) =Θ[l] fun x => abs (f x) ^ (g x).re 
goal: (fun x => f x ^ g x) =Θ[l] fun x => Complex.abs (f x) ^ (g x).re

full_name: Complex.isTheta_cpow_const_rpow
code: theorem isTheta_cpow_const_rpow {b : ℂ} (hl : b.re = 0 → b ≠ 0 → ∀ᶠ x in l, f x ≠ 0) :
    (fun x => f x ^ b) =Θ[l] fun x => abs (f x) ^ b.re 
goal: (fun x => f x ^ b) =Θ[l] fun x => Complex.abs (f x) ^ b.re

full_name: Asymptotics.IsBigOWith.rpow
code: theorem IsBigOWith.rpow (h : IsBigOWith c l f g) (hc : 0 ≤ c) (hr : 0 ≤ r) (hg : 0 ≤ᶠ[l] g) :
    IsBigOWith (c ^ r) l (fun x => f x ^ r) fun x => g x ^ r 
goal: Asymptotics.IsBigOWith (c ^ r) l (fun x => f x ^ r) fun x => g x ^ r

full_name: Asymptotics.IsBigO.rpow
code: theorem IsBigO.rpow (hr : 0 ≤ r) (hg : 0 ≤ᶠ[l] g) (h : f =O[l] g) :
    (fun x => f x ^ r) =O[l] fun x => g x ^ r 
goal: (fun x => f x ^ r) =O[l] fun x => g x ^ r

full_name: Asymptotics.IsTheta.rpow
code: theorem IsTheta.rpow (hr : 0 ≤ r) (hf : 0 ≤ᶠ[l] f) (hg : 0 ≤ᶠ[l] g) (h : f =Θ[l] g) :
    (fun x => f x ^ r) =Θ[l] fun x => g x ^ r 
goal: (fun x => f x ^ r) =Θ[l] fun x => g x ^ r

full_name: Asymptotics.IsLittleO.rpow
code: theorem IsLittleO.rpow (hr : 0 < r) (hg : 0 ≤ᶠ[l] g) (h : f =o[l] g) :
    (fun x => f x ^ r) =o[l] fun x => g x ^ r 
goal: (fun x => f x ^ r) =o[l] fun x => g x ^ r

full_name: Asymptotics.IsBigO.sqrt
code: protected lemma IsBigO.sqrt (hfg : f =O[l] g) (hg : 0 ≤ᶠ[l] g) :
    (Real.sqrt <| f ·) =O[l] (Real.sqrt <| g ·) 
goal: (fun x => √(f x)) =O[l] fun x => √(g x)

full_name: Asymptotics.IsLittleO.sqrt
code: protected lemma IsLittleO.sqrt (hfg : f =o[l] g) (hg : 0 ≤ᶠ[l] g) :
    (Real.sqrt <| f ·) =o[l] (Real.sqrt <| g ·) 
goal: (fun x => √(f x)) =o[l] fun x => √(g x)

full_name: Asymptotics.IsTheta.sqrt
code: protected lemma IsTheta.sqrt (hfg : f =Θ[l] g) (hf : 0 ≤ᶠ[l] f) (hg : 0 ≤ᶠ[l] g) :
    (Real.sqrt <| f ·) =Θ[l] (Real.sqrt <| g ·) 
goal: (fun x => √(f x)) =Θ[l] fun x => √(g x)

full_name: isLittleO_rpow_exp_pos_mul_atTop
code: /-- `x ^ s = o(exp(b * x))` as `x → ∞` for any real `s` and positive `b`. -/
theorem isLittleO_rpow_exp_pos_mul_atTop (s : ℝ) {b : ℝ} (hb : 0 < b) :
    (fun x : ℝ => x ^ s) =o[atTop] fun x => exp (b * x) 
goal: (fun x => x ^ s) =o[Filter.atTop] fun x => rexp (b * x)

full_name: isLittleO_zpow_exp_pos_mul_atTop
code: /-- `x ^ k = o(exp(b * x))` as `x → ∞` for any integer `k` and positive `b`. -/
theorem isLittleO_zpow_exp_pos_mul_atTop (k : ℤ) {b : ℝ} (hb : 0 < b) :
    (fun x : ℝ => x ^ k) =o[atTop] fun x => exp (b * x) 
goal: (fun x => x ^ k) =o[Filter.atTop] fun x => rexp (b * x)

full_name: isLittleO_pow_exp_pos_mul_atTop
code: /-- `x ^ k = o(exp(b * x))` as `x → ∞` for any natural `k` and positive `b`. -/
theorem isLittleO_pow_exp_pos_mul_atTop (k : ℕ) {b : ℝ} (hb : 0 < b) :
    (fun x : ℝ => x ^ k) =o[atTop] fun x => exp (b * x) 
goal: (fun x => x ^ k) =o[Filter.atTop] fun x => rexp (b * x)

full_name: isLittleO_rpow_exp_atTop
code: /-- `x ^ s = o(exp x)` as `x → ∞` for any real `s`. -/
theorem isLittleO_rpow_exp_atTop (s : ℝ) : (fun x : ℝ => x ^ s) =o[atTop] exp 
goal: (fun x => x ^ s) =o[Filter.atTop] rexp

full_name: isLittleO_exp_neg_mul_rpow_atTop
code: /-- `exp (-a * x) = o(x ^ s)` as `x → ∞`, for any positive `a` and real `s`. -/
theorem isLittleO_exp_neg_mul_rpow_atTop {a : ℝ} (ha : 0 < a) (b : ℝ) :
    IsLittleO atTop (fun x : ℝ => exp (-a * x)) fun x : ℝ => x ^ b 
goal: (fun x => rexp (-a * x)) =o[Filter.atTop] fun x => x ^ b

full_name: isLittleO_log_rpow_atTop
code: theorem isLittleO_log_rpow_atTop {r : ℝ} (hr : 0 < r) : log =o[atTop] fun x => x ^ r 
goal: Real.log =o[Filter.atTop] fun x => x ^ r

full_name: isLittleO_log_rpow_rpow_atTop
code: theorem isLittleO_log_rpow_rpow_atTop {s : ℝ} (r : ℝ) (hs : 0 < s) :
    (fun x => log x ^ r) =o[atTop] fun x => x ^ s 
goal: (fun x => Real.log x ^ r) =o[Filter.atTop] fun x => x ^ s

full_name: isLittleO_abs_log_rpow_rpow_nhds_zero
code: theorem isLittleO_abs_log_rpow_rpow_nhds_zero {s : ℝ} (r : ℝ) (hs : s < 0) :
    (fun x => |log x| ^ r) =o[𝓝[>] 0] fun x => x ^ s 
goal: (fun x => |Real.log x| ^ r) =o[𝓝[>] 0] fun x => x ^ s

full_name: isLittleO_log_rpow_nhds_zero
code: theorem isLittleO_log_rpow_nhds_zero {r : ℝ} (hr : r < 0) : log =o[𝓝[>] 0] fun x => x ^ r 
goal: Real.log =o[𝓝[>] 0] fun x => x ^ r

full_name: tendsto_log_div_rpow_nhds_zero
code: theorem tendsto_log_div_rpow_nhds_zero {r : ℝ} (hr : r < 0) :
    Tendsto (fun x => log x / x ^ r) (𝓝[>] 0) (𝓝 0) 
goal: Filter.Tendsto (fun x => Real.log x / x ^ r) (𝓝[>] 0) (𝓝 0)

full_name: tendsto_log_mul_rpow_nhds_zero
code: theorem tendsto_log_mul_rpow_nhds_zero {r : ℝ} (hr : 0 < r) :
    Tendsto (fun x => log x * x ^ r) (𝓝[>] 0) (𝓝 0) 
goal: Filter.Tendsto (fun x => Real.log x * x ^ r) (𝓝[>] 0) (𝓝 0)

full_name: tendsto_log_mul_self_nhds_zero_left
code: lemma tendsto_log_mul_self_nhds_zero_left : Filter.Tendsto (fun x ↦ log x * x) (𝓝[<] 0) (𝓝 0) 
goal: Filter.Tendsto (fun x => Real.log x * x) (𝓝[<] 0) (𝓝 0)