> 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); 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.)
> CheckFunctionalEquation(L); -2.958228394578794270293982119810E-31 > Evaluate(L,1); 0.0904903908324296291135897572580 > Evaluate(L,2); 0.364286342944364068154291450139
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.
> 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.0234062571006075114301535636401The 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)); 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; > CheckFunctionalEquation(L); 3.15544362088404722164691426113E-30
In fact, our L-series is the same as that constructed by LSeries(E,K)/LE.
> 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.655371552164974435712378842492
We take two L-functions with Euler products over a field K: L1(M, s)=∏p∏i=1m bigl(1 - αi(p)/N psbigr) - 1 ( and) L2(N, s)=∏p∏j=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)=∏p∏i=1m∏j=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.
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
> 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
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
> 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 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)= ∏p∏i=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.
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.
> 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
> 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
> 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
> 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
> 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