Introduction#
This chapter presents the facilities provided in Magma for Dirichlet and Hecke characters, currently implemented over number fields. For Dirichlet characters over the rationals (as FldRat), see Section Dirichlet Characters.
The principal constructors are DirichletGroup whose elements are functions on number field elements, and HeckeCharacterGroup whose elements are functions 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 (see Chapter Class Field Theory).
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.
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
DirichletGroupwill return the dual group to theRayResidueRingof 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
HeckeCharacterGroupwill return the dual group to theRayClassGroupof 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.
- TotallyUnitTrivialSubgroup(G): GrpDrchNF -> GrpDrchNF#
Given a group of Dirichlet characters, return the subgroup that is totally trivial on the image of the field units in the residue ring. That is, it is trivial at each place individually.
- HilbertCharacterSubgroup(G): GrpHecke -> GrpHecke#
Given a group of Hecke characters, return the subgroup corresponding to the class group (those with trivial conductor).
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.
- Components(chi): GrpDrchNFElt -> Assoc#
- Components(psi): GrpHeckeElt -> Assoc#
Given a Hecke or Dirichlet character, return its components as an associative array of Dirichlet characters indexed by bad places. For a Hecke character, this is the decomposition of its
DirichletRestriction. Note that the character need not be primitive.
- Component(chi, P): GrpDrchNFElt, RngOrdIdl -> GrpDrchNFEl#
- Component(psi, P): GrpHeckeElt, RngOrdIdl -> GrpDrchNFElt#
- Component(chi, oo): GrpDrchNFElt, RngIntElt -> GrpDrchNFEl#
- Component(psi, oo): GrpHeckeElt, RngIntElt -> GrpDrchNFElt#
- Component(chi, P): GrpDrchNFElt, PlcNumElt -> GrpDrchNFEl#
- Component(psi, P): GrpHeckeElt, PlcNumElt -> GrpDrchNFElt#
Given a Dirichlet or Hecke character and a prime ideal or place (possibly specified by an integer for an infinite place), return the corresponding Dirichlet character component. For a place that it is not ramified, the trivial character of the integer ring is returned.
- 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
DirichletRestrictionof 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
DirichletRestrictionto finds its underlying primitive part, and then takes theHeckeLiftof 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\subseteq 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 of 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={\rm ord}(\chi)\), if the character previously had \(\chi(u)=\zeta_m^v\), it will now have \(\chi(u)=(e^q)^v\) where \(q\) is \({\rm ord}(e)/m\).
- Extend(chi, D): GrpDrchNFElt, GrpDrchNF -> GrpDrchNFElt#
- Extend(psi, H): GrpHeckeElt, GrpHecke -> GrpHeckeElt#
- Extend(chi, I): GrpDrchNFElt, RngOrdIdl -> GrpDrchNFElt#
- Extend(psi, I): GrpHeckeElt, RngOrdIdl -> GrpHeckeElt#
- Extend(chi, I, oo): GrpDrchNFElt, RngOrdIdl, SeqEnum -> GrpDrchNFElt#
- Extend(psi, I, oo): GrpHeckeElt, RngOrdIdl, SeqEnum -> GrpHeckeElt#
- Extend(G, D): GrpDrchNF, GrpDrchNF -> GrpDrchNF#
- Extend(G, H): GrpHecke, GrpHecke -> GrpHecke#
- Extend(G, I): GrpDrchNF, RngOrdIdl -> GrpDrchNF#
- Extend(G, I): GrpHecke, RngOrdIdl -> GrpHecke#
- Extend(G, I, oo): GrpDrchNF, RngOrdIdl, SeqEnum -> GrpDrchNF#
- Extend(G, I, oo): GrpHecke, RngOrdIdl, SeqEnum -> GrpHecke#
Given a Dirichlet character modulo \(I\) and a Dirichlet character group modulo \(J\) for which \(J\subseteq 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\). 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 \(\chi_p(-1)=+1\) for each \(\chi_p\) in its decomposition.
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 function returns the Dirichlet restriction of it on the field elements.
- NormInduction(K, chi): FldNum, GrpDrchElt -> GrpHeckeElt#
Given a Dirichlet character \(\chi\) over the rationals (as
FldRat) induce it to a Hecke character over the number field \(K\). That is, find \(\psi\) with \(\psi(a)=\chi({\rm N}a)\) with \(\psi\) primitive.
- QuadraticCharacter(e): FldNumElt -> GrpHeckeElt#
Given a nonzero field element \(e\) over an absolute number field, return the associated quadratic Hecke character (which will be trivial when \(e\) is a square).
- Example: dirichlet Q (ex-853a78)#
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. In terms of class field theory, this can viewed as saying that the global Artin map relates \(-1\) to complex conjugation.
- Example: Simple Char Ops (ex-b4977b)#
This example gives some basic character operations.
> K := QuadraticField(-23); > p3 := Factorization(3*Integers(K))[1][1]; > G1 := HeckeCharacterGroup(p3^1); > G2 := HeckeCharacterGroup(p3^2); > G3 := HeckeCharacterGroup(p3^3); > assert Extend(G1.1,G3) eq G3.1^9; > assert Restrict(G2.1^3,G1) eq G1.1; > assert Extend(G1.1,p3^3) eq Extend(G2.1^3,p3^3); > assert Restrict(Restrict(G3.1^3,p3^2)^3,p3) eq G1.1; > assert G1 eq HilbertCharacterSubgroup(G1); > assert Restrict(HilbertCharacterSubgroup(G2),G1) eq G1; > assert Restrict(sub<G2|[G2.1^3]>,p3) eq G1; > assert Extend(G2,G3) eq sub<G3|[G3.1^3]>; > assert Extend(G1,p3^2) eq Restrict(sub<G3|[G3.1^9]>,G2);
> chi := KroneckerCharacter(-7); > K := QuadraticField(5); > theta := NormInduction(K,chi); > Type(theta); GrpHeckeElt > Modulus(theta); assert IsPrimitive(theta); Principal Prime Ideal, Generator: 7 [ 1, 2 ] // places at infinity > cbrt := Parent(theta).1; > assert cbrt^3 eq theta; // Order(cbrt) is 6 > SetTargetRing(~cbrt,GF(13)!2); // choice of gen > cbrt(K.1); // now an element of GF(13) 10 > DirichletRestriction(cbrt)(K.1); -zeta_6 + 1
- DirichletCharacter(I, B): RngOrdIdl, Tup -> GrpDrchNFElt, GrpDrchNF#
- DirichletCharacter(I, oo, B): RngOrdIdl, SeqEnum, Tup -> GrpDrchNFElt, GrpDrchNF#
- DirichletCharacter(G, B): GrpDrchNF, Tup -> GrpDrchNFElt, GrpDrchNF#
- DirichletCharacter(I, L): RngOrdIdl, List -> GrpDrchNFElt, GrpDrchNF#
- DirichletCharacter(I, oo, L): RngOrdIdl, SeqEnum, List -> GrpDrchNFElt, GrpDrchNF#
- DirichletCharacter(G, L): GrpDrchNF, List -> GrpDrchNFElt, GrpDrchNF#
- HeckeCharacter(I, B): RngOrdIdl, Tup -> GrpHeckeElt#
- HeckeCharacter(I, oo, B): RngOrdIdl, SeqEnum, Tup -> GrpHeckeElt#
- HeckeCharacter(G, B): GrpHecke, Tup -> GrpHeckeElt#
- HeckeCharacter(I, L): RngOrdIdl, List -> GrpHeckeElt#
- HeckeCharacter(I, oo, L): RngOrdIdl, SeqEnum, List -> GrpHeckeElt#
- HeckeCharacter(G, L): GrpHecke, List -> GrpHeckeElt#
RequireGenerators: BoolElt Default: true
Given either an ideal (and also possibly a set of real infinite places) or a
DirichletGroup, and a list/tuple of 2-tuples each containing a field element and a element ofIntegers(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 a torsion element of some cyclotomic field.The parameter
RequireGeneratorsdemands that the given field elements should generate theRayResidueRingof the ideal. The second return argument is a subgroup of the ambientDirichletGroupby 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 can now be an ideal of the field, andRequireGeneratorsdemands that these generate theRayClassGroupof the ideal.
- Example: Dirichlet Hecke (ex-80bd7f)#
We define a character on \(5 O_K\) that sends \(\sqrt{-23}\) to \(\zeta_8^2\) (note that \(\sqrt{-23}\) has order 8 in the
RayResidueRingto 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 \(\zeta_8^6\) and \((3+2\sqrt{-23})\), an element of order 6 in the
RayResidueRing, to \(\zeta_{24}^8\).> 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 \(\zeta_8^6\).
> 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
Rawparameter.> _<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 \({\mathbb{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
AssociatedPrimitiveCharacterof 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: Central Chars (ex-3ed3f9)#
> 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 \({\mathbb{Q}}\) in Magma. The first takes a Dirichlet character over the
Rationals()and returns one over the rationals as a number field (or more precisely over the first cyclotomic field, which unlikeQNF()is unique in Magma), and the second reverses this.
- Example: Dirich Chars Over Nf And Q (ex-5e238b)#
> G := DirichletGroup(16*3^2*5^2*7*11, CyclotomicField(2^6*3*5)); > #G; 57600 > repeat chi := Random(G); until Order(chi) eq 30; > psi := DirichletCharacterOverNF(chi); > Order(psi); 30 > #Parent(psi)`ambient; 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 \(\psi\), one can define the associated \(L\)-function as
and this satisfies a functional equation whose conductor is the product of the conductor of \(\psi\) and the discriminant of (the integer ring) of the number field for \(\psi\).
- Example: Lfunc Hecke (ex-d505ea)#
> _<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); // approx with old CheckFunctionalEquation 4042 > CFENew(L); -3.492459655E-10
Hecke Grössencharacters and their L-functions#
Computations with Grössencharacters and their L-functions can now be done in Magma. 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, that is, those of type \(A_0\); it also requires that the field of definition be a CM-field (an imaginary quadratic extension of a totally real field). The methods used are described in [Watkins, 2011].
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 is 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 \(\psi\) and a Dirichlet character \(\chi\) (of the same modulus) and a compatible \(\infty\)-type \(T\) return the associated Grössencharacter.
The \(\infty\)-type is a sequence of pairs of integers which correspond to embeddings, such that
\[\psi\bigl((\alpha)\bigr)= \prod_{i=1}^{\#T} (\alpha^{\sigma_i})^{T[i][1]} (\bar\alpha^{\sigma_i})^{T[i][2]}\]for all \(\alpha\) that are congruent to 1 modulo the modulus of \(\psi\). For a Grössencharacter to exist it follows that the \(\infty\)-type must trivialise all (totally positive) units that are congruent to 1 modulo the modulus of \(\psi\). Each pair in \(T\) must have the same sum.
The Dirichlet character \(\chi\) must correspond to the action on the image of the
UnitGroupin theRayResidueRingof the modulus (note that [Watkins, 2011, §5.2] makes the reciprocal choice). In particular, for every unit \(u\) we must have that\[\chi(u)= \prod_{i=1}^{\#T} (u^{\sigma_i})^{T[i][1]}(\bar u^{\sigma_i})^{T[i][2]},\]and since the \(\infty\)-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
RawEvalon an ideal will return an element in an extension of the field \(K\) (to which the \(\infty\)-type is then applied) and two elements in cyclotomic fields, corresponding to evaluations for \(\chi\) and \(\psi\) respectively.For cyclotomic fields in Magma there is a specific order of the internal embeddings, while for general CM fields the user can obtain the ordering via the output of
Conjugatesor evaluating atInfinitePlaces.
- 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(GR): GrossenChar -> RngOrdIdl, SeqEnum#
- Modulus(GR): GrossenChar -> RngOrdIdl, SeqEnum#
- IsPrimitive(GR): GrossenChar -> BoolElt#
- AssociatedPrimitiveGrossencharacter(psi): GrossenChar -> GrossenChar#
The conductor of the Grössencharacter is the conductor of the quotient of the
DirichletRestrictionof the Hecke part divided by its Dirichlet 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.
- Components(GR): GrossenChar -> Assoc#
Given a Grössencharacter, return the components of its Hecke part divided by the reciprocal of its Dirichlet part.
- Component(GR, P): GrossenChar, RngOrdIdl -> GrpDrchNFEl#
- Component(GR, oo): GrossenChar, RngIntElt -> GrpDrchNFEl#
- Component(GR, P): GrossenChar, PlcNumElt -> GrpDrchNFEl#
Given a Grössencharacter and a prime ideal or place (possibly specified by an integer for an infinite place), return the corresponding Dirichlet character component. For a place that it is not ramified, the trivial character of the integer ring is returned.
- Extend(GR, I): GrossenChar, RngOrdIdl -> GrossenChar#
- Restrict(GR, 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(GR): GrossenChar -> GrpDrchNFElt#
Compute the central character (down to \({\mathbb{Q}}\)) of a Grössencharacter, normalizing the result to be weight 0, and returning it as a Dirichlet character (over \({\mathbb{Q}}\) as a number field).
- GrossenTwist(GR, D): GrossenChar, List -> GrossenChar, GrpHecke#
Hilbert: BoolElt Default: false
Given a Grossencharacter \(Y\) and a list \(D\) of tuples \(\langle a,r \rangle\), find a twist \(\Psi\) of \(Y\) (by a Hecke character of the same modulus as \(Y\)) such that \(\Psi(a)=r\) for all data tuples. This operates by dividing the given \(r\)-values by the evaluations of \(Y\) at the given ideals, and using
HeckeCharacteron the resulting cyclotomic data. The intrinsic also returns a group of Hecke characters that corresponds to a kernel. The given values \(r\) should be coercible into the complex numbers, and a numerical matching is made. The \(a\) should be ideals or field elements. TheHilbertparameter restricts to twisting by characters of trivial modulus.
- TateTwist(GR, n): GrossenChar, RngIntElt -> GrossenChar#
- TateTwist(psi, n): GrpHeckeElt, RngIntElt -> GrossenChar#
Given a Grossencharacter or a Hecke character, return its Tate twist as a Grossencharacter. Note that the field need not be CM in the latter case.
- Example: Grossenchar Gaussian (ex-42864c)#
First, an example of \([1,0]\)-type Grössencharacters on the Gaussian field, with modulus \({\mathfrak{p}}_2^3\) where \({\mathfrak{p}}_2\) 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); CFENew(L); 1.57772181044202361082345713057E-30 > CentralValue(L); 0.655514388573029952616209897475 > CentralValue(LSeries(EllipticCurve("32a"))); 0.655514388573029952616209897473
- Example: Grossenchar Sqrt23 (ex-b4291f)#
An example with the canonical Grössencharacter for \(K={\mathbb{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 > CFENew(LSeries(GR)); 4.73316543132607083247037139170E-30 > 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\); in general, this
extension_fieldattribute is a capitulation field for \(K\) (thus \(K\) itself when the class number is 1), and the values of the Grössencharacter can be further twisted by cyclotomic factors.We can also twist the Grössencharacter by a Hecke character on \(I\), either via the
Grossencharacterintrinsic, 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 > CFENew(LSeries(GR2)); -7.09974814698910624870555708755E-30
- Example: Grossenchar Symcubed Sqrt59 (ex-7d182f)#
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 \({{\mathbb{Q}}}(\sqrt{-59})\), which has class number 3. The \(L\)-function can be alternatively realised from a weight 4 modular form of level \(59^2\).
> 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); > CFENew(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: Grossen Char Cyclo5 (ex-38ad25)#
An example with \({{\mathbb{Q}}}(\zeta_5)\), comparing the central value to the periods derived from \(\Gamma\)-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 \(\infty\)-type sends \(\zeta_5\) to \((\zeta_5^1)^3\cdot (\zeta_5^4)^0\cdot (\zeta_5^2)^1\cdot (\zeta_5^3)^2=\zeta_5^{11}\) 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, ... >; > CFENew(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]]\) \(\infty\)-type sends \(\zeta_5\) to \(\zeta_5^{3+0+2\cdot 2+3}=1\), but we still need \({\mathfrak{p}}_5\) 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); > 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 ]; > IntegerRelation(LOGS); [ -14, 2, -2, 14, 15, -4, 4 ]
- Example: Grossenchar Embedding (ex-a39eeb)#
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 _:=CFENew(L) : L in Ls ]; // force Sign computation [ 0.999999999999999999999999999997, 1.00000000000000000000000000000, 0.999999999999999999999999999997, 1.00000000000000000000000000000 ]
- Example: Grossen Large Gamma (ex-03fd6d)#
A final example with characters of trivial conductor, here of type \([2,0]\) in \({{\mathbb{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 \(\Gamma\)-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]; > IntegerRelation(LOGS); [ 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: Grossen Cyclo8 (ex-105c44)#
An example from [van Geemen and van Straten, 1993, §8.8]. Here the Grössencharacter is on an ideal of norm \(2^4\) in the cyclotomic field \({{\mathbb{Q}}}(\zeta_8)\). The Euler factors will factor in various fields. In Table 7.6 of the cited paper, one notes that the coefficients satisfy \(a_{17}=-180\) and \(a_{17^2}=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); > CFENew(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
- Example: Hypgeom Mot (ex-d12cc1)#
This examples exhibits the use of
GrossenTwist, and links a Grössencharacter to a hypergeometric datum. The chosen \(t\)-value is such that the degree 3 \(L\)-function is imprimitive, and it splits as \(L(\chi_{12},s+1)L(\Psi,s)\), where \(\Psi\) is defined over \({{\mathbb{Q}}}(\sqrt{-84})\), and has trivial modulus and \([2,0]\) \(\infty\)-type; there are still four such characters (the class number is 4), and we want the one with \(\Psi(\tenfrak p_2)=2\) and \(\Psi(\tenfrak p_3)=-3\). We then check the degree 3 Euler factors on all good primes up to 100.> P := PrimesInInterval(5,100); > H := HypergeometricData([2,3],[1,6]); > t := -27; > ZT := Translate(LSeries(KroneckerCharacter(12)),1); > K := QuadraticField(-84); > DATA2 := <Factorization(2*Integers(K))[1][1],2>; > DATA3 := <Factorization(3*Integers(K))[1][1],-3>; > G := HeckeCharacterGroup(1*Integers(K)); > GR := Grossencharacter(G.0,[[2,0]]); > LGR := LSeries(GrossenTwist(GR,[* DATA2, DATA3 *])); > PROD := LGR*ZT; > assert &and[EulerFactor(PROD,p : Integral) eq > EulerFactor(H,t,p) : p in P];
And another (simpler) example of GrossenTwist.
> K := QuadraticField(-1); > H := HeckeCharacterGroup(7*Integers(K)); > psi := H.1; // order 12 > GR := Grossencharacter(psi,[[1,0]]); > TW := GR*psi^7; > P := PrimesUpTo(100,K); > D :=[* <p,TW(p)> : p in P | Gcd(14,Norm(p)) eq 1 *]; > assert GrossenTwist(GR,D) eq TW;
Local Root Numbers#
One can also compute the local root numbers of Hecke characters and Grössencharacters at prime ideals over the field of definition and at places at infinity. Multiplying these together gives the global root number.
- RootNumber(GR, P): GrossenChar, RngOrgIdl -> FldComElt#
- RootNumber(psi, P): GrpHeckeElt, RngOrgIdl -> FldComElt#
- RootNumber(GR, P): GrossenChar, PlcNumElt -> FldComElt#
- RootNumber(psi, P): GrpHeckeElt, PlcNumElt -> FldComElt#
Precision: RngIntElt Default:
Given a Hecke character or Grössencharacter and a place or a prime ideal, return the local root number as a complex number.
- RootNumber(GR, p): GrossenChar, RngIntElt -> FldComElt#
- RootNumber(psi, p): GrpHeckeElt, RngIntElt -> FldComElt#
Precision: RngIntElt Default:
Given a Hecke character or Grössencharcter and a rational prime \(p\), compute the (induced) root number at \(p\).
- RootNumbers(GR): GrossenChar -> SeqEnum#
- RootNumbers(psi): GrossenChar -> SeqEnum#
Precision: RngIntElt Default: AA : BoolElt Default: false
Given a Hecke character or Grössencharacter, return the local root numbers at bad places (including infinite ones) as an array of tuples with places and complex approximations given. If the
AAvararg is set, the answer is returned as an associative array.
- RootNumber(GR): GrossenChar -> SeqEnum#
- RootNumber(psi): GrossenChar -> SeqEnum#
Precision: RngIntElt Default:
Given a Hecke character or Grössencharacter, return the global root number.
- Example: Rootno 27a (ex-a7b80a)#
We compute the local root numbers of the Grössencharacter over \({{\mathbb{Q}}}(\sqrt{-3})\) for the elliptic curve 27a, and some of its powers.
> G := Grossencharacter(EllipticCurve("27a")); G; Grossencharacter G of type [[ 1, 0 ]] for Hecke-Dirichlet pair (1,$.1*$.2^2) with modulus of norm 9 over Quadratic Field x^2 + 3 > K := NumberField(Order(Modulus(G))); > I := Ideal(Decomposition(K,3)[1][1]); > RootNumber(G,I); 6.80316131261355894597927551960E-31 + 1.00000000000000000000000000000*i > RootNumber(G,InfinitePlaces(K)[1]); -1.00000000000000000000000000000*i > RootNumber(G); // product of the two previous 1.00000000000000000000000000000 - 6.80316131261355894597927551960E-31*i > // over Q, the root numbers get induced to -1 and -1 > RootNumber(G,3); // at the rational prime 3 -1.00000000000000000000000000000 + 6.80316131261355894597927551960E-31*i > RootNumber(HodgeStructure(G)); // at oo -1 > for k in [1..12] do k,Real(RootNumber(G^k)); end for; 1 1.00000000000000000000000000000 2 1.00000000000000000000000000000 3 1.00000000000000000000000000000 4 1.00000000000000000000000000000 5 -1.00000000000000000000000000000 6 1.00000000000000000000000000000 7 1.00000000000000000000000000000 8 1.00000000000000000000000000000 9 -1.00000000000000000000000000000 10 1.00000000000000000000000000000 11 -1.00000000000000000000000000000 12 1.00000000000000000000000000000
- Example: Rohrlich Rootno (ex-f91aec)#
This example comes from Exercise 5.5 in Rohrlich’s PCMI lectures [Rohrlich, n.d.].
We take the Grössencharacter corresponding to the elliptic curve 49a, and then twist it over \({{\mathbb{Q}}}(\sqrt{-7})\) by \(-118-18\sqrt{-7}\). This disturbs the root number and the resulting \(L\)-function is no longer self dual, but it still vanishes at the central point.
> GR := Grossencharacter(EllipticCurve("49a")); > K := NumberField(Order(Modulus(GR))); K; // ensure same field Quadratic Field with defining polynomial x^2 + 7 over the Rational Field > psi := QuadraticCharacter(-118-18*K.1); > RootNumber(GR); 1.00000000000000000000000000000 + 1.04356488711804586030321101838E-30*i > RootNumber(psi); 1.00000000000000000000000000000 - 3.55311676760811128464401934867E-32*i > RootNumber(GR*psi); 0.943041920192897214648941373352 - 0.332673919565230241738496249562*i > L := LSeries(GR*psi); > CentralValue(L); // zero 2.91343312836088675607917006164E-30 > Sign(L); // root of 253*x^4 - 394*x^2 + 253 0.943041920192897214648941373361 - 0.332673919565230241738496249560*i
Grössencharacters and Elliptic Curves#
There are also functions that transform between elliptic curves over \({\mathbb{Q}}\) that have complex multiplication (over an imaginary quadratic field), and Grössencharacters associated to them.
- Grossencharacter(E): CrvEll -> GrossenChar#
Given an elliptic curve over \({\mathbb{Q}}\) with complex multiplication by an imaginary quadratic order, return the associated Grössencharacter.
- EllipticCurve(GR): GrossenChar -> CrvEll#
Given a suitable Grössencharacter, in particular of \(\infty\)-type \([1,0]\) over an imaginary quadratic field, with the underlying character of order 2, return an elliptic curve in the associated isogeny class.
- Example: Grossenchar And Ec (ex-e6dfed)#
> E := EllipticCurve("49a"); // cm by -7 > G := Grossencharacter(QuadraticTwist(E,5*29)); > Conductor(QuadraticTwist(EllipticCurve(G),5*29)); 49 > // > E := EllipticCurve([2^2 * 3 * 5^3 * 7 * 11^2 * 13^3, 0]); > G := Grossencharacter(E); > assert IsIsogenous(E,EllipticCurve(G)); > // > E := EllipticCurve([0, 2 * 3^5 * 5^3 * 7^4 * 11^2 * 13^5]); > G := Grossencharacter(E); > assert IsIsogenous(E,EllipticCurve(G)); > // > K := QuadraticField(-163); > p := Factorization(163*Integers(K))[1][1]; > psi := HeckeCharacterGroup(p).0; > G := Grossencharacter(psi,[[1,0]]); > E := EllipticCurve(G); > b, cm := HasComplexMultiplication(E); > assert b; assert cm eq -163; > Conductor(E); 26569