[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Characters

There is an ability to use characters on number fields, similar to Dirichlet characters over the integers. These are implemented via DirichletGroup on number field elements, and HeckeCharacterGroup on ideals. The former is the dual of the RayResidueRing of an ideal, and the latter is the dual of the RayClassGroup of an ideal. Arithmetic on groups can be done multiplicatively, and the characters can be evaluated at suitable field elements and ideals. The sub constructor, along with + and meet for subgroups on the same modulus, should also work.

The associated types are GrpDrchNF and GrpDrchNFElt, GrpHecke and GrpHeckeElt. The number field must be an absolute extension of the rationals.

Subsections

Creation Functions

DirichletGroup(I) : RngOrdIdl -> GrpDrchNF
DirichletGroup(I, oo) : RngOrdIdl, SeqEnum -> GrpDrchNF
Given an ideal I of the integer ring of the number field K and a set of real places of K, the intrinsic DirichletGroup will return the dual group to the RayResidueRing of the specified information.
HeckeCharacterGroup(I) : RngOrdIdl -> GrpHecke
HeckeCharacterGroup(I, oo) : RngOrdIdl, SeqEnum -> GrpHecke
Given an ideal I of the integer ring of the number field K and a set of real places of K, the intrinsic HeckeCharacterGroup will return the dual group to the RayClassGroup of the specified information.
UnitTrivialSubgroup(G) : GrpDrchNF -> GrpDrchNF
Given a group of Dirichlet characters, return the subgroup that is trivial on the image of the field units in the residue ring.

Functions on Groups and Group Elements

Modulus(G) : GrpDrchNF -> RngOrdIdl, SeqEnum
Modulus(G) : GrpHecke -> RngOrdIdl, SeqEnum
Modulus(chi) : GrpDrchNFElt -> RngOrdIdl, SeqEnum
Modulus(chi) : GrpHeckeElt -> RngOrdIdl, SeqEnum
Returns the modulus ideal and a (possibly empty) sequence of real places.
Order(chi) : GrpDrchNFElt -> RngIntElt
Order(psi) : GrpHeckeElt -> RngIntElt
Returns the order of a Dirichlet or Hecke character.
Random(G) : GrpDrchNF -> GrpDrchNFElt
Random(G) : GrpHecke -> GrpHeckeElt
Returns a random element of a Dirichlet or Hecke group.
Domain(G) : GrpDrchNF -> FldNum
Domain(G) : GrpDrchNFElt -> FldNum
Returns the number field that is the domain for the Dirichlet character.
Domain(G) : GrpHecke -> PowIdl
Domain(G) : GrpHeckeElt -> PowIdl
Returns the set of ideals that is the domain for the Hecke character.
Decomposition(chi) : GrpDrchNFElt -> List
Returns a list of characters of prime power modulus (and real places) whose product (after extension to the original DirichletGroup) is the given Dirichlet character.
Conductor(chi) : GrpDrchNFElt -> RngOrdIdl, SeqEnum
Conductor(psi) : GrpHeckeElt -> RngOrdIdl, SeqEnum
The product of the moduli of the all nontrivial characters in the decomposition of the given Dirichlet character, given as an ideal and a set of real places. Similarly with Hecke characters, where, in fact, one takes the DirichletRestriction of the Hecke character, and decomposes this.
AssociatedPrimitiveCharacter(chi) : GrpDrchNFElt -> GrpDrchNFElt
AssociatedPrimitiveCharacter(psi) : GrpHeckeElt -> GrpHeckeElt
The primitive Dirichlet character associated to the one that is given, which can be obtained by multiplying all the nontrivial characters in the decomposition. Similarly with Hecke characters, for which this decomposes the DirichletRestriction to finds its underlying primitive part, and then takes the HeckeLift of this.
Restrict(chi, D) : GrpDrchNFElt, GrpDrchNF -> GrpDrchNFElt
Restrict(psi, H) : GrpHeckeElt, GrpHecke -> GrpHeckeElt
Restrict(chi, I) : GrpDrchNFElt, RngOrdIdl -> GrpDrchNFElt
Restrict(psi, I) : GrpHeckeElt, RngOrdIdl -> GrpHeckeElt
Restrict(chi, I, oo) : GrpDrchNFElt, RngOrdIdl, SeqEnum -> GrpDrchNFElt
Restrict(psi, I, oo) : GrpHeckeElt, RngOrdIdl, SeqEnum -> GrpHeckeElt
Restrict(G, D) : GrpDrchNF, GrpDrchNF -> GrpDrchNF
Restrict(G, H) : GrpHecke, GrpHecke -> GrpHecke
Restrict(G, I) : GrpDrchNF, RngOrdIdl -> GrpDrchNF
Restrict(G, I) : GrpHecke, RngOrdIdl -> GrpHecke
Restrict(G, I, oo) : GrpDrchNF, RngOrdIdl, SeqEnum -> GrpDrchNF
Restrict(G, I, oo) : GrpHecke, RngOrdIdl, SeqEnum -> GrpHecke
Given a Dirichlet character modulo an ideal I and a Dirichlet character group modulo J for which I⊆J (including behavior at real places when specified) with the character trivial on (J/I)star, this returns the restricted character on J. Similarly with Hecke characters, and with an ideal (with possible real places) at the second argument. Also with a group of characters as the first argument.
TargetRestriction(G, C) : GrpDrchNF, FldCyc -> GrpDrchNF
TargetRestriction(H, C) : GrpHecke, FldCyc -> GrpDrchNF
Given a group of Dirichlet or Hecke characters and a cyclotomic field, return the subgroup of characters whose image is contained in the cyclotomic field.
SetTargetRing(~chi, e) : GrpDrchNFElt, RngElt ->
SetTargetRing(~psi, e) : GrpHeckeElt, RngElt ->
Given a Dirichlet or Hecke character and a suitable root of unity, modify the character to take values according to this root unity. The ring element must be a root of unity, and its order must be a multiple of the order of the character. Writing m=( ord)(chi), if the character previously had chi(u)=ζmv, it will now have chi(u)=(eq)v where q is ( ord)(e)/m.
Extend(chi, D) : GrpDrchNFElt, GrpDrchNF -> GrpDrchNFElt, GrpDrchNF
Extend(psi, H) : GrpHeckeElt, GrpHecke -> GrpHeckeElt, GrpHecke
Extend(chi, I) : GrpDrchNFElt, RngOrdIdl -> GrpDrchNFElt, GrpDrchNF
Extend(psi, I) : GrpHeckeElt, RngOrdIdl -> GrpHeckeElt, GrpHecke
Extend(chi, I, oo) : GrpDrchNFElt, RngOrdIdl, SeqEnum -> GrpDrchNFElt, GrpDrchNF
Extend(psi, I, oo) : GrpHeckeElt, RngOrdIdl, SeqEnum -> GrpHeckeElt, GrpHecke
Extend(G, D) : GrpDrchNF, GrpDrchNF -> GrpDrchNF, GrpDrchNF
Extend(G, H) : GrpHecke, GrpHecke -> GrpHecke, GrpHecke
Extend(G, I) : GrpDrchNF, RngOrdIdl -> GrpDrchNF, GrpDrchNF
Extend(G, I) : GrpHecke, RngOrdIdl -> GrpHecke, GrpHecke
Extend(G, I, oo) : GrpDrchNF, RngOrdIdl, SeqEnum -> GrpDrchNF, GrpDrchNF
Extend(G, I, oo) : GrpHecke, RngOrdIdl, SeqEnum -> GrpHecke, GrpHecke
Given a Dirichlet character modulo I and a Dirichlet character group modulo J for which J⊆I (again possibly including the real places), this function returns the induced character on J, that is, the one that is trivial on (I/J)star. A second return value corresponds to a kernel. Similarly with Hecke characters, and with an ideal (with possible real places) at the second argument. Also with a group of characters as the first argument.

Predicates on Group Elements

IsTrivial(chi) : GrpDrchNFElt -> BoolElt
IsTrivial(psi) : GrpHeckeElt -> BoolElt
Returns whether the given character corresponds to the trivial element in the character group.
IsTrivialOnUnits(chi) : GrpDrchNFElt -> BoolElt
Returns whether a Dirichlet character is trivial on the units of the number field; this determines whether the character can lift to a Hecke character on the ideals.
IsOdd(chi) : GrpDrchNFElt -> BoolElt
Returns whether a Dirichlet character chi has chi( - 1)= - 1.
IsEven(chi) : GrpDrchNFElt -> BoolElt
Returns whether a Dirichlet character chi has chi( - 1)= + 1.
IsTotallyEven(chi) : GrpDrchNFElt -> BoolElt
Returns whether a Dirichlet character chi has chip( - 1)= + 1 for each chip in its decomposition.
IsPrimitive(chi) : GrpDrchNFElt -> BoolElt
IsPrimitive(psi) : GrpHeckeElt -> BoolElt
Returns whether a Dirichlet character is primitive, that is, whether its conductor and modulus are equal.

Passing between Dirichlet and Hecke Characters

HeckeLift(chi) : GrpDrchNFElt -> GrpHeckeElt, GrpHecke
Given a Dirichlet character that is trivial on the units of the number field, this functions returns a Hecke character that extends its domain to all the ideals of the integer ring. Also returns a kernel, so as to span the set of all possible lifts.
DirichletRestriction(psi) : GrpHeckeElt -> GrpDrchNFElt
Given a Hecke character on the ideals of the integer ring of a number field, this functions returns the Dirichlet restriction of it on the field elements.

Example FldNum_dirichletQ (H34E16)

This example tries to codify the terminology via a standard example with Dirichlet characters over the rationals. We construct various characters modulo 5.

> Q := NumberField(Polynomial([-1, 1]) : DoLinearExtension);
> O := IntegerRing(Q);
> I := 5*O;
> DirichletGroup(I);
Abelian Group isomorphic to Z/4
Group of Dirichlet characters of modulus of norm 5 mapping to
 Cyclotomic Field of order 4 and degree 2

The above group is the Dirichlet characters modulo 5. However, the odd characters are not characters on ideals, as they are nontrivial on the units. To pass to the Hecke characters, we need to enlarge the modulus to consider embeddings at the real place. Note that this will give four more characters, corresponding to multiplying the above by the character that has chi as +1 on positive elements and -1 on negative elements; such characters will not be periodic in the traditional sense of Dirichlet characters, but are still completely multiplicative.

> D := DirichletGroup(I, [1]); D; // include first real place
Abelian Group isomorphic to Z/2 + Z/4
Group of Dirichlet characters D of modulus of norm 5 and infinite
places [ 1 ] mapping to Cyclotomic Field of order 4 and degree 2
> [ IsTrivialOnUnits(x) : x in Elements(D) ];
[ true, false, false, true, true, false, false, true ]

> HeckeLift(D.1); // non-trivial on units Runtime error in 'HeckeLift': Character is nontrivial on the units > hl := HeckeLift(D.1 * D.2); > hl(2); zeta_4 > hl(2) eq (D.1 * D.2)(2); true

So only half of the 8 completely multiplicative characters on field elements lift to characters on ideals, and these correspond exactly the standard four Dirichlet characters modulo 5, though evinced in a different guise.


DirichletCharacter(I, B) : RngOrdIdl, Tup -> GrpDrchNFElt, GrpDrchNF
DirichletCharacter(I, oo, B) : RngOrdIdl, SeqEnum, Tup -> GrpDrchNFElt, GrpDrchNF
DirichletCharacter(G, B) : GrpDrchNF, Tup -> GrpDrchNFElt, GrpDrchNF
HeckeCharacter(I, B) : RngOrdIdl, Tup -> GrpHeckeElt
HeckeCharacter(I, oo, B) : RngOrdIdl, SeqEnum, Tup -> GrpHeckeElt
HeckeCharacter(G, B) : GrpHecke, Tup -> GrpHeckeElt
    RequireGenerators: BoolElt          Default: true
Given either an ideal (and also possibly a set of real infinite places) or a DirichletGroup, and a tuple of 2-tuples each containing a field element and a element of Integers(m) for some m, construct a Dirichlet character that sends each field element to the cyclotomic unit corresponding to the residue element. The second member of each 2-tuple can alternatively be an element of some cyclotomic field.

The parameter RequireGenerators demands that the given field elements should generate the RayResidueRing of the ideal. The second return argument is a subgroup of the ambient DirichletGroup by which the returned character can be translated and still retain the same values on the given elements.

Similarly for HeckeCharacter -- there the first element in each 2-tuple should be an ideal of the field, and RequireGenerators demands that these generate the RayClassGroup of the ideal.


Example FldNum_dirichlet-hecke (H34E17)

We define a character on 5 OK that sends Sqrt( - 23) to ζ82 (note that Sqrt( - 23) has order 8 in the RayResidueRing to this modulus).

> K := QuadraticField(-23);
> I := 5*IntegerRing(K);
> chi, SG := DirichletCharacter
>           (I, <<K.1, Integers(8)!2>> : RequireGenerators := false);
> chi(K.1);
zeta_4
> (SG.1 * chi)(K.1);
zeta_4

And then we define one that sends Sqrt( - 23) to ζ86 and (3 + 2Sqrt( - 23)), an element of order 6 in the RayResidueRing, to ζ248.

> data := <<K.1, Integers(8)!6>, <3+2*K.1,Integers(24)!8>>;
> chi, SG := DirichletCharacter(I, data);
> chi(K.1);
-zeta_4
> chi(3+2*K.1);
zeta_3
> #SG; // this subgroup SG is trivial, as the data determine chi
1

Note that we can replace the Integers(8)!6 in the first tuple by ζ86.

> C<zeta8> := CyclotomicField(8);
> data2 := <<K.1, zeta8^6>, <3+2*K.1,Integers(24)!8>>;
> chi2 := DirichletCharacter(I, data2);
> chi eq chi2;
true

Now we give a example with Hecke characters over a cubic field. We also note that the evaluation of a character (either Dirichlet or Hecke) can be obtained in "raw" form as an element in a residue ring via the use of the Raw vararg.

> _<x> := PolynomialRing(Integers());
> K<s> := NumberField(x^3-x^2+7*x-6); // #ClassGroup(K) is 5
> I := Factorization(11*IntegerRing(K))[2][1]; // norm 121
> HG := HeckeCharacterGroup(I,[1]); // has 20 elements
> f3 := Factorization(3*IntegerRing(K))[1][1]; // order 10
> data := < <f3, Integers(10)!7> >;
> psi := HeckeCharacter(HG, data : RequireGenerators := false);
> psi(f3);
-zeta_10^2
> psi(f3) eq CyclotomicField(10).1^7;
true
> '@'(f3,psi : Raw); // get Raw form of evaluation
14
> Parent($1);
Residue class ring of integers modulo 20
> f113 := Factorization(113*IntegerRing(K))[1][1]; // order 4
> data2 := < <f113, Integers(4)!3> >;
> psi := HeckeCharacter(HG, <data[1], data2[1]>);
> psi(f113);
-zeta_4

CentralCharacter(chi) : GrpDrchNFElt -> GrpDrchNFElt
CentralCharacter(psi) : GrpHeckeElt -> GrpDrchNFElt
Given a Dirichlet or Hecke character, compute its central character down to the rationals. This is defined by computing a Dirichlet character that is defined over Q and agrees with the given character on a set of generators of the residue ring of the norm of the modulus of the given character. The AssociatedPrimitiveCharacter of this is then returned. It should have the same value as the original character on all unramified primes (at least). Note that the central character will always be a Dirichlet character, as the class number of the rationals is 1.

Example FldNum_central-chars (H34E18)

> K := NumberField(Polynomial([4,3,-1,1])); // x^3-x^2+3*x+4
> f7 := Factorization(7*Integers(K))[1][1];
> G:= DirichletGroup(f7^2,[1]);
> chi := G.1*G.2*G.3;
> cc := CentralCharacter(chi); Conductor(cc);
Principal Ideal, Generator: [49] // conductor 49
[ 1 ] // infinite place
> cc := CentralCharacter(chi^14); Conductor(cc);
Principal Ideal, Generator: [7] // conductor 7
[ ] // no infinite places
> ////////////////
> K := NumberField(Polynomial([-10,-9,-10,1]));
> #ClassGroup(K); // C7 class group
7
> f5 := Factorization(5*Integers(K))[1][1];
> H := HeckeCharacterGroup(f5,[1]);
> cc:=CentralCharacter(H.1); Conductor(cc);
Principal Prime Ideal, Generator: [5] // conductor 5
[ 1 ] // infinite place
> Order(H.1), Order(cc);
28 4
> IsTrivial(CentralCharacter(H.1^4));
true

DirichletCharacterOverNF(chi) : GrpDrchElt -> GrpDrchNFElt
DirichletCharacterOverQ(chi) : GrpDrchNFElt -> GrpDrchElt
These are utility functions to pass between the two types of Dirichlet character over Q in Magma. The first takes a Dirichlet character over the Rationals() and returns one over the rationals as a number field, and the second reverses this.

Example FldNum_dirich-chars-over-nf-and-q (H34E19)

> SetSeed(1);
> G := DirichletGroup(16*3^2*5^2*7*11, CyclotomicField(2^6*3*5));
> #G;
57600
> chi := Random(G);
> Order(chi);
30
> psi := DirichletCharacterOverNF(chi);
> Order(psi);
30
> #Parent(psi)`supergroup;
57600
> &and[chi(p) eq psi(p) : p in PrimesUpTo(1000)];
true
> DirichletCharacterOverQ(psi) eq chi;
true

L-functions of Hecke Characters

Given a primitive Hecke character ψ, one can define the associated L-function as L(ψ, s)=∏p bigl(1 - ψ(p)/(N)psbigr) - 1, and this satisfies a functional equation whose conductor is the product of the conductor of ψand the discriminant of (the integer ring) of the number field for ψ.


Example FldNum_lfunc-hecke (H34E20)

> _<x> := PolynomialRing(Integers());
> K<s> := NumberField(x^5 - 2*x^4 + 2*x + 2);
> I2 := Factorization( 2 * IntegerRing(K) ) [1][1]; // ideal above 2
> I11 := Factorization( 11 * IntegerRing(K) ) [1][1]; // above 11
> I := I2*I11; Norm(I);
22
> H := HeckeCharacterGroup(I, [1]);
> #H;
2
> psi := H.1; IsPrimitive(psi);
false
> prim := AssociatedPrimitiveCharacter(psi); Norm(Conductor(prim));
11
> L := LSeries(prim);
> LSetPrecision(L, 10); LCfRequired(L); // number of terms needed
4042
> CheckFunctionalEquation(L); // 2 or 3 seconds
-3.492459655E-10

Hecke Grössencharacters and their L-functions

A limited ability to compute Grössencharacters and their L-functions exists, but it has only really been tested for complex quadratic fields and a bit for ( Q)(ζ5). These are "quasi-characters" in that their image is not restricted to the unit circle (and 0). The implementation in Magma handles the "algebraic" characters of this sort, or those of type A0; it also requires that the field of definition be a CM-field (an imaginary quadratic extension of a totally real field).

The natural definition of Grössencharacters would be on a coset of the dual group of the RayResidueRing extended by the ClassGroup, without any modding out by units (which gives the RayClassGroup). However, the Magma implementation uses a Hecke character combined with an auxiliary Dirichlet character to simulate this. Arithmetic with Grössencharacters in also possible, even though there is no underlying group structure. However, equality with Grössencharacters is not implemented (one needs to check that various class group representatives are compatible, etc.).

Grossencharacter(psi, chi, T) : GrpHeckeElt, GrpDrchNFElt, SeqEnum -> GrossenChar
RawEval(I, GR) : RngOrdFracIdl, GrossenChar -> FldNumElt, FldCycElt, FldCycElt
Given a Hecke character ψand a Dirichlet character chi (of the same modulus) and a compatible ∞-type T return the associated Grössencharacter.

The ∞-type is a sequence of pairs of integers which correspond to embeddings, such that ψbigl((α)bigr)= ∏i=1#Tσi)T[i][1] (barασi)T[i][2] for all αthat are congruent to 1 modulo the modulus of ψ. For a Grössencharacter to exist it follows that the ∞-type must trivialise all (totally positive) units that are congruent to 1 modulo the modulus of ψ. Each pair in T must have the same sum.

The Dirichlet character chi must correspond to the action on the image of the UnitGroup in the RayResidueRing of the modulus. In particular, for every unit u we must have that chi(u)= ∏i=1#T (uσi)T[i][1](bar uσi)T[i][2], and since the ∞-type is multiplicative, we need only check this on generators of the units.

Evaluating a Grössencharacter returns a complex number, corresponding to some choice of internal embeddings. The use of RawEval on an ideal will return an element in an extension of the field K (to which the ∞-type is then applied) and two elements in cyclotomic fields, corresponding to evaluations for chi and ψrespectively.

Grossencharacter(psi, T) : GrpHeckeElt, SeqEnum -> GrossenChar
Same as above, but Magma will try to compute a compatible Dirichlet character chi for the given data. If there is more than one possibility, an arbitrary choice could be made.
Conductor(psi) : GrossenChar -> RngOrdIdl, SeqEnum
Modulus(psi) : GrossenChar -> RngOrdIdl, SeqEnum
IsPrimitive(psi) : GrossenChar -> BoolElt
AssociatedPrimitiveGrossencharacter(psi) : GrossenChar -> GrossenChar
The conductor of the Grössencharacter is the conductor of the product of the Dirichlet part with the DirichletRestriction of the Hecke part. A Grössencharacter is primitive if its modulus is the same as the conductor. When taking L-functions, as before the conductor is multiplied by the discriminant of the integer ring of the field.
Extend(psi, I) : GrossenChar, RngOrdIdl -> GrossenChar
Restrict(psi, I) : GrossenChar, RngOrdIdl -> GrossenChar
Extension and restriction of a Grössencharacter. Note that the second argument is an ideal, unlike the Dirichlet/Hecke cases, where it is a group of characters.
CentralCharacter(psi) : GrossenChar -> GrpDrchNFElt
Compute the central character (down to Q) of a Grössencharacter, normalizing the result to be weight 0, and returning it as a Dirichlet character (over Q as a number field).

Example FldNum_grossenchar-gaussian (H34E21)

First, an example of [1, 0]-type Grössencharacters on the Gaussian field, with modulus p23 where p2 is the (ramified) prime above 2. This induces the L-function for the congruent number curve.

> K<i> := QuadraticField(-1);
> I := (1+i)^3*IntegerRing(K);
> HG := HeckeCharacterGroup(I, []);
> DG := DirichletGroup(I, []); #DG;
4
> GR := Grossencharacter(HG.0, DG.1^3, [[1,0]]);
> L := LSeries(GR); CheckFunctionalEquation(L);
1.57772181044202361082345713057E-30
> CentralValue(L);
0.655514388573029952616209897475
> CentralValue(LSeries(EllipticCurve("32a")));
0.655514388573029952616209897473

Example FldNum_grossenchar-sqrt23 (H34E22)

An example with the canonical Grössencharacter for K=( Q)(Sqrt( - 23)). The ramification here is only at the prime above 23.

> K<s> := QuadraticField(-23);
> I := Factorization(23*IntegerRing(K))[1][1]; // ramified place
> HG := HeckeCharacterGroup(I, []);
> DG := DirichletGroup(I, []); #DG;
22
> GR := Grossencharacter(HG.0, DG.1^11, [[1,0]]); // canonical character
> CheckFunctionalEquation(LSeries(GR));
-5.17492753824983744350093938826E-28
> H := K`extension_field; H; // defined by internal code
Number Field with defining polynomial y^3 + 1/2*(s + 3) over K

The values of the Grössencharacter are in the given field extension of K. We can also twist the Grössencharacter by a Hecke character on I, either via the Grossencharacter intrinsic, or by direct multiplication.

> i2 :=  Factorization(2*IntegerRing(K))[1][1]; // ideal of norm 2
> (GR*HG.1)(i2); // evaluation at i2
-0.140157638956246665944180880120 - 1.40725116316960648195556086783*i
> GR2 := Grossencharacter(HG.1, DG.1^11, [[1,0]]); // psi over zeta_11
> GR2(i2);
-0.140157638956246665944180880120 - 1.40725116316960648195556086783*i
> RawEval(i2,GR2);  // first value is in the cubic extension of K
H.1
1
zeta_33^4
> CheckFunctionalEquation(LSeries(GR2));
-7.09974814698910624870555708755E-30

Example FldNum_grossenchar-symcubed-sqrt59 (H34E23)

An example from Fernando Rodriguez Villegas where the Grössencharacter yields an L-function with even functional equation, but vanishing central value. This is the cube of the canonical character on ( Q)(Sqrt( - 59)), which has class number 3. The L-function can be alternatively realised from a weight 4 modular form of level 592.

> K := QuadraticField(-59);
> I := Factorization(59*IntegerRing(K))[1][1];
> H := HeckeCharacterGroup(I);
> DG := DirichletGroup(I);
> GR := Grossencharacter(H.0, DG.1^29, [[3,0]]); // cube of canonical char
> L := LSeries(GR);
> CheckFunctionalEquation(L);
0.000000000000000000000000000000
> Sign(L);
1.00000000000000000000000000000
> CentralValue(L);
3.51858026759864075475017925650E-30
> LSetPrecision(L, 9);
> LTaylor(L, 2, 3); // first 3 terms of Taylor series about s=2
-1.09144041E-12 + 9.82515510E-11*z + 2.87637101*z^2 - 7.65817878*z^3 + ...

The same Grössencharacter can be obtained from cubing the canonical character (of type [1, 0]).

> GR3 := Grossencharacter(H.0, DG.1^29, [[1,0]])^3;
> CentralValue(LSeries(GR3));
3.51858026759864075475017925650E-30

Example FldNum_grossen-char-cyclo5 (H34E24)

An example with ( Q)(ζ5), comparing the central value to the periods derived from Γ-values.

> _<x> := PolynomialRing(Rationals());
> K<z5> := NumberField(x^4+x^3+x^2+x+1);
> p5 := Factorization(5*IntegerRing(K))[1][1]; // ramified prime above 5
> H := HeckeCharacterGroup(p5^2);
> DG := DirichletGroup(p5^2);  // need p5^2 to get chi with this oo-type
> chi := DG.1^2*DG.2; // could alternatively have Magma compute this
> GR := Grossencharacter(H.0, chi, [[3,0],[1,2]]);

We can compute that this ∞-type sends ζ5 to (ζ51)3.(ζ54)0.(ζ52)1.(ζ53)2511 under the default embedding, and thus the ideal needs to afford a character of order 5 for a Grössencharacter to exist.

> L := LSeries(GR);
> LSeriesData(L); // Conductor is Norm(p5^2) * disc(K) = 5^2 * 5^3
<4, [ 0, -1, 1, 0 ], 3125, ... >;
> CheckFunctionalEquation(L); // functional equation works
0.000000000000000000000000000000
> CentralValue(L); // same as Evaluate(L,2)
1.25684568045898366613593980559
> Gamma(1/5)^3 * Gamma(2/5)^3 / Gamma(3/5)^2 / Gamma(4/5)^2 / 5^(7/2);
1.25684568045898366613593980558

The [[3, 0], [2, 1]] ∞-type sends ζ5 to ζ53 + 0 + 2.2 + 3=1, but we still need p5 in the modulus to trivialise the units of infinite order.

> H := HeckeCharacterGroup( 1 * IntegerRing(K)); // try conductor 1

> GR := Grossencharacter(H.0, [[3,0],[2,1]]); Runtime error in 'Grossencharacter': oo-type should be trivial on all totally positive units that are 1 mod I Fails for -zeta_5^2 - 1 which gives -1.000000000 - 3.293785801E-101*$.1 > H := HeckeCharacterGroup(p5); // conductor of norm 5 > GR := Grossencharacter(H.0, [[3,0],[2,1]]); // finds a character > L := LSeries(GR); // CheckFunctionalEquation(L); > PI := Pi(RealField()); > CentralValue(L); // now recognise as a product via logs and LLL 0.749859246433372123005585683300 > A := [ Gamma(1/5), Gamma(2/5), Gamma(3/5), Gamma(4/5), 5, PI, $1 ]; > LOGS := [ ComplexField() ! Log(x) : x in A ]; > LinearRelation(LOGS : Al := "LLL"); [ -14, 2, -2, 14, 15, -4, 4 ]

Example FldNum_grossenchar-embedding (H34E25)

Twisting a Grössencharacter by a Hilbert character is equivalent to changing the embedding.

> K := QuadraticField(-39);
> I := 39*IntegerRing(K);
> F := &*[f[1] : f in Factorization(I)]; // ideal of norm 39
> H := HeckeCharacterGroup(F); H;
Abelian Group isomorphic to Z/4 + Z/12 given as Z/4 + Z/12
> Norm(Conductor(H.1)); // H.1 is a Hilbert character of norm 1
1
> GR := Grossencharacter(H.0, [[3,0]]); // third power

There are four Hilbert characters here (from the class group of K), and we twist the Grössencharacter by each.

> L0 := LSeries(AssociatedPrimitiveGrossencharacter(GR));
> L1 := LSeries(AssociatedPrimitiveGrossencharacter(GR*H.1));
> L2 := LSeries(AssociatedPrimitiveGrossencharacter(GR*H.1^2));
> L3 := LSeries(AssociatedPrimitiveGrossencharacter(GR*H.1^3));
> Ls := [ L0, L1, L2, L3 ]; for L in Ls do LSetPrecision(L, 10); end for;
> for L in Ls do [CentralValue(L), Sign(L)]; end for;
[ 1.335826177, 1.000000000 + 2.706585223E-10*i ]
[ -1.373433032*i, -0.9999999999 - 6.351223882E-11*i ]
[ 1.335826177, 1.000000000 - 2.706585223E-10*i ]
[ 1.373433032*i, -0.9999999999 + 6.351223882E-11*i ]

The embedding information is stored internally in K'Hip, and we modify this directly to get the same L-values via a different method.

> K`Hip; // extension of infinite place of K
[ [ 1, 1 ] place at infinity ]
> IP := InfinitePlaces(K`extension_field); IP;
[ [ 1, 1 ] place at infinity, [ 1, 2 ] place at infinity,
  [ 1, 3 ] place at infinity, [ 1, 4 ] place at infinity ]
> for ip in IP do K`Hip := [ ip ]; // change ip, but use same GR
>        L := LSeries(AssociatedPrimitiveGrossencharacter(GR));
>        LSetPrecision(L, 10); [CentralValue(L), Sign(L)]; end for;
[ 1.335826177, 1.000000000 - 2.706585223E-10*i ]
[ 1.373433032*i, -0.9999999999 + 6.351223882E-11*i ]
[ 1.335826177, 1.000000000 - 2.706585223E-10*i ]
[ -1.373433032*i, -0.9999999999 - 6.351223882E-11*i ]

Finally, we can note that all the Hilbert characters have sign +1 in their functional equations, though two of the twists of the Grössencharacter have sign -1.

> Ls := [ LSeries(AssociatedPrimitiveCharacter(H.1^k)) : k in [1..4] ];
> [ Sign(L) where _:=CheckFunctionalEquation(L) : L in Ls ];
[ 0.999999999999999999999999999997, 1.00000000000000000000000000000,
  0.999999999999999999999999999997, 1.00000000000000000000000000000 ]

Example FldNum_grossen-large-gamma (H34E26)

A final example with characters of trivial conductor, here of type [2, 0] in ( Q)(Sqrt( - 23)).

> K<s> := QuadraticField(-23); // class number 3
> I := 1*IntegerRing(K);
> HG := HeckeCharacterGroup(I, []);
> GR := Grossencharacter(HG.0, [[2,0]]); // of oo-type (2,0)
> Evaluate(LSeries(GR), 2); // value at edge of critical strip
1.23819100212426040400794384795
> Evaluate(LSeries(GR*HG.1), 2); // twist by nontrivial Hecke char
0.670337208665839403747922477469
> Evaluate(LSeries(GR*HG.1^2), 2);
1.06110583266449728309907405960

The product of these three L-values should be related to values of the Γ-function at k/23 for integral k. (One could alternatively relate these L-values to periods of an elliptic curve over the Hilbert class field of K having ramification only above 23.)

> SetDefaultRealFieldPrecision(100);
> e1 := Evaluate(LSeries(GR : Precision:=100), 2);
> e2 := Evaluate(LSeries(GR*HG.1 : Precision:=100), 2);
> e3 := Evaluate(LSeries(GR*HG.1^2 : Precision:=100), 2);
> GAMMA := [Gamma(i/23) : i in [1..22]];
> A := GAMMA cat [3,23,Pi(RealField())] cat [e1,e2,e3];
> LOGS := [ComplexField()!Log(x) : x in A];
> LinearRelation(LOGS : Al:="LLL");
[ 2,  2,  2,  2, -2,  2, -2,  2,  2, -2, -2,
  2,  2, -2, -2,  2, -2,  2, -2, -2, -2, -2,
 -2, -7,  6, -2, -2, -2 ]
> &*[ GAMMA[i]^(2*(DirichletGroup(23).1)(i)) : i in [1..22] ];
24723927.96264290790447830542942451626433185347196157309315591128
> 3^2 * 23^7 / Pi(RealField())^6 * (e1*e2*e3)^2;
24723927.96264290790447830542942451626433185347196157309315591128

Example FldNum_grossen-cyclo8 (H34E27)

An example from [vGvS93, S8.8]. Here the Grössencharacter is on an ideal of norm 24 in the cyclotomic field ( Q)(ζ8). The Euler factors will factor in various fields. In Table 7.6 of the cited paper, one notes that the coefficients satisfy a17= - 180 and a172=15878.

> Q<z8> := CyclotomicField(8);
> p2 := Factorization(2*Integers(Q))[1][1];
> G := HeckeCharacterGroup(p2^4);
> psi := G.0; // trivial
> GR := Grossencharacter(psi, [[3,0],[1,2]]);
> L:=LSeries(GR);
> CheckFunctionalEquation(L);
6.31088724176809444329382852226E-30
> Factorization(EulerFactor(L,7 : Integral)); // p is 7 mod 8
[ <343*x^2 + 1, 2> ]
> K<s2> := QuadraticField(-2);
> _<t> := PolynomialRing(K);
> Factorization(EulerFactor(L,3 : Integral),K); // 3 mod 8
[ <t^2 + 1/81*(-2*s2 - 1), 1>, <t^2 + 1/81*(2*s2 - 1), 1> ]
> K<i> := QuadraticField(-1);
> _<t> := PolynomialRing(K);
> Factorization(EulerFactor(L,5 : Integral),K); // 5 mod 8
[ <t^2 + 1/3125*(-24*i + 7), 1>, <t^2 + 1/3125*(24*i + 7), 1> ]
> EulerFactor(L,17 : Integral); // -180 and 15878 as desired
24137569*x^4 - 884340*x^3 + 15878*x^2 - 180*x + 1

 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

Version: V2.19 of Mon Dec 17 14:40:36 EST 2012