LeanBridge Blueprint

3.6. Miscellaneous🔗

This section lists the LMFDB definitions in the category mf, apart from those in mf.maass, mf.hilbert, mf.bianchi and mf.siegel. Each definition links back to its LMFDB knowl. hecke_algebra.definition also belongs here, although its id puts it in another LMFDB category.

Definition3.6.1
Statement uses 2
Statement dependency previews
Preview
Definition 3.1.46
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Hecke algebra. (LMFDB)

For a commutative ring R and an R-module M equipped with an action of Hecke operators, such as spaces of modular forms or modular symbols, the associated R-Hecke algebra is the R-subalgebra of the R-endomorphism ring of M generated by the Hecke operators.

We usually include all Hecke operators, i.e. also those the index of which divides the level or is a multiple of the characteristic (if applicable).

If the ring R is not mentioned, then it is either \Q or \C, depending on the context.

Depends on: Definition 3.1.46 Definition 3.6.2

Lean code for Definition3.6.1●6 definitions
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/HeckeAlgebra.lean
    complete
    def Module.End.heckeAlgebra.{u_1, u_2, u_3} (R : Type u_1) {M : Type u_2}
      {ι : Type u_3} [CommRing R] [AddCommGroup M] [Module R M]
      (T : ι → Module.End R M) : Subalgebra R (Module.End R M)
    def Module.End.heckeAlgebra.{u_1, u_2, u_3}
      (R : Type u_1) {M : Type u_2}
      {ι : Type u_3} [CommRing R]
      [AddCommGroup M] [Module R M]
      (T : ι → Module.End R M) :
      Subalgebra R (Module.End R M)
    The **`R`-Hecke algebra** (LMFDB `hecke_algebra.definition`) of an `R`-module `M` equipped
    with an action of Hecke operators `T i`: the `R`-subalgebra of the endomorphism ring `End_R(M)`
    generated by the Hecke operators. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/HeckeAlgebra.lean
    complete
    def HeckeRing.GL2.cuspFormHeckeAlgebra {N : ℕ} [NeZero N] (k : ℤ) :
      Subalgebra ℂ
        (Module.End ℂ
          (CuspForm
            (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ)
              (CongruenceSubgroup.Gamma1 N))
            k))
    def HeckeRing.GL2.cuspFormHeckeAlgebra {N : ℕ}
      [NeZero N] (k : ℤ) :
      Subalgebra ℂ
        (Module.End ℂ
          (CuspForm
            (Subgroup.map
              (Matrix.SpecialLinearGroup.mapGL
                ℝ)
              (CongruenceSubgroup.Gamma1 N))
            k))
    The **Hecke algebra of `S_k(Γ₁(N))`** (LMFDB `hecke_algebra.definition`), over `ℂ`: the
    `ℂ`-subalgebra of `End(S_k(Γ₁(N)))` generated by the Hecke operators `T_n` for every `n ≥ 1`,
    including the `U_p` at the primes `p ∣ N`, and the diamond operators `⟨d⟩` (with them, the
    single double cosets `T_n` of Tau Ceti generate the classical algebra, see
    `modularFormHeckeAlgebra`). It contains Tau Ceti's integral algebra `TauCeti.heckeTCuspAlgebra`,
    generated by the `T_n` alone (`heckeTCuspAlgebra_le_restrictScalars_cuspFormHeckeAlgebra`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/HeckeAlgebra.lean
    complete
    def HeckeRing.GL2.modularFormHeckeAlgebra {N : ℕ} [NeZero N] (k : ℤ) :
      Subalgebra ℂ
        (Module.End ℂ
          (ModularForm
            (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ)
              (CongruenceSubgroup.Gamma1 N))
            k))
    def HeckeRing.GL2.modularFormHeckeAlgebra
      {N : ℕ} [NeZero N] (k : ℤ) :
      Subalgebra ℂ
        (Module.End ℂ
          (ModularForm
            (Subgroup.map
              (Matrix.SpecialLinearGroup.mapGL
                ℝ)
              (CongruenceSubgroup.Gamma1 N))
            k))
    The **Hecke algebra of `M_k(Γ₁(N))`** (LMFDB `hecke_algebra.definition`), over `ℂ`: the
    `ℂ`-subalgebra of `End(M_k(Γ₁(N)))` generated by the Hecke operators `T_n` for every `n ≥ 1`,
    including the `U_p` at the primes `p ∣ N`, and the diamond operators `⟨d⟩`. Tau Ceti's `T_n` is
    the operator of the single double coset `Γ₁(N) diag(1, n) Γ₁(N)`, which differs from the
    classical `T_n` by terms involving diamond operators when `n` is divisible by the square of a
    prime not dividing `N`; with the diamond operators among the generators the algebra is the
    classical `ℂ[T_n, ⟨d⟩]`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/HeckeAlgebra.lean
    complete
    def HeckeRing.GL2.cuspFormCharSpaceHeckeAlgebra {N : ℕ} [NeZero N] (k : ℤ)
      (χ : (ZMod N)ˣ →* ℂˣ) :
      Subalgebra ℂ (Module.End ℂ ↥(cuspFormCharSpace k χ))
    def HeckeRing.GL2.cuspFormCharSpaceHeckeAlgebra
      {N : ℕ} [NeZero N] (k : ℤ)
      (χ : (ZMod N)ˣ →* ℂˣ) :
      Subalgebra ℂ
        (Module.End ℂ
          ↥(cuspFormCharSpace k χ))
    The **Hecke algebra of `S_k(N, χ)`** (LMFDB `hecke_algebra.definition`), over `ℂ`: the
    `ℂ`-subalgebra of `End(S_k(N, χ))` generated by the classical Hecke operators `T_n` for every
    `n ≥ 1` (`heckeTCompositeGamma0`), including those whose index is not prime to `N`. The diamond
    operators act on `S_k(N, χ)` by the scalars `χ(d)`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/HeckeAlgebra.lean
    complete
    def HeckeRing.GL2.modFormCharSpaceHeckeAlgebra {N : ℕ} [NeZero N] (k : ℤ)
      (χ : (ZMod N)ˣ →* ℂˣ) :
      Subalgebra ℂ (Module.End ℂ ↥(modFormCharSpace k χ))
    def HeckeRing.GL2.modFormCharSpaceHeckeAlgebra
      {N : ℕ} [NeZero N] (k : ℤ)
      (χ : (ZMod N)ˣ →* ℂˣ) :
      Subalgebra ℂ
        (Module.End ℂ ↥(modFormCharSpace k χ))
    The **Hecke algebra of `M_k(N, χ)`** (LMFDB `hecke_algebra.definition`), over `ℂ`: the
    `ℂ`-subalgebra of `End(M_k(N, χ))` generated by the classical Hecke operators `T_n` for every
    `n ≥ 1` (`heckeTCompositeGamma0`), including those whose index is not prime to `N`. The diamond
    operators act on `M_k(N, χ)` by the scalars `χ(d)`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/HeckeAlgebra.lean
    complete
    def TauCeti.ModularSymbols.heckeAlgebra.{u_1} (R : Type u_1) [CommRing R]
      (N w : ℕ) [NeZero N] :
      Subalgebra R
        (Module.End R
          (TauCeti.ModularSymbols R (CongruenceSubgroup.Gamma1 N) w))
    def TauCeti.ModularSymbols.heckeAlgebra.{u_1}
      (R : Type u_1) [CommRing R] (N w : ℕ)
      [NeZero N] :
      Subalgebra R
        (Module.End R
          (TauCeti.ModularSymbols R
            (CongruenceSubgroup.Gamma1 N) w))
    The **`R`-Hecke algebra of the modular symbols** `𝕄_w(Γ₁(N); R)` of weight `w + 2` (LMFDB
    `hecke_algebra.definition`): the `R`-subalgebra of `End_R(𝕄_w(Γ₁(N); R))` generated by the Hecke
    operators `T_n` for every `n ≥ 1`, including those whose index divides the level or is a multiple
    of the characteristic of `R`. Over `ℤ` it is Tau Ceti's `TauCeti.ModularSymbols.heckeTAlgebra`
    (`heckeAlgebra_int`). 
Definition3.6.2
Statement uses 7
Statement dependency previews
Preview
Definition 3.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 14
Reverse dependency previews
Preview
Definition 3.6.1
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
XL∃∀N

Modular form (general). (LMFDB)

The term modular form is used to describe several types of complex functions which have a certain type of functional equation and growth condition. Examples include:

Modular forms of the same weight and multiplier system that are defined over the same group form a \mathbb{C}-vector space.

Depends on: Definition 3.1.1 Definition 3.1.101 Definition 3.4.2 Definition 3.3.1 Definition 3.2.1 Definition 3.6.21 Definition 3.5.1

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

Base change of a GL(2) modular form. (LMFDB)

Let K \supseteq F be a finite extension of number fields, not necessarily Galois. Let f be a modular form on \GL(2) over F of level \mathfrak{N}.

For a (nonzero) prime \mathfrak{p} \nmid \mathfrak{N} of F, let L_{\mathfrak{p}}(f,T) be the (good, degree 2) Euler factor at \mathfrak{p}. For r \in \Z_{\geq 1} and a polynomial h(T) \in \C[T], let h^{(r)}(T) be the polynomial whose roots are the r-th powers of the roots of h(T) (with \deg h^{(r)}(T)=\deg h(T)).

We say that a modular form g for \GL(2) over K is a base change of f to K if

L_{\mathfrak{q}}(g,T) = L_{\mathfrak{p}}^{(r)}(f,T)

for all but finitely many primes \mathfrak{q} of K, where \mathfrak{q} lies over \mathfrak{p} \nmid \mathfrak{N} and r is the degree of \mathfrak{q} over \mathfrak{p}.

In general, we say that a form g for \GL(2) over K is a base change if there exists a proper subfield K_0 \subsetneq K and a modular form g_0 on \GL(2) over K_0 such that g is the base change of g_0 to K.

In particular, if g is a base change from \Q to K, then a_{\mathfrak{q}}(g) = a_{\sigma(\mathfrak{q})}(g) for all \sigma \in \mathrm{Aut}(K).

Depends on: Definition 3.6.2 Definition 5.1.1

Definition3.6.4
Statement uses 3
Statement dependency previews
Preview
Definition 3.6.2
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Complex multiplication. (LMFDB)

A modular form f for \GL(2) over a number field F has complex multiplication (CM) if it is equal to its twist by a nontrivial Hecke character \chi over F, or equivalently

a_{\frak{p}} = \chi(\frak{p}) a_{\frak{p}}

for all good primes \frak{p} \nmid \frak{N}. Such a character \chi is necessarily quadratic, and a_{\frak{p}} = 0 for all good primes \frak{p} such that \chi(\frak{p}) = -1.

Depends on: Definition 6.1.37 Definition 3.6.2 Definition 5.1.1

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

Self twist of a modular form. (LMFDB)

A newform f=\sum a_n q^n admits a self twist by a nontrivial primitive Dirichlet character \chi if we have a_p=\chi(p)a_p for all but finitely many primes p.

This can occur only when \chi has order 2 and a_p=0 for all primes p not dividing the level of f for which \chi(p)=-1. The character \chi is then the Kronecker character of a quadratic field K and may be identified by the discriminant D of K.

If D is negative, the modular form f is said to have complex multiplication (CM) by K, and if D is positive, f is said to have real multiplication (RM) by K. The latter can occur only when f is a modular form of weight 1 whose projective image is dihedral.

It is possible for a modular form to have more than one self twist; this occurs precisely when f is a modular form of weight one whose projective image is isomorphic to D_2:=C_2\times C_2; in this case f admits three self twists, two of which are CM and one of which is RM.

Depends on: Definition 6.1.1 Definition 6.1.28 Definition 6.1.30 Definition 3.1.57 Definition 3.1.64 Definition 3.1.76 Definition 3.1.80 Definition 3.1.101 Definition 5.1.17

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

Combinatorics and q-series. (LMFDB)

Infinite products are intimately linked to <em>combinatorics</em>, in particular via the partition function p(n), whose generating function is 1/\prod_{n\ge1}(1-q^n)=q^{1/24}/\eta(z). Thus, identities involving \eta or more general products can usually be translated into combinatorial identities. An extremely simple example is the following: we have trivially

\prod_{n\ge1}(1-q^n)=\prod_{n\ge1}(1-q^{2n})\prod_{n\ge1}(1-q^{2n-1})\;,

hence 1/\prod_{n\ge1}(1-q^{2n-1})=\prod_{n\ge1}(1+q^n)\;. This can be restated in combinatorial terms as saying that the number of partitions of a positive integer into odd parts is equal to its number of partitions into unequal parts (i.e. without "repetitions"), which is not a totally trivial statement.

Set (q)_n=\prod_{1\le m\le n}(1-q^m), so that for instance \eta(z)=q^{1/24}(q)_{\infty}. Many combinatorial identities involve different series of the type \sum_{n\ge0}f_n(q)/(q)_n, and most of them have a modular interpretation. For instance, consider the following identity due to Euler:

\prod_{n\ge1}(1-aq^n)=\sum_{n\ge0}(-1)^na^nq^{n(n+1)/2}/(q)_n\;.

Setting a=1, a=-1, a=-q^{-1}, a=q^{-1/2}, and a=-q^{-1/2} gives the following identities involving modular forms:

\eta(z)=q^{1/24}\sum_{n\ge0}(-1)^n\dfrac{q^{n(n+1)/2}}{(q)_n}, \quad\quad \dfrac{\eta(2z)}{\eta(z)}=q^{1/24}\sum_{n\ge0}\dfrac{q^{n(n+1)/2}}{(q)_n},

\dfrac{2\eta(2z)}{\eta(z)}=q^{1/24}\sum_{n\ge0}\dfrac{q^{n(n-1)/2}}{(q)_n},\quad\quad \dfrac{\eta(z/2)}{\eta(z)}=q^{-1/48}\sum_{n\ge0}(-1)^n\dfrac{q^{n^2/2}}{(q)_n},

\dfrac{\eta^2(z)}{\eta(z/2)\eta(2z)}=q^{-1/48}\sum_{n\ge0}\dfrac{q^{n^2/2}}{(q)_n}.

The famous <em>Rogers&#8210;Ramanujan identities</em> are further identities of the same type.

A general framework, also valid in several dimensions, has been given by W. Nahm in connection with rational conformal field theories (RCFT) in theoretical physics: Let A be a d\times d positive definite symmetric matrix, B a row vector of dimension d, and C a constant. Consider f(z)=\sum_{N\in\Z_{\ge0}^d}\dfrac{q^{(1/2)N^tAN+BN+C}}{\prod_{1\le i\le d}(q)_{n_i}}\;, where N=(n_1,\dots,n_d)^t is considered as a column vector and the n_i range though all nonnegative integers. The question is to determine all triples (A,B,C) such that f is modular on some subgroup of \Gamma. For d=1, the above examples give (A,B,C)=(1,1/2,1/24), (1,-1/2,1/24), and (1,0,-1/48), and the Rogers&#8210;Ramanujan identities give the additional examples (A,B,C)=(2,1,11/60) and (2,0,-1/60). It has been shown by Don Zagier that together with two other identities corresponding to (A,B,C)=(1/2,1,1/40) and (1/2,0,-1/40), these are the only examples in dimension 1. On the other hand, for d=2 many examples are known, but the complete list has not been found.

Depends on: Definition 8.3.141 Definition 3.6.2 Definition 3.6.17 Definition 3.6.26

Definition3.6.7
Statement uses 4
Statement dependency previews
Preview
Definition 3.1.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Elliptic functions. (LMFDB)

The first example is through the theory of elliptic functions, and the closely related elementary theory of elliptic curves over \C: in this context, the functions that arise naturally are the Eisenstein series E_k (or their alternately normalized counterparts F_k and G_k), the quasi-modular Eisenstein series E_2, the discriminant function \Delta and the elliptic modular invariant j.

Tau Ceti Review: ModularForm.E, ModularForm.discriminant, TauCeti.ModularForm.j, TauCeti.ModularForm.j_smul.

Depends on: Definition 3.1.1 Definition 3.1.28 Definition 4.1.4 Definition 3.6.22

Lean code for Definition3.6.7●8 declarations
  • defdefined in Mathlib/NumberTheory/ModularForms/EisensteinSeries/Basic.lean
    complete
    def ModularForm.E {k : ℕ} (hk : 3 ≤ k) :
      ModularForm (Matrix.SpecialLinearGroup.mapGL ℝ).range ↑k
    def ModularForm.E {k : ℕ} (hk : 3 ≤ k) :
      ModularForm
        (Matrix.SpecialLinearGroup.mapGL
            ℝ).range
        ↑k
    Normalised Eisenstein series of level 1 and weight `k`,
    here they have been scaled by `1/2` since we sum over coprime pairs. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Eisenstein/Normalisations.lean
    complete
    def ModularForm.eisensteinF (k : ℕ) (τ : UpperHalfPlane) : ℂ
    def ModularForm.eisensteinF (k : ℕ)
      (τ : UpperHalfPlane) : ℂ
    The Eisenstein series `F_k(τ) = -B_k/(2k) + ∑_{n ≥ 1} σ_{k-1}(n) qⁿ`, `q = e^{2πiτ}` (LMFDB
    `mf.gl2.history.elliptic`): the normalisation of the Eisenstein series of weight `k` with first
    Fourier coefficient `1`, written `F_k` by Cohen and Strömberg. For even `k ≥ 4` it is
    `-(B_k/(2k)) E_k` (`ModularForm.eisensteinF_eq`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Eisenstein/Normalisations.lean
    complete
    theorem ModularForm.eisensteinF_eq {k : ℕ} (τ : UpperHalfPlane) (hk : 3 ≤ k)
      (hk2 : Even k) :
      ModularForm.eisensteinF k τ =
        -(↑(bernoulli k) / (2 * ↑k)) * (ModularForm.E hk) τ
    theorem ModularForm.eisensteinF_eq {k : ℕ}
      (τ : UpperHalfPlane) (hk : 3 ≤ k)
      (hk2 : Even k) :
      ModularForm.eisensteinF k τ =
        -(↑(bernoulli k) / (2 * ↑k)) *
          (ModularForm.E hk) τ
    **`F_k` is an alternately normalised `E_k`** (LMFDB `mf.gl2.history.elliptic`): for even
    `k ≥ 4`, `F_k = -(B_k/(2k)) E_k`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Eisenstein/Normalisations.lean
    complete
    theorem ModularForm.tsum_eisSummand_eq_two_mul_riemannZeta_mul_E {k : ℕ}
      (τ : UpperHalfPlane) (hk : 3 ≤ k) :
      ∑' (v : Fin 2 → ℤ), EisensteinSeries.eisSummand (↑k) v τ =
        2 * riemannZeta ↑k * (ModularForm.E hk) τ
    theorem ModularForm.tsum_eisSummand_eq_two_mul_riemannZeta_mul_E
      {k : ℕ} (τ : UpperHalfPlane)
      (hk : 3 ≤ k) :
      ∑' (v : Fin 2 → ℤ),
          EisensteinSeries.eisSummand (↑k) v
            τ =
        2 * riemannZeta ↑k *
          (ModularForm.E hk) τ
    **`G_k` is an alternately normalised `E_k`** (LMFDB `mf.gl2.history.elliptic`): the Eisenstein
    series `G_k(τ) = ∑_{(m, n) ≠ (0, 0)} (mτ + n)^{-k}` of the lattice `ℤτ + ℤ` is `2 ζ(k) E_k(τ)` for
    `k ≥ 3`, the term of `(m, n) = (0, 0)` in the sum over `ℤ²` being `0`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/QuasiModular.lean
    complete
    theorem ModularForm.isQuasiModularForm_E2 :
      ModularForm.IsQuasiModularForm
        (Matrix.SpecialLinearGroup.mapGL ℝ).range 2 1 1 EisensteinSeries.E2
    theorem ModularForm.isQuasiModularForm_E2 :
      ModularForm.IsQuasiModularForm
        (Matrix.SpecialLinearGroup.mapGL
            ℝ).range
        2 1 1 EisensteinSeries.E2
    **`E₂` is quasi-modular** of weight `2` and depth at most `1` on `SL(2, ℤ)`, with trivial
    multiplier and `P(z, X) = E₂(z) - (6i/π) X` (written `E₂(z) - (2πi / 2ζ(2)) X`). 
  • defdefined in Mathlib/NumberTheory/ModularForms/Discriminant.lean
    complete
    def ModularForm.discriminant (z : UpperHalfPlane) : ℂ
    def ModularForm.discriminant
      (z : UpperHalfPlane) : ℂ
    The modular discriminant `Δ(z) = η(z) ^ 24`, where `η` is the Dedekind eta function. 
  • defdefined in TauCeti/Analysis/Complex/ModularForms/LevelOne/JInputs.lean
    complete
    def TauCeti.ModularForm.j (z : UpperHalfPlane) : ℂ
    def TauCeti.ModularForm.j
      (z : UpperHalfPlane) : ℂ
    The normalized modular invariant `j = E₄³ / Δ` on the upper half-plane. 
  • theoremdefined in TauCeti/Analysis/Complex/ModularForms/LevelOne/JInputs.lean
    complete
    theorem TauCeti.ModularForm.j_smul (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ)
      (z : UpperHalfPlane) :
      TauCeti.ModularForm.j
          ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) γ • z) =
        TauCeti.ModularForm.j z
    theorem TauCeti.ModularForm.j_smul
      (γ :
        Matrix.SpecialLinearGroup (Fin 2) ℤ)
      (z : UpperHalfPlane) :
      TauCeti.ModularForm.j
          ((Matrix.SpecialLinearGroup.map
                (Int.castRingHom ℝ))
              γ •
            z) =
        TauCeti.ModularForm.j z
    The weight factors cancel, so `j` is invariant under `SL₂(ℤ)`. 
Definition3.6.8
Statement uses 7
Statement dependency previews
Preview
Definition 3.1.10
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Hecke Characters. (LMFDB)

An important variant of theta functions are modular forms coming from certain Hecke characters of a quadratic number field K. In this case the definition is given in terms of a sum over integral ideals but this can be reformulated as a linear combination of theta functions of the form \Theta_{L;Q;h}(z) defined above. In this case the lattice L is an ideal in K, the quadratic form Q is the norm form, that is, Q(x)=\mathcal{N}_{K/\Q}(x), and the function h is given by the Hecke character. There are several reasons for the importance of these functions: one is that even though they are cusp forms, their Fourier coefficients can be easily computed, contrary to functions like \Delta. A second is that they are all CM forms, and conversely all CM forms are obtained from Hecke characters. In addition, a CM form is easily seen to be <em>lacunary</em> (i.e., the proportion of nonzero Fourier coefficients tends to zero), and, conversely, Serre has shown that for integral weight k\ge1, a nonzero form f is lacunary if and only either k=1, or k\ge2 and f is a linear combination of CM forms.

Depends on: Definition 6.1.37 Definition 3.1.10 Definition 3.1.14 Definition 3.1.38 Definition 3.1.101 Definition 3.6.2 Definition 5.1.1

Definition3.6.9
Statement uses 3
Statement dependency previews
Preview
Definition 3.6.2
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Infinite products. (LMFDB)

Many theta functions have <em>infinite product</em> representations, and this is another important source of modular forms: for instance, the Dedekind eta function \eta(z)=q^{1/24}\prod_{n\ge1}(1-q^n), and \Delta(z)=\eta^{24}(z)=q\prod_{n\ge1}(1-q^n)^{24} are fundamental examples (where q=e^{2\pi iz}). The modularity of \eta (equivalently of \Delta) is not at all clear from the definition as an infinite product; it can be proved by showing that \eta is in fact a theta series using the <em>Jacobi triple product</em> relation, for example.

Since \eta is the basic construction block of infinite products, this implies that many types of infinite products are modular (of course, not products of the type \prod(1-q^{n^2}) or \prod(1-q^n)^n). As shown by Richard Borcherds, certain products of the type \prod_{n\ge1}(1-q^n)^{c(n^2)} for suitable c(n) (that can in fact be given as Fourier coefficients of other modular forms) are modular.

However, the function q^c\prod_{n\ge0}(1-q^{5n+1}) for instance is not modular for any value of c, although it closely resembles \eta.

Depends on: Definition 3.6.2 Definition 3.6.17 Definition 3.6.26

Definition3.6.10
Statement uses 10
Statement dependency previews
Preview
Definition 3.1.46
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

New modular forms from given ones. (LMFDB)

In addition to the different situations we have seen above, which involve modular functions and forms, there are also many ways to create new modular forms from given ones. <h4>Vector space or graded ring structure</h4> The most trivial way to construct a modular form from given ones is to use the vector space structure: if f and g have the same weight and multiplier system on some group G, then of course so does \lambda f+\mu g, for any constants \lambda and \mu. Another way is to use the fact that the set of all modular forms with trivial multiplier for a given group has the structure of a graded ring. Even more is true: if f and g are modular for the same group G, then so is the product fg, whose weight will be the sum of the weights and multiplier system, the product of the multiplier systems.

<h4>Differentiation</h4> If we differentiate the modular identity f(\gamma z)=v(\gamma)(cz+d)^kf(z) and use (\gamma z)'=(cz+d)^{-2}, we obtain

f'(\gamma z)=v(\gamma)((cz+d)^{k+2}f'(z)+k(cz+d)^{k+1}f(z))\;.

Thus f' is almost a modular form (it is in fact a quasi-modular form) of weight k+2, and it is exactly modular if k=0. There are many ways to "repair" this defect of modularity: two of them involve modifying the differentiation operator by using the auxiliary functions 1/y=1/\Im(z) or the quasi-Eisenstein series E_2. Another is to take suitable combinations which remove the extra terms that prevent modularity: for instance, if f is of weight k and g of weight \ell, then f^\ell/g^k is of weight 0, so its derivative is really modular of weight 2, and expanding shows that \ell f'g-kfg' is modular of weight k+\ell+2. This is a special case of a series of bilinear operators called the Rankin&#8210;Cohen operators.

<h4>Changing the group</h4> If we accept to modify the group on which a function is modular, there are many other ways to create new modular forms. For instance, if f is modular on some group, then f(mz) will also be modular of the same weight on some other group for any m\in\Q^{\times}. A similar construction implies that if f(z)=\sum_{n\ge n_0}a_nq^{n/N} is modular, then so is \sum_{n\equiv r\pmod{M}}a_nq^{n/N} and \sum_{n\ge n_0}\psi(n)a_nq^{n/N} for any periodic function \psi. This last construction is called *twisting* by \psi.

<h4>Enlarging the group</h4> Even more interesting is the possibility to *enlarge* the group on which a function is modular: if f is modular on some subgroup H of finite index of some other group G, say with trivial multiplier system, and if (\gamma_i) is a system of left coset representatives of H\backslash G, so that G=\bigsqcup_iH\gamma_i, then it is clear that \sum_i f|_k\gamma_i will be modular on G. This is a special case of the averaging procedure mentioned at the very beginning. An important example combining the above two methods is the construction of Hecke operators: let p be a prime. If, for instance, f is modular of weight k on the full modular group \Gamma, the functions f((z+j)/p) and f(pz) will be modular only on the subgroup \Gamma_0(p) of \Gamma, but it is immediate to show that the linear combination g=\sum_{0\le j\le p-1}f((z+j)/p)+p^kf(pz) is again modular on the full modular group \Gamma, and we can define the Hecke operator T(p) by T(p)(f)=g/p.

Depends on: Definition 3.1.46 Definition 3.1.101 Definition 8.3.141 Definition 8.3.144 Definition 8.3.166 Definition 3.6.2 Definition 3.6.21 Definition 3.6.22 Definition 3.6.25 Definition 3.6.26

Lean code for Definition3.6.10●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ModularForm.lean
    complete
    def ModularForm.multiplierSpace {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.HasDetOne]
      (k : ℤ) (v : ↥Γ →* Circle) : Submodule ℂ (UpperHalfPlane → ℂ)
    def ModularForm.multiplierSpace
      {Γ : Subgroup (GL (Fin 2) ℝ)}
      [Γ.HasDetOne] (k : ℤ)
      (v : ↥Γ →* Circle) :
      Submodule ℂ (UpperHalfPlane → ℂ)
    The space of **modular forms** (LMFDB `mf`) of weight `k ∈ ℤ` and multiplier system `v` on a
    subgroup `Γ` of `SL(2, ℝ)`: the holomorphic functions `f : ℍ → ℂ` with `f ∣[k] γ = v(γ) f` for every
    `γ ∈ Γ` (the functional equation, LMFDB `mf.transformation_property`) that are bounded at every cusp
    of `Γ` (the growth condition, LMFDB `mf.growth_condition`), as a complex vector space. The LMFDB's
    `mf` is an umbrella term also covering Maass, Hilbert, Bianchi and Siegel modular forms; this is its
    elliptic, holomorphic, integral-weight instance, which Mathlib's `ModularForm Γ k` is for `v = 1`
    (`mem_multiplierSpace_one_iff`). The multiplier only gives nonzero forms if it is a multiplier
    system of weight `k` (`MonoidHom.isMultiplierSystem_of_slash_eq_smul`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/DerivativeLaw.lean
    complete
    theorem ModularForm.derivOfComplex_smul {Γ : Subgroup (GL (Fin 2) ℝ)}
      [Γ.HasDetOne] {v : ↥Γ →* Circle} {k : ℤ} {f : UpperHalfPlane → ℂ}
      (γ : ↥Γ) (z : UpperHalfPlane)
      (hf : f ∈ ModularForm.multiplierSpace k v) :
      ModularForm.derivOfComplex f (↑γ • z) =
        ↑(v γ) *
          (UpperHalfPlane.denom ↑γ ↑z ^ (k + 2) *
              ModularForm.derivOfComplex f z +
            ↑k * ↑(↑↑γ 1 0) * UpperHalfPlane.denom ↑γ ↑z ^ (k + 1) * f z)
    theorem ModularForm.derivOfComplex_smul
      {Γ : Subgroup (GL (Fin 2) ℝ)}
      [Γ.HasDetOne] {v : ↥Γ →* Circle} {k : ℤ}
      {f : UpperHalfPlane → ℂ} (γ : ↥Γ)
      (z : UpperHalfPlane)
      (hf :
        f ∈ ModularForm.multiplierSpace k v) :
      ModularForm.derivOfComplex f (↑γ • z) =
        ↑(v γ) *
          (UpperHalfPlane.denom ↑γ ↑z ^
                (k + 2) *
              ModularForm.derivOfComplex f z +
            ↑k * ↑(↑↑γ 1 0) *
                UpperHalfPlane.denom ↑γ ↑z ^
                  (k + 1) *
              f z)
    **The transformation law of the derivative** (LMFDB `mf.gl2.history.new`): if `f` is a modular
    form of weight `k` and multiplier system `v` on `Γ`, then
    `f'(γz) = v(γ) ((cz + d)^(k + 2) f'(z) + k c (cz + d)^(k + 1) f(z))` for `γ = (a, b; c, d) ∈ Γ`.
    The LMFDB's formula lacks the factor `c` of the second term. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/DerivativeLaw.lean
    complete
    theorem ModularForm.isQuasiModularForm_derivOfComplex
      {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.HasDetOne] {v : ↥Γ →* Circle} {k : ℤ}
      {f : UpperHalfPlane → ℂ} (hf : f ∈ ModularForm.multiplierSpace k v) :
      ModularForm.IsQuasiModularForm Γ (k + 2) 1 v
        (ModularForm.derivOfComplex f)
    theorem ModularForm.isQuasiModularForm_derivOfComplex
      {Γ : Subgroup (GL (Fin 2) ℝ)}
      [Γ.HasDetOne] {v : ↥Γ →* Circle} {k : ℤ}
      {f : UpperHalfPlane → ℂ}
      (hf :
        f ∈ ModularForm.multiplierSpace k v) :
      ModularForm.IsQuasiModularForm Γ (k + 2)
        1 v (ModularForm.derivOfComplex f)
    **The derivative of a modular form is quasi-modular** (LMFDB `mf.gl2.history.new`): if `f` is a
    modular form of weight `k` and multiplier system `v` on `Γ`, then `f'` is a quasi-modular form of
    weight `k + 2`, depth at most `1` and multiplier system `v`, with `P(z, X) = f'(z) + k f(z) X`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/DerivativeLaw.lean
    complete
    def ModularForm.rankinCohenBracket (k l : ℤ) (f g : UpperHalfPlane → ℂ)
      (n : ℕ) : UpperHalfPlane → ℂ
    def ModularForm.rankinCohenBracket (k l : ℤ)
      (f g : UpperHalfPlane → ℂ) (n : ℕ) :
      UpperHalfPlane → ℂ
    The **`n`-th Rankin–Cohen bracket**
    `[f, g]ₙ = ∑_{r + s = n} (-1)^r C(k + n - 1, s) C(ℓ + n - 1, r) f^(r) g^(s)` of functions `f` and
    `g` on the upper half-plane, taken in weights `k` and `ℓ`, where `f^(r)` is the `r`-th derivative:
    the series of bilinear operators of which `ℓ f' g - k f g'` is, up to sign, the case `n = 1` (LMFDB
    `mf.gl2.history.new`). That `[f, g]ₙ` is a modular form of weight `k + ℓ + 2n` for modular forms
    `f` and `g` (Cohen) is `ModularForm.rankinCohenBracket_mem_multiplierSpace`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/RankinCohen.lean
    complete
    theorem ModularForm.rankinCohenBracket_mem_multiplierSpace
      {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.HasDetOne] {v w : ↥Γ →* Circle}
      {k l : ℤ} {f g : UpperHalfPlane → ℂ} (n : ℕ)
      (hf : f ∈ ModularForm.multiplierSpace k v)
      (hg : g ∈ ModularForm.multiplierSpace l w) :
      ModularForm.rankinCohenBracket k l f g n ∈
        ModularForm.multiplierSpace (k + l + 2 * ↑n) (v * w)
    theorem ModularForm.rankinCohenBracket_mem_multiplierSpace
      {Γ : Subgroup (GL (Fin 2) ℝ)}
      [Γ.HasDetOne] {v w : ↥Γ →* Circle}
      {k l : ℤ} {f g : UpperHalfPlane → ℂ}
      (n : ℕ)
      (hf :
        f ∈ ModularForm.multiplierSpace k v)
      (hg :
        g ∈ ModularForm.multiplierSpace l w) :
      ModularForm.rankinCohenBracket k l f g
          n ∈
        ModularForm.multiplierSpace
          (k + l + 2 * ↑n) (v * w)
    **Cohen's theorem**: if `f` and `g` are modular forms on `Γ` of weights `k` and `ℓ` and
    multiplier systems `v` and `w`, then their `n`-th Rankin–Cohen bracket `[f, g]ₙ` is a modular form
    of weight `k + ℓ + 2n` and multiplier system `v w`. For `n = 1` this is the modularity of
    `ℓ f' g - k f g'` (LMFDB `mf.gl2.history.new`), by `rankinCohenBracket_one`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ChangeOfGroup.lean
    complete
    theorem ModularForm.qExpansion_twistOfWidth_coeff {Γ : Subgroup (GL (Fin 2) ℝ)}
      {k : ℤ} {M N : ℕ} (Φ : ZMod M → ℂ) (F : ModularForm Γ k) [Γ.HasDetOne]
      [NeZero M] [NeZero N] (hΓ : ↑N ∈ Γ.strictPeriods) (n : ℕ) :
      (PowerSeries.coeff n)
          (UpperHalfPlane.qExpansion ↑N ⇑(ModularForm.twistOfWidth N Φ F)) =
        Φ ↑n * (PowerSeries.coeff n) (UpperHalfPlane.qExpansion ↑N ⇑F)
    theorem ModularForm.qExpansion_twistOfWidth_coeff
      {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ}
      {M N : ℕ} (Φ : ZMod M → ℂ)
      (F : ModularForm Γ k) [Γ.HasDetOne]
      [NeZero M] [NeZero N]
      (hΓ : ↑N ∈ Γ.strictPeriods) (n : ℕ) :
      (PowerSeries.coeff n)
          (UpperHalfPlane.qExpansion ↑N
            ⇑(ModularForm.twistOfWidth N Φ
                F)) =
        Φ ↑n *
          (PowerSeries.coeff n)
            (UpperHalfPlane.qExpansion ↑N ⇑F)
    **The expansion of a twist** (LMFDB `mf.gl2.history.new`): if `f = ∑ aₙ q^(n/N)` is a modular
    form on `Γ`, where `N` is a strict period of `Γ`, then for every function `ψ` modulo `M` the
    function `∑ ψ(n) aₙ q^(n/N)` is the modular form `twistOfWidth N ψ f`: its `n`-th coefficient in
    `q^(1/N)` is `ψ(n) aₙ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ChangeOfGroup.lean
    complete
    theorem ModularForm.sum_slash_eq_trace.{u_1} {k : ℤ}
      {𝒢 ℋ : Subgroup (GL (Fin 2) ℝ)} [𝒢.IsFiniteRelIndex ℋ]
      (G : ModularForm 𝒢 k) {ι : Type u_1} [Fintype ι] {δ : ι → ↥ℋ}
      (hδ : Function.Bijective fun i => Quotient.mk'' (δ i)) :
      ∑ i, SlashAction.map k ↑(δ i) ⇑G = ⇑(ModularForm.trace ℋ G)
    theorem ModularForm.sum_slash_eq_trace.{u_1}
      {k : ℤ} {𝒢 ℋ : Subgroup (GL (Fin 2) ℝ)}
      [𝒢.IsFiniteRelIndex ℋ]
      (G : ModularForm 𝒢 k) {ι : Type u_1}
      [Fintype ι] {δ : ι → ↥ℋ}
      (hδ :
        Function.Bijective fun i =>
          Quotient.mk'' (δ i)) :
      ∑ i, SlashAction.map k ↑(δ i) ⇑G =
        ⇑(ModularForm.trace ℋ G)
    **The sum over coset representatives is the trace** (LMFDB `mf.gl2.history.new`): if `f` is a
    modular form on `H`, with trivial multiplier system, and `G` is the disjoint union of finitely many
    right cosets `(H ∩ G) γᵢ`, then `∑ᵢ f ∣[k] γᵢ` is the trace of `f`, a modular form on `G`. The
    LMFDB's `H` is a subgroup of finite index of `G`, in which case `H ∩ G = H`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ChangeOfGroup.lean
    complete
    theorem HeckeRing.GL2.heckeTNat_apply_of_level_one {p : ℕ} [NeZero p] {k : ℤ}
      (f :
        ModularForm
          (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ)
            (CongruenceSubgroup.Gamma1 1))
          k)
      (hp : Nat.Prime p) (z : UpperHalfPlane) :
      ((HeckeRing.GL2.heckeTNat k p) f) z =
        (∑ j,
              f
                ((Matrix.GeneralLinearGroup.map (algebraMap ℚ ℝ))
                    (HeckeRing.GL2.upperTriRep p j) •
                  z) +
            ↑p ^ k * f (TauCeti.scaleGL p • z)) /
          ↑p
    theorem HeckeRing.GL2.heckeTNat_apply_of_level_one
      {p : ℕ} [NeZero p] {k : ℤ}
      (f :
        ModularForm
          (Subgroup.map
            (Matrix.SpecialLinearGroup.mapGL
              ℝ)
            (CongruenceSubgroup.Gamma1 1))
          k)
      (hp : Nat.Prime p)
      (z : UpperHalfPlane) :
      ((HeckeRing.GL2.heckeTNat k p) f) z =
        (∑ j,
              f
                ((Matrix.GeneralLinearGroup.map
                      (algebraMap ℚ ℝ))
                    (HeckeRing.GL2.upperTriRep
                      p j) •
                  z) +
            ↑p ^ k *
              f (TauCeti.scaleGL p • z)) /
          ↑p
    **The Hecke operator `T(p)` at level `1`** (LMFDB `mf.gl2.history.new`): for a modular form `f`
    of weight `k` on `SL(2, ℤ)` and a prime `p`,
    `T_p f = (∑_{0 ≤ j < p} f((z + j)/p) + p^k f(pz)) / p`, where `T_p` is Tau Ceti's Hecke operator,
    `(z + j)/p` is the image of `z` under `!![1, j; 0, p]` (`coe_upperTriRep_smul`) and `pz` its image
    under `diag(p, 1)` (`coe_scaleGL_smul`). So the sum is again a modular form on `SL(2, ℤ)`. 
Definition3.6.11
Statement uses 5
Statement dependency previews
Preview
Definition 3.1.28
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Poincar&eacute; series. (LMFDB)

We can define a function which has the modular transformation property of modular forms by averaging over the group action:

f(z)=\sum_{\gamma\in\langle T\rangle\backslash\Gamma}h(\gamma z)(cz+d)^{-k},

whenever this makes sense, where T=\left(\begin{matrix}1&1\\0&1\end{matrix}\right) acts on \Gamma by left-multiplication. If h=1 we recover the Eisenstein series. If h(z)=\exp(2\pi i nz) with n\in\Z, which is indeed 1-periodic, we produce what are called Poincar'e; series. A special case for which it is <em>not</em> necessary to divide by the left-action of T is the function f(z)=\sum_{\gamma\in\Gamma}(\gamma z)^{-n}(cz+d)^{-k}, for suitable values of n.

Depends on: Definition 3.1.28 Definition 8.3.141 Definition 3.6.2 Definition 3.6.26 Definition 3.1.107

Lean code for Definition3.6.11●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/PoincareAverage.lean
    complete
    def ModularForm.averageSeries (h : UpperHalfPlane → ℂ) (k : ℤ)
      (z : UpperHalfPlane) : ℂ
    def ModularForm.averageSeries
      (h : UpperHalfPlane → ℂ) (k : ℤ)
      (z : UpperHalfPlane) : ℂ
    The **average** `∑_{γ ∈ ⟨T⟩ \ Γ} h(γz) (cz + d)^{-k}` of a function `h` on the upper
    half-plane over the right cosets of `⟨T⟩` in `Γ = SL(2, ℤ)`, in weight `k` (LMFDB
    `mf.gl2.history.poincare`). It is an unconditional sum (`tsum`, `0` when not summable) over the
    cosets, each represented by a chosen element. For `1`-periodic `h` the terms do not depend on the
    representatives, and the average has the transformation property of modular forms of weight `k`
    (`ModularForm.averageSeries_smul`). The series converges absolutely in weight `k ≥ 3` when `h` is
    bounded on the orbit of `z` (`ModularForm.summable_norm_averageTerm`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/PoincareAverage.lean
    complete
    theorem ModularForm.averageSeries_smul {h : UpperHalfPlane → ℂ} (k : ℤ)
      (z : UpperHalfPlane)
      (hh : ∀ (w : UpperHalfPlane), h (ModularGroup.T • w) = h w)
      (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ) :
      ModularForm.averageSeries h k (γ • z) =
        UpperHalfPlane.denom
              (Matrix.SpecialLinearGroup.toGL
                ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) γ))
              ↑z ^
            k *
          ModularForm.averageSeries h k z
    theorem ModularForm.averageSeries_smul
      {h : UpperHalfPlane → ℂ} (k : ℤ)
      (z : UpperHalfPlane)
      (hh :
        ∀ (w : UpperHalfPlane),
          h (ModularGroup.T • w) = h w)
      (γ :
        Matrix.SpecialLinearGroup (Fin 2) ℤ) :
      ModularForm.averageSeries h k (γ • z) =
        UpperHalfPlane.denom
              (Matrix.SpecialLinearGroup.toGL
                ((Matrix.SpecialLinearGroup.map
                    (Int.castRingHom ℝ))
                  γ))
              ↑z ^
            k *
          ModularForm.averageSeries h k z
    **The average has the modular transformation property** (LMFDB `mf.gl2.history.poincare`):
    for a `1`-periodic `h`, `f(γz) = (cz + d)^k f(z)` for every `γ = !![a, b; c, d] ∈ SL(2, ℤ)`. The
    average is a `tsum`, so this holds also where the series diverges, both sides being `0`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/PoincareAverage.lean
    complete
    theorem ModularForm.summable_norm_averageTerm {h : UpperHalfPlane → ℂ} {k : ℤ}
      (z : UpperHalfPlane) (hk : 3 ≤ k) {C : ℝ}
      (hC : ∀ (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ), ‖h (γ • z)‖ ≤ C) :
      Summable fun q => ‖ModularForm.averageTerm h k z q.out‖
    theorem ModularForm.summable_norm_averageTerm
      {h : UpperHalfPlane → ℂ} {k : ℤ}
      (z : UpperHalfPlane) (hk : 3 ≤ k)
      {C : ℝ}
      (hC :
        ∀
          (γ :
            Matrix.SpecialLinearGroup (Fin 2)
              ℤ),
          ‖h (γ • z)‖ ≤ C) :
      Summable fun q =>
        ‖ModularForm.averageTerm h k z q.out‖
    **The average converges absolutely in weight `k ≥ 3` when `h` is bounded on the orbit of `z`**
    (LMFDB `mf.gl2.history.poincare`), in particular when `h` is bounded: the bottom rows `(c, d)` of
    the cosets `⟨T⟩γ` are distinct, so the series is dominated by the Eisenstein series of weight
    `k`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/PoincareAverage.lean
    complete
    theorem ModularForm.averageSeries_one_eq_E (z : UpperHalfPlane) {l : ℕ}
      (hl : 3 ≤ l) :
      ModularForm.averageSeries (fun x => 1) (↑l) z =
        2 * (ModularForm.E hl) z
    theorem ModularForm.averageSeries_one_eq_E
      (z : UpperHalfPlane) {l : ℕ}
      (hl : 3 ≤ l) :
      ModularForm.averageSeries (fun x => 1)
          (↑l) z =
        2 * (ModularForm.E hl) z
    **For `h = 1` the average is `2 E_k`** (LMFDB `mf.gl2.history.poincare`): twice Mathlib's
    normalised Eisenstein series of weight `l ≥ 3`, which is the sum over the cosets of `±⟨T⟩`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/PoincareAverage.lean
    complete
    theorem ModularForm.cexp_smul_T (n : ℤ) (w : UpperHalfPlane) :
      Complex.exp (2 * ↑Real.pi * Complex.I * ↑n * ↑(ModularGroup.T • w)) =
        Complex.exp (2 * ↑Real.pi * Complex.I * ↑n * ↑w)
    theorem ModularForm.cexp_smul_T (n : ℤ)
      (w : UpperHalfPlane) :
      Complex.exp
          (2 * ↑Real.pi * Complex.I * ↑n *
            ↑(ModularGroup.T • w)) =
        Complex.exp
          (2 * ↑Real.pi * Complex.I * ↑n * ↑w)
    **`e^{2πinz}` is `1`-periodic** (LMFDB `mf.gl2.history.poincare`): its value does not change
    under `T : z ↦ z + 1`, for every `n ∈ ℤ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/PoincareAverage.lean
    complete
    theorem ModularForm.averageSeries_cexp {k : ℤ} (z : UpperHalfPlane) (hk : 3 ≤ k)
      (hk2 : Even k) (n : ℤ) :
      ModularForm.averageSeries
          (fun w => Complex.exp (2 * ↑Real.pi * Complex.I * ↑n * ↑w)) k z =
        2 * ModularForm.poincareSeries 1 1 k n 1 z
    theorem ModularForm.averageSeries_cexp {k : ℤ}
      (z : UpperHalfPlane) (hk : 3 ≤ k)
      (hk2 : Even k) (n : ℤ) :
      ModularForm.averageSeries
          (fun w =>
            Complex.exp
              (2 * ↑Real.pi * Complex.I * ↑n *
                ↑w))
          k z =
        2 *
          ModularForm.poincareSeries 1 1 k n 1
            z
    **For `h(z) = e^{2πinz}` the average is twice the Poincaré series** (LMFDB
    `mf.gl2.history.poincare`): in even weight `k ≥ 3` and for every `n ∈ ℤ`, the average of
    `e^{2πinz}` over `⟨T⟩ \ SL(2, ℤ)` is twice the `n`-th Poincaré series `P_k^n(Γ, 1; z; ∞)` of
    `specialfunction.poincare` (LeanBridge's `ModularForm.poincareSeries`), which sums over the cosets
    of the stabiliser `Γ_∞ = ±⟨T⟩` of `∞`: each coset `±⟨T⟩γ` is the union of `⟨T⟩γ` and `⟨T⟩(-γ)`,
    whose terms agree in even weight. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/PoincareAverage.lean
    complete
    theorem ModularForm.summable_norm_averageTerm_zpow {k : ℤ} (z : UpperHalfPlane)
      {n : ℤ} (hn : 2 ≤ n) (hkn : 2 ≤ k - n) :
      Summable fun γ => ‖ModularForm.averageTerm (fun w => ↑w ^ (-n)) k z γ‖
    theorem ModularForm.summable_norm_averageTerm_zpow
      {k : ℤ} (z : UpperHalfPlane) {n : ℤ}
      (hn : 2 ≤ n) (hkn : 2 ≤ k - n) :
      Summable fun γ =>
        ‖ModularForm.averageTerm
            (fun w => ↑w ^ (-n)) k z γ‖
    **The series over the whole group converges absolutely for `2 ≤ n ≤ k - 2`** (LMFDB
    `mf.gl2.history.poincare`). Its terms are `(az + b)^{-n} (cz + d)^{-(k - n)}`. Where
    `|az + b| ≤ |cz + d|`, the matrix `γ = !![a, b; c, d]` is determined by its top row `(a, b)` and
    the integer `m` nearest to the real part of `(cz + d) / (az + b)`, and
    `|cz + d| ≥ |az + b| |m + i| / 3`, so that the term is at most
    `3^{k - n} |az + b|^{-k} |m + i|^{-(k - n)}`, which is summable over `(a, b)` and `m`. Elsewhere
    the same holds with the rows exchanged. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/PoincareAverage.lean
    complete
    theorem ModularForm.fullAverageSeries_eq_averageSeries {k : ℤ}
      (z : UpperHalfPlane) {n : ℤ} (hn : 2 ≤ n) (hkn : 2 ≤ k - n) :
      ModularForm.fullAverageSeries k z n =
        ModularForm.averageSeries (fun w => ∑' (m : ℤ), (↑w + ↑m) ^ (-n)) k
          z
    theorem ModularForm.fullAverageSeries_eq_averageSeries
      {k : ℤ} (z : UpperHalfPlane) {n : ℤ}
      (hn : 2 ≤ n) (hkn : 2 ≤ k - n) :
      ModularForm.fullAverageSeries k z n =
        ModularForm.averageSeries
          (fun w =>
            ∑' (m : ℤ), (↑w + ↑m) ^ (-n))
          k z
    **The series over the whole group is the average of `∑_m (w + m)^{-n}`** (LMFDB
    `mf.gl2.history.poincare`): for `2 ≤ n ≤ k - 2`, grouping the terms by the cosets `⟨T⟩γ`, the sum
    over `Γ` is the average over `⟨T⟩ \ Γ` of the `1`-periodic function `w ↦ ∑_{m ∈ ℤ} (w + m)^{-n}`
    (`ModularForm.tsum_zpow_smul_T`). 
Definition3.6.12
Statement uses 6
Statement dependency previews
Preview
Definition 2.3
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Remainder terms. (LMFDB)

Another occurrence of modular forms is in <em>remainder terms</em> of many asymptotic formulas in number theory. Eisenstein series have "large" coefficients, which are <em>explicitly known</em>, while cusp forms have "small" coefficients, which are usually less explicit. By "explicit" in this context we mean that the coefficients are given by simple arithmetic functions, for example divisor functions. If the spaces of modular forms that we consider are <em>finite dimensional</em> and if by any chance they are spanned by Eisenstein series, we can obtain explicit formulas for the coefficients of modular forms, with <em>no</em> error term. On the other hand, if they are not spanned by Eisenstein series, we can still write explicit formulas, with a "small" error term corresponding to the contribution of cusp forms.

A typical example of this is to find formulas for r_k(n), the number of representations of a positive integer n as a sum of k squares. This is in fact the coefficient of e^{\pi i z} in <em>&theta;</em>^k. The space of modular form to which \theta^k belongs is known to be spanned by Eisenstein series for k\le8, so we have explicit formulas for r_k(n) in these cases and otherwise we have approximate explicit formulas with a small error term. In fact, in the special case k=10, the cusp form which occurs is a <em>CM form</em>, so it has the special property that its coefficients can also easily be computed, so there does also exist an explicit formula for r_{10}(n).

Depends on: Definition 2.3 Definition 3.1.10 Definition 3.1.14 Definition 3.1.28 Definition 3.6.2 Definition 3.6.19

Definition3.6.13
Statement uses 3
Statement dependency previews
Preview
Definition 3.6.2
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Theta functions. (LMFDB)

The preceding examples are in some sense "na&iuml;ve", since modularity is essentially built into the definition. Less naive examples are <em>theta functions</em>. These can be given as averages over a lattice L:

\Theta_{L;Q;h}(z) = \sum_{x \in L} h(x)e^{2\pi izQ(x)}

where Q is a quadratic form and h some function on L, whenever the sum converges. Here, the basic reason for modularity comes from the <em>Poisson summation formula</em>, or equivalently from the theory of the Fourier transform and the Fourier invariance of the function e^{-\pi x^2}. Although this is very classical, it is a slightly deeper reason for modularity. In addition, since the Fourier transform exists in any dimension and it is easy to construct functions which are invariant under the Fourier transform, this gives a large collection of modular forms. A slightly more subtle explanation of this comes from the theory of the <em>Weil representation</em>.

Depends on: Definition 8.4.9 Definition 3.6.2 Definition 3.6.26

Definition3.6.14
Statement uses 13
Statement dependency previews
Preview
Definition 1.2.1
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0XL∃∀N

Algebraic varieties. (LMFDB)

A much deeper occurrence of modular forms comes from the theory of algebraic varieties over \Q, or more generally over a number field: to such an object one can associate in a natural way one or several Dirichlet series defined as Euler products involving the number of points of the variety over all finite fields. It is *conjectured*, and far from proved, that *all* these Dirichlet series satisfy similar properties to that of the Riemann zeta function \zeta(s) and generalizations: meromorphic continuation to the whole complex plane with known poles, a functional equation when s\mapsto k-s for suitable k, and so forth. The existence of this functional equation together with suitable regularity conditions is closely linked to the fact that the function \sum_{n\ge1}a(n)q^n has a modularity property. In the specific case of elliptic curves defined over \Q, this has been proved, giving another much deeper source of modular forms (of weight 2 and trivial multiplier system) linked to elliptic curves.

Much more recently, Brumer&#8210;Kramer have conjectured a similar connection between isogeny classes of abelian surfaces defined over \Q with endomorphism ring reduced to \Z and certain modular forms on a subgroup of \Sp_4(\Q) called the paramodular group.

Depends on: Definition 1.2.1 Definition 1.2.22 Definition 1.2.60 Definition 4.1.64 Definition 4.2.31 Definition 8.3.104 Definition 2.22 Definition 2.24 Definition 2.25 Definition 2.51 Definition 3.6.2 Definition 3.6.26 Definition 5.1.1

Definition3.6.15
uses 1used by 0XL∃∀N

Growth condition for a modular form. (LMFDB)

A modular form f satisfies a growth condition which restricts the growth of f as y\rightarrow \infty in complex variables z=x+iy.

Depends on: Definition 3.6.2

Definition3.6.16
Statement uses 7
Statement dependency previews
Preview
Definition 3.1.14
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
used by 0✓L∃∀N

Half-integral weight modular forms. (LMFDB)

Let k be an odd integer, and let N a positive integer divisible by 4. Let \chi be a character modulo N. A modular form of half-integral weight k/2 , level N and character \chi is an holomorphic function defined on the upper half plane \mathcal{H}, satisfying the transformation formula

f(\gamma z) = \chi(d) j(\gamma, z)^k f(z)

for every \gamma=\left(\begin{matrix} a & b \\ c & d \end{matrix}\right)\in\Gamma_0(N) and z\in \mathcal{H}, and being holomorphic at the cusps. Here the automorphy factor j(\gamma, z) is given by

j(\gamma, z) = \theta(\gamma z)/\theta(z),

where \theta denotes the classical theta function. This space is denoted by M_{k/2}(N), and the subspace of cusp forms is denoted by S_{k/2}(N).

These modular forms are related with integral weight modular forms through the Shimura correspondence. In terms of this correspondence, the space of cusp forms can be decomposed according to the Shimura decomposition.

Depends on: Definition 6.1.1 Definition 3.1.14 Definition 3.1.57 Definition 3.1.87 Definition 3.1.101 Definition 8.3.53 Definition 3.6.19

Lean code for Definition3.6.16●12 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/HalfIntegralWeight.lean
    complete
    def ModularForm.halfIntegralWeightSpace {N : ℕ} (χ : DirichletCharacter ℂ N)
      (k : ℤ) : Submodule ℂ (UpperHalfPlane → ℂ)
    def ModularForm.halfIntegralWeightSpace
      {N : ℕ} (χ : DirichletCharacter ℂ N)
      (k : ℤ) :
      Submodule ℂ (UpperHalfPlane → ℂ)
    The space `M_{k/2}(N, χ)` of **modular forms of half-integral weight** `k/2` (LMFDB
    `mf.half_integral_weight`), level `N` and character `χ`: the holomorphic `f : ℍ → ℂ` with
    `f(γz) = χ(d) j(γ, z)^k f(z)` for every `γ = (a, b; c, d) ∈ Γ₀(N)` and `z ∈ ℍ`, where `j` is
    Shimura's theta multiplier `ModularForm.thetaFactor`, that are holomorphic at the cusps: for every
    `γ ∈ SL(2, ℤ)`, `|cz + d|^(-k/2) f(γz)` is bounded as `Im z → ∞`. The LMFDB requires `k` odd and
    `4 ∣ N` (`hasWeight_of_mem_halfIntegralWeightSpace`); the space is defined for all `k` and `N`.
    
    The LMFDB defines `j(γ, z) = θ(γz) / θ(z)`; Shimura's formula
    `j(γ, z) = (c/d) ε_d⁻¹ (cz + d)^(1/2)` for `γ ∈ Γ₀(4)` is used instead, and
    `ModularForm.thetaSeries_smul` proves `θ(γz) = j(γ, z) θ(z)` for `θ(z) = Σ_n e^{2πin²z}`. As `θ`
    has no zero on `ℍ`, the two agree (`ModularForm.thetaFactor_eq_div`,
    `ModularForm.mem_halfIntegralWeightSpace_iff`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/HalfIntegralWeight.lean
    complete
    def ModularForm.halfIntegralWeightCuspSpace {N : ℕ}
      (χ : DirichletCharacter ℂ N) (k : ℤ) :
      Submodule ℂ (UpperHalfPlane → ℂ)
    def ModularForm.halfIntegralWeightCuspSpace
      {N : ℕ} (χ : DirichletCharacter ℂ N)
      (k : ℤ) :
      Submodule ℂ (UpperHalfPlane → ℂ)
    The space `S_{k/2}(N, χ)` of **cusp forms of half-integral weight** `k/2` (LMFDB
    `mf.half_integral_weight`), level `N` and character `χ`: the `f ∈ M_{k/2}(N, χ)` that vanish at
    the cusps, that is, `|cz + d|^(-k/2) f(γz) → 0` as `Im z → ∞` for every `γ ∈ SL(2, ℤ)`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaMultiplier.lean
    complete
    def ModularForm.thetaSeries (z : UpperHalfPlane) : ℂ
    def ModularForm.thetaSeries
      (z : UpperHalfPlane) : ℂ
    The **theta function** `θ(z) = ∑_{n ∈ ℤ} e(n² z)` on the upper half plane, which is
    `jacobiTheta (2 z)`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/Weight.lean
    complete
    def ModularForm.thetaFactor (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ)
      (z : UpperHalfPlane) : ℂ
    def ModularForm.thetaFactor
      (γ :
        Matrix.SpecialLinearGroup (Fin 2) ℤ)
      (z : UpperHalfPlane) : ℂ
    **Shimura's theta multiplier** `j(γ, z) = (c/d) ε_d⁻¹ (cz + d)^(1/2)`, with the principal
    square root: for `γ ∈ Γ₀(4)` it is the automorphy factor `θ(γz) / θ(z)` of the theta function
    `θ(z) = Σ q^(n²)`, the automorphy factor of weight `1/2`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaNonvanishing.lean
    complete
    theorem ModularForm.thetaSeries_apply_ne_zero (z : UpperHalfPlane) :
      ModularForm.thetaSeries z ≠ 0
    theorem ModularForm.thetaSeries_apply_ne_zero
      (z : UpperHalfPlane) :
      ModularForm.thetaSeries z ≠ 0
    **The theta function has no zero on the upper half-plane**: `θ(z) ≠ 0` for every `z ∈ ℍ`. The
    modular form `θ²` of weight `1` on `Γ₁(4)`, of index `12` and with trivial point stabilisers, has
    order of vanishing at most `1 · 12 · 1 / 24` at every point, by the valence formula. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaNonvanishing.lean
    complete
    theorem ModularForm.thetaFactor_eq_div {γ : Matrix.SpecialLinearGroup (Fin 2) ℤ}
      (z : UpperHalfPlane) (hγ : γ ∈ CongruenceSubgroup.Gamma0 4) :
      ModularForm.thetaFactor γ z =
        ModularForm.thetaSeries (γ • z) / ModularForm.thetaSeries z
    theorem ModularForm.thetaFactor_eq_div
      {γ :
        Matrix.SpecialLinearGroup (Fin 2) ℤ}
      (z : UpperHalfPlane)
      (hγ : γ ∈ CongruenceSubgroup.Gamma0 4) :
      ModularForm.thetaFactor γ z =
        ModularForm.thetaSeries (γ • z) /
          ModularForm.thetaSeries z
    **The theta multiplier is `θ(γz) / θ(z)`** (LMFDB `mf.half_integral_weight`): for `γ ∈ Γ₀(4)`,
    Shimura's factor `j(γ, z) = (c/d) ε_d⁻¹ (cz + d)^(1/2)` is the knowl's automorphy factor, the
    quotient being defined as `θ` has no zero on `ℍ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaNonvanishing.lean
    complete
    theorem ModularForm.mem_halfIntegralWeightSpace_iff {N : ℕ}
      {χ : DirichletCharacter ℂ N} {k : ℤ} {f : UpperHalfPlane → ℂ}
      (hk : Odd k) (hN : 4 ∣ N) :
      f ∈ ModularForm.halfIntegralWeightSpace χ k ↔
        MDiff f ∧
          (∀ γ ∈ CongruenceSubgroup.Gamma0 N,
              ∀ (z : UpperHalfPlane),
                f (γ • z) =
                  χ ↑(↑γ 1 1) *
                      (ModularForm.thetaSeries (γ • z) /
                          ModularForm.thetaSeries z) ^
                        k *
                    f z) ∧
            ∀ (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ),
              UpperHalfPlane.IsBoundedAtImInfty
                (ModularForm.halfIntegralWeightSlash k γ f)
    theorem ModularForm.mem_halfIntegralWeightSpace_iff
      {N : ℕ} {χ : DirichletCharacter ℂ N}
      {k : ℤ} {f : UpperHalfPlane → ℂ}
      (hk : Odd k) (hN : 4 ∣ N) :
      f ∈
          ModularForm.halfIntegralWeightSpace
            χ k ↔
        MDiff f ∧
          (∀ γ ∈ CongruenceSubgroup.Gamma0 N,
              ∀ (z : UpperHalfPlane),
                f (γ • z) =
                  χ ↑(↑γ 1 1) *
                      (ModularForm.thetaSeries
                            (γ • z) /
                          ModularForm.thetaSeries
                            z) ^
                        k *
                    f z) ∧
            ∀
              (γ :
                Matrix.SpecialLinearGroup
                  (Fin 2) ℤ),
              UpperHalfPlane.IsBoundedAtImInfty
                (ModularForm.halfIntegralWeightSlash
                  k γ f)
    **The knowl's definition of `M_{k/2}(N, χ)`** (LMFDB `mf.half_integral_weight`): for odd `k`
    and `4 ∣ N`, a function `f : ℍ → ℂ` lies in `M_{k/2}(N, χ)` exactly when it is holomorphic,
    satisfies `f(γz) = χ(d) j(γ, z)^k f(z)` for every `γ = (a, b; c, d) ∈ Γ₀(N)` with
    `j(γ, z) = θ(γz) / θ(z)`, and is holomorphic at the cusps. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaMultiplier.lean
    complete
    theorem ModularForm.thetaSeries_mem_halfIntegralWeightSpace :
      ModularForm.thetaSeries ∈ ModularForm.halfIntegralWeightSpace 1 1
    theorem ModularForm.thetaSeries_mem_halfIntegralWeightSpace :
      ModularForm.thetaSeries ∈
        ModularForm.halfIntegralWeightSpace 1
          1
    **The theta function is a modular form of weight `1/2`**: `θ ∈ M_{1/2}(4, 1)`. So
    `ModularForm.halfIntegralWeightSpace` is not vacuous, and its multiplier is that of `θ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/HalfIntegralWeight.lean
    complete
    theorem ModularForm.hasWeight_of_mem_halfIntegralWeightSpace {N : ℕ}
      (χ : DirichletCharacter ℂ N) (k : ℤ) {f : UpperHalfPlane → ℂ}
      (hf : f ∈ ModularForm.halfIntegralWeightSpace χ k) (hN : 4 ∣ N) :
      ModularForm.HasWeight f N χ (↑k / 2)
    theorem ModularForm.hasWeight_of_mem_halfIntegralWeightSpace
      {N : ℕ} (χ : DirichletCharacter ℂ N)
      (k : ℤ) {f : UpperHalfPlane → ℂ}
      (hf :
        f ∈
          ModularForm.halfIntegralWeightSpace
            χ k)
      (hN : 4 ∣ N) :
      ModularForm.HasWeight f N χ (↑k / 2)
    **The forms of `M_{k/2}(N, χ)` have weight `k/2`**: for odd `k` and `4 ∣ N` they satisfy the
    transformation law of weight `k/2` of `ModularForm.HasWeight`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaMultiplier.lean
    complete
    theorem ModularForm.thetaSeries_smul {γ : Matrix.SpecialLinearGroup (Fin 2) ℤ}
      (z : UpperHalfPlane) (hγ : γ ∈ CongruenceSubgroup.Gamma0 4) :
      ModularForm.thetaSeries (γ • z) =
        ModularForm.thetaFactor γ z * ModularForm.thetaSeries z
    theorem ModularForm.thetaSeries_smul
      {γ :
        Matrix.SpecialLinearGroup (Fin 2) ℤ}
      (z : UpperHalfPlane)
      (hγ : γ ∈ CongruenceSubgroup.Gamma0 4) :
      ModularForm.thetaSeries (γ • z) =
        ModularForm.thetaFactor γ z *
          ModularForm.thetaSeries z
    **The transformation law of the theta function.** For `γ = (a, b; c, d) ∈ Γ₀(4)`,
    `θ(γ z) = j(γ, z) θ(z)` with Shimura's theta multiplier `j(γ, z) = (c / d) ε_d⁻¹ (c z + d) ^ (1/2)`:
    the theta multiplier `ModularForm.thetaFactor` is the automorphy factor of `θ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaDiscriminant.lean
    complete
    theorem ModularForm.thetaSeries_mul_discriminant_mem_halfIntegralWeightCuspSpace :
      ModularForm.thetaSeries * ModularForm.discriminant ∈
        ModularForm.halfIntegralWeightCuspSpace 1 (2 * ↑12 + 1)
    theorem ModularForm.thetaSeries_mul_discriminant_mem_halfIntegralWeightCuspSpace :
      ModularForm.thetaSeries *
          ModularForm.discriminant ∈
        ModularForm.halfIntegralWeightCuspSpace
          1 (2 * ↑12 + 1)
    **`θ Δ` is a cusp form of half-integral weight**: `θ Δ ∈ S_{25/2}(4, 1)`, for `θ` the theta
    function and `Δ` the discriminant. So the domain of the Shimura correspondence
    (LMFDB `cmf.shimura_correspondence`) is not zero. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaDiscriminant.lean
    complete
    theorem ModularForm.thetaSeries_mul_discriminant_ne_zero :
      ModularForm.thetaSeries * ModularForm.discriminant ≠ 0
    theorem ModularForm.thetaSeries_mul_discriminant_ne_zero :
      ModularForm.thetaSeries *
          ModularForm.discriminant ≠
        0
    **`θ Δ` is not zero** (LMFDB `cmf.shimura_correspondence`). 
Definition3.6.17
uses 0
Used by 4
Reverse dependency previews
Preview
Definition 3.1.37
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Dedekind eta function. (LMFDB)

We define the Dedekind eta function \eta(z) by the formula

\eta(z)=q^{1/24}\prod_{n\geq1}(1-q^n),

where q=e^{2\pi iz}.

It is related to the Discriminant modular form via the formula

\Delta(z)=\eta^{24}(z).

Tau Ceti Review: ModularForm.eta.

Lean code for Definition3.6.17●1 definition
  • defdefined in Mathlib/NumberTheory/ModularForms/DedekindEta.lean
    complete
    def ModularForm.eta (z : ℂ) : ℂ
    def ModularForm.eta (z : ℂ) : ℂ
    The eta function, whose value at z is `q^ 1 / 24 * ∏' 1 - q ^ (n + 1)` for `q = e ^ 2 π i z`. 
Definition3.6.18
uses 0used by 0XL∃∀N

Shimura decomposition. (LMFDB)

Let k be an odd integer. Let S_0(N, \chi) denote the subspace of S_{3/2}(N, \chi) spanned by theta series if k=3, and let S_0(N, \chi)=0 if k>3. Let S_0'(N, \chi) denote the orthogonal complement of S_0(N, \chi) in S_{3/2}(N, \chi). Then

S_0'(N, \chi) = \oplus_F S_{k/2}(N, \chi, F),

where F runs over all newforms of weight k-1, level dividing N/2 and character \chi^2, and the space S_{k/2}(N, \chi, F) is defined by

S_{k/2}(N, \chi, F) =\{ g \in S_0'(N, \chi): T_{p^2} g = \lambda_p(F) g \quad \forall\, p\nmid N\}.

Definition3.6.19
Statement uses 2
Statement dependency previews
Preview
Definition 3.1.57
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 3
Reverse dependency previews
Preview
Definition 3.6.12
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Theta function. (LMFDB)

The (classical) theta function \theta(z) is a holomorphic modular form of half-integral weight 1/2 and level 4, defined by the formula

\theta(z)=\sum_{n=-\infty}^\infty e^{\pi iz n^2}.

It has the following <em>product expansion</em>:

\theta(z)=\prod_{n\geq1}(1+q^{n-1/2})^2(1-q^n),

where q=e^{2\pi iz}.

The (classical) theta function is related to the Dedekind eta function via the formula:

\theta(z)=\frac{\eta^5(z)}{\eta^2(z/2)\eta^2(2z)}=\frac{\eta^2((z+1)/2)}{\eta(z+1)}.

Tau Ceti Review: jacobiTheta.

Depends on: Definition 3.1.57 Definition 3.6.17

Lean code for Definition3.6.19●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaMultiplier.lean
    complete
    def ModularForm.thetaSeries (z : UpperHalfPlane) : ℂ
    def ModularForm.thetaSeries
      (z : UpperHalfPlane) : ℂ
    The **theta function** `θ(z) = ∑_{n ∈ ℤ} e(n² z)` on the upper half plane, which is
    `jacobiTheta (2 z)`. 
  • defdefined in Mathlib/NumberTheory/ModularForms/JacobiTheta/OneVariable.lean
    complete
    def jacobiTheta (τ : ℂ) : ℂ
    def jacobiTheta (τ : ℂ) : ℂ
    Jacobi's one-variable theta function `∑' (n : ℤ), exp (π * I * n ^ 2 * τ)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaMultiplier.lean
    complete
    theorem ModularForm.thetaSeries_eq (z : UpperHalfPlane) :
      ModularForm.thetaSeries z = jacobiTheta (2 * ↑z)
    theorem ModularForm.thetaSeries_eq
      (z : UpperHalfPlane) :
      ModularForm.thetaSeries z =
        jacobiTheta (2 * ↑z)
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaMultiplier.lean
    complete
    theorem ModularForm.thetaSeries_mem_halfIntegralWeightSpace :
      ModularForm.thetaSeries ∈ ModularForm.halfIntegralWeightSpace 1 1
    theorem ModularForm.thetaSeries_mem_halfIntegralWeightSpace :
      ModularForm.thetaSeries ∈
        ModularForm.halfIntegralWeightSpace 1
          1
    **The theta function is a modular form of weight `1/2`**: `θ ∈ M_{1/2}(4, 1)`. So
    `ModularForm.halfIntegralWeightSpace` is not vacuous, and its multiplier is that of `θ`. 
  • theoremdefined in LeanBridge/ForMathlib/Analysis/SpecialFunctions/JacobiTripleProduct.lean
    complete
    theorem hasProd_tsum_zpow_mul_zpow_sq.{u_1} {𝕜 : Type u_1} [NormedField 𝕜]
      [CompleteSpace 𝕜] {q z : 𝕜} (hq : ‖q‖ < 1) (hz : z ≠ 0) :
      HasProd
        (fun n =>
          (1 - q ^ (2 * (n + 1))) * (1 + z * q ^ (2 * n + 1)) *
            (1 + z⁻¹ * q ^ (2 * n + 1)))
        (∑' (n : ℤ), z ^ n * q ^ n ^ 2)
    theorem hasProd_tsum_zpow_mul_zpow_sq.{u_1}
      {𝕜 : Type u_1} [NormedField 𝕜]
      [CompleteSpace 𝕜] {q z : 𝕜}
      (hq : ‖q‖ < 1) (hz : z ≠ 0) :
      HasProd
        (fun n =>
          (1 - q ^ (2 * (n + 1))) *
              (1 + z * q ^ (2 * n + 1)) *
            (1 + z⁻¹ * q ^ (2 * n + 1)))
        (∑' (n : ℤ), z ^ n * q ^ n ^ 2)
    **The Jacobi triple product identity**: for `‖q‖ < 1` and `z ≠ 0` in a complete normed field,
    the product `∏_{n ≥ 1} (1 - q^(2n)) (1 + z q^(2n-1)) (1 + z⁻¹ q^(2n-1))` converges to the theta
    series `∑_{n ∈ ℤ} zⁿ q^(n²)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaProduct.lean
    complete
    theorem ModularForm.hasProd_thetaSeries (z : UpperHalfPlane) :
      HasProd
        (fun n =>
          (1 + Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ (2 * n + 1)) ^
              2 *
            (1 -
              Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ (2 * (n + 1))))
        (ModularForm.thetaSeries z)
    theorem ModularForm.hasProd_thetaSeries
      (z : UpperHalfPlane) :
      HasProd
        (fun n =>
          (1 +
                Complex.exp
                    (2 * ↑Real.pi *
                        Complex.I *
                      ↑z) ^
                  (2 * n + 1)) ^
              2 *
            (1 -
              Complex.exp
                  (2 * ↑Real.pi * Complex.I *
                    ↑z) ^
                (2 * (n + 1))))
        (ModularForm.thetaSeries z)
    **The product expansion of the theta function** (LMFDB `mf.half_integral_weight.theta`): the
    product `∏_{n ≥ 1} (1 + q^(2n-1))² (1 - q^(2n))` converges to `θ(z)`, where `q = e^{2πiz}`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaProduct.lean
    complete
    theorem ModularForm.thetaSeries_eq_eta_pow_five_div (z : UpperHalfPlane) :
      ModularForm.thetaSeries z =
        ModularForm.eta (2 * ↑z) ^ 5 /
          (ModularForm.eta ↑z ^ 2 * ModularForm.eta (4 * ↑z) ^ 2)
    theorem ModularForm.thetaSeries_eq_eta_pow_five_div
      (z : UpperHalfPlane) :
      ModularForm.thetaSeries z =
        ModularForm.eta (2 * ↑z) ^ 5 /
          (ModularForm.eta ↑z ^ 2 *
            ModularForm.eta (4 * ↑z) ^ 2)
    **The theta function as an eta quotient** (LMFDB `mf.half_integral_weight.theta`):
    `θ(z) = η(2z)⁵ / (η(z)² η(4z)²)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/ThetaProduct.lean
    complete
    theorem ModularForm.thetaSeries_eq_eta_sq_div (z : UpperHalfPlane) :
      ModularForm.thetaSeries z =
        ModularForm.eta (↑z + 1 / 2) ^ 2 / ModularForm.eta (2 * ↑z + 1)
    theorem ModularForm.thetaSeries_eq_eta_sq_div
      (z : UpperHalfPlane) :
      ModularForm.thetaSeries z =
        ModularForm.eta (↑z + 1 / 2) ^ 2 /
          ModularForm.eta (2 * ↑z + 1)
    **The theta function as an eta quotient** (LMFDB `mf.half_integral_weight.theta`):
    `θ(z) = η(z + 1/2)² / η(2z + 1)`. 
Definition3.6.20
uses 0used by 1✓L∃∀N

Jacobi forms. (LMFDB)

A Jacobi form (of full level) of weight k and index N is a holomorphic function f:\mathcal{H}\times\C\to \C where \mathcal{H} is the upper half plane that satisfies the following conditions. <ul> <li>For all \left(\begin{matrix}a&b\\c&d\end{matrix} \right) \in SL(2,{\Bbb Z}), we have

f\left(\frac{a\tau+b}{c\tau+d}, \frac{z}{c\tau+d}\right)= (c\tau+d)^k e^{2\pi i\, mcz^2 /(c\tau+d)} f(\tau,z)

</li> <li>f has a Fourier expansion

f(\tau,z)=\sum_{n,r:4nN-r^2\ge0} c(n,r) e^{2\pi i (n\tau+r z)}.

</li> </ul> The space of Jacobi forms is denoted by J_{k,N}. If furthermore, the Fourier expansion is over only those n,r for which 4Nn-r^2>0, we say it is a Jacobi cusp form, and denote the space of Jacobi cusp forms by J_{k,N}^{\text{cusp}}.

Lean code for Definition3.6.20●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/AutomorphicForms/Jacobi/Basic.lean
    complete
    def ModularForm.jacobiFormSpace (k : ℤ) (N : ℕ) :
      Submodule ℂ (UpperHalfPlane × ℂ → ℂ)
    def ModularForm.jacobiFormSpace (k : ℤ)
      (N : ℕ) :
      Submodule ℂ (UpperHalfPlane × ℂ → ℂ)
    The space `J_{k,N}` of **Jacobi forms** (LMFDB `mf.jacobi`) of weight `k` and index `N`, of full
    level: the holomorphic `f : ℍ × ℂ → ℂ` with
    `f((aτ + b) / (cτ + d), z / (cτ + d)) = (cτ + d)^k e^{2πiNcz² / (cτ + d)} f(τ, z)` for every
    `(a, b; c, d) ∈ SL(2, ℤ)` and `(τ, z) ∈ ℍ × ℂ`, with a Fourier expansion
    `f(τ, z) = ∑ c(n, r) e^{2πi(nτ + rz)}` over the integers `n, r` with `4nN - r² ≥ 0` and `n ≥ 0`.
    Holomorphy is on the complex manifold `ℍ × ℂ`.
    
    The knowl writes `m` for the index `N` in the transformation law. For `N ≥ 1` the condition
    `n ≥ 0` follows from `4nN ≥ r²`; for `N = 0` the knowl's condition `r = 0` alone would allow
    `n < 0`, and `n ≥ 0` is imposed, as by Eichler and Zagier. The elliptic transformation law, which
    the knowl omits, follows (`apply_add_mul_add_of_mem_jacobiFormSpace`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/AutomorphicForms/Jacobi/Basic.lean
    complete
    def ModularForm.jacobiCuspFormSpace (k : ℤ) (N : ℕ) :
      Submodule ℂ (UpperHalfPlane × ℂ → ℂ)
    def ModularForm.jacobiCuspFormSpace (k : ℤ)
      (N : ℕ) :
      Submodule ℂ (UpperHalfPlane × ℂ → ℂ)
    The space `J_{k,N}^cusp` of **Jacobi cusp forms** (LMFDB `mf.jacobi`) of weight `k` and index
    `N`: the Jacobi forms whose Fourier expansion runs over the integers `n, r` with
    `4nN - r² > 0`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/AutomorphicForms/Jacobi/Basic.lean
    complete
    def ModularForm.HasJacobiFourierExpansion (f : UpperHalfPlane × ℂ → ℂ)
      (c : ℤ × ℤ → ℂ) : Prop
    def ModularForm.HasJacobiFourierExpansion
      (f : UpperHalfPlane × ℂ → ℂ)
      (c : ℤ × ℤ → ℂ) : Prop
    The family `c : ℤ × ℤ → ℂ` is **a family of Fourier coefficients** of `f : ℍ × ℂ → ℂ`:
    `f(τ, z) = ∑_{n, r ∈ ℤ} c(n, r) e^{2πi(nτ + rz)}` for every `(τ, z) ∈ ℍ × ℂ`, the sum converging
    unconditionally. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/AutomorphicForms/Jacobi/Basic.lean
    complete
    def ModularForm.jacobiFactor (k : ℤ) (N : ℕ) (x : UpperHalfPlane × ℂ)
      (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ) : ℂ
    def ModularForm.jacobiFactor (k : ℤ) (N : ℕ)
      (x : UpperHalfPlane × ℂ)
      (γ :
        Matrix.SpecialLinearGroup (Fin 2) ℤ) :
      ℂ
    The factor `(cτ + d)^k e^{2πiNcz² / (cτ + d)}` of the transformation law of Jacobi forms of
    weight `k` and index `N`, for `γ = (a, b; c, d) ∈ SL(2, ℤ)` and `x = (τ, z)`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/AutomorphicForms/Jacobi/Basic.lean
    complete
    theorem ModularForm.apply_add_mul_add_of_mem_jacobiFormSpace {k : ℤ} {N : ℕ}
      {f : UpperHalfPlane × ℂ → ℂ} (τ : UpperHalfPlane) (z : ℂ) (a b : ℤ)
      (hf : f ∈ ModularForm.jacobiFormSpace k N) :
      f (τ, z + ↑a * ↑τ + ↑b) =
        Complex.exp
            (-2 * ↑Real.pi * Complex.I * ↑N * (↑a ^ 2 * ↑τ + 2 * ↑a * z)) *
          f (τ, z)
    theorem ModularForm.apply_add_mul_add_of_mem_jacobiFormSpace
      {k : ℤ} {N : ℕ}
      {f : UpperHalfPlane × ℂ → ℂ}
      (τ : UpperHalfPlane) (z : ℂ) (a b : ℤ)
      (hf :
        f ∈ ModularForm.jacobiFormSpace k N) :
      f (τ, z + ↑a * ↑τ + ↑b) =
        Complex.exp
            (-2 * ↑Real.pi * Complex.I * ↑N *
              (↑a ^ 2 * ↑τ + 2 * ↑a * z)) *
          f (τ, z)
    **The elliptic transformation law** `f(τ, z + λτ + μ) = e^{-2πiN(λ²τ + 2λz)} f(τ, z)` of a
    Jacobi form of index `N`, for all `λ, μ ∈ ℤ`: it follows from the transformation law under
    `SL(2, ℤ)` and the periodicity in `z`, so that the LMFDB definition, which omits it, agrees with
    that of Eichler and Zagier. 
Definition3.6.21
uses 0
Used by 7
Reverse dependency previews
Preview
Definition 3.1.107
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Multiplier system. (LMFDB)

A multiplier system of weight k\in\mathbb{Z} for a group G is a group homomorphism from G to the group S^1 of complex numbers of modulus 1, with the added condition that, if -I\in G, then v(-I)=(-1)^k.

Lean code for Definition3.6.21●5 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/Basic.lean
    complete
    def MonoidHom.IsMultiplierSystem {Γ : Subgroup (GL (Fin 2) ℝ)}
      (v : ↥Γ →* Circle) (k : ℤ) : Prop
    def MonoidHom.IsMultiplierSystem
      {Γ : Subgroup (GL (Fin 2) ℝ)}
      (v : ↥Γ →* Circle) (k : ℤ) : Prop
    A homomorphism `v : Γ → S¹` from a subgroup `Γ` of `GL(2, ℝ)` to the unit circle is a
    **multiplier system** (LMFDB `mf.multipliersystem`) of weight `k ∈ ℤ` if `v(-I) = (-1) ^ k`
    whenever `-I ∈ Γ`. This is the LMFDB's notion, for integral weight, where multiplier systems are
    homomorphisms; the multipliers of non-integral weight, such as that of the Dedekind eta function
    (`ModularForm.etaMultiplier`), are not homomorphisms and are not covered. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/Basic.lean
    complete
    theorem MonoidHom.isMultiplierSystem_of_slash_eq_smul
      {Γ : Subgroup (GL (Fin 2) ℝ)} (v : ↥Γ →* Circle) {k : ℤ}
      {f : UpperHalfPlane → ℂ} (hf : f ≠ 0)
      (h : ∀ (γ : ↥Γ), SlashAction.map k (↑γ) f = ↑(v γ) • f) :
      v.IsMultiplierSystem k
    theorem MonoidHom.isMultiplierSystem_of_slash_eq_smul
      {Γ : Subgroup (GL (Fin 2) ℝ)}
      (v : ↥Γ →* Circle) {k : ℤ}
      {f : UpperHalfPlane → ℂ} (hf : f ≠ 0)
      (h :
        ∀ (γ : ↥Γ),
          SlashAction.map k (↑γ) f =
            ↑(v γ) • f) :
      v.IsMultiplierSystem k
    **The condition at `-I` is forced by the transformation law**: if a nonzero function
    `f : ℍ → ℂ` satisfies `f ∣[k] γ = v(γ) f` for every `γ ∈ Γ`, then `v` is a multiplier system of
    weight `k`, since `-I` slashes by `(-1) ^ k`. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/Basic.lean
    complete
    def CongruenceSubgroup.nebentypusMultiplier {N : ℕ} (χ : (ZMod N)ˣ →* ℂˣ) :
      ↥(Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ)
            (CongruenceSubgroup.Gamma0 N)) →*
        Circle
    def CongruenceSubgroup.nebentypusMultiplier
      {N : ℕ} (χ : (ZMod N)ˣ →* ℂˣ) :
      ↥(Subgroup.map
            (Matrix.SpecialLinearGroup.mapGL
              ℝ)
            (CongruenceSubgroup.Gamma0 N)) →*
        Circle
    The **nebentypus multiplier** of a character `χ` of `(ℤ/Nℤ)ˣ`: the homomorphism `γ ↦ χ(d)` on
    `Γ₀(N)`, as a subgroup of `GL(2, ℝ)`, where `d` is the lower-right entry of `γ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/Basic.lean
    complete
    theorem CongruenceSubgroup.isMultiplierSystem_nebentypusMultiplier_iff {N : ℕ}
      (χ : (ZMod N)ˣ →* ℂˣ) {k : ℤ} :
      (CongruenceSubgroup.nebentypusMultiplier χ).IsMultiplierSystem k ↔
        ↑(χ (-1)) = (-1) ^ k
    theorem CongruenceSubgroup.isMultiplierSystem_nebentypusMultiplier_iff
      {N : ℕ} (χ : (ZMod N)ˣ →* ℂˣ) {k : ℤ} :
      (CongruenceSubgroup.nebentypusMultiplier
              χ).IsMultiplierSystem
          k ↔
        ↑(χ (-1)) = (-1) ^ k
    The nebentypus multiplier of `χ` is a **multiplier system of weight `k`** exactly when `χ` has
    the parity of `k`: `χ(-1) = (-1) ^ k`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/Basic.lean
    complete
    theorem CongruenceSubgroup.mem_modFormCharSpace_iff_slash_eq_smul {N : ℕ}
      (χ : (ZMod N)ˣ →* ℂˣ) {k : ℤ}
      {f :
        ModularForm
          (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ)
            (CongruenceSubgroup.Gamma1 N))
          k} :
      f ∈ modFormCharSpace k χ ↔
        ∀
          (γ :
            ↥(Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ)
                (CongruenceSubgroup.Gamma0 N))),
          SlashAction.map k ↑γ ⇑f =
            ↑((CongruenceSubgroup.nebentypusMultiplier χ) γ) • ⇑f
    theorem CongruenceSubgroup.mem_modFormCharSpace_iff_slash_eq_smul
      {N : ℕ} (χ : (ZMod N)ˣ →* ℂˣ) {k : ℤ}
      {f :
        ModularForm
          (Subgroup.map
            (Matrix.SpecialLinearGroup.mapGL
              ℝ)
            (CongruenceSubgroup.Gamma1 N))
          k} :
      f ∈ modFormCharSpace k χ ↔
        ∀
          (γ :
            ↥(Subgroup.map
                (Matrix.SpecialLinearGroup.mapGL
                  ℝ)
                (CongruenceSubgroup.Gamma0
                  N))),
          SlashAction.map k ↑γ ⇑f =
            ↑((CongruenceSubgroup.nebentypusMultiplier
                    χ)
                  γ) •
              ⇑f
    **The nebentypus law is the law of the nebentypus multiplier**: a modular form for `Γ₁(N)`
    lies in Tau Ceti's `M_k(Γ₁(N), χ)` exactly when `f ∣[k] γ = v(γ) f` for every `γ ∈ Γ₀(N)`, where
    `v` is the nebentypus multiplier of `χ`. 
Definition3.6.22
Statement uses 7
Statement dependency previews
Preview
Definition 2.3
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 2
Reverse dependency previews
Preview
Definition 3.6.7
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Quasi-modular form. (LMFDB)

A quasi-modular form of weight k and multiplier system v for a fuchsian group G is a function f from \mathfrak{H} to \mathbb{C} which is holomorphic and satisfies a certain growth condition and, for any \gamma=\left(\begin{matrix}a&b\\c&d\end{matrix}\right)\in G and z\in\mathfrak{H}, we have:

(f|_k\gamma)(z)=v(\gamma)P\left(z,\frac{c}{cz+d}\right),

where P is a polynomial in two variables whose coefficients depend only on f and not on \gamma and f|_k\gamma is the weight k slash-action. The *degree* of P is called the *depth* of f.

An example of a quasi-modular form is the Eisenstein series E_2(z)=1-24\sum_{n\geq1}\sigma_1(n)q^n, where q=e^{2\pi iz} and \sigma_1 is a divisor function. It has weight 2 and depth 1 on \Gamma and it has the following transformation property:

E_2(\gamma z)=(cz+d)^2E_2(z)-\frac{6i}{\pi}c(cz+d).

Tau Ceti Review: EisensteinSeries.E2.

Depends on: Definition 2.3 Definition 3.1.101 Definition 8.3.51 Definition 8.3.141 Definition 3.6.21 Definition 3.6.25 Definition 3.6.27

Lean code for Definition3.6.22●8 declarations
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/QuasiModular.lean
    complete
    def ModularForm.IsQuasiModularForm (Γ : Subgroup (GL (Fin 2) ℝ)) (k : ℤ)
      (p : ℕ) (v : ↥Γ →* Circle) (f : UpperHalfPlane → ℂ) : Prop
    def ModularForm.IsQuasiModularForm
      (Γ : Subgroup (GL (Fin 2) ℝ)) (k : ℤ)
      (p : ℕ) (v : ↥Γ →* Circle)
      (f : UpperHalfPlane → ℂ) : Prop
    A function `f : ℍ → ℂ` is a **quasi-modular form** (LMFDB `mf.quasi_modular`) of weight `k`,
    depth at most `p` and multiplier `v : Γ → S¹` on a subgroup `Γ` of `GL(2, ℝ)` if it is holomorphic,
    bounded at every cusp of `Γ` (the growth condition), and there are holomorphic `f_0, …, f_p` such
    that `(f ∣[k] γ)(z) = v(γ) P(z, c / (cz + d))` for every `γ = (a, b; c, d) ∈ Γ`, where
    `P(z, X) = Σ_j f_j(z) X^j`. The LMFDB's polynomial `P` "whose coefficients depend only on `f`" is
    read as a polynomial in `X` whose coefficients are holomorphic functions of `z`, as in
    Kaneko–Zagier; the depth is its degree in `X` (`HasQuasiModularDepth`). 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/QuasiModular.lean
    complete
    def ModularForm.HasQuasiModularDepth (Γ : Subgroup (GL (Fin 2) ℝ)) (k : ℤ)
      (p : ℕ) (v : ↥Γ →* Circle) (f : UpperHalfPlane → ℂ) : Prop
    def ModularForm.HasQuasiModularDepth
      (Γ : Subgroup (GL (Fin 2) ℝ)) (k : ℤ)
      (p : ℕ) (v : ↥Γ →* Circle)
      (f : UpperHalfPlane → ℂ) : Prop
    A quasi-modular form `f` of weight `k` and multiplier `v` **has depth** `p` (LMFDB
    `mf.quasi_modular`) if `p` is the least degree of a polynomial `P` in its transformation law. 
  • defdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/QuasiModular.lean
    complete
    def ModularForm.quasiModularPolynomial (p : ℕ)
      (F : Fin (p + 1) → UpperHalfPlane → ℂ) (γ : GL (Fin 2) ℝ)
      (z : UpperHalfPlane) : ℂ
    def ModularForm.quasiModularPolynomial (p : ℕ)
      (F : Fin (p + 1) → UpperHalfPlane → ℂ)
      (γ : GL (Fin 2) ℝ)
      (z : UpperHalfPlane) : ℂ
    The value `P(z, c / (cz + d)) = Σ_{j ≤ p} f_j(z) (c / (cz + d))^j` at `z` of the polynomial
    `P(z, X) = Σ_j f_j(z) X^j` with coefficients `F = (f_0, …, f_p)`, for `γ = (a, b; c, d)`. 
  • defdefined in Mathlib/NumberTheory/ModularForms/EisensteinSeries/E2/Defs.lean
    complete
    def EisensteinSeries.E2 : UpperHalfPlane → ℂ
    def EisensteinSeries.E2 : UpperHalfPlane → ℂ
    The normalised Eisenstein series of weight `2` and level `1`.
    Defined as `(1 / 2 * ζ(2)) * G2 `. 
  • theoremdefined in Mathlib/NumberTheory/ModularForms/EisensteinSeries/E2/Summable.lean
    complete
    theorem EisensteinSeries.E2_eq_tsum_cexp (z : UpperHalfPlane) :
      EisensteinSeries.E2 z =
        1 -
          24 *
            ∑' (n : ℕ+),
              ↑((ArithmeticFunction.sigma 1) ↑n) *
                Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ ↑n
    theorem EisensteinSeries.E2_eq_tsum_cexp
      (z : UpperHalfPlane) :
      EisensteinSeries.E2 z =
        1 -
          24 *
            ∑' (n : ℕ+),
              ↑((ArithmeticFunction.sigma 1)
                    ↑n) *
                Complex.exp
                    (2 * ↑Real.pi *
                        Complex.I *
                      ↑z) ^
                  ↑n
    The q-expansion of the normalised weight-2 Eisenstein series:
    `E₂(z) = 1 - 24 ∑_{n≥1} σ₁(n) qⁿ`. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/QuasiModular.lean
    complete
    theorem ModularForm.isQuasiModularForm_E2 :
      ModularForm.IsQuasiModularForm
        (Matrix.SpecialLinearGroup.mapGL ℝ).range 2 1 1 EisensteinSeries.E2
    theorem ModularForm.isQuasiModularForm_E2 :
      ModularForm.IsQuasiModularForm
        (Matrix.SpecialLinearGroup.mapGL
            ℝ).range
        2 1 1 EisensteinSeries.E2
    **`E₂` is quasi-modular** of weight `2` and depth at most `1` on `SL(2, ℤ)`, with trivial
    multiplier and `P(z, X) = E₂(z) - (6i/π) X` (written `E₂(z) - (2πi / 2ζ(2)) X`). 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/QuasiModularDepth.lean
    complete
    theorem ModularForm.hasQuasiModularDepth_E2 :
      ModularForm.HasQuasiModularDepth
        (Matrix.SpecialLinearGroup.mapGL ℝ).range 2 1 1 EisensteinSeries.E2
    theorem ModularForm.hasQuasiModularDepth_E2 :
      ModularForm.HasQuasiModularDepth
        (Matrix.SpecialLinearGroup.mapGL
            ℝ).range
        2 1 1 EisensteinSeries.E2
    **`E₂` has depth `1`** (LMFDB `mf.quasi_modular`): it is quasi-modular of weight `2` and depth
    `1` on `SL(2, ℤ)`, with trivial multiplier. 
  • theoremdefined in LeanBridge/ForMathlib/NumberTheory/ModularForms/Multiplier/QuasiModularDepth.lean
    complete
    theorem ModularForm.E2_smul (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ)
      (z : UpperHalfPlane) :
      EisensteinSeries.E2 (γ • z) =
        UpperHalfPlane.denom
                (Matrix.SpecialLinearGroup.toGL
                  ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) γ))
                ↑z ^
              2 *
            EisensteinSeries.E2 z -
          6 * Complex.I / ↑Real.pi * ↑(↑γ 1 0) *
            UpperHalfPlane.denom
              (Matrix.SpecialLinearGroup.toGL
                ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) γ))
              ↑z
    theorem ModularForm.E2_smul
      (γ :
        Matrix.SpecialLinearGroup (Fin 2) ℤ)
      (z : UpperHalfPlane) :
      EisensteinSeries.E2 (γ • z) =
        UpperHalfPlane.denom
                (Matrix.SpecialLinearGroup.toGL
                  ((Matrix.SpecialLinearGroup.map
                      (Int.castRingHom ℝ))
                    γ))
                ↑z ^
              2 *
            EisensteinSeries.E2 z -
          6 * Complex.I / ↑Real.pi *
              ↑(↑γ 1 0) *
            UpperHalfPlane.denom
              (Matrix.SpecialLinearGroup.toGL
                ((Matrix.SpecialLinearGroup.map
                    (Int.castRingHom ℝ))
                  γ))
              ↑z
    **The transformation law of `E₂`** (LMFDB `mf.quasi_modular`): for `γ = (a, b; c, d)` in
    `SL(2, ℤ)`, `E₂(γz) = (cz + d)² E₂(z) - (6i/π) c (cz + d)`. 
Definition3.6.23
uses 0used by 1✓L∃∀N

The group \Gamma_0(N) is the subgroup of \textrm{SL}(2,\mathbb{Z}) that consists of matrices that become upper triangular when reduced modulo N. That is,

\Gamma_0(N) = \left\lbrace \left .\begin{pmatrix} a & b \\ c & d \end{pmatrix}\in \textrm{SL}(2,\mathbb{Z})\ \right|\ c\equiv 0\pmod N \right\rbrace.

Tau Ceti Review: CongruenceSubgroup.Gamma0, CongruenceSubgroup.Gamma0_mem.

Lean code for Definition3.6.23●2 declarations
  • defdefined in Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
    complete
    def CongruenceSubgroup.Gamma0 (N : ℕ) :
      Subgroup (Matrix.SpecialLinearGroup (Fin 2) ℤ)
    def CongruenceSubgroup.Gamma0 (N : ℕ) :
      Subgroup
        (Matrix.SpecialLinearGroup (Fin 2) ℤ)
    The congruence subgroup of `SL(2, ℤ)` of matrices whose lower left-hand entry reduces to zero
    modulo `N`. 
  • theoremdefined in Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
    complete
    theorem CongruenceSubgroup.Gamma0_mem {N : ℕ}
      {A : Matrix.SpecialLinearGroup (Fin 2) ℤ} :
      A ∈ CongruenceSubgroup.Gamma0 N ↔ ↑(↑A 1 0) = 0
    theorem CongruenceSubgroup.Gamma0_mem {N : ℕ}
      {A :
        Matrix.SpecialLinearGroup (Fin 2) ℤ} :
      A ∈ CongruenceSubgroup.Gamma0 N ↔
        ↑(↑A 1 0) = 0
Definition3.6.24
uses 0used by 0✓L∃∀N

The group \Gamma_1(N) is the subgroup of \textrm{SL}(2,\mathbb{Z}) that consists of matrices that become upper triangular with ones on the diagonal when reduced modulo N. That is,

\Gamma_1(N) = \left\lbrace \left .\begin{pmatrix} a & b \\ c & d \end{pmatrix}\in \textrm{SL}(2,\mathbb{Z})\ \right|\ a\equiv 1,\ c\equiv 0,\ d\equiv 1\pmod N \right\rbrace.

Tau Ceti Review: CongruenceSubgroup.Gamma1, CongruenceSubgroup.Gamma1_mem.

Lean code for Definition3.6.24●2 declarations
  • defdefined in Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
    complete
    def CongruenceSubgroup.Gamma1 (N : ℕ) :
      Subgroup (Matrix.SpecialLinearGroup (Fin 2) ℤ)
    def CongruenceSubgroup.Gamma1 (N : ℕ) :
      Subgroup
        (Matrix.SpecialLinearGroup (Fin 2) ℤ)
    The congruence subgroup `Gamma1` of `SL(2, ℤ)` consisting of matrices
    whose bottom row is congruent to `(0,1)` modulo `N`. 
  • theoremdefined in Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
    complete
    theorem CongruenceSubgroup.Gamma1_mem (N : ℕ)
      (A : Matrix.SpecialLinearGroup (Fin 2) ℤ) :
      A ∈ CongruenceSubgroup.Gamma1 N ↔
        ↑(↑A 0 0) = 1 ∧ ↑(↑A 1 1) = 1 ∧ ↑(↑A 1 0) = 0
    theorem CongruenceSubgroup.Gamma1_mem (N : ℕ)
      (A :
        Matrix.SpecialLinearGroup (Fin 2) ℤ) :
      A ∈ CongruenceSubgroup.Gamma1 N ↔
        ↑(↑A 0 0) = 1 ∧
          ↑(↑A 1 1) = 1 ∧ ↑(↑A 1 0) = 0
Definition3.6.25
Statement uses 3
Statement dependency previews
Preview
Definition 3.6.2
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 3
Reverse dependency previews
Preview
Definition 3.2.4
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Weight k slash-action. (LMFDB)

Let f be a function from \mathcal{H} to \mathbb{C}. We define the weight k slash-action f|_k\gamma to be the action of \gamma=\left(\begin{matrix}a&b\\c&d\end{matrix}\right)\in\textrm{SL}_2(\mathbb{R}) given by

f|_k\gamma(z)=\det(\gamma)^{k/2}(cz+d)^{-k}f(\gamma z).

Note that, if f is a modular form with multiplier system v, the modularity condition is equivalent to

f|_k\gamma(z)=v(\gamma)f(z).

Tau Ceti Review: SlashAction, ModularForm.slash_def.

Depends on: Definition 3.6.2 Definition 3.6.21 Definition 3.6.27

Lean code for Definition3.6.25●2 declarations
  • class(5 methods)defined in Mathlib/NumberTheory/ModularForms/SlashActions.lean
    complete
    class SlashAction.{u_1, u_2, u_3} (β : Type u_1) (G : Type u_2) (α : Type u_3)
      [Monoid G] [AddMonoid α] : Type (max (max u_1 u_2) u_3)
    class SlashAction.{u_1, u_2, u_3} (β : Type u_1)
      (G : Type u_2) (α : Type u_3) [Monoid G]
      [AddMonoid α] :
      Type (max (max u_1 u_2) u_3)
    A general version of the slash action of the space of modular forms. This is the same data as a
    family of `DistribMulAction Gᵒᵖ α` indexed by `k`. 
    map : β → G → α → α
    zero_slash : ∀ (k : β) (g : G), SlashAction.map k g 0 = 0
    slash_one : ∀ (k : β) (a : α), SlashAction.map k 1 a = a
    slash_mul : ∀ (k : β) (g h : G) (a : α), SlashAction.map k (g * h) a = SlashAction.map k h (SlashAction.map k g a)
    add_slash : ∀ (k : β) (g : G) (a b : α), SlashAction.map k g (a + b) = SlashAction.map k g a + SlashAction.map k g b
  • theoremdefined in Mathlib/NumberTheory/ModularForms/SlashActions.lean
    complete
    theorem ModularForm.slash_def {k : ℤ} (f : UpperHalfPlane → ℂ)
      (g : GL (Fin 2) ℝ) :
      SlashAction.map k g f = fun τ =>
        (UpperHalfPlane.σ g) (f (g • τ)) *
            ↑|↑(Matrix.GeneralLinearGroup.det g)| ^ (k - 1) *
          UpperHalfPlane.denom g ↑τ ^ (-k)
    theorem ModularForm.slash_def {k : ℤ}
      (f : UpperHalfPlane → ℂ)
      (g : GL (Fin 2) ℝ) :
      SlashAction.map k g f = fun τ =>
        (UpperHalfPlane.σ g) (f (g • τ)) *
            ↑|↑(Matrix.GeneralLinearGroup.det
                      g)| ^
              (k - 1) *
          UpperHalfPlane.denom g ↑τ ^ (-k)
Definition3.6.26
Statement uses 4
Statement dependency previews
Preview
Definition 3.6.2
Loading preview
Statement dependency preview content is loaded from the rendered-fragment cache.
Used by 6
Reverse dependency previews
Preview
Definition 3.6.6
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
XL∃∀N

Transformation property for modular forms. (LMFDB)

A modular form f satisfies a transformation property for a group \Gamma, which relates the value of f at a point in its domain with the value of f at the point transformed under the action of \Gamma on the domain.

For example in the classical case of \Gamma = \SL(2,\Z), a modular form f:\mathcal{H}\rightarrow\C satisfies the transformation

f(\gamma z) = f\left(\frac{az+b}{cz+d}\right)= v(\gamma)(cz+d)^kf(z),

for all z\in\mathcal{H}, \gamma=\left(\begin{array}{ll}a&b\\c&d\end{array}\right)\in\SL_2(\Z) and multiplier system v.

Depends on: Definition 8.3.141 Definition 3.6.2 Definition 3.6.21 Definition 3.6.27

Definition3.6.27
uses 1
Used by 15
Reverse dependency previews
Preview
Definition 1.1.13
Loading preview
Reverse dependency preview content is loaded from the rendered-fragment cache.
✓L∃∀N

Upper half-plane. (LMFDB)

The upper half-plane \mathcal{H} is the set of complex numbers whose imaginary part is positive, endowed with the topology induced from \C.

The completed upper half-plane \mathcal{H}^* is

\mathcal{H} \cup \Q \cup \{ \infty\},

endowed with the topology such that the disks tangent to the real line at r \in \Q form a fundamental system of neighbourhoods of r, and strips \{ z \in \mathcal{H} \mid \operatorname{Im} z > y \} \cup \{ \infty\}, y>0, form a fundamental system of neighbourhoods of \infty, which should therefore be thought of as i \infty.

The modular group \SL_2(\Z) acts properly discontinuously on \mathcal{H} and \mathcal{H}^* by the formula

\left( \begin{matrix} a & b \\ c& d \end{matrix} \right) \cdot z = \frac{az+b}{cz+d},

with the obvious conventions regarding \infty.

Tau Ceti Review: UpperHalfPlane.

Depends on: Definition 8.3.141

Lean code for Definition3.6.27●5 declarations
  • inductive(2 constructors)defined in LeanBridge/ForMathlib/Analysis/Complex/UpperHalfPlane/Completed.lean
    complete
    inductive UpperHalfPlane.Completed : Type
    inductive UpperHalfPlane.Completed : Type
    The **completed upper half-plane** `ℍ* = ℍ ∪ ℚ ∪ {∞}` (LMFDB `mf.upper_half_plane`): the points
    of the upper half-plane `ℍ` together with the cusps, the points of `ℚ ∪ {∞} = OnePoint ℚ`. Its
    topology (`hasBasis_nhds_infty`, `hasBasis_nhds_ratCast`, `isOpenEmbedding_ofUpperHalfPlane`) and
    its action of `SL₂(ℤ)` (`smul_ofUpperHalfPlane`, `smul_cusp`) are those of the LMFDB. 
    UpperHalfPlane.Completed.ofUpperHalfPlane
      (z : UpperHalfPlane) : UpperHalfPlane.Completed
    A point of the upper half-plane. 
    UpperHalfPlane.Completed.cusp (c : OnePoint ℚ) :
      UpperHalfPlane.Completed
    A cusp: a rational number or `∞`. 
  • theoremdefined in LeanBridge/ForMathlib/Analysis/Complex/UpperHalfPlane/Completed.lean
    complete
    theorem UpperHalfPlane.Completed.hasBasis_nhds_ratCast (r : ℚ) :
      (nhds (UpperHalfPlane.Completed.cusp ↑r)).HasBasis (fun ρ => 0 < ρ)
        fun ρ =>
        insert (UpperHalfPlane.Completed.cusp ↑r)
          (UpperHalfPlane.Completed.ofUpperHalfPlane ''
            {z | dist (↑z) (↑r + ↑ρ * Complex.I) < ρ})
    theorem UpperHalfPlane.Completed.hasBasis_nhds_ratCast
      (r : ℚ) :
      (nhds
            (UpperHalfPlane.Completed.cusp
              ↑r)).HasBasis
        (fun ρ => 0 < ρ) fun ρ =>
        insert
          (UpperHalfPlane.Completed.cusp ↑r)
          (UpperHalfPlane.Completed.ofUpperHalfPlane ''
            {z |
              dist (↑z)
                  (↑r + ↑ρ * Complex.I) <
                ρ})
    **The tangent disks form a fundamental system of neighbourhoods of `r ∈ ℚ`**: the sets
    `D ∪ {r}`, for `D` the open disks tangent to the real line at `r`, of centre `r + iρ` and
    radius `ρ > 0`. 
  • theoremdefined in LeanBridge/ForMathlib/Analysis/Complex/UpperHalfPlane/Completed.lean
    complete
    theorem UpperHalfPlane.Completed.hasBasis_nhds_infty :
      (nhds (UpperHalfPlane.Completed.cusp OnePoint.infty)).HasBasis
        (fun y => 0 < y) fun y =>
        insert (UpperHalfPlane.Completed.cusp OnePoint.infty)
          (UpperHalfPlane.Completed.ofUpperHalfPlane '' {z | y < z.im})
    theorem UpperHalfPlane.Completed.hasBasis_nhds_infty :
      (nhds
            (UpperHalfPlane.Completed.cusp
              OnePoint.infty)).HasBasis
        (fun y => 0 < y) fun y =>
        insert
          (UpperHalfPlane.Completed.cusp
            OnePoint.infty)
          (UpperHalfPlane.Completed.ofUpperHalfPlane ''
            {z | y < z.im})
    **The strips form a fundamental system of neighbourhoods of `∞`**: the sets
    `{z | Im z > y} ∪ {∞}`, `y > 0`. 
  • theoremdefined in LeanBridge/ForMathlib/Analysis/Complex/UpperHalfPlane/Completed.lean
    complete
    theorem UpperHalfPlane.Completed.smul_cusp
      (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ) (c : OnePoint ℚ) :
      γ • UpperHalfPlane.Completed.cusp c =
        UpperHalfPlane.Completed.cusp
          ((Matrix.SpecialLinearGroup.mapGL ℚ) γ • c)
    theorem UpperHalfPlane.Completed.smul_cusp
      (γ :
        Matrix.SpecialLinearGroup (Fin 2) ℤ)
      (c : OnePoint ℚ) :
      γ • UpperHalfPlane.Completed.cusp c =
        UpperHalfPlane.Completed.cusp
          ((Matrix.SpecialLinearGroup.mapGL ℚ)
              γ •
            c)
  • structure(2 fields)defined in Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
    complete
    structure UpperHalfPlane : Type
    structure UpperHalfPlane : Type
    The open upper half plane, denoted as `ℍ` within the `UpperHalfPlane` namespace 
    coe : ℂ
    Canonical embedding of the upper half-plane into `ℂ`. 
    coe_im_pos : 0 < (↑self).im