> 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
> 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); Runtime error: L*(s) has a pole at s = 1 > L := Z/RiemannZeta(); > Evaluate(L,1); 0.339837278240523535464278781159
> 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.)
> CFENew(L); 0.000000000000000000000000000000 > Evaluate(L,1); 0.0904903908324296291135897572581 > Evaluate(L,2); 0.364286342944364068154291450139
This is roughly what the built-in function LSeries(C) does:
> LC:=LSeries(C); > CFENew(LC); 0.000000000000000000000000000000 > Evaluate(LC,1); 0.0904903908324296291135897572581 > Evaluate(LC,2); 0.364286342944364068154291450139
The point is that for an L-series L(s)=∑an/ns, the associated theta function (used in CFENew or 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, CFENew(L); > end for; -2 0.0150037010097490317173530048996 -1 0.101579424986956534846398098015 0 0.157218613580238064317855126848 1 0.195989746558550757309403554281 2 0.224553905951474457074100971432
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(CFENew(L)); > end function; > for p in PrimesUpTo(20) do // try a_p in Hasse-Weil range and find best one > hasse := Floor(2*Sqrt(p)); > _,V[p] := Min([Try(V,p, a_p): a_p in [-hasse..hasse]]); > V[p] -:= hasse+1; > 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 *] > CFENew(L); 5.62416733501076689050846061301E-17
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.
> 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; WARNING: 2 is ramified in each part of tensor prod WARNING: 3 is ramified in each part of tensor prod > CFENew(L); 0.0234062571006075114301535636259The 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, true> > loc, model:=LocalInformation(EK,p);loc,model; <Prime Ideal Two element generators: [2, 0, 0] [0, 1, 0], 0, 0, 1, I0, true> 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)); 0This 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; WARNING: 3 is ramified in each part of tensor prod > CFENew(L); 7.88860905221011805411728565283E-31
In fact, our L-series is the same as that constructed by LSeries(E,K)/LE.
In this example we illustrate how to use LSeries(E,K) to experiment with the Birch-Swinnerton-Dyer conjecture for elliptic curves in non-abelian extensions of Q.
> 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.33333333333333333333333333334Finally, 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.655371552164974435712378842491
In this example we go through Exercise 5.5 of Rohrlich's Park City notes [Roh11], illustrating an example of a nonorthogonal L-function that has vanishing central value.
We will be interested in the twist of the elliptic curve 49a by an element d in the quadratic field (Q)(Sqrt( - 7)). By construction, this twist will have a point on it. Namely, we write 49a as y2=x3 - 35x - 98, and take d as the evaluation of the right-side cubic polynomial at x=(1 + Sqrt( - 7))/2.
> K<s7> := QuadraticField(-7); > f := func<x|x^3-35*x-98>; > d := f((1+s7)/2); // -118 - 18*s7, norm 2^6 * 11 * 23
We then take the quadratic Hecke character corresponding to this element, and multiply it by the canonical Grössencharacter for 49a. The central value of the resulting L-series will then vanish, even though the root number is non-orthogonal.
> eta := QuadraticCharacter(d);
> xi := eta*Grossencharacter(EllipticCurve("49a"));
> L := LSeries(xi); // conductor 7^2 * 11 * 23
> CentralValue(L); Sign(L);
-5.52547662275340591670187425483E-30
0.943041920192897214648941373358 - 0.332673919565230241738496249575*i
We can also work with the associated elliptic curve, using the point that we already know on it.
> E := EllipticCurve([K|-35,-98]); // a model for 49a > Q := QuadraticTwist(E,d); > pt := Points(Q,(1+s7)*d/2)[1]; > Height(pt); // nonzero 1.28216334015607284474482974
While it is easy to get two independent points on the twisted curve (indeed, a second point could be obtained from this first via the isogeny of multiplication by (1 + Sqrt( - 7))/2), it is actually non-trivial to prove a sufficient saturation bound to show this is really the full Mordell-Weil group.
> b,G,m := PseudoMordellWeilGroup(Q : SearchBound:=10); > PTS := [m(G.3),m(G.4)]; // G.1 and G.2 are 2-torsion > [Height(P) : P in PTS]; // differ by multiple of 2 [ 2.56432668031214568948965948, 1.28216334015607284474482974 ]
There is no Gross-Zagier theorem known in this case, but one can numerically verify the relevant Birch--Swinnerton-Dyer analogue.
> fd := Coefficient(LTaylor(L,1,2),1); // L'(1) > OM := Periods(Q); > h := Height(pt : Precision:=10); > [fd/p/h : p in &cat OM]; [ 7.041379671 + 19.96043517*i, 29.92586360 + 0.6653478392*i, 1.34017E-28 + 21.16601049*i, 28.00000000 - 10.58300524*i ] > [Norm(x) : x in $1]; [ 448.0000000, 895.9999999, 448.0000000, 896.0000001 ]
Other examples of unitary L-functions with vanishing central value can come from modular forms (this was first noted/computed by W. A. Stein). We take the quadratic character of conductor 61 and modulus 122, and then compute the desired modular form and its associated modular symbols. This calculation already (rigorously) gives that the central value vanishes, and we can check this numerically also (and that the sign is nonorthogonal).
> chi := DirichletGroup(122).1; > f := Newforms(CuspForms(chi))[1][1]; // 1st isogeny class > LRatio(ModularSymbols(f),1); 0 > L := LSeries(f : Embedding:=func<x|Conjugates(x)[1]>); > CentralValue(L), Sign(L); 0.000000000000000000000000000000 -0.768221279597375842045546498599 - 0.640184399664479868371288748833*i
The above is the smallest example with quadratic character. Already at level 61 (likely a numerical coincidence) there is an example with sextic character.
> chi := DirichletGroup(61,CyclotomicField(6)).1; > f := Newforms(CuspForms(chi))[1][1]; // 1st isogeny class > LRatio(ModularSymbols(f),1); 0 > L := LSeries(f : Embedding:=func<x|Conjugates(x)[1]>); > CentralValue(L), Sign(L); 0.000000000000000000000000000000 -0.855151728742069755180538648199 + 0.518377778101501519766806791991*i