File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean

full_name: HurwitzKernelBounds.isBigO_exp_neg_mul_of_le
code: lemma isBigO_exp_neg_mul_of_le {c d : ℝ} (hcd : c ≤ d) :
    (fun t ↦ exp (-d * t)) =O[atTop] fun t ↦ exp (-c * t) 
goal: (fun t => rexp (-d * t)) =O[Filter.atTop] fun t => rexp (-c * t)

full_name: _private.Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds.0.HurwitzKernelBounds.exp_lt_aux
code: private lemma exp_lt_aux {t : ℝ} (ht : 0 < t) : rexp (-π * t) < 1 
goal: rexp (-π * t) < 1

full_name: _private.Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds.0.HurwitzKernelBounds.isBigO_one_aux
code: private lemma isBigO_one_aux :
    IsBigO atTop (fun t : ℝ ↦ (1 - rexp (-π * t))⁻¹) (fun _ ↦ (1 : ℝ)) 
goal: (fun t => (1 - rexp (-π * t))⁻¹) =O[Filter.atTop] fun x => 1

full_name: HurwitzKernelBounds.f_nat
code: /-- Summand in the sum to be bounded (`ℕ` version). -/
def f_nat (k : ℕ) (a t : ℝ) (n : ℕ) : ℝ 
goal: ℝ

full_name: HurwitzKernelBounds.g_nat
code: /-- An upper bound for the summand when `0 ≤ a`. -/
def g_nat (k : ℕ) (a t : ℝ) (n : ℕ) : ℝ 
goal: ℝ

full_name: HurwitzKernelBounds.f_le_g_nat
code: lemma f_le_g_nat (k : ℕ) {a t : ℝ} (ha : 0 ≤ a) (ht : 0 < t) (n : ℕ) :
    ‖f_nat k a t n‖ ≤ g_nat k a t n 
goal: ‖HurwitzKernelBounds.f_nat k a t n‖ ≤ HurwitzKernelBounds.g_nat k a t n

full_name: HurwitzKernelBounds.F_nat
code: /-- The sum to be bounded (`ℕ` version). -/
def F_nat (k : ℕ) (a t : ℝ) : ℝ 
goal: ℝ

full_name: HurwitzKernelBounds.summable_f_nat
code: lemma summable_f_nat (k : ℕ) (a : ℝ) {t : ℝ} (ht : 0 < t) : Summable (f_nat k a t) 
goal: Summable (HurwitzKernelBounds.f_nat k a t)

full_name: HurwitzKernelBounds.F_nat_zero_le
code: lemma F_nat_zero_le {a : ℝ} (ha : 0 ≤ a) {t : ℝ} (ht : 0 < t) :
    ‖F_nat 0 a t‖ ≤ rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t)) 
goal: ‖HurwitzKernelBounds.F_nat 0 a t‖ ≤ rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t))

full_name: HurwitzKernelBounds.F_nat_zero_zero_sub_le
code: lemma F_nat_zero_zero_sub_le {t : ℝ} (ht : 0 < t) :
    ‖F_nat 0 0 t - 1‖ ≤ rexp (-π * t) / (1 - rexp (-π * t)) 
goal: ‖HurwitzKernelBounds.F_nat 0 0 t - 1‖ ≤ rexp (-π * t) / (1 - rexp (-π * t))

full_name: HurwitzKernelBounds.isBigO_atTop_F_nat_zero_sub
code: lemma isBigO_atTop_F_nat_zero_sub {a : ℝ} (ha : 0 ≤ a) : ∃ p, 0 < p ∧
    (fun t ↦ F_nat 0 a t - (if a = 0 then 1 else 0)) =O[atTop] fun t ↦ exp (-p * t) 
goal: ∃ p, 0 < p ∧ (fun t => HurwitzKernelBounds.F_nat 0 a t - if a = 0 then 1 else 0) =O[Filter.atTop] fun t => rexp (-p * t)

full_name: HurwitzKernelBounds.F_nat_one_le
code: lemma F_nat_one_le {a : ℝ} (ha : 0 ≤ a) {t : ℝ} (ht : 0 < t) :
    ‖F_nat 1 a t‖ ≤ rexp (-π * (a ^ 2 + 1) * t) / (1 - rexp (-π * t)) ^ 2
      + a * rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t)) 
goal: ‖HurwitzKernelBounds.F_nat 1 a t‖ ≤
  rexp (-π * (a ^ 2 + 1) * t) / (1 - rexp (-π * t)) ^ 2 + a * rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t))

full_name: HurwitzKernelBounds.isBigO_atTop_F_nat_one
code: lemma isBigO_atTop_F_nat_one {a : ℝ} (ha : 0 ≤ a) : ∃ p, 0 < p ∧
    F_nat 1 a =O[atTop] fun t ↦ exp (-p * t) 
goal: ∃ p, 0 < p ∧ HurwitzKernelBounds.F_nat 1 a =O[Filter.atTop] fun t => rexp (-p * t)

full_name: HurwitzKernelBounds.f_int
code: /-- Summand in the sum to be bounded (`ℤ` version). -/
def f_int (k : ℕ) (a t : ℝ) (n : ℤ) : ℝ 
goal: ℝ

full_name: HurwitzKernelBounds.f_int_ofNat
code: lemma f_int_ofNat (k : ℕ) {a : ℝ} (ha : 0 ≤ a) (t : ℝ) (n : ℕ) :
    f_int k a t (Int.ofNat n) = f_nat k a t n 
goal: HurwitzKernelBounds.f_int k a t (Int.ofNat n) = HurwitzKernelBounds.f_nat k a t n

full_name: HurwitzKernelBounds.f_int_negSucc
code: lemma f_int_negSucc (k : ℕ) {a : ℝ} (ha : a ≤ 1) (t : ℝ) (n : ℕ) :
    f_int k a t (Int.negSucc n) = f_nat k (1 - a) t n 
goal: HurwitzKernelBounds.f_int k a t (Int.negSucc n) = HurwitzKernelBounds.f_nat k (1 - a) t n

full_name: HurwitzKernelBounds.summable_f_int
code: lemma summable_f_int (k : ℕ) (a : ℝ) {t : ℝ} (ht : 0 < t) : Summable (f_int k a t) 
goal: Summable (HurwitzKernelBounds.f_int k a t)

full_name: HurwitzKernelBounds.F_int
code: /-- The sum to be bounded (`ℤ` version). -/
def F_int (k : ℕ) (a : UnitAddCircle) (t : ℝ) : ℝ 
goal: ℝ

full_name: HurwitzKernelBounds.F_int_eq_of_mem_Icc
code: lemma F_int_eq_of_mem_Icc (k : ℕ) {a : ℝ} (ha : a ∈ Icc 0 1) {t : ℝ} (ht : 0 < t) :
    F_int k a t = (F_nat k a t) + (F_nat k (1 - a) t) 
goal: HurwitzKernelBounds.F_int k (↑a) t = HurwitzKernelBounds.F_nat k a t + HurwitzKernelBounds.F_nat k (1 - a) t

full_name: HurwitzKernelBounds.isBigO_atTop_F_int_zero_sub
code: lemma isBigO_atTop_F_int_zero_sub (a : UnitAddCircle) : ∃ p, 0 < p ∧
    (fun t ↦ F_int 0 a t - (if a = 0 then 1 else 0)) =O[atTop] fun t ↦ exp (-p * t) 
goal: ∃ p, 0 < p ∧ (fun t => HurwitzKernelBounds.F_int 0 a t - if a = 0 then 1 else 0) =O[Filter.atTop] fun t => rexp (-p * t)

full_name: HurwitzKernelBounds.isBigO_atTop_F_int_one
code: lemma isBigO_atTop_F_int_one (a : UnitAddCircle) : ∃ p, 0 < p ∧
    F_int 1 a =O[atTop] fun t ↦ exp (-p * t) 
goal: ∃ p, 0 < p ∧ HurwitzKernelBounds.F_int 1 a =O[Filter.atTop] fun t => rexp (-p * t)