Chapter 1

Modular symbols

1.1 Tutorial

This tutorial, which was written by Kevin Buzzard and William Stein, introduces the reader to the modular symbols package Hecke. It assumes no previous knowledge of Magma, and shouldn’t take more than 30 minutes to read. It does, however, assume that you are using a computer on which both Magma and the Hecke package are installed.

1.1.1 The basics

OK, here are the basics. To compute spaces of modular forms (characteristic 0) we’re going to use modular symbols. To work with characteristic 0 forms on Γ_{0}(53) of weight k = 2, type

   > N:=53;
   > k:=2;
   > M:=ModularSymbols(N,k);

The Magma object M is now a vector space over Q. In fact, M is a ModTupFld, which is Magma-speak for a vector space over a field (in the official release, M will probably be of type ModSym); it has a lot more structure than this though! For example, the level N is attached to M:

   > M`N;
   53

The syntax M`N is Magma’s way of accessing an attribute. If you want to find the level of M, it is better to use the Level function. This will work even if the internal structure of M is changed in a later version of Hecke.

   > Level(M);
   53

To get the exact list of what the ModularSymbols function can handle, just type

   > ModularSymbols;

and see how overloaded it is and exactly what you can and can’t do. For example, it will tell you that you can omit k if it’s 2.

Note that M is actually the vector space of modular symbols, so it has a funny dimension:

dim M = 2 × (cusp forms) + 1 × (Eisenstein series).

   > Dimension(M);
   9

That’s 2 × 4 = 8 for the cusp forms (one elliptic curve and three conjugate things), and one for the Eisenstein series.

Now there is some secret extra data that M knows about because

   > D:=Decomposition(M);

decomposes the new part of M into eigenspaces. I know this because

   > Decomposition;

gives me, amongst the output,

       (<ModTupFld> M) -> SeqEnum
         Compute the Hecke decomposition of the *NEW* subspace of M.
and M is a ModTupFld. The output of Decomposition is a SeqEnum of Hecke-

invariant subspaces in the linear dual of the space of modular symbols. The entries of D are subspace, which have a “degree” (=dim(M)) and a “dimension” (= dim(subspace)). Complex conjugation is not used to decompose the spaces any further; the subspaces correspond to spaces of conjugates of eigenforms, with the dimension still 2 times too big if the form is a cusp form.

   > #D;
   3

So there are 3 new things (the Eisenstein series, the elliptic curve, and the other Galois conjugate things). The command Factor returns the i-th factor of the decomposition, so Factor(D,i) is the same as D[i].

> qEigenform(Factor(D,1));
q - q^2 - 3*q^3 - q^4 + 3*q^6 - 4*q^7
> qEigenform(Factor(D,2));
q + a*q^2 + (-a^2 - a + 3)*q^3 + (a^2 - 2)*q^4 + (a^2 - 3)*q^5
  - q^6 + (a^2 - 1)*q^7
> qEigenform(Factor(D,3));
I haven't yet programmed q-expansions of Eisenstein series.

The command qEigenform prints out the q-expansion^{1}, and takes an optional second entry: a lower bound on the precision.

> qEigenform(Factor(D,1),20);
q - q^2 - 3*q^3 - q^4 + 3*q^6 - 4*q^7 + 3*q^8 + 6*q^9 + 3*q^12
  - 3*q^13 + 4*q^14 - q^16 - 3*q^17 - 6*q^18 - 5*q^19 + 12*q^21
  + 7*q^23

Note also:

> qEigenform(Factor(D,2));
q + a*q^2 + (-a^2 - a + 3)*q^3 + (a^2 - 2)*q^4 + (a^2 - 3)*q^5
  - q^6 + (a^2 - 1)*q^7
> f:=qEigenform(Factor(D,2));
> Category(f);
RngSerPowElt

That’s all well and good, but what is a???

> Parent(Coefficient(f,1));
Univariate Quotient Polynomial Algebra in a over Rational
Field with modulus a^3 + a^2 - 3*a - 1

Note that

> Coefficient(f,1);
1

1William hasn’t decide how to represent the transcendental constant term in Magma.

Maybe he should just call it an indeterminate b; then the q-expansion might look something like:

b + q + a ∗ q^{2} + (−a^{2} − a + 3) ∗ q^{3} + (a^{2} − 2) ∗ q^{4} + (a^{2} − 3) ∗ q^{5} − q^{6} + (a^{2} − 1) ∗ q^{7} and this would lie in a quotient of K(a, b). There could be another function that computes b, if necessary. What do you think, Kevin?

but it’s a certain kind of 1 :-)

   > b:=Coefficient(f,1);
   > b;
   1
   > Parent(b);
   Univariate Quotient Polynomial Algebra in a over Rational
   Field with modulus a^3 + a^2 - 3*a - 1

In fact, you can go crazy here:

   > K<a> := Parent(b);
   > K;
   Univariate Quotient Polynomial Algebra in a over Rational
   Field with modulus a^3 + a^2 - 3*a - 1
   > Modulus(K);
   x^3 + x^2 - 3*x - 1
   > MinimalPolynomial(a);
   x^3 + x^2 - 3*x - 1

1.1.2 Modular forms with character

Next, let’s try forms with a character. Note that the full Γ_{1}(N) isn’t done; the only forms done are Γ_{1}(N) with character. But this is OK; it is easy, but avoid the garbage!

   > DirichletCharacter(5,[2]);
   [garbage]

Ugh. But this is, according to the output of

   > DirichletCharacter;

the character of level 5 and order 2, taking values in Q. If I’d gone for (5, [4]) the character would automatically take values in the 4th cyclotomic field :-) The point: the level and the base field are now well-defined!!!

   > eps:=DirichletCharacter(5,[4]);
   > Category(eps);
   Rec

So there’s our character. Currently it is stored as a Rec-type object, but in the official release it will have its own type. Now we have no need to define the level, or the base field.

> M:=ModularSymbols(eps,5);
> M;
Full Vector space of degree 4 over Cyclotomic Field of order 4
and degree 2
User basis:
(1 0 0 0)
(0 1 0 0)
(0 0 1 0)
(0 0 0 1)

Note that I only had to give the character and weight! And moreover, the answer is a vector space over a field bigger than Q.

> M:=ModularSymbols(eps,11);
> D:=Decomposition(M);
> qEigenform(Factor(D,1));
q + a*q^2 + (-1/112*a^3 + (-5/112*zeta - 5/112)*a^2
     + 295/14*zeta*a  + (190/7*zeta - 190/7))*q^3
   + (a^2 - 1024*zeta)*q^4
   + ((1/16*zeta - 3/56)*a^3 + (117/112*zeta + 159/112)*a^2
      + (1018/7*zeta + 281/2)*a - 12027/7*zeta + 7176/7)*q^5
   + ((-5/28*zeta - 5/28)*a^3 - 67/14*zeta*a^2
      + (2635/7*zeta - 2635/7)*a - 29944/7)*q^6
   + (27/112*zeta*a^3 + (695/112*zeta - 695/112)*a^2
      + 10401/14*a + (43910/7*zeta + 43910/7))*q^7

Eew. Whatever are these a’s and ζ’s?

> f:=qEigenform(Factor(D,1));
> Category(f);
RngSerPowElt
> Parent(Coefficient(f,1));
Univariate Quotient Polynomial Algebra in a over Cyclotomic Field
of order 4 and degree 2 with modulus a^4 + (-15*zeta - 15)*a^3
  - 2896*zeta*a^2 + (39120*zeta - 39120)*a - 479104

Thus ζ is a a primitive 4th root of unity; this is how Magma stores cyclotomic fields.

1.1.3 Working modulo p

To work mod p, the trick is to use a character. So, for example, to work with the space of forms of level 37 and weight 2, (for Γ_{0}) mod 3, try this:

> eps:=DirichletCharacter(37,[1],3);

(or)

> eps2:=DirichletCharacter(37,3);

(and then)

> M:=ModularSymbols(eps,2);

(or)

> M2:=ModularSymbols(eps2,2);

There is no difference between the two, except that eps2 is stored internally in a slightly more efficient format.

> M;
Full Vector space of degree 6 over GF(3)
User basis:
(1 0 0 0 0 0)
(0 1 0 0 0 0)
(0 0 1 0 0 0)
(0 0 0 1 0 0)
(0 0 0 0 1 0)
(0 0 0 0 0 1)

Now M is over a finite field! If you only want to work with Γ_{0}, you can instead

use the command ModularSymbols(N,k,p).

1.1.4 Hecke operators

These act on the space of modular symbols, and spit out matrices. So, for example, let’s compute one over a field of size p^{2}.

> eps:=DirichletCharacter(5,[4],3);
> ModularSymbols(eps,7);
Full Vector space of degree 6 over GF(3^2)
User basis:
(    1     0     0     0     0     0)
(    0     1     0     0     0     0)
(    0     0     1     0     0     0)
(    0     0     0     1     0     0)
(    0     0     0     0     1     0)
(    0     0     0     0     0     1)

The Dirichlet character is level 5, order 4, defined mod 3. So the ground field is forced to be F_{9}. Note that eps is odd. Note also that, in this case, I probably don’t mind “which” eps has been chosen. If I’d gone for

   > eps:=DirichletCharacter(5,[4],5);

then I genuinely don’t know which one of the characters it would choose—the Teichmuller one or its inverse. Another variant of the DirichletCharacter command gives precise control over the character.

Anyway, let’s get back to Hecke operators. No doubt this is all the same in characteristic 0 and characteristic p.

   > eps:=DirichletCharacter(5,[4],3);
   > M:=ModularSymbols(eps,7);
   > Dimension(M);
   6
   > T7:=Tn(M,7);
   > T7;
   [a^7   0   0 a^7   a a^2]
   [  0 a^7   0 a^5   a   0]
   [  0   0 a^7   0   0   0]
   [  0   0   0 a^7   0   0]
   [  0   0   0   0 a^7   0]
   [  0   0   0   0   0 a^7]
   > factor(CharacteristicPolynomial(T7));
   [
       <x + a^3, 6>
   ]

What is a? It is a generator for the unit group of F_{9}:

   > F<a> := Parent(T7[1,1]);
   > R<X>:=PolynomialRing(GF(3));
   > MinimalPolynomial(a);
   X^2 + 2*X + 2
   > Order(a);
   8

Let’s check that there’s an elliptic curve of conductor 37 which is supersingular at 2.

   > M:=ModularSymbols(37,2);
   > T2:=Tn(M,2);
   > T2;

   [-1  1  1 -1  0]
   [ 1 -1  1  0  0]
   [ 0  0 -2  1  0]
   [ 0  0  0  0  0]
   [ 0  0  0  1  3]
   > Dimension(Kernel(T2));
   2

Yup, there it is. Twice! This is because we’re working with modular symbols.

1.1.5 The plus one quotient

I guess at some point I should mention how to cut this 2 down to 1:

   > ModularSymbols(37,2,+1);
   Full Vector space of degree 3 over Rational Field
   User basis:
   (1 0 0)
   (0 1 0)
   (0 0 1)
   > ModularSymbols(37,2,-1);
   Full Vector space of degree 2 over Rational Field
   User basis:
   (1 0)
   (0 1)
   > ModularSymbols(37,2);
   Full Vector space of degree 5 over Rational Field
   User basis:
   (1 0 0 0 0)
   (0 1 0 0 0)
   (0 0 1 0 0)
   (0 0 0 1 0)
   (0 0 0 0 1)

Check it out! The plus part gets 1 dimension of the cusp forms, and the Eisenstein series; the −1 part gets 1 dimension of the cusp forms and necessarily no Eisenstein series!

1.1.6 Print and FullDecomposition

We next learn the Print command and discuss the merits of Decomposition versus FullDecomposition. First, I’ll do Print (which will probably be unnecessary in the official version of this package).

> M:=ModularSymbols(7,4);
> D:=Decomposition(M);
> D;
[
    Vector space of degree 4, dimension 2 over Rational Field
    User basis:
    (   1    0  3/5    7)
    (   0    1 -4/5    0)
]
> Print(D);
Modular symbols factors:
  7k4A:  dim = 2    cuspidal

As you can see, the Print command rocks :-) The answer also gives this coded message 7k4A. Actually, there is a very strange command ModularFactor, which seems to do everything for you at once: (7k4A is of course the unique cusp form defined over Q of level 7 and weight 4; the Eisenstein series for Γ_{0}(7) and weight 4 are (both) old).

> f:=ModularFactor("7k4A");
> qEigenform(f);
q - q^2 - 2*q^3 - 7*q^4 + 16*q^5 + 2*q^6 - 7*q^7

Neat, huh? The k, which stands for “weight k”, is just a separator between 7 and 4. Also, you can use Print with e.g. forms with a character:

> M:=ModularSymbols(DirichletCharacter(7,[3]),4);
> D:=Decomposition(M);
> Print(D);
Modular symbols factors:
(nontrivial character)
  7k4epsA:  dim = 2    cuspidal
  7k4epsB:  dim = 1  eisenstein
  7k4epsC:  dim = 1  eisenstein

The character isn’t identified by the notation 7k4epsA, though.

Now FullDecomposition:
> M:=ModularSymbols(7,4);
> D:=FullDecomposition(M);
> Print(D);
Modular symbols factors:

     7k4A:  dim = 2    cuspidal
     7k4B:  dim = 2  eisenstein  (old:   1A)

As you can see, FullDecomposition includes forms that are old as well as new forms. If possible, use Decomposition instead of FullDecomposition because it is faster and uses less memory.

1.1.7 Dimensions of spaces of modular forms

There are functions for computing dimensions of spaces of modular forms, without computing the spaces themselves using modular symbols. For example,

   > DimensionSk(7,4);     // trivial character
   1
   > DimensionSkG1(37,4);
   153
   > DimensionSk(DirichletCharacter(7,[3]),4);
   1

1.1.8 Elliptic curves

Elliptic curves are a bit special:

   > f:=ModularFactor("14A");
   > E:=EllipticCurve(f);
   > E;
   Elliptic Curve defined by y^2 = x^3 + 5805*x - 285714 over
   Rational Field

Neat, huh? The model was computed by integrating to obtain the period lattice in C. The model for E is not the minimal model, but that is easy to get:

   > C:=MinimalModel(E);
   > C;
   Elliptic Curve defined by y^2 + x*y + y = x^3 + 4*x - 6 over
   Rational Field