|
|
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
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);
Runtime error: L*(s) has a pole at s = 1
> L := Z/RiemannZeta();
> Evaluate(L,1);
0.339837278240523535464278781159
We construct 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.)
> 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
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 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.
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;
WARNING: 2 is ramified in each part of tensor prod
WARNING: 3 is ramified in each part of tensor prod
> CFENew(L);
0.0234062571006075114301535636259
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, 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));
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;
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.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.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
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
|