An L-series or an L-function is an infinite sum L(s)=∑n=1^∞an/ns in the complex variable s with complex coefficients an. Such functions arise in many places in mathematics and they are usually naturally associated with some kind of mathematical object, for instance a character, a number field, a curve, a modular form or a cohomology group of an algebraic variety. The coefficients an are certain invariants associated with that object. For example, in the case of a character chi: (Z/mZ)^ * to C^ * they are simply its values an=chi(n) when gcd(n, m)=1 and 0 otherwise.
Magma is able to associate an L-series to various types of object. The intrinsic which provides access to such pre-defined L-series (apart from the Riemann zeta function that is not quite associated with anything) is
{LSeries(object: optional parameters)}
Every such function returns a variable of type LSer. A range of functions may now be applied to this L-series object as described in the following sections, and these are independent of the object to which the L-series was originally associated. In fact, an object of type LSer only "remembers" its origin for printing purposes.
Precision: RngIntElt Default:
The Riemann zeta function ζ(s) is returned.The number of digits of precision to which the values ζ(s) are to be computed may be specified using the Precision parameter. If it is omitted, the precision of the default real field will be used.
Check that ζ(2) agrees numerically with π2/6.
> L := RiemannZeta( : Precision:=40); > Evaluate(L,2); 1.644934066848226436472415166646025189219 > Pi(RealField(40))^2/6; 1.644934066848226436472415166646025189219
Method: MonStgElt Default: "Default"
ClassNumberFormula: BoolElt Default: false
Precision: RngIntElt Default:
Create the Dedekind zeta function ζ(K, s) of a number field K. The series is defined by ∑I ( Norm)K/Q(I) - s, where the sum is taken over the non-zero ideals I of the maximal order of K. For K=Q, the series coincides with the Riemann zeta function.The optional parameter Method may be "Artin", "Direct" or "Default" and specifies whether the zeta function should be computed as a product of L-series of Artin representations or directly, by counting prime ideals. (The default behaviour depends upon the field.)
For the "Direct" method, the Dedekind zeta function has a simple pole at s=1 whose residue must be known in order to compute the L-values. The class number formula gives an expression for this residue in terms of the number of real/complex embeddings of K, the regulator, the class number and the number of roots of unity in K. If the optional parameter ClassNumberFormula is set to true, then these quantities are computed on initialization (using Magma's functions Signature(K), Regulator(K), #ClassGroup(MaximalOrder(K)) and #TorsionSubgroup(UnitGroup(K))) and it might take some time if the discriminant of K is large. If ClassNumberFormula is false (default) then the residue is computed numerically from the functional equation. This is generally faster, unless the discriminant of K is small and the precision is set to be very high.
The number of digits of precision to which the values ζ(K, s) are to be computed may be specified using the Precision parameter. If it is omitted the precision is taken to be that of the default real field.
> P<x> := PolynomialRing(Integers()); > K := NumberField(x^2+1); > L := LSeries(K); > Evaluate(L, 2); 1.50670300992298503088656504818This particular example could have been expressed somewhat more succinctly by replacing the first two lines by either K:=CyclotomicField(4) or K:=QuadraticField(-1).
> R<x> := PolynomialRing(Rationals()); > F := NumberField(x^12-3); > L := LSeries(F: Method:="Direct"); Time: 0.078 > Conductor(L), LCfRequired(L); 1579460446107205632 92968955438The set-up time for the direct method is negligible, but the L-value computation will take days for this number of coefficients. On the other hand, the normal closure of F is not too large and has only representations of small dimension:
> G := GaloisGroup(F); > #G, [Degree(ch): ch in CharacterTable(G)]; 24 [ 1, 1, 1, 1, 2, 2, 2, 2, 2 ] > time L := LSeries(F : Method:="Artin"); Time: 5.234It took longer to define the L-series, but the advantage is that it is a product of L-series with very small conductors, and the L-value calculations are almost instant:
> [Conductor(f[1]) : f in Factorisation(L)]; [ 1, 12, 3888, 576, 243, 15552, 15552 ] > time Evaluate(L, 2); 1.63925427193646882835990708818 Time: 3.250
> _<x> := PolynomialRing(Rationals()); > K<s5> := NumberField( x^2-5 ); > L<s205> := NumberField( x^2-205 ); > C := Compositum(K,L); > e1 := C!(5+s5); > e2 := C!(41+s205); > E:=ext<C | Polynomial( [ -e1*e2, 0, 1] )>; > A:=AbsoluteField(E); > DefiningPolynomial(A); x^8 - 820*x^6 + 223040*x^4 - 24206400*x^2 + 871430400 > Signature(A); // totally real 8 0 > L := LSeries(A); > LCfRequired(L); 2739 > CheckFunctionalEquation(L); 1.57772181044202361082345713057E-30 > Evaluate(L, 1/2); // zero as expected -9.98707556173617338749102627597E-62
So the evaluation of L at 1/2 is zero as expected. In fact, L is a product, and one factor has odd sign:
> L`prod; [ <L-series of Riemann zeta function, 1>, <L-series of Artin representation of Number Field A with character ( 1, 1, 1, -1, -1 ) and conductor 41, 1>, <L-series of Artin representation of Number Field A with character ( 1, 1, -1, -1, 1 ) and conductor 5, 1>, <L-series of Artin representation of Number Field A with character ( 1, 1, -1, 1, -1 ) and conductor 205, 1>, <L-series of Artin representation of Number Field A with character ( 2, -2, 0, 0, 0 ) and conductor 42025, 2> ] > [ ComplexField(9)!Sign(x[1]) : x in $1 ]; [ 1.00000000, 1.00000000, 1.00000000, 1.00000000, -1.00000000 ] > Sign(L`prod[5][1]); -1.00000000000000000000000000000
Precision: RngIntElt Default:
Creates the L-series of an Artin representation A. (For information about Artin representations see Chapter ARTIN REPRESENTATIONS.)
> K := QuadraticField(-1); > triv,sign := Explode(ArtinRepresentations(K)); > Evaluate(LSeries(triv), 2); // zeta(2)=pi^2/6 1.64493406684822643647241516665 > Evaluate(LSeries(sign), 2); 0.915965594177219015054603514933
> load galpols; > f:=PolynomialWithGaloisGroup(7,6); > K:=NumberField(f); > A:=ArtinRepresentations(K); > a:=A[2];a; Artin representation of Number Field with defining polynomial x^7 - 2*x^6 - 7*x^5 + 11*x^4 + 16*x^3 - 14*x^2 - 11*x + 2 over the Rational Field with character ( 6, 2, 3, 0, 0, 1, -1, -1, -1 ) and conductor 988410721Its L-series with the default precision of 30 digits needs a lot of coefficients to compute with
> L:=LSeries(a); > LCfRequired(L); 1830809We decrease the precision to 8 digits
> L:=LSeries(a: Precision:=8); > LCfRequired(L); 52584Now it takes under 30 seconds to verify the functional equation of L(a, s) and to compute its value at s=2.
> CheckFunctionalEquation(L); -2.9802322E-7 > Evaluate(L,2); 1.1105970
Precision: RngIntElt Default:
Create the L-series L(E, s) of an elliptic curve E defined over Q or over a number field.The number of digits of precision to which the values L(E, s) are to be computed may be specified using the Precision parameter. If it is omitted the precision is taken to be that of the default real field.
Note that the computation time for evaluating an L-series grows roughly like the square root of the conductor (or its norm to Q if the base field is a number field). Therefore an evaluation might take an unreasonable amount of time if the conductor of E is much larger than, say, 1010 or so. If only the leading term at s=1 is required, over Q it is faster to use AnalyticRank or ConjecturalRegulator.
Note also for general number fields it is only conjectured that L(E/K, s) has a meromorphic continuation to C and also possesses a functional equation. This conjecture is implicitly used in the computations.
> E := EllipticCurve([0,1,1,0,0]); > Conductor(E); 43 > L:=LSeries(E); > Evaluate(L, 1); 0.000000000000000000000000000000 > Evaluate(L, 1 : Derivative:=1); 0.343523974618478230618071163922Now base change E to K=Q(i). The Mordell-Weil rank of E over K is 2:
> Rank(E) + Rank(QuadraticTwist(E,-1)); 2So we expect L(E/K, s) to have a zero of order 2:
> K := QuadraticField(-1); > EK := BaseChange(E, K); > L := LSeries(EK); > Evaluate(L, 1); 0.000000000000000000000000000000 > Evaluate(L, 1 : Derivative:=1) lt 10^-20; true > Evaluate(L, 1 : Derivative:=2); 1.62399545025600030722546910342
Method: MonStgElt Default: "Default"
Precision: RngIntElt Default:
Given an elliptic curve E defined over the rationals and a number field K, create the L-series L(E/K, s) associated with E/K. Note that in general it is only conjectured that L(E/K, s) has an analytic continuation to C and possesses a functional equation. This conjecture is implicitly used in the computations.Technically, the resulting L-series is the tensor product of two l-adic representations, the one associated to E/Q and the one associated to K/Q. Method specifies how LSeries(K) should be defined. It is the same parameter as for LSeries(FldNum), except that when E and K both have wild ramification at either 2 or 3, "Direct" is always used. Note that the conductor of the L-series L(E/K, s) usually increases very rapidly with the discriminant of K. Consequently, if the used method is "Direct" or the irreducible constituents of PermutationCharacter(K) have large dimension, the computation time may be quite substantial.
The number of digits of precision to which the values L(E/K, s) are to be computed may be specified using the Precision parameter. If it is omitted the precision is taken to be that of the default real field.
> E := EllipticCurve([0, 0, 0, 1, 0]); > F := QuadraticTwist(E, 5); > L := LSeries(E, QuadraticField(5)); > Evaluate(L, 1); 1.53733828470360522458966069195 > Evaluate(LSeries(E),1) * Evaluate(LSeries(F),1); 1.53733828470360522458966069195Here is another example over a cyclotomic field. The L-value computations are fast, as here they only involve one-dimensional twists:
> E := EllipticCurve([0, 0, 0, 1, 0]); > L := LSeries(E, CyclotomicField(11)); > time Evaluate(L, 1); -1.03578452039312258255988860081E-28 Time: 4.797
Precision: RngIntElt Default:
Twisted L-series of an elliptic curve E/Q by an Artin representation A. Currently does not allow E and A to be simultaneously wildly ramified at either 2 or 3.
> E := EllipticCurve(CremonaDatabase(),"11A3"); > K := CyclotomicField(5); > art := ArtinRepresentations(K); > for A in art do Evaluate(LSeries(E,A),1); end for; 0.253841860855910684337758923351 0.685976714588516438169889514223 + 1.10993363969520543571381847366*$.1 2.83803828204429619496466743334 0.685976714588516438169889514223 - 1.10993363969520543571381847366*$.1All the L-values are non-zero, so according to the Birch-Swinnerton-Dyer conjecture E has rank 0 over Q(ζ5). Indeed:
> #TwoSelmerGroup(BaseChange(E,K)); 1
> load galpols; > E:=EllipticCurve("11a3"); // X_1(11) > f:=PolynomialWithGaloisGroup(8,5); // Quaternion Galois group > K:=NumberField(f); > A:=ArtinRepresentations(K); > assert exists(a){a: a in A | Degree(a) eq 2};a; Artin representation of Number Field with defining polynomial x^8 - 12*x^6 + 36*x^4 - 36*x^2 + 9 over the Rational Field with character ( 2, -2, 0, 0, 0 ) > L:=LSeries(E,a: Precision:=10); > LCfRequired(L); 208818 > time Evaluate(L,1); 1.678012769 Time: 23.688 > Sign(L); 1.000000002
Precision: RngIntElt Default:
ExcFactors: SeqEnum Default: []
L-series of a hyperelliptic curve C defined over the rationals.The number of digits of precision to which the values L(C, s) are to be computed may be specified using the Precision parameter. If it is omitted the precision is taken to be that of the default real field. If the conductor exponents and the local factors at (some of) the bad primes are known in advance, they can be passed as a sequence of tuples <prime,conductor exponent,local factor>, e.g. ExcFactors:=[< 2, 11, 1 - x >].
> R<x> := PolynomialRing(Rationals()); > C := HyperellipticCurve(x^5+1); > L := LSeries(C: Precision:=18); > LCfRequired(L); // need this number of coefficients 1809 > Evaluate(L,1); // L(C,1) 1.03140710417331775 > Sign(L); // sign in the functional equation 1.00000000000000000The L-value is non-zero, indicating that the Jacobian should have rank 0. In fact, it does:
> RankBound(Jacobian(C)); 0
Precision: RngIntElt Default:
Given a primitive dirichlet character chi: (Z/mZ)^ * to C^ *, create the associated Dirichlet L-series L(chi, s)=∑n=1^∞chi(n)/ns. The character chi must be defined so that its values fall in either the ring of integers, the rational field or a cyclotomic field.The number of digits of precision to which the values L(chi, s) are to be computed may be specified using the Precision parameter. If it is omitted the precision is taken to be that of the default real field.
For information on Dirichlet characters, see Section Dirichlet Characters.
> G<Chi> := DirichletGroup(37, CyclotomicField(36)); > L := LSeries(Chi); > Evaluate(L,1); // depends on the chosen generator of G 1.65325576836885655776002342451 - 0.551607898922910805875537715934*$.1
Given a cuspidal newform in a space of Hilbert modular forms, this creates the associated L-series.
> K := QuadraticField(5); > H := HilbertCuspForms(K,7*Integers(K),[2,2]); > f := NewformDecomposition(NewSubspace(H))[1]; > L := LSeries(Eigenform(f)); > LSetPrecision(L,9); > LCfRequired(L); 198 > time CheckFunctionalEquation(L); -2.32830644E-10 Time: 16.590
Precision: RngIntElt Default:
Given a primitive Hecke (Grössen)character on ideals, construct the associated L-series.For more information on these see Section Characters.
Embedding: Map/UserProgram Default:
Precision: RngIntElt Default:
Given a modular form f, construct the L-series L(f, s)=∑n=1^∞an/ns, where f has the q-expansion ∑n=0^∞an qn. It is assumed that L(f, s) satisfies a functional equation of the standard kind (see Section Terminology for the precise form of the functional equation).The optional parameter embedding specifies a map which embeds the coefficients of f into the complex field. By default this is the identity map, so that the coefficients of f must be coercible into C. Otherwise, the value of the parameter must either be an object of type Map or a user-defined function e(x) each having domain the base ring of f and codomain the complex field (or values than can be coerced into the complex field).
The number of digits of precision to which the values L(f, s) are to be computed may be specified using the Precision parameter. If it is omitted the precision is taken to be that of the default real field.
> f := Newforms("G1N16k2A")[1]; f; q + (-a - 1)*q^2 + (a - 1)*q^3 + 2*a*q^4 + (-a - 1)*q^5 + 2*q^6 - 2*a*q^7 + O(q^8) > B:=BaseRing(f); B; Equation Order with defining polynomial x^2 + 1 over ZThe two distinct embeddings of B into the complex numbers give rise to two modular forms, which can be accessed using the ComplexEmbeddings function.
> f1, f2 := Explode(ComplexEmbeddings(f)[1]); > Coefficient(f,2), Coefficient(f1,2), Coefficient(f2,2); -a - 1 -1.00000000000000000000000000000 + 1.00000000000000000000000000000*$.1 -1.00000000000000000000000000000 - 1.00000000000000000000000000000*$.1Thus, f1 and f2 have genuine complex coefficients and we can construct the associated L-series and compute their L-values, for instance at s=1.
> L1 := LSeries(f1); > L2 := LSeries(f2); > CheckFunctionalEquation(L1); -2.36658271566303541623518569585E-30 > CheckFunctionalEquation(L2); -2.36658271566303541623518569585E-30 > v1 := Evaluate(L1,1); v2 := Evaluate(L2,1); v1,v2; 0.359306437003505684066327207778 + 0.0714704939991172686588458066910*$.1 0.359306437003505684066327207778 - 0.0714704939991172686588458066910*$.1If instead we invoke LSeries(f), Magma will note that f is defined over a number field and complain that the coefficients of f are not well-defined complex numbers.
> L := LSeries(f); For f over a number field, you have to specify a complex embeddingInstead of using ComplexEmbeddings, one can instead explicitly specify an embedding of the coefficients of B into the complex numbers using the parameter Embedding with the function LSeries The following statements define the same L-function as L2 above.
> C<i> := ComplexField(); > L2A := LSeries(f: Embedding:=hom< B -> C | i > ); > L2B := LSeries(f: Embedding:=func< x | Conjugates(x)[1] > ); > L2C := LSeries(f1: Embedding:=func< x | ComplexConjugate(x) > );
Finally, we illustrate the very important fact that Magma expects, but does not check that the L-function associated to a modular form satisfies a functional equation.
> L := LSeries(f1+f2); // or L:=LSeries(f: Embedding:=func<x|Trace(B!x)>);
Although Magma is happy with this definition, it is in fact illegal. The modular form f has a character whose values lie in the field of the 4-th roots of unity.
> Order(DirichletCharacter(f)); 4
The two embeddings f1 and f2 of f have different (complex conjugate) characters and f1 + f2 does not satisfy a functional equation of the standard kind. Magma will suspect this when it tries to determine the sign in the functional equation and thereby print a warning:
> Evaluate(L,1); |Sign| is far from 1, wrong functional equation? 0.736718188651826073550560964422 > CheckFunctionalEquation(L); 0.00814338037134482026061721221244
The function CheckFunctionalEquation should return 0 (to current precision), so the functional equation is not satisfied, and the result of evaluating L will be a random number. So it is the user's responsibility to ensure that the modular form does satisfy a functional equation as described in Section Terminology. Here are some examples of modular forms that do.
> CheckFunctionalEquation(LSeries(f1^2*f2)); 1.57772181044202361082345713057E-30 > f3 := ModularForm(EllipticCurve([0, -1, 1, 0, 0])); > CheckFunctionalEquation(LSeries(f3)); 0.000000000000000000000000000000 > M := Newforms("37k2"); > f4 := M[1,1]; f5 := M[2,1]; f6 := M[3,1]; > CheckFunctionalEquation(LSeries((f5+2*f6)*f4)); 5.91645678915758854058796423962E-31