ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean

full_name: Real.sin_lt
code: /-- For 0 < x, we have sin x < x. -/
theorem sin_lt (h : 0 < x) : sin x < x 
goal: Real.sin x < x

full_name: Real.sin_le
code: lemma sin_le (hx : 0 ≤ x) : sin x ≤ x 
goal: Real.sin x ≤ x

full_name: Real.lt_sin
code: lemma lt_sin (hx : x < 0) : x < sin x 
goal: x < Real.sin x

full_name: Real.le_sin
code: lemma le_sin (hx : x ≤ 0) : x ≤ sin x 
goal: x ≤ Real.sin x

full_name: Real.one_sub_sq_div_two_le_cos
code: lemma one_sub_sq_div_two_le_cos : 1 - x ^ 2 / 2 ≤ cos x 
goal: 1 - x ^ 2 / 2 ≤ Real.cos x

full_name: Real.two_div_pi_mul_le_sin
code: /-- **Jordan's inequality**. -/
lemma two_div_pi_mul_le_sin (hx₀ : 0 ≤ x) (hx : x ≤ π / 2) : 2 / π * x ≤ sin x 
goal: 2 / Real.pi * x ≤ Real.sin x

full_name: Real.sin_le_two_div_pi_mul
code: /-- **Jordan's inequality** for negative values. -/
lemma sin_le_two_div_pi_mul (hx : -(π / 2) ≤ x) (hx₀ : x ≤ 0) : sin x ≤ 2 / π * x 
goal: Real.sin x ≤ 2 / Real.pi * x

full_name: Real.one_sub_two_div_pi_mul_le_cos
code: /-- **Jordan's inequality** for `cos`. -/
lemma one_sub_two_div_pi_mul_le_cos (hx₀ : 0 ≤ x) (hx : x ≤ π / 2) : 1 - 2 / π * x ≤ cos x 
goal: 1 - 2 / Real.pi * x ≤ Real.cos x

full_name: Real.cos_quadratic_upper_bound
code: lemma cos_quadratic_upper_bound (hx : |x| ≤ π) : cos x ≤ 1 - 2 / π ^ 2 * x ^ 2 
goal: Real.cos x ≤ 1 - 2 / Real.pi ^ 2 * x ^ 2

full_name: Real.sin_gt_sub_cube
code: /-- For 0 < x ≤ 1 we have x - x ^ 3 / 4 < sin x.

This is also true for x > 1, but it's nontrivial for x just above 1. This inequality is not
tight; the tighter inequality is sin x > x - x ^ 3 / 6 for all x > 0, but this inequality has
a simpler proof. -/
theorem sin_gt_sub_cube {x : ℝ} (h : 0 < x) (h' : x ≤ 1) : x - x ^ 3 / 4 < sin x 
goal: x - x ^ 3 / 4 < Real.sin x

full_name: Real.deriv_tan_sub_id
code: /-- The derivative of `tan x - x` is `1/(cos x)^2 - 1` away from the zeroes of cos. -/
theorem deriv_tan_sub_id (x : ℝ) (h : cos x ≠ 0) :
    deriv (fun y : ℝ => tan y - y) x = 1 / cos x ^ 2 - 1 
goal: deriv (fun y => Real.tan y - y) x = 1 / Real.cos x ^ 2 - 1

full_name: Real.lt_tan
code: /-- For all `0 < x < π/2` we have `x < tan x`.

This is proved by checking that the function `tan x - x` vanishes
at zero and has non-negative derivative. -/
theorem lt_tan {x : ℝ} (h1 : 0 < x) (h2 : x < π / 2) : x < tan x 
goal: x < Real.tan x

full_name: Real.le_tan
code: theorem le_tan {x : ℝ} (h1 : 0 ≤ x) (h2 : x < π / 2) : x ≤ tan x 
goal: x ≤ Real.tan x

full_name: Real.cos_lt_one_div_sqrt_sq_add_one
code: theorem cos_lt_one_div_sqrt_sq_add_one {x : ℝ} (hx1 : -(3 * π / 2) ≤ x) (hx2 : x ≤ 3 * π / 2)
    (hx3 : x ≠ 0) : cos x < (1 / √(x ^ 2 + 1) : ℝ) 
goal: Real.cos x < 1 / √(x ^ 2 + 1)

full_name: Real.cos_le_one_div_sqrt_sq_add_one
code: theorem cos_le_one_div_sqrt_sq_add_one {x : ℝ} (hx1 : -(3 * π / 2) ≤ x) (hx2 : x ≤ 3 * π / 2) :
    cos x ≤ (1 : ℝ) / √(x ^ 2 + 1) 
goal: Real.cos x ≤ 1 / √(x ^ 2 + 1)
File: Mathlib/Analysis/SpecialFunctions/Gaussian/PoissonSummation.lean

full_name: rexp_neg_quadratic_isLittleO_rpow_atTop
code: lemma rexp_neg_quadratic_isLittleO_rpow_atTop {a : ℝ} (ha : a < 0) (b s : ℝ) :
    (fun x ↦ rexp (a * x ^ 2 + b * x)) =o[atTop] (· ^ s) 
goal: (fun x => rexp (a * x ^ 2 + b * x)) =o[Filter.atTop] fun x => x ^ s

full_name: cexp_neg_quadratic_isLittleO_rpow_atTop
code: lemma cexp_neg_quadratic_isLittleO_rpow_atTop {a : ℂ} (ha : a.re < 0) (b : ℂ) (s : ℝ) :
    (fun x : ℝ ↦ cexp (a * x ^ 2 + b * x)) =o[atTop] (· ^ s) 
goal: (fun x => cexp (a * ↑x ^ 2 + b * ↑x)) =o[Filter.atTop] fun x => x ^ s

full_name: cexp_neg_quadratic_isLittleO_abs_rpow_cocompact
code: lemma cexp_neg_quadratic_isLittleO_abs_rpow_cocompact {a : ℂ} (ha : a.re < 0) (b : ℂ) (s : ℝ) :
    (fun x : ℝ ↦ cexp (a * x ^ 2 + b * x)) =o[cocompact ℝ] (|·| ^ s) 
goal: (fun x => cexp (a * ↑x ^ 2 + b * ↑x)) =o[Filter.cocompact ℝ] fun x => |x| ^ s

full_name: tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact
code: theorem tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact {a : ℝ} (ha : 0 < a) (s : ℝ) :
    Tendsto (fun x : ℝ => |x| ^ s * rexp (-a * x ^ 2)) (cocompact ℝ) (𝓝 0) 
goal: Filter.Tendsto (fun x => |x| ^ s * rexp (-a * x ^ 2)) (Filter.cocompact ℝ) (𝓝 0)

full_name: isLittleO_exp_neg_mul_sq_cocompact
code: theorem isLittleO_exp_neg_mul_sq_cocompact {a : ℂ} (ha : 0 < a.re) (s : ℝ) :
    (fun x : ℝ => Complex.exp (-a * x ^ 2)) =o[cocompact ℝ] fun x : ℝ => |x| ^ s 
goal: (fun x => cexp (-a * ↑x ^ 2)) =o[Filter.cocompact ℝ] fun x => |x| ^ s

full_name: Complex.tsum_exp_neg_quadratic
code: /-- Jacobi's theta-function transformation formula for the sum of `exp -Q(x)`, where `Q` is a
negative definite quadratic form. -/
theorem Complex.tsum_exp_neg_quadratic {a : ℂ} (ha : 0 < a.re) (b : ℂ) :
    (∑' n : ℤ, cexp (-π * a * n ^ 2 + 2 * π * b * n)) =
      1 / a ^ (1 / 2 : ℂ) * ∑' n : ℤ, cexp (-π / a * (n + I * b) ^ 2) 
goal: ∑' (n : ℤ), cexp (-↑π * a * ↑n ^ 2 + 2 * ↑π * b * ↑n) =
  1 / a ^ (1 / 2) * ∑' (n : ℤ), cexp (-↑π / a * (↑n + Complex.I * b) ^ 2)

full_name: Complex.tsum_exp_neg_mul_int_sq
code: theorem Complex.tsum_exp_neg_mul_int_sq {a : ℂ} (ha : 0 < a.re) :
    (∑' n : ℤ, cexp (-π * a * (n : ℂ) ^ 2)) =
      1 / a ^ (1 / 2 : ℂ) * ∑' n : ℤ, cexp (-π / a * (n : ℂ) ^ 2) 
goal: ∑' (n : ℤ), cexp (-↑π * a * ↑n ^ 2) = 1 / a ^ (1 / 2) * ∑' (n : ℤ), cexp (-↑π / a * ↑n ^ 2)

full_name: Real.tsum_exp_neg_mul_int_sq
code: theorem Real.tsum_exp_neg_mul_int_sq {a : ℝ} (ha : 0 < a) :
    (∑' n : ℤ, exp (-π * a * (n : ℝ) ^ 2)) =
      (1 : ℝ) / a ^ (1 / 2 : ℝ) * (∑' n : ℤ, exp (-π / a * (n : ℝ) ^ 2)) 
goal: ∑' (n : ℤ), rexp (-π * a * ↑n ^ 2) = 1 / a ^ (1 / 2) * ∑' (n : ℤ), rexp (-π / a * ↑n ^ 2)
File: Mathlib/Analysis/SpecialFunctions/JapaneseBracket.lean

full_name: sqrt_one_add_norm_sq_le
code: theorem sqrt_one_add_norm_sq_le (x : E) : √((1 : ℝ) + ‖x‖ ^ 2) ≤ 1 + ‖x‖ 
goal: √(1 + ‖x‖ ^ 2) ≤ 1 + ‖x‖

full_name: one_add_norm_le_sqrt_two_mul_sqrt
code: theorem one_add_norm_le_sqrt_two_mul_sqrt (x : E) :
    (1 : ℝ) + ‖x‖ ≤ √2 * √(1 + ‖x‖ ^ 2) 
goal: 1 + ‖x‖ ≤ √2 * √(1 + ‖x‖ ^ 2)

full_name: rpow_neg_one_add_norm_sq_le
code: 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) 
goal: (1 + ‖x‖ ^ 2) ^ (-r / 2) ≤ 2 ^ (r / 2) * (1 + ‖x‖) ^ (-r)

full_name: le_rpow_one_add_norm_iff_norm_le
code: 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 
goal: t ≤ (1 + ‖x‖) ^ (-r) ↔ ‖x‖ ≤ t ^ (-r⁻¹) - 1

full_name: closedBall_rpow_sub_one_eq_empty_aux
code: theorem closedBall_rpow_sub_one_eq_empty_aux {r t : ℝ} (hr : 0 < r) (ht : 1 < t) :
    Metric.closedBall (0 : E) (t ^ (-r⁻¹) - 1) = ∅ 
goal: Metric.closedBall 0 (t ^ (-r⁻¹) - 1) = ∅

full_name: finite_integral_rpow_sub_one_pow_aux
code: theorem finite_integral_rpow_sub_one_pow_aux {r : ℝ} (n : ℕ) (hnr : (n : ℝ) < r) :
    (∫⁻ x : ℝ in Ioc 0 1, ENNReal.ofReal ((x ^ (-r⁻¹) - 1) ^ n)) < ∞ 
goal: ∫⁻ (x : ℝ) in Set.Ioc 0 1, ENNReal.ofReal ((x ^ (-r⁻¹) - 1) ^ n) < ⊤

full_name: finite_integral_one_add_norm
code: theorem finite_integral_one_add_norm {r : ℝ} (hnr : (finrank ℝ E : ℝ) < r) :
    (∫⁻ x : E, ENNReal.ofReal ((1 + ‖x‖) ^ (-r)) ∂μ) < ∞ 
goal: ∫⁻ (x : E), ENNReal.ofReal ((1 + ‖x‖) ^ (-r)) ∂μ < ⊤

full_name: integrable_one_add_norm
code: theorem integrable_one_add_norm {r : ℝ} (hnr : (finrank ℝ E : ℝ) < r) :
    Integrable (fun x ↦ (1 + ‖x‖) ^ (-r)) μ 
goal: MeasureTheory.Integrable (fun x => (1 + ‖x‖) ^ (-r)) μ

full_name: integrable_rpow_neg_one_add_norm_sq
code: theorem integrable_rpow_neg_one_add_norm_sq {r : ℝ} (hnr : (finrank ℝ E : ℝ) < r) :
    Integrable (fun x ↦ ((1 : ℝ) + ‖x‖ ^ 2) ^ (-r / 2)) μ 
goal: MeasureTheory.Integrable (fun x => (1 + ‖x‖ ^ 2) ^ (-r / 2)) μ
File: Mathlib/Analysis/SpecialFunctions/Complex/Analytic.lean

full_name: analyticOn_cexp
code: /-- `exp` is entire -/
theorem analyticOn_cexp : AnalyticOn ℂ exp univ 
goal: AnalyticOn ℂ cexp Set.univ

full_name: analyticAt_cexp
code: /-- `exp` is analytic at any point -/
theorem analyticAt_cexp : AnalyticAt ℂ exp z 
goal: AnalyticAt ℂ cexp z

full_name: AnalyticAt.cexp
code: /-- `exp ∘ f` is analytic -/
theorem AnalyticAt.cexp (fa : AnalyticAt ℂ f x) : AnalyticAt ℂ (fun z ↦ exp (f z)) x 
goal: AnalyticAt ℂ (fun z => cexp (f z)) x

full_name: AnalyticOn.cexp
code: /-- `exp ∘ f` is analytic -/
theorem AnalyticOn.cexp (fs : AnalyticOn ℂ f s) : AnalyticOn ℂ (fun z ↦ exp (f z)) s 
goal: AnalyticOn ℂ (fun z => cexp (f z)) s

full_name: analyticAt_clog
code: /-- `log` is analytic away from nonpositive reals -/
theorem analyticAt_clog (m : z ∈ slitPlane) : AnalyticAt ℂ log z 
goal: AnalyticAt ℂ Complex.log z

full_name: AnalyticAt.clog
code: /-- `log` is analytic away from nonpositive reals -/
theorem AnalyticAt.clog (fa : AnalyticAt ℂ f x) (m : f x ∈ slitPlane) :
    AnalyticAt ℂ (fun z ↦ log (f z)) x 
goal: AnalyticAt ℂ (fun z => Complex.log (f z)) x

full_name: AnalyticOn.clog
code: /-- `log` is analytic away from nonpositive reals -/
theorem AnalyticOn.clog (fs : AnalyticOn ℂ f s) (m : ∀ z ∈ s, f z ∈ slitPlane) :
    AnalyticOn ℂ (fun z ↦ log (f z)) s 
goal: AnalyticOn ℂ (fun z => Complex.log (f z)) s

full_name: AnalyticAt.cpow
code: /-- `f z ^ g z` is analytic if `f z` is not a nonpositive real -/
theorem AnalyticAt.cpow (fa : AnalyticAt ℂ f x) (ga : AnalyticAt ℂ g x)
    (m : f x ∈ slitPlane) : AnalyticAt ℂ (fun z ↦ f z ^ g z) x 
goal: AnalyticAt ℂ (fun z => f z ^ g z) x

full_name: AnalyticOn.cpow
code: /-- `f z ^ g z` is analytic if `f z` avoids nonpositive reals -/
theorem AnalyticOn.cpow (fs : AnalyticOn ℂ f s) (gs : AnalyticOn ℂ g s)
    (m : ∀ z ∈ s, f z ∈ slitPlane) : AnalyticOn ℂ (fun z ↦ f z ^ g z) s 
goal: AnalyticOn ℂ (fun z => f z ^ g z) s
File: Mathlib/Analysis/SpecialFunctions/Pow/Integral.lean

full_name: MeasureTheory.lintegral_rpow_eq_lintegral_meas_le_mul
code: /-- An application of the layer cake formula / Cavalieri's principle / tail probability formula:

For a nonnegative function `f` on a measure space, the Lebesgue integral of `f` can
be written (roughly speaking) as: `∫⁻ f^p ∂μ = p * ∫⁻ t in 0..∞, t^(p-1) * μ {ω | f(ω) ≥ t}`.

See `MeasureTheory.lintegral_rpow_eq_lintegral_meas_lt_mul` for a version with sets of the form
`{ω | f(ω) > t}` instead. -/
theorem lintegral_rpow_eq_lintegral_meas_le_mul :
    ∫⁻ ω, ENNReal.ofReal (f ω ^ p) ∂μ =
      ENNReal.ofReal p * ∫⁻ t in Ioi 0, μ {a : α | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1)) 
goal: ∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ =
  ENNReal.ofReal p * ∫⁻ (t : ℝ) in Set.Ioi 0, μ {a | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))

full_name: MeasureTheory.lintegral_rpow_eq_lintegral_meas_lt_mul
code: /-- An application of the layer cake formula / Cavalieri's principle / tail probability formula:

For a nonnegative function `f` on a measure space, the Lebesgue integral of `f` can
be written (roughly speaking) as: `∫⁻ f^p ∂μ = p * ∫⁻ t in 0..∞, t^(p-1) * μ {ω | f(ω) > t}`.

See `MeasureTheory.lintegral_rpow_eq_lintegral_meas_le_mul` for a version with sets of the form
`{ω | f(ω) ≥ t}` instead. -/
theorem lintegral_rpow_eq_lintegral_meas_lt_mul :
    ∫⁻ ω, ENNReal.ofReal (f ω ^ p) ∂μ =
      ENNReal.ofReal p * ∫⁻ t in Ioi 0, μ {a : α | t < f a} * ENNReal.ofReal (t ^ (p - 1)) 
goal: ∫⁻ (ω : α), ENNReal.ofReal (f ω ^ p) ∂μ =
  ENNReal.ofReal p * ∫⁻ (t : ℝ) in Set.Ioi 0, μ {a | t < f a} * ENNReal.ofReal (t ^ (p - 1))
File: Mathlib/Analysis/NormedSpace/Int.lean

full_name: Int.nnnorm_coe_units
code: theorem nnnorm_coe_units (e : ℤˣ) : ‖(e : ℤ)‖₊ = 1 
goal: ‖↑e‖₊ = 1

full_name: Int.norm_coe_units
code: theorem norm_coe_units (e : ℤˣ) : ‖(e : ℤ)‖ = 1 
goal: ‖↑e‖ = 1

full_name: Int.nnnorm_natCast
code: @[simp]
theorem nnnorm_natCast (n : ℕ) : ‖(n : ℤ)‖₊ = n 
goal: ‖↑n‖₊ = ↑n

full_name: Int.toNat_add_toNat_neg_eq_nnnorm
code: @[simp]
theorem toNat_add_toNat_neg_eq_nnnorm (n : ℤ) : ↑n.toNat + ↑(-n).toNat = ‖n‖₊ 
goal: ↑n.toNat + ↑(-n).toNat = ‖n‖₊

full_name: Int.toNat_add_toNat_neg_eq_norm
code: @[simp]
theorem toNat_add_toNat_neg_eq_norm (n : ℤ) : ↑n.toNat + ↑(-n).toNat = ‖n‖ 
goal: ↑n.toNat + ↑(-n).toNat = ‖n‖
File: Mathlib/Analysis/Subadditive.lean

full_name: Subadditive
code: /-- A real-valued sequence is subadditive if it satisfies the inequality `u (m + n) ≤ u m + u n`
for all `m, n`. -/
def Subadditive (u : ℕ → ℝ) : Prop 
goal: Prop

full_name: Subadditive.lim
code: /-- The limit of a bounded-below subadditive sequence. The fact that the sequence indeed tends to
this limit is given in `Subadditive.tendsto_lim` -/
@[nolint unusedArguments] -- Porting note: was irreducible
protected def lim (_h : Subadditive u) 
goal: ℝ

full_name: Subadditive.lim_le_div
code: theorem lim_le_div (hbdd : BddBelow (range fun n => u n / n)) {n : ℕ} (hn : n ≠ 0) :
    h.lim ≤ u n / n 
goal: h.lim ≤ u n / ↑n

full_name: Subadditive.apply_mul_add_le
code: theorem apply_mul_add_le (k n r) : u (k * n + r) ≤ k * u n + u r 
goal: u (k * n + r) ≤ ↑k * u n + u r

full_name: Subadditive.eventually_div_lt_of_div_lt
code: theorem eventually_div_lt_of_div_lt {L : ℝ} {n : ℕ} (hn : n ≠ 0) (hL : u n / n < L) :
    ∀ᶠ p in atTop, u p / p < L 
goal: ∀ᶠ (p : ℕ) in Filter.atTop, u p / ↑p < L

full_name: Subadditive.tendsto_lim
code: /-- Fekete's lemma: a subadditive sequence which is bounded below converges. -/
theorem tendsto_lim (hbdd : BddBelow (range fun n => u n / n)) :
    Tendsto (fun n => u n / n) atTop (𝓝 h.lim) 
goal: Filter.Tendsto (fun n => u n / ↑n) Filter.atTop (𝓝 h.lim)
File: Mathlib/Analysis/NormedSpace/IndicatorFunction.lean

full_name: norm_indicator_eq_indicator_norm
code: theorem norm_indicator_eq_indicator_norm : ‖indicator s f a‖ = indicator s (fun a => ‖f a‖) a 
goal: ‖s.indicator f a‖ = s.indicator (fun a => ‖f a‖) a

full_name: nnnorm_indicator_eq_indicator_nnnorm
code: theorem nnnorm_indicator_eq_indicator_nnnorm :
    ‖indicator s f a‖₊ = indicator s (fun a => ‖f a‖₊) a 
goal: ‖s.indicator f a‖₊ = s.indicator (fun a => ‖f a‖₊) a

full_name: norm_indicator_le_of_subset
code: theorem norm_indicator_le_of_subset (h : s ⊆ t) (f : α → E) (a : α) :
    ‖indicator s f a‖ ≤ ‖indicator t f a‖ 
goal: ‖s.indicator f a‖ ≤ ‖t.indicator f a‖

full_name: indicator_norm_le_norm_self
code: theorem indicator_norm_le_norm_self : indicator s (fun a => ‖f a‖) a ≤ ‖f a‖ 
goal: s.indicator (fun a => ‖f a‖) a ≤ ‖f a‖

full_name: norm_indicator_le_norm_self
code: theorem norm_indicator_le_norm_self : ‖indicator s f a‖ ≤ ‖f a‖ 
goal: ‖s.indicator f a‖ ≤ ‖f a‖
File: Mathlib/Analysis/SpecialFunctions/Complex/Arctan.lean

full_name: Complex.arctan
code: /-- The complex arctangent, defined via the complex logarithm. -/
noncomputable def arctan (z : ℂ) : ℂ 
goal: ℂ

full_name: Complex.tan_arctan
code: theorem tan_arctan {z : ℂ} (h₁ : z ≠ I) (h₂ : z ≠ -I) : tan (arctan z) = z 
goal: Complex.tan z.arctan = z

full_name: Complex.cos_ne_zero_of_arctan_bounds
code: /-- `cos z` is nonzero when the bounds in `arctan_tan` are met (`z` lies in the vertical strip
`-π / 2 < z.re < π / 2` and `z ≠ π / 2`). -/
lemma cos_ne_zero_of_arctan_bounds {z : ℂ} (h₀ : z ≠ π / 2) (h₁ : -(π / 2) < z.re)
    (h₂ : z.re ≤ π / 2) : cos z ≠ 0 
goal: Complex.cos z ≠ 0

full_name: Complex.arctan_tan
code: theorem arctan_tan {z : ℂ} (h₀ : z ≠ π / 2) (h₁ : -(π / 2) < z.re) (h₂ : z.re ≤ π / 2) :
    arctan (tan z) = z 
goal: (Complex.tan z).arctan = z

full_name: Complex.ofReal_arctan
code: @[simp, norm_cast]
theorem ofReal_arctan (x : ℝ) : (Real.arctan x : ℂ) = arctan x 
goal: ↑(Real.arctan x) = (↑x).arctan

full_name: Complex.arg_one_add_mem_Ioo
code: /-- The argument of `1 + z` for `z` in the open unit disc is always in `(-π / 2, π / 2)`. -/
lemma arg_one_add_mem_Ioo {z : ℂ} (hz : ‖z‖ < 1) : (1 + z).arg ∈ Set.Ioo (-(π / 2)) (π / 2) 
goal: (1 + z).arg ∈ Set.Ioo (-(Real.pi / 2)) (Real.pi / 2)

full_name: Complex.hasSum_arctan_aux
code: /-- We can combine the logs in `log (1 + z * I) + -log (1 - z * I)` into one.
This is only used in `hasSum_arctan`. -/
lemma hasSum_arctan_aux {z : ℂ} (hz : ‖z‖ < 1) :
    log (1 + z * I) + -log (1 - z * I) = log ((1 + z * I) / (1 - z * I)) 
goal: Complex.log (1 + z * Complex.I) + -Complex.log (1 - z * Complex.I) =
  Complex.log ((1 + z * Complex.I) / (1 - z * Complex.I))

full_name: Complex.hasSum_arctan
code: /-- The power series expansion of `Complex.arctan`, valid on the open unit disc. -/
theorem hasSum_arctan {z : ℂ} (hz : ‖z‖ < 1) :
    HasSum (fun n : ℕ ↦ (-1) ^ n * z ^ (2 * n + 1) / ↑(2 * n + 1)) (arctan z) 
goal: HasSum (fun n => (-1) ^ n * z ^ (2 * n + 1) / ↑(2 * n + 1)) z.arctan

full_name: Real.hasSum_arctan
code: /-- The power series expansion of `Real.arctan`, valid on `-1 < x < 1`. -/
theorem Real.hasSum_arctan {x : ℝ} (hx : ‖x‖ < 1) :
    HasSum (fun n : ℕ => (-1) ^ n * x ^ (2 * n + 1) / ↑(2 * n + 1)) (arctan x) 
goal: HasSum (fun n => (-1) ^ n * x ^ (2 * n + 1) / ↑(2 * n + 1)) (Real.arctan x)
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Asymptotics.lean

full_name: ContinuousLinearMap.isBigOWith_id
code: theorem isBigOWith_id : IsBigOWith ‖f‖ l f fun x => x 
goal: Asymptotics.IsBigOWith ‖f‖ l ⇑f fun x => x

full_name: ContinuousLinearMap.isBigO_id
code: theorem isBigO_id : f =O[l] fun x => x 
goal: ⇑f =O[l] fun x => x

full_name: ContinuousLinearMap.isBigOWith_comp
code: theorem isBigOWith_comp [RingHomIsometric σ₂₃] {α : Type*} (g : F →SL[σ₂₃] G) (f : α → F)
    (l : Filter α) : IsBigOWith ‖g‖ l (fun x' => g (f x')) f 
goal: Asymptotics.IsBigOWith ‖g‖ l (fun x' => g (f x')) f

full_name: ContinuousLinearMap.isBigO_comp
code: theorem isBigO_comp [RingHomIsometric σ₂₃] {α : Type*} (g : F →SL[σ₂₃] G) (f : α → F)
    (l : Filter α) : (fun x' => g (f x')) =O[l] f 
goal: (fun x' => g (f x')) =O[l] f

full_name: ContinuousLinearMap.isBigOWith_sub
code: theorem isBigOWith_sub (x : E) :
    IsBigOWith ‖f‖ l (fun x' => f (x' - x)) fun x' => x' - x 
goal: Asymptotics.IsBigOWith ‖f‖ l (fun x' => f (x' - x)) fun x' => x' - x

full_name: ContinuousLinearMap.isBigO_sub
code: theorem isBigO_sub (x : E) :
    (fun x' => f (x' - x)) =O[l] fun x' => x' - x 
goal: (fun x' => f (x' - x)) =O[l] fun x' => x' - x

full_name: ContinuousLinearEquiv.isBigO_comp
code: theorem isBigO_comp {α : Type*} (f : α → E) (l : Filter α) : (fun x' => e (f x')) =O[l] f 
goal: (fun x' => e (f x')) =O[l] f

full_name: ContinuousLinearEquiv.isBigO_sub
code: theorem isBigO_sub (l : Filter E) (x : E) : (fun x' => e (x' - x)) =O[l] fun x' => x' - x 
goal: (fun x' => e (x' - x)) =O[l] fun x' => x' - x

full_name: ContinuousLinearEquiv.isBigO_comp_rev
code: theorem isBigO_comp_rev {α : Type*} (f : α → E) (l : Filter α) : f =O[l] fun x' => e (f x') 
goal: f =O[l] fun x' => e (f x')

full_name: ContinuousLinearEquiv.isBigO_sub_rev
code: theorem isBigO_sub_rev (l : Filter E) (x : E) : (fun x' => x' - x) =O[l] fun x' => e (x' - x) 
goal: (fun x' => x' - x) =O[l] fun x' => e (x' - x)
File: Mathlib/Analysis/NormedSpace/FunctionSeries.lean

full_name: tendstoUniformlyOn_tsum
code: /-- An infinite sum of functions with summable sup norm is the uniform limit of its partial sums.
Version relative to a set, with general index set. -/
theorem tendstoUniformlyOn_tsum {f : α → β → F} (hu : Summable u) {s : Set β}
    (hfu : ∀ n x, x ∈ s → ‖f n x‖ ≤ u n) :
    TendstoUniformlyOn (fun t : Finset α => fun x => ∑ n ∈ t, f n x) (fun x => ∑' n, f n x) atTop
      s 
goal: TendstoUniformlyOn (fun t x => ∑ n ∈ t, f n x) (fun x => ∑' (n : α), f n x) Filter.atTop s

full_name: tendstoUniformlyOn_tsum_nat
code: /-- An infinite sum of functions with summable sup norm is the uniform limit of its partial sums.
Version relative to a set, with index set `ℕ`. -/
theorem tendstoUniformlyOn_tsum_nat {f : ℕ → β → F} {u : ℕ → ℝ} (hu : Summable u) {s : Set β}
    (hfu : ∀ n x, x ∈ s → ‖f n x‖ ≤ u n) :
    TendstoUniformlyOn (fun N => fun x => ∑ n ∈ Finset.range N, f n x) (fun x => ∑' n, f n x) atTop
      s 
goal: TendstoUniformlyOn (fun N x => ∑ n ∈ Finset.range N, f n x) (fun x => ∑' (n : ℕ), f n x) Filter.atTop s

full_name: tendstoUniformly_tsum
code: /-- An infinite sum of functions with summable sup norm is the uniform limit of its partial sums.
Version with general index set. -/
theorem tendstoUniformly_tsum {f : α → β → F} (hu : Summable u) (hfu : ∀ n x, ‖f n x‖ ≤ u n) :
    TendstoUniformly (fun t : Finset α => fun x => ∑ n ∈ t, f n x)
      (fun x => ∑' n, f n x) atTop 
goal: TendstoUniformly (fun t x => ∑ n ∈ t, f n x) (fun x => ∑' (n : α), f n x) Filter.atTop

full_name: tendstoUniformly_tsum_nat
code: /-- An infinite sum of functions with summable sup norm is the uniform limit of its partial sums.
Version with index set `ℕ`. -/
theorem tendstoUniformly_tsum_nat {f : ℕ → β → F} {u : ℕ → ℝ} (hu : Summable u)
    (hfu : ∀ n x, ‖f n x‖ ≤ u n) :
    TendstoUniformly (fun N => fun x => ∑ n ∈ Finset.range N, f n x) (fun x => ∑' n, f n x)
      atTop 
goal: TendstoUniformly (fun N x => ∑ n ∈ Finset.range N, f n x) (fun x => ∑' (n : ℕ), f n x) Filter.atTop

full_name: continuousOn_tsum
code: /-- An infinite sum of functions with summable sup norm is continuous on a set if each individual
function is. -/
theorem continuousOn_tsum [TopologicalSpace β] {f : α → β → F} {s : Set β}
    (hf : ∀ i, ContinuousOn (f i) s) (hu : Summable u) (hfu : ∀ n x, x ∈ s → ‖f n x‖ ≤ u n) :
    ContinuousOn (fun x => ∑' n, f n x) s 
goal: ContinuousOn (fun x => ∑' (n : α), f n x) s

full_name: continuous_tsum
code: /-- An infinite sum of functions with summable sup norm is continuous if each individual
function is. -/
theorem continuous_tsum [TopologicalSpace β] {f : α → β → F} (hf : ∀ i, Continuous (f i))
    (hu : Summable u) (hfu : ∀ n x, ‖f n x‖ ≤ u n) : Continuous fun x => ∑' n, f n x 
goal: Continuous fun x => ∑' (n : α), f n x
File: Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean

full_name: IsConformalMap
code: /-- A continuous linear map `f'` is said to be conformal if it's
    a nonzero multiple of a linear isometry. -/
def IsConformalMap {R : Type*} {X Y : Type*} [NormedField R] [SeminormedAddCommGroup X]
    [SeminormedAddCommGroup Y] [NormedSpace R X] [NormedSpace R Y] (f' : X →L[R] Y) 
goal: Prop

full_name: isConformalMap_id
code: theorem isConformalMap_id : IsConformalMap (id R M) 
goal: IsConformalMap (ContinuousLinearMap.id R M)

full_name: IsConformalMap.smul
code: theorem IsConformalMap.smul (hf : IsConformalMap f) {c : R} (hc : c ≠ 0) :
    IsConformalMap (c • f) 
goal: IsConformalMap (c • f)

full_name: isConformalMap_const_smul
code: theorem isConformalMap_const_smul (hc : c ≠ 0) : IsConformalMap (c • id R M) 
goal: IsConformalMap (c • ContinuousLinearMap.id R M)

full_name: LinearIsometry.isConformalMap
code: protected theorem LinearIsometry.isConformalMap (f' : M →ₗᵢ[R] N) :
    IsConformalMap f'.toContinuousLinearMap 
goal: IsConformalMap f'.toContinuousLinearMap

full_name: isConformalMap_of_subsingleton
code: @[nontriviality]
theorem isConformalMap_of_subsingleton [Subsingleton M] (f' : M →L[R] N) : IsConformalMap f' 
goal: IsConformalMap f'

full_name: IsConformalMap.comp
code: theorem comp (hg : IsConformalMap g) (hf : IsConformalMap f) : IsConformalMap (g.comp f) 
goal: IsConformalMap (g.comp f)

full_name: IsConformalMap.injective
code: protected theorem injective {f : M' →L[R] N} (h : IsConformalMap f) : Function.Injective f 
goal: Function.Injective ⇑f

full_name: IsConformalMap.ne_zero
code: theorem ne_zero [Nontrivial M'] {f' : M' →L[R] N} (hf' : IsConformalMap f') : f' ≠ 0 
goal: f' ≠ 0