File: Mathlib/Analysis/SpecialFunctions/Exp.lean

full_name: Complex.exp_bound_sq
code: theorem exp_bound_sq (x z : ℂ) (hz : ‖z‖ ≤ 1) :
    ‖exp (x + z) - exp x - z • exp x‖ ≤ ‖exp x‖ * ‖z‖ ^ 2 
goal: ‖Complex.exp (x + z) - Complex.exp x - z • Complex.exp x‖ ≤ ‖Complex.exp x‖ * ‖z‖ ^ 2

full_name: Complex.locally_lipschitz_exp
code: theorem locally_lipschitz_exp {r : ℝ} (hr_nonneg : 0 ≤ r) (hr_le : r ≤ 1) (x y : ℂ)
    (hyx : ‖y - x‖ < r) : ‖exp y - exp x‖ ≤ (1 + r) * ‖exp x‖ * ‖y - x‖ 
goal: ‖Complex.exp y - Complex.exp x‖ ≤ (1 + r) * ‖Complex.exp x‖ * ‖y - x‖

full_name: Complex.continuous_exp
code: @[continuity]
theorem continuous_exp : Continuous exp 
goal: Continuous Complex.exp

full_name: Complex.continuousOn_exp
code: theorem continuousOn_exp {s : Set ℂ} : ContinuousOn exp s 
goal: ContinuousOn Complex.exp s

full_name: Complex.exp_sub_sum_range_isBigO_pow
code: lemma exp_sub_sum_range_isBigO_pow (n : ℕ) :
    (fun x ↦ exp x - ∑ i ∈ Finset.range n, x ^ i / i !) =O[𝓝 0] (· ^ n) 
goal: (fun x => Complex.exp x - ∑ i ∈ Finset.range n, x ^ i / ↑i !) =O[𝓝 0] fun x => x ^ n

full_name: Complex.exp_sub_sum_range_succ_isLittleO_pow
code: lemma exp_sub_sum_range_succ_isLittleO_pow (n : ℕ) :
    (fun x ↦ exp x - ∑ i ∈ Finset.range (n + 1), x ^ i / i !) =o[𝓝 0] (· ^ n) 
goal: (fun x => Complex.exp x - ∑ i ∈ Finset.range (n + 1), x ^ i / ↑i !) =o[𝓝 0] fun x => x ^ n

full_name: Filter.Tendsto.cexp
code: theorem Filter.Tendsto.cexp {l : Filter α} {f : α → ℂ} {z : ℂ} (hf : Tendsto f l (𝓝 z)) :
    Tendsto (fun x => exp (f x)) l (𝓝 (exp z)) 
goal: Filter.Tendsto (fun x => Complex.exp (f x)) l (𝓝 (Complex.exp z))

full_name: ContinuousWithinAt.cexp
code: nonrec
theorem ContinuousWithinAt.cexp (h : ContinuousWithinAt f s x) :
    ContinuousWithinAt (fun y => exp (f y)) s x 
goal: ContinuousWithinAt (fun y => Complex.exp (f y)) s x

full_name: ContinuousAt.cexp
code: @[fun_prop]
nonrec
theorem ContinuousAt.cexp (h : ContinuousAt f x) : ContinuousAt (fun y => exp (f y)) x 
goal: ContinuousAt (fun y => Complex.exp (f y)) x

full_name: ContinuousOn.cexp
code: @[fun_prop]
theorem ContinuousOn.cexp (h : ContinuousOn f s) : ContinuousOn (fun y => exp (f y)) s 
goal: ContinuousOn (fun y => Complex.exp (f y)) s

full_name: Continuous.cexp
code: @[fun_prop]
theorem Continuous.cexp (h : Continuous f) : Continuous fun y => exp (f y) 
goal: Continuous fun y => Complex.exp (f y)

full_name: Real.continuous_exp
code: @[continuity]
theorem continuous_exp : Continuous exp 
goal: Continuous Real.exp

full_name: Real.continuousOn_exp
code: theorem continuousOn_exp {s : Set ℝ} : ContinuousOn exp s 
goal: ContinuousOn Real.exp s

full_name: Real.exp_sub_sum_range_isBigO_pow
code: lemma exp_sub_sum_range_isBigO_pow (n : ℕ) :
    (fun x ↦ exp x - ∑ i ∈ Finset.range n, x ^ i / i !) =O[𝓝 0] (· ^ n) 
goal: (fun x => Real.exp x - ∑ i ∈ Finset.range n, x ^ i / ↑i !) =O[𝓝 0] fun x => x ^ n

full_name: Real.exp_sub_sum_range_succ_isLittleO_pow
code: lemma exp_sub_sum_range_succ_isLittleO_pow (n : ℕ) :
    (fun x ↦ exp x - ∑ i ∈ Finset.range (n + 1), x ^ i / i !) =o[𝓝 0] (· ^ n) 
goal: (fun x => Real.exp x - ∑ i ∈ Finset.range (n + 1), x ^ i / ↑i !) =o[𝓝 0] fun x => x ^ n

full_name: Filter.Tendsto.rexp
code: theorem Filter.Tendsto.rexp {l : Filter α} {f : α → ℝ} {z : ℝ} (hf : Tendsto f l (𝓝 z)) :
    Tendsto (fun x => exp (f x)) l (𝓝 (exp z)) 
goal: Filter.Tendsto (fun x => Real.exp (f x)) l (𝓝 (Real.exp z))

full_name: ContinuousWithinAt.rexp
code: nonrec
theorem ContinuousWithinAt.rexp (h : ContinuousWithinAt f s x) :
    ContinuousWithinAt (fun y ↦ exp (f y)) s x 
goal: ContinuousWithinAt (fun y => Real.exp (f y)) s x

full_name: ContinuousAt.rexp
code: @[fun_prop]
nonrec
theorem ContinuousAt.rexp (h : ContinuousAt f x) : ContinuousAt (fun y ↦ exp (f y)) x 
goal: ContinuousAt (fun y => Real.exp (f y)) x

full_name: ContinuousOn.rexp
code: @[fun_prop]
theorem ContinuousOn.rexp (h : ContinuousOn f s) :
    ContinuousOn (fun y ↦ exp (f y)) s 
goal: ContinuousOn (fun y => Real.exp (f y)) s

full_name: Continuous.rexp
code: @[fun_prop]
theorem Continuous.rexp (h : Continuous f) : Continuous fun y ↦ exp (f y) 
goal: Continuous fun y => Real.exp (f y)

full_name: Real.exp_half
code: theorem exp_half (x : ℝ) : exp (x / 2) = √(exp x) 
goal: Real.exp (x / 2) = √(Real.exp x)

full_name: Real.tendsto_exp_atTop
code: /-- The real exponential function tends to `+∞` at `+∞`. -/
theorem tendsto_exp_atTop : Tendsto exp atTop atTop 
goal: Filter.Tendsto Real.exp Filter.atTop Filter.atTop

full_name: Real.tendsto_exp_neg_atTop_nhds_zero
code: /-- The real exponential function tends to `0` at `-∞` or, equivalently, `exp(-x)` tends to `0`
at `+∞` -/
theorem tendsto_exp_neg_atTop_nhds_zero : Tendsto (fun x => exp (-x)) atTop (𝓝 0) 
goal: Filter.Tendsto (fun x => Real.exp (-x)) Filter.atTop (𝓝 0)

full_name: Real.tendsto_exp_nhds_zero_nhds_one
code: /-- The real exponential function tends to `1` at `0`. -/
theorem tendsto_exp_nhds_zero_nhds_one : Tendsto exp (𝓝 0) (𝓝 1) 
goal: Filter.Tendsto Real.exp (𝓝 0) (𝓝 1)

full_name: Real.tendsto_exp_atBot
code: theorem tendsto_exp_atBot : Tendsto exp atBot (𝓝 0) 
goal: Filter.Tendsto Real.exp Filter.atBot (𝓝 0)

full_name: Real.tendsto_exp_atBot_nhdsWithin
code: theorem tendsto_exp_atBot_nhdsWithin : Tendsto exp atBot (𝓝[>] 0) 
goal: Filter.Tendsto Real.exp Filter.atBot (𝓝[>] 0)

full_name: Real.isBoundedUnder_ge_exp_comp
code: @[simp]
theorem isBoundedUnder_ge_exp_comp (l : Filter α) (f : α → ℝ) :
    IsBoundedUnder (· ≥ ·) l fun x => exp (f x) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l fun x => Real.exp (f x)

full_name: Real.isBoundedUnder_le_exp_comp
code: @[simp]
theorem isBoundedUnder_le_exp_comp {f : α → ℝ} :
    (IsBoundedUnder (· ≤ ·) l fun x => exp (f x)) ↔ IsBoundedUnder (· ≤ ·) l f 
goal: (Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => Real.exp (f x)) ↔
  Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l f

full_name: Real.tendsto_exp_div_pow_atTop
code: /-- The function `exp(x)/x^n` tends to `+∞` at `+∞`, for any natural number `n` -/
theorem tendsto_exp_div_pow_atTop (n : ℕ) : Tendsto (fun x => exp x / x ^ n) atTop atTop 
goal: Filter.Tendsto (fun x => Real.exp x / x ^ n) Filter.atTop Filter.atTop

full_name: Real.tendsto_pow_mul_exp_neg_atTop_nhds_zero
code: /-- The function `x^n * exp(-x)` tends to `0` at `+∞`, for any natural number `n`. -/
theorem tendsto_pow_mul_exp_neg_atTop_nhds_zero (n : ℕ) :
    Tendsto (fun x => x ^ n * exp (-x)) atTop (𝓝 0) 
goal: Filter.Tendsto (fun x => x ^ n * Real.exp (-x)) Filter.atTop (𝓝 0)

full_name: Real.tendsto_mul_exp_add_div_pow_atTop
code: /-- The function `(b * exp x + c) / (x ^ n)` tends to `+∞` at `+∞`, for any natural number
`n` and any real numbers `b` and `c` such that `b` is positive. -/
theorem tendsto_mul_exp_add_div_pow_atTop (b c : ℝ) (n : ℕ) (hb : 0 < b) :
    Tendsto (fun x => (b * exp x + c) / x ^ n) atTop atTop 
goal: Filter.Tendsto (fun x => (b * Real.exp x + c) / x ^ n) Filter.atTop Filter.atTop

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

full_name: Real.expOrderIso
code: /-- `Real.exp` as an order isomorphism between `ℝ` and `(0, +∞)`. -/
def expOrderIso : ℝ ≃o Ioi (0 : ℝ) 
goal: ℝ ≃o ↑(Set.Ioi 0)

full_name: Real.coe_expOrderIso_apply
code: @[simp]
theorem coe_expOrderIso_apply (x : ℝ) : (expOrderIso x : ℝ) = exp x 
goal: ↑(Real.expOrderIso x) = Real.exp x

full_name: Real.coe_comp_expOrderIso
code: @[simp]
theorem coe_comp_expOrderIso : (↑) ∘ expOrderIso = exp 
goal: Subtype.val ∘ ⇑Real.expOrderIso = Real.exp

full_name: Real.range_exp
code: @[simp]
theorem range_exp : range exp = Set.Ioi 0 
goal: Set.range Real.exp = Set.Ioi 0

full_name: Real.map_exp_atTop
code: @[simp]
theorem map_exp_atTop : map exp atTop = atTop 
goal: Filter.map Real.exp Filter.atTop = Filter.atTop

full_name: Real.comap_exp_atTop
code: @[simp]
theorem comap_exp_atTop : comap exp atTop = atTop 
goal: Filter.comap Real.exp Filter.atTop = Filter.atTop

full_name: Real.tendsto_exp_comp_atTop
code: @[simp]
theorem tendsto_exp_comp_atTop {f : α → ℝ} :
    Tendsto (fun x => exp (f x)) l atTop ↔ Tendsto f l atTop 
goal: Filter.Tendsto (fun x => Real.exp (f x)) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop

full_name: Real.tendsto_comp_exp_atTop
code: theorem tendsto_comp_exp_atTop {f : ℝ → α} :
    Tendsto (fun x => f (exp x)) atTop l ↔ Tendsto f atTop l 
goal: Filter.Tendsto (fun x => f (Real.exp x)) Filter.atTop l ↔ Filter.Tendsto f Filter.atTop l

full_name: Real.map_exp_atBot
code: @[simp]
theorem map_exp_atBot : map exp atBot = 𝓝[>] 0 
goal: Filter.map Real.exp Filter.atBot = 𝓝[>] 0

full_name: Real.comap_exp_nhdsWithin_Ioi_zero
code: @[simp]
theorem comap_exp_nhdsWithin_Ioi_zero : comap exp (𝓝[>] 0) = atBot 
goal: Filter.comap Real.exp (𝓝[>] 0) = Filter.atBot

full_name: Real.tendsto_comp_exp_atBot
code: theorem tendsto_comp_exp_atBot {f : ℝ → α} :
    Tendsto (fun x => f (exp x)) atBot l ↔ Tendsto f (𝓝[>] 0) l 
goal: Filter.Tendsto (fun x => f (Real.exp x)) Filter.atBot l ↔ Filter.Tendsto f (𝓝[>] 0) l

full_name: Real.comap_exp_nhds_zero
code: @[simp]
theorem comap_exp_nhds_zero : comap exp (𝓝 0) = atBot 
goal: Filter.comap Real.exp (𝓝 0) = Filter.atBot

full_name: Real.tendsto_exp_comp_nhds_zero
code: @[simp]
theorem tendsto_exp_comp_nhds_zero {f : α → ℝ} :
    Tendsto (fun x => exp (f x)) l (𝓝 0) ↔ Tendsto f l atBot 
goal: Filter.Tendsto (fun x => Real.exp (f x)) l (𝓝 0) ↔ Filter.Tendsto f l Filter.atBot

full_name: Real.openEmbedding_exp
code: theorem openEmbedding_exp : OpenEmbedding exp 
goal: OpenEmbedding Real.exp

full_name: Real.map_exp_nhds
code: @[simp]
theorem map_exp_nhds (x : ℝ) : map exp (𝓝 x) = 𝓝 (exp x) 
goal: Filter.map Real.exp (𝓝 x) = 𝓝 (Real.exp x)

full_name: Real.comap_exp_nhds_exp
code: @[simp]
theorem comap_exp_nhds_exp (x : ℝ) : comap exp (𝓝 (exp x)) = 𝓝 x 
goal: Filter.comap Real.exp (𝓝 (Real.exp x)) = 𝓝 x

full_name: Real.isLittleO_pow_exp_atTop
code: theorem isLittleO_pow_exp_atTop {n : ℕ} : (fun x : ℝ => x ^ n) =o[atTop] Real.exp 
goal: (fun x => x ^ n) =o[Filter.atTop] Real.exp

full_name: Real.isBigO_exp_comp_exp_comp
code: @[simp]
theorem isBigO_exp_comp_exp_comp {f g : α → ℝ} :
    ((fun x => exp (f x)) =O[l] fun x => exp (g x)) ↔ IsBoundedUnder (· ≤ ·) l (f - g) 
goal: ((fun x => Real.exp (f x)) =O[l] fun x => Real.exp (g x)) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (f - g)

full_name: Real.isTheta_exp_comp_exp_comp
code: @[simp]
theorem isTheta_exp_comp_exp_comp {f g : α → ℝ} :
    ((fun x => exp (f x)) =Θ[l] fun x => exp (g x)) ↔
      IsBoundedUnder (· ≤ ·) l fun x => |f x - g x| 
goal: ((fun x => Real.exp (f x)) =Θ[l] fun x => Real.exp (g x)) ↔
  Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => |f x - g x|

full_name: Real.isLittleO_exp_comp_exp_comp
code: @[simp]
theorem isLittleO_exp_comp_exp_comp {f g : α → ℝ} :
    ((fun x => exp (f x)) =o[l] fun x => exp (g x)) ↔ Tendsto (fun x => g x - f x) l atTop 
goal: ((fun x => Real.exp (f x)) =o[l] fun x => Real.exp (g x)) ↔ Filter.Tendsto (fun x => g x - f x) l Filter.atTop

full_name: Real.isLittleO_one_exp_comp
code: theorem isLittleO_one_exp_comp {f : α → ℝ} :
    ((fun _ => 1 : α → ℝ) =o[l] fun x => exp (f x)) ↔ Tendsto f l atTop 
goal: ((fun x => 1) =o[l] fun x => Real.exp (f x)) ↔ Filter.Tendsto f l Filter.atTop

full_name: Real.isBigO_one_exp_comp
code: /-- `Real.exp (f x)` is bounded away from zero along a filter if and only if this filter is bounded
from below under `f`. -/
@[simp]
theorem isBigO_one_exp_comp {f : α → ℝ} :
    ((fun _ => 1 : α → ℝ) =O[l] fun x => exp (f x)) ↔ IsBoundedUnder (· ≥ ·) l f 
goal: ((fun x => 1) =O[l] fun x => Real.exp (f x)) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l f

full_name: Real.isBigO_exp_comp_one
code: /-- `Real.exp (f x)` is bounded away from zero along a filter if and only if this filter is bounded
from below under `f`. -/
theorem isBigO_exp_comp_one {f : α → ℝ} :
    (fun x => exp (f x)) =O[l] (fun _ => 1 : α → ℝ) ↔ IsBoundedUnder (· ≤ ·) l f 
goal: ((fun x => Real.exp (f x)) =O[l] fun x => 1) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l f

full_name: Real.isTheta_exp_comp_one
code: /-- `Real.exp (f x)` is bounded away from zero and infinity along a filter `l` if and only if
`|f x|` is bounded from above along this filter. -/
@[simp]
theorem isTheta_exp_comp_one {f : α → ℝ} :
    (fun x => exp (f x)) =Θ[l] (fun _ => 1 : α → ℝ) ↔ IsBoundedUnder (· ≤ ·) l fun x => |f x| 
goal: ((fun x => Real.exp (f x)) =Θ[l] fun x => 1) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => |f x|

full_name: Real.summable_exp_nat_mul_iff
code: lemma summable_exp_nat_mul_iff {a : ℝ} :
    Summable (fun n : ℕ ↦ exp (n * a)) ↔ a < 0 
goal: (Summable fun n => Real.exp (↑n * a)) ↔ a < 0

full_name: Real.summable_exp_neg_nat
code: lemma summable_exp_neg_nat : Summable fun n : ℕ ↦ exp (-n) 
goal: Summable fun n => Real.exp (-↑n)

full_name: Real.summable_pow_mul_exp_neg_nat_mul
code: lemma summable_pow_mul_exp_neg_nat_mul (k : ℕ) {r : ℝ} (hr : 0 < r) :
    Summable fun n : ℕ ↦ n ^ k * exp (-r * n) 
goal: Summable fun n => ↑n ^ k * Real.exp (-r * ↑n)

full_name: HasSum.rexp
code: /-- If `f` has sum `a`, then `exp ∘ f` has product `exp a`. -/
lemma HasSum.rexp {ι} {f : ι → ℝ} {a : ℝ} (h : HasSum f a) : HasProd (rexp ∘ f) (rexp a) 
goal: HasProd (Real.exp ∘ f) (Real.exp a)

full_name: Complex.comap_exp_cobounded
code: @[simp]
theorem comap_exp_cobounded : comap exp (cobounded ℂ) = comap re atTop 
goal: Filter.comap Complex.exp (Bornology.cobounded ℂ) = Filter.comap Complex.re Filter.atTop

full_name: Complex.comap_exp_nhds_zero
code: @[simp]
theorem comap_exp_nhds_zero : comap exp (𝓝 0) = comap re atBot 
goal: Filter.comap Complex.exp (𝓝 0) = Filter.comap Complex.re Filter.atBot

full_name: Complex.comap_exp_nhdsWithin_zero
code: theorem comap_exp_nhdsWithin_zero : comap exp (𝓝[≠] 0) = comap re atBot 
goal: Filter.comap Complex.exp (𝓝[≠] 0) = Filter.comap Complex.re Filter.atBot

full_name: Complex.tendsto_exp_nhds_zero_iff
code: theorem tendsto_exp_nhds_zero_iff {α : Type*} {l : Filter α} {f : α → ℂ} :
    Tendsto (fun x => exp (f x)) l (𝓝 0) ↔ Tendsto (fun x => re (f x)) l atBot 
goal: Filter.Tendsto (fun x => Complex.exp (f x)) l (𝓝 0) ↔ Filter.Tendsto (fun x => (f x).re) l Filter.atBot

full_name: Complex.tendsto_exp_comap_re_atTop
code: /-- `Complex.abs (Complex.exp z) → ∞` as `Complex.re z → ∞`. -/
theorem tendsto_exp_comap_re_atTop : Tendsto exp (comap re atTop) (cobounded ℂ) 
goal: Filter.Tendsto Complex.exp (Filter.comap Complex.re Filter.atTop) (Bornology.cobounded ℂ)

full_name: Complex.tendsto_exp_comap_re_atBot
code: /-- `Complex.exp z → 0` as `Complex.re z → -∞`. -/
theorem tendsto_exp_comap_re_atBot : Tendsto exp (comap re atBot) (𝓝 0) 
goal: Filter.Tendsto Complex.exp (Filter.comap Complex.re Filter.atBot) (𝓝 0)

full_name: Complex.tendsto_exp_comap_re_atBot_nhdsWithin
code: theorem tendsto_exp_comap_re_atBot_nhdsWithin : Tendsto exp (comap re atBot) (𝓝[≠] 0) 
goal: Filter.Tendsto Complex.exp (Filter.comap Complex.re Filter.atBot) (𝓝[≠] 0)

full_name: HasSum.cexp
code: /-- If `f` has sum `a`, then `exp ∘ f` has product `exp a`. -/
lemma HasSum.cexp {ι : Type*} {f : ι → ℂ} {a : ℂ} (h : HasSum f a) : HasProd (cexp ∘ f) (cexp a) 
goal: HasProd (Complex.exp ∘ f) (Complex.exp a)