ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Real.tendsto_mul_exp_add_div_pow_atTop
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 
Arguments: (b c : ℝ) (n : ℕ) (hb : 0 < b)
Goal: Filter.Tendsto (fun x => (b * Real.exp x + c) / x ^ n) Filter.atTop Filter.atTop
-- Real.tendsto_div_pow_mul_exp_add_atTop
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) 
Arguments: (b c : ℝ) (n : ℕ) (hb : 0 ≠ b)
Goal: Filter.Tendsto (fun x => x ^ n / (b * Real.exp x + c)) Filter.atTop (𝓝 0)
-- Real.coe_expOrderIso_apply
@[simp]
theorem coe_expOrderIso_apply (x : ℝ) : (expOrderIso x : ℝ) = exp x 
Arguments: (x : ℝ)
Goal: ↑(Real.expOrderIso x) = Real.exp x
-- Real.coe_comp_expOrderIso
@[simp]
theorem coe_comp_expOrderIso : (↑) ∘ expOrderIso = exp 
Goal: Subtype.val ∘ ⇑Real.expOrderIso = Real.exp
-- Real.range_exp
@[simp]
theorem range_exp : range exp = Set.Ioi 0 
Goal: Set.range Real.exp = Set.Ioi 0
-- Real.map_exp_atTop
@[simp]
theorem map_exp_atTop : map exp atTop = atTop 
Goal: Filter.map Real.exp Filter.atTop = Filter.atTop
-- Real.comap_exp_atTop
@[simp]
theorem comap_exp_atTop : comap exp atTop = atTop 
Goal: Filter.comap Real.exp Filter.atTop = Filter.atTop
-- Real.tendsto_exp_comp_atTop
@[simp]
theorem tendsto_exp_comp_atTop {f : α → ℝ} :
    Tendsto (fun x => exp (f x)) l atTop ↔ Tendsto f l atTop 
Arguments: {α : Type u_1} {l : Filter α} {f : α → ℝ}
Goal: Filter.Tendsto (fun x => Real.exp (f x)) l Filter.atTop ↔ Filter.Tendsto f l Filter.atTop
-- Real.tendsto_comp_exp_atTop
theorem tendsto_comp_exp_atTop {f : ℝ → α} :
    Tendsto (fun x => f (exp x)) atTop l ↔ Tendsto f atTop l 
Arguments: {α : Type u_1} {l : Filter α} {f : ℝ → α}
Goal: Filter.Tendsto (fun x => f (Real.exp x)) Filter.atTop l ↔ Filter.Tendsto f Filter.atTop l
-- Real.map_exp_atBot
@[simp]
theorem map_exp_atBot : map exp atBot = 𝓝[>] 0 
Goal: Filter.map Real.exp Filter.atBot = 𝓝[>] 0
-- Real.comap_exp_nhdsWithin_Ioi_zero
@[simp]
theorem comap_exp_nhdsWithin_Ioi_zero : comap exp (𝓝[>] 0) = atBot 
Goal: Filter.comap Real.exp (𝓝[>] 0) = Filter.atBot
-- Real.tendsto_comp_exp_atBot
theorem tendsto_comp_exp_atBot {f : ℝ → α} :
    Tendsto (fun x => f (exp x)) atBot l ↔ Tendsto f (𝓝[>] 0) l 
Arguments: {α : Type u_1} {l : Filter α} {f : ℝ → α}
Goal: Filter.Tendsto (fun x => f (Real.exp x)) Filter.atBot l ↔ Filter.Tendsto f (𝓝[>] 0) l
-- Real.comap_exp_nhds_zero
@[simp]
theorem comap_exp_nhds_zero : comap exp (𝓝 0) = atBot 
Goal: Filter.comap Real.exp (𝓝 0) = Filter.atBot
-- Real.tendsto_exp_comp_nhds_zero
@[simp]
theorem tendsto_exp_comp_nhds_zero {f : α → ℝ} :
    Tendsto (fun x => exp (f x)) l (𝓝 0) ↔ Tendsto f l atBot 
Arguments: {α : Type u_1} {l : Filter α} {f : α → ℝ}
Goal: Filter.Tendsto (fun x => Real.exp (f x)) l (𝓝 0) ↔ Filter.Tendsto f l Filter.atBot
-- Real.openEmbedding_exp
theorem openEmbedding_exp : OpenEmbedding exp 
Goal: OpenEmbedding Real.exp
-- Real.map_exp_nhds
@[simp]
theorem map_exp_nhds (x : ℝ) : map exp (𝓝 x) = 𝓝 (exp x) 
Arguments: (x : ℝ)
Goal: Filter.map Real.exp (𝓝 x) = 𝓝 (Real.exp x)
-- Real.comap_exp_nhds_exp
@[simp]
theorem comap_exp_nhds_exp (x : ℝ) : comap exp (𝓝 (exp x)) = 𝓝 x 
Arguments: (x : ℝ)
Goal: Filter.comap Real.exp (𝓝 (Real.exp x)) = 𝓝 x
-- Real.isLittleO_pow_exp_atTop
theorem isLittleO_pow_exp_atTop {n : ℕ} : (fun x : ℝ => x ^ n) =o[atTop] Real.exp 
Arguments: {n : ℕ}
Goal: (fun x => x ^ n) =o[Filter.atTop] Real.exp
-- Real.isBigO_exp_comp_exp_comp
@[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) 
Arguments: {α : Type u_1} {l : Filter α} {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)
-- Real.isTheta_exp_comp_exp_comp
@[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| 
Arguments: {α : Type u_1} {l : Filter α} {f g : α → ℝ}
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|
-- Real.isLittleO_exp_comp_exp_comp
@[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 
Arguments: {α : Type u_1} {l : Filter α} {f g : α → ℝ}
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
-- Real.isLittleO_one_exp_comp
theorem isLittleO_one_exp_comp {f : α → ℝ} :
    ((fun _ => 1 : α → ℝ) =o[l] fun x => exp (f x)) ↔ Tendsto f l atTop 
Arguments: {α : Type u_1} {l : Filter α} {f : α → ℝ}
Goal: ((fun x => 1) =o[l] fun x => Real.exp (f x)) ↔ Filter.Tendsto f l Filter.atTop
-- Real.isBigO_one_exp_comp
@[simp]
theorem isBigO_one_exp_comp {f : α → ℝ} :
    ((fun _ => 1 : α → ℝ) =O[l] fun x => exp (f x)) ↔ IsBoundedUnder (· ≥ ·) l f 
Arguments: {α : Type u_1} {l : Filter α} {f : α → ℝ}
Goal: ((fun x => 1) =O[l] fun x => Real.exp (f x)) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≥ x_1) l f
-- Real.isBigO_exp_comp_one
theorem isBigO_exp_comp_one {f : α → ℝ} :
    (fun x => exp (f x)) =O[l] (fun _ => 1 : α → ℝ) ↔ IsBoundedUnder (· ≤ ·) l f 
Arguments: {α : Type u_1} {l : Filter α} {f : α → ℝ}
Goal: ((fun x => Real.exp (f x)) =O[l] fun x => 1) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l f
-- Real.isTheta_exp_comp_one
@[simp]
theorem isTheta_exp_comp_one {f : α → ℝ} :
    (fun x => exp (f x)) =Θ[l] (fun _ => 1 : α → ℝ) ↔ IsBoundedUnder (· ≤ ·) l fun x => |f x| 
Arguments: {α : Type u_1} {l : Filter α} {f : α → ℝ}
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|
-- Real.summable_exp_nat_mul_iff
lemma summable_exp_nat_mul_iff {a : ℝ} :
    Summable (fun n : ℕ ↦ exp (n * a)) ↔ a < 0 
Arguments: {a : ℝ}
Goal: (Summable fun n => Real.exp (↑n * a)) ↔ a < 0
-- Real.summable_exp_neg_nat
lemma summable_exp_neg_nat : Summable fun n : ℕ ↦ exp (-n) 
Goal: Summable fun n => Real.exp (-↑n)
-- Real.summable_pow_mul_exp_neg_nat_mul
lemma summable_pow_mul_exp_neg_nat_mul (k : ℕ) {r : ℝ} (hr : 0 < r) :
    Summable fun n : ℕ ↦ n ^ k * exp (-r * n) 
Arguments: (k : ℕ) {r : ℝ} (hr : 0 < r)
Goal: Summable fun n => ↑n ^ k * Real.exp (-r * ↑n)
-- HasSum.rexp
lemma HasSum.rexp {ι} {f : ι → ℝ} {a : ℝ} (h : HasSum f a) : HasProd (rexp ∘ f) (rexp a) 
Arguments: {ι : Type u_1} {f : ι → ℝ} {a : ℝ} (h : HasSum f a)
Goal: HasProd (Real.exp ∘ f) (Real.exp a)
-- Complex.comap_exp_cobounded
@[simp]
theorem comap_exp_cobounded : comap exp (cobounded ℂ) = comap re atTop 
Goal: Filter.comap Complex.exp (Bornology.cobounded ℂ) = Filter.comap Complex.re Filter.atTop
-- Complex.comap_exp_nhds_zero
@[simp]
theorem comap_exp_nhds_zero : comap exp (𝓝 0) = comap re atBot 
Goal: Filter.comap Complex.exp (𝓝 0) = Filter.comap Complex.re Filter.atBot
-- Complex.comap_exp_nhdsWithin_zero
theorem comap_exp_nhdsWithin_zero : comap exp (𝓝[≠] 0) = comap re atBot 
Goal: Filter.comap Complex.exp (𝓝[≠] 0) = Filter.comap Complex.re Filter.atBot
-- Complex.tendsto_exp_nhds_zero_iff
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 
Arguments: {α : Type u_1} {l : Filter α} {f : α → ℂ}
Goal: Filter.Tendsto (fun x => Complex.exp (f x)) l (𝓝 0) ↔ Filter.Tendsto (fun x => (f x).re) l Filter.atBot
-- Complex.tendsto_exp_comap_re_atTop
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 ℂ)
-- Complex.tendsto_exp_comap_re_atBot
theorem tendsto_exp_comap_re_atBot : Tendsto exp (comap re atBot) (𝓝 0) 
Goal: Filter.Tendsto Complex.exp (Filter.comap Complex.re Filter.atBot) (𝓝 0)
-- Complex.tendsto_exp_comap_re_atBot_nhdsWithin
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)
-- HasSum.cexp
lemma HasSum.cexp {ι : Type*} {f : ι → ℂ} {a : ℂ} (h : HasSum f a) : HasProd (cexp ∘ f) (cexp a) 
Arguments: {ι : Type u_1} {f : ι → ℂ} {a : ℂ} (h : HasSum f a)
Goal: HasProd (Complex.exp ∘ f) (Complex.exp a)
-- Complex.Gammaℝ_def
lemma Gammaℝ_def (s : ℂ) : Gammaℝ s = π ^ (-s / 2) * Gamma (s / 2) 
Arguments: (s : ℂ)
Goal: s.Gammaℝ = ↑π ^ (-s / 2) * Complex.Gamma (s / 2)
-- Complex.Gammaℂ_def
lemma Gammaℂ_def (s : ℂ) : Gammaℂ s = 2 * (2 * π) ^ (-s) * Gamma s 
Arguments: (s : ℂ)
Goal: s.Gammaℂ = 2 * (2 * ↑π) ^ (-s) * Complex.Gamma s
-- Complex.Gammaℝ_add_two
lemma Gammaℝ_add_two {s : ℂ} (hs : s ≠ 0) : Gammaℝ (s + 2) = Gammaℝ s * s / 2 / π 
Arguments: {s : ℂ} (hs : s ≠ 0)
Goal: (s + 2).Gammaℝ = s.Gammaℝ * s / 2 / ↑π
-- Complex.Gammaℂ_add_one
lemma Gammaℂ_add_one {s : ℂ} (hs : s ≠ 0) : Gammaℂ (s + 1) = Gammaℂ s * s / 2 / π 
Arguments: {s : ℂ} (hs : s ≠ 0)
Goal: (s + 1).Gammaℂ = s.Gammaℂ * s / 2 / ↑π
-- Complex.Gammaℝ_ne_zero_of_re_pos
lemma Gammaℝ_ne_zero_of_re_pos {s : ℂ} (hs : 0 < re s) : Gammaℝ s ≠ 0 
Arguments: {s : ℂ} (hs : 0 < s.re)
Goal: s.Gammaℝ ≠ 0
-- Complex.Gammaℝ_eq_zero_iff
lemma Gammaℝ_eq_zero_iff {s : ℂ} : Gammaℝ s = 0 ↔ ∃ n : ℕ, s = -(2 * n) 
Arguments: {s : ℂ}
Goal: s.Gammaℝ = 0 ↔ ∃ n, s = -(2 * ↑n)
-- Complex.Gammaℝ_one
@[simp]
lemma Gammaℝ_one : Gammaℝ 1 = 1 
Goal: Complex.Gammaℝ 1 = 1
-- Complex.Gammaℂ_one
@[simp]
lemma Gammaℂ_one : Gammaℂ 1 = 1 / π 
Goal: Complex.Gammaℂ 1 = 1 / ↑π
-- Complex.differentiable_Gammaℝ_inv
lemma differentiable_Gammaℝ_inv : Differentiable ℂ (fun s ↦ (Gammaℝ s)⁻¹) 
Goal: Differentiable ℂ fun s => s.Gammaℝ⁻¹
-- Complex.Gammaℝ_residue_zero
lemma Gammaℝ_residue_zero : Tendsto (fun s ↦ s * Gammaℝ s) (𝓝[≠] 0) (𝓝 2) 
Goal: Filter.Tendsto (fun s => s * s.Gammaℝ) (𝓝[≠] 0) (𝓝 2)
-- Complex.Gammaℝ_mul_Gammaℝ_add_one
lemma Gammaℝ_mul_Gammaℝ_add_one (s : ℂ) : Gammaℝ s * Gammaℝ (s + 1) = Gammaℂ s 
Arguments: (s : ℂ)
Goal: s.Gammaℝ * (s + 1).Gammaℝ = s.Gammaℂ
-- Complex.Gammaℝ_one_sub_mul_Gammaℝ_one_add
lemma Gammaℝ_one_sub_mul_Gammaℝ_one_add (s : ℂ) :
    Gammaℝ (1 - s) * Gammaℝ (1 + s) = (cos (π * s / 2))⁻¹ 
Arguments: (s : ℂ)
Goal: (1 - s).Gammaℝ * (1 + s).Gammaℝ = (Complex.cos (↑π * s / 2))⁻¹
-- Complex.Gammaℝ_div_Gammaℝ_one_sub
lemma Gammaℝ_div_Gammaℝ_one_sub {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -(2 * n + 1)) :
    Gammaℝ s / Gammaℝ (1 - s) = Gammaℂ s * cos (π * s / 2) 
Arguments: {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -(2 * ↑n + 1))
Goal: s.Gammaℝ / (1 - s).Gammaℝ = s.Gammaℂ * Complex.cos (↑π * s / 2)
-- Complex.inv_Gammaℝ_one_sub
lemma inv_Gammaℝ_one_sub {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -n) :
    (Gammaℝ (1 - s))⁻¹ = Gammaℂ s * cos (π * s / 2) * (Gammaℝ s)⁻¹ 
Arguments: {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -↑n)
Goal: (1 - s).Gammaℝ⁻¹ = s.Gammaℂ * Complex.cos (↑π * s / 2) * s.Gammaℝ⁻¹
-- Complex.inv_Gammaℝ_two_sub
lemma inv_Gammaℝ_two_sub {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -n) :
    (Gammaℝ (2 - s))⁻¹ = Gammaℂ s * sin (π * s / 2) * (Gammaℝ (s + 1))⁻¹ 
Arguments: {s : ℂ} (hs : ∀ (n : ℕ), s ≠ -↑n)
Goal: (2 - s).Gammaℝ⁻¹ = s.Gammaℂ * Complex.sin (↑π * s / 2) * (s + 1).Gammaℝ⁻¹
-- integrableOn_exp_Iic
theorem integrableOn_exp_Iic (c : ℝ) : IntegrableOn exp (Iic c) 
Arguments: (c : ℝ)
Goal: MeasureTheory.IntegrableOn rexp (Set.Iic c) MeasureTheory.volume
-- integral_exp_Iic
theorem integral_exp_Iic (c : ℝ) : ∫ x : ℝ in Iic c, exp x = exp c 
Arguments: (c : ℝ)
Goal: ∫ (x : ℝ) in Set.Iic c, rexp x = rexp c
-- integral_exp_Iic_zero
theorem integral_exp_Iic_zero : ∫ x : ℝ in Iic 0, exp x = 1 
Goal: ∫ (x : ℝ) in Set.Iic 0, rexp x = 1
-- integral_exp_neg_Ioi
theorem integral_exp_neg_Ioi (c : ℝ) : (∫ x : ℝ in Ioi c, exp (-x)) = exp (-c) 
Arguments: (c : ℝ)
Goal: ∫ (x : ℝ) in Set.Ioi c, rexp (-x) = rexp (-c)
-- integral_exp_neg_Ioi_zero
theorem integral_exp_neg_Ioi_zero : (∫ x : ℝ in Ioi 0, exp (-x)) = 1 
Goal: ∫ (x : ℝ) in Set.Ioi 0, rexp (-x) = 1
-- integrableOn_Ioi_rpow_of_lt
theorem integrableOn_Ioi_rpow_of_lt {a : ℝ} (ha : a < -1) {c : ℝ} (hc : 0 < c) :
    IntegrableOn (fun t : ℝ => t ^ a) (Ioi c) 
Arguments: {a : ℝ} (ha : a < -1) {c : ℝ} (hc : 0 < c)
Goal: MeasureTheory.IntegrableOn (fun t => t ^ a) (Set.Ioi c) MeasureTheory.volume
-- integrableOn_Ioi_rpow_iff
theorem integrableOn_Ioi_rpow_iff {s t : ℝ} (ht : 0 < t) :
    IntegrableOn (fun x ↦ x ^ s) (Ioi t) ↔ s < -1 
Arguments: {s t : ℝ} (ht : 0 < t)
Goal: MeasureTheory.IntegrableOn (fun x => x ^ s) (Set.Ioi t) MeasureTheory.volume ↔ s < -1
-- not_integrableOn_Ioi_rpow
theorem not_integrableOn_Ioi_rpow (s : ℝ) : ¬ IntegrableOn (fun x ↦ x ^ s) (Ioi (0 : ℝ)) 
Arguments: (s : ℝ)
Goal: ¬MeasureTheory.IntegrableOn (fun x => x ^ s) (Set.Ioi 0) MeasureTheory.volume
-- setIntegral_Ioi_zero_rpow
theorem setIntegral_Ioi_zero_rpow (s : ℝ) : ∫ x in Ioi (0 : ℝ), x ^ s = 0 
Arguments: (s : ℝ)
Goal: ∫ (x : ℝ) in Set.Ioi 0, x ^ s = 0
-- integral_Ioi_rpow_of_lt
theorem integral_Ioi_rpow_of_lt {a : ℝ} (ha : a < -1) {c : ℝ} (hc : 0 < c) :
    ∫ t : ℝ in Ioi c, t ^ a = -c ^ (a + 1) / (a + 1) 
Arguments: {a : ℝ} (ha : a < -1) {c : ℝ} (hc : 0 < c)
Goal: ∫ (t : ℝ) in Set.Ioi c, t ^ a = -c ^ (a + 1) / (a + 1)
-- integrableOn_Ioi_cpow_of_lt
theorem integrableOn_Ioi_cpow_of_lt {a : ℂ} (ha : a.re < -1) {c : ℝ} (hc : 0 < c) :
    IntegrableOn (fun t : ℝ => (t : ℂ) ^ a) (Ioi c) 
Arguments: {a : ℂ} (ha : a.re < -1) {c : ℝ} (hc : 0 < c)
Goal: MeasureTheory.IntegrableOn (fun t => ↑t ^ a) (Set.Ioi c) MeasureTheory.volume
-- integrableOn_Ioi_cpow_iff
theorem integrableOn_Ioi_cpow_iff {s : ℂ} {t : ℝ} (ht : 0 < t) :
    IntegrableOn (fun x : ℝ ↦ (x : ℂ) ^ s) (Ioi t) ↔ s.re < -1 
Arguments: {s : ℂ} {t : ℝ} (ht : 0 < t)
Goal: MeasureTheory.IntegrableOn (fun x => ↑x ^ s) (Set.Ioi t) MeasureTheory.volume ↔ s.re < -1
-- not_integrableOn_Ioi_cpow
theorem not_integrableOn_Ioi_cpow (s : ℂ) :
    ¬ IntegrableOn (fun x : ℝ ↦ (x : ℂ) ^ s) (Ioi (0 : ℝ)) 
Arguments: (s : ℂ)
Goal: ¬MeasureTheory.IntegrableOn (fun x => ↑x ^ s) (Set.Ioi 0) MeasureTheory.volume
-- setIntegral_Ioi_zero_cpow
theorem setIntegral_Ioi_zero_cpow (s : ℂ) : ∫ x in Ioi (0 : ℝ), (x : ℂ) ^ s = 0 
Arguments: (s : ℂ)
Goal: ∫ (x : ℝ) in Set.Ioi 0, ↑x ^ s = 0
-- integral_Ioi_cpow_of_lt
theorem integral_Ioi_cpow_of_lt {a : ℂ} (ha : a.re < -1) {c : ℝ} (hc : 0 < c) :
    (∫ t : ℝ in Ioi c, (t : ℂ) ^ a) = -(c : ℂ) ^ (a + 1) / (a + 1) 
Arguments: {a : ℂ} (ha : a.re < -1) {c : ℝ} (hc : 0 < c)
Goal: ∫ (t : ℝ) in Set.Ioi c, ↑t ^ a = -↑c ^ (a + 1) / (a + 1)
-- integrable_inv_one_add_sq
theorem integrable_inv_one_add_sq : Integrable fun (x : ℝ) ↦ (1 + x ^ 2)⁻¹ 
Goal: MeasureTheory.Integrable (fun x => (1 + x ^ 2)⁻¹) MeasureTheory.volume
-- integral_Iic_inv_one_add_sq
@[simp]
theorem integral_Iic_inv_one_add_sq {i : ℝ} :
    ∫ (x : ℝ) in Set.Iic i, (1 + x ^ 2)⁻¹ = arctan i + (π / 2) 
Arguments: {i : ℝ}
Goal: ∫ (x : ℝ) in Set.Iic i, (1 + x ^ 2)⁻¹ = Real.arctan i + π / 2
-- integral_Ioi_inv_one_add_sq
@[simp]
theorem integral_Ioi_inv_one_add_sq {i : ℝ} :
    ∫ (x : ℝ) in Set.Ioi i, (1 + x ^ 2)⁻¹ = (π / 2) - arctan i 
Arguments: {i : ℝ}
Goal: ∫ (x : ℝ) in Set.Ioi i, (1 + x ^ 2)⁻¹ = π / 2 - Real.arctan i
-- integral_univ_inv_one_add_sq
@[simp]
theorem integral_univ_inv_one_add_sq : ∫ (x : ℝ), (1 + x ^ 2)⁻¹ = π 
Goal: ∫ (x : ℝ), (1 + x ^ 2)⁻¹ = π
-- sqrt_one_add_norm_sq_le
theorem sqrt_one_add_norm_sq_le (x : E) : √((1 : ℝ) + ‖x‖ ^ 2) ≤ 1 + ‖x‖ 
Arguments: {E : Type u_1} [NormedAddCommGroup E] (x : E)
Goal: √(1 + ‖x‖ ^ 2) ≤ 1 + ‖x‖
-- one_add_norm_le_sqrt_two_mul_sqrt
theorem one_add_norm_le_sqrt_two_mul_sqrt (x : E) :
    (1 : ℝ) + ‖x‖ ≤ √2 * √(1 + ‖x‖ ^ 2) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] (x : E)
Goal: 1 + ‖x‖ ≤ √2 * √(1 + ‖x‖ ^ 2)
-- rpow_neg_one_add_norm_sq_le
theorem rpow_neg_one_add_norm_sq_le {r : ℝ} (x : E) (hr : 0 < r) :
    ((1 : ℝ) + ‖x‖ ^ 2) ^ (-r / 2) ≤ (2 : ℝ) ^ (r / 2) * (1 + ‖x‖) ^ (-r) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] {r : ℝ} (x : E) (hr : 0 < r)
Goal: (1 + ‖x‖ ^ 2) ^ (-r / 2) ≤ 2 ^ (r / 2) * (1 + ‖x‖) ^ (-r)
-- le_rpow_one_add_norm_iff_norm_le
theorem le_rpow_one_add_norm_iff_norm_le {r t : ℝ} (hr : 0 < r) (ht : 0 < t) (x : E) :
    t ≤ (1 + ‖x‖) ^ (-r) ↔ ‖x‖ ≤ t ^ (-r⁻¹) - 1 
Arguments: {E : Type u_1} [NormedAddCommGroup E] {r t : ℝ} (hr : 0 < r) (ht : 0 < t) (x : E)
Goal: t ≤ (1 + ‖x‖) ^ (-r) ↔ ‖x‖ ≤ t ^ (-r⁻¹) - 1
-- closedBall_rpow_sub_one_eq_empty_aux
theorem closedBall_rpow_sub_one_eq_empty_aux {r t : ℝ} (hr : 0 < r) (ht : 1 < t) :
    Metric.closedBall (0 : E) (t ^ (-r⁻¹) - 1) = ∅ 
Arguments: (E : Type u_1) [NormedAddCommGroup E] {r t : ℝ} (hr : 0 < r) (ht : 1 < t)
Goal: Metric.closedBall 0 (t ^ (-r⁻¹) - 1) = ∅
-- finite_integral_rpow_sub_one_pow_aux
theorem finite_integral_rpow_sub_one_pow_aux {r : ℝ} (n : ℕ) (hnr : (n : ℝ) < r) :
    (∫⁻ x : ℝ in Ioc 0 1, ENNReal.ofReal ((x ^ (-r⁻¹) - 1) ^ n)) < ∞ 
Arguments: {r : ℝ} (n : ℕ) (hnr : ↑n < r)
Goal: ∫⁻ (x : ℝ) in Set.Ioc 0 1, ENNReal.ofReal ((x ^ (-r⁻¹) - 1) ^ n) < ⊤
-- finite_integral_one_add_norm
theorem finite_integral_one_add_norm {r : ℝ} (hnr : (finrank ℝ E : ℝ) < r) :
    (∫⁻ x : E, ENNReal.ofReal ((1 + ‖x‖) ^ (-r)) ∂μ) < ∞ 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] {μ : MeasureTheory.Measure E} [μ.IsAddHaarMeasure] {r : ℝ} (hnr : ↑(FiniteDimensional.finrank ℝ E) < r)
Goal: ∫⁻ (x : E), ENNReal.ofReal ((1 + ‖x‖) ^ (-r)) ∂μ < ⊤
-- integrable_one_add_norm
theorem integrable_one_add_norm {r : ℝ} (hnr : (finrank ℝ E : ℝ) < r) :
    Integrable (fun x ↦ (1 + ‖x‖) ^ (-r)) μ 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] {μ : MeasureTheory.Measure E} [μ.IsAddHaarMeasure] {r : ℝ} (hnr : ↑(FiniteDimensional.finrank ℝ E) < r)
Goal: MeasureTheory.Integrable (fun x => (1 + ‖x‖) ^ (-r)) μ
-- integrable_rpow_neg_one_add_norm_sq
theorem integrable_rpow_neg_one_add_norm_sq {r : ℝ} (hnr : (finrank ℝ E : ℝ) < r) :
    Integrable (fun x ↦ ((1 : ℝ) + ‖x‖ ^ 2) ^ (-r / 2)) μ 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E] [MeasurableSpace E] [BorelSpace E] {μ : MeasureTheory.Measure E} [μ.IsAddHaarMeasure] {r : ℝ} (hnr : ↑(FiniteDimensional.finrank ℝ E) < r)
Goal: MeasureTheory.Integrable (fun x => (1 + ‖x‖ ^ 2) ^ (-r / 2)) μ
-- Complex.hasStrictDerivAt_sin
theorem hasStrictDerivAt_sin (x : ℂ) : HasStrictDerivAt sin (cos x) x 
Arguments: (x : ℂ)
Goal: HasStrictDerivAt Complex.sin (Complex.cos x) x
-- Complex.hasDerivAt_sin
theorem hasDerivAt_sin (x : ℂ) : HasDerivAt sin (cos x) x 
Arguments: (x : ℂ)
Goal: HasDerivAt Complex.sin (Complex.cos x) x
-- Complex.contDiff_sin
theorem contDiff_sin {n} : ContDiff ℂ n sin 
Arguments: {n : ℕ∞}
Goal: ContDiff ℂ n Complex.sin
-- Complex.differentiable_sin
theorem differentiable_sin : Differentiable ℂ sin 
Goal: Differentiable ℂ Complex.sin
-- Complex.differentiableAt_sin
theorem differentiableAt_sin {x : ℂ} : DifferentiableAt ℂ sin x 
Arguments: {x : ℂ}
Goal: DifferentiableAt ℂ Complex.sin x
-- Complex.deriv_sin
@[simp]
theorem deriv_sin : deriv sin = cos 
Goal: deriv Complex.sin = Complex.cos
-- Complex.hasStrictDerivAt_cos
theorem hasStrictDerivAt_cos (x : ℂ) : HasStrictDerivAt cos (-sin x) x 
Arguments: (x : ℂ)
Goal: HasStrictDerivAt Complex.cos (-Complex.sin x) x
-- Complex.hasDerivAt_cos
theorem hasDerivAt_cos (x : ℂ) : HasDerivAt cos (-sin x) x 
Arguments: (x : ℂ)
Goal: HasDerivAt Complex.cos (-Complex.sin x) x
-- Complex.contDiff_cos
theorem contDiff_cos {n} : ContDiff ℂ n cos 
Arguments: {n : ℕ∞}
Goal: ContDiff ℂ n Complex.cos
-- Complex.differentiable_cos
theorem differentiable_cos : Differentiable ℂ cos 
Goal: Differentiable ℂ Complex.cos
-- Complex.differentiableAt_cos
theorem differentiableAt_cos {x : ℂ} : DifferentiableAt ℂ cos x 
Arguments: {x : ℂ}
Goal: DifferentiableAt ℂ Complex.cos x
-- Complex.deriv_cos
theorem deriv_cos {x : ℂ} : deriv cos x = -sin x 
Arguments: {x : ℂ}
Goal: deriv Complex.cos x = -Complex.sin x
-- Complex.deriv_cos'
@[simp]
theorem deriv_cos' : deriv cos = fun x => -sin x 
Goal: deriv Complex.cos = fun x => -Complex.sin x
-- Complex.hasStrictDerivAt_sinh
theorem hasStrictDerivAt_sinh (x : ℂ) : HasStrictDerivAt sinh (cosh x) x 
Arguments: (x : ℂ)
Goal: HasStrictDerivAt Complex.sinh (Complex.cosh x) x
-- Complex.hasDerivAt_sinh
theorem hasDerivAt_sinh (x : ℂ) : HasDerivAt sinh (cosh x) x 
Arguments: (x : ℂ)
Goal: HasDerivAt Complex.sinh (Complex.cosh x) x
-- Complex.contDiff_sinh
theorem contDiff_sinh {n} : ContDiff ℂ n sinh 
Arguments: {n : ℕ∞}
Goal: ContDiff ℂ n Complex.sinh
-- Complex.differentiable_sinh
theorem differentiable_sinh : Differentiable ℂ sinh 
Goal: Differentiable ℂ Complex.sinh
-- Complex.differentiableAt_sinh
theorem differentiableAt_sinh {x : ℂ} : DifferentiableAt ℂ sinh x 
Arguments: {x : ℂ}
Goal: DifferentiableAt ℂ Complex.sinh x
-- Complex.deriv_sinh
@[simp]
theorem deriv_sinh : deriv sinh = cosh 
Goal: deriv Complex.sinh = Complex.cosh
-- Complex.hasStrictDerivAt_cosh
theorem hasStrictDerivAt_cosh (x : ℂ) : HasStrictDerivAt cosh (sinh x) x 
Arguments: (x : ℂ)
Goal: HasStrictDerivAt Complex.cosh (Complex.sinh x) x
-- Complex.hasDerivAt_cosh
theorem hasDerivAt_cosh (x : ℂ) : HasDerivAt cosh (sinh x) x 
Arguments: (x : ℂ)
Goal: HasDerivAt Complex.cosh (Complex.sinh x) x
-- Complex.contDiff_cosh
theorem contDiff_cosh {n} : ContDiff ℂ n cosh 
Arguments: {n : ℕ∞}
Goal: ContDiff ℂ n Complex.cosh
-- Complex.differentiable_cosh
theorem differentiable_cosh : Differentiable ℂ cosh 
Goal: Differentiable ℂ Complex.cosh
-- Complex.differentiableAt_cosh
theorem differentiableAt_cosh {x : ℂ} : DifferentiableAt ℂ cosh x 
Arguments: {x : ℂ}
Goal: DifferentiableAt ℂ Complex.cosh x
-- Complex.deriv_cosh
@[simp]
theorem deriv_cosh : deriv cosh = sinh 
Goal: deriv Complex.cosh = Complex.sinh
-- HasStrictDerivAt.ccos
theorem HasStrictDerivAt.ccos (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') x 
Arguments: {f : ℂ → ℂ} {f' x : ℂ} (hf : HasStrictDerivAt f f' x)
Goal: HasStrictDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') x
-- HasDerivAt.ccos
theorem HasDerivAt.ccos (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') x 
Arguments: {f : ℂ → ℂ} {f' x : ℂ} (hf : HasDerivAt f f' x)
Goal: HasDerivAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') x
-- HasDerivWithinAt.ccos
theorem HasDerivWithinAt.ccos (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') s x 
Arguments: {f : ℂ → ℂ} {f' x : ℂ} {s : Set ℂ} (hf : HasDerivWithinAt f f' s x)
Goal: HasDerivWithinAt (fun x => Complex.cos (f x)) (-Complex.sin (f x) * f') s x
-- derivWithin_ccos
theorem derivWithin_ccos (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x) :
    derivWithin (fun x => Complex.cos (f x)) s x = -Complex.sin (f x) * derivWithin f s x 
Arguments: {f : ℂ → ℂ} {x : ℂ} {s : Set ℂ} (hf : DifferentiableWithinAt ℂ f s x) (hxs : UniqueDiffWithinAt ℂ s x)
Goal: derivWithin (fun x => Complex.cos (f x)) s x = -Complex.sin (f x) * derivWithin f s x
-- deriv_ccos
@[simp]
theorem deriv_ccos (hc : DifferentiableAt ℂ f x) :
    deriv (fun x => Complex.cos (f x)) x = -Complex.sin (f x) * deriv f x 
Arguments: {f : ℂ → ℂ} {x : ℂ} (hc : DifferentiableAt ℂ f x)
Goal: deriv (fun x => Complex.cos (f x)) x = -Complex.sin (f x) * deriv f x
-- HasStrictDerivAt.csin
theorem HasStrictDerivAt.csin (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') x 
Arguments: {f : ℂ → ℂ} {f' x : ℂ} (hf : HasStrictDerivAt f f' x)
Goal: HasStrictDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') x
-- HasDerivAt.csin
theorem HasDerivAt.csin (hf : HasDerivAt f f' x) :
    HasDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') x 
Arguments: {f : ℂ → ℂ} {f' x : ℂ} (hf : HasDerivAt f f' x)
Goal: HasDerivAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') x
-- HasDerivWithinAt.csin
theorem HasDerivWithinAt.csin (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') s x 
Arguments: {f : ℂ → ℂ} {f' x : ℂ} {s : Set ℂ} (hf : HasDerivWithinAt f f' s x)
Goal: HasDerivWithinAt (fun x => Complex.sin (f x)) (Complex.cos (f x) * f') s x