File: Mathlib/NumberTheory/LSeries/Basic.lean

full_name: LSeries.term
code: /-- The `n`th term of the L-series of `f` evaluated at `s`. We set it to zero when `n = 0`. -/
noncomputable
def term (f : ℕ → ℂ) (s : ℂ) (n : ℕ) : ℂ 
goal: ℂ

full_name: LSeries.term_def
code: lemma term_def (f : ℕ → ℂ) (s : ℂ) (n : ℕ) :
    term f s n = if n = 0 then 0 else f n / n ^ s 
goal: LSeries.term f s n = if n = 0 then 0 else f n / ↑n ^ s

full_name: LSeries.term_zero
code: @[simp]
lemma term_zero (f : ℕ → ℂ) (s : ℂ) : term f s 0 = 0 
goal: LSeries.term f s 0 = 0

full_name: LSeries.term_of_ne_zero
code: @[simp]
lemma term_of_ne_zero {n : ℕ} (hn : n ≠ 0) (f : ℕ → ℂ) (s : ℂ) :
    term f s n = f n / n ^ s 
goal: LSeries.term f s n = f n / ↑n ^ s

full_name: LSeries.term_congr
code: lemma term_congr {f g : ℕ → ℂ} (h : ∀ {n}, n ≠ 0 → f n = g n) (s : ℂ) (n : ℕ) :
    term f s n = term g s n 
goal: LSeries.term f s n = LSeries.term g s n

full_name: LSeries.norm_term_eq
code: lemma norm_term_eq (f : ℕ → ℂ) (s : ℂ) (n : ℕ) :
    ‖term f s n‖ = if n = 0 then 0 else ‖f n‖ / n ^ s.re 
goal: ‖LSeries.term f s n‖ = if n = 0 then 0 else ‖f n‖ / ↑n ^ s.re

full_name: LSeries.norm_term_le
code: lemma norm_term_le {f g : ℕ → ℂ} (s : ℂ) {n : ℕ} (h : ‖f n‖ ≤ ‖g n‖) :
    ‖term f s n‖ ≤ ‖term g s n‖ 
goal: ‖LSeries.term f s n‖ ≤ ‖LSeries.term g s n‖

full_name: LSeries.norm_term_le_of_re_le_re
code: lemma norm_term_le_of_re_le_re (f : ℕ → ℂ) {s s' : ℂ} (h : s.re ≤ s'.re) (n : ℕ) :
    ‖term f s' n‖ ≤ ‖term f s n‖ 
goal: ‖LSeries.term f s' n‖ ≤ ‖LSeries.term f s n‖

full_name: LSeries
code: /-- The value of the L-series of the sequence `f` at the point `s`
if it converges absolutely there, and `0` otherwise. -/
noncomputable
def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ 
goal: ℂ

full_name: LSeries_congr
code: lemma LSeries_congr {f g : ℕ → ℂ} (s : ℂ) (h : ∀ {n}, n ≠ 0 → f n = g n) :
    LSeries f s = LSeries g s 
goal: LSeries f s = LSeries g s

full_name: LSeriesSummable
code: /-- `LSeriesSummable f s` indicates that the L-series of `f` converges absolutely at `s`. -/
def LSeriesSummable (f : ℕ → ℂ) (s : ℂ) : Prop 
goal: Prop

full_name: LSeriesSummable_congr
code: lemma LSeriesSummable_congr {f g : ℕ → ℂ} (s : ℂ) (h : ∀ {n}, n ≠ 0 → f n = g n) :
    LSeriesSummable f s ↔ LSeriesSummable g s 
goal: LSeriesSummable f s ↔ LSeriesSummable g s

full_name: LSeriesSummable.congr'
code: /-- If `f` and `g` agree on large `n : ℕ` and the `LSeries` of `f` converges at `s`,
then so does that of `g`. -/
lemma LSeriesSummable.congr' {f g : ℕ → ℂ} (s : ℂ) (h : f =ᶠ[atTop] g) (hf : LSeriesSummable f s) :
    LSeriesSummable g s 
goal: LSeriesSummable g s

full_name: LSeriesSummable_congr'
code: /-- If `f` and `g` agree on large `n : ℕ`, then the `LSeries` of `f` converges at `s`
if and only if that of `g` does. -/
lemma LSeriesSummable_congr' {f g : ℕ → ℂ} (s : ℂ) (h : f =ᶠ[atTop] g) :
    LSeriesSummable f s ↔ LSeriesSummable g s 
goal: LSeriesSummable f s ↔ LSeriesSummable g s

full_name: LSeries.eq_zero_of_not_LSeriesSummable
code: theorem LSeries.eq_zero_of_not_LSeriesSummable (f : ℕ → ℂ) (s : ℂ) :
    ¬ LSeriesSummable f s → LSeries f s = 0 
goal: ¬LSeriesSummable f s → LSeries f s = 0

full_name: LSeriesSummable_zero
code: @[simp]
theorem LSeriesSummable_zero {s : ℂ} : LSeriesSummable 0 s 
goal: LSeriesSummable 0 s

full_name: LSeriesHasSum
code: /-- This states that the L-series of the sequence `f` converges absolutely at `s` and that
the value there is `a`. -/
def LSeriesHasSum (f : ℕ → ℂ) (s a : ℂ) : Prop 
goal: Prop

full_name: LSeriesHasSum.LSeriesSummable
code: lemma LSeriesHasSum.LSeriesSummable {f : ℕ → ℂ} {s a : ℂ}
    (h : LSeriesHasSum f s a) : LSeriesSummable f s 
goal: LSeriesSummable f s

full_name: LSeriesHasSum.LSeries_eq
code: lemma LSeriesHasSum.LSeries_eq {f : ℕ → ℂ} {s a : ℂ}
    (h : LSeriesHasSum f s a) : LSeries f s = a 
goal: LSeries f s = a

full_name: LSeriesSummable.LSeriesHasSum
code: lemma LSeriesSummable.LSeriesHasSum {f : ℕ → ℂ} {s : ℂ} (h : LSeriesSummable f s) :
    LSeriesHasSum f s (LSeries f s) 
goal: LSeriesHasSum f s (LSeries f s)

full_name: LSeriesHasSum_iff
code: lemma LSeriesHasSum_iff {f : ℕ → ℂ} {s a : ℂ} :
    LSeriesHasSum f s a ↔ LSeriesSummable f s ∧ LSeries f s = a 
goal: LSeriesHasSum f s a ↔ LSeriesSummable f s ∧ LSeries f s = a

full_name: LSeriesHasSum_congr
code: lemma LSeriesHasSum_congr {f g : ℕ → ℂ} (s a : ℂ) (h : ∀ {n}, n ≠ 0 → f n = g n) :
    LSeriesHasSum f s a ↔ LSeriesHasSum g s a 
goal: LSeriesHasSum f s a ↔ LSeriesHasSum g s a

full_name: LSeriesSummable.of_re_le_re
code: lemma LSeriesSummable.of_re_le_re {f : ℕ → ℂ} {s s' : ℂ} (h : s.re ≤ s'.re)
    (hf : LSeriesSummable f s) : LSeriesSummable f s' 
goal: LSeriesSummable f s'

full_name: LSeriesSummable_iff_of_re_eq_re
code: theorem LSeriesSummable_iff_of_re_eq_re {f : ℕ → ℂ} {s s' : ℂ} (h : s.re = s'.re) :
    LSeriesSummable f s ↔ LSeriesSummable f s' 
goal: LSeriesSummable f s ↔ LSeriesSummable f s'

full_name: LSeries.delta
code: /-- The indicator function of `{1} ⊆ ℕ` with values in `ℂ`. -/
def LSeries.delta (n : ℕ) : ℂ 
goal: ℂ

full_name: LSeries.notation._aux_Mathlib_NumberTheory_LSeries_Basic___unexpand_LSeries_1
code: @[inherit_doc]
scoped[LSeries.notation] notation "L" => LSeries
goal: Lean.PrettyPrinter.Unexpander

full_name: LSeries.notation._aux_Mathlib_NumberTheory_LSeries_Basic___macroRules_LSeries_notation_termL_1
code: @[inherit_doc]
scoped[LSeries.notation] notation "L" => LSeries
goal: Lean.Macro

full_name: LSeries.notation.«_aux_Mathlib_NumberTheory_LSeries_Basic___macroRules_LSeries_notation_term↗__1»
code: /-- We introduce notation `↗f` for `f` interpreted as a function `ℕ → ℂ`.

Let `R` be a ring with a coercion to `ℂ`. Then we can write `↗χ` when `χ : DirichletCharacter R`
or `↗f` when `f : ArithmeticFunction R` or simply `f : N → R` with a coercion from `ℕ` to `N`
as an argument to `LSeries`, `LSeriesHasSum`, `LSeriesSummable` etc. -/
scoped[LSeries.notation] notation:max "↗" f:max => fun n : ℕ ↦ (f n : ℂ)
goal: Lean.Macro

full_name: LSeries.notation._aux_Mathlib_NumberTheory_LSeries_Basic___unexpand_LSeries_delta_1
code: @[inherit_doc]
scoped[LSeries.notation] notation "δ" => delta
goal: Lean.PrettyPrinter.Unexpander

full_name: LSeries.notation._aux_Mathlib_NumberTheory_LSeries_Basic___macroRules_LSeries_notation_termδ_1
code: @[inherit_doc]
scoped[LSeries.notation] notation "δ" => delta
goal: Lean.Macro

full_name: LSeries_zero
code: @[simp]
lemma LSeries_zero : LSeries 0 = 0 
goal: LSeries 0 = 0

full_name: LSeries.term_delta
code: lemma term_delta (s : ℂ) (n : ℕ) : term δ s n = if n = 1 then 1 else 0 
goal: LSeries.term LSeries.delta s n = if n = 1 then 1 else 0

full_name: LSeries.mul_delta_eq_smul_delta
code: lemma mul_delta_eq_smul_delta {f : ℕ → ℂ} : f * δ = f 1 • δ 
goal: f * LSeries.delta = f 1 • LSeries.delta

full_name: LSeries.mul_delta
code: lemma mul_delta {f : ℕ → ℂ} (h : f 1 = 1) : f * δ = δ 
goal: f * LSeries.delta = LSeries.delta

full_name: LSeries.delta_mul_eq_smul_delta
code: lemma delta_mul_eq_smul_delta {f : ℕ → ℂ} : δ * f = f 1 • δ 
goal: LSeries.delta * f = f 1 • LSeries.delta

full_name: LSeries.delta_mul
code: lemma delta_mul {f : ℕ → ℂ} (h : f 1 = 1) : δ * f = δ 
goal: LSeries.delta * f = LSeries.delta

full_name: LSeries_delta
code: /-- The L-series of `δ` is the constant function `1`. -/
lemma LSeries_delta : LSeries δ = 1 
goal: LSeries LSeries.delta = 1

full_name: LSeriesSummable.le_const_mul_rpow
code: /-- If the `LSeries` of `f` is summable at `s`, then `f n` is bounded in absolute value
by a constant times `n^(re s)`. -/
lemma LSeriesSummable.le_const_mul_rpow {f : ℕ → ℂ} {s : ℂ} (h : LSeriesSummable f s) :
    ∃ C, ∀ n ≠ 0, ‖f n‖ ≤ C * n ^ s.re 
goal: ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ s.re

full_name: LSeriesSummable.isBigO_rpow
code: /-- If the `LSeries` of `f` is summable at `s`, then `f = O(n^(re s))`. -/
lemma LSeriesSummable.isBigO_rpow {f : ℕ → ℂ} {s : ℂ} (h : LSeriesSummable f s) :
    f =O[atTop] fun n ↦ (n : ℝ) ^ s.re 
goal: f =O[Filter.atTop] fun n => ↑n ^ s.re

full_name: LSeriesSummable_of_le_const_mul_rpow
code: /-- If `f n` is bounded in absolute value by a constant times `n^(x-1)` and `re s > x`,
then the `LSeries` of `f` is summable at `s`. -/
lemma LSeriesSummable_of_le_const_mul_rpow {f : ℕ → ℂ} {x : ℝ} {s : ℂ} (hs : x < s.re)
    (h : ∃ C, ∀ n ≠ 0, ‖f n‖ ≤ C * n ^ (x - 1)) :
    LSeriesSummable f s 
goal: LSeriesSummable f s

full_name: LSeriesSummable_of_isBigO_rpow
code: /-- If `f = O(n^(x-1))` and `re s > x`, then the `LSeries` of `f` is summable at `s`. -/
lemma LSeriesSummable_of_isBigO_rpow {f : ℕ → ℂ} {x : ℝ} {s : ℂ} (hs : x < s.re)
    (h : f =O[atTop] fun n ↦ (n : ℝ) ^ (x - 1)) :
    LSeriesSummable f s 
goal: LSeriesSummable f s

full_name: LSeriesSummable_of_bounded_of_one_lt_re
code: /-- If `f` is bounded, then its `LSeries` is summable at `s` when `re s > 1`. -/
theorem LSeriesSummable_of_bounded_of_one_lt_re {f : ℕ → ℂ} {m : ℝ}
    (h : ∀ n ≠ 0, Complex.abs (f n) ≤ m) {s : ℂ} (hs : 1 < s.re) :
    LSeriesSummable f s 
goal: LSeriesSummable f s

full_name: LSeriesSummable_of_bounded_of_one_lt_real
code: /-- If `f` is bounded, then its `LSeries` is summable at `s : ℝ` when `s > 1`. -/
theorem LSeriesSummable_of_bounded_of_one_lt_real {f : ℕ → ℂ} {m : ℝ}
    (h : ∀ n ≠ 0, Complex.abs (f n) ≤ m) {s : ℝ} (hs : 1 < s) :
    LSeriesSummable f s 
goal: LSeriesSummable f ↑s