Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

The specific eigenform attached to a modular elliptic curve at its least modular level

Definition
KN_EllipticCurveAttachedEigenform

by davidloeffler · Oct 8, 2026 · Mathlib 0df444a (Lean v4.33.1)

elliptic-curvesmodular-formsnonvanishingnumber-theory

Let E be a modular elliptic curve over the rationals and fix a complex embedding of the algebraic closure of the rationals. This construction upgrades the chosen weight-two cusp form at the least modular level to an eigenform on Γ₁, with trivial nebentype and with nth algebraic Fourier coefficient equal to the integer E.LFunction(n).

Unlike an existential specialization, it exposes a specific form and its coefficient identities, so that arithmetic compatibility can be stated and proved for that same form.

Definition code
import Definitions.Def_KN_HorizontalPadicLAux
import Definitions.Def_FLTPrelim_Modularity
import Theorems.Thm_MTT_hasSum_heckePrime
import Theorems.Thm_HorizontalPadicL_ellipticCurve_attachedForm_isNormalizedEigenform

set_option autoImplicit false
noncomputable section

open scoped ModularForm

namespace HorizontalPadicL

def gammaZeroToGammaOne {N : ℕ} (hN : 0 < N)
    (f : CuspFormAtLevel N hN) : CuspForm (MTT.GammaOne N) 2 where
  toFun := f
  slash_action_eq' := fun A hA =>
    f.slash_action_eq' A (Subgroup.map_mono (CongruenceSubgroup.Gamma1_in_Gamma0 N) hA)
  holo' := f.holo'
  zero_at_cusps' hc := by
    let : NeZero N := ⟨Nat.ne_of_gt hN⟩
    apply f.zero_at_cusps'
    rw [Subgroup.IsArithmetic.isCusp_iff_isCusp_SL2Z]
    rwa [Subgroup.IsArithmetic.isCusp_iff_isCusp_SL2Z] at hc

@[simp] theorem gammaZeroToGammaOne_apply {N : ℕ} (hN : 0 < N)
    (f : CuspFormAtLevel N hN) (z : UpperHalfPlane) :
    gammaZeroToGammaOne hN f z = f z := rfl

lemma normalizedEigenform_hecke_recurrence {N : ℕ} {hN : 0 < N}
    {f : CuspFormAtLevel N hN} (hf : f.IsNormalizedEigenform)
    (p n : ℕ) (hp : p.Prime) :
    ModularFormClass.qCoeff f (p * n) +
        (if p ∣ N then 0 else (p : ℂ)) *
          (if p ∣ n then ModularFormClass.qCoeff f (n / p) else 0) =
      ModularFormClass.qCoeff f p * ModularFormClass.qCoeff f n := by
  by_cases hn0 : n = 0
  · subst n
    have ha0 : ModularFormClass.qCoeff f 0 = 0 := by
      simpa [ModularFormClass.qCoeff, CongruenceSubgroup.strictPeriods_Gamma0] using
        (CuspFormClass.qExpansion_coeff_zero f one_pos
          (show (1 : ℝ) ∈
            (CongruenceSubgroup.Gamma0 N : Subgroup (GL (Fin 2) ℝ)).strictPeriods by simp))
    simp [ha0]
  · obtain ⟨r, m, hpm, rfl⟩ := Nat.exists_eq_pow_mul_and_not_dvd hn0 p hp.ne_one
    have hc : (p ^ r).Coprime m := (hp.coprime_iff_not_dvd.mpr hpm).pow_left r
    have hc1 : (p ^ (r + 1)).Coprime m := (hp.coprime_iff_not_dvd.mpr hpm).pow_left (r + 1)
    have hc2 : (p ^ (r + 2)).Coprime m := (hp.coprime_iff_not_dvd.mpr hpm).pow_left (r + 2)
    rw [show p * (p ^ r * m) = p ^ (r + 1) * m by ring,
      hf.qCoeff_mul_of_coprime _ _ hc1,
      hf.qCoeff_mul_of_coprime _ _ hc]
    cases r with
    | zero =>
        simp [hf.qCoeff_one, hpm]
    | succ r =>
        have hdiv : p ∣ p ^ (r + 1) * m := ⟨p ^ r * m, by ring⟩
        rw [if_pos hdiv]
        have hquot : (p ^ (r + 1) * m) / p = p ^ r * m := by
          simp [pow_succ, hp.ne_zero, mul_assoc, mul_left_comm]
        rw [hquot]
        by_cases hpN : p ∣ N
        · rw [if_pos hpN]
          simp only [zero_mul, add_zero]
          rw [show r + 1 + 1 = r + 2 by omega]
          rw [hf.qCoeff_prime_pow_of_dvd p r hp hpN]
          ring
        · rw [if_neg hpN]
          rw [hf.qCoeff_mul_of_coprime _ _ ((hp.coprime_iff_not_dvd.mpr hpm).pow_left r)]
          rw [show r + 1 + 1 = r + 2 by omega]
          rw [hf.qCoeff_prime_pow_of_not_dvd p r hp hpN]
          ring

def attachedEigenformCandidate (E : WeierstrassCurve ℚ) [E.IsElliptic]
    (hmod : IsModular E) (hnormalized :
      CuspForm.IsNormalizedEigenform (modularFormAtConductor E hmod).form)
    (iota : MTT.Qbar →+* ℂ) :
    MTT.Eigenform (modularConductor E hmod) 2 iota where
  form := gammaZeroToGammaOne (modularConductor_pos E hmod)
    (modularFormAtConductor E hmod).form
  epsilon := 1
  coeff n := (E.LFunction n : MTT.Qbar)
  coeff_eq n := by
    change (UpperHalfPlane.qExpansion 1 (modularFormAtConductor E hmod).form).coeff n = _
    rw [← (modularFormAtConductor E hmod).coeff_eq n]
    simp
  normalized := by
    have hc : ((E.LFunction 1 : ℤ) : ℂ) = 1 := by
      simpa [ModularFormClass.qCoeff, ← (modularFormAtConductor E hmod).coeff_eq 1]
        using hnormalized.qCoeff_one
    exact_mod_cast hc
  character_law gamma z := by
    have hdet : ((gamma.val 0 0 : ℤ) : ZMod (modularConductor E hmod)) *
        (gamma.val 1 1 : ZMod (modularConductor E hmod)) = 1 := by
      have hd := congrArg (fun x : ℤ => (x : ZMod (modularConductor E hmod)))
        gamma.val.property
      rw [Matrix.det_fin_two] at hd
      simpa [CongruenceSubgroup.Gamma0_mem.mp gamma.property] using hd
    have hunit : IsUnit (gamma.val 1 1 : ZMod (modularConductor E hmod)) := by
      apply isUnit_iff_exists_inv.mpr
      exact ⟨(gamma.val 0 0 : ZMod (modularConductor E hmod)), by
        simpa [mul_comm] using hdet⟩
    have hone : (1 : DirichletCharacter MTT.Qbar (modularConductor E hmod))
        (gamma.val 1 1 : ZMod (modularConductor E hmod)) = 1 := by
      exact MulChar.one_apply hunit
    have h := (ModularForm.slash_action_eq'_iff 2
      (modularFormAtConductor E hmod).form gamma.val z).mp
        (congrFun ((modularFormAtConductor E hmod).form.slash_action_eq'
          (Matrix.SpecialLinearGroup.mapGL ℝ gamma.val) ⟨gamma.val, gamma.property, rfl⟩) z)
    simp only [hone, map_one, one_mul]
    convert h using 1 <;> rfl
  eigen p hp z := by
    let P := modularFormAtConductor E hmod
    let a : ℕ → ℂ := fun n => ModularFormClass.qCoeff P.form n
    have hper : Function.Periodic (P.form ∘ UpperHalfPlane.ofComplex) 1 := by
      simpa using SlashInvariantFormClass.periodic_comp_ofComplex P.form
        (show (1 : ℝ) ∈
          (CongruenceSubgroup.Gamma0 (modularConductor E hmod) :
            Subgroup (GL (Fin 2) ℝ)).strictPeriods by
          simp [CongruenceSubgroup.strictPeriods_Gamma0])
    have hsum : ∀ w : UpperHalfPlane,
        HasSum (fun n => a n • Function.Periodic.qParam (1 : ℝ) (w : ℂ) ^ n)
          (P.form w) := by
      intro w
      let : NeZero (modularConductor E hmod) :=
        ⟨Nat.ne_of_gt (modularConductor_pos E hmod)⟩
      exact UpperHalfPlane.hasSum_qExpansion one_pos hper P.form.holo'
        (CuspFormClass.zero_at_infty P.form).isBoundedAtImInfty w
    have heps : iota ((1 : DirichletCharacter MTT.Qbar (modularConductor E hmod)) p) =
        if p ∣ modularConductor E hmod then 0 else 1 := by
      by_cases hpN : p ∣ modularConductor E hmod
      · rw [if_pos hpN]
        have hnonunit : ¬ IsUnit (p : ZMod (modularConductor E hmod)) := by
          exact fun hunit => ((ZMod.isUnit_prime_iff_not_dvd hp).mp hunit) hpN
        change iota (MulChar.trivial (ZMod (modularConductor E hmod)) MTT.Qbar p) = 0
        simp [MulChar.trivial, hnonunit]
      · rw [if_neg hpN]
        have hunit : IsUnit (p : ZMod (modularConductor E hmod)) := by
          exact (ZMod.isUnit_prime_iff_not_dvd hp).mpr hpN
        simp [MulChar.one_apply hunit]
    have hhecke := MTT.hasSum_heckePrime 2
      (iota ((1 : DirichletCharacter MTT.Qbar (modularConductor E hmod)) p)) hp
      (P.form : UpperHalfPlane → ℂ) a z hsum
    have hscalar := (hsum z).const_smul (a p)
    rw [heps] at hhecke
    have hterms : ∀ n : ℕ,
        (a (p * n) + (if p ∣ modularConductor E hmod then 0 else 1) *
          (p : ℂ) ^ (2 - 1) * (if p ∣ n then a (n / p) else 0)) =
          a p * a n := by
      intro n
      simpa [mul_assoc] using
        (normalizedEigenform_hecke_recurrence hnormalized p n hp)
    rw [show MTT.heckePrime 2
      (iota ((1 : DirichletCharacter MTT.Qbar (modularConductor E hmod)) p)) p
      (gammaZeroToGammaOne (modularConductor_pos E hmod) P.form) z =
        MTT.heckePrime 2
          (iota ((1 : DirichletCharacter MTT.Qbar (modularConductor E hmod)) p)) p
          P.form z by rfl]
    change MTT.heckePrime 2
      (iota ((1 : DirichletCharacter MTT.Qbar (modularConductor E hmod)) p)) p
      P.form z = iota (E.LFunction p : MTT.Qbar) * P.form z
    rw [heps]
    have hcoeff : iota (E.LFunction p : MTT.Qbar) = a p := by
      simpa [a, ModularFormClass.qCoeff] using P.coeff_eq p
    rw [hcoeff]
    change MTT.heckePrime 2
      (if p ∣ modularConductor E hmod then 0 else 1) p
      P.form z = a p * P.form z
    apply HasSum.unique hhecke
    simpa only [hterms, smul_eq_mul, ← mul_assoc] using hscalar

/-- The weight-two eigenform associated with E at its least modular level. -/
noncomputable def attachedEigenform (iota : MTT.Qbar →+* ℂ)
    (E : WeierstrassCurve ℚ) [E.IsElliptic] (hmod : IsModular E) :
    MTT.Eigenform (modularConductor E hmod) 2 iota :=
  attachedEigenformCandidate E hmod
    (ellipticCurve_attachedForm_isNormalizedEigenform E hmod) iota

@[simp] theorem attachedEigenform_coeff (iota : MTT.Qbar →+* ℂ)
    (E : WeierstrassCurve ℚ) [E.IsElliptic] (hmod : IsModular E) (n : ℕ) :
    (attachedEigenform iota E hmod).coeff n = (E.LFunction n : MTT.Qbar) := rfl

@[simp] theorem attachedEigenform_epsilon (iota : MTT.Qbar →+* ℂ)
    (E : WeierstrassCurve ℚ) [E.IsElliptic] (hmod : IsModular E) :
    (attachedEigenform iota E hmod).epsilon = 1 := rfl

end HorizontalPadicL
Source
Kriz–Nordentoft, https://arxiv.org/pdf/2310.20678, Corollary 5.17 and its specialization to modular elliptic curves; modularity and q-expansion definitions as in the mission core.; interface refactor of HorizontalPadicL.ellipticCurve_eigenform_specialization_v2 and its accepted proof.

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me