Overconvergent Modular Forms

These routines compute characteristic series of operators on overconvergent modular forms. While these are p-adic modular forms, the result also gives information about classical spaces: it determines the characteristic series up to a congruence (details are given below). The big advantage of this approach is that extremely large weights can be handled (the method works by indirectly computing a small part of the large space).

The algorithm has a running time which is linear in log(k), where k is the weight. The implementation for level 1 is well optimized.

The algorithm is given in Algorithms 1 and 2 of [Lau11]. Suggestions of David Loeffler and John Voight are used in generating certain spaces of classical modular forms for level N ≥2.

OverconvergentHeckeSeriesDegreeBound(p, N, k, m) : RngIntElt, RngIntElt, RngIntElt, RngIntElt -> RngIntElt
This returns a bound on the degree of the characteristic series modulo pm of the Atkin Up operator on the space of overconvergent p-adic modular forms of (even) weight k and level Γ0(N). This bound is due to Daqing Wan and depends only on k modulo p - 1 rather than k itself.
OverconvergentHeckeSeries(p, N, k, m) : RngIntElt, RngIntElt, RngIntElt, RngIntElt -> RngUPolElt
OverconvergentHeckeSeries(p, N, k, m) : RngIntElt, RngIntElt, [ RngIntElt ], RngIntElt -> [ RngUPolElt ]
OverconvergentHeckeSeries(p, chi, k, m) : RngIntElt, GrpDrchElt, RngIntElt, RngIntElt -> RngUPolElt, RngPadElt
OverconvergentHeckeSeries(p, chi, k, m) : RngIntElt, GrpDrchElt, [ RngIntElt ], RngIntElt -> [ RngUPolElt ], RngPadElt
    WeightBound: RngIntElt              Default: 
This returns the characteristic series P(t) modulo pm of the Atkin Up operator acting on the space of overconvergent p-adic modular forms of weight k and level Γ0(N), or with character chi on Γ1(N) when chi is the second argument.

The first argument must be a prime p ≥5 not dividing N.

The third argument may be either a single weight or a sequence of weights, in which case the function returns a sequence containing the characteristic series for each weight. The given weights must be congruent to each other modulo p - 1. Note that it is more efficient to compute several weights together rather than separately. (In particular, the part of the algorithm which builds up spaces from classical spaces of low weight can be done for all the weights together.)

When the second argument is a character chi, it must take values in a cyclotomic field. In this case the function returns a second value: a p-adic integer that defines the embedding of the cyclotomic field in the p-adic field.

When m ≤k - 1, by Coleman's theorem, P(t) is also the reverse characteristic polynomial modulo pm of the Atkin Up operator on the space of classical modular forms of level Γ0(Np) and weight k, In addition, when m ≤(k - 2)/2, P(t) is the reverse characteristic polynomial modulo pm of the Hecke Tp operator on the space of classical modular forms of level Γ0(N) and weight k.

The optional parameter WeightBound is a bound on the weight of the forms used to generate certain spaces of classical modular forms that are used at one point in the algorithm (for level N ≥2). The default value is 6 for the case of Γ0(N) and for the case of even character chi, and 3 for odd chi. For most levels, the algorithm terminates more quickly with WeightBound 4 rather than 6. For some small levels, the algorithm may fail to terminate with these settings, however it will terminate when WeightBound is set to a sufficiently large value. There is some randomization in the algorithm, which may also cause variation in running time. The output is proven correct in all instances where the algorithm terminates.

Example ModFrm_overconvergent (H141E19)

> _<t> := PolynomialRing(Integers()); // use t for printing
> time OverconvergentHeckeSeries(5,11,10000,5);
625*t^8 + 375*t^7 + 1275*t^6 - 875*t^5 - 661*t^4 + 335*t^3 + 1189*t^2 + 861*t + 1
Time: 0.300
> time OverconvergentHeckeSeries(5,11,10000,5 : WeightBound := 4);
625*t^8 + 375*t^7 + 1275*t^6 - 875*t^5 - 661*t^4 + 335*t^3 + 1189*t^2 + 861*t + 1
Time: 0.130
Note that the same result was obtained each time, but the weight bound reduced the computational work involved.
> OverconvergentHeckeSeries(7,3,[1000,1006],5);
[
    7203*t^6 - 4116*t^5 + 6713*t^4 - 700*t^3 - 4675*t^2 - 4426*t + 1,
    2401*t^6 + 8134*t^4 - 3976*t^3 + 5160*t^2 + 5087*t + 1
]
> Pseq := OverconvergentHeckeSeries(7,3,[1000,1006],5: WeightBound := 4);
> assert Pseq eq $1; // check that it is the same as the previous result
> OverconvergentHeckeSeriesDegreeBound(7,3,1000,5);
9
> OverconvergentHeckeSeries(29,1,10000,10);
    134393786323419*t^8 - 174295724342741*t^7 - 174857545225000*t^6
    - 153412311426730*t^5 + 41820892464727*t^4 - 148803482429283*t^3
    - 111232323996568*t^2 + 165679475331974*t + 1
V2.28, 13 July 2023