LeanBridge Blueprint

2. L-functions🔗

This chapter lists the LMFDB definitions in the category lfunction. Each definition links back to its LMFDB knowl. af, af.bernoulli_numbers, af.divisor_function, af.multiplicative and specialfunction.gamma also belong here, although their ids put them in another LMFDB category. It also lists the knowls about the LMFDB's data on this subject that have mathematical content, from the categories intro and rcs.

Definition2.1
uses 0used by 1✓L∃∀N

Arithmetic function. (LMFDB)

An arithmetic function is a complex-valued function whose domain is the positive integers.

Tau Ceti Review: ArithmeticFunction.

Lean code for Definition2.1●1 definition
  • defdefined in Mathlib/NumberTheory/ArithmeticFunction/Defs.lean
    complete
    def ArithmeticFunction.{u_1} (R : Type u_1) [Zero R] : Type u_1
    def ArithmeticFunction.{u_1} (R : Type u_1)
      [Zero R] : Type u_1
    An arithmetic function is a function from `ℕ` that maps 0 to 0. In the literature, they are
    often instead defined as functions from `ℕ+`. Multiplication on `ArithmeticFunctions` is by
    Dirichlet convolution. 
Definition2.2
uses 0
Used by 2
Reverse dependency previews
Preview
Definition 2.30
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Bernoulli numbers. (LMFDB)

The Bernoulli numbers are the rational numbers B_n that appear as coefficients of the formal power series

\frac{T}{e^T-1}=\sum_{n\ge 0}B_n\frac{T^n}{n!},

which has radius of convergence 2\pi.

Tau Ceti Review: bernoulli, bernoulliPowerSeries, bernoulliPowerSeries_mul_exp_sub_one.

Lean code for Definition2.2●5 declarations
  • defdefined in Mathlib/NumberTheory/Bernoulli.lean
    complete
    def bernoulli (n : ℕ) : ℚ
    def bernoulli (n : ℕ) : ℚ
    The Bernoulli numbers are defined to be `bernoulli'` with a parity sign. 
  • defdefined in Mathlib/NumberTheory/Bernoulli.lean
    complete
    def bernoulliPowerSeries.{u_1} (A : Type u_1) [CommRing A] [Algebra ℚ A] :
      PowerSeries A
    def bernoulliPowerSeries.{u_1} (A : Type u_1)
      [CommRing A] [Algebra ℚ A] :
      PowerSeries A
    The exponential generating function for the Bernoulli numbers `bernoulli n`. 
  • theoremdefined in Mathlib/NumberTheory/Bernoulli.lean
    complete
    theorem bernoulliPowerSeries_mul_exp_sub_one.{u_1} (A : Type u_1) [CommRing A]
      [Algebra ℚ A] :
      bernoulliPowerSeries A * (PowerSeries.exp A - 1) = PowerSeries.X
    theorem bernoulliPowerSeries_mul_exp_sub_one.{u_1}
      (A : Type u_1) [CommRing A]
      [Algebra ℚ A] :
      bernoulliPowerSeries A *
          (PowerSeries.exp A - 1) =
        PowerSeries.X
  • defdefined in LeanBridge/ForMathlib/NumberTheory/BernoulliRadius.lean
    complete
    def bernoulliSeries : FormalMultilinearSeries ℂ ℂ ℂ
    def bernoulliSeries :
      FormalMultilinearSeries ℂ ℂ ℂ
    The power series `∑ Bₙ Tⁿ / n!` (LMFDB `af.bernoulli_numbers`) over `ℂ`, as a formal
    multilinear series: its coefficients are those of Mathlib's `bernoulliPowerSeries ℂ`, the formal
    power series of `T / (e^T - 1)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/BernoulliRadius.lean
    complete
    theorem radius_bernoulliSeries :
      bernoulliSeries.radius = ENNReal.ofReal (2 * Real.pi)
    theorem radius_bernoulliSeries :
      bernoulliSeries.radius =
        ENNReal.ofReal (2 * Real.pi)
    **The power series `∑ Bₙ Tⁿ / n!` of `T / (e^T - 1)` has radius of convergence `2π`** (LMFDB
    `af.bernoulli_numbers`): `|B₂ₖ| / (2k)! = 2 ζ(2k) / (2π)^{2k}` with `1 ≤ ζ(2k) ≤ 2` for `k ≥ 1`,
    and the odd Bernoulli numbers vanish beyond `B₁`. 
Definition2.3
Statement uses 2
Statement dependency previews
Preview
Definition 2.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 3
Reverse dependency previews
Preview
Definition 3.1.28
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Divisor function. (LMFDB)

A divisor function is a multiplicative arithmetic function of the form

\sigma_{\tau}(n)=\sum_{d\mid n}d^\tau,

for some fixed \tau\in\mathbb{C}.

Tau Ceti Review: ArithmeticFunction.sigma.

Depends on: Definition 2.1 Definition 2.4

Lean code for Definition2.3●4 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ArithmeticFunction/DivisorFunction.lean
    complete
    def ArithmeticFunction.divisorFunction (τ : ℂ) : ArithmeticFunction ℂ
    def ArithmeticFunction.divisorFunction
      (τ : ℂ) : ArithmeticFunction ℂ
    The **divisor function** `σ_τ(n) = ∑_{d ∣ n} d ^ τ` (LMFDB `af.divisor_function`) for a complex
    exponent `τ`, as an arithmetic function with complex values. For a natural exponent `k` it is
    Mathlib's `ArithmeticFunction.sigma k` (`divisorFunction_natCast`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ArithmeticFunction/DivisorFunction.lean
    complete
    theorem ArithmeticFunction.isMultiplicative_divisorFunction (τ : ℂ) :
      (ArithmeticFunction.divisorFunction τ).IsMultiplicative
    theorem ArithmeticFunction.isMultiplicative_divisorFunction
      (τ : ℂ) :
      (ArithmeticFunction.divisorFunction
          τ).IsMultiplicative
    The divisor function is multiplicative. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ArithmeticFunction/DivisorFunction.lean
    complete
    theorem ArithmeticFunction.divisorFunction_natCast (n k : ℕ) :
      (ArithmeticFunction.divisorFunction ↑k) n =
        ↑((ArithmeticFunction.sigma k) n)
    theorem ArithmeticFunction.divisorFunction_natCast
      (n k : ℕ) :
      (ArithmeticFunction.divisorFunction ↑k)
          n =
        ↑((ArithmeticFunction.sigma k) n)
    For a natural exponent `k`, the divisor function is Mathlib's `σ k`. 
  • defdefined in Mathlib/NumberTheory/ArithmeticFunction/Misc.lean
    complete
    def ArithmeticFunction.sigma (k : ℕ) : ArithmeticFunction ℕ
    def ArithmeticFunction.sigma (k : ℕ) :
      ArithmeticFunction ℕ
    `σ k n` is the sum of the `k`th powers of the divisors of `n` 
Definition2.4
uses 0used by 1✓L∃∀N

Multiplicative arithmetic function. (LMFDB)

An arithmetic function f:\mathbb{Z}_{>0}\to \C is multiplicative if f(mn)=f(m)f(n) for all coprime integers m,n>0, and is not the zero-function (in particular, f(1)=1).

Tau Ceti Review: ArithmeticFunction.IsMultiplicative.

Lean code for Definition2.4●1 definition
  • defdefined in Mathlib/NumberTheory/ArithmeticFunction/Defs.lean
    complete
    def ArithmeticFunction.IsMultiplicative.{u_1} {R : Type u_1}
      [MonoidWithZero R] (f : ArithmeticFunction R) : Prop
    def ArithmeticFunction.IsMultiplicative.{u_1}
      {R : Type u_1} [MonoidWithZero R]
      (f : ArithmeticFunction R) : Prop
    Multiplicative functions 
Definition2.5
Statement uses 2
Statement dependency previews
Preview
Definition 2.20
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Introduction/Features. (LMFDB)

In the LMFDB, we aim for every object to have its own homepage. Note the following features:

Knowls: Interspersed throughout the LMFDB are underlined words. These words represent knowls, which are bits of context free information. A knowl is identified by a word or phrase underlined with a dotted line. Clicking on a knowl brings up a box of text containing information about the object. Clicking on the knowl a second time will retract the box of text.

Navigating:

  • *Browsing:* One way to investigate information on the database is

through browsing. For each type of object in the database, you can browse by distinguishing features. For example, to look for information about L-functions, you can browse by degree or underlying object.

  • *Searching:* Another way to investigate is through searching. You

can search either by using a label to find a specific object or by specifying certain characteristics an object may have. For each of these types of searching, there is an example in grey text, and a description of possible inputs. Some fields may be left blank (or with grey text) in a search.

  • *Navigation Bars:* On a given page, additional headings may appear in

the navigation bar. For example Learn More About, which contains additional information, and Downloads or Data, for files.

  • *Breadcrumbs:* On the top left of the header of a given page there is

a description of your current path of navigation. Clicking on an item in the path will take you back to that page.

Properties: On the upper right hand side of a homepage for an object there is often a box containing specific properties of the object. This box can be closed and opened by clicking on the vertical arrow.

Related Objects: Often below the properties box in the upper right hand side of a homepage for an object is a box containing links to the homepages of directly related objects.

Zeros of L-functions Search: For each L-function in the database we have identified the lowest zero above the real axis. It is believed that the value of this zero uniquely identifies an L-function. This gives an interesting and useful way of identifying an L-function.

Downloading: You may download available data, for example moment polynomials of the zeta function. Some data is available to download within a page, while other data may be obtained through a link in the navigation bar.

Feedback: If you encounter any issues or problems while using the LMFDB, please click on Feedback in the upper right hand corner of the header to file a report.

Depends on: Definition 2.20 Definition 2.68

Definition2.6
Statement uses 20
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

A tour of the Riemann zeta function. (LMFDB)

The simplest of all L-functions is the Riemann zeta function, a function whose analytic properties were first discovered by Bernhard Riemann in 1859 in his attempts to find a formula for the number of primes smaller than a given number x. It gives us a model for how to think about other L-functions.

Let's begin by taking a look at this prototype: the Riemann zeta function homepage.

The first thing we see is that the Riemann zeta function can be defined as a special type of infinite series, called a Dirichlet series:

\zeta(s):=1+\frac1{2^s}+\frac1{3^s}+\frac1{4^s}+\cdots.

This is the classical definition of \zeta(s) and holds in the half plane Re(s)>1.

All L-functions can be expressed as Dirichlet series. On this website we normalize each Dirichlet series so that it converges absolutely for Re (s)>1.

The page then exhibits the functional equation, an equation that relates the values of this L-function on the left and on the right of the line Re (s)= 1/2. A key component of the functional equation is that it involves Euler's Gamma function, which is well known as a function that interpolates factorials. Again, this is typical of all L-functions: there is a functional equation involving the product of the L-function and some Gamma functions and relates the values at s and 1-s. The Selberg data is a way of encoding the functional equation; details at the bottom of this page.

The page then goes on by showing the Euler product formula of the L-function. In the case of \zeta(s), this was discovered by Leonhard Euler and later used by Riemann as a starting point for investigating prime numbers. In particular, Riemann showed that the distribution of prime numbers is determined by the location of the zeros of \zeta(s). All L-functions have an Euler product, i.e. they have an expression as an infinite product over primes where the factor for each prime is the inverse of a polynomial in p^{-s}.

Next we find the imaginary parts of the first few zeros of the Riemann zeta function. Riemann's Hypothesis is that any non-trivial zero of the zeta function has real part 1/2. Moreover, it's hypothesized that any non-trivial zero of any L-function has real part 1/2. This is true, so far, for every zero ever found. Consequently on these pages we only display the imaginary parts of the zeros. The first non-trivial zero of the Riemann zeta function is at 1/2+ i 14.1347... and was actually computed by Riemann himself. It has been checked that the first 10 trillion zeros of the Riemann zeta function all have real part 1/2, where the zeros are written in increasing order of their imaginary part. On these pages we have high precision rendering of the first 36 billion zeros; see http://www.lmfdb.org/zeros/zeta/.

Further information found on the Riemann zeta function page is the list of values the function takes at some special points. Again, this is typical of L-functions. The special values of L-functions form a remarkable area of modern research. The Birch and Swinnerton-Dyer Conjecture, mentioned above as one of the Clay Millennium problems, has to do with the special values of L-functions associated with elliptic curves.

Finally the page concludes by displaying the graph of the Hardy Z-function. This function has the same modulus as \zeta(s) on the critical line, so its graph helps to provide a visual picture of the Riemann zeta function. In particular, the Z-function has the same zeros as the L-function and so for this one we can see the first zero at 14.1347...

In order to successfully navigate the L-functions pages you need to know a little bit about how we classify L-functions. As we mentioned, each L-function has a Dirichlet series, a functional equation, and an Euler product. We sort our L-functions first by degree, then by conductor.

There is a certain amount of compatibility between these expressions. For example, it is believed that the Euler product can always be written as a product over primes of the inverse of a polynomial in p^{-s}. In all known cases, at almost all primes the degree of this polynomial is the same as the number of Gamma factors in the functional equation!

We specify a functional equation by providing its Selberg data; this is a 4-tuple which has the shape (degree, conductor, Gamma-shifts, sign), or:

(d,N,(\mu_1,\dots , \mu_{J}:\nu_{1},\dots ,\nu_{K}),\varepsilon).

Here the degree d=J+2K is a positive integer, the conductor N is a positive integer, the \mu are complex numbers with non-negative real parts and imaginary parts which sum to 0, and the sign \epsilon is a complex number with absolute value 1.

For example, the LMFDB page for the Riemann zeta function identifies its Selberg data using the notation (1,1,(0:),1), where the first value 1 is the degree, the second is the conductor, (0:) indicates the spectral parameters and the last 1 is the sign of the functional equation.

Depends on: Definition 4.1.64 Definition 4.1.70 Definition 2.7 Definition 2.17 Definition 2.18 Definition 2.20 Definition 2.22 Definition 2.24 Definition 2.25 Definition 2.26 Definition 2.47 Definition 2.51 Definition 2.55 Definition 2.58 Definition 2.60 Definition 2.63 Definition 2.66 Definition 2.68 Definition 2.69 Definition 2.76

Definition2.7
Statement uses 3
Statement dependency previews
Preview
Definition 2.22
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 47
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

L-function. (LMFDB)

An (analytic) L-function is a Dirichlet series that has an Euler product and satisfies a certain type of functional equation.

It is expected that all L-functions satisfy the Riemann Hypothesis, that all of the zeros in the critical strip are on the critical line. Selberg has defined a class \mathcal S of Dirichlet series that satisfy the Selberg axioms. It is conjectured (but far from proven) that \mathcal S is precisely the set of all L-functions. Selberg's axioms have not been verified for all of the L-functions in this database but are known to hold for many of them.

It is also conjectured that a precise form of the functional equation holds for every element of \mathcal S. Under this assumption the functional equation is determined by a quadruple known as the Selberg data, consisting of the degree, conductor, spectral parameters, and sign.

Tau Ceti Review: LSeries.

Depends on: Definition 2.22 Definition 2.24 Definition 2.25

Lean code for Definition2.7●6 declarations
  • structure(14 fields)defined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    structure AnalyticLFunction : Type
    structure AnalyticLFunction : Type
    An **analytic L-function** (LMFDB `lfunction`), in its analytic normalisation: a Dirichlet
    series `L(s) = ∑ aₙ n ^ (-s)` that converges absolutely for `re s > 1`, has an Euler product and
    satisfies a **functional equation** (LMFDB `lfunction.functional_equation`) of the form
    
    `Λ(s) = N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ) L(s) = ε conj (Λ (1 - conj s))`
    
    with Selberg data `(N, μ, ν, ε)` and degree `d = J + 2 K`. The structure records the coefficients
    `aₙ`, the continuation `L(s)` of the series, which is holomorphic on `ℂ` except for at most a pole
    at `s = 1`, and the completed L-function `Λ(s)`, which is holomorphic except at `s = 0` and
    `s = 1`, the only possible poles of a completed L-function (they come from factors `ζ(s)`). The
    completion equals `N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ) L(s)` for `re s > 1`, hence as a
    meromorphic function by analytic continuation, and the functional equation is stated pointwise
    for `s ≠ 0, 1`, where no junk values intervene.
    
    The Euler product is encoded by the multiplicativity of the coefficients, with `a₁ = 1`, and by
    local factors `∑ₖ a_{pᵏ} Tᵏ = 1 / Fₚ(T)` for polynomials `Fₚ` of degree at most `d`, with equality
    exactly for the primes `p ∤ N` (LMFDB `lfunction.euler_product`, without the Ramanujan bounds
    `|αᵢ(p)| = 1` and `|βᵢ(p)| ≤ 1`, which are not known in general). 
    coeff : ℕ → ℂ
    The Dirichlet coefficients `aₙ`, in the analytic normalisation. 
    toFun : ℂ → ℂ
    The analytic continuation `L(s)` of the Dirichlet series. 
    completed : ℂ → ℂ
    The completed L-function `Λ(s)` (LMFDB `lfunction.completed`). 
    selbergData : AnalyticLFunction.SelbergData
    The Selberg data of the functional equation. 
    coeff_one : self.coeff 1 = 1
    coeff_mul_of_coprime : ∀ {m n : ℕ}, m.Coprime n → self.coeff (m * n) = self.coeff m * self.coeff n
    exists_eulerFactor : ∀ (p : ℕ),
      Nat.Prime p →
        ∃ F,
          F.natDegree ≤ self.selbergData.degree ∧
            (F.natDegree = self.selbergData.degree ↔ ¬p ∣ self.selbergData.conductor) ∧
              (↑F * PowerSeries.mk fun k => self.coeff (p ^ k)) = 1
    LSeriesSummable_coeff : ∀ {s : ℂ}, 1 < s.re → LSeriesSummable self.coeff s
    toFun_eq_LSeries : ∀ {s : ℂ}, 1 < s.re → self.toFun s = LSeries self.coeff s
    differentiableOn_toFun : DifferentiableOn ℂ self.toFun {1}ᶜ
    meromorphicAt_toFun : MeromorphicAt self.toFun 1
    completed_eq : ∀ {s : ℂ},
      1 < s.re → self.completed s = ↑self.selbergData.conductor ^ (s / 2) * self.selbergData.gammaFactor s * self.toFun s
    differentiableOn_completed : DifferentiableOn ℂ self.completed {0, 1}ᶜ
    completed_eq_sign_mul_conj : ∀ {s : ℂ},
      s ≠ 0 → s ≠ 1 → self.completed s = self.selbergData.sign * (starRingEnd ℂ) (self.completed (1 - (starRingEnd ℂ) s))
  • structure(8 fields)defined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    structure AnalyticLFunction.SelbergData : Type
    structure AnalyticLFunction.SelbergData : Type
    The **Selberg data** (LMFDB `lfunction.selbergdata`) of a functional equation
    `Λ(s) = N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ) L(s) = ε conj (Λ (1 - conj s))`: the
    **conductor** `N` (LMFDB `lfunction.conductor`), the **spectral parameters** `μⱼ` of the factors
    `Γ_ℝ` and `νₖ` of the factors `Γ_ℂ` (LMFDB `lfunction.spectral_parameters`), and the **sign** `ε`
    (LMFDB `lfunction.sign`). The degree, the first entry of the LMFDB's quadruple, is
    `AnalyticLFunction.SelbergData.degree`. As in the LMFDB, the spectral parameters are normalised
    so that each `re μⱼ` is `0` or `1` (assuming Selberg's eigenvalue conjecture), each `re νₖ` is a
    positive integer or half-integer, and `∑ μⱼ + 2 ∑ νₖ` is real; the LMFDB states that this makes
    the data of a functional equation unique, which is not proved here. 
    conductor : ℕ
    The conductor `N`. 
    μ : Multiset ℂ
    The spectral parameters `μⱼ` of the factors `Γ_ℝ(s + μⱼ)`. 
    ν : Multiset ℂ
    The spectral parameters `νₖ` of the factors `Γ_ℂ(s + νₖ)`. 
    sign : ℂ
    The sign `ε`. 
    conductor_pos : 0 < self.conductor
    re_eq_zero_or_one_of_mem_μ : ∀ x ∈ self.μ, x.re = 0 ∨ x.re = 1
    exists_two_mul_re_eq_of_mem_ν : ∀ x ∈ self.ν, ∃ k, 0 < k ∧ 2 * x.re = ↑k
    im_sum_add_two_mul_sum : (self.μ.sum + 2 * self.ν.sum).im = 0
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.selbergData (self : AnalyticLFunction) :
      AnalyticLFunction.SelbergData
    abbrev AnalyticLFunction.selbergData
      (self : AnalyticLFunction) :
      AnalyticLFunction.SelbergData
    The Selberg data of the functional equation. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.eqOn_toFun_of_coeff_eq (L : AnalyticLFunction)
      {L' : AnalyticLFunction}
      (h : ∀ (n : ℕ), n ≠ 0 → L.coeff n = L'.coeff n) :
      Set.EqOn L.toFun L'.toFun {1}ᶜ
    theorem AnalyticLFunction.eqOn_toFun_of_coeff_eq
      (L : AnalyticLFunction)
      {L' : AnalyticLFunction}
      (h :
        ∀ (n : ℕ),
          n ≠ 0 → L.coeff n = L'.coeff n) :
      Set.EqOn L.toFun L'.toFun {1}ᶜ
    The continuation of an analytic L-function is determined by its Dirichlet coefficients. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RiemannZeta.lean
    complete
    def AnalyticLFunction.zeta : AnalyticLFunction
    def AnalyticLFunction.zeta : AnalyticLFunction
    The **Riemann zeta function** (LMFDB `lfunction.riemann`) as an analytic L-function: the
    Dirichlet series `∑ n ^ (-s)`, with Euler factors `(1 - p ^ (-s))⁻¹`, continued by `riemannZeta`
    and completed by `completedRiemannZeta`, with Selberg data `(1, 1, (0 : ), 1)`. 
  • defdefined in Mathlib/NumberTheory/LSeries/Basic.lean
    complete
    def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ
    def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ
    The value of the L-series of the sequence `f` at the point `s`
    if it converges absolutely there, and `0` otherwise. 
Definition2.8
Statement uses 3
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1✓L∃∀N

Analytic conductor. (LMFDB)

The analytic conductor of an L-function L(s) with infinity factor L_{\infty}(s) and conductor N is the real number

A := \mathrm{exp}\left(2\mathrm{Re}\left(\frac{L_{\infty}'(1/2)}{L_{\infty}(1/2)}\right)\right)N.

Depends on: Definition 2.7 Definition 2.17 Definition 2.39

Lean code for Definition2.8●6 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticConductor.lean
    complete
    def AnalyticLFunction.analyticConductor (L : AnalyticLFunction) : ℝ
    def AnalyticLFunction.analyticConductor
      (L : AnalyticLFunction) : ℝ
    The **analytic conductor** (LMFDB `lfunction.analytic_conductor`)
    `exp (2 re (L_∞'(1 / 2) / L_∞(1 / 2))) N` of an analytic L-function with gamma factor `L_∞(s)`
    (`AnalyticLFunction.SelbergData.gammaFactor`, LMFDB `lfunction.infinity_factor`) and conductor `N`.
    
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticConductor.lean
    complete
    def AnalyticLFunction.SelbergData.analyticConductor
      (D : AnalyticLFunction.SelbergData) : ℝ
    def AnalyticLFunction.SelbergData.analyticConductor
      (D : AnalyticLFunction.SelbergData) : ℝ
    The **analytic conductor** (LMFDB `lfunction.analytic_conductor`)
    `exp (2 re (L_∞'(1 / 2) / L_∞(1 / 2))) N` of a functional equation with gamma factor `L_∞(s)` and
    conductor `N`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.SelbergData.gammaFactor
      (D : AnalyticLFunction.SelbergData) (s : ℂ) : ℂ
    def AnalyticLFunction.SelbergData.gammaFactor
      (D : AnalyticLFunction.SelbergData)
      (s : ℂ) : ℂ
    The **gamma factor** `∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ)` (LMFDB `lfunction.infinity_factor`) of a
    functional equation, the product of its shifted Deligne gamma factors `Γ_ℝ` and `Γ_ℂ` (LMFDB
    `lfunction.gamma_factor`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.conductor (L : AnalyticLFunction) : ℕ
    def AnalyticLFunction.conductor
      (L : AnalyticLFunction) : ℕ
    The **conductor** (LMFDB `lfunction.conductor`) of an analytic L-function. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticConductor.lean
    complete
    theorem AnalyticLFunction.SelbergData.analyticConductor_pos
      (D : AnalyticLFunction.SelbergData) : 0 < D.analyticConductor
    theorem AnalyticLFunction.SelbergData.analyticConductor_pos
      (D : AnalyticLFunction.SelbergData) :
      0 < D.analyticConductor
    The analytic conductor is positive. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticConductor.lean
    complete
    theorem AnalyticLFunction.SelbergData.analyticConductor_eq_analyticConductorLMFDB
      (D : AnalyticLFunction.SelbergData) {k : ℤ} (hk : 0 < k)
      (hμ : D.μ = 0) (hν : D.ν = {(↑k - 1) / 2}) :
      D.analyticConductor =
        HeckeRing.GL2.Newform.analyticConductorLMFDB D.conductor k
    theorem AnalyticLFunction.SelbergData.analyticConductor_eq_analyticConductorLMFDB
      (D : AnalyticLFunction.SelbergData)
      {k : ℤ} (hk : 0 < k) (hμ : D.μ = 0)
      (hν : D.ν = {(↑k - 1) / 2}) :
      D.analyticConductor =
        HeckeRing.GL2.Newform.analyticConductorLMFDB
          D.conductor k
    For the gamma factor `Γ_ℂ(s + (k - 1) / 2)` of a newform of weight `k`, the analytic conductor
    is the analytic conductor `N (exp (ψ (k / 2)) / (2π))²` of a newform of level `N` and weight `k`. 
Definition2.9
Statement uses 2
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 10
Reverse dependency previews
Preview
Definition 2.70
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Analytic rank. (LMFDB)

The analytic rank of an L-function L(s) is its order of vanishing at its central point.

When the analytic rank r is positive, the value listed in the LMFDB is typically an upper bound that is believed to be tight (in the sense that there are known to be r zeroes located very near to the central point).

Depends on: Definition 2.13 Definition 2.7

Lean code for Definition2.9●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticRank.lean
    complete
    def AnalyticLFunction.analyticRank (L : AnalyticLFunction) : ℕ
    def AnalyticLFunction.analyticRank
      (L : AnalyticLFunction) : ℕ
    The **analytic rank** (LMFDB `lfunction.analytic_rank`) of an analytic L-function: the order
    of vanishing of its continuation at its central point `s = 1 / 2` (LMFDB
    `lfunction.central_point`). It is also the order of vanishing at `(w + 1) / 2` of the arithmetic
    normalisation of any weight `w` (`analyticOrderNatAt_arithmeticNormalization`). The LMFDB's stored
    values are typically upper bounds believed to be tight, a convention of its data. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticRank.lean
    complete
    theorem AnalyticLFunction.natCast_analyticRank (L : AnalyticLFunction) :
      ↑L.analyticRank = analyticOrderAt L.toFun (1 / 2)
    theorem AnalyticLFunction.natCast_analyticRank
      (L : AnalyticLFunction) :
      ↑L.analyticRank =
        analyticOrderAt L.toFun (1 / 2)
    The analytic rank is the order of vanishing at the central point, which is finite. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticRank.lean
    complete
    theorem AnalyticLFunction.iteratedDeriv_analyticRank_ne_zero
      (L : AnalyticLFunction) :
      iteratedDeriv L.analyticRank L.toFun (1 / 2) ≠ 0
    theorem AnalyticLFunction.iteratedDeriv_analyticRank_ne_zero
      (L : AnalyticLFunction) :
      iteratedDeriv L.analyticRank L.toFun
          (1 / 2) ≠
        0
    The derivative of order the analytic rank does not vanish at the central point. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticRank.lean
    complete
    theorem AnalyticLFunction.analyticOrderNatAt_arithmeticNormalization
      (L : AnalyticLFunction) (w : ℕ) :
      analyticOrderNatAt (L.arithmeticNormalization w) ((↑w + 1) / 2) =
        L.analyticRank
    theorem AnalyticLFunction.analyticOrderNatAt_arithmeticNormalization
      (L : AnalyticLFunction) (w : ℕ) :
      analyticOrderNatAt
          (L.arithmeticNormalization w)
          ((↑w + 1) / 2) =
        L.analyticRank
    The analytic rank is the order of vanishing of the arithmetic normalisation of weight `w` at
    its central point `(w + 1) / 2`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticRank.lean
    complete
    theorem AnalyticLFunction.analyticRank_congr (L : AnalyticLFunction)
      {L' : AnalyticLFunction}
      (h : ∀ (n : ℕ), n ≠ 0 → L.coeff n = L'.coeff n) :
      L.analyticRank = L'.analyticRank
    theorem AnalyticLFunction.analyticRank_congr
      (L : AnalyticLFunction)
      {L' : AnalyticLFunction}
      (h :
        ∀ (n : ℕ),
          n ≠ 0 → L.coeff n = L'.coeff n) :
      L.analyticRank = L'.analyticRank
    The analytic rank only depends on the Dirichlet coefficients. 
Definition2.10
uses 1
Used by 6
Reverse dependency previews
Preview
Definition 2.15
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Arithmetic L-function. (LMFDB)

An L-function L(s) = \sum_{n=1}^{\infty} a_n n^{-s} is called arithmetic if its Dirichlet coefficients a_n are algebraic numbers.

Tau Ceti Review: IsAlgebraic, LSeries.

Depends on: Definition 2.7

Lean code for Definition2.10●2 definitions
  • defdefined in Mathlib/RingTheory/Algebraic/Defs.lean
    complete
    def IsAlgebraic.{u, v} (R : Type u) {A : Type v} [CommRing R] [Ring A]
      [Algebra R A] (x : A) : Prop
    def IsAlgebraic.{u, v} (R : Type u)
      {A : Type v} [CommRing R] [Ring A]
      [Algebra R A] (x : A) : Prop
    An element of an R-algebra is algebraic over R if it is a root of a nonzero polynomial
    with coefficients in R. 
  • defdefined in Mathlib/NumberTheory/LSeries/Basic.lean
    complete
    def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ
    def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ
    The value of the L-series of the sequence `f` at the point `s`
    if it converges absolutely there, and `0` otherwise. 
Definition2.11
Statement uses 2
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Bad prime. (LMFDB)

The bad primes of an L-function are the primes that divided its conductor.

Tau Ceti Review: Nat.primeFactors.

Depends on: Definition 2.7 Definition 2.17

Lean code for Definition2.11●7 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.conductor (L : AnalyticLFunction) : ℕ
    def AnalyticLFunction.conductor
      (L : AnalyticLFunction) : ℕ
    The **conductor** (LMFDB `lfunction.conductor`) of an analytic L-function. 
  • defdefined in Mathlib/Data/Nat/PrimeFin.lean
    complete
    def Nat.primeFactors (n : ℕ) : Finset ℕ
    def Nat.primeFactors (n : ℕ) : Finset ℕ
    The prime factors of a natural number as a finset. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.exists_eulerFactor (self : AnalyticLFunction)
      (p : ℕ) :
      Nat.Prime p →
        ∃ F,
          F.natDegree ≤ self.selbergData.degree ∧
            (F.natDegree = self.selbergData.degree ↔
                ¬p ∣ self.selbergData.conductor) ∧
              (↑F * PowerSeries.mk fun k => self.coeff (p ^ k)) = 1
    theorem AnalyticLFunction.exists_eulerFactor
      (self : AnalyticLFunction) (p : ℕ) :
      Nat.Prime p →
        ∃ F,
          F.natDegree ≤
              self.selbergData.degree ∧
            (F.natDegree =
                  self.selbergData.degree ↔
                ¬p ∣
                    self.selbergData.conductor) ∧
              (↑F *
                  PowerSeries.mk fun k =>
                    self.coeff (p ^ k)) =
                1
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/BadPrime.lean
    complete
    def AnalyticLFunction.badPrimes (L : AnalyticLFunction) : Finset ℕ
    def AnalyticLFunction.badPrimes
      (L : AnalyticLFunction) : Finset ℕ
    The **bad primes** (LMFDB `lfunction.bad_prime`) of an analytic L-function: the primes that
    divide its conductor. By the axiom `exists_eulerFactor` on the degrees of the Euler factors, they
    are determined by the Dirichlet coefficients (`badPrimes_eq_of_coeff_eq`), hence by the L-function
    (`badPrimes_eq_of_toFun_eq`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/BadPrime.lean
    complete
    theorem AnalyticLFunction.dvd_conductor_iff (L : AnalyticLFunction) {p : ℕ}
      (hp : Nat.Prime p) :
      p ∣ L.conductor ↔ (PowerSeries.coeff L.degree) (L.eulerFactor p) = 0
    theorem AnalyticLFunction.dvd_conductor_iff
      (L : AnalyticLFunction) {p : ℕ}
      (hp : Nat.Prime p) :
      p ∣ L.conductor ↔
        (PowerSeries.coeff L.degree)
            (L.eulerFactor p) =
          0
    A prime divides the conductor exactly when the coefficient of `x ^ d` of its Euler factor
    vanishes, where `d` is the degree. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/BadPrime.lean
    complete
    theorem AnalyticLFunction.badPrimes_eq_of_coeff_eq (L : AnalyticLFunction)
      {L' : AnalyticLFunction}
      (h : ∀ (n : ℕ), n ≠ 0 → L.coeff n = L'.coeff n) :
      L.badPrimes = L'.badPrimes
    theorem AnalyticLFunction.badPrimes_eq_of_coeff_eq
      (L : AnalyticLFunction)
      {L' : AnalyticLFunction}
      (h :
        ∀ (n : ℕ),
          n ≠ 0 → L.coeff n = L'.coeff n) :
      L.badPrimes = L'.badPrimes
    **The bad primes are determined by the Dirichlet coefficients**: two analytic L-functions with
    the same coefficients `aₙ` (`n ≥ 1`) have the same bad primes, although their conductors are given
    by their Selberg data. The proof uses the axiom `exists_eulerFactor` on the degrees of the Euler
    factors. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/BadPrime.lean
    complete
    theorem AnalyticLFunction.badPrimes_eq_of_toFun_eq (L : AnalyticLFunction)
      {L' : AnalyticLFunction}
      (h : ∀ (s : ℂ), 1 < s.re → L.toFun s = L'.toFun s) :
      L.badPrimes = L'.badPrimes
    theorem AnalyticLFunction.badPrimes_eq_of_toFun_eq
      (L : AnalyticLFunction)
      {L' : AnalyticLFunction}
      (h :
        ∀ (s : ℂ),
          1 < s.re → L.toFun s = L'.toFun s) :
      L.badPrimes = L'.badPrimes
    **The bad primes are determined by the L-function**: two analytic L-functions that agree on
    the half-plane `re s > 1` have the same bad primes. 
Definition2.12
Statement uses 3
Statement dependency previews
Preview
Definition 2.17
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1XL∃∀N

Central character of an L-function. (LMFDB)

An L-function has an Euler product of the form L(s) = \prod_p L_p(p^{-s})^{-1} where L_p(x) = 1 + a_p x + \ldots + (-1)^d \chi(p) x^d. The character \chi is a Dirichlet character mod N and is called central character of the L-function. Here, N is the conductor of L.

Depends on: Definition 6.1.1 Definition 2.17 Definition 2.24

Definition2.13
Statement uses 3
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 9
Reverse dependency previews
Preview
Definition 2.9
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Central point of an L-function. (LMFDB)

The central point of an L-function is the point on the real axis of the critical line. Equivalently, it is the fixed point of the functional equation.

In the analytic normalization, the central point is s=1/2, in the arithmetic normalization, it is s=\frac{w+1}{2}, where w is the weight of the L-function.

Depends on: Definition 2.7 Definition 2.18 Definition 2.25

Lean code for Definition2.13●4 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CentralPoint.lean
    complete
    def AnalyticLFunction.centralPoint : ℂ
    def AnalyticLFunction.centralPoint : ℂ
    The **central point** (LMFDB `lfunction.central_point`) `s = 1 / 2` of an analytic L-function in
    its analytic normalisation: the point of the critical line on the real axis
    (`criticalLine_inter_im_eq_zero`), equivalently the fixed point of the functional equation, which
    relates `s` and `1 - conj s` (`one_sub_eq_self_iff`). It is the same point for every analytic
    L-function. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CentralPoint.lean
    complete
    def AnalyticLFunction.arithmeticCentralPoint (w : ℕ) : ℂ
    def AnalyticLFunction.arithmeticCentralPoint
      (w : ℕ) : ℂ
    The **central point** (LMFDB `lfunction.central_point`) `s = (w + 1) / 2` of an analytic
    L-function in its arithmetic normalisation of weight `w` (for the LMFDB, its motivic weight): the
    point of the critical line `re s = (1 + w) / 2` on the real axis
    (`arithmeticCriticalLine_inter_im_eq_zero`), equivalently the fixed point of the functional
    equation, which relates `s` and `1 + w - conj s` (`add_sub_eq_self_iff`). It is the translate of
    `centralPoint` by `w / 2`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CentralPoint.lean
    complete
    theorem AnalyticLFunction.criticalLine_inter_im_eq_zero :
      AnalyticLFunction.criticalLine ∩ Complex.im ⁻¹' {0} =
        {AnalyticLFunction.centralPoint}
    theorem AnalyticLFunction.criticalLine_inter_im_eq_zero :
      AnalyticLFunction.criticalLine ∩
          Complex.im ⁻¹' {0} =
        {AnalyticLFunction.centralPoint}
    The central point is the point of the critical line on the real axis. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CentralPoint.lean
    complete
    theorem AnalyticLFunction.one_sub_eq_self_iff {s : ℂ} :
      1 - s = s ↔ s = AnalyticLFunction.centralPoint
    theorem AnalyticLFunction.one_sub_eq_self_iff
      {s : ℂ} :
      1 - s = s ↔
        s = AnalyticLFunction.centralPoint
    The central point is the fixed point of the functional equation, which relates `s` and
    `1 - conj s`, or `1 - s` on the real axis. 
Definition2.14
Statement uses 3
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Central value of an L-function. (LMFDB)

The central value of an L-function is its value at the central point of the critical strip.

Depends on: Definition 2.7 Definition 2.13 Definition 2.19

Lean code for Definition2.14●3 declarations
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.toFun (self : AnalyticLFunction) : ℂ → ℂ
    abbrev AnalyticLFunction.toFun
      (self : AnalyticLFunction) : ℂ → ℂ
    The analytic continuation `L(s)` of the Dirichlet series. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticRank.lean
    complete
    theorem AnalyticLFunction.analyticRank_eq_zero_iff (L : AnalyticLFunction) :
      L.analyticRank = 0 ↔ L.toFun (1 / 2) ≠ 0
    theorem AnalyticLFunction.analyticRank_eq_zero_iff
      (L : AnalyticLFunction) :
      L.analyticRank = 0 ↔ L.toFun (1 / 2) ≠ 0
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.arithmeticNormalization_add (L : AnalyticLFunction)
      (w : ℕ) (s : ℂ) : L.arithmeticNormalization w (s + ↑w / 2) = L.toFun s
    theorem AnalyticLFunction.arithmeticNormalization_add
      (L : AnalyticLFunction) (w : ℕ)
      (s : ℂ) :
      L.arithmeticNormalization w
          (s + ↑w / 2) =
        L.toFun s
Definition2.15
Statement uses 4
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1XL∃∀N

Coefficient field of an L-function. (LMFDB)

The coefficient field of an arithmetic L-function L(s)=\sum a_nn^{-s} is the number field generated by the algebraic integers a_nn^{w/2}, where w is the motivic weight.

Depends on: Definition 2.7 Definition 2.10 Definition 2.46 Definition 5.1.1

Definition2.16
Statement uses 3
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1✓L∃∀N

Completed L-function. (LMFDB)

If the L-function L(s) satisfies the functional equation

\Lambda(s) := N^{s/2} \prod_{j=1}^J \Gamma_{\mathbb{R}}(s+\mu_j) \prod_{k=1}^K \Gamma_{\mathbb{C}}(s+\nu_k) \cdot L(s) = \varepsilon \overline{\Lambda}(1-s),

then \Lambda(s) is called the completed L-function.

The completed L-function is the product of the L-function and its gamma factors.

Depends on: Definition 2.7 Definition 2.25 Definition 2.26

Lean code for Definition2.16●6 declarations
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.completed (self : AnalyticLFunction) : ℂ → ℂ
    abbrev AnalyticLFunction.completed
      (self : AnalyticLFunction) : ℂ → ℂ
    The completed L-function `Λ(s)` (LMFDB `lfunction.completed`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_eq (self : AnalyticLFunction) {s : ℂ} :
      1 < s.re →
        self.completed s =
          ↑self.selbergData.conductor ^ (s / 2) *
              self.selbergData.gammaFactor s *
            self.toFun s
    theorem AnalyticLFunction.completed_eq
      (self : AnalyticLFunction) {s : ℂ} :
      1 < s.re →
        self.completed s =
          ↑self.selbergData.conductor ^
                (s / 2) *
              self.selbergData.gammaFactor s *
            self.toFun s
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Completed.lean
    complete
    theorem AnalyticLFunction.completed_eq_of_notMem_gammaPoles
      (L : AnalyticLFunction) {s : ℂ} (hs : s ∉ L.selbergData.gammaPoles)
      (hs₀ : s ≠ 0) (hs₁ : s ≠ 1) :
      L.completed s =
        ↑L.conductor ^ (s / 2) * L.selbergData.gammaFactor s * L.toFun s
    theorem AnalyticLFunction.completed_eq_of_notMem_gammaPoles
      (L : AnalyticLFunction) {s : ℂ}
      (hs : s ∉ L.selbergData.gammaPoles)
      (hs₀ : s ≠ 0) (hs₁ : s ≠ 1) :
      L.completed s =
        ↑L.conductor ^ (s / 2) *
            L.selbergData.gammaFactor s *
          L.toFun s
    **The completed L-function is the product of the L-function, its gamma factor and
    `N ^ (s / 2)`** (LMFDB `lfunction.completed`):
    `Λ(s) = N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ) L(s)` at every `s ≠ 0, 1` that is not a pole of
    the gamma factor. The axioms give it for `re s > 1`; both sides are analytic on the complement of
    the poles and of `0` and `1`, which is connected. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_eq_sign_mul_conj (self : AnalyticLFunction)
      {s : ℂ} :
      s ≠ 0 →
        s ≠ 1 →
          self.completed s =
            self.selbergData.sign *
              (starRingEnd ℂ) (self.completed (1 - (starRingEnd ℂ) s))
    theorem AnalyticLFunction.completed_eq_sign_mul_conj
      (self : AnalyticLFunction) {s : ℂ} :
      s ≠ 0 →
        s ≠ 1 →
          self.completed s =
            self.selbergData.sign *
              (starRingEnd ℂ)
                (self.completed
                  (1 - (starRingEnd ℂ) s))
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.SelbergData.gammaFactor
      (D : AnalyticLFunction.SelbergData) (s : ℂ) : ℂ
    def AnalyticLFunction.SelbergData.gammaFactor
      (D : AnalyticLFunction.SelbergData)
      (s : ℂ) : ℂ
    The **gamma factor** `∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ)` (LMFDB `lfunction.infinity_factor`) of a
    functional equation, the product of its shifted Deligne gamma factors `Γ_ℝ` and `Γ_ℂ` (LMFDB
    `lfunction.gamma_factor`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/TrivialZero.lean
    complete
    def AnalyticLFunction.SelbergData.gammaPoles
      (D : AnalyticLFunction.SelbergData) : Set ℂ
    def AnalyticLFunction.SelbergData.gammaPoles
      (D : AnalyticLFunction.SelbergData) :
      Set ℂ
    The **poles of the gamma factors** (LMFDB `lfunction.gamma_factor`) `Γ_ℝ(s + μⱼ)` and
    `Γ_ℂ(s + νₖ)` of a functional equation: the points `-μⱼ - 2n` and `-νₖ - n` for `n ∈ ℕ`, the poles
    of `Γ((s + μⱼ) / 2)` and `Γ(s + νₖ)`. Since `Γ` has no zeros, these are also the poles of the
    product `AnalyticLFunction.SelbergData.gammaFactor`. 
Definition2.17
Statement uses 5
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 9
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
XL∃∀N

Conductor of an L-function. (LMFDB)

The conductor of an L-function is the integer N occurring in its functional equation

\Lambda(s) := N^{s/2} \prod_{j=1}^J \Gamma_{\mathbb{R}}(s+\mu_j) \prod_{k=1}^K \Gamma_{\mathbb{C}}(s+\nu_k) \cdot L(s) = \varepsilon \overline{\Lambda}(1-s).

The conductor of an analytic L-function is the second component in the Selberg data. For a Dirichlet L-function associated with a primitive Dirichlet character, the conductor of the L-function is the same as the conductor of the character. For a primitive L-function associated with a cusp form \phi on GL(2)/\mathbb{Q}, the conductor of the L-function is the same as the level of \phi.

In the literature, the word level is sometimes used instead of conductor.

Depends on: Definition 6.1.1 Definition 6.1.2 Definition 3.1.14 Definition 2.7 Definition 2.25

Definition2.18
Statement uses 2
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 7
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Critical line of an L-function. (LMFDB)

The critical line of an L-function is the line of symmetry of its functional equation.

In the analytic normalization, the functional equation relates s to 1-s and the critical line is the line \Re(s) = \frac12.

In the arithmetic normalization, the functional equation relates s to 1 + w - s, where w is the motivic weight. In that normalization the critical line is \Re(s) = \frac{1+w}2.

Depends on: Definition 2.7 Definition 2.25

Lean code for Definition2.18●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CriticalStrip.lean
    complete
    def AnalyticLFunction.criticalLine : Set ℂ
    def AnalyticLFunction.criticalLine : Set ℂ
    The **critical line** (LMFDB `lfunction.critical_line`) `re s = 1 / 2` of an analytic
    L-function in its analytic normalisation: the line of symmetry of its functional equation, which
    relates `s` and `1 - conj s` (`mem_criticalLine_iff_one_sub_conj_eq`). It is the same line for
    every analytic L-function. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CriticalStrip.lean
    complete
    def AnalyticLFunction.arithmeticCriticalLine (w : ℕ) : Set ℂ
    def AnalyticLFunction.arithmeticCriticalLine
      (w : ℕ) : Set ℂ
    The **critical line** (LMFDB `lfunction.critical_line`) `re s = (1 + w) / 2` of an analytic
    L-function in its arithmetic normalisation of weight `w` (for the LMFDB, its motivic weight
    `AnalyticLFunction.motivicWeight`): the line of symmetry of the functional equation, which then
    relates `s` and `1 + w - conj s` (`mem_arithmeticCriticalLine_iff_add_sub_conj_eq`). It is the
    translate of `criticalLine` by `w / 2`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CriticalStrip.lean
    complete
    theorem AnalyticLFunction.mem_criticalLine_iff_one_sub_conj_eq {s : ℂ} :
      s ∈ AnalyticLFunction.criticalLine ↔ 1 - (starRingEnd ℂ) s = s
    theorem AnalyticLFunction.mem_criticalLine_iff_one_sub_conj_eq
      {s : ℂ} :
      s ∈ AnalyticLFunction.criticalLine ↔
        1 - (starRingEnd ℂ) s = s
    The critical line is the line of symmetry of the functional equation
    `Λ(s) = ε conj (Λ (1 - conj s))`: the set of fixed points of `s ↦ 1 - conj s`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CriticalStrip.lean
    complete
    theorem AnalyticLFunction.mem_arithmeticCriticalLine_iff_add_sub_conj_eq {w : ℕ}
      {s : ℂ} :
      s ∈ AnalyticLFunction.arithmeticCriticalLine w ↔
        1 + ↑w - (starRingEnd ℂ) s = s
    theorem AnalyticLFunction.mem_arithmeticCriticalLine_iff_add_sub_conj_eq
      {w : ℕ} {s : ℂ} :
      s ∈
          AnalyticLFunction.arithmeticCriticalLine
            w ↔
        1 + ↑w - (starRingEnd ℂ) s = s
    In the arithmetic normalisation of weight `w`, the critical line is the line of symmetry of the
    functional equation: the set of fixed points of `s ↦ 1 + w - conj s`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CriticalStrip.lean
    complete
    theorem AnalyticLFunction.riemannHypothesis_iff_mem_criticalLine
      (L : AnalyticLFunction) :
      L.RiemannHypothesis ↔
        ∀ ρ ∈ L.zeros, 0 < ρ.re → ρ ∈ AnalyticLFunction.criticalLine
    theorem AnalyticLFunction.riemannHypothesis_iff_mem_criticalLine
      (L : AnalyticLFunction) :
      L.RiemannHypothesis ↔
        ∀ ρ ∈ L.zeros,
          0 < ρ.re →
            ρ ∈ AnalyticLFunction.criticalLine
    The Riemann hypothesis for an analytic L-function says that its zeros `ρ` with `re ρ > 0` lie
    on the critical line. 
Definition2.19
Statement uses 5
Statement dependency previews
Preview
Definition 2.22
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 3
Reverse dependency previews
Preview
Definition 2.14
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Critical strip. (LMFDB)

In the analytic normalization, the functional equation relates s to 1-s and the critical strip is the open strip \{ s \in {\mathbb{C}}: 0 < \Re(s) < 1 \}.

In the arithmetic normalization, the functional equation relates s to 1 + w - s, where w is the motivic weight of the L-function, and the critical strip is the open strip \{ s \in {\mathbb{C}}: w/2 < \Re(s) < w/2 + 1 \}.

In either normalization, the Dirichlet series and Euler product converge absolutely to the right of the critical strip, and so the L-function does not vanish there. Therefore all nontrivial zeros of the L-function lie in (the closure of) the critical strip.

Depends on: Definition 2.22 Definition 2.24 Definition 2.25 Definition 2.46 Definition 2.47

Lean code for Definition2.19●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CriticalStrip.lean
    complete
    def AnalyticLFunction.criticalStrip : Set ℂ
    def AnalyticLFunction.criticalStrip : Set ℂ
    The **critical strip** (LMFDB `lfunction.critical_strip`) `0 < re s < 1` of an analytic
    L-function in its analytic normalisation, whose functional equation relates `s` and `1 - conj s`.
    To its right the Dirichlet series and the Euler product converge absolutely
    (`AnalyticLFunction.LSeriesSummable_coeff`, `summable_norm_tsum_term_prime_pow_sub_one`) and the
    L-function does not vanish (`toFun_ne_zero`), so the zeros `ρ` with `re ρ > 0` lie in its closure
    (`mem_closure_criticalStrip`), and so do the zeros of the completed L-function, which by the
    functional equation does not vanish to the left of the strip either
    (`mem_closure_criticalStrip_of_completed_eq_zero`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CriticalStrip.lean
    complete
    def AnalyticLFunction.arithmeticCriticalStrip (w : ℕ) : Set ℂ
    def AnalyticLFunction.arithmeticCriticalStrip
      (w : ℕ) : Set ℂ
    The **critical strip** (LMFDB `lfunction.critical_strip`) `w / 2 < re s < w / 2 + 1` of an
    analytic L-function in its arithmetic normalisation of weight `w` (for the LMFDB, its motivic
    weight), whose functional equation relates `s` and `1 + w - conj s`. It is the translate of
    `criticalStrip` by `w / 2`. To its right the Dirichlet series converges absolutely
    (`LSeriesSummable_arithmeticCoeff`) and the L-function does not vanish
    (`arithmeticNormalization_ne_zero`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CriticalStrip.lean
    complete
    theorem AnalyticLFunction.summable_norm_tsum_term_prime_pow_sub_one
      (L : AnalyticLFunction) {s : ℂ} (hs : 1 < s.re) :
      Summable fun p => ‖∑' (e : ℕ), LSeries.term L.coeff s (↑p ^ e) - 1‖
    theorem AnalyticLFunction.summable_norm_tsum_term_prime_pow_sub_one
      (L : AnalyticLFunction) {s : ℂ}
      (hs : 1 < s.re) :
      Summable fun p =>
        ‖∑' (e : ℕ),
              LSeries.term L.coeff s
                (↑p ^ e) -
            1‖
    To the right of its critical strip, the Euler product of an analytic L-function converges
    absolutely: the series `∑ₚ |Lₚ(s) - 1|` over the primes converges, where `Lₚ(s)` is the Euler
    factor `∑ₖ a_{pᵏ} p ^ (-k s)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CriticalStrip.lean
    complete
    theorem AnalyticLFunction.toFun_ne_zero (L : AnalyticLFunction) {s : ℂ}
      (hs : 1 < s.re) : L.toFun s ≠ 0
    theorem AnalyticLFunction.toFun_ne_zero
      (L : AnalyticLFunction) {s : ℂ}
      (hs : 1 < s.re) : L.toFun s ≠ 0
    An analytic L-function does not vanish to the right of its critical strip. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/CriticalStrip.lean
    complete
    theorem AnalyticLFunction.mem_closure_criticalStrip_of_completed_eq_zero
      (L : AnalyticLFunction) {ρ : ℂ} (hρ : L.completed ρ = 0) :
      ρ ∈ closure AnalyticLFunction.criticalStrip
    theorem AnalyticLFunction.mem_closure_criticalStrip_of_completed_eq_zero
      (L : AnalyticLFunction) {ρ : ℂ}
      (hρ : L.completed ρ = 0) :
      ρ ∈
        closure
          AnalyticLFunction.criticalStrip
    The zeros of the completed L-function `Λ(s) = N ^ (s / 2) γ(s) L(s)`, in which the trivial zeros
    of `L` at the poles of the gamma factor `γ` are cancelled, lie in the closure of the critical
    strip: `Λ` does not vanish for `re s > 1`, nor, by the functional equation, for `re s < 0`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/NontrivialZero.lean
    complete
    theorem AnalyticLFunction.summable_norm_tsum_term_arithmeticCoeff_prime_pow_sub_one
      (L : AnalyticLFunction) {w : ℕ} {s : ℂ} (hs : ↑w / 2 + 1 < s.re) :
      Summable fun p =>
        ‖∑' (e : ℕ), LSeries.term (L.arithmeticCoeff w) s (↑p ^ e) - 1‖
    theorem AnalyticLFunction.summable_norm_tsum_term_arithmeticCoeff_prime_pow_sub_one
      (L : AnalyticLFunction) {w : ℕ} {s : ℂ}
      (hs : ↑w / 2 + 1 < s.re) :
      Summable fun p =>
        ‖∑' (e : ℕ),
              LSeries.term
                (L.arithmeticCoeff w) s
                (↑p ^ e) -
            1‖
    In the arithmetic normalisation of weight `w`, to the right of its critical strip, the Euler
    product of an analytic L-function converges absolutely: the series `∑ₚ |Lₚ(s) - 1|` over the primes
    converges, where `Lₚ(s)` is the Euler factor `∑ₖ a_{pᵏ} p ^ (k w / 2) p ^ (-k s)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/NontrivialZero.lean
    complete
    theorem AnalyticLFunction.zeros_diff_trivialZeros_subset_closure_criticalStrip
      (L : AnalyticLFunction) :
      L.zeros \ L.trivialZeros ⊆ closure AnalyticLFunction.criticalStrip
    theorem AnalyticLFunction.zeros_diff_trivialZeros_subset_closure_criticalStrip
      (L : AnalyticLFunction) :
      L.zeros \ L.trivialZeros ⊆
        closure
          AnalyticLFunction.criticalStrip
    **The nontrivial zeros of an analytic L-function lie in the closure of its critical strip**
    (LMFDB `lfunction.critical_strip`): its zeros that are not trivial zeros, at poles of its gamma
    factor, satisfy `0 ≤ re ρ ≤ 1`. Off the poles and `0` and `1` they are zeros of the completed
    L-function `Λ(s) = N ^ (s / 2) L_∞(s) L(s)`, which does not vanish outside the closed strip. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/NontrivialZero.lean
    complete
    theorem AnalyticLFunction.mem_closure_arithmeticCriticalStrip
      (L : AnalyticLFunction) {w : ℕ} {s : ℂ}
      (hs : s - ↑w / 2 ∈ L.zeros \ L.trivialZeros) :
      s ∈ closure (AnalyticLFunction.arithmeticCriticalStrip w)
    theorem AnalyticLFunction.mem_closure_arithmeticCriticalStrip
      (L : AnalyticLFunction) {w : ℕ} {s : ℂ}
      (hs :
        s - ↑w / 2 ∈
          L.zeros \ L.trivialZeros) :
      s ∈
        closure
          (AnalyticLFunction.arithmeticCriticalStrip
            w)
    **In the arithmetic normalisation, the nontrivial zeros lie in the closure of the critical
    strip** (LMFDB `lfunction.critical_strip`): the nontrivial zeros of the arithmetic normalisation
    `s ↦ L(s - w / 2)` of weight `w`, the `s` with `s - w / 2` a nontrivial zero of `L`, satisfy
    `w / 2 ≤ re s ≤ w / 2 + 1`. 
Definition2.20
Statement uses 4
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 11
Reverse dependency previews
Preview
Definition 2.5
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Degree of an L-function. (LMFDB)

The degree of an L-function is the number J + 2K of Gamma factors occurring in its functional equation

\Lambda(s) := N^{s/2} \prod_{j=1}^J \Gamma_{\mathbb{R}}(s+\mu_j) \prod_{k=1}^K \Gamma_{\mathbb{C}}(s+\nu_k) \cdot L(s) = \varepsilon \overline{\Lambda}(1-s).

The degree appears as the first component of the Selberg data of L(s). In all known cases it is the degree of the polynomial of the inverse of the Euler factor at any prime not dividing the conductor.

Depends on: Definition 2.7 Definition 2.17 Definition 2.25 Definition 2.26

Lean code for Definition2.20●3 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.degree (L : AnalyticLFunction) : ℕ
    def AnalyticLFunction.degree
      (L : AnalyticLFunction) : ℕ
    The **degree** (LMFDB `lfunction.degree`) of an analytic L-function. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.SelbergData.degree
      (D : AnalyticLFunction.SelbergData) : ℕ
    def AnalyticLFunction.SelbergData.degree
      (D : AnalyticLFunction.SelbergData) : ℕ
    The **degree** `J + 2 K` (LMFDB `lfunction.degree`) of a functional equation with `J` factors
    `Γ_ℝ` and `K` factors `Γ_ℂ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.exists_eulerFactor (self : AnalyticLFunction)
      (p : ℕ) :
      Nat.Prime p →
        ∃ F,
          F.natDegree ≤ self.selbergData.degree ∧
            (F.natDegree = self.selbergData.degree ↔
                ¬p ∣ self.selbergData.conductor) ∧
              (↑F * PowerSeries.mk fun k => self.coeff (p ^ k)) = 1
    theorem AnalyticLFunction.exists_eulerFactor
      (self : AnalyticLFunction) (p : ℕ) :
      Nat.Prime p →
        ∃ F,
          F.natDegree ≤
              self.selbergData.degree ∧
            (F.natDegree =
                  self.selbergData.degree ↔
                ¬p ∣
                    self.selbergData.conductor) ∧
              (↑F *
                  PowerSeries.mk fun k =>
                    self.coeff (p ^ k)) =
                1
Definition2.21
Statement uses 6
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Dirichlet L-function. (LMFDB)

A Dirichlet L-function is an L-function defined by a Dirichlet series of the form {\displaystyle L(s, \chi)=\sum_{n=1}^\infty \frac {\chi(n)}{n^s}}, where \chi is a Dirichlet character.

Dirichlet L-functions can be meromorphically continued to the complex plane, have an Euler product {\displaystyle L(s, \chi)= \prod_p (1 - \chi(p) p^{-s} )^{-1}}, and satisfy a functional equation of the form

\Lambda(s,\chi) = q^{s/2} \Gamma_{\mathbb{R}} (s) L(s,\chi) = \varepsilon_{\chi} \overline{\Lambda}(1-s),

where q is the conductor of \chi.

These L-functions were introduced by Peter Gustav Lejeune Dirichlet in the mid-1800s as a tool to study prime numbers in arithmetic progressions.

Tau Ceti Review: DirichletCharacter.LFunction, DirichletCharacter.LFunction_eq_LSeries, DirichletCharacter.IsPrimitive.completedLFunction_one_sub, DirichletCharacter.rootNumber.

Depends on: Definition 6.1.1 Definition 6.1.2 Definition 2.7 Definition 2.22 Definition 2.24 Definition 2.25

Lean code for Definition2.21●13 declarations
  • defdefined in Mathlib/NumberTheory/LSeries/DirichletContinuation.lean
    complete
    def DirichletCharacter.LFunction {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N) (s : ℂ) : ℂ
    def DirichletCharacter.LFunction {N : ℕ}
      [NeZero N] (χ : DirichletCharacter ℂ N)
      (s : ℂ) : ℂ
    The unique meromorphic function `ℂ → ℂ` which agrees with `∑' n : ℕ, χ n / n ^ s` wherever the
    latter is convergent. This is constructed as a linear combination of Hurwitz zeta functions.
    
    Note that this is not the same as `LSeries χ`: they agree in the convergence range, but
    `LSeries χ s` is defined to be `0` if `re s ≤ 1`.
    
  • theoremdefined in Mathlib/NumberTheory/LSeries/DirichletContinuation.lean
    complete
    theorem DirichletCharacter.LFunction_eq_LSeries {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re) :
      DirichletCharacter.LFunction χ s = LSeries (fun x => χ ↑x) s
    theorem DirichletCharacter.LFunction_eq_LSeries
      {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N) {s : ℂ}
      (hs : 1 < s.re) :
      DirichletCharacter.LFunction χ s =
        LSeries (fun x => χ ↑x) s
    For `1 < re s` the L-function of a Dirichlet character agrees with the sum of the naive Dirichlet
    series.
    
  • theoremdefined in Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean
    complete
    theorem DirichletCharacter.LSeries_eulerProduct_tprod {s : ℂ} {N : ℕ}
      (χ : DirichletCharacter ℂ N) (hs : 1 < s.re) :
      ∏' (p : Nat.Primes), (1 - χ ↑↑p * ↑↑p ^ (-s))⁻¹ =
        LSeries (fun n => χ ↑n) s
    theorem DirichletCharacter.LSeries_eulerProduct_tprod
      {s : ℂ} {N : ℕ}
      (χ : DirichletCharacter ℂ N)
      (hs : 1 < s.re) :
      ∏' (p : Nat.Primes),
          (1 - χ ↑↑p * ↑↑p ^ (-s))⁻¹ =
        LSeries (fun n => χ ↑n) s
    The Euler product for Dirichlet L-series, valid for `s.re > 1`.
    This version is stated in terms of `tprod`. 
  • theoremdefined in Mathlib/NumberTheory/LSeries/DirichletContinuation.lean
    complete
    theorem DirichletCharacter.IsPrimitive.completedLFunction_one_sub {N : ℕ}
      [NeZero N] {χ : DirichletCharacter ℂ N} (hχ : χ.IsPrimitive) (s : ℂ) :
      DirichletCharacter.completedLFunction χ (1 - s) =
        ↑N ^ (s - 1 / 2) * χ.rootNumber *
          DirichletCharacter.completedLFunction χ⁻¹ s
    theorem DirichletCharacter.IsPrimitive.completedLFunction_one_sub
      {N : ℕ} [NeZero N]
      {χ : DirichletCharacter ℂ N}
      (hχ : χ.IsPrimitive) (s : ℂ) :
      DirichletCharacter.completedLFunction χ
          (1 - s) =
        ↑N ^ (s - 1 / 2) * χ.rootNumber *
          DirichletCharacter.completedLFunction
            χ⁻¹ s
    **Functional equation** for primitive Dirichlet L-functions. 
  • defdefined in Mathlib/NumberTheory/LSeries/DirichletContinuation.lean
    complete
    def DirichletCharacter.rootNumber {N : ℕ} [NeZero N]
      (χ : DirichletCharacter ℂ N) : ℂ
    def DirichletCharacter.rootNumber {N : ℕ}
      [NeZero N]
      (χ : DirichletCharacter ℂ N) : ℂ
    Global root number of `χ` (for `χ` primitive; junk otherwise). Defined as
    `gaussSum χ stdAddChar / I ^ a / N ^ (1 / 2)`, where `a = 0` if even, `a = 1` if odd. (The factor
    `1 / I ^ a` is the Archimedean root number.) This is a complex number of absolute value 1.
    
  • structure(14 fields)defined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    structure AnalyticLFunction : Type
    structure AnalyticLFunction : Type
    An **analytic L-function** (LMFDB `lfunction`), in its analytic normalisation: a Dirichlet
    series `L(s) = ∑ aₙ n ^ (-s)` that converges absolutely for `re s > 1`, has an Euler product and
    satisfies a **functional equation** (LMFDB `lfunction.functional_equation`) of the form
    
    `Λ(s) = N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ) L(s) = ε conj (Λ (1 - conj s))`
    
    with Selberg data `(N, μ, ν, ε)` and degree `d = J + 2 K`. The structure records the coefficients
    `aₙ`, the continuation `L(s)` of the series, which is holomorphic on `ℂ` except for at most a pole
    at `s = 1`, and the completed L-function `Λ(s)`, which is holomorphic except at `s = 0` and
    `s = 1`, the only possible poles of a completed L-function (they come from factors `ζ(s)`). The
    completion equals `N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ) L(s)` for `re s > 1`, hence as a
    meromorphic function by analytic continuation, and the functional equation is stated pointwise
    for `s ≠ 0, 1`, where no junk values intervene.
    
    The Euler product is encoded by the multiplicativity of the coefficients, with `a₁ = 1`, and by
    local factors `∑ₖ a_{pᵏ} Tᵏ = 1 / Fₚ(T)` for polynomials `Fₚ` of degree at most `d`, with equality
    exactly for the primes `p ∤ N` (LMFDB `lfunction.euler_product`, without the Ramanujan bounds
    `|αᵢ(p)| = 1` and `|βᵢ(p)| ≤ 1`, which are not known in general). 
    coeff : ℕ → ℂ
    The Dirichlet coefficients `aₙ`, in the analytic normalisation. 
    toFun : ℂ → ℂ
    The analytic continuation `L(s)` of the Dirichlet series. 
    completed : ℂ → ℂ
    The completed L-function `Λ(s)` (LMFDB `lfunction.completed`). 
    selbergData : AnalyticLFunction.SelbergData
    The Selberg data of the functional equation. 
    coeff_one : self.coeff 1 = 1
    coeff_mul_of_coprime : ∀ {m n : ℕ}, m.Coprime n → self.coeff (m * n) = self.coeff m * self.coeff n
    exists_eulerFactor : ∀ (p : ℕ),
      Nat.Prime p →
        ∃ F,
          F.natDegree ≤ self.selbergData.degree ∧
            (F.natDegree = self.selbergData.degree ↔ ¬p ∣ self.selbergData.conductor) ∧
              (↑F * PowerSeries.mk fun k => self.coeff (p ^ k)) = 1
    LSeriesSummable_coeff : ∀ {s : ℂ}, 1 < s.re → LSeriesSummable self.coeff s
    toFun_eq_LSeries : ∀ {s : ℂ}, 1 < s.re → self.toFun s = LSeries self.coeff s
    differentiableOn_toFun : DifferentiableOn ℂ self.toFun {1}ᶜ
    meromorphicAt_toFun : MeromorphicAt self.toFun 1
    completed_eq : ∀ {s : ℂ},
      1 < s.re → self.completed s = ↑self.selbergData.conductor ^ (s / 2) * self.selbergData.gammaFactor s * self.toFun s
    differentiableOn_completed : DifferentiableOn ℂ self.completed {0, 1}ᶜ
    completed_eq_sign_mul_conj : ∀ {s : ℂ},
      s ≠ 0 → s ≠ 1 → self.completed s = self.selbergData.sign * (starRingEnd ℂ) (self.completed (1 - (starRingEnd ℂ) s))
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Dirichlet.lean
    complete
    def AnalyticLFunction.dirichlet {N : ℕ} {χ : DirichletCharacter ℂ N}
      [NeZero N] (hχ : χ.IsPrimitive) : AnalyticLFunction
    def AnalyticLFunction.dirichlet {N : ℕ}
      {χ : DirichletCharacter ℂ N} [NeZero N]
      (hχ : χ.IsPrimitive) : AnalyticLFunction
    The **Dirichlet L-function** `L(s, χ)` (LMFDB `lfunction.dirichlet`) of a primitive Dirichlet
    character `χ` modulo `N` as an analytic L-function: the Dirichlet series `∑ χ(n) n ^ (-s)`, with
    Euler factors `(1 - χ(p) p ^ (-s))⁻¹`, continued by `DirichletCharacter.LFunction` and completed by
    `Λ(s, χ) = N ^ (s / 2) Γ_ℝ(s + δ) L(s, χ)`, with the Selberg data
    `AnalyticLFunction.SelbergData.dirichlet`, where `δ` is `0` for even `χ` and `1` for odd `χ`.
    Mathlib's `DirichletCharacter.completedLFunction` is `Γ_ℝ(s + δ) L(s, χ)`, without the factor
    `N ^ (s / 2)`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Dirichlet.lean
    complete
    def AnalyticLFunction.SelbergData.dirichlet {N : ℕ}
      (χ : DirichletCharacter ℂ N) [NeZero N] :
      AnalyticLFunction.SelbergData
    def AnalyticLFunction.SelbergData.dirichlet
      {N : ℕ} (χ : DirichletCharacter ℂ N)
      [NeZero N] :
      AnalyticLFunction.SelbergData
    The **Selberg data** `(1, N, (δ : ), ε_χ)` of the L-function of a primitive Dirichlet character
    `χ` modulo `N`: the conductor `N`, the single spectral parameter `μ = δ`, where `δ` is `0` for even
    `χ` and `1` for odd `χ`, and the sign `ε_χ`, the root number `DirichletCharacter.rootNumber χ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Dirichlet.lean
    complete
    theorem AnalyticLFunction.SelbergData.gammaFactor_dirichlet {N : ℕ}
      (χ : DirichletCharacter ℂ N) [NeZero N] :
      (AnalyticLFunction.SelbergData.dirichlet χ).gammaFactor =
        χ.gammaFactor
    theorem AnalyticLFunction.SelbergData.gammaFactor_dirichlet
      {N : ℕ} (χ : DirichletCharacter ℂ N)
      [NeZero N] :
      (AnalyticLFunction.SelbergData.dirichlet
            χ).gammaFactor =
        χ.gammaFactor
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Dirichlet.lean
    complete
    theorem AnalyticLFunction.eulerPolynomial_dirichlet {N p : ℕ}
      {χ : DirichletCharacter ℂ N} [NeZero N] (hχ : χ.IsPrimitive)
      (hp : Nat.Prime p) :
      (AnalyticLFunction.dirichlet hχ).eulerPolynomial p =
        1 - Polynomial.C (χ ↑p) * Polynomial.X
    theorem AnalyticLFunction.eulerPolynomial_dirichlet
      {N p : ℕ} {χ : DirichletCharacter ℂ N}
      [NeZero N] (hχ : χ.IsPrimitive)
      (hp : Nat.Prime p) :
      (AnalyticLFunction.dirichlet
              hχ).eulerPolynomial
          p =
        1 - Polynomial.C (χ ↑p) * Polynomial.X
    **The Euler factor of a Dirichlet L-function** (LMFDB `lfunction.dirichlet`) at a prime `p` is
    `1 - χ(p) T`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Dirichlet.lean
    complete
    theorem AnalyticLFunction.dirichlet_eq_zeta {N : ℕ} {χ : DirichletCharacter ℂ N}
      [NeZero N] (hχ : χ.IsPrimitive) (hN : N = 1) :
      AnalyticLFunction.dirichlet hχ = AnalyticLFunction.zeta
    theorem AnalyticLFunction.dirichlet_eq_zeta
      {N : ℕ} {χ : DirichletCharacter ℂ N}
      [NeZero N] (hχ : χ.IsPrimitive)
      (hN : N = 1) :
      AnalyticLFunction.dirichlet hχ =
        AnalyticLFunction.zeta
    **Modulo `1`, the Dirichlet L-function is the Riemann zeta function**
    `AnalyticLFunction.zeta`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Dirichlet.lean
    complete
    theorem DirichletCharacter.completedLFunction_conj {N : ℕ}
      (χ : DirichletCharacter ℂ N) {s : ℂ} [NeZero N] (hs : s ≠ 1) :
      DirichletCharacter.completedLFunction χ ((starRingEnd ℂ) s) =
        (starRingEnd ℂ) (DirichletCharacter.completedLFunction χ⁻¹ s)
    theorem DirichletCharacter.completedLFunction_conj
      {N : ℕ} (χ : DirichletCharacter ℂ N)
      {s : ℂ} [NeZero N] (hs : s ≠ 1) :
      DirichletCharacter.completedLFunction χ
          ((starRingEnd ℂ) s) =
        (starRingEnd ℂ)
          (DirichletCharacter.completedLFunction
            χ⁻¹ s)
    **Conjugation symmetry of the completed L-function of a Dirichlet character**:
    `Λ(conj s, χ) = conj (Λ(s, χ⁻¹))` for `s ≠ 1`, where `Λ(s, χ) = Γ_ℝ(s + δ) L(s, χ)` is Mathlib's
    `DirichletCharacter.completedLFunction`. For `re s > 1` it follows from the Dirichlet series, since
    `conj (χ(n)) = χ⁻¹(n)`, and the identity theorem extends it to every `s ≠ 1`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Dirichlet.lean
    complete
    theorem DirichletCharacter.IsPrimitive.norm_rootNumber {N : ℕ}
      {χ : DirichletCharacter ℂ N} [NeZero N] (hχ : χ.IsPrimitive) :
      ‖χ.rootNumber‖ = 1
    theorem DirichletCharacter.IsPrimitive.norm_rootNumber
      {N : ℕ} {χ : DirichletCharacter ℂ N}
      [NeZero N] (hχ : χ.IsPrimitive) :
      ‖χ.rootNumber‖ = 1
    **The root number of a primitive Dirichlet character has absolute value `1`**: it is the sign
    of the functional equation of `AnalyticLFunction.dirichlet`. 
Definition2.22
uses 0
Used by 7
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Dirichlet series. (LMFDB)

A Dirichlet series is a formal series of the form F(s) = {\displaystyle \sum_{n=1}^{\infty} \frac{a_n}{ n^{s}}}, where a_n \in {\mathbb{C}}.

Tau Ceti Review: LSeries, LSeries.term, ArithmeticFunction.

Lean code for Definition2.22●3 definitions
  • defdefined in Mathlib/NumberTheory/LSeries/Basic.lean
    complete
    def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ
    def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ
    The value of the L-series of the sequence `f` at the point `s`
    if it converges absolutely there, and `0` otherwise. 
  • defdefined in Mathlib/NumberTheory/LSeries/Basic.lean
    complete
    def LSeries.term (f : ℕ → ℂ) (s : ℂ) (n : ℕ) : ℂ
    def LSeries.term (f : ℕ → ℂ) (s : ℂ) (n : ℕ) :
      ℂ
    The `n`th term of the L-series of `f` evaluated at `s`. We set it to zero when `n = 0`. 
  • defdefined in Mathlib/NumberTheory/ArithmeticFunction/Defs.lean
    complete
    def ArithmeticFunction.{u_1} (R : Type u_1) [Zero R] : Type u_1
    def ArithmeticFunction.{u_1} (R : Type u_1)
      [Zero R] : Type u_1
    An arithmetic function is a function from `ℕ` that maps 0 to 0. In the literature, they are
    often instead defined as functions from `ℕ+`. Multiplication on `ArithmeticFunctions` is by
    Dirichlet convolution. 
Definition2.23
uses 1used by 1✓L∃∀N

Dual of an L-function. (LMFDB)

The dual of an L-function L(s) = \sum_{n=1}^{\infty} \frac{a_n}{n^s} is the complex conjugate \bar{L}(s) = \sum_{n=1}^{\infty} \frac{\bar{a_n}}{n^s}.

Tau Ceti Review: LSeries, starRingEnd.

Depends on: Definition 2.7

Lean code for Definition2.23●2 definitions
  • defdefined in Mathlib/NumberTheory/LSeries/Basic.lean
    complete
    def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ
    def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ
    The value of the L-series of the sequence `f` at the point `s`
    if it converges absolutely there, and `0` otherwise. 
  • defdefined in Mathlib/Algebra/Star/Basic.lean
    complete
    def starRingEnd.{u} (R : Type u) [CommSemiring R] [StarRing R] : R →+* R
    def starRingEnd.{u} (R : Type u)
      [CommSemiring R] [StarRing R] : R →+* R
    `star` as a ring endomorphism, for commutative `R`. This is used to denote complex
    conjugation, and is available under the notation `conj` in the scope `ComplexConjugate`.
    
    Note that this is the preferred form (over `starRingAut`, available under the same hypotheses)
    because the notation `E →ₗ⋆[R] F` for an `R`-conjugate-linear map (short for
    `E →ₛₗ[starRingEnd R] F`) does not pretty-print if there is a coercion involved, as would be the
    case for `(↑starRingAut : R →* R)`. 
Definition2.24
uses 0
Used by 15
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
XL∃∀N

Euler product of an L-function. (LMFDB)

It is expected that the Euler product of an L-function of degree d and conductor N can be written as

L(s)=\prod_p L_p(s)

where for p\nmid N

L_p(s)=\prod_{n=1}^d \left( 1-\frac{\alpha_{n}(p)}{p^s}\right)^{-1} \text{ with } |\alpha_{n}(p)|=1

and for p\mid N,

L_p(s)=\prod_{n=1}^{d_p}\left( 1-\frac{\beta_{n}(p)}{p^s}\right)^{-1} \text{ where } d_p < d \text{ and } |\beta_n(p)|\le 1.

The functions L_p(s) are called Euler factors (or local factors).

Definition2.25
Statement uses 2
Statement dependency previews
Preview
Definition 2.26
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 31
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Functional equation of an L-function. (LMFDB)

All known analytic L-functions have a functional equation that can be written in the form

\Lambda(s) := N^{s/2} \prod_{j=1}^J \Gamma_{\mathbb{R}}(s+\mu_j) \prod_{k=1}^K \Gamma_{\mathbb{C}}(s+\nu_k) \cdot L(s) = \varepsilon \overline{\Lambda}(1-s),

where N is an integer, \Gamma_{\mathbb{R}} and \Gamma_{\mathbb{C}} are defined in terms of the \Gamma-function, \mathrm{Re}(\mu_j) = 0 \ \mathrm{or} \ 1 (assuming Selberg's eigenvalue conjecture), and \mathrm{Re}(\nu_k) is a positive integer or half-integer,

\sum \mu_j + 2 \sum \nu_k \ \ \ \ \text{is real},

and \varepsilon is the sign of the functional equation. With those restrictions on the spectral parameters, the data in the functional equation is specified uniquely. The integer d = J + 2 K is the degree of the L-function. The integer N is the conductor (or level) of the L-function. The pair [J,K] is the signature of the L-function. The parameters in the functional equation can be used to make up the 4-tuple called the Selberg data.

The axioms of the Selberg class are less restrictive than given above.

Note that the functional equation above has the central point at s=1/2, and relates s\leftrightarrow 1-s.

For many L-functions there is another normalization which is natural. The corresponding functional equation relates s\leftrightarrow w+1-s for some positive integer w, called the motivic weight of the L-function. The central point is at s=(w+1)/2, and the arithmetically normalized Dirichlet coefficients a_n n^{w/2} are algebraic integers.

Depends on: Definition 2.26 Definition 2.76

Lean code for Definition2.25●8 declarations
  • structure(8 fields)defined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    structure AnalyticLFunction.SelbergData : Type
    structure AnalyticLFunction.SelbergData : Type
    The **Selberg data** (LMFDB `lfunction.selbergdata`) of a functional equation
    `Λ(s) = N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ) L(s) = ε conj (Λ (1 - conj s))`: the
    **conductor** `N` (LMFDB `lfunction.conductor`), the **spectral parameters** `μⱼ` of the factors
    `Γ_ℝ` and `νₖ` of the factors `Γ_ℂ` (LMFDB `lfunction.spectral_parameters`), and the **sign** `ε`
    (LMFDB `lfunction.sign`). The degree, the first entry of the LMFDB's quadruple, is
    `AnalyticLFunction.SelbergData.degree`. As in the LMFDB, the spectral parameters are normalised
    so that each `re μⱼ` is `0` or `1` (assuming Selberg's eigenvalue conjecture), each `re νₖ` is a
    positive integer or half-integer, and `∑ μⱼ + 2 ∑ νₖ` is real; the LMFDB states that this makes
    the data of a functional equation unique, which is not proved here. 
    conductor : ℕ
    The conductor `N`. 
    μ : Multiset ℂ
    The spectral parameters `μⱼ` of the factors `Γ_ℝ(s + μⱼ)`. 
    ν : Multiset ℂ
    The spectral parameters `νₖ` of the factors `Γ_ℂ(s + νₖ)`. 
    sign : ℂ
    The sign `ε`. 
    conductor_pos : 0 < self.conductor
    re_eq_zero_or_one_of_mem_μ : ∀ x ∈ self.μ, x.re = 0 ∨ x.re = 1
    exists_two_mul_re_eq_of_mem_ν : ∀ x ∈ self.ν, ∃ k, 0 < k ∧ 2 * x.re = ↑k
    im_sum_add_two_mul_sum : (self.μ.sum + 2 * self.ν.sum).im = 0
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.SelbergData.gammaFactor
      (D : AnalyticLFunction.SelbergData) (s : ℂ) : ℂ
    def AnalyticLFunction.SelbergData.gammaFactor
      (D : AnalyticLFunction.SelbergData)
      (s : ℂ) : ℂ
    The **gamma factor** `∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ)` (LMFDB `lfunction.infinity_factor`) of a
    functional equation, the product of its shifted Deligne gamma factors `Γ_ℝ` and `Γ_ℂ` (LMFDB
    `lfunction.gamma_factor`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_eq (self : AnalyticLFunction) {s : ℂ} :
      1 < s.re →
        self.completed s =
          ↑self.selbergData.conductor ^ (s / 2) *
              self.selbergData.gammaFactor s *
            self.toFun s
    theorem AnalyticLFunction.completed_eq
      (self : AnalyticLFunction) {s : ℂ} :
      1 < s.re →
        self.completed s =
          ↑self.selbergData.conductor ^
                (s / 2) *
              self.selbergData.gammaFactor s *
            self.toFun s
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_eq_sign_mul_conj (self : AnalyticLFunction)
      {s : ℂ} :
      s ≠ 0 →
        s ≠ 1 →
          self.completed s =
            self.selbergData.sign *
              (starRingEnd ℂ) (self.completed (1 - (starRingEnd ℂ) s))
    theorem AnalyticLFunction.completed_eq_sign_mul_conj
      (self : AnalyticLFunction) {s : ℂ} :
      s ≠ 0 →
        s ≠ 1 →
          self.completed s =
            self.selbergData.sign *
              (starRingEnd ℂ)
                (self.completed
                  (1 - (starRingEnd ℂ) s))
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.SelbergData.degree
      (D : AnalyticLFunction.SelbergData) : ℕ
    def AnalyticLFunction.SelbergData.degree
      (D : AnalyticLFunction.SelbergData) : ℕ
    The **degree** `J + 2 K` (LMFDB `lfunction.degree`) of a functional equation with `J` factors
    `Γ_ℝ` and `K` factors `Γ_ℂ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_sub_eq_sign_mul_conj (L : AnalyticLFunction)
      (w : ℕ) {s : ℂ} (hs₀ : s ≠ ↑w / 2) (hs₁ : s ≠ 1 + ↑w / 2) :
      L.completed (s - ↑w / 2) =
        L.sign *
          (starRingEnd ℂ)
            (L.completed (1 + ↑w - (starRingEnd ℂ) s - ↑w / 2))
    theorem AnalyticLFunction.completed_sub_eq_sign_mul_conj
      (L : AnalyticLFunction) (w : ℕ) {s : ℂ}
      (hs₀ : s ≠ ↑w / 2)
      (hs₁ : s ≠ 1 + ↑w / 2) :
      L.completed (s - ↑w / 2) =
        L.sign *
          (starRingEnd ℂ)
            (L.completed
              (1 + ↑w - (starRingEnd ℂ) s -
                ↑w / 2))
    The functional equation in the arithmetic normalisation of weight `w` relates `s` and
    `1 + w - s`: the completion `Λ(s - w / 2)` equals `ε conj (Λ ((1 + w - conj s) - w / 2))`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/SelbergFunctionalEquation.lean
    complete
    theorem AnalyticLFunction.selbergFunctionalEquation_coeff
      (L : AnalyticLFunction) : LSeries.SelbergFunctionalEquation L.coeff
    theorem AnalyticLFunction.selbergFunctionalEquation_coeff
      (L : AnalyticLFunction) :
      LSeries.SelbergFunctionalEquation
        L.coeff
    **Every analytic L-function satisfies Selberg's functional equation axiom** (LMFDB
    `lfunction.functional_equation`, `lfunction.selberg_class.axioms`): its functional equation
    `Λ(s) = ε conj (Λ (1 - conj s))`, with `Λ(s) = N ^ (s / 2) L_∞(s) L(s)`, is one of Selberg's form,
    with the gamma factor `AnalyticLFunction.SelbergData.selbergGammaFactor` of its Selberg data. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/SelbergFunctionalEquation.lean
    complete
    theorem AnalyticLFunction.SelbergData.not_eqOn_gammaDivThree
      (D : AnalyticLFunction.SelbergData) (c : ℂ) :
      ¬Set.EqOn LSeries.SelbergGammaFactor.gammaDivThree.toFun
          (fun s => c * (↑D.conductor ^ (s / 2) * D.gammaFactor s))
          {s | 0 < s.re}
    theorem AnalyticLFunction.SelbergData.not_eqOn_gammaDivThree
      (D : AnalyticLFunction.SelbergData)
      (c : ℂ) :
      ¬Set.EqOn
          LSeries.SelbergGammaFactor.gammaDivThree.toFun
          (fun s =>
            c *
              (↑D.conductor ^ (s / 2) *
                D.gammaFactor s))
          {s | 0 < s.re}
    **The axioms of the Selberg class allow more gamma factors than the LMFDB's functional
    equation** (LMFDB `lfunction.functional_equation`): the gamma factor `Γ(s / 3)` of Selberg's form
    is not `c N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ)` for any Selberg data `(N, μ, ν, ε)` and any
    constant `c`, not even on the half-plane `re s > 0`, where both sides are holomorphic. The proof
    uses only the spacing of the poles, not the LMFDB's restrictions on `N`, `μⱼ` and `νₖ`. 
Definition2.26
uses 1
Used by 10
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Gamma factors. (LMFDB)

The complex functions

\Gamma_{\R}(s) := \pi^{-s/2}\Gamma(s/2)\qquad\text{and}\qquad \Gamma_{\C}(s):= 2(2\pi)^{-s}\Gamma(s)

that appear in the functional equation of an L-function are known as gamma factors. Here \Gamma(s):=\int_0^\infty e^{-t}t^{s-1}dt is Euler's gamma function.

The gamma factors satisfy \Gamma_{\C}(s) = \Gamma_{\R}(s) \Gamma_{\R}(s + 1) and can also be viewed as "missing" factors of the Euler product of an L-function corresponding to (real or complex) archimedean places.

Tau Ceti Review: Complex.Gammaℝ, Complex.Gammaℂ, Complex.Gammaℝ_mul_Gammaℝ_add_one.

Depends on: Definition 2.24

Lean code for Definition2.26●3 declarations
  • defdefined in Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean
    complete
    def Complex.Gammaℝ (s : ℂ) : ℂ
    def Complex.Gammaℝ (s : ℂ) : ℂ
    Deligne's archimedean Gamma factor for a real infinite place.
    
    See "Valeurs de fonctions L et périodes d'intégrales" § 5.3. Note that this is not the same as
    `Real.Gamma`; in particular it is a function `ℂ → ℂ`. 
  • defdefined in Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean
    complete
    def Complex.Gammaℂ (s : ℂ) : ℂ
    def Complex.Gammaℂ (s : ℂ) : ℂ
    Deligne's archimedean Gamma factor for a complex infinite place.
    
    See "Valeurs de fonctions L et périodes d'intégrales" § 5.3. (Some authors omit the factor of 2).
    Note that this is not the same as `Complex.Gamma`. 
  • theoremdefined in Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean
    complete
    theorem Complex.Gammaℝ_mul_Gammaℝ_add_one (s : ℂ) :
      s.Gammaℝ * (s + 1).Gammaℝ = s.Gammaℂ
    theorem Complex.Gammaℝ_mul_Gammaℝ_add_one
      (s : ℂ) :
      s.Gammaℝ * (s + 1).Gammaℝ = s.Gammaℂ
    Reformulation of the doubling formula in terms of `Gammaℝ`. 
Definition2.27
Statement uses 11
Statement dependency previews
Preview
Definition 2.28
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

A history of L-functions. (LMFDB)

Definition 2.30

<h2>Riemann's memoir</h2> Definition 2.38

<h2>Dirichlet L-functions</h2> Definition 2.29

<h2>Dedekind zeta functions</h2> lfunction.history.dedekind

The automorphy properties of Hilbert modular forms for real quadratic fields were considered in the 1901 Gottingen University Habilitationssschrift of Otto Blumenthal. Therein he refers to unpublished work of 1893-1894 of his advisor David Hilbert. Hilbert modular forms were significantly developed by Hecke in his 1910 dissertation.

<h2>The L-function of \Delta</h2> Definition 2.36

<h2>Hecke L-functions</h2> Definition 2.32

Definition 2.33

<h2> Artin L-functions </h2> Definition 2.28

<h2> Siegel Modular forms </h2> lfunction.history.siegel

<h2> Rankin-Selberg convolution </h2> Definition 2.37

<h2>L-functions of nonholomorphic modular forms</h2> Definition 2.35

<h2> Tate's thesis </h2> lfunction.history.tates_thesis

<h2> Hasse-Weil L-functions </h2> Definition 2.31

<h2> Langlands Program </h2>

Definition 2.34

Depends on: Definition 2.28 Definition 2.29 Definition 2.30 Definition 2.31 Definition 2.32 Definition 2.33 Definition 2.34 Definition 2.35 Definition 2.36 Definition 2.37 Definition 2.38

Definition2.28
uses 0used by 1XL∃∀N

Artin L-functions. (LMFDB)

Artin L-functions were introduced in 1924 . Artin's conjecture that these L-functions are entire remains unsolved, though many instances are known.

Definition2.29
uses 1used by 1✓L∃∀N

Dirichlet's work on L-functions. (LMFDB)

The first use of the letter L to denote these functions was by Dirichlet in 1837 (see <i>Werke I</i> pages 313-342) who used L-functions to prove that there are infinitely many primes in any (primitive) arithmetic progression. He considered series of the form

L(s,\chi)=\sum_{n=1}^\infty \frac{\chi(n)}{n^s}

where \chi is a (Dirichlet) character, which is the extension to the integers of a character of the group (\mathbb{Z}/q\mathbb{Z})^*. For example the arithmetic function \chi defined by

\chi(n)=\begin{cases} 1 & \textrm{ if } n\equiv 1 \bmod 3\\ -1 & \textrm{ if } n\equiv 2\bmod 3\\ 0 & \textrm{ if }n\equiv 0\bmod 3\end{cases}

is a Dirichlet character modulo 3. The above L-function has an Euler product

L(s,\chi)=\prod_{p }\left(1-\frac{\chi(p)}{p^s}\right)^{-1}

and satisfies a functional equation that

\left(\frac{3}{\pi}\right)^{\frac{s}{2}}\Gamma\left(\frac{s+1}{2}\right) L(s,\chi)

is invariant under s\to 1-s. Also, note the special value

L(1,\chi)= \frac{\pi}{3\sqrt{3}};

Dirichlet needed to know that his L-functions did not vanish at 1 and he used special values to prove this fact. Dirichlet's original proof was for prime moduli; for composite moduli he required his class number formula which was proven in 1839 - 1840 (see his Werke I, pp. 411-496).

Tau Ceti Review: Nat.infinite_setOfPred_prime_and_modEq, DirichletCharacter.LFunction_apply_one_ne_zero.

Depends on: Definition 6.1.1

Lean code for Definition2.29●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LSeries/DirichletModThree.lean
    complete
    def DirichletCharacter.χ₃ : DirichletCharacter ℂ 3
    def DirichletCharacter.χ₃ :
      DirichletCharacter ℂ 3
    The **Dirichlet character `χ₃` modulo `3`** (LMFDB `lfunction.history.dirichlet`), with values
    `1`, `-1`, `0` at the integers congruent to `1`, `2`, `0` modulo `3`
    (`DirichletCharacter.χ₃_intCast`): the quadratic character of the field `ℤ/3ℤ`, with complex
    values. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LSeries/DirichletModThree.lean
    complete
    theorem DirichletCharacter.χ₃_intCast (m : ℤ) :
      DirichletCharacter.χ₃ ↑m =
        if m % 3 = 1 then 1 else if m % 3 = 2 then -1 else 0
    theorem DirichletCharacter.χ₃_intCast (m : ℤ) :
      DirichletCharacter.χ₃ ↑m =
        if m % 3 = 1 then 1
        else if m % 3 = 2 then -1 else 0
    **The values of `χ₃`** (LMFDB `lfunction.history.dirichlet`): `χ₃(m)` is `1`, `-1` or `0` as the
    integer `m` is congruent to `1`, `2` or `0` modulo `3`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Dirichlet.lean
    complete
    theorem DirichletCharacter.LFunction_eulerProduct_hasProd {N : ℕ}
      (χ : DirichletCharacter ℂ N) {s : ℂ} [NeZero N] (hs : 1 < s.re) :
      HasProd (fun p => (1 - χ ↑↑p * ↑↑p ^ (-s))⁻¹)
        (DirichletCharacter.LFunction χ s)
    theorem DirichletCharacter.LFunction_eulerProduct_hasProd
      {N : ℕ} (χ : DirichletCharacter ℂ N)
      {s : ℂ} [NeZero N] (hs : 1 < s.re) :
      HasProd
        (fun p => (1 - χ ↑↑p * ↑↑p ^ (-s))⁻¹)
        (DirichletCharacter.LFunction χ s)
    **The Euler product of a Dirichlet L-function** (LMFDB `lfunction.history.dirichlet`):
    `L(s, χ) = ∏ (1 - χ(p) p ^ (-s))⁻¹` over the primes `p`, for `re s > 1`. This is Mathlib's
    `DirichletCharacter.LSeries_eulerProduct_hasProd`, stated for the continued L-function
    `DirichletCharacter.LFunction`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LSeries/DirichletModThree.lean
    complete
    theorem DirichletCharacter.completedLFunctionModThree_one_sub (s : ℂ) :
      DirichletCharacter.completedLFunctionModThree (1 - s) =
        DirichletCharacter.completedLFunctionModThree s
    theorem DirichletCharacter.completedLFunctionModThree_one_sub
      (s : ℂ) :
      DirichletCharacter.completedLFunctionModThree
          (1 - s) =
        DirichletCharacter.completedLFunctionModThree
          s
    **The functional equation of `L(s, χ₃)`** (LMFDB `lfunction.history.dirichlet`): the entire
    function `(3 / π) ^ (s / 2) Γ((s + 1) / 2) L(s, χ₃)` is invariant under `s ↦ 1 - s`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LSeries/DirichletModThree.lean
    complete
    theorem DirichletCharacter.completedLFunctionModThree_eq {s : ℂ}
      (hs : ∀ (n : ℕ), s ≠ -(2 * ↑n + 1)) :
      DirichletCharacter.completedLFunctionModThree s =
        (3 / ↑Real.pi) ^ (s / 2) * Complex.Gamma ((s + 1) / 2) *
          DirichletCharacter.LFunction DirichletCharacter.χ₃ s
    theorem DirichletCharacter.completedLFunctionModThree_eq
      {s : ℂ}
      (hs : ∀ (n : ℕ), s ≠ -(2 * ↑n + 1)) :
      DirichletCharacter.completedLFunctionModThree
          s =
        (3 / ↑Real.pi) ^ (s / 2) *
            Complex.Gamma ((s + 1) / 2) *
          DirichletCharacter.LFunction
            DirichletCharacter.χ₃ s
    **The completed L-function of `χ₃` is `(3 / π) ^ (s / 2) Γ((s + 1) / 2) L(s, χ₃)`** (LMFDB
    `lfunction.history.dirichlet`), for `s` not among the poles `-1, -3, -5, …` of `Γ((s + 1) / 2)`. At
    these poles the right-hand side is `0` in Lean (`Complex.Gamma_neg_nat_eq_zero`), unlike the
    left-hand side (`DirichletCharacter.completedLFunctionModThree_ne_zero_of_re_nonpos`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LSeries/DirichletModThree.lean
    complete
    theorem DirichletCharacter.LFunction_χ₃_apply_one :
      DirichletCharacter.LFunction DirichletCharacter.χ₃ 1 =
        ↑Real.pi / (3 * ↑√3)
    theorem DirichletCharacter.LFunction_χ₃_apply_one :
      DirichletCharacter.LFunction
          DirichletCharacter.χ₃ 1 =
        ↑Real.pi / (3 * ↑√3)
    **The special value `L(1, χ₃) = π / (3 √3)`** (LMFDB `lfunction.history.dirichlet`): by the
    partial fraction expansion of the cotangent at `1 / 3`, the series
    `1 - 1/2 + 1/4 - 1/5 + 1/7 - 1/8 + ⋯` for `L(1, χ₃)` has sum `(π / 3) cot(π / 3)`. 
  • theoremdefined in Mathlib/NumberTheory/LSeries/PrimesInAP.lean
    complete
    theorem Nat.infinite_setOfPred_prime_and_modEq {q a : ℕ} (hq : q ≠ 0)
      (h : a.Coprime q) : {p | Nat.Prime p ∧ p ≡ a [MOD q]}.Infinite
    theorem Nat.infinite_setOfPred_prime_and_modEq
      {q a : ℕ} (hq : q ≠ 0)
      (h : a.Coprime q) :
      {p |
          Nat.Prime p ∧
            p ≡ a [MOD q]}.Infinite
  • theoremdefined in Mathlib/NumberTheory/LSeries/Nonvanishing.lean
    complete
    theorem DirichletCharacter.LFunction_apply_one_ne_zero {N : ℕ}
      {χ : DirichletCharacter ℂ N} [NeZero N] (hχ : χ ≠ 1) :
      DirichletCharacter.LFunction χ 1 ≠ 0
    theorem DirichletCharacter.LFunction_apply_one_ne_zero
      {N : ℕ} {χ : DirichletCharacter ℂ N}
      [NeZero N] (hχ : χ ≠ 1) :
      DirichletCharacter.LFunction χ 1 ≠ 0
    The L-function of a nontrivial Dirichlet character does not vanish at `s = 1`. 
Definition2.30
uses 1used by 1XL∃∀N

Euler's work on the zeta function. (LMFDB)

The prototype of L-functions is the Riemann zeta-function defined by

\zeta(s)=\sum_{n=1}^\infty \frac {1}{n^s}

for \Re s>1. Euler discovered that \zeta(2)=\frac{\pi^2}{6}, and he also found the fundamental identity

\zeta(s)=\prod_p \left(1-\frac{1}{p^s}\right)^{-1},

which he used to prove that the series \sum_p \frac{1}{p} diverges. Euler considered other divergent series and noticed a connection between values of \zeta at s and 1-s, linked by powers of \pi and Bernoulli numbers, such as the interpretations

1+2+3+\dots =-\frac{1}{12}

and

1+4+9+16+\dots =0.

Euler found hints of many of the remarkable features of L-functions that make them such worthy objects of study: the Euler product, special values, and the functional equation. It was left to Riemann to discover perhaps the most remarkable property of all, one that hasn't been proven yet: the Riemann Hypothesis that each non-real zero of \zeta(s) has real part equal to \frac 12.

Depends on: Definition 2.2

Definition2.31
uses 0used by 1XL∃∀N

Hasse-Weil L-function. (LMFDB)

In 1955 Hasse introduced the zeta-function associated with a curve, today called the Hasse-Weil zeta function. For a Fermat curve x^m+y^m=1 he obtains an expression for his zeta-function in terms of L-functions with a Hecke character.

Definition2.32
Statement uses 2
Statement dependency previews
Preview
Definition 6.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1XL∃∀N

Hecke L-functions. (LMFDB)

The L-functions associated with finite characters of number fields (often called Dirichlet charaters or finite Hecke characters) were considered by Hecke in a series of papers beginning in 1917. In the first paper of this series, &Uuml;ber die Zetafunktion _beliebiger algebraischer Zahlkorper_ G"ott. Nachr. 1917 77-89 (1917), he refers to \zeta_k(s) as the "Dirichlet-Dedekindsche Zetafunktion". Here he gives the functional equation for the Dedekind zeta-function of any number field. In the second paper <i>&Uuml;ber eine neue anwendung der Zetafunktionnen auf die arithmetik der Zahlkorper</i> also in 1917, he refers to it as "der Dedekindschen Funktion \zeta_k(s)." This paper ends with the remark that for abelian extensions \zeta_k(s) can be factored as a product of Dirichlet L-functions. In the third paper in the series, he refers again to "Dirichlet-Dedekindsche Funktion \zeta_k(s)". Here he proves the functional equation for L-functions of finite Hecke characters.

The L-functions associated with Hecke's Gro&beta;encharaktere, i.e. characters of infinite order, and their functional equations appear in a two-paper series beginning in 1918 . It is only in the second of these papers (1920) that Hecke uses the term "Gro&beta;encharaktere".

Depends on: Definition 6.1.1 Definition 6.1.37

Definition2.33
uses 0used by 1✓L∃∀N

Hecke operators, history. (LMFDB)

Hecke , building on Mordell, introduced operators acting on vector spaces of modular forms. The forms which were simultaneous eigenvalues of these operators have multiplicative Fourier coefficients so that their associated Dirichlet series have Euler products and functional equations. Hecke mainly worked with level 1 modular forms. The more subtle theory of Hecke operators for spaces of higher level and with character was developed by Atkin and Lehner, and Li .

Tau Ceti Review: HeckeRing.GL2.Eigenform, HeckeRing.GL2.heckeTNat, HeckeRing.GL2.Eigenform.qExpansion_coeff_mul, HeckeRing.GL2.Eigenform.LSeries_eulerProduct_hasProd, CuspForm.frickeCompletedL_functional_equation_gamma1.

Lean code for Definition2.33●8 declarations
  • structure(extends 2, 9 fields)defined in TauCeti/NumberTheory/ModularForms/Newforms/Eigenform.lean
    complete
    structure HeckeRing.GL2.Eigenform (N : ℕ) [NeZero N] (k : ℤ) : Type
    structure HeckeRing.GL2.Eigenform (N : ℕ) [NeZero N]
      (k : ℤ) : Type
    **A full Hecke eigenform.** This is a nonzero cusp form in a fixed nebentypus space together
    with its eigenvalue at every positive index. In contrast with `EigenformAwayFromLevel`, no
    coprimality condition excludes the primes dividing the level. 
    • CuspForm (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma1 N)) k
    toFun : UpperHalfPlane → ℂ
    Inherited from
    1. CuspForm
    2. SlashInvariantForm
    slash_action_eq' : ∀ γ ∈ Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma1 N),
      SlashAction.map k γ self.toFun = self.toFun
    Inherited from
    1. CuspForm
    2. SlashInvariantForm
    holo' : MDiff ⇑self.toSlashInvariantForm
    Inherited from
    1. CuspForm
    zero_at_cusps' : ∀ {c : OnePoint ℝ},
      IsCusp c (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma1 N)) → c.IsZeroAt self.toFun k
    Inherited from
    1. CuspForm
    χ : (ZMod N)ˣ →* ℂˣ
    The nebentypus character. 
    mem_charSpace : self.toCuspForm ∈ cuspFormCharSpace k self.χ
    The form transforms under the diamond operators by `χ`. 
    eigenvalue : ℕ+ → ℂ
    The eigenvalue at a positive index. 
    isEigen : ∀ (n : ℕ+),
      ((HeckeRing.GL2.heckeRingHomCuspCharSpace k self.χ) (HeckeRing.GL2.heckeTCompositeGamma0 N ↑n)) ⟨self.toCuspForm, ⋯⟩ =
        self.eigenvalue n • ⟨self.toCuspForm, ⋯⟩
    The Hecke element `T_n` acts on the form by `eigenvalue n`. 
    ne_zero : self.toCuspForm ≠ 0
    An eigenform is nonzero. 
  • defdefined in TauCeti/NumberTheory/ModularForms/HeckeSlash/Operators.lean
    complete
    def HeckeRing.GL2.heckeTNat {N : ℕ} [NeZero N] (k : ℤ) (n : ℕ)
      [_hn : NeZero n] :
      Module.End ℂ
        (ModularForm
          (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ)
            (CongruenceSubgroup.Gamma1 N))
          k)
    def HeckeRing.GL2.heckeTNat {N : ℕ} [NeZero N]
      (k : ℤ) (n : ℕ) [_hn : NeZero n] :
      Module.End ℂ
        (ModularForm
          (Subgroup.map
            (Matrix.SpecialLinearGroup.mapGL
              ℝ)
            (CongruenceSubgroup.Gamma1 N))
          k)
    **The Hecke operator `T_n` on `M_k(Γ₁(N))`.** It is the slash operator of the canonical
    double coset `Γ₁(N) · diag(1, n) · Γ₁(N)`.
    
    The `NeZero n` binder records the classical convention that Hecke operators are indexed by
    positive integers, and it is not optional: at `n = 0` the entry tuple `![1, 0]` fails the
    positivity side condition of `natDiagGL`, which then returns its junk value `1`, so the double
    coset degenerates to `Γ₁(N)` itself and the construction would silently be the identity operator
    rather than `T₀`. The binder is `_`-named because only the *statements* below use it — the body
    is the same slash operator either way, and it is the index that is being constrained. 
  • theoremdefined in TauCeti/NumberTheory/ModularForms/Newforms/Eigenform.lean
    complete
    theorem HeckeRing.GL2.Eigenform.qExpansion_coeff_mul {N : ℕ} [NeZero N] {k : ℤ}
      (f : HeckeRing.GL2.Eigenform N k)
      (h₁ :
        (PowerSeries.coeff 1) (UpperHalfPlane.qExpansion 1 ⇑f.toCuspForm) =
          1)
      {m n : ℕ} (hmn : m.Coprime n) :
      (PowerSeries.coeff (m * n))
          (UpperHalfPlane.qExpansion 1 ⇑f.toCuspForm) =
        (PowerSeries.coeff m) (UpperHalfPlane.qExpansion 1 ⇑f.toCuspForm) *
          (PowerSeries.coeff n) (UpperHalfPlane.qExpansion 1 ⇑f.toCuspForm)
    theorem HeckeRing.GL2.Eigenform.qExpansion_coeff_mul
      {N : ℕ} [NeZero N] {k : ℤ}
      (f : HeckeRing.GL2.Eigenform N k)
      (h₁ :
        (PowerSeries.coeff 1)
            (UpperHalfPlane.qExpansion 1
              ⇑f.toCuspForm) =
          1)
      {m n : ℕ} (hmn : m.Coprime n) :
      (PowerSeries.coeff (m * n))
          (UpperHalfPlane.qExpansion 1
            ⇑f.toCuspForm) =
        (PowerSeries.coeff m)
            (UpperHalfPlane.qExpansion 1
              ⇑f.toCuspForm) *
          (PowerSeries.coeff n)
            (UpperHalfPlane.qExpansion 1
              ⇑f.toCuspForm)
    **Multiplicativity of the coefficients of a normalised full eigenform**: `a_{mn} = a_m a_n`
    for all coprime `m`, `n` (Diamond–Shurman Proposition 5.8.5 (3)). 
  • theoremdefined in TauCeti/NumberTheory/ModularForms/LFunction/EulerProduct.lean
    complete
    theorem HeckeRing.GL2.Eigenform.LSeries_eulerProduct_hasProd {N : ℕ} [NeZero N]
      {k : ℤ} (f : HeckeRing.GL2.Eigenform N k)
      (h₁ :
        (PowerSeries.coeff 1) (UpperHalfPlane.qExpansion 1 ⇑f.toCuspForm) =
          1)
      {s : ℂ} (hs : ↑k / 2 + 1 < s.re) :
      HasProd
        (fun p =>
          (1 -
                (PowerSeries.coeff ↑p)
                    (UpperHalfPlane.qExpansion 1 ⇑f.toCuspForm) *
                  ↑↑p ^ (-s) +
              (MulChar.ofUnitHom f.χ) ↑↑p * ↑↑p ^ (k - 1) *
                ↑↑p ^ (-2 * s))⁻¹)
        (LSeries
          (fun n =>
            (PowerSeries.coeff n)
              (UpperHalfPlane.qExpansion 1 ⇑f.toCuspForm))
          s)
    theorem HeckeRing.GL2.Eigenform.LSeries_eulerProduct_hasProd
      {N : ℕ} [NeZero N] {k : ℤ}
      (f : HeckeRing.GL2.Eigenform N k)
      (h₁ :
        (PowerSeries.coeff 1)
            (UpperHalfPlane.qExpansion 1
              ⇑f.toCuspForm) =
          1)
      {s : ℂ} (hs : ↑k / 2 + 1 < s.re) :
      HasProd
        (fun p =>
          (1 -
                (PowerSeries.coeff ↑p)
                    (UpperHalfPlane.qExpansion
                      1 ⇑f.toCuspForm) *
                  ↑↑p ^ (-s) +
              (MulChar.ofUnitHom f.χ) ↑↑p *
                  ↑↑p ^ (k - 1) *
                ↑↑p ^ (-2 * s))⁻¹)
        (LSeries
          (fun n =>
            (PowerSeries.coeff n)
              (UpperHalfPlane.qExpansion 1
                ⇑f.toCuspForm))
          s)
    The quadratic Euler factors of a normalized full Hecke eigenform have product equal to
    its coefficient L-series on `Re s > k/2 + 1`. The zero-extended character makes the factors
    linear at bad primes. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Newform/EigenformLFunction.lean
    complete
    theorem CuspForm.frickeCompletedL_eq_mul_LSeries {k : ℤ} {s : ℂ} {N : ℕ}
      [NeZero N]
      (f :
        CuspForm
          (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ)
            (CongruenceSubgroup.Gamma1 N))
          k)
      (M : ℕ+) (hk : 0 < k) (hs : ↑k / 2 + 1 < s.re) :
      f.frickeCompletedL M s =
        ↑↑M ^ (s / 2) * (2 * ↑Real.pi) ^ (-s) * Complex.Gamma s *
          LSeries
            (fun n =>
              (PowerSeries.coeff n) (UpperHalfPlane.qExpansion 1 ⇑f))
            s
    theorem CuspForm.frickeCompletedL_eq_mul_LSeries
      {k : ℤ} {s : ℂ} {N : ℕ} [NeZero N]
      (f :
        CuspForm
          (Subgroup.map
            (Matrix.SpecialLinearGroup.mapGL
              ℝ)
            (CongruenceSubgroup.Gamma1 N))
          k)
      (M : ℕ+) (hk : 0 < k)
      (hs : ↑k / 2 + 1 < s.re) :
      f.frickeCompletedL M s =
        ↑↑M ^ (s / 2) *
              (2 * ↑Real.pi) ^ (-s) *
            Complex.Gamma s *
          LSeries
            (fun n =>
              (PowerSeries.coeff n)
                (UpperHalfPlane.qExpansion 1
                  ⇑f))
            s
    **The completed L-function completes the Dirichlet series** (LMFDB
    `lfunction.history.hecke_operators`): for a cusp form `f` of weight `k > 0` on `Γ₁(N)`, in
    particular for a Hecke eigenform, Tau Ceti's level-`M` completed L-function is
    `Λ_M(s, f) = M^{s/2} (2π)^{-s} Γ(s) ∑ aₙ n⁻ˢ` on `Re s > k/2 + 1`. 
  • theoremdefined in TauCeti/NumberTheory/ModularForms/LFunction/FunctionalEquation.lean
    complete
    theorem CuspForm.frickeCompletedL_functional_equation_gamma1 {N : ℕ} [NeZero N]
      {k : ℤ}
      (f :
        CuspForm
          (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ)
            (CongruenceSubgroup.Gamma1 N))
          k)
      (hk : 0 < k) (s : ℂ) :
      f.frickeCompletedL (N.toPNat ⋯) (↑k - s) =
        Complex.I ^ k *
          ((TauCeti.normalizedFrickeOperatorCusp k) f).frickeCompletedL
            (N.toPNat ⋯) s
    theorem CuspForm.frickeCompletedL_functional_equation_gamma1
      {N : ℕ} [NeZero N] {k : ℤ}
      (f :
        CuspForm
          (Subgroup.map
            (Matrix.SpecialLinearGroup.mapGL
              ℝ)
            (CongruenceSubgroup.Gamma1 N))
          k)
      (hk : 0 < k) (s : ℂ) :
      f.frickeCompletedL (N.toPNat ⋯)
          (↑k - s) =
        Complex.I ^ k *
          ((TauCeti.normalizedFrickeOperatorCusp
                  k)
                f).frickeCompletedL
            (N.toPNat ⋯) s
    Hecke's functional equation for a positive-weight cusp form on `Γ₁(N)`, with the normalized
    Fricke operator providing the companion cusp form. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Newform/EigenformLFunction.lean
    complete
    theorem CuspForm.frickeCompletedL_sub_eq_of_level_one {k : ℤ} (s : ℂ)
      (f :
        CuspForm
          (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ)
            (CongruenceSubgroup.Gamma1 1))
          k)
      (hk : 0 < k) :
      f.frickeCompletedL 1 (↑k - s) = Complex.I ^ k * f.frickeCompletedL 1 s
    theorem CuspForm.frickeCompletedL_sub_eq_of_level_one
      {k : ℤ} (s : ℂ)
      (f :
        CuspForm
          (Subgroup.map
            (Matrix.SpecialLinearGroup.mapGL
              ℝ)
            (CongruenceSubgroup.Gamma1 1))
          k)
      (hk : 0 < k) :
      f.frickeCompletedL 1 (↑k - s) =
        Complex.I ^ k * f.frickeCompletedL 1 s
    **The functional equation of a cusp form of level `1`** (LMFDB
    `lfunction.history.hecke_operators`), Hecke's case: `Λ(k - s, f) = i^k Λ(s, f)` for a cusp form
    `f` of level `1` and weight `k > 0`, in particular for a Hecke eigenform, where
    `Λ(s, f) = (2π)^{-s} Γ(s) ∑ aₙ n⁻ˢ` on `Re s > k/2 + 1`
    (`CuspForm.frickeCompletedL_eq_mul_LSeries`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Newform/LFunctionSign.lean
    complete
    theorem HeckeRing.GL2.Newform.analyticCompletedL_eq_rootNumber_mul {N : ℕ}
      [NeZero N] {k : ℤ} (f : HeckeRing.GL2.Newform N k) (s : ℂ)
      (hk : 0 < k) :
      f.analyticCompletedL s =
        f.rootNumber *
          (starRingEnd ℂ) (f.analyticCompletedL (1 - (starRingEnd ℂ) s))
    theorem HeckeRing.GL2.Newform.analyticCompletedL_eq_rootNumber_mul
      {N : ℕ} [NeZero N] {k : ℤ}
      (f : HeckeRing.GL2.Newform N k) (s : ℂ)
      (hk : 0 < k) :
      f.analyticCompletedL s =
        f.rootNumber *
          (starRingEnd ℂ)
            (f.analyticCompletedL
              (1 - (starRingEnd ℂ) s))
    **The functional equation** (LMFDB `cmf.lfunction`): `Λ(s, f) = ε Λ̄(1 - s, f)`, where
    `Λ̄(s, f) = conj (Λ(conj s, f))`. 
Definition2.34
uses 0used by 1XL∃∀N

Langlands program. (LMFDB)

Langlands theory of automorphic forms ushered in an age of a new understanding of the profundity of L-functions. His small book Euler Products of 1967 contains the beginnings of a general theory.

In 1969 Ogg proved the holomorphy and functional equation for the Rankin-Selberg convolution of two inequivalent cusp forms of the same level. This is a degree 4 L-function. In 1972 Jacquet considered the Rankin-Selberg convolution of two GL(2) cusp forms and obtained the analytic continuation and functional equation of the associated L-function. In 1979 Winnie Li completed the Rankin-Selberg story for two arbitrary GL(2) cusp forms. Her techniques really require the use of Tate's thesis and the theory of automorphic forms as it is virtually impossible to figure out the Euler factors at bad primes without these.

In 1971 Andrianov explicitly constructed the L-function for a genus 2 Siegel modular form and gave its analytic continuation and functional equation.

In 1972 Godement and Jacquet defined the L-function of a general automorphic form on a reductive group and obtained the analytic continuation and functional equation.

It wasn't until the mid 1970's that Shimura and, shortly later but independently, Zagier proved that the L-function associated with the symmetric square of a cusp form is entire. See also the footnote in Selberg's paper that suggests that Selberg had discovered this many years earlier.

In 1977 Asai obtained the holomorphy and functional equation of certain degree 4 L-functions associated with Hilbert modular forms over quadratic fields. These are known as Asai L-functions.

Beginning in 1978 Shahidi and completed in 1999 with Kim proved that the symmetric cube of a GL(2) L-function is entire and has functional equation.

In 1980 Langlands proved Artin's conjecture for 2-dimensional representations of tetrahedral type (and also for certain octahedral representations) . In 1981 Tunnell proved Artin's conjecture for octahedral representations .

In work beginning in 1981 with , Shahidi proved the holomorphy and functional equation for many automorphic L-functions.

In 1983 Jacquet, Piatetskii-Shapiro, and Shalika obtained the meromorphicity and functional equation for the L-function that is a general Rankin-Selberg convolution of automorphic L-functions.

In 1995 Andrew Wiles proved the holomorphy and functional equation of the Hasse-Weil zeta-function of most elliptic curves. In 2001 this work was extended by Breuil, Conrad, Diamond, and Taylor to include all elliptic curves .

Definition2.35
uses 0used by 1XL∃∀N

L-functions of Maass forms. (LMFDB)

In 1949 Hans Maass made his profound discovery that there are L-functions associated with non-holomorphic automorphic forms. In his Math Review of Maass' article J. Lehner writes

<i>In Hecke's theory of Dirichlet series with Euler products we associate, roughly speaking, a Dirichlet series with an automorphic function; the invariance of the latter under linear substitutions is used, together with the Mellin transform, to derive a functional equation for the Dirichlet series. This suffices for the discussion of the \zeta-function of an imaginary quadratic field, for example, but not of a real quadratic field. In order to handle the latter case, the author defines a class of functions ("automorphic wave functions") to take the place of the analytic automorphic functions of Hecke's theory. </i>

Maass' work prompted Andre; Weil to remark "Il a fallu Maass pour nous sortir du ghetto des fonctions holomorphes."

Definition2.36
uses 0used by 1XL∃∀N

Ramanujan tau L-function. (LMFDB)

In 1916 Ramanujan made the startling observation that the coefficients of the \Delta function are multiplicative! Ramanujan defined \tau(n) by

q\prod_{n=1}^\infty (1-q^n)^{24}=\sum_{n=1}^\infty \tau(n)q^n

and conjectured that \tau(mn)=\tau(m)\tau(n) whenever m and n are relatively prime. Moreover that \sum_{r=0}^\infty \tau(p^r)X^r = (1-\tau(p)X +p^{11}X^2)^{-1}

and that |\tau(p)|< 2p^{11/2}. The first two of these astounding conjectures were verified by Mordell in 1917 (see "On Mr. Ramanujan's Empirical Expansions of Modular Functions." Proc. Cambridge Phil. Soc.19, (1917)) and the last by Deligne in 1974 in work for which he won a Fields Medal. It was already known that

\Delta(z)=\sum_{n=1}^\infty \tau(n)e(nz)

is a modular form of weight 12. Thus L(s)=\sum_{n=1}^\infty \tau(n)n^{-s} has a functional equation and (by Mordell) an Euler product. Ramanujan's discovery was the ushering in of a new age of arithmetic L-functions.

Definition2.37
uses 0used by 1XL∃∀N

Ranking-Selberg convolution, history. (LMFDB)

In 1939 R. A. Rankin studied Ramanujan's conjecture about the size of \tau(n) and was led to consider the analytic properties of g(s)=\sum_{n=1}^\infty \tau(n)^2 n^{-s}. He proved that \zeta(2s-22) g(s) is analytic everywhere except for a simple pole at s=12 and satisfies a functional equation. This was the beginning of the Rankin - Selberg convolution which we now realize was a hugely important event in the theory of L-functions. Selberg did the same calculation around the same time.

Definition2.38
uses 0used by 1XL∃∀N

Riemann's memoir. (LMFDB)

In 1859, in an 8 page paper "Uber die Anzahl der Primzahlen unter einer gegebenen Grosse" Transcript read to the Berlin Academy of Sciences by Gauss' former student Encke, Riemann first considered \zeta(s) as a function of a complex variable s. He proved that \zeta(s) is a meromorphic function in the complex s-plane whose only singularity is a simple pole at s=1 with residue 1. He went on to prove that

\xi(s)=\frac{1}{2} s(s-1)\pi^{-s/2}\Gamma(s/2) \zeta(s)

is entire of order 1 and satisfies the functional equation

\xi(s)=\xi(1-s).

He proved that \xi(s) has infinitely many zeros, all of which are in the critical strip 0\le \sigma\le 1, where \sigma denotes the real part of s. Riemann calculated the first few of these zeros (this was discovered later when Siegel studied Riemann's notes left to the Gottingen library) and found them to lie on the critical line \sigma=1/2. He conjectured that all of the zeros are on this line. And the analytic theory of L-functions was born!

Definition2.39
Statement uses 4
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1✓L∃∀N

Infinity factor of an L-function. (LMFDB)

The infinity factor L_{\infty}(s) of an L-function L(s) is the product of its Gamma factors:

L_{\infty}(s) := \prod_{j=1}^J \Gamma_{\mathbb{R}}(s+\mu_j) \prod_{k=1}^K \Gamma_{\mathbb{C}}(s+\nu_k).

Here the \mu_j and \nu_k are the spectral parameters of the L-function.

That is, the functional equation has the form

\Lambda(s) := L_{\infty}(s) L(s) = \varepsilon \overline{\Lambda}(1-s).

Depends on: Definition 2.7 Definition 2.25 Definition 2.26 Definition 2.63

Lean code for Definition2.39●6 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.SelbergData.gammaFactor
      (D : AnalyticLFunction.SelbergData) (s : ℂ) : ℂ
    def AnalyticLFunction.SelbergData.gammaFactor
      (D : AnalyticLFunction.SelbergData)
      (s : ℂ) : ℂ
    The **gamma factor** `∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ)` (LMFDB `lfunction.infinity_factor`) of a
    functional equation, the product of its shifted Deligne gamma factors `Γ_ℝ` and `Γ_ℂ` (LMFDB
    `lfunction.gamma_factor`). 
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.μ (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    abbrev AnalyticLFunction.SelbergData.μ
      (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    The spectral parameters `μⱼ` of the factors `Γ_ℝ(s + μⱼ)`. 
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.ν (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    abbrev AnalyticLFunction.SelbergData.ν
      (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    The spectral parameters `νₖ` of the factors `Γ_ℂ(s + νₖ)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_eq (self : AnalyticLFunction) {s : ℂ} :
      1 < s.re →
        self.completed s =
          ↑self.selbergData.conductor ^ (s / 2) *
              self.selbergData.gammaFactor s *
            self.toFun s
    theorem AnalyticLFunction.completed_eq
      (self : AnalyticLFunction) {s : ℂ} :
      1 < s.re →
        self.completed s =
          ↑self.selbergData.conductor ^
                (s / 2) *
              self.selbergData.gammaFactor s *
            self.toFun s
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Completed.lean
    complete
    theorem AnalyticLFunction.completed_eq_of_notMem_gammaPoles
      (L : AnalyticLFunction) {s : ℂ} (hs : s ∉ L.selbergData.gammaPoles)
      (hs₀ : s ≠ 0) (hs₁ : s ≠ 1) :
      L.completed s =
        ↑L.conductor ^ (s / 2) * L.selbergData.gammaFactor s * L.toFun s
    theorem AnalyticLFunction.completed_eq_of_notMem_gammaPoles
      (L : AnalyticLFunction) {s : ℂ}
      (hs : s ∉ L.selbergData.gammaPoles)
      (hs₀ : s ≠ 0) (hs₁ : s ≠ 1) :
      L.completed s =
        ↑L.conductor ^ (s / 2) *
            L.selbergData.gammaFactor s *
          L.toFun s
    **The completed L-function is the product of the L-function, its gamma factor and
    `N ^ (s / 2)`** (LMFDB `lfunction.completed`):
    `Λ(s) = N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ) L(s)` at every `s ≠ 0, 1` that is not a pole of
    the gamma factor. The axioms give it for `re s > 1`; both sides are analytic on the complement of
    the poles and of `0` and `1`, which is connected. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_eq_sign_mul_conj (self : AnalyticLFunction)
      {s : ℂ} :
      s ≠ 0 →
        s ≠ 1 →
          self.completed s =
            self.selbergData.sign *
              (starRingEnd ℂ) (self.completed (1 - (starRingEnd ℂ) s))
    theorem AnalyticLFunction.completed_eq_sign_mul_conj
      (self : AnalyticLFunction) {s : ℂ} :
      s ≠ 0 →
        s ≠ 1 →
          self.completed s =
            self.selbergData.sign *
              (starRingEnd ℂ)
                (self.completed
                  (1 - (starRingEnd ℂ) s))
Definition2.40
Statement uses 3
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Degree 1 L-functions, all. (LMFDB)

The degree 1 L-functions are:

  • \zeta(s): the Riemann zeta function

  • L(s, \chi): the Dirichlet L-function of a primitive Dirichlet character

Note that these L-functions also arise as Artin L-functions.

Depends on: Definition 6.2.10 Definition 2.7 Definition 2.20

Definition2.41
Statement uses 5
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Degree 2 L-functions, examples. (LMFDB)

Examples of primitive degree 2 L-functions are:

Depends on: Definition 3.1.64 Definition 4.1.64 Definition 2.7 Definition 2.20 Definition 3.6.23

Definition2.42
Statement uses 2
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Degree 3 L-functions, examples. (LMFDB)

Examples of primitive degree 3 L-functions are:

  • L(s, f, \mathrm{sym}^2): the symmetric square of a degree 2 L-function

  • L(s,f): standard L-function of a cusp form on GL(3)

Depends on: Definition 2.7 Definition 2.20

Definition2.43
Statement uses 4
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Degree 4 L-functions, examples. (LMFDB)

Examples of primitive degree 4 L-functions are:

  • L(s, f, \mathrm{sym}^3): the symmetric cube L-function of a cusp form on GL(2)

  • L(s, F, \mathrm{spin}): spin L-function of a Siegel modular form on GSp(4) (genus 2)

  • L(s,f): standard L-function of a cusp form on the Picard group SL(2,Z[i])

  • L(s,f): standard L-function of a cusp form on Sp(4)

  • L(s,f): standard L-function of a cusp form on GL(4)

  • L(s,E): L-function of an elliptic curve over a quadratic field

  • L(s,f): standard L-function of a Hilbert modular form on GL(2) over a real quadratic field

Depends on: Definition 3.1.14 Definition 2.7 Definition 2.20 Definition 2.48

Definition2.44
Statement uses 11
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Label of L-function. (LMFDB)

Each L-function L has a label of the form d-N-q.k-x-y-i, where

Depends on: Definition 6.1.1 Definition 6.1.3 Definition 6.1.20 Definition 6.1.30 Definition 2.7 Definition 2.12 Definition 2.17 Definition 2.20 Definition 2.25 Definition 2.47 Definition 2.62

Definition2.45
Statement uses 2
Statement dependency previews
Preview
Definition 2.10
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 6
Reverse dependency previews
Preview
Definition 4.1.2
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Leading coefficient. (LMFDB)

The leading coefficient of an arithmetic L-function is the first nonzero coefficient of its Laurent series expansion at the central point.

Tau Ceti Review: meromorphicTrailingCoeffAt.

Depends on: Definition 2.10 Definition 2.13

Lean code for Definition2.45●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticRank.lean
    complete
    def AnalyticLFunction.leadingCoeff (L : AnalyticLFunction) : ℂ
    def AnalyticLFunction.leadingCoeff
      (L : AnalyticLFunction) : ℂ
    The **leading coefficient** (LMFDB `lfunction.leading_coeff`) of an analytic L-function: the
    first nonzero coefficient `L⁽ʳ⁾(1 / 2) / r!` of the Taylor expansion of its continuation at its
    central point `s = 1 / 2`, where `r` is the analytic rank (`leadingCoeff_eq_iteratedDeriv`). It is
    also the leading coefficient at `(w + 1) / 2` of the arithmetic normalisation of any weight `w`
    (`meromorphicTrailingCoeffAt_arithmeticNormalization`). The LMFDB defines it for arithmetic
    L-functions; the definition makes sense for all. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticRank.lean
    complete
    theorem AnalyticLFunction.leadingCoeff_eq_iteratedDeriv
      (L : AnalyticLFunction) :
      L.leadingCoeff =
        iteratedDeriv L.analyticRank L.toFun (1 / 2) /
          ↑L.analyticRank.factorial
    theorem AnalyticLFunction.leadingCoeff_eq_iteratedDeriv
      (L : AnalyticLFunction) :
      L.leadingCoeff =
        iteratedDeriv L.analyticRank L.toFun
            (1 / 2) /
          ↑L.analyticRank.factorial
    The leading coefficient is `L⁽ʳ⁾(1 / 2) / r!`, where `r` is the analytic rank. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticRank.lean
    complete
    theorem AnalyticLFunction.meromorphicTrailingCoeffAt_arithmeticNormalization
      (L : AnalyticLFunction) (w : ℕ) :
      meromorphicTrailingCoeffAt (L.arithmeticNormalization w)
          ((↑w + 1) / 2) =
        L.leadingCoeff
    theorem AnalyticLFunction.meromorphicTrailingCoeffAt_arithmeticNormalization
      (L : AnalyticLFunction) (w : ℕ) :
      meromorphicTrailingCoeffAt
          (L.arithmeticNormalization w)
          ((↑w + 1) / 2) =
        L.leadingCoeff
    The leading coefficient is the leading coefficient of the arithmetic normalisation of weight
    `w` at its central point `(w + 1) / 2`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticRank.lean
    complete
    theorem AnalyticAt.meromorphicTrailingCoeffAt_eq_iteratedDeriv_div_factorial
      {f : ℂ → ℂ} {x : ℂ} {n : ℕ} (hf : AnalyticAt ℂ f x)
      (hn : analyticOrderAt f x = ↑n) :
      meromorphicTrailingCoeffAt f x = iteratedDeriv n f x / ↑n.factorial
    theorem AnalyticAt.meromorphicTrailingCoeffAt_eq_iteratedDeriv_div_factorial
      {f : ℂ → ℂ} {x : ℂ} {n : ℕ}
      (hf : AnalyticAt ℂ f x)
      (hn : analyticOrderAt f x = ↑n) :
      meromorphicTrailingCoeffAt f x =
        iteratedDeriv n f x / ↑n.factorial
    The trailing coefficient of a function analytic at `x` of finite order `n` there is its `n`-th
    Taylor coefficient `f⁽ⁿ⁾(x) / n!`. 
  • defdefined in Mathlib/Analysis/Meromorphic/TrailingCoefficient.lean
    complete
    def meromorphicTrailingCoeffAt.{u_1, u_2} {𝕜 : Type u_1}
      [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E]
      [NormedSpace 𝕜 E] (f : 𝕜 → E) (x : 𝕜) : E
    def meromorphicTrailingCoeffAt.{u_1, u_2}
      {𝕜 : Type u_1}
      [NontriviallyNormedField 𝕜]
      {E : Type u_2} [NormedAddCommGroup E]
      [NormedSpace 𝕜 E] (f : 𝕜 → E) (x : 𝕜) :
      E
    If `f` is meromorphic of finite order at a point `x`, the trailing coefficient is defined as the
    (unique!) value `g x` for a presentation of `f` in the form `(z - x) ^ order • g z` with `g`
    analytic at `x`. In all other cases, the trailing coefficient is defined to be zero.
    
Definition2.46
Statement uses 3
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 3
Reverse dependency previews
Preview
Definition 2.15
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
XL∃∀N

Motivic weight. (LMFDB)

The motivic weight (or arithmetic weight) of an arithmetic L-function with analytic normalization L_{an}(s)=\sum_{n=1}^\infty a_nn^{-s} is the least nonnegative integer w for which a_nn^{w/2} is an algebraic integer for all n\ge 1.

If the L-function arises from a motive, then the weight of the motive has the same parity as the motivic weight of the L-function, but the weight of the motive could be larger. This apparent discrepancy comes from the fact that a Tate twist increases the weight of the motive. This corresponds to the change of variables s \mapsto s + j in the L-function of the motive.

Depends on: Definition 2.7 Definition 2.10 Definition 2.47

Definition2.47
uses 1
Used by 12
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Normalization of an L-function. (LMFDB)

In its arithmetic normalization, an L-function L(s) of weight w has its central value at s=\frac{w+1}{2} and the functional equation relates s to 1 + w - s. For L-functions defined by an Euler product \prod_p L_p(s)^{-1} where the coefficients of L_p are algebraic integers, this is the usual normalization implied by the definition.

The analytic normalization of an L-function is defined by L_{an}(s):=L(s+w/2), where L(s) is the L-function in its arithmetic normalization. This moves the central value to s=1/2, and the functional equation of L_{an}(s) relates s to 1-s.

Depends on: Definition 2.25

Lean code for Definition2.47●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.arithmeticNormalization (L : AnalyticLFunction)
      (w : ℕ) (s : ℂ) : ℂ
    def AnalyticLFunction.arithmeticNormalization
      (L : AnalyticLFunction) (w : ℕ)
      (s : ℂ) : ℂ
    The L-function `s ↦ L(s - w / 2)` in its **arithmetic normalisation** of weight `w` (LMFDB
    `lfunction.normalization`), whose central point is `(w + 1) / 2` and whose functional equation
    relates `s` and `1 + w - s`. Conversely, `L` is the **analytic normalisation**
    `L(s) = L_arith(s + w / 2)` of it. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.arithmeticCoeff (L : AnalyticLFunction) (w n : ℕ) : ℂ
    def AnalyticLFunction.arithmeticCoeff
      (L : AnalyticLFunction) (w n : ℕ) : ℂ
    The Dirichlet coefficients `aₙ n ^ (w / 2)` of the arithmetic normalisation of weight `w` of an
    analytic L-function with Dirichlet coefficients `aₙ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.arithmeticNormalization_eq_LSeries
      (L : AnalyticLFunction) (w : ℕ) {s : ℂ} (hs : 1 + ↑w / 2 < s.re) :
      L.arithmeticNormalization w s = LSeries (L.arithmeticCoeff w) s
    theorem AnalyticLFunction.arithmeticNormalization_eq_LSeries
      (L : AnalyticLFunction) (w : ℕ) {s : ℂ}
      (hs : 1 + ↑w / 2 < s.re) :
      L.arithmeticNormalization w s =
        LSeries (L.arithmeticCoeff w) s
    The arithmetic normalisation of weight `w` is the Dirichlet series with the coefficients
    `aₙ n ^ (w / 2)` for `re s > 1 + w / 2`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_sub_eq_sign_mul_conj (L : AnalyticLFunction)
      (w : ℕ) {s : ℂ} (hs₀ : s ≠ ↑w / 2) (hs₁ : s ≠ 1 + ↑w / 2) :
      L.completed (s - ↑w / 2) =
        L.sign *
          (starRingEnd ℂ)
            (L.completed (1 + ↑w - (starRingEnd ℂ) s - ↑w / 2))
    theorem AnalyticLFunction.completed_sub_eq_sign_mul_conj
      (L : AnalyticLFunction) (w : ℕ) {s : ℂ}
      (hs₀ : s ≠ ↑w / 2)
      (hs₁ : s ≠ 1 + ↑w / 2) :
      L.completed (s - ↑w / 2) =
        L.sign *
          (starRingEnd ℂ)
            (L.completed
              (1 + ↑w - (starRingEnd ℂ) s -
                ↑w / 2))
    The functional equation in the arithmetic normalisation of weight `w` relates `s` and
    `1 + w - s`: the completion `Λ(s - w / 2)` equals `ε conj (Λ ((1 + w - conj s) - w / 2))`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.motivicWeight (L : AnalyticLFunction) : ℕ
    def AnalyticLFunction.motivicWeight
      (L : AnalyticLFunction) : ℕ
    The **motivic weight** (LMFDB `lfunction.motivic_weight`) of an arithmetic L-function: the
    least `w` such that every coefficient `aₙ n ^ (w / 2)` with `n ≥ 1` is an algebraic integer. When
    there is no such `w` it takes the junk value `0`. 
Definition2.48
uses 0
Used by 2
Reverse dependency previews
Preview
Definition 2.43
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Primitive L-function. (LMFDB)

An L-function is <b>primitive</b> if it cannot be written as a product of nontrivial L-functions. The "trivial L-function" is the constant function 1.

Lean code for Definition2.48●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Primitive.lean
    complete
    def AnalyticLFunction.IsPrimitive (L : AnalyticLFunction) : Prop
    def AnalyticLFunction.IsPrimitive
      (L : AnalyticLFunction) : Prop
    An analytic L-function is **primitive** (LMFDB `lfunction.primitive`) if it is not trivial and
    cannot be written as a product of two nontrivial L-functions: whenever its Dirichlet coefficients
    `aₙ` (`n ≥ 1`) are those of a product `L₁ L₂`, which are the Dirichlet convolution of the
    coefficients of `L₁` and `L₂`, one of `L₁` and `L₂` is trivial. As for irreducible elements of a
    monoid, and in the Selberg class, the trivial L-function itself is not primitive, a case that the
    knowl's wording leaves open. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Primitive.lean
    complete
    def AnalyticLFunction.IsTrivial (L : AnalyticLFunction) : Prop
    def AnalyticLFunction.IsTrivial
      (L : AnalyticLFunction) : Prop
    An analytic L-function is **trivial** (LMFDB `lfunction.primitive`) if it is the constant
    function `1`, the trivial L-function `AnalyticLFunction.one`: if its Dirichlet coefficients `aₙ`
    vanish for `n ≥ 2`, as `a₁ = 1` holds for every analytic L-function. Its continuation is then `1`
    (`IsTrivial.toFun_eq_one`), and the trivial analytic L-functions are those of degree `0`
    (`isTrivial_iff_degree_eq_zero`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Primitive.lean
    complete
    def AnalyticLFunction.one : AnalyticLFunction
    def AnalyticLFunction.one : AnalyticLFunction
    The **trivial L-function** (LMFDB `lfunction.primitive`), the constant function `1`: the
    analytic L-function with Dirichlet coefficients `δ = (1, 0, 0, …)`, Euler factors `1`, completion
    `1` and Selberg data `(1, ∅, ∅, 1)`, of degree `0`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Primitive.lean
    complete
    def AnalyticLFunction.mul (L₁ L₂ : AnalyticLFunction) : AnalyticLFunction
    def AnalyticLFunction.mul
      (L₁ L₂ : AnalyticLFunction) :
      AnalyticLFunction
    The **product** `L₁ L₂` of two analytic L-functions: the analytic L-function with the Dirichlet
    coefficients `L₁.coeff ⍟ L₂.coeff`, the Dirichlet convolution of those of `L₁` and `L₂`, the
    continuation `L₁(s) L₂(s)`, the completion `Λ₁(s) Λ₂(s)`, the Euler factors `F₁,ₚ F₂,ₚ` and the
    Selberg data `(N₁ N₂, μ₁ + μ₂, ν₁ + ν₂, ε₁ ε₂)`, of degree `d₁ + d₂`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Primitive.lean
    complete
    theorem AnalyticLFunction.isPrimitive_zeta : AnalyticLFunction.zeta.IsPrimitive
    theorem AnalyticLFunction.isPrimitive_zeta :
      AnalyticLFunction.zeta.IsPrimitive
    **The Riemann zeta function is primitive**, being of degree `1`. 
Definition2.49
Statement uses 4
Statement dependency previews
Preview
Definition 2.10
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 2
Reverse dependency previews
Preview
Definition 2.70
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Rational L-function. (LMFDB)

A rational L-function L(s) is an arithmetic L-function with coefficient field \Q; equivalently, its Euler product in the arithmetic normalization can be written as a product over rational primes

L(s)=\prod_pL_p(p^{-s})^{-1}

with L_p\in \Z[T].

Depends on: Definition 2.10 Definition 2.15 Definition 2.24 Definition 2.47

Lean code for Definition2.49●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Rational.lean
    complete
    def AnalyticLFunction.IsRational (L : AnalyticLFunction) : Prop
    def AnalyticLFunction.IsRational
      (L : AnalyticLFunction) : Prop
    An analytic L-function `L(s) = ∑ aₙ n ^ (-s)` is **rational** (LMFDB `lfunction.rational`) if
    it is arithmetic with a motivic weight `w`, that is, the numbers `aₙ n ^ (w / 2)` are algebraic
    integers for some `w`, and its coefficient field, the field generated by the `aₙ n ^ (w / 2)` for
    the least such `w` (`AnalyticLFunction.motivicWeight`), is `ℚ`. The existence of `w` makes the
    coefficients `aₙ` algebraic (`AnalyticLFunction.IsRational.isAlgebraic_coeff`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Rational.lean
    complete
    def AnalyticLFunction.arithmeticEulerPolynomial (L : AnalyticLFunction)
      (w p : ℕ) : Polynomial ℂ
    def AnalyticLFunction.arithmeticEulerPolynomial
      (L : AnalyticLFunction) (w p : ℕ) :
      Polynomial ℂ
    The **Euler factor in the arithmetic normalisation** of weight `w` of an analytic L-function at
    `p`: `L_p(T) = F_p(p ^ (w / 2) T)`, where `F_p` is the Euler factor in the analytic normalisation
    (`AnalyticLFunction.eulerPolynomial`), so that `L(s - w / 2) = ∏ₚ L_p(p ^ (-s))⁻¹`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.motivicWeight (L : AnalyticLFunction) : ℕ
    def AnalyticLFunction.motivicWeight
      (L : AnalyticLFunction) : ℕ
    The **motivic weight** (LMFDB `lfunction.motivic_weight`) of an arithmetic L-function: the
    least `w` such that every coefficient `aₙ n ^ (w / 2)` with `n ≥ 1` is an algebraic integer. When
    there is no such `w` it takes the junk value `0`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.arithmeticCoeff (L : AnalyticLFunction) (w n : ℕ) : ℂ
    def AnalyticLFunction.arithmeticCoeff
      (L : AnalyticLFunction) (w n : ℕ) : ℂ
    The Dirichlet coefficients `aₙ n ^ (w / 2)` of the arithmetic normalisation of weight `w` of an
    analytic L-function with Dirichlet coefficients `aₙ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Rational.lean
    complete
    theorem AnalyticLFunction.IsRational.isAlgebraic_coeff {L : AnalyticLFunction}
      {n : ℕ} (h : L.IsRational) (hn : n ≠ 0) : IsAlgebraic ℚ (L.coeff n)
    theorem AnalyticLFunction.IsRational.isAlgebraic_coeff
      {L : AnalyticLFunction} {n : ℕ}
      (h : L.IsRational) (hn : n ≠ 0) :
      IsAlgebraic ℚ (L.coeff n)
    **A rational L-function is arithmetic** (LMFDB `lfunction.arithmetic`): its Dirichlet
    coefficients `aₙ`, `n ≥ 1`, are algebraic numbers, as `aₙ n ^ (w / 2)` is an algebraic integer
    and `n ^ (w / 2)` a square root of `n ^ w`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Rational.lean
    complete
    theorem AnalyticLFunction.arithmeticEulerPolynomial_mul_mk
      (L : AnalyticLFunction) {w p : ℕ} (hp : Nat.Prime p) :
      (↑(L.arithmeticEulerPolynomial w p) *
          PowerSeries.mk fun k => L.arithmeticCoeff w (p ^ k)) =
        1
    theorem AnalyticLFunction.arithmeticEulerPolynomial_mul_mk
      (L : AnalyticLFunction) {w p : ℕ}
      (hp : Nat.Prime p) :
      (↑(L.arithmeticEulerPolynomial w p) *
          PowerSeries.mk fun k =>
            L.arithmeticCoeff w (p ^ k)) =
        1
    **The Euler factor in the arithmetic normalisation inverts the local series**:
    `L_p(T) ∑ₖ a_{pᵏ} p ^ (k w / 2) Tᵏ = 1` at a prime `p`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Rational.lean
    complete
    theorem AnalyticLFunction.isRational_iff (L : AnalyticLFunction) :
      L.IsRational ↔
        ∀ (p : ℕ),
          Nat.Prime p →
            ∃ G,
              Polynomial.map (Int.castRingHom ℂ) G =
                L.arithmeticEulerPolynomial L.motivicWeight p
    theorem AnalyticLFunction.isRational_iff
      (L : AnalyticLFunction) :
      L.IsRational ↔
        ∀ (p : ℕ),
          Nat.Prime p →
            ∃ G,
              Polynomial.map
                  (Int.castRingHom ℂ) G =
                L.arithmeticEulerPolynomial
                  L.motivicWeight p
    **A rational L-function is one whose Euler factors in the arithmetic normalisation lie in
    `ℤ[T]`** (LMFDB `lfunction.rational`): `L` is rational exactly when, for its motivic weight `w`,
    every Euler factor `L_p(T) = F_p(p ^ (w / 2) T)` of `L(s - w / 2) = ∏ₚ L_p(p ^ (-s))⁻¹` is the image
    of a polynomial with integer coefficients. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Rational.lean
    complete
    theorem AnalyticLFunction.isRational_zeta : AnalyticLFunction.zeta.IsRational
    theorem AnalyticLFunction.isRational_zeta :
      AnalyticLFunction.zeta.IsRational
    **The Riemann zeta function is rational**: its coefficients `aₙ = 1` are integers, and its
    motivic weight is `0`. 
Definition2.50
uses 1
Used by 4
Reverse dependency previews
Preview
Definition 2.51
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Generalized Riemann hypothesis. (LMFDB)

The Riemann hypothesis is the assertion that if \rho is a zero of an analytic L-function then \mathrm{Re}(\rho)>0 implies that \mathrm{Re}(\rho)=1/2.

Tau Ceti Review: RiemannHypothesis.

Depends on: Definition 2.7

Lean code for Definition2.50●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RiemannHypothesis.lean
    complete
    def AnalyticLFunction.RiemannHypothesis (L : AnalyticLFunction) : Prop
    def AnalyticLFunction.RiemannHypothesis
      (L : AnalyticLFunction) : Prop
    The **Riemann hypothesis** (LMFDB `lfunction.rh`) for an analytic L-function: its zeros `ρ`
    with `re ρ > 0` lie on the critical line `re ρ = 1 / 2`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RiemannHypothesis.lean
    complete
    def GeneralizedRiemannHypothesis : Prop
    def GeneralizedRiemannHypothesis : Prop
    The **generalized Riemann hypothesis** (LMFDB `lfunction.rh`): every analytic L-function
    satisfies the Riemann hypothesis, that is, all of its zeros `ρ` with `re ρ > 0` satisfy
    `re ρ = 1 / 2`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RiemannHypothesis.lean
    complete
    def AnalyticLFunction.zeros (L : AnalyticLFunction) : Set ℂ
    def AnalyticLFunction.zeros
      (L : AnalyticLFunction) : Set ℂ
    The **zeros** (LMFDB `lfunction.zeros`) of an analytic L-function: the points where its
    continuation, a meromorphic function on `ℂ`, has positive order. Away from the only possible pole
    `s = 1` they are the points where the continuation vanishes (`mem_zeros_iff`); using the order
    makes the junk value at a pole irrelevant. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RiemannZeta.lean
    complete
    theorem riemannHypothesis_iff_zeta :
      RiemannHypothesis ↔ AnalyticLFunction.zeta.RiemannHypothesis
    theorem riemannHypothesis_iff_zeta :
      RiemannHypothesis ↔
        AnalyticLFunction.zeta.RiemannHypothesis
    Mathlib's `RiemannHypothesis` is the Riemann hypothesis (LMFDB `lfunction.rh`) for the Riemann
    zeta function as an analytic L-function. 
  • defdefined in Mathlib/NumberTheory/LSeries/RiemannZeta.lean
    complete
    def RiemannHypothesis : Prop
    def RiemannHypothesis : Prop
    A formal statement of the **Riemann hypothesis** – constructing a term of this type is worth a
    million dollars. 
Definition2.51
Statement uses 7
Statement dependency previews
Preview
Definition 2.18
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 4
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
XL∃∀N

Riemann zeta-function. (LMFDB)

The Riemann zeta-function is defined by the Dirichlet series

\zeta(s)=\sum_{n=1}^\infty \frac 1{n^s},

which converges for s=\sigma+it with \sigma>1. Euler showed that

\zeta(s)=\prod_p (1-p^{-s})^{-1},

known today as the Euler product, for s a real number with s>1, a fact that connects the study of \zeta(s) with the prime numbers. Riemann, in 1859, was the first to consider \zeta(s) as a function of a complex variable. He proved that \zeta(s) has an analytic continuation to the whole complex plane apart from a simple pole at s=1 with residue 1. Riemann proved a remarkable functional equation. He showed that

\xi(s):=\frac 12 s (s-1) \pi^{-s/2} \Gamma(s/2) \zeta(s)

is an entire function of order 1 which satisfies

\xi(s)=\xi(1-s).

Riemann showed that the distribution of prime numbers depends on the location of the zeros of the Riemann zeta-function which, by the Euler product and functional equation, are all in the critical strip 0\le \sigma \le 1. Riemann showed that the number N(T) of zeros of \zeta(s) in the critical strip with ordinates at most T satisfies

N(T)=\frac{T}{2\pi} \log\frac{T}{2\pi e} +O(\log T).

He calculated the first few zeros and verified that they are on the critical line \sigma=1/2 and then made his famous conjecture, today known as the Riemann Hypothesis, that all of the zeros are on the critical line. In 1896 Hadamard and de la Vallee Poussin independently proved that \zeta(s) has no zeros on the boundary of the critical strip, i.e. all of the zeros are in the open strip 0< \sigma < 1, and in doing so proved the Prime Number Theorem, that the number of primes less than a large number x is asymptotic to \frac{x}{\log x}.

Today we know that the first 10 trillion zeros of \zeta(s) are all on the critical line and that at least 41% of all of the complex zeros are on the critical line.

Depends on: Definition 2.18 Definition 2.19 Definition 2.22 Definition 2.24 Definition 2.25 Definition 2.50 Definition 2.68

Definition2.52
uses 0used by 0✓L∃∀N

Euler product for the Riemann zeta function. (LMFDB)

The Euler product for the Riemann zeta function is its expansion as the infinite product

\zeta(s) = \prod_{p \textrm{ prime}} \frac{1}{1-p^{-s}}.

This expansion holds in the region \Re(s)>1, where the product is absolutely convergent. The first proof of this expansion, due to Euler (1737), is based on the fact that every positive integer n can be written uniquely as a product of primes. Namely, for \Re(s) >1,

\prod_{p } \frac{1}{1-p^{-s}} = \prod_p \left(\sum_{k=0}^\infty p^{-ks} \right) = \sum_{n=1}^\infty n^{-s} = \zeta(s).

Lean code for Definition2.52●2 theorems
  • theoremdefined in Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean
    complete
    theorem riemannZeta_eulerProduct_tprod {s : ℂ} (hs : 1 < s.re) :
      ∏' (p : Nat.Primes), (1 - ↑↑p ^ (-s))⁻¹ = riemannZeta s
    theorem riemannZeta_eulerProduct_tprod {s : ℂ}
      (hs : 1 < s.re) :
      ∏' (p : Nat.Primes),
          (1 - ↑↑p ^ (-s))⁻¹ =
        riemannZeta s
    The Euler product for the Riemann ζ function, valid for `s.re > 1`.
    This version is stated in terms of `tprod`. 
  • theoremdefined in Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean
    complete
    theorem riemannZeta_eulerProduct_hasProd {s : ℂ} (hs : 1 < s.re) :
      HasProd (fun p => (1 - ↑↑p ^ (-s))⁻¹) (riemannZeta s)
    theorem riemannZeta_eulerProduct_hasProd {s : ℂ}
      (hs : 1 < s.re) :
      HasProd (fun p => (1 - ↑↑p ^ (-s))⁻¹)
        (riemannZeta s)
    The Euler product for the Riemann ζ function, valid for `s.re > 1`.
    This version is stated in terms of `HasProd`. 
Definition2.53
Statement uses 5
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Root analytic conductor. (LMFDB)

If d is the degree of the L-function L(s), the root analytic conductor \alpha of L is the dth root of the analytic conductor of L. It plays a role analogous to the root discriminant for number fields.

Depends on: Definition 2.7 Definition 2.8 Definition 2.20 Definition 5.1.1 Definition 5.1.75

Lean code for Definition2.53●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RootAnalyticConductor.lean
    complete
    def AnalyticLFunction.rootAnalyticConductor (L : AnalyticLFunction) : ℝ
    def AnalyticLFunction.rootAnalyticConductor
      (L : AnalyticLFunction) : ℝ
    The **root analytic conductor** `α = A ^ (1 / d)` (LMFDB `lfunction.root_analytic_conductor`) of
    an analytic L-function of degree `d` (LMFDB `lfunction.degree`) and analytic conductor `A` (LMFDB
    `lfunction.analytic_conductor`), the positive real `d`-th root of `A`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RootAnalyticConductor.lean
    complete
    theorem AnalyticLFunction.rootAnalyticConductor_pow_degree
      (L : AnalyticLFunction) (hL : L.degree ≠ 0) :
      L.rootAnalyticConductor ^ L.degree = L.analyticConductor
    theorem AnalyticLFunction.rootAnalyticConductor_pow_degree
      (L : AnalyticLFunction)
      (hL : L.degree ≠ 0) :
      L.rootAnalyticConductor ^ L.degree =
        L.analyticConductor
    **The root analytic conductor is a `d`-th root of the analytic conductor.** 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RootAnalyticConductor.lean
    complete
    theorem AnalyticLFunction.rootAnalyticConductor_pos (L : AnalyticLFunction) :
      0 < L.rootAnalyticConductor
    theorem AnalyticLFunction.rootAnalyticConductor_pos
      (L : AnalyticLFunction) :
      0 < L.rootAnalyticConductor
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/AnalyticConductor.lean
    complete
    def AnalyticLFunction.analyticConductor (L : AnalyticLFunction) : ℝ
    def AnalyticLFunction.analyticConductor
      (L : AnalyticLFunction) : ℝ
    The **analytic conductor** (LMFDB `lfunction.analytic_conductor`)
    `exp (2 re (L_∞'(1 / 2) / L_∞(1 / 2))) N` of an analytic L-function with gamma factor `L_∞(s)`
    (`AnalyticLFunction.SelbergData.gammaFactor`, LMFDB `lfunction.infinity_factor`) and conductor `N`.
    
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.degree (L : AnalyticLFunction) : ℕ
    def AnalyticLFunction.degree
      (L : AnalyticLFunction) : ℕ
    The **degree** (LMFDB `lfunction.degree`) of an analytic L-function. 
Definition2.54
uses 1used by 0✓L∃∀N

Root angle of L-function. (LMFDB)

The root angle of an L-function is the argument of its root number, as a real number \alpha with -0.5 < \alpha \le 0.5.

Tau Ceti Review: Complex.arg, Complex.neg_pi_lt_arg, Complex.arg_le_pi.

Depends on: Definition 2.60

Lean code for Definition2.54●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.sign (L : AnalyticLFunction) : ℂ
    def AnalyticLFunction.sign
      (L : AnalyticLFunction) : ℂ
    The **sign** `ε` (LMFDB `lfunction.sign`, `lfunction.root_number`) of the functional equation
    `Λ(s) = ε conj (Λ (1 - conj s))` of an analytic L-function, also called its root number. 
  • defdefined in Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
    complete
    def Complex.arg (x : ℂ) : ℝ
    def Complex.arg (x : ℂ) : ℝ
    `arg` returns values in the range $(-π, π]$, such that for `x ≠ 0`,
    `sin (arg x) = x.im / x.abs` and `cos (arg x) = x.re / x.abs`,
    `arg 0` defaults to `0` 
  • theoremdefined in Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
    complete
    theorem Complex.neg_pi_lt_arg (x : ℂ) : -Real.pi < x.arg
    theorem Complex.neg_pi_lt_arg (x : ℂ) :
      -Real.pi < x.arg
  • theoremdefined in Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
    complete
    theorem Complex.arg_le_pi (x : ℂ) : x.arg ≤ Real.pi
    theorem Complex.arg_le_pi (x : ℂ) :
      x.arg ≤ Real.pi
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.norm_sign (L : AnalyticLFunction) : ‖L.sign‖ = 1
    theorem AnalyticLFunction.norm_sign
      (L : AnalyticLFunction) : ‖L.sign‖ = 1
    The sign of the functional equation of an analytic L-function has absolute value `1`. 
Definition2.55
Statement uses 2
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 2
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Sign of an L-function. (LMFDB)

The sign of an L-function is the complex number \varepsilon occurring in its functional equation

\Lambda(s) := N^{s/2} \prod_{j=1}^J \Gamma_{\mathbb{R}}(s+\mu_j) \prod_{k=1}^K \Gamma_{\mathbb{C}}(s+\nu_k) \cdot L(s) = \varepsilon \overline{\Lambda}(1-s).

It appears as the fourth component of the Selberg data of L.

If all of the coefficients of the Dirichlet series defining L(s) are real, then necessarily \varepsilon = \pm 1. If the coefficients are real and \varepsilon = - 1, then L(1/2)=0.

Depends on: Definition 2.7 Definition 2.25

Lean code for Definition2.55●6 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.sign (L : AnalyticLFunction) : ℂ
    def AnalyticLFunction.sign
      (L : AnalyticLFunction) : ℂ
    The **sign** `ε` (LMFDB `lfunction.sign`, `lfunction.root_number`) of the functional equation
    `Λ(s) = ε conj (Λ (1 - conj s))` of an analytic L-function, also called its root number. 
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.sign
      (self : AnalyticLFunction.SelbergData) : ℂ
    abbrev AnalyticLFunction.SelbergData.sign
      (self : AnalyticLFunction.SelbergData) :
      ℂ
    The sign `ε`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_eq (self : AnalyticLFunction) {s : ℂ} :
      1 < s.re →
        self.completed s =
          ↑self.selbergData.conductor ^ (s / 2) *
              self.selbergData.gammaFactor s *
            self.toFun s
    theorem AnalyticLFunction.completed_eq
      (self : AnalyticLFunction) {s : ℂ} :
      1 < s.re →
        self.completed s =
          ↑self.selbergData.conductor ^
                (s / 2) *
              self.selbergData.gammaFactor s *
            self.toFun s
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_eq_sign_mul_conj (self : AnalyticLFunction)
      {s : ℂ} :
      s ≠ 0 →
        s ≠ 1 →
          self.completed s =
            self.selbergData.sign *
              (starRingEnd ℂ) (self.completed (1 - (starRingEnd ℂ) s))
    theorem AnalyticLFunction.completed_eq_sign_mul_conj
      (self : AnalyticLFunction) {s : ℂ} :
      s ≠ 0 →
        s ≠ 1 →
          self.completed s =
            self.selbergData.sign *
              (starRingEnd ℂ)
                (self.completed
                  (1 - (starRingEnd ℂ) s))
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RootNumber.lean
    complete
    theorem AnalyticLFunction.sign_eq_one_or_eq_neg_one (L : AnalyticLFunction)
      (hL : ∀ (n : ℕ), n ≠ 0 → (starRingEnd ℂ) (L.coeff n) = L.coeff n) :
      L.sign = 1 ∨ L.sign = -1
    theorem AnalyticLFunction.sign_eq_one_or_eq_neg_one
      (L : AnalyticLFunction)
      (hL :
        ∀ (n : ℕ),
          n ≠ 0 →
            (starRingEnd ℂ) (L.coeff n) =
              L.coeff n) :
      L.sign = 1 ∨ L.sign = -1
    **The sign of a self-dual L-function is `±1`** (LMFDB `lfunction.root_number`): if the Dirichlet
    coefficients are real, then `ε = 1` or `ε = -1`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RootNumber.lean
    complete
    theorem AnalyticLFunction.toFun_one_half_eq_zero_of_sign_eq_neg_one
      (L : AnalyticLFunction)
      (hL : ∀ (n : ℕ), n ≠ 0 → (starRingEnd ℂ) (L.coeff n) = L.coeff n)
      (hε : L.sign = -1) : L.toFun (1 / 2) = 0
    theorem AnalyticLFunction.toFun_one_half_eq_zero_of_sign_eq_neg_one
      (L : AnalyticLFunction)
      (hL :
        ∀ (n : ℕ),
          n ≠ 0 →
            (starRingEnd ℂ) (L.coeff n) =
              L.coeff n)
      (hε : L.sign = -1) : L.toFun (1 / 2) = 0
    **A self-dual L-function of sign `-1` vanishes at the central point** (LMFDB
    `lfunction.root_number`): if the Dirichlet coefficients are real and `ε = -1`, then
    `L(1 / 2) = 0`. 
Definition2.56
Statement uses 3
Statement dependency previews
Preview
Definition 2.22
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 3
Reverse dependency previews
Preview
Definition 2.72
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Selberg class of L-functions. (LMFDB)

The Selberg class \mathcal{S} is the set of all Dirichlet series that satisfy the four Selberg class axioms. The set \mathcal{S} was defined by Atle Selberg, who conjectured that its elements all satisfy the Riemann hypothesis.

Depends on: Definition 2.22 Definition 2.50 Definition 2.57

Lean code for Definition2.56●2 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/SelbergClass.lean
    complete
    def LSeries.selbergClass : Set (ℕ → ℂ)
    def LSeries.selbergClass : Set (ℕ → ℂ)
    The **Selberg class** (LMFDB `lfunction.selberg_class`): the Dirichlet series, encoded by their
    coefficients, that satisfy the Selberg axioms. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/SelbergClass.lean
    complete
    theorem LSeries.delta_mem_selbergClass : LSeries.delta ∈ LSeries.selbergClass
    theorem LSeries.delta_mem_selbergClass :
      LSeries.delta ∈ LSeries.selbergClass
    The constant Dirichlet series `1 = ∑ δₙ n ^ (-s)`, where `δ₁ = 1` and `δₙ = 0` for `n ≠ 1`,
    satisfies the Selberg axioms, with `m = 0`, the gamma factor `γ(s) = 1` and `bₙ = 0`: the Selberg
    class is not empty. 
Definition2.57
Statement uses 2
Statement dependency previews
Preview
Definition 2.24
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1✓L∃∀N

Selberg class axioms. (LMFDB)

The Selberg axioms for F(s)=\sum_{n=1}^\infty \frac{a_n}{n^s} in the Selberg class are: <ol> <li> Analyticity: (s-1)^mF(s) is an entire function of finite order for some non-negative integer m <li> Ramanujan Hypothesis: a_n = O_{\epsilon}(n^\epsilon) for any fixed \epsilon>0 <li> Functional equation: there is a function \gamma_F(s) of the form

\gamma_F(s)=\epsilon Q^s \prod_{i=1}^k\Gamma(\lambda_is+\mu_i)

where |\epsilon|=1, Q>0, \lambda_i>0, and Re(\mu_i)\ge 0 such that \Lambda(s)=\gamma_F(s)F(s)

satisfies

\Lambda(s)=\overline{\Lambda}(1-s)

where \overline{\Lambda}(s)=\overline{\Lambda(\overline{s})}.</li> <li> Euler product: a_1=1, and \log F(s)=\sum_{n=1}^\infty \frac{b_n}{n^s}

where b_n=0 unless n is a positive power of a prime and b_n\ll n^\theta for some \theta<1/2.</li> </ol>

Depends on: Definition 2.24 Definition 2.25

Lean code for Definition2.57●5 definitions
  • structure(4 fields)defined in LeanBridge/ForMathlib/NumberTheory/LFunction/SelbergClass.lean
    complete
    structure LSeries.SelbergAxioms (a : ℕ → ℂ) : Prop
    structure LSeries.SelbergAxioms (a : ℕ → ℂ) : Prop
    The **Selberg axioms** (LMFDB `lfunction.selberg_class.axioms`) for the Dirichlet series
    `F(s) = ∑ aₙ n ^ (-s)`: analyticity, the Ramanujan hypothesis, a functional equation and an Euler
    product. 
    selbergAnalyticity : LSeries.SelbergAnalyticity a
    ramanujanHypothesis : LSeries.RamanujanHypothesis a
    selbergFunctionalEquation : LSeries.SelbergFunctionalEquation a
    selbergEulerProduct : LSeries.SelbergEulerProduct a
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/SelbergClass.lean
    complete
    def LSeries.SelbergAnalyticity (a : ℕ → ℂ) : Prop
    def LSeries.SelbergAnalyticity (a : ℕ → ℂ) :
      Prop
    Selberg's **analyticity** axiom (LMFDB `lfunction.selberg_class.axioms`) for the Dirichlet
    series `F(s) = ∑ aₙ n ^ (-s)`: for some `m ∈ ℕ`, `(s - 1) ^ m F(s)` is an entire function `G` of
    finite order, that is `|G(z)| ≤ C exp (|z| ^ ρ)` for some `C` and `ρ` and all large `|z|`. Here
    `F(s)` is the sum of the series for `re s > 1`, where it converges absolutely under the Ramanujan
    hypothesis (`RamanujanHypothesis.LSeriesSummable`); `G` is its continuation multiplied by
    `(s - 1) ^ m`. Mathlib has no order of growth of entire functions, so the bound is written out. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/SelbergClass.lean
    complete
    def LSeries.RamanujanHypothesis (a : ℕ → ℂ) : Prop
    def LSeries.RamanujanHypothesis (a : ℕ → ℂ) :
      Prop
    The **Ramanujan hypothesis** (LMFDB `lfunction.selberg_class.axioms`) of the Selberg class for
    the Dirichlet series `∑ aₙ n ^ (-s)`: `aₙ = O(n ^ ε)` for every `ε > 0`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/SelbergClass.lean
    complete
    def LSeries.SelbergFunctionalEquation (a : ℕ → ℂ) : Prop
    def LSeries.SelbergFunctionalEquation
      (a : ℕ → ℂ) : Prop
    Selberg's **functional equation** axiom (LMFDB `lfunction.selberg_class.axioms`,
    `lfunction.functional_equation`) for the Dirichlet series `F(s) = ∑ aₙ n ^ (-s)`: there is a gamma
    factor `γ(s) = ε Q ^ s ∏ᵢ Γ(λᵢ s + μᵢ)` such that `Λ(s) = γ(s) F(s)` satisfies
    `Λ(s) = conj (Λ (1 - conj s))`, where `F` is the continuation of the series from `re s > 1` to
    `ℂ ∖ {1}`. The identity is required on the strip `0 < re s < 1`, where `Λ(s)` and
    `conj (Λ (1 - conj s))` are holomorphic; by analytic continuation it then holds wherever both sides
    are holomorphic, which is the identity of meromorphic functions on `ℂ` when `F` is meromorphic at
    `1` (as the analyticity axiom ensures), and it avoids the junk values at the poles of the gamma
    factor. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/SelbergClass.lean
    complete
    def LSeries.SelbergEulerProduct (a : ℕ → ℂ) : Prop
    def LSeries.SelbergEulerProduct (a : ℕ → ℂ) :
      Prop
    Selberg's **Euler product** axiom (LMFDB `lfunction.selberg_class.axioms`,
    `lfunction.euler_product`) for the Dirichlet series `F(s) = ∑ aₙ n ^ (-s)`: `a₁ = 1` and
    `log F(s) = ∑ bₙ n ^ (-s)`, where `bₙ = 0` unless `n` is a positive power of a prime and
    `bₙ = O(n ^ θ)` for some `θ < 1 / 2`. The logarithm is understood as `F(s) = exp (∑ bₙ n ^ (-s))`
    with the series converging absolutely, for `re s > 1`; given the other axioms this is the same as
    asking it on some right half-plane, since then `b_p = a_p`. 
Definition2.58
Statement uses 8
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 2
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Selberg data for the functional equation of an L-function. (LMFDB)

The Selberg data for an L-function is the quadruple (d, N,(\mu_1,\ldots,\mu_J:\nu_1,\ldots,\nu_K),\varepsilon) obtained from the parameters in the analytically normalized functional equation.

Here d=J+2K is the degree of the L-function, N is the conductor of the L-function, the set of \mu_j and \nu_k arising from the \Gamma_{\mathbb{R}} and \Gamma_{\mathbb{C}} factors, respectively, are the spectral parameters, and \varepsilon is the sign of the L-function.

Depends on: Definition 2.7 Definition 2.17 Definition 2.20 Definition 2.25 Definition 2.26 Definition 2.47 Definition 2.55 Definition 2.63

Lean code for Definition2.58●6 definitions
  • structure(8 fields)defined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    structure AnalyticLFunction.SelbergData : Type
    structure AnalyticLFunction.SelbergData : Type
    The **Selberg data** (LMFDB `lfunction.selbergdata`) of a functional equation
    `Λ(s) = N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ) L(s) = ε conj (Λ (1 - conj s))`: the
    **conductor** `N` (LMFDB `lfunction.conductor`), the **spectral parameters** `μⱼ` of the factors
    `Γ_ℝ` and `νₖ` of the factors `Γ_ℂ` (LMFDB `lfunction.spectral_parameters`), and the **sign** `ε`
    (LMFDB `lfunction.sign`). The degree, the first entry of the LMFDB's quadruple, is
    `AnalyticLFunction.SelbergData.degree`. As in the LMFDB, the spectral parameters are normalised
    so that each `re μⱼ` is `0` or `1` (assuming Selberg's eigenvalue conjecture), each `re νₖ` is a
    positive integer or half-integer, and `∑ μⱼ + 2 ∑ νₖ` is real; the LMFDB states that this makes
    the data of a functional equation unique, which is not proved here. 
    conductor : ℕ
    The conductor `N`. 
    μ : Multiset ℂ
    The spectral parameters `μⱼ` of the factors `Γ_ℝ(s + μⱼ)`. 
    ν : Multiset ℂ
    The spectral parameters `νₖ` of the factors `Γ_ℂ(s + νₖ)`. 
    sign : ℂ
    The sign `ε`. 
    conductor_pos : 0 < self.conductor
    re_eq_zero_or_one_of_mem_μ : ∀ x ∈ self.μ, x.re = 0 ∨ x.re = 1
    exists_two_mul_re_eq_of_mem_ν : ∀ x ∈ self.ν, ∃ k, 0 < k ∧ 2 * x.re = ↑k
    im_sum_add_two_mul_sum : (self.μ.sum + 2 * self.ν.sum).im = 0
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.selbergData (self : AnalyticLFunction) :
      AnalyticLFunction.SelbergData
    abbrev AnalyticLFunction.selbergData
      (self : AnalyticLFunction) :
      AnalyticLFunction.SelbergData
    The Selberg data of the functional equation. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.SelbergData.degree
      (D : AnalyticLFunction.SelbergData) : ℕ
    def AnalyticLFunction.SelbergData.degree
      (D : AnalyticLFunction.SelbergData) : ℕ
    The **degree** `J + 2 K` (LMFDB `lfunction.degree`) of a functional equation with `J` factors
    `Γ_ℝ` and `K` factors `Γ_ℂ`. 
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.μ (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    abbrev AnalyticLFunction.SelbergData.μ
      (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    The spectral parameters `μⱼ` of the factors `Γ_ℝ(s + μⱼ)`. 
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.ν (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    abbrev AnalyticLFunction.SelbergData.ν
      (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    The spectral parameters `νₖ` of the factors `Γ_ℂ(s + νₖ)`. 
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.sign
      (self : AnalyticLFunction.SelbergData) : ℂ
    abbrev AnalyticLFunction.SelbergData.sign
      (self : AnalyticLFunction.SelbergData) :
      ℂ
    The sign `ε`. 
Definition2.59
uses 0
Used by 2
Reverse dependency previews
Preview
Definition 2.75
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Self-dual L-function. (LMFDB)

An L-function L(s) = \sum_{n=1}^{\infty} \frac{a_n}{n^s} is called self-dual if its Dirichlet coefficients a_n are real.

Tau Ceti Review: LSeries, starRingEnd, Complex.conj_eq_iff_real.

Lean code for Definition2.59●3 declarations
  • defdefined in Mathlib/NumberTheory/LSeries/Basic.lean
    complete
    def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ
    def LSeries (f : ℕ → ℂ) (s : ℂ) : ℂ
    The value of the L-series of the sequence `f` at the point `s`
    if it converges absolutely there, and `0` otherwise. 
  • defdefined in Mathlib/Algebra/Star/Basic.lean
    complete
    def starRingEnd.{u} (R : Type u) [CommSemiring R] [StarRing R] : R →+* R
    def starRingEnd.{u} (R : Type u)
      [CommSemiring R] [StarRing R] : R →+* R
    `star` as a ring endomorphism, for commutative `R`. This is used to denote complex
    conjugation, and is available under the notation `conj` in the scope `ComplexConjugate`.
    
    Note that this is the preferred form (over `starRingAut`, available under the same hypotheses)
    because the notation `E →ₗ⋆[R] F` for an `R`-conjugate-linear map (short for
    `E →ₛₗ[starRingEnd R] F`) does not pretty-print if there is a coercion involved, as would be the
    case for `(↑starRingAut : R →* R)`. 
  • theoremdefined in Mathlib/Basic/Complex/Basic.lean
    complete
    theorem Complex.conj_eq_iff_real {z : ℂ} : (starRingEnd ℂ) z = z ↔ ∃ r, z = ↑r
    theorem Complex.conj_eq_iff_real {z : ℂ} :
      (starRingEnd ℂ) z = z ↔ ∃ r, z = ↑r
Definition2.60
uses 1
Used by 10
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Sign of the functional equation. (LMFDB)

The sign of the functional equation of an analytic L-function, also called the root number, is the complex number \varepsilon that appears in the functional equation of \Lambda(s)=\varepsilon \overline{\Lambda}(1-s). The sign appears as the 4th entry in the quadruple known as the Selberg data.

Depends on: Definition 2.25

Lean code for Definition2.60●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.sign (L : AnalyticLFunction) : ℂ
    def AnalyticLFunction.sign
      (L : AnalyticLFunction) : ℂ
    The **sign** `ε` (LMFDB `lfunction.sign`, `lfunction.root_number`) of the functional equation
    `Λ(s) = ε conj (Λ (1 - conj s))` of an analytic L-function, also called its root number. 
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.sign
      (self : AnalyticLFunction.SelbergData) : ℂ
    abbrev AnalyticLFunction.SelbergData.sign
      (self : AnalyticLFunction.SelbergData) :
      ℂ
    The sign `ε`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_eq_sign_mul_conj (self : AnalyticLFunction)
      {s : ℂ} :
      s ≠ 0 →
        s ≠ 1 →
          self.completed s =
            self.selbergData.sign *
              (starRingEnd ℂ) (self.completed (1 - (starRingEnd ℂ) s))
    theorem AnalyticLFunction.completed_eq_sign_mul_conj
      (self : AnalyticLFunction) {s : ℂ} :
      s ≠ 0 →
        s ≠ 1 →
          self.completed s =
            self.selbergData.sign *
              (starRingEnd ℂ)
                (self.completed
                  (1 - (starRingEnd ℂ) s))
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.norm_sign (L : AnalyticLFunction) : ‖L.sign‖ = 1
    theorem AnalyticLFunction.norm_sign
      (L : AnalyticLFunction) : ‖L.sign‖ = 1
    The sign of the functional equation of an analytic L-function has absolute value `1`. 
  • structure(8 fields)defined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    structure AnalyticLFunction.SelbergData : Type
    structure AnalyticLFunction.SelbergData : Type
    The **Selberg data** (LMFDB `lfunction.selbergdata`) of a functional equation
    `Λ(s) = N ^ (s / 2) ∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ) L(s) = ε conj (Λ (1 - conj s))`: the
    **conductor** `N` (LMFDB `lfunction.conductor`), the **spectral parameters** `μⱼ` of the factors
    `Γ_ℝ` and `νₖ` of the factors `Γ_ℂ` (LMFDB `lfunction.spectral_parameters`), and the **sign** `ε`
    (LMFDB `lfunction.sign`). The degree, the first entry of the LMFDB's quadruple, is
    `AnalyticLFunction.SelbergData.degree`. As in the LMFDB, the spectral parameters are normalised
    so that each `re μⱼ` is `0` or `1` (assuming Selberg's eigenvalue conjecture), each `re νₖ` is a
    positive integer or half-integer, and `∑ μⱼ + 2 ∑ νₖ` is real; the LMFDB states that this makes
    the data of a functional equation unique, which is not proved here. 
    conductor : ℕ
    The conductor `N`. 
    μ : Multiset ℂ
    The spectral parameters `μⱼ` of the factors `Γ_ℝ(s + μⱼ)`. 
    ν : Multiset ℂ
    The spectral parameters `νₖ` of the factors `Γ_ℂ(s + νₖ)`. 
    sign : ℂ
    The sign `ε`. 
    conductor_pos : 0 < self.conductor
    re_eq_zero_or_one_of_mem_μ : ∀ x ∈ self.μ, x.re = 0 ∨ x.re = 1
    exists_two_mul_re_eq_of_mem_ν : ∀ x ∈ self.ν, ∃ k, 0 < k ∧ 2 * x.re = ↑k
    im_sum_add_two_mul_sum : (self.μ.sum + 2 * self.ν.sum).im = 0
Definition2.61
Statement uses 2
Statement dependency previews
Preview
Definition 2.26
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Signature of an L-function. (LMFDB)

The signature either refers to the pair [J,K] where J is the number of \Gamma_{\mathbb{R}} and K is the number of \Gamma_{\mathbb{C}} in the Selberg data, or else it refers to the tuple

(\Re(\mu_1),\ldots,\Re(\mu_J); 2\Re(\nu_1),\ldots,2\Re(\nu_K)).

Note that the entries in that tuple are non-negative integers.

Tau Ceti Review: Multiset.card.

Depends on: Definition 2.26 Definition 2.58

Lean code for Definition2.61●6 declarations
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.μ (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    abbrev AnalyticLFunction.SelbergData.μ
      (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    The spectral parameters `μⱼ` of the factors `Γ_ℝ(s + μⱼ)`. 
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.ν (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    abbrev AnalyticLFunction.SelbergData.ν
      (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    The spectral parameters `νₖ` of the factors `Γ_ℂ(s + νₖ)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.SelbergData.re_eq_zero_or_one_of_mem_μ
      (self : AnalyticLFunction.SelbergData) (x : ℂ) :
      x ∈ self.μ → x.re = 0 ∨ x.re = 1
    theorem AnalyticLFunction.SelbergData.re_eq_zero_or_one_of_mem_μ
      (self : AnalyticLFunction.SelbergData)
      (x : ℂ) :
      x ∈ self.μ → x.re = 0 ∨ x.re = 1
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.SelbergData.exists_two_mul_re_eq_of_mem_ν
      (self : AnalyticLFunction.SelbergData) (x : ℂ) :
      x ∈ self.ν → ∃ k, 0 < k ∧ 2 * x.re = ↑k
    theorem AnalyticLFunction.SelbergData.exists_two_mul_re_eq_of_mem_ν
      (self : AnalyticLFunction.SelbergData)
      (x : ℂ) :
      x ∈ self.ν → ∃ k, 0 < k ∧ 2 * x.re = ↑k
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.SelbergData.degree
      (D : AnalyticLFunction.SelbergData) : ℕ
    def AnalyticLFunction.SelbergData.degree
      (D : AnalyticLFunction.SelbergData) : ℕ
    The **degree** `J + 2 K` (LMFDB `lfunction.degree`) of a functional equation with `J` factors
    `Γ_ℝ` and `K` factors `Γ_ℂ`. 
  • defdefined in Mathlib/Data/Multiset/Defs.lean
    complete
    def Multiset.card.{u_1} {α : Type u_1} : Multiset α → ℕ
    def Multiset.card.{u_1} {α : Type u_1} :
      Multiset α → ℕ
    The cardinality of a multiset is the sum of the multiplicities
    of all its elements, or simply the length of the underlying list. 
Definition2.62
Statement uses 2
Statement dependency previews
Preview
Definition 2.25
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1XL∃∀N

Spectral label. (LMFDB)

The spectral parameters are encoded as a string "x-y". Here x is the concatenation of expressions of the form ru and cv. The first indicates that \Gamma_{\R}(s + \mu) appears in the functional equation with \Re(\mu) = u, and the second that \Gamma_{\C}(s + \nu) appears with 2\Re(\nu) = v. The factor of 2 is included so that the u and vs are integral. In the multiset of u and vs, if the multiplicities are all a multiple of an integer n > 1 then we use en to shorten x. For example, r0r0c0c0 is encoded r0c0e2. The \Gamma_{\R} terms and \Gamma_{\C} terms are separately sorted, and we use the identity \Gamma_{\C}(s) = \Gamma_{\R}(s)\Gamma_{\R}(s + 1) as much as possible to combine pairs \Gamma_{\R}(s + \mu)\Gamma_{\R}(s + \mu + 1) into \Gamma_{\C}(s + \mu) in the interest of brevity.

Similarly, y is either 0 (indicating that all \mu_j and \nu_j are real), or the concatenation of expressions of the form pt, mt or ct indicating complex numbers with imaginary part either t or -t or both (respectively). These imaginary parts are listed in the same order as the real parts and are sorted by increasing absolute value within parameters with the same real part. We round imaginary parts to two digits after the decimal point. We write p0 when the imaginary part is zero to the known precision, and p0.00 and m0.00 for imaginary parts with an absolute value smaller than 0.5 \cdot 10^{-2}.

Depends on: Definition 2.25 Definition 2.63

Definition2.63
Statement uses 3
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 4
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

L-function spectral parameters. (LMFDB)

The spectral parameters are the numbers \mu_j and \nu_k that appear as shifts in the gamma factors (\Gamma_{\mathbb{R}} and \Gamma_{\mathbb{C}}, respectively) in the functional equation of an L-function.

Depends on: Definition 2.7 Definition 2.25 Definition 2.26

Lean code for Definition2.63●5 declarations
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.μ (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    abbrev AnalyticLFunction.SelbergData.μ
      (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    The spectral parameters `μⱼ` of the factors `Γ_ℝ(s + μⱼ)`. 
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.SelbergData.ν (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    abbrev AnalyticLFunction.SelbergData.ν
      (self : AnalyticLFunction.SelbergData) :
      Multiset ℂ
    The spectral parameters `νₖ` of the factors `Γ_ℂ(s + νₖ)`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    def AnalyticLFunction.SelbergData.gammaFactor
      (D : AnalyticLFunction.SelbergData) (s : ℂ) : ℂ
    def AnalyticLFunction.SelbergData.gammaFactor
      (D : AnalyticLFunction.SelbergData)
      (s : ℂ) : ℂ
    The **gamma factor** `∏ⱼ Γ_ℝ(s + μⱼ) ∏ₖ Γ_ℂ(s + νₖ)` (LMFDB `lfunction.infinity_factor`) of a
    functional equation, the product of its shifted Deligne gamma factors `Γ_ℝ` and `Γ_ℂ` (LMFDB
    `lfunction.gamma_factor`). 
  • abbrevdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    abbrev AnalyticLFunction.selbergData (self : AnalyticLFunction) :
      AnalyticLFunction.SelbergData
    abbrev AnalyticLFunction.selbergData
      (self : AnalyticLFunction) :
      AnalyticLFunction.SelbergData
    The Selberg data of the functional equation. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/Basic.lean
    complete
    theorem AnalyticLFunction.completed_eq (self : AnalyticLFunction) {s : ℂ} :
      1 < s.re →
        self.completed s =
          ↑self.selbergData.conductor ^ (s / 2) *
              self.selbergData.gammaFactor s *
            self.toFun s
    theorem AnalyticLFunction.completed_eq
      (self : AnalyticLFunction) {s : ℂ} :
      1 < s.re →
        self.completed s =
          ↑self.selbergData.conductor ^
                (s / 2) *
              self.selbergData.gammaFactor s *
            self.toFun s
Definition2.64
uses 0used by 0XL∃∀N

Symmetric power of an L-function. (LMFDB)

Let L(s) be an L-function given by an Euler product

L(s)= \prod_{p\not\in S} \prod_{j=1}^r \left (1- \frac{\alpha_j}{p^s}\right)^{-1} \times \prod_{p \in S} L_p(s),

where S is a finite set of primes. The symmetric n-th power of L(s) is an L-function given by an Euler product

L(s,\mathrm{sym}^n) = \prod_{p\not\in S}\prod_{ { \mathrm{degree}-n} \atop \mathrm{monomials}\,m} \left( 1- \frac{m(\alpha_1,\dotsc,\alpha_r)}{p^s} \right)^{-1} \times \prod_{p\in S} L_p(s,\mathrm{sym}^n).

The Euler factors at the primes p\in S (the "bad" primes) are computed via a more complicated recipe which involves a non-trivial amount of information about the underlying object. The degree of an Euler factor at one of the bad primes will be smaller than the degree of the Euler factors outside the set S.

Definition2.65
uses 0used by 0XL∃∀N

Taxonomy of L-functions. (LMFDB)

Taxonomy of L-functions =======================

One can consider L-functions as autonomous objects, not necessarily arising from another more basic object. From that point of view it is natural to develop a taxonomy of L-functions, where only the properties of the L-function are used for the classification.

The most obvious invariant of an L-function is its <em>degree</em>. After the degree, it is not immediately obvious which properties of the L-function should be considered next, but we propose the following as a reasonable scheme:

Note: some of the names could be better. And the order is not canonical.

  1. Degree.

The non-negative integer d=J+2K, where J and K refer respectively to the number of \Gamma_{\R} and \Gamma_{\C} factors in the functional equation. Recall that the L-function axioms determine J and K uniquely.

  1. Signature.

The pair (J,K).

1.5) \Gamma-data

The pair (\{\mu_1,...,\mu_J\}, \{\nu_1,...,\nu_K\}), where at this point we may wish to think of the \mu_j and \nu_k as depending on a parameter. For example, the two main classes of degree 2 L-functions have:

(\{i\lambda,-i\lambda\},\{\}) \ \ \ \ \ \ \ \ \ or \ \ \ \ \ \ \ \ \ (\{\},\{\frac{k-1}{2}\}),

where \lambda is a positive real number and k is an integer.

  1. Is the L-function algebraic?

We call an L-function <em>algebraic</em> if its Dirichlet coefficients are algebraic numbers. This, conjecturally, is equivalent to each of:

a) \mu_j and \nu_k are real

b) The L-function is the L-function of a Galois representation.

c) The L-function is motivic

d) There exists a number field K/\Q, called the <em>field of coefficients</em>, and a integer w, called the <em>motivic weight</em> of the L-function, such that a_n n^{w/2} is in integer of K for all n. (Note that w is chosen to be the minimal integer with this property.) (Note also that, conjecturally, w=\min\{0,\max\{\nu_k\}\}. In the arithmetic normalization, the functional equation relates s to w+1-s.) (Note that for holomorphic GL(2) cusp forms, motivic weight is one less than the "classical" weight. For Siegel modular forms, the "classical" weight has yet another relationship to the motivic weight.)

2') The motivic weight

2") The field of coefficients

  1. Level.

The non-negative integer N appearing in the functional equation.

Note: Once the level and the specific numbers in the \Gamma-factors have been specified, then (conjecturally) there are only finitely many L-functions possible.

  1. Central character.

The Euler product has the form

L(s) = \prod_p F_p(p^{-s})

where

F_p(x) = 1+a_p x + \cdots + (-1)^d \chi(p) x^d.

The character \chi, which is a Dirichlet character mod~N, is called the <em>central character</em> of the L-function.

If p is a good prime, then the roots of F_p are called the <em>Satake paramaters at p</em> for the L-funciton.

Note: if L(s)=L(s,f) for some object f, then f may have its own Satake parameters, which in general are different from the Satake parameters of the L-function. (This has to be the case, because f probably has infinitely many L-functions associated to it, and each L-function has different Satake parameters.)

  1. Sign.

The parameter \varepsilon appearing in the functional equation. Also known as the "root number."

The above classification exhausts the parameters in the functional equation and the Euler product, but there are further refinements based on the distribution of Dirichlet coefficients.

  1. Self-dual?

Are the Dirichlet coefficients real?

  1. Sato-Tate group

The Sato-Tate group of an L-function is a compact subgroup of a classical matrix group whose eigenvalues under Haar measure have the same distribution as the distribution of Satake parameters of the L-function. Further discussion below.

The Dirichlet coefficients a_p,...,a_{p^{[d/2]}} have a limiting distribution. The first few moments of those coefficients uniquely determine the distributions. For example, for L-functions of degree d=2 and weight w\ge 1 with rational coefficients there are three possibilities:

\langle |a_p|^2 \rangle = 1, \ \ \ \ \ \langle |a_p|^4 \rangle = 2;

and

\langle |a_p|^2 \rangle = 1, \ \ \ \ \ \langle |a_p|^4 \rangle = 3;

and

\langle |a_p|^2 \rangle = 2, \ \ \ \ \ \langle |a_p|^4 \rangle = 6.

The first possibility corresponds to what was classically known as "Sato-Tate", while the second two are commonly called "CM". For d=2 and w=0 there are several more options.

Serre uses "Sato-Tate group" for the general case. See his excellent book "Lectures on N_X(p)" .

As the degree grows there are more possibilities: 55 for L-functions of degree d=4 and weight w=1 with rational coefficients, of which 52 arise for abelian surfaces (in fact, for Jacobians of hyperelliptic curves); this follows from the classification of Fite-Kedlaya-Rotger-Sutherland .

Note: The first few coefficient moments determine the distribution because there is a compact matrix group whose eigenvalues have the same distribution as the Satake parameters. That group is the <em>Sato-Tate group</em> of the L-function. All of this is conjectural for d>2.

Note: The Sato-Tate group determines which operations on the L-function (sym^n, for example) have poles.

Definition2.66
Statement uses 6
Statement dependency previews
Preview
Definition 2.10
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1XL∃∀N

Trivial zeros of an L-function. (LMFDB)

The zeros of an L-function L(s) that occur at poles of its gamma factors are trivial zeros.

The presence of trivial zeros is required by the functional equation. In its analytic normalization, the L-function L(s) has no zeros or poles in the right half-plane \Re(s)>1, but the gamma factors that appear in the functional equation have poles. Since the completed L-function has no poles (except possibly from Riemann zeta-function factors), the L-function must have zeros at poles of the gamma factors.

For arithmetic L-functions, the poles are at certain negative integers.

Depends on: Definition 2.10 Definition 2.16 Definition 2.25 Definition 2.26 Definition 2.47 Definition 2.68

Definition2.67
Statement uses 7
Statement dependency previews
Preview
Definition 2.20
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Underlying object of an L-function. (LMFDB)

L-functions arise from many different sources. Already in degree 2 we have examples of L-functions associated with holomorphic cusp forms, with Maass forms, with elliptic curves, with characters of number fields (Hecke characters), and with 2-dimensional representations of the Galois group of a number field (Artin L-functions).

Sometimes an L-function may arise from more than one source. For example, the L-functions associated with elliptic curves are also associated with weight 2 cusp forms. A goal of the Langlands program ostensibly is to prove that any degree d L-function is associated with an automorphic form on \mathrm{GL}(d). Because of this representation theoretic genesis, one can associate an L-function not only to an automorphic representation but also to symmetric powers, or exterior powers of that representation, or to the tensor product of two representations (the Rankin-Selberg product of two L-functions).

Depends on: Definition 6.1.37 Definition 3.1.1 Definition 4.1.64 Definition 2.20 Definition 3.2.4 Definition 5.1.1 Definition 5.1.23

Definition2.68
Statement uses 4
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 9
Reverse dependency previews
Preview
Definition 2.5
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Zeros of an L-function. (LMFDB)

The zeros of an L-function L(s) are the complex numbers \rho for which L(\rho)=0.

Under the Riemann Hypothesis, every non-trivial zero \rho lies on the critical line \Re(s)=1/2 (in the analytic normalization).

The lowest zero of an L-function L(s) is the least \gamma>0 for which L(1/2+i\gamma)=0. Note that even when L(1/2)=0, the lowest zero is by definition a positive real number.

Depends on: Definition 2.7 Definition 2.18 Definition 2.47 Definition 2.50

Lean code for Definition2.68●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RiemannHypothesis.lean
    complete
    def AnalyticLFunction.zeros (L : AnalyticLFunction) : Set ℂ
    def AnalyticLFunction.zeros
      (L : AnalyticLFunction) : Set ℂ
    The **zeros** (LMFDB `lfunction.zeros`) of an analytic L-function: the points where its
    continuation, a meromorphic function on `ℂ`, has positive order. Away from the only possible pole
    `s = 1` they are the points where the continuation vanishes (`mem_zeros_iff`); using the order
    makes the junk value at a pole irrelevant. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RiemannHypothesis.lean
    complete
    theorem AnalyticLFunction.mem_zeros_iff (L : AnalyticLFunction) {ρ : ℂ}
      (hρ : ρ ≠ 1) : ρ ∈ L.zeros ↔ L.toFun ρ = 0
    theorem AnalyticLFunction.mem_zeros_iff
      (L : AnalyticLFunction) {ρ : ℂ}
      (hρ : ρ ≠ 1) :
      ρ ∈ L.zeros ↔ L.toFun ρ = 0
    Away from `s = 1`, the zeros of an analytic L-function are the points where its continuation
    vanishes. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/NontrivialZeroCriticalLine.lean
    complete
    theorem AnalyticLFunction.RiemannHypothesis.zeros_diff_trivialZeros_subset_criticalLine
      {L : AnalyticLFunction} (h : L.RiemannHypothesis) :
      L.zeros \ L.trivialZeros ⊆ AnalyticLFunction.criticalLine
    theorem AnalyticLFunction.RiemannHypothesis.zeros_diff_trivialZeros_subset_criticalLine
      {L : AnalyticLFunction}
      (h : L.RiemannHypothesis) :
      L.zeros \ L.trivialZeros ⊆
        AnalyticLFunction.criticalLine
    **Under the Riemann hypothesis, every nontrivial zero lies on the critical line** (LMFDB
    `lfunction.zeros`): if the zeros `ρ` with `re ρ > 0` of an analytic L-function satisfy
    `re ρ = 1 / 2`, then so does every zero that is not a trivial zero, that is, not at a pole of the
    gamma factor (LMFDB `lfunction.trivial_zero`). A nontrivial zero with `re ρ ≤ 0` would be reflected
    by the functional equation to a zero of real part at least `1`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/NontrivialZeroCriticalLine.lean
    complete
    theorem AnalyticLFunction.riemannHypothesis_iff_zeros_diff_trivialZeros_subset_criticalLine
      (L : AnalyticLFunction) :
      L.RiemannHypothesis ↔
        L.zeros \ L.trivialZeros ⊆ AnalyticLFunction.criticalLine
    theorem AnalyticLFunction.riemannHypothesis_iff_zeros_diff_trivialZeros_subset_criticalLine
      (L : AnalyticLFunction) :
      L.RiemannHypothesis ↔
        L.zeros \ L.trivialZeros ⊆
          AnalyticLFunction.criticalLine
    **The Riemann hypothesis says that the nontrivial zeros lie on the critical line** (LMFDB
    `lfunction.zeros`): an analytic L-function satisfies the Riemann hypothesis (LMFDB `lfunction.rh`),
    which constrains its zeros with positive real part, if and only if every zero that is not at a pole
    of its gamma factor lies on the critical line `re s = 1 / 2`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/LowestZero.lean
    complete
    def AnalyticLFunction.lowestZero (L : AnalyticLFunction) : ℝ
    def AnalyticLFunction.lowestZero
      (L : AnalyticLFunction) : ℝ
    The **lowest zero** (LMFDB `lfunction.zeros`) of an analytic L-function: the least `γ > 0` such
    that `L(1 / 2 + i γ) = 0`. It is a positive real number even when `L(1 / 2) = 0`; the infimum is
    attained when there is such a `γ` (`centralPoint_add_lowestZero_mul_I_mem_zeros`), since the zeros
    are isolated. When there is none, it takes the junk value `0`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/LowestZero.lean
    complete
    theorem AnalyticLFunction.lowestZero_pos (L : AnalyticLFunction)
      (h :
        ∃ γ,
          0 < γ ∧
            AnalyticLFunction.centralPoint + ↑γ * Complex.I ∈ L.zeros) :
      0 < L.lowestZero
    theorem AnalyticLFunction.lowestZero_pos
      (L : AnalyticLFunction)
      (h :
        ∃ γ,
          0 < γ ∧
            AnalyticLFunction.centralPoint +
                ↑γ * Complex.I ∈
              L.zeros) :
      0 < L.lowestZero
    When an analytic L-function has a zero `1 / 2 + i γ` with `γ > 0`, its lowest zero is positive.
    
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/LowestZero.lean
    complete
    theorem AnalyticLFunction.centralPoint_add_lowestZero_mul_I_mem_zeros
      (L : AnalyticLFunction)
      (h :
        ∃ γ,
          0 < γ ∧
            AnalyticLFunction.centralPoint + ↑γ * Complex.I ∈ L.zeros) :
      AnalyticLFunction.centralPoint + ↑L.lowestZero * Complex.I ∈ L.zeros
    theorem AnalyticLFunction.centralPoint_add_lowestZero_mul_I_mem_zeros
      (L : AnalyticLFunction)
      (h :
        ∃ γ,
          0 < γ ∧
            AnalyticLFunction.centralPoint +
                ↑γ * Complex.I ∈
              L.zeros) :
      AnalyticLFunction.centralPoint +
          ↑L.lowestZero * Complex.I ∈
        L.zeros
    When an analytic L-function has a zero `1 / 2 + i γ` with `γ > 0`, its lowest zero `γ₀` gives a
    zero `1 / 2 + i γ₀`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/LowestZero.lean
    complete
    theorem AnalyticLFunction.lowestZero_le (L : AnalyticLFunction) {γ : ℝ}
      (hγ : 0 < γ)
      (h : AnalyticLFunction.centralPoint + ↑γ * Complex.I ∈ L.zeros) :
      L.lowestZero ≤ γ
    theorem AnalyticLFunction.lowestZero_le
      (L : AnalyticLFunction) {γ : ℝ}
      (hγ : 0 < γ)
      (h :
        AnalyticLFunction.centralPoint +
            ↑γ * Complex.I ∈
          L.zeros) :
      L.lowestZero ≤ γ
    The lowest zero is at most every `γ > 0` with `L(1 / 2 + i γ) = 0`. 
Definition2.69
Statement uses 2
Statement dependency previews
Preview
Definition 2.18
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 1✓L∃∀N

Z-function of an L-function. (LMFDB)

The (Hardy or Riemann-Siegel) Z-function for the Riemann zeta-function is a real-valued function defined in terms of the values of \zeta(s) on the critical line via the formula

Z(t) := e^{i \theta(t)} \zeta\left( \frac{1}{2} + it \right),

where \theta(t) is the Riemann-Siegel theta function

\theta(t) := \arg \left(\Gamma\left(\frac{2it+1}{4}\right)\right) -\frac{\log\pi}{2}t.

There is a bijection between zeros t_0 of Z(t) and zeros \frac{1}{2}+it_0 of \zeta(s).

The Z-function of a general L-function is a smooth real-valued function of a real variable t such that

|Z(t)|=|L(1/2+it)|.

Specifically, if we write the completed L-function as \Lambda(s)=\gamma(s)L(s), where \Lambda(s) satisfies the functional equation

\Lambda(s)=\varepsilon \overline{\Lambda}(1-s),

then Z(t) is defined by

Z(t)=\overline{\varepsilon}^{1/2} \frac{\gamma(1/2+it)}{|\gamma(1/2+it)|} L(1/2+it).

The square root is chosen so that Z(t)>0 for sufficiently small t>0.

The multiset of zeros of Z(t) matches that of L(1/2+it) and Z(t) changes sign at the zeros of L(1/2+it) of odd multiplicity.

Depends on: Definition 2.18 Definition 2.25

Lean code for Definition2.69●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/ZFunction.lean
    complete
    def AnalyticLFunction.zFunction (L : AnalyticLFunction) (t : ℝ) : ℝ
    def AnalyticLFunction.zFunction
      (L : AnalyticLFunction) (t : ℝ) : ℝ
    The **Z-function** (LMFDB `lfunction.zfunction`) of an analytic L-function: the real-valued
    function `Z(t) = conj ε ^ (1 / 2) γ(1 / 2 + i t) / |γ(1 / 2 + i t)| L(1 / 2 + i t)`, where
    `Λ(s) = γ(s) L(s)` with `γ(s) = N ^ (s / 2) L_∞(s)` and `ε` is the sign of the functional equation
    (`ofReal_zFunction`). It is real because of the functional equation, `|Z(t)| = |L(1 / 2 + i t)|`
    (`abs_zFunction`), and the square root of `conj ε` is chosen so that `Z(t) > 0` for small `t > 0`
    (`eventually_zFunction_pos`). For the Riemann zeta function, `ζ(1 / 2) < 0` makes this the
    negative of Mathlib's `hardyZ`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RiemannSiegelTheta.lean
    complete
    def riemannSiegelTheta (t : ℝ) : ℝ
    def riemannSiegelTheta (t : ℝ) : ℝ
    The **Riemann–Siegel theta function** (LMFDB `lfunction.zfunction`)
    `θ(t) = arg Γ((2 i t + 1) / 4) - (log π / 2) t`, with the continuous branch of
    `arg Γ(1 / 4 + i t / 2)` that vanishes at `t = 0` (where `Γ(1 / 4) > 0`). As Mathlib has no
    continuous logarithm of `Γ`, the branch is written as the integral of its derivative
    `re ψ(1 / 4 + i u / 2) / 2`, where `ψ = Γ' / Γ` is the digamma function;
    `exp_riemannSiegelTheta_mul_I` shows that `exp (i θ(t))` is
    `Γ_ℝ(1 / 2 + i t) / |Γ_ℝ(1 / 2 + i t)|`, so that `θ(t)` is an argument of
    `π ^ (-i t / 2) Γ(1 / 4 + i t / 2)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/RiemannSiegelTheta.lean
    complete
    theorem ofReal_hardyZ_eq_exp_mul_riemannZeta (t : ℝ) :
      ↑(hardyZ t) =
        Complex.exp (↑(riemannSiegelTheta t) * Complex.I) *
          riemannZeta (1 / 2 + ↑t * Complex.I)
    theorem ofReal_hardyZ_eq_exp_mul_riemannZeta
      (t : ℝ) :
      ↑(hardyZ t) =
        Complex.exp
            (↑(riemannSiegelTheta t) *
              Complex.I) *
          riemannZeta (1 / 2 + ↑t * Complex.I)
    Hardy's Z-function is `Z(t) = exp (i θ(t)) ζ(1 / 2 + i t)`, where `θ` is the Riemann–Siegel
    theta function. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/ZFunction.lean
    complete
    theorem AnalyticLFunction.ofReal_zFunction (L : AnalyticLFunction) (t : ℝ) :
      ↑(L.zFunction t) =
        ↑L.zFunctionSign * (starRingEnd ℂ) L.sign ^ 2⁻¹ *
            (L.completingFactor
                (AnalyticLFunction.centralPoint + ↑t * Complex.I) /
              ↑‖L.completingFactor
                    (AnalyticLFunction.centralPoint + ↑t * Complex.I)‖) *
          L.toFun (AnalyticLFunction.centralPoint + ↑t * Complex.I)
    theorem AnalyticLFunction.ofReal_zFunction
      (L : AnalyticLFunction) (t : ℝ) :
      ↑(L.zFunction t) =
        ↑L.zFunctionSign *
              (starRingEnd ℂ) L.sign ^ 2⁻¹ *
            (L.completingFactor
                (AnalyticLFunction.centralPoint +
                  ↑t * Complex.I) /
              ↑‖L.completingFactor
                    (AnalyticLFunction.centralPoint +
                      ↑t * Complex.I)‖) *
          L.toFun
            (AnalyticLFunction.centralPoint +
              ↑t * Complex.I)
    The Z-function is `Z(t) = conj ε ^ (1 / 2) γ(1 / 2 + i t) / |γ(1 / 2 + i t)| L(1 / 2 + i t)`,
    where `γ(s) = N ^ (s / 2) L_∞(s)` and the square root of `conj ε` is `±` the principal one. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/ZFunction.lean
    complete
    theorem AnalyticLFunction.eventually_zFunction_pos (L : AnalyticLFunction) :
      ∀ᶠ (t : ℝ) in nhdsWithin 0 (Set.Ioi 0), 0 < L.zFunction t
    theorem AnalyticLFunction.eventually_zFunction_pos
      (L : AnalyticLFunction) :
      ∀ᶠ (t : ℝ) in nhdsWithin 0 (Set.Ioi 0),
        0 < L.zFunction t
    The Z-function is positive for small `t > 0`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/ZFunctionZeros.lean
    complete
    theorem AnalyticLFunction.contDiff_zFunction (L : AnalyticLFunction) :
      ContDiff ℝ (↑⊤) L.zFunction
    theorem AnalyticLFunction.contDiff_zFunction
      (L : AnalyticLFunction) :
      ContDiff ℝ (↑⊤) L.zFunction
    **The Z-function is smooth** (LMFDB `lfunction.zfunction`), as it is real analytic. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/ZFunctionZeros.lean
    complete
    theorem AnalyticLFunction.analyticOrderAt_zFunction (L : AnalyticLFunction)
      (t₀ : ℝ) :
      analyticOrderAt L.zFunction t₀ =
        analyticOrderAt L.toFun
          (AnalyticLFunction.centralPoint + ↑t₀ * Complex.I)
    theorem AnalyticLFunction.analyticOrderAt_zFunction
      (L : AnalyticLFunction) (t₀ : ℝ) :
      analyticOrderAt L.zFunction t₀ =
        analyticOrderAt L.toFun
          (AnalyticLFunction.centralPoint +
            ↑t₀ * Complex.I)
    **The zeros of the Z-function have the multiplicities of the zeros of `L(1 / 2 + i t)`**
    (LMFDB `lfunction.zfunction`): the order of vanishing of `Z` at `t` is the order of vanishing of
    `L` at `1 / 2 + i t`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/LFunction/ZFunctionZeros.lean
    complete
    theorem AnalyticLFunction.eventually_zFunction_mul_zFunction_neg
      (L : AnalyticLFunction) (t₀ : ℝ)
      (h :
        Odd
          (analyticOrderNatAt L.toFun
            (AnalyticLFunction.centralPoint + ↑t₀ * Complex.I))) :
      ∀ᶠ (t : ℝ) in nhdsWithin t₀ (Set.Iio t₀),
        ∀ᶠ (u : ℝ) in nhdsWithin t₀ (Set.Ioi t₀),
          L.zFunction t * L.zFunction u < 0
    theorem AnalyticLFunction.eventually_zFunction_mul_zFunction_neg
      (L : AnalyticLFunction) (t₀ : ℝ)
      (h :
        Odd
          (analyticOrderNatAt L.toFun
            (AnalyticLFunction.centralPoint +
              ↑t₀ * Complex.I))) :
      ∀ᶠ (t : ℝ) in
        nhdsWithin t₀ (Set.Iio t₀),
        ∀ᶠ (u : ℝ) in
          nhdsWithin t₀ (Set.Ioi t₀),
          L.zFunction t * L.zFunction u < 0
    **The Z-function changes sign at the zeros of odd multiplicity** (LMFDB `lfunction.zfunction`):
    if `L` vanishes at `1 / 2 + i t₀` to odd order, then `Z(t)` and `Z(u)` have opposite signs for
    `t < t₀ < u` close enough to `t₀`. 
Definition2.70
Statement uses 26
Statement dependency previews
Preview
Definition 2.7
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Completeness of L-function Data. (LMFDB)

The database currently contains more than 20 million L-functions. Most of these are stored in the database along with related information such as zeros and analytic rank that have been precomputed using explicit precision bounds (see the "reliability" link on each L-function's home page for further details). A small number of dynamically computed L-functions are also available, as noted in the summary below. The pages for dynamically computed L-functions may be missing information that cannot be computed quickly, and the data displayed on them may be less accurate than the displayed precision suggests.

Below is a summary of available L-functions by degree. Note that the counts are not mutually exclusive, as different types of mathematical objects may have the same L-function. For precomputed L-functions, objects in the database that are believed to give rise to this L-function are listed in the "origins" box on the L-functions home page.

Degree 1

Degree 2

Degree 3

  • 1552 L-functions of \GL(3) Maass forms.

  • 51 dynamically computed Dedekind zeta functions of the cubic fields with absolute discriminant |D|\le 368.

  • 7925 dynamically computed Artin L-functions arising from 3-dimensional Artin representations of conductor N\le 90\,000 are available.

Degree 4

  • 41\,653 imprimitive rational L-functions corresponding to (Galois orbits of) newforms of dimension 2.

  • 253\,190 L-functions of elliptic curve isogeny classes over quadratic fields (all but 9 isogeny classes of elliptic curves over quadratic fields in the database).

  • 66\,684 L-functions of Hilbert modular forms of dimension 1 over real quadratic fields (each is also the L-function of an isogeny class of elliptic curves over a quadratic field).

  • 2913 dynamically computed L-functions of Hilbert modular forms of dimension d>1 over real quadratic fields.

  • 185\,541 L-functions of Bianchi newforms of dimension 1 over imaginary quadratic fields (all but the 40 that do not correspond to elliptic curves).

  • 65\,534 L-functions of isogeny classes of genus 2 curves over \Q (some of which also arise as L-functions of classical/Hilbert/Bianchi newforms, elliptic curves over quadratic fields, or products of L-functions of elliptic curves over \Q).

  • 35 dynamically computed Artin L-functions arising from 4-dimensional Artin representations of conductor N\le 5196 are available.

Degrees 5 to 40

  • 115\,645 imprimitive rational L-functions corresponding to newforms of dimensions 3 to 20 and weight k\le 200 (there are at least 2000 in each even degree from 6 to 40).

Depends on: Definition 6.2.1 Definition 6.1.1 Definition 6.1.30 Definition 3.1.1 Definition 3.1.9 Definition 3.1.22 Definition 3.1.34 Definition 3.1.64 Definition 3.1.101 Definition 4.1.4 Definition 4.1.37 Definition 4.1.72 Definition 4.2.31 Definition 2.7 Definition 2.9 Definition 2.17 Definition 2.20 Definition 2.46 Definition 2.49 Definition 2.51 Definition 2.68 Definition 3.4.13 Definition 3.3.1 Definition 3.3.2 Definition 3.2.4 Definition 5.1.3

Definition2.71
uses 0used by 0XL∃∀N

Completeness of Riemann Zeta Zeros Data. (LMFDB)

This database contains the 103{,}800{,}788{,}359 zeros of the Riemann zeta function \zeta(s) with imaginary part in the interval (0,30\,610\,046\,000], all of which have real part \frac{1}{2}.

Definition2.72
Statement uses 11
Statement dependency previews
Preview
Definition 2.9
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Reliability of Curve L-function Data. (LMFDB)

L-functions of genus 2 curves over \Q in the database have been precomputed using heuristic precision bounds that should (but are not guaranteed to) ensure that all zeros and special values are accurate to the displayed precision (up to an error in the last digit), and that the list of zeros is complete (within the region covered by the list, which includes the lowest zero).

All L-function computations for genus 2 curves are conditional on the assumption that the L-function lies in the Selberg class, and in particular, has an analytic continuation that satisfies the functional equation. For genus 2 curves with bad reduction at 2, this includes the 2-part of the conductor and the Euler factor at 2, which was computed using the functional equation as described in Section 5 of .

In cases where a genus 2 L-function is imprimitive, the computation is also conditional on knowing its factorization into primitive L-functions.

The displayed analytic rank r is an upper bound on the true analytic rank that is believed to be tight; it is known that there are r (but not r+1) zeros within a region of s=1/2 (in the analytic normalization) of radius equal to the error implied by the displayed precision of the zeros (assuming the heuristic precision bounds are sufficient to achieve this error bound).

For L-functions of genus 2 curves over \Q the parity of the analytic rank is determined by the sign \varepsilon=\pm 1 of the functional equation. The parity of the displayed analytic rank is always consistent with the sign, thus any displayed analytic rank r\le 1 is correct provided that the heuristic precision bounds are sufficient to identify all zeros near s=1/2.

Depends on: Definition 4.2.14 Definition 4.2.25 Definition 2.9 Definition 2.17 Definition 2.24 Definition 2.25 Definition 2.47 Definition 2.48 Definition 2.56 Definition 2.60 Definition 2.68

Definition2.73
Statement uses 4
Statement dependency previews
Preview
Definition 2.9
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Reliability of Dirichlet L-function Data. (LMFDB)

All Dirichlet L-functions in the database have been precomputed using rigorous precision bounds and interval arithmetic ensure that zeros and special values are accurate to the displayed precision (up to an error in the last digit displayed), and that the list of zeros is complete (within the region covered by the list, including the lowest zero).

For Dirichlet L-functions in the database, all listed zeros are known to lie on the critcial line, and the analytic rank is known to be zero.

Depends on: Definition 6.1.1 Definition 2.9 Definition 2.18 Definition 2.68

Definition2.74
Statement uses 4
Statement dependency previews
Preview
Definition 2.9
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Reliability of Elliptic Curve L-function Data. (LMFDB)

L-functions of elliptic curves over \Q in the database have been precomputed using heuristic precision bounds that should (but are not guaranteed to) ensure that all zeros and special values are accurate to the displayed precision (up to an error in the last digit), and that the list of zeros is complete (within the region covered by the list, including the lowest zero).

For L-functions of elliptic curves over \Q the displayed analytic rank is known to be correct in all but one case, the L-function of the elliptic curve \texttt{234446.a1}, which is the unique curve of Mordell-Weil rank 4 in the database. For this L-function the analytic rank is known to be either 2 or 4.

Depends on: Definition 4.1.4 Definition 4.1.105 Definition 2.9 Definition 2.68

Definition2.75
Statement uses 9
Statement dependency previews
Preview
Definition 2.9
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Reliability of Modular L-function Data. (LMFDB)

L-functions of classical, Hilbert, and Bianchi modular forms in the database have been precomputed using rigorous precision bounds and interval arithmetic ensure that zeros and special values are accurate to the displayed precision (up to an error in the last digit displayed), and that the list of zeros is complete (within the region covered by the list, including the lowest zero). Each zero is known to lie within a disc whose radius is determined by the displayed precision, but note that this is not sufficient to prove that the lie on the critical line.

The displayed analytic rank r is an upper bound on the true analytic rank that is believed to be tight; it is known that there are r (but not r+1) zeros within a region of s=1/2 (in the analytic normalization) of radius equal to the error implied by the displayed precision of the zeros). In particular, any displayed analytic rank r=0 must be correct.

For self-dual L-functions the parity of the analytic rank is determined by the sign \varepsilon=\pm 1 of the functional equation that all modular L-functions are known to satisfy. The parity of the displayed analytic rank is always consistent with the sign, thus for self-dual modular L-functions any displayed analytic rank r\le 1 must be correct.

For classical modular form L-functions the displayed analytic rank has been rigorously verified in all cases (even when it is greater than one or the L-function is not self-dual).

For Bianchi modular form L-functions, all results are conditional on the assumption that the elliptic curve whose isogeny class has the same label as the Bianchi modular form actually has the same L-function; this is known if the elliptic curve is modular, but the modularity of the elliptic curves over imaginary quadratic fields is not known in general and has been explicitly verified for only a subset of the elliptic curves in the database.

Depends on: Definition 3.1.64 Definition 2.9 Definition 2.18 Definition 2.47 Definition 2.59 Definition 2.60 Definition 2.68 Definition 3.4.13 Definition 3.3.1

Definition2.76
uses 0
Used by 2
Reverse dependency previews
Preview
Definition 2.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Euler gamma function. (LMFDB)

The (Euler) gamma function \Gamma(z) is defined by the integral

\Gamma(z) = \int_0^{ \infty } e^{-t} t^{z} \frac{dt}{t}

for Re(z) > 0. It satisfies the functional equation

\Gamma(z+1) = z \Gamma(z),

and can thus be continued into a meromorphic function on the complex plane, whose poles are at the non-positive integers \{0,-1,-2,\ldots\}.

Tau Ceti Review: Complex.Gamma, Complex.Gamma_eq_integral, Complex.Gamma_add_one, Complex.differentiableAt_Gamma.

Lean code for Definition2.76●5 declarations
  • defdefined in Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
    complete
    def Complex.Gamma (s : ℂ) : ℂ
    def Complex.Gamma (s : ℂ) : ℂ
    The `Γ` function (of a complex variable `s`). 
  • theoremdefined in Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
    complete
    theorem Complex.Gamma_eq_integral {s : ℂ} (hs : 0 < s.re) :
      Complex.Gamma s = s.GammaIntegral
    theorem Complex.Gamma_eq_integral {s : ℂ}
      (hs : 0 < s.re) :
      Complex.Gamma s = s.GammaIntegral
  • theoremdefined in Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
    complete
    theorem Complex.Gamma_add_one (s : ℂ) (h2 : s ≠ 0) :
      Complex.Gamma (s + 1) = s * Complex.Gamma s
    theorem Complex.Gamma_add_one (s : ℂ)
      (h2 : s ≠ 0) :
      Complex.Gamma (s + 1) =
        s * Complex.Gamma s
    The recurrence relation for the `Γ` function. 
  • theoremdefined in Mathlib/Analysis/SpecialFunctions/Gamma/Deriv.lean
    complete
    theorem Complex.differentiableAt_Gamma (s : ℂ) (hs : ∀ (m : ℕ), s ≠ -↑m) :
      DifferentiableAt ℂ Complex.Gamma s
    theorem Complex.differentiableAt_Gamma (s : ℂ)
      (hs : ∀ (m : ℕ), s ≠ -↑m) :
      DifferentiableAt ℂ Complex.Gamma s
  • theoremdefined in Mathlib/Analysis/SpecialFunctions/Gamma/Deriv.lean
    complete
    theorem Complex.not_continuousAt_Gamma_neg_nat (n : ℕ) :
      ¬ContinuousAt Complex.Gamma (-↑n)
    theorem Complex.not_continuousAt_Gamma_neg_nat
      (n : ℕ) :
      ¬ContinuousAt Complex.Gamma (-↑n)