Documentation

LeanPool.FLTEichlerShimura.Definitions.Def_ModularForm_HeckeOperator

Hecke operators Tp​, Up​ on functions on the upper half-plane #

Definition: ModularForm_HeckeOperator (e1cf8d29-c1f1-569b-9fbd-05f00ec56b83), by Claude, 2026-09-05.

The module sets up the weight-$k$ Hecke operators $T_p$ and $U_p$ as operators on arbitrary functions $f\colon\mathbb H\to\mathbb C$, using Mathlib's weight-$k$ slash action of $\mathrm{GL}_2(\mathbb R)$ (normalisation $|\det\gamma|^{k-1}\,\mathrm{denom}(\gamma,\tau)^{-k}$). First come the matrices: upperTriangularGL a b d is $\begin{pmatrix}a&b\\0&d\end{pmatrix}$ as an element of $\mathrm{GL}_2(\mathbb R)$, given $ad\neq 0$; heckeMatrix p j is $\begin{pmatrix}1&j\\0&p\end{pmatrix}$ and heckeDiagMatrix p is $\begin{pmatrix}p&0\\0&1\end{pmatrix}$, both defined for all natural $p$ with the junk value $1$ at $p=0$ so as to be total. Accompanying lemmas record their entries, that both determinants equal $p$ and are positive, the values of UpperHalfPlane.denom ($p$, resp. $1$), the Möbius actions $\tau\mapsto(\tau+j)/p$ and $\tau\mapsto p\tau$, the triviality of the conjugation $\sigma$ attached to a positive determinant, and hence the pointwise slash formulas $(f\mid_k \texttt{heckeMatrix\ p\ j})(\tau)=p^{-1}f((\tau+j)/p)$ and $(f\mid_k\texttt{heckeDiagMatrix\ p})(\tau)=p^{k-1}f(p\tau)$ for $p\neq 0$.

Then heckeU k p f $=\sum_{j<p} f\mid_k\begin{pmatrix}1&j\\0&p\end{pmatrix}$ and heckeT k p f $=$ heckeU k p f $+\,f\mid_k\begin{pmatrix}p&0\\0&1\end{pmatrix}$, with the pointwise formulas $(U_pf)(\tau)=p^{-1}\sum_{j<p}f((\tau+j)/p)$ and $(T_pf)(\tau)=(U_pf)(\tau)+p^{k-1}f(p\tau)$ for $p\neq 0$, the degenerate values heckeU k 0 f = 0 and heckeT k 0 f = f, and additivity, $\mathbb C$-homogeneity, compatibility with negation and subtraction. Note that $p$ is an arbitrary natural number here: nothing in these definitions requires $p$ prime or imposes any modularity or growth condition on $f$.

Finally the same operators are given on the coefficient side, as operators on sequences $a\colon\mathbb N\to\mathbb C$: coeffHeckeU p a n = a (n * p) and `coeffHeckeT k p a n = a (n * p)

Relation to Mathlib. Mathlib supplies the upper half-plane, its $\mathrm{GL}_2(\mathbb R)$-action with UpperHalfPlane.denom, UpperHalfPlane.σ and the weight-$k$ slash action; the Hecke matrices and the operators $T_p$, $U_p$ built from them, together with their coefficient-side counterparts, are the project's own.

Where it is used. These operators are the input to the notion of a normalised Hecke eigenform used throughout the modularity part of the argument; the coefficient-side versions coeffHeckeT and coeffHeckeU allow eigenform conditions on $q$-expansion coefficients to be stated without analysis. Separate modules prove that $T_p$ and $U_p$ preserve the spaces of modular and cusp forms for $\Gamma_0(N)$ and relate the two descriptions.

<!-- Generated by add_prove2me_provenance.py -->

noncomputable def ModularForm.upperTriangularGL (a b d : ℝ) (had : a * d ≠ 0) :
GL (Fin 2) ℝ

The invertible upper-triangular matrix with entries a, b, 0, d.

Equations
Instances For
    @[simp]
    theorem ModularForm.val_upperTriangularGL (a b d : ℝ) (had : a * d ≠ 0) :
    ↑(upperTriangularGL a b d had) = !![a, b; 0, d]
    noncomputable def ModularForm.heckeMatrix (p j : ℕ) :
    GL (Fin 2) ℝ

    The Hecke matrix with rows (1, j) and (0, p); the identity when p = 0.

    Equations
    Instances For
      noncomputable def ModularForm.heckeDiagMatrix (p : ℕ) :
      GL (Fin 2) ℝ

      The diagonal Hecke matrix with entries p, 1; the identity when p = 0.

      Equations
      Instances For
        @[simp]
        theorem ModularForm.val_heckeMatrix {p : ℕ} (hp : p ≠ 0) (j : ℕ) :
        ↑(heckeMatrix p j) = !![1, ↑j; 0, ↑p]
        @[simp]
        theorem ModularForm.val_heckeDiagMatrix {p : ℕ} (hp : p ≠ 0) :
        ↑(heckeDiagMatrix p) = !![↑p, 0; 0, 1]
        theorem ModularForm.denom_heckeMatrix {p : ℕ} (hp : p ≠ 0) (j : ℕ) (τ : UpperHalfPlane) :
        theorem ModularForm.coe_heckeMatrix_smul {p : ℕ} (hp : p ≠ 0) (j : ℕ) (τ : UpperHalfPlane) :
        ↑(heckeMatrix p j • τ) = (↑τ + ↑j) / ↑p
        theorem ModularForm.coe_heckeDiagMatrix_smul {p : ℕ} (hp : p ≠ 0) (τ : UpperHalfPlane) :
        ↑(heckeDiagMatrix p • τ) = ↑p * ↑τ
        theorem ModularForm.slash_heckeMatrix_apply (k : ℤ) {p : ℕ} (hp : p ≠ 0) (j : ℕ) (f : UpperHalfPlane → ℂ) (τ : UpperHalfPlane) :
        SlashAction.map k (heckeMatrix p j) f τ = (↑p)⁻¹ * f (heckeMatrix p j • τ)
        theorem ModularForm.slash_heckeDiagMatrix_apply (k : ℤ) {p : ℕ} (hp : p ≠ 0) (f : UpperHalfPlane → ℂ) (τ : UpperHalfPlane) :
        SlashAction.map k (heckeDiagMatrix p) f τ = ↑p ^ (k - 1) * f (heckeDiagMatrix p • τ)
        noncomputable def ModularForm.heckeU (k : ℤ) (p : ℕ) (f : UpperHalfPlane → ℂ) :

        The unnormalized U-operator, summing weight-k slash actions over the matrices heckeMatrix p j.

        Equations
        Instances For
          noncomputable def ModularForm.heckeT (k : ℤ) (p : ℕ) (f : UpperHalfPlane → ℂ) :

          The unnormalized T-operator, adding the slash action of diag(p, 1) to heckeU.

          Equations
          Instances For
            theorem ModularForm.heckeU_def (k : ℤ) (p : ℕ) (f : UpperHalfPlane → ℂ) :
            heckeU k p f = ∑ j ∈ Finset.range p, SlashAction.map k (heckeMatrix p j) f
            @[simp]
            theorem ModularForm.heckeU_zero_left (k : ℤ) (f : UpperHalfPlane → ℂ) :
            heckeU k 0 f = 0
            @[simp]
            theorem ModularForm.heckeT_zero_left (k : ℤ) (f : UpperHalfPlane → ℂ) :
            heckeT k 0 f = f
            theorem ModularForm.heckeU_apply (k : ℤ) {p : ℕ} (hp : p ≠ 0) (f : UpperHalfPlane → ℂ) (τ : UpperHalfPlane) :
            heckeU k p f τ = (↑p)⁻¹ * ∑ j ∈ Finset.range p, f (heckeMatrix p j • τ)
            theorem ModularForm.heckeT_apply (k : ℤ) {p : ℕ} (hp : p ≠ 0) (f : UpperHalfPlane → ℂ) (τ : UpperHalfPlane) :
            heckeT k p f τ = (↑p)⁻¹ * ∑ j ∈ Finset.range p, f (heckeMatrix p j • τ) + ↑p ^ (k - 1) * f (heckeDiagMatrix p • τ)
            @[simp]
            theorem ModularForm.heckeU_zero (k : ℤ) (p : ℕ) :
            heckeU k p 0 = 0
            @[simp]
            theorem ModularForm.heckeT_zero (k : ℤ) (p : ℕ) :
            heckeT k p 0 = 0
            theorem ModularForm.heckeU_add (k : ℤ) (p : ℕ) (f g : UpperHalfPlane → ℂ) :
            heckeU k p (f + g) = heckeU k p f + heckeU k p g
            theorem ModularForm.heckeT_add (k : ℤ) (p : ℕ) (f g : UpperHalfPlane → ℂ) :
            heckeT k p (f + g) = heckeT k p f + heckeT k p g
            theorem ModularForm.heckeU_smul (k : ℤ) (p : ℕ) (c : ℂ) (f : UpperHalfPlane → ℂ) :
            heckeU k p (c • f) = c • heckeU k p f
            theorem ModularForm.heckeT_smul (k : ℤ) (p : ℕ) (c : ℂ) (f : UpperHalfPlane → ℂ) :
            heckeT k p (c • f) = c • heckeT k p f
            theorem ModularForm.heckeU_neg (k : ℤ) (p : ℕ) (f : UpperHalfPlane → ℂ) :
            heckeU k p (-f) = -heckeU k p f
            theorem ModularForm.heckeT_neg (k : ℤ) (p : ℕ) (f : UpperHalfPlane → ℂ) :
            heckeT k p (-f) = -heckeT k p f
            theorem ModularForm.heckeU_sub (k : ℤ) (p : ℕ) (f g : UpperHalfPlane → ℂ) :
            heckeU k p (f - g) = heckeU k p f - heckeU k p g
            theorem ModularForm.heckeT_sub (k : ℤ) (p : ℕ) (f g : UpperHalfPlane → ℂ) :
            heckeT k p (f - g) = heckeT k p f - heckeT k p g
            noncomputable def ModularForm.coeffHeckeT (k : ℤ) (p : ℕ) (a : ℕ → ℂ) (n : ℕ) :

            The coefficient transformation a(n * p) + p^(k - 1) * a(n / p), with the second term only when p ∣ n.

            Equations
            Instances For
              def ModularForm.coeffHeckeU (p : ℕ) (a : ℕ → ℂ) (n : ℕ) :

              The coefficient transformation sending a(n) to a(n * p).

              Equations
              Instances For
                theorem ModularForm.coeffHeckeT_apply (k : ℤ) (p : ℕ) (a : ℕ → ℂ) (n : ℕ) :
                coeffHeckeT k p a n = a (n * p) + if p ∣ n then ↑p ^ (k - 1) * a (n / p) else 0
                theorem ModularForm.coeffHeckeU_apply (p : ℕ) (a : ℕ → ℂ) (n : ℕ) :
                coeffHeckeU p a n = a (n * p)
                theorem ModularForm.coeffHeckeT_of_dvd (k : ℤ) {p n : ℕ} (h : p ∣ n) (a : ℕ → ℂ) :
                coeffHeckeT k p a n = a (n * p) + ↑p ^ (k - 1) * a (n / p)
                theorem ModularForm.coeffHeckeT_of_not_dvd (k : ℤ) {p n : ℕ} (h : ¬p ∣ n) (a : ℕ → ℂ) :
                coeffHeckeT k p a n = a (n * p)
                theorem ModularForm.coeffHeckeT_eq_coeffHeckeU_add (k : ℤ) (p : ℕ) (a : ℕ → ℂ) (n : ℕ) :
                coeffHeckeT k p a n = coeffHeckeU p a n + if p ∣ n then ↑p ^ (k - 1) * a (n / p) else 0
                theorem ModularForm.coeffHeckeT_add (k : ℤ) (p : ℕ) (a b : ℕ → ℂ) :
                coeffHeckeT k p (a + b) = coeffHeckeT k p a + coeffHeckeT k p b
                theorem ModularForm.coeffHeckeT_smul (k : ℤ) (p : ℕ) (c : ℂ) (a : ℕ → ℂ) :
                coeffHeckeT k p (c • a) = c • coeffHeckeT k p a
                theorem ModularForm.coeffHeckeU_add (p : ℕ) (a b : ℕ → ℂ) :
                theorem ModularForm.coeffHeckeU_smul (p : ℕ) (c : ℂ) (a : ℕ → ℂ) :