[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Advanced Examples

Subsections

Handmade L-series of an Elliptic Curve


Example Lseries_lseries-elliptic-selfmade (H127E20)

This is an example of how the general LSeries function can be used to define the L-series for elliptic curves. This is essentially what LSeries(E) does:

> E := EllipticCurve([1,2,3,4,5]);
> N := Conductor(E);N;
10351
> P<x> := PolynomialRing(Integers());

The easiest way to define the coefficients is to provide the local factors.

> cf := func< p,d|1 - TraceOfFrobenius(E,GF(p,1))*x
>                     +(N mod p ne 0 select p else 0)*x^2 >;
> L := LSeries(2,[0,1],N,cf : Parent:=E, Sign:=RootNumber(E));
Compare this with the built-in function LSeries(E)

> Evaluate(L,2);
0.977431866894500508679039127647
> Evaluate(LSeries(E),2);
0.977431866894500508679039127647

Self-made Dedekind Zeta Function


Example Lseries_lseries-dedekind-selfmade (H127E21)

This is an example of how the general LSeries function may be used to define the Dedekind zeta function of a number field K. This is essentially what the function LSeries(K) does:

> function DedekindZeta(K)
>   M := MaximalOrder(K);
>   r1,r2 := Signature(K);
>   gamma := [0: k in [1..r1+r2]] cat [1: k in [1..r2]];
>   disc := Abs(Discriminant(M));
>   P<x> := PolynomialRing(Integers());

The coefficients are defined by means of local factors; for a prime p we take the product of 1 - xfk where the fi are the residue degrees of primes above p. Note that this local factor has (maximal) degree [K:Q] if and only if p is unramified or, equivalently, if and only if p does not divide the discriminant of K which is (up to sign) the conductor of our zeta-function.

>   cf := func<p,d|&*[1-x^Degree(k[1]): k in Decomposition(M,p)]>;

Finally, the Dedekind zeta function has a pole at s=1 and we need its residue (or, rather, the residue of ζ^ * (s)) which we compute using the class number formula.

>   h := #ClassGroup(M);
>   reg := Regulator(K);
>   mu := #TorsionSubgroup(UnitGroup(M));
>   return LSeries(1, gamma, disc, cf: Parent:=K, Sign:=1, Poles:=[1],
>     Residues := [-2^(r1+r2)*Pi(RealField())^(r2/2)*reg*h/mu]);
> end function;
> Z := DedekindZeta(CyclotomicField(5)); Z;
L-series of Cyclotomic Field of order 5 and degree 4
> Evaluate(Z,1);
L*(s) has a pole at s = 1
> L := Z/RiemannZeta();
> Evaluate(L,1);
0.339837278240523535464278781159

L-series of a Genus 2 Hyperelliptic Curve


Example Lseries_lseries-genus2 (H127E22)

We compute an L-series of a hyperelliptic curve of genus 2.

> P<x> := PolynomialRing(Integers());
> C := HyperellipticCurve([x^5+x^4,x^3+x+1]); C;
Hyperelliptic Curve defined by y^2 + (x^3 + x + 1)*y = x^5 + x^4
over Rational Field

There is an L-series attached to ( H)1(C) or, equivalently, the ( H)1 of the Jacobian J of C. To define this L-series, we need its local factors which, for primes p of good reduction of C, are given by EulerFactor(J,GF(p,1)). Let us look at the primes of bad reduction:

> Abs(Discriminant(C));
169
> Factorization(Integers()!$1);
[ <13, 2> ]

There is one prime p=13 where the curve has bad reduction. There the fibre is a singular curve whose normalization is elliptic.

> A<X,Y> := AffineSpace(GF(13,1),2);
> C13 := Curve(A,Equation(AffinePatch(C,1)));
> GeometricGenus(C), GeometricGenus(C13);
2 1
> SingularPoints(C13);
{@ (9, 1) @}
> p := $1[1]; IsNode(p), IsCusp(p);
false true
> C13A := Translation(C13,p)(C13);
> C13B := Blowup(C13A); C13B;
Curve over GF(13) defined by
X^3 + 12*X^2*Y + 7*X^2 + 12*X*Y + 12*Y^2 + 3*Y + 1
> E := EllipticCurve(ProjectiveClosure(C13B));
The local factor of C at p=13 is given by the Euler factor of this elliptic curve

> EulerFactor(E);
13*x^2 + 5*x + 1

The conductor of L(C, s) is 132, the same as the discriminant in this case. So, we define L(C, s):

> J := Jacobian(C);
> loc := func<p,d|p eq 13 select EulerFactor(E) else EulerFactor(J, GF(p,1))>;
> L := LSeries(2,[0,0,1,1],13^2,loc);

Now we check the functional equation and compute a few L-values. (Most of the execution time will be spent generating coefficients, so the first call takes some time. After that, the computations are reasonably fast.)

> CheckFunctionalEquation(L);
-2.958228394578794270293982119810E-31
> Evaluate(L,1);
0.0904903908324296291135897572580
> Evaluate(L,2);
0.364286342944364068154291450139

Experimental Mathematics for Small Conductor


Example Lseries_lseries-experimental (H127E23)

This example shows how one may construct the first 20 coefficients of the L-series of an elliptic curve of conductor 11 without knowing anything about either the curve or modular form theory.

The point is that for an L-series L(s)=∑an/ns, the associated theta function (used in CheckFunctionalEquation) is a series with an as coefficients and terms that decrease very rapidly with n. This means that if we truncate the series to, for instance, just a1 + a2/2s and call LSeries with the same parameters (weight, sign, etc.) as those for L(s) but just [a1, a2, 0, 0, 0, 0, ...] as the coefficient vector, then CheckFunctionalEquation will return a number reasonably close to 0, because the coefficients an for n>2 only make a small contribution.

With this in mind, we create an L-series that looks like that of an elliptic curve with conductor 11 and sign 1, that is, we take weight = 2, conductor = 1, gamma = [0,1], sign = 1 and no poles:

> L := LSeries(2, [0,1], 11, 0 : Sign:=1);

Then taking a1=1, and recalling the requirement that all the coefficients must be weakly multiplicative, we try various a2 to see which of the truncated L-series 1 + a2/2s is closest to satisfying a functional equation. Using the knowledge that a2 (and every other an) is an integer together with the Hasse-Weil bound, |ap|<2Sqrt(p), we find just 5 choices:

> for a_2 := -2 to 2 do
>   LSetCoefficients(L,[1,a_2]);
>   print a_2, CheckFunctionalEquation(L);
> end for;
-2 0.008448098707478090187579588380635
-1 0.07557498328782515608604001309880
0 0.1427018678681722219845004378169
1 0.2098287524485192878829608625350
2 0.2769556370288663537814212872532

It seems that a2= - 2 is the best choice, so we set it. Note that this also determines a4, a8, etc. We next proceed to find a3 in the same way. It might come as a surprise, but in this way we can find the first 30 or so coefficients correctly. (Actually, by using careful bounds, it is even possible to prove that these are indeed uniquely determined.) Here is code that finds a1, ..., a20:

> N := LCfRequired(L); N;
48
> V := [0 : k in [1..N] ];   // keep a_p in here
> P<x> := PolynomialRing(Integers());
> function Try(V,p,a_p)  // set V[p]=a_p and try functional equation
>   V[p] := a_p;
>   LSetCoefficients(L, func<p,d | 1-V[p]*x+(p eq 11 select 0 else p)*x^2 >);
>   return Abs(CheckFunctionalEquation(L));
> end function;
> for p := 2 to 20 do     // try a_p in Hasse-Weil range and find best one
>   if IsPrime(p) then
>     hasse := Floor(2*Sqrt(p));
>     _,V[p] := Min([Try(V,p, a_p): a_p in [-hasse..hasse]]);
>     V[p] -:= hasse+1;
>   end if;
> end for;
> LSetCoefficients(L, func<p,d | 1-V[p]*x+(p eq 11 select 0 else p)*x^2 >);

We list the coefficients that we found and apply CheckFunctionalEquation to them:

> LGetCoefficients(L,20);
[* 1, -2, -1, 2, 1, 2, -2, 0, -2, -2, 1, -2, 4, 4, -1, -4, -2, 4, 0, 2*]
> CheckFunctionalEquation(L);
4.186579790674123374418985668816E-16

Compare this with the actual truth:

> qExpansion(Newforms("11A")[1],21);
q - 2*q^2 - q^3 + 2*q^4 + q^5 + 2*q^6 - 2*q^7 - 2*q^9 - 2*q^10 + q^11
    - 2*q^12 + 4*q^13 + 4*q^14 - q^15 - 4*q^16 - 2*q^17 + 4*q^18 +
    2*q^20 + O(q^21)

Such methods have been used by Stark in his experiments with L-functions of number fields, and by Mestre to find restrictions on possible conductors of elliptic curves. In fact, by modifying our example (changing 11 to 1 ... 10 and sign = 1 to sign = +- 1) one can show that for N<11 there are no modular elliptic curves of conductor N.


Tensor Product of L-series Coming from l-adic Representations


Example Lseries_lseries-tensor (H127E24)

This is an example of using the tensor product for L-functions coming from l-adic representations. This is what LSeries(E,K) uses to construct L-series of elliptic curves over number fields.

> E := EllipticCurve([ 0, 0, 0, 0, 1]); // Mordell curve
> P<x> := PolynomialRing(Integers());
> K := NumberField(x^3-2);
> LE := LSeries(E);
> LK := LSeries(K);

We have now two L-functions, one associated to an elliptic curve and one to a number field. They both come from l-adic representations, and we can try to construct their tensor product. Actually, the function TensorProduct requires us to specify exponents of the conductor and the bad local factors of the tensor product representation, but we can try and let Magma do it, hoping that nothing unusual happens. We take the tensor product of the two L-series and divide it by L(E, s) to speed up the computations. Remember that L(K, s) has a copy of the Riemann zeta function as a factor.

> L := TensorProduct(LE, LK, []) / LE;
> CheckFunctionalEquation(L);
  |Sign| is far from 1, wrong functional equation?
0.0234062571006075114301535636401
The resulting L-function does not satisfy the required functional equation, so something unusual does happen at a prime where both E and K have bad reduction, which in this case must be either p=2 or p=3.

Let us check p=2. We change the base field of E to K and look at its reduction at the unique prime above 2:

> EK := BaseChange(E,K);
> p := Decomposition(MaximalOrder(K),2)[1,1];
> LocalInformation(E,2);
<2, 4, 2, 3, IV>
> loc, model:=LocalInformation(EK,p);loc,model;
<Principal Prime Ideal
Generator:
    [0, -1, 0], 0, 0, 1, I0>
Elliptic Curve defined by y^2 - y = x^3 over K

We see that E has acquired good reduction at p|2. This means that the inertia invariants at 2 of the l-adic representation associated to L, namely ρE tensor (ρK - ρQ) are larger than the tensor product of the corresponding inertia invariants, which is zero. Thus the local factor of L at 2 is not Fp(x)=1 (which is what TensorProduct assumed), but a polynomial of higher degree. In fact, it is the characteristic polynomial of Frobenius of the reduced curve E/K mod p, so Fp(x)=1 - a2x + 2x2 with a2 given by

> TraceOfFrobenius(Reduction(model, p));
0
This is now the correct L-function (at p=3 the default procedure works) and the functional equation is satisfied

> L := TensorProduct(LE,LK,[<2,4,1+2*x^2>])/LE;
> CheckFunctionalEquation(L);
3.15544362088404722164691426113E-30

In fact, our L-series is the same as that constructed by LSeries(E,K)/LE.


Non-abelian Twist of an Elliptic Curve


Example Lseries_lseries-nonabtwist (H127E25)

In this example we illustrate how to use LSeries(E,K) to construct non-abelian twists of elliptic curves.

> E := EllipticCurve([0, 0, 0, 0, 1]);
> P<x> := PolynomialRing(Integers());
> K := NumberField(x^3-2);
> L := LSeries(E,K) / LSeries(E);
> lval := Evaluate(L, 1); lval;
0.655371552164974435712378842491

The series L is the L-function of non-abelian twist of E and it appears that L(1) is non-zero. In other words, the analytic rank of L(E/K, s) at s=1 is the same as that of L(E/Q, s). Tate's version of the Birch-Swinnerton-Dyer conjecture then predicts that the Mordell-Weil rank of E/K is the same as the rank over Q, so the elliptic curve has not acquired new independent points. This is something that can be confirmed by a Selmer group computation:

> EK := BaseChange(E,K);
> twoE := MultiplicationByMMap(E, 2);
> #SelmerGroup(twoE);
2
> twoEK := MultiplicationByMMap(EK, 2);
> #SelmerGroup(twoEK);
2

Indeed, the 2-Selmer rank is 1 in both cases, as expected. Also, the second part of the Birch-Swinnerton-Dyer conjecture predicts that the following quotient should be rational:

> p1, p2 := Explode(Periods(E));
> lval*Sqrt(Abs(Discriminant(K))) / (p1*Im(p2));
1.33333333333333333333333333334
Finally, the same L-series can be defined via the Artin representation machinery:

> triv,sign,rho:=Explode(ArtinRepresentations(K));
> L:=LSeries(E,rho);
> CentralValue(L);
0.655371552164974435712378842492

Other Tensor Products

We take two L-functions with Euler products over a field K: L1(M, s)=∏pi=1m bigl(1 - αi(p)/N psbigr) - 1 ( and) L2(N, s)=∏pj=1n bigl(1 - βj(p)/N psbigr) - 1, where M and N are of degrees m and n respectively, and we ignore bad Euler factors in the above. Their tensor product is an L-function of degree mn given by L(A tensor B, s)=∏pi=1mj=1n bigl(1 - αi(p)βj(p)/N psbigr) - 1. It is not clear in general how to compute bad Euler factors, and even the gamma factors can be tricky. Internally, the functionality tries to compute a "Hodge structure" corresponding to the gamma factors of each object, with the "Hodge structure" for the tensor product then following via combinatorics, before passing back to the gamma factors.

Some tensor products can induce poles, particularly when tensoring an L-series with itself. Also in some cases, the tensor product will be taken over ( Q) unless the user specifies otherwise.


Example Lseries_ec-tensorprod (H127E26)

A tensor product of two elliptic curves over ( Q).

> E1 := EllipticCurve("11a");
> E2 := EllipticCurve("17a");
> L1 := LSeries(E1);
> L2 := LSeries(E2);
> L := TensorProduct(L1, L2, []);
> LSeriesData(L); // level is 11^2 * 17^2
<3, [ 0, 1, -1, 0 ], 34969, ... >
> CheckFunctionalEquation(L);
-2.83989925879564249948222283502E-29

Example Lseries_level1-modform (H127E27)

A tensor product of two modular forms of level 1.

> f1 := ModularForms(1,12).2;
> f2 := ModularForms(1,26).2;
> L1 := LSeries(f1);
> L2 := LSeries(f2);
> L := TensorProduct(L1, L2, []);
> LSeriesData(L); // weight is (12-1)+(26-1)+1 -- motivic weight is 11+25
<37, [ 0, 1, -11, -10 ], 1, ... >
> CheckFunctionalEquation(L);
-5.75014913311889483177106362349E-25
> Pi(RealField(30))^2 * Evaluate(L,24) / Evaluate(L,25);
9.87142857142857142857142857136
> 691/70.; // Ramanujan congruence
9.87142857142857142857142857142

Example Lseries_siegel-modular-form (H127E28)

An example related to Siegel modular forms (see [vGvS93, S8.7]).

> E := EllipticCurve("32a"); // congruent number curve
> chi := DirichletGroup(32).1; // character of conductor 4 lifted
> MF := ModularForms(chi, 3); // weight 3 modular forms on Gamma1(32,chi)
> NF := Newforms(MF);
> NF[1][1]; // q-expansion of the desired form
q + a*q^3 + 2*q^5 - 2*a*q^7 - 7*q^9 - a*q^11 + O(q^12)
> Parent(Coefficient(NF[1][1], 3)); // defined over Q(i)
Number Field with defining polynomial x^2 + 16 over the Rational Field
> f1, f2 := Explode(ComplexEmbeddings(NF[1][1])[1]);
> L1 := LSeries(E);
> L2 := LSeries(f1); // first complex embedding
> L := TensorProduct(L1, L2, [ <2, 9> ]); // conductor 2^9 (guessed)
> time CheckFunctionalEquation(L);
-3.15544362088404722164691426113E-30
Time: 2.090

Example Lseries_tensprod-overK (H127E29)

An example of a tensor product over a field larger than the rationals.

> K<s> := QuadraticField(-3);
> I := Factorization(3 * IntegerRing(K))[1][1];
> H := HeckeCharacterGroup(I^2);
> G := Grossencharacter(H.0, [[1, 0]]); // canonical character
> E := EllipticCurve([1, (3+s)/2, 0, (1+s)/2, 0]);
> Norm(Conductor(E));
73
> LG := LSeries(G);
> LE := LSeries(E);
> TP := TensorProduct(LE, LG, [<I, 5>], K); // ensure 3-part correct
> LSetPrecision(TP, 9); // there is another factor of 3 from K
> LCfRequired(TP);
1642
> CheckFunctionalEquation(TP);
4.65661287E-10

Symmetric Powers

Symmetric power L-functions form a natural analogue to tensor products. Here we essentially tensor an L-function with itself repeatedly, but remove redundant factors.

In the case of GL(1), the kth symmetric power is simply the L-function associated to the kth power of the underlying character, though we must be careful to ensure primitivity (this disregards the bad primes). Explicitly, we have L(( Sym)kψ, s)=∏p Bigl(1 - ψ(p)k/N psBigr) - 1, (again ignoring bad primes) and so the eigenvalues are just the kth powers of the original. It is relatively easy to compute the bad Euler factors, given those for L(ψ, s).

In the case of GL(2), the kth symmetric power is an L-function of degree (k + 1) over the field of definition, given by L(( Sym)k A, s)= ∏pi=0k Bigl(1 - α1(p)k - iα2(p)i/N psBigr) - 1, where α1(p) and α2(p) are the eigenvalues at the prime p. In the case of elliptic curves, one can use the fact that α1(p)α2(p)=p to rewrite these via symmetric functions.

A similar definition can be made for higher degree L-functions, yielding that the kth symmetric power of an L-function of degree d will have degree (k + d - 1choose d - 1).

If the object itself has a natural powering operation (as with, say, Hecke characters), Magma will simply take the primitivization therein. The bad Euler factors have been explicitly calculated for elliptic curves over the rationals in [MW06] and [DMW09]. In other cases, the user will likely have to provide them. Furthermore, the full ability to take symmetric powers over fields other than the rationals is not yet fully implemented.

SymmetricPower(L, m) : LSer, RngIntElt -> LSer
    BadEulerFactors: SeqEnum            Default: []
Return the L-series corresponding to the mth symmetric power of L. The BadEulerFactors consists of < p, f, E > triples, where p is a prime, f the conductor exponent, and E a polynomial that gives the Euler factor at that prime.

Example Lseries_lseries-sympow (H127E30)

Some basic code, showing the special cases where Magma will just take the power of the underlying object.

> G := FullDirichletGroup(3*5*7);
> chi := G.1*G.2*G.3; // Random now gives an imprimitive character
> L := LSeries(chi);
> LS3 := SymmetricPower(L, 3);
> Lc3 := LSeries(chi^3);
> Evaluate(LS3, 1);
0.843964498053507794372984784470 + 0.199232992137116783033645803753*i
> Evaluate(Lc3, 1);
0.843964498053507794372984784470 + 0.199232992137116783033645803753*i

Example Lseries_sympow-ec (H127E31)

> K := QuadraticField(-23);
> I := Factorization(23 * IntegerRing(K))[1][1];
> G := HeckeCharacterGroup(I);
> psi := G.1^14; // Random now gives an imprimitive character
> L := LSeries(psi);
> LS5 := SymmetricPower(L, 5);
> Lp5 := LSeries(psi^5);
> Evaluate(LS5, 1);
0.870801884824381647583631149814 + 0.622589291563954831229726530813*i
> Evaluate(Lp5, 1);
0.870801884824381647583631149814 + 0.622589291563954831229726530813*i

Example Lseries_sympow-ec (H127E32)

In this example we take symmetric powers of the L-function of a Grossencharacter.

> GR := Grossencharacter(psi, [[1,0]]);
> L := LSeries(GR);
> LS4 := SymmetricPower(L, 4);
> Lp4 := LSeries(GR^4);
> Evaluate(LS4, 3);
0.354651275716915313430268098042 - 0.147519877277453173656613056548*i
> Evaluate(Lp4, 3);
0.354651275716915313430268098042 - 0.147519877277453173656613056548*i

Example Lseries_sympow-ec (H127E33)

An example with symmetric powers of elliptic curves. In the case of the symmetric square of 389A, the ModularDegree code will do the same calculation, but more efficiently.

> E := EllipticCurve("389a");
> L := LSeries(E);
> L2 := SymmetricPower(L, 2);
> LSeriesData(L2);
<3, [ 0, 1, 0 ], 389^2, function(p, d) ... end function, 1, [], []>
> LSetPrecision(L2, 9);
> Evaluate(L2, 2);
3.17231145
> ($1 * Conductor(E)) / (2 * Pi(RealField()) * FundamentalVolume(E));
40.0000000
> ModularDegree(E);
40

Example Lseries_sympow-ec2 (H127E34)

This in an example where a higher symmetric power has a vanishing central value, here a zero of (presumably) order 4. It comes from work of Buhler, Schoen, and Top [BST97].

> E := EllipticCurve("73a");
> L := LSeries(E);
> L3 := SymmetricPower(L, 3);
> LSeriesData(L3); // Magma knows the Sign is +1
<4, [ 0, -1, 1, 0 ], 73^3, function(p, d) ... end function, 1, [], []>
> LSetPrecision(L3, 9);
> CentralValue(L3);
-2.16367048E-12

 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

Version: V2.19 of Mon Dec 17 14:40:36 EST 2012