With the exception of some modular forms, all the built-in L-series have weakly multiplicative coefficients, so that L(s)=∑an/ns with amn=aman for m, n coprime. For two such L-series, Magma allows the user to construct their product and, provided that it makes sense, their quotient.
There are also various methods to construct a new L-function from old L-functions, namely tensor products and symmetrizations. The notion of Hodge structure is also useful to have.
Poles: SeqEnum Default: []
Residues: SeqEnum Default: []
Precision: RngIntElt Default:
Let L1(s) and L2(s) be two L-series of the same weight whose coefficients are weakly multiplicative, that is, they satisfy amn=aman for m, n coprime. This function constructs their product L(s)=L1(s)L2(s).If one of the L-series has zeros that cancel the poles of the other L-series, the user should specify the list of poles for L1 * (s)L2 * (s) using the Poles parameter and the corresponding residues using the Residues parameter. See Section Terminology for the terminology and Section Constructing a General L-Series for the format of the poles and residues parameters.
The number of digits of precision to which the values L(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.
Poles: SeqEnum Default: []
Residues: SeqEnum Default: []
Precision: RngIntElt Default:
Let L1(s) and L2(s) be two L-series whose coefficients amn are weakly multiplicative, that is, they satisfy amn=aman for m, n coprime. This function constructs their quotient L(s)=L1(s)/L2(s).This function assumes (but does not check!) that this quotient exists and is a genuine L-function with finitely many poles.
If L2(s) happens to have zeros that give poles in the quotient, the user must specify the list of poles of L1 * (s)/L2 * (s) using the Poles parameter and the corresponding residues using the Residues parameter. See Section Terminology for the terminology and Section Constructing a General L-Series for the format of Poles and Residues.
The number of digits of precision to which the values L(s) are to be computed may be specified using the Precision parameter. If it is omitted, the precision is taken to be minimum of that of the inputs.
Magma can compute with Hodge structures of an L-series. In the sense of Deligne [Del79, Table 5.3], this is printed as a series of < p, q > pairs and < p, p, ε > triples, where the former have p<q and correspond to Hp, q and Hq, p, and with the latter F_∞=( - 1)p + ε is the action of complex conjugation on Hp, p. An alternative printing (of the HodgeVector) can be obtained from the vararg PrintHodgeVector or PHV when creating a Hodge structure.
Hodge structures of the same weight (possibly negative) can be added or subtracted (though virtual Hodge structures are not currently allowed). They can also be tensored and inverted (the latter negates all p, q) via the multiplication operator and Dual.
Given an L-series, determine if it has a Hodge structure. The HodgeStructure intrinsic can also be applied to various other objects.
Given a sequence (or other aggregate) of tuples corresponding to Hodge (p, q)'s, construct the given Hodge structure. Here both (p, q) and (q, p) must be given (for redundancy), and (p, p, ε) must have its sign given as a third element in the tuple.
Given a weight and a sequence of γ-shifts, return the Hodge structure.
Given a Hodge structure, negate all the (p, q)'s.
Given a Hodge structure and an integer, take the Tate twist of the structure. This subtracts k from all the p and q, decreasing the weight by 2k. This corresponds to translating the L-function in the complex plane.
Given an L-series, translate it by the given integer (or rational).
The γ-factors (or shifts), degree, and (motivic) weight of a Hodge structure.
The Hodge structure obtained by shifting so that all p, q≥0 with at least one of them equal to zero. Also returns the shift amount.
The root number at ∞ of a Hodge structure, which is a 4th root of unity.Note that this is the reciprocal of that given by Deligne in [Del79, Table 5.3].
This is the standard operation on Hodge structures, also accessible via the '*' operator.
The mth symmetric power of a Hodge structure.
The determinant of a Hodge structure.
The alternating square of Hodge structure. The general symmetrization intrinsic for Hodge structures has not been implemented at this time, but these last examples are probably the more interesting cases.
Given a Hodge structure, return its Hodge vector, and the Tate twist to make it effective. This is an array of hp, q starting which the first nonzero.
Given a Hodge structure or an L-series with a Hodge structure, return its critical points. In the case that the list is infinite, it will be truncated at height 100.
Take the tensor product with the nontrivial weight 0 Hodge structure.
> LE := LSeries(EllipticCurve("11a"));
> HE := HodgeStructure(LE); HE;
Hodge structure of weight 1 given by <0,1>
> Lf := LSeries(Newforms(CuspForms(9,4))[1][1]);
> Hf := HodgeStructure(Lf); Hf;
Hodge structure of weight 3 given by <0,3>
> PR := Translate(LE,1)*Lf;
> HodgeStructure(PR);
Hodge structure of weight 3 given by <0,3> <1,2>
> TateTwist(HE,-1)+Hf; // direct sum
Hodge structure of weight 3 given by <0,3> <1,2>
> TP := TensorProduct(LE,Lf);
> HodgeStructure(TP);
Hodge structure of weight 4 given by <0,4> <1,3>
> HE*Hf; // tensor product
Hodge structure of weight 4 given by <0,4> <1,3>
> RootNumber(HodgeStructure([[0,0,1]])); // imag quad field
-zeta_4
> RootNumber(HE); // elliptic curve
-1
> RootNumber(Hf); // wt 4 modform
1
> assert SymmetricPower(HE,2) eq HodgeStructure(SymmetricPower(LE,2));
> CriticalPoints(SymmetricPower(Hf,2));
[ 1, 3, 4, 6 ]
> CriticalPoints(ImaginaryTwist(SymmetricPower(Hf,2)));
[ 2, 5 ]
The above discussion with Hodge structure folds nicely into the TensorProduct machinery.
BadPrimes: SeqEnum Default: []
Precision: RngIntElt Default:
Sign: FldComElt Default:
Let L1 and L2 be L-functions such that L1(s)=L(V1, s) and L2(s)=L(V2, s) are associated to systems of l-adic representations V1 and V2 (à la Serre). This function computes their tensor product L(s)=L(V1 tensor V2, s). This can be used, for example, to twist an L-function by characters or higher-dimensional Artin representations (see Examples H136E43, H136E44).Note that, in particular, both L1(s) and L2(s) must have integer conductor, weakly multiplicative coefficients and an underlying Hodge structure (which is computed from the γ-shifts). The argument ExcFactors (or the vararg BadPrimes) is a list of tuples of the form < p, v > or < p, v, Fp(x) > that give, for each of the primes p where V1 and V2 both have bad reduction, the valuation v of the conductor of V1 tensor V2 at p and the inverse local factor at p. If the data is not provided for such a prime p, Magma will attempt to compute the local factors by assuming that the inertia invariants behave well at p,
(V1 tensor V2)Ip = V1Ip tensor V2Ip.
It will also compute the conductor exponents by predicting the tame and wild degrees from the degrees of the local factors, but this does not work if both V1 and V2 are wildly ramified at p.
The sign in the functional equation of L(V1 tensor V2, s) cannot be determined from the signs of the factors, so it will be calculated numerically from the functional equation. If the sign is known, the user may specify it by means of the Sign parameter.
The number of digits of precision to which the values L(s) are to be computed may be specified using the Precision parameter. If it is omitted, the precision is taken to be the minimal precision among the tensor parts.
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.
However, if L1 and L2 have Euler products over the same field K, this field can be given as an additional argument, and the tensor product will be taken with respect to that field. Namely, we take two L-functions with Euler products over a field K: L1(M, s)=∏p∏i=1m (1 - αi(p)/N ps) - 1 (and) L2(N, s)=∏p∏j=1n (1 - βj(p)/N ps) - 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 (1 - αi(p)βj(p)/N ps) - 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.
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, [ -1, 0, 0, 1 ], 34969, function(p, d [ Precision ]) ... end function, 0,
[], []>
> CFENew(L);
0.000000000000000000000000000000
> f1 := ModularForms(1,12).2; > f2 := ModularForms(1,26).2; > L1 := LSeries(f1); > L2 := LSeries(f2); > L := TensorProduct(L1, L2, []); WARNING: Modular form is not known to be a newform WARNING: Modular form is not known to be a newform > LSeriesData(L); // weight is (12-1)+(26-1)+1 -- motivic weight is 11+25 <37, [ -11, -10, 0, 1 ], 1, function(p, d [ Precision ]) ... end function, 0, [], []> > CFENew(L); 0.000000000000000000000000000000 > Pi(RealField(30))^2 * Evaluate(L,24) / Evaluate(L,25); 9.87142857142857142857142857142 > 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)
WARNING: Modular form is not known to be a newform
> time CFENew(L);
3.15544362088404722164691426113E-30
Time: 1.900
> 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); // approx for old CheckFunctionalEquation 1642 > CFENew(TP); 0.000000000
> K := NumberField(x^2 - 5) where x is PolynomialRing(Rationals()).1; > SetStoreModularForms(K, true); // to save computation time > f5 := Factorization(5*Integers(K))[1][1]; > H := HilbertCuspForms(K,2*3*f5,[2,4]); > N := NewformDecomposition(NewSubspace(H)); // 4-dimensional > f11 := Factorization(11*Integers(K))[1][1]; // get right form > f := [f : f in N | HeckeEigenvalue(Eigenform(f),f11) eq -2*K.1-58][1]; > Lf := LSeries(Eigenform(f)); > psi := HeckeCharacterGroup(f5,[1,2]).1; > Lpsi := LSeries(psi); > R := PolynomialRing(Integers()); > TP := TensorProduct(Lf,Lpsi,[<f5,3,R!1>],K); // 5^4 in all, 1 from K
The above constructs the L-series of a specific Hilbert modular form of weight [2, 4] of level 6√5 over (Q)(√5), and then twists it by a nontrivial Hecke character. This corresponds to twisting the Fourier coefficients by a Dirichlet character of this field, which yields a Hilbert modular form at level 6(√5)2. We construct this latter form below.
We then compare the L-series data (to ensure that Magma correctly worked with the Hodge structure over the real quadratic field in the tensor product), and Euler factors up to 100 (a weak check). The use of CFENew or CheckFunctionalEquation to (say) 6 digits takes a few minutes, so we omit it here.
> H := HilbertCuspForms(K, 2*3*f5^2, [2,4]);
> time N := NewformDecomposition(NewSubspace(H));
Time: 1.410
> g := [g : g in N | Dimension(g) eq 1 and
> HeckeEigenvalue(Eigenform(g),f11) eq -2*K.1-58][1];
> Lg := LSeries(Eigenform(g));
> assert forall{ i : i in [1..3] |
> LSeriesData(TP)[i] eq LSeriesData(Lg)[i] };
> // weak check of Euler factors
> assert forall{ p : p in PrimesUpTo(100) |
> EulerFactor(TP, p : Degree:=1, Integral) eq
> EulerFactor(Lg, p : Degree:=1, Integral) };
> // weak check of Euler over K
> assert forall{ p : p in PrimesUpTo(100, K) |
> Round(Coefficient(EulerFactor(TP, p), 1)) eq
> Round(Coefficient(EulerFactor(Lg, p), 1)) };
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 (1 - ψ(p)k/N ps) - 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 (1 - α1(p)k - iα2(p)i/N ps) - 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.
More general symmetrizations are also possible, with the determinant and the alternating square perhaps being the most useful.
Translate: BoolElt Default: false
This computes the determinant L-series, returned as a translate of an L-function of a Dirichlet character.
BadPrimes: SeqEnum Default: []
Return the L-series corresponding to the mth symmetric power of L. The BadPrimes vararg 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; > L := LSeries(chi); > LS3 := SymmetricPower(L, 3); > Lc3 := LSeries(chi^3); > Evaluate(LS3, 1); 0.843964498053507794372984784472 + 0.199232992137116783033645803753*i > Evaluate(Lc3, 1); 0.843964498053507794372984784472 + 0.199232992137116783033645803753*i
> K := QuadraticField(-23); > I := Factorization(23 * IntegerRing(K))[1][1]; > G := HeckeCharacterGroup(I); > psi := G.1^14; > 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); 4.48608491213433366278327243071 + 0.424809367967343270765667919450*i > Evaluate(Lp4, 3); 4.48608491213433366278327243071 + 0.424809367967343270765667919450*i
> E := EllipticCurve("389a");
> L := LSeries(E);
> L2 := SymmetricPower(L, 2);
> LSeriesData(L2);
<3, [ 0, 1, 0 ], 151321, 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"); // conductor 73
> L := LSeries(E); // note this is < 389 (!)
> L3 := SymmetricPower(L, 3);
> LSeriesData(L3); // Magma knows the Sign is +1
<4, [ 0, -1, 1, 0 ], 389017, function(p, d) ... end function, 1, [], []>
> LSetPrecision(L3, 9);
> CentralValue(L3); // analytic rank 2
-1.14998623E-16
BadPrimes: SeqEnum Default: []
PoleOrder: RngIntElt Default: 0
Induction: BoolElt Default: true
The Symmetrization intrinsic is the general workhorse. It takes an L-function and a partition (weakly decreasing sequence of nonnegative integers) as inputs. The BadPrimes vararg is as with other cases, while PoleOrder specifies that an appropriate translate of the Riemann ζ-function will be a factor of the result (Magma knows about this is some cases). Finally, the Induction vararg controls how GL(1) objects over fields larger than Q are handled.Magma will reduce the symmetrization, so that, for example, the {6, 4}-symmetrization of a degree 2 L-function will just be the translate by 4 of its symmetric square. However, the practical symmetrizations that can be computed are still rather limited. Thus, for reasons of efficiency, Magma contains hardcoded formulas for small degree examples. For degree 2 these include all symmetric powers. For degree 3 it includes the symmetric cube, the alternating square ({1, 1}-symmetrization), and {2, 1}-symmetrization, not to mention the determinant (which is always available). For degree 4 Magma has the symmetric and alternating squares, and for degree 5 the alternating square is available. Furthermore, for objects such as Artin representations, Symmetrization can be applied to the object itself, and the resulting L-function is (highly) imprimitive, easing computations.
AssumeTrue: BoolElt Default: false
AssumeFalse: BoolElt Default: false
Given an L-function return whether it is orthogonal (respectively symplectic). Firstly this means it is self-dual, that is it has real coefficients (a check is done for the first few values). If the motivic weight is odd, then it is symplectic but not orthogonal. If the degree is odd, then it is orthogonal but not symplectic. If both the degree and motivic weight are even, then currently the user must specify AssumeTrue or AssumeFalse for a result to be given.
BadPrimes: SeqEnum Default: []
PoleOrder: RngIntElt Default: 0
Given an orthogonal L-function and a suitable partition p, return the orthogonal symmetrization. Referring to Section Symmetrization, the symmetrization of L can factor into smaller parts. In particular, one can throw out "old" factors, and concentrate on those that are truly new. In general, one should have that the degree exceeds twice the number of parts in the partition (see the "modification rules" in the above reference), as these form a basis for the representation space (up to twisting).In degree 2, the relevant partitions are of the form (m), and all the orthogonal symmetrizations themselves have degree 2. In degree 3, again the relevant partitions are singletons, and the orthogonal mth power has degree 2m + 1. Magma allows one to consider m≤4 via hand-coded formulas. In degree 4 the practical partitions are (2) and (2, 2), these leading to degree 9 and 10 L-functions respectively.
Similarly one can compute the symplectic symmetrization of a symplectic L-function. The only (interesting) available case is for degree 4 L-functions, when the (1, 1) partition gives a L-function of degree 5.
> x := PolynomialRing(Integers()).1; > Lf := LSeries(Newforms(ModularForms(25,4))[1][1]); > S2 := Symmetrization(Lf,[2] : BadPrimes:=[<5,2,1+125*x>]); > CFENew(S2); 0.000000000000000000000000000000 > S31 := Symmetrization(Lf,[3,1] : BadPrimes:=[<5,2,1+5^7*x>]); > CFENew(S31); 0.000000000000000000000000000000 > LSetPrecision(Lf,10); > S3 := Symmetrization(Lf,[3] : BadPrimes:=[<5,4,1>]); > CFENew(S3); 0.0000000000 > S4 := Symmetrization(Lf,[4] : BadPrimes:=[<5,4,1-125^2*x>]); > CFENew(S4); 5.820766091E-11
Another (unitary) example in degree 2 is from a weight 2 newform with complex character. Here we take a "semistable" example, as for such L-functions it is relatively easy to compute the bad prime info.
> f := Newforms(CuspForms(FullDirichletGroup(13).1^2,2))[1][1]; > L := LSeries(f : Embedding:=func<x|Conjugates(x)[1]>); > BP := [<13,2,Polynomial([1,-(-Coefficient(EulerFactor(L,13),1))^2])>]; > S2 := Symmetrization(L,[2] : BadPrimes:=BP); > CFENew(S2); // deg 3, conductor 169 0.000000000000000000000000000000 > LSetPrecision(L,15); > BP := [<13,3,Polynomial([1,-(-Coefficient(EulerFactor(L,13),1))^3])>]; > S3 := Symmetrization(L,[3] : BadPrimes:=BP); > CFENew(S3); // deg 4, conductor 13^3 8.88178419700125E-16 > LSetPrecision(L,5); > BP := [<13,4,Polynomial([1,-(-Coefficient(EulerFactor(L,13),1))^4])>]; > S4 := Symmetrization(L,[4] : BadPrimes:=BP); > CFENew(S4); // deg 5, conductor 13^4 0.00000
> H := HypergeometricData([1,1,1],[2,2,2]); > L := LSeries(H,2 : BadPrimes:=[<2,8,1>],SaveEuler:=10000); > LSetPrecision(L,5); > assert IsOrthogonal(L); // degree 3 weight 2 > S3 := Symmetrization(L,[3] : BadPrimes:=[<2,26,1>]); > [Degree(x[1]) : x in Factorization(S3)]; [ 8, 3 ] > CFENew(S3); // 2^18 for deg 7 factor 0.045944
It would be more efficient to compute the above information using OrthogonalSymmetrization. Note that the BadPrimes vararg in the first form referred to the whole L-functions, while when using this second form we center on the degree 7 constituent.
> O3 := OrthogonalSymmetrization(L,[3] : BadPrimes:=[<2,18,1>]); > Degree(O3); 7 > CFENew(O3); // L-coeffs already computed, thanks to SaveEuler 0.00000
The {2, 1}-symmetrization of a degree 3 L-function has degree 8, and when the input is orthogonal there is a degree 3 constituent corresponding to the L-function.
> LSetPrecision(L,20); > S21 := Symmetrization(L,[2,1] : BadPrimes:=[<2,20,1>]); // deg 8 > CFENew(S21); 0.00000000000000000000 > LT := Translate(L,2); > CFENew(S21/LT); 0.00000000000000000000
The degree 5 constituent is the orthogonal symmetric square twisted by the determinant.
> D := Determinant(L); D; Translation by 3 of L-series of Kronecker character -4 > O2 := OrthogonalSymmetrization(L,[2] : BadPrimes:=[<2,10,1>]); > CFENew(O2); 0.00000000000000000000 > TP := TensorProduct(O2,D : BadPrimes:=[<2,12,1>]); > Q := Translate(S21/LT,2); > P := PrimesUpTo(100); > assert &and[EulerFactor(TP,p) eq EulerFactor(Q,p) : p in P];
Be careful here! It turns out that CFENew works to 12 digits for the quotient of S21 with the Determinant, but in fact there is no such factorization at the level of L-functions (the issue is likely that the lowest height zero on the critical line for the Determinant is rather large, and thus the poles in the L-quotient do not contribute much).
> CFENew(S21/LT/D); // the product of these 2.5742151368679484303E-6 > CFENew(LT/D); // last two is ~10^(-12) 6.3865388810908029459E-5
A superior way to detect constituents is through taking a Selberg inner product; here this would just be looking at the average cp value when twisting by the appropriate Dirichlet character.
The {1, 1}-symmetrization (or alternating square) of a degree 3 L-function is actually a translate of the original L-function tensored with its determinant.
> S := Symmetrization(L,[1,1] : BadPrimes:=[<2,8,1>]); > DL := TensorProduct(D,L : BadPrimes:=[<2,8,1>]); > T := Translate(DL,-2); > assert &and[EulerFactor(T,p) eq EulerFactor(S,p) : p in P];
> x := PolynomialRing(Integers()).1; > H := HypergeometricData([4,4],[1,1,2,2]); > L := LSeries(H,2 : Precision:=10); > assert IsSymplectic(L); // degree 4 weight 1 > L`parent; Elliptic Curve defined by y^2 + x*y + $.1*y = x^3 + $.1*x^2 over Number Field with defining polynomial x^2 - 1/512 over the Rational Field > S := Symmetrization(L,[1,1] : BadPrimes:=[<2,16,1-2*x>]); > Degree(S); 6 > CFENew(S); 0.0000000000 > Factorization(S)[2]; <Translation by 1 of L-series of Riemann zeta function, 1>
Alternatively, we can compute this via the symplectic symmetrization, when we don't have to specify the bad prime information corresponding to the ζ-function.
> S := SymplecticSymmetrization(L,[1,1] : BadPrimes:=[<2,16,1>]); > Degree(S); 5 > CFENew(S); 0.0000000000
Another example comes from hypergeometric motives, where here the conductor is sufficiently small so that the slowdown from computing quadratic coefficients is not too problematic.
> H := HypergeometricData([4,2,2,2,2],[1,1,1,1,1,1]); > L := LSeries(H,1 : Precision:=10); // t=1 degeneration > Conductor(L); // degree 4, conductor 2^8, motivic wt 5 256 > S := SymplecticSymmetrization(L,[1,1] : BadPrimes:=[<2,8,1>]); > time CFENew(S); 0.0000000000 Time: 2.300
An additional source of such L-functions could be Grössencharacters, though these are inductions from GL(1).
> K<zeta5> := CyclotomicField(5); > p5 := Factorization(5*Integers(K))[1][1]; > psi := HeckeCharacterGroup(p5^2).0; > GR := Grossencharacter(psi,[[3,0],[1,2]]); > L := LSeries(GR : Precision:=15); > S := SymplecticSymmetrization(L,[1,1] : BadPrimes:=[<5,6,1>]); > CFENew(S); // S is imprimitive 0.000000000000000 > Q := S/Translate(LSeries(KroneckerCharacter(5)),3); > CFENew(Q); 0.000000000000000
Here are some examples involving the higher orthogonal symmetrizations. Again we note that computing the quadratic term of the underlying L-function can sometimes be quite time-consuming.
> _<x> := PolynomialRing(Integers()); > H := HypergeometricData([2,2,2],[1,1,1]); > L := LSeries(H,2 : BadPrimes:=[<2,9,1>],Precision:=5); > BP := [<2,18,1-16*x>]; > O4 := OrthogonalSymmetrization(L,[4] : BadPrimes:=BP); > CFENew(O4); // OSym^4(deg3) // deg 9 0.00000 > H := HypergeometricData([2,2,2,2,2],[1,1,1,4]); > L := LSeries(H,1); // degree 4, weight 4, cond 2^7 > BP := [<2,15,1-16*x>]; > O2 := OrthogonalSymmetrization(L,[2] : BadPrimes:=BP); > LSetPrecision(O2,5); // only 450 terms required, but slow! > time CFENew(O2); // OSym^2(deg4) // deg 9 0.00000 Time: 21.420
With this latter selection of L, one can verify (using about 1000 terms to get 3 digits, taking 5 minutes) that the orthogonal symmetrization L[2, 2] has conductor 221 and trivial Euler factor at 2. This is fully in line with a computation from (wild) Swan slopes.
We are able to give a computed example of an L[2, 2] orthogonal symmetrization of a degree 4 L-function. It turns out to be imprimitive (in fact, with a factor of ζ, but factors even further it seems), though L itself is primitive.
> _<x> := PolynomialRing(Integers()); > H := HypergeometricData([2,2,2,2,2],[1,1,1,1,1]); > L := LSeries(H,1 : SaveEuler:=10^4); // degree 4, weight 4, cond 2^8 > LSetPrecision(L,5); > BP := [<2,12,(1-2^8*x)^2*(1+2^8*x)^2>]; // Swan conductor 16-10 or 6 > O22 := OrthogonalSymmetrization(L,[2,2] : BadPrimes:=BP,PoleOrder:=1); > time CFENew(O22); // OSym^[2,2](deg4) // deg 10 1.5259E-5 Time: 6.910 > BP := [<2,12,(1+2^8*x^2)*(1+2^4*x)>]; // Swan conductor 15-9 or 6 > O2 := OrthogonalSymmetrization(L,[2] : BadPrimes:=BP); > time CFENew(O2); // OSym^2(deg4) // deg 9 0.00000 Time: 0.220
It is difficult to give an example of a primitive L-function of degree 5 and nonzero weight for which the {1, 1}-symmetrization is computable reasonably fast; one example here is the t=1 hypergeometric motive from [4, 4, 4] and [1, 2, 2, 2, 2, 2], whose L^({1, 1}) has conductor 224 and trivial Euler factor.
Having no better example, we rely on the 4th symmetric power of an elliptic curve L-function, which is primitive though not wholly generic. Indeed, the resulting {1, 1}-symmetrization is itself imprimitive. Importantly, the coefficients can be computed fast.
> _<x> := PolynomialRing(Integers());
> E := EllipticCurve("128a");
> L := LSeries(E);
> S4 := SymmetricPower(L,4 : Precision:=5);
> Degree(S4), Conductor(S4); // 2^10, slopes 5/3,5/3,5/3,0,0
5 1024
> BP :=[<2,24,1+16*x>]; // Swan conductor (5/3)*9
> S11 := Symmetrization(S4,[1,1] : BadPrimes:=BP);
> time CFENew(S11); // Sym^[1,1](deg5) // deg 10
0.00000
Time: 1.910