The most powerful way to create class fields or abelian extensions in Magma is to use the AbelianExtension function that enables the user to create the extension corresponding to some ideal group.
So, before we can describe the creation functions for the class fields, we have to deal with the ideal groups.
The classical approach to class field theory, which is well suited for computation, is based on ideal groups which are generalisations of the ideal class group.
In this section we describe in detail how to create full ideal groups, mainly ray class groups. As ray class groups are closely related to the unit groups of residue class rings of maximal order, these too are presented here.
In addition to the functions listed here, the CRT is relevant in this context.
Given an integral ideal I belonging to the maximal order of a number field, the ray class group modulo I is the quotient of the subgroup generated by the ideals coprime to I by the subgroup generated by the principal ideals generated by elements congruent to 1 modulo I and T if present.The sequence T contains the numbers [ i1, ..., ir] of certain real infinite places. When the sequence is supplied, the generators of the principal ideals must take positive values at the places indicated by T. The sequence T must be strictly ascending containing only positive integers, each not exceeding the number of real embeddings.
This function requires the class group to be known. If it is not already stored, it will be computed in such a way that its correctness is not guaranteed. However, it will almost always be correct. If the user requires a guaranteed result, then the class group must be verified by the user or computed up to the proof level required beforehand.
The ray class group is returned as an abelian group A, together with a mapping between A and a set of representatives for the ray classes.
The algorithm used is a mixture of Pauli's approach following Hasse ([Pau96], [HPP97]) and Cohen's method ([CDO96], [CDO98], [Coh00]).
Given a divisor (or place) of an absolute number field, compute the Ray class group defined modulo the divisor.This function requires the class group to be known. If it is not already stored, it will be computed in such a way that its correctness is not guaranteed. However, it will almost always be correct. If the user requires a guaranteed result, then the class group must be verified by the user or computed up to the proof level required beforehand.
The ray class group is returned as an abelian group A, together with a mapping between A and a set of representatives for the ray classes.
The algorithm used is a mixture of Pauli's approach following Hasse ([Pau96], [HPP97]) and Cohen's method ([CDO96], [CDO98], [Coh00]).
> R<x> := PolynomialRing(Integers());
> o := MaximalOrder(x^2-10);
> RayClassGroup(2*o, [1,2]);
Abelian Group isomorphic to Z/2 + Z/2
Defined on 2 generators
Relations:
2*$.1 = 0
2*$.2 = 0
Mapping from: Abelian Group isomorphic to Z/2 + Z/2
Defined on 2 generators
Relations:
2*$.1 = 0
2*$.2 = 0 to Set of ideals of o
> RayClassGroup(2*o);
Abelian Group isomorphic to Z/2
Defined on 1 generator
Relations:
2*$.1 = 0
Mapping from: Abelian Group isomorphic to Z/2
Defined on 1 generator
Relations:
2*$.1 = 0 to Set of ideals of o
As one can see, the inclusion of the infinite places only added a C2
factor to the group. In general, a set of infinite places containing n
elements can at most add n C2 factors to the group without
infinite places.
Now we enlarge the modulus by small primes. As one can see, the ray class group gets bigger.
> RayClassGroup(8*3*5*7*11*13*101*o);
Abelian Group isomorphic to Z/2 + Z/2 + Z/2 + Z/4 + Z/4 + Z/24 + Z/24 + Z/120 +
Z/600
Defined on 9 generators
Relations:
2*$.1 = 0
2*$.2 = 0
2*$.3 = 0
8*$.4 = 0
24*$.5 = 0
4*$.6 = 0
120*$.7 = 0
12*$.8 = 0
600*$.9 = 0
Mapping from: Abelian Group isomorphic to Z/2 + Z/2 + Z/2 + Z/4 + Z/4 + Z/24 +
Z/24 + Z/120 + Z/600
Defined on 9 generators
Relations:
2*$.1 = 0
2*$.2 = 0
2*$.3 = 0
8*$.4 = 0
24*$.5 = 0
4*$.6 = 0
120*$.7 = 0
12*$.8 = 0
600*$.9 = 0 to Set of ideals of o
Given an integral ideal I belonging to the maximal order of a number field, the ray residue ring modulo I is the unit group of the maximal order modulo I extended by one C2 factor for each element of T. The sequence T should be viewed as a condition on the signs of the numbers factored out.Let I be an integral ideal of an absolute maximal order and let T be a set of real places given by an increasing sequence containing integers i, 1≤i≤r1 where r1 is the number of real zeros of the defining polynomial of the field. This function computes the group of units mod * (I, T). The result is a finite abelian group and a map from the group to the order to which the ideal belongs.
When T is not given the unit group of the residue ring mod m is returned. This is equivalent to formally setting T := [ ] to be the empty sequence.
Given an effective divisor D of a number field, compute the unit group of the residue class ring defined modulo the divisor, ie. compute the group of elements that for the finite places in the support of D approximate 1 and have positive sign at the real infinite places of the support of D.
Let S be a finite set of prime ideals in a number field K. For an integer p, the p-Selmer group of S is defined as Kp(S) := { x ∈K x /(K x )p | vQ(x) = 0 mod p forall Q ∉S } Kp(S) is a finite abelian group of exponent p.
Integral: BoolElt Default: true
Nice: BoolElt Default: true
Raw: BoolElt Default: false
For a prime integer p and a set of prime ideals S in a number field K, the function returns the p-Selmer group of S as an abstract group G, together with a map m from K to G. The map comes with an inverse.In principle, the domain of m is the set of x in K satisfying the condition in the definition of Kp(S) above. When m(x) is invoked for x in K, it is assumed without checking that x satisfies the condition. If x does not, either a runtime error occurs, or the map returns a random element of G. (Checking the condition would require a far more expensive computation. The algorithm identifies the class of x in Kp(S) by computing the multiplicative orders of residues of x, and of the group generators, modulo some unrelated primes.)
The role of the optional parameters is as follows. The p-Selmer group is realized as a subgroup of a quotient of a suitable group of tilde S-units of the number field, the images of the map returned by pSelmerGroup are tilde S-units. Initially, tilde S is chosen as S and then enlarged until the p-part of the ideal class group of K is generated by the ideals in S. The parameter Raw is related to the same parameter in SUnitGroup, see SUnitGroup for more information. If the parameter is set to true, the objects returned as images of the pSelmerGroup map are exponent vectors that are applied to a fixed sequence of elements to get actual S-units, see the following example for a demonstration.
In addition to changing the return type, Raw also implies a reduction of the results, elements returned under Raw are reduced by removing the projection of the lattice generated by pth powers of tilde S-units. As a side effect of this reduction, elements are no longer guaranteed to be integral. To offset this, the parameter Integral can be set to true, in which case the sequence of multiplicative generators will be extended to contain uniformizing elements for all ideals in tilde S and the exponent vectors will be supplemented accordingly to achieve integrality.
> k := NumberField(Polynomial([-10, 0,1]));
> m := MaximalOrder(k);
> lp := Factorization(2*3*11*m);
> S := [ i[1] : i in lp];
> KpS, mKpS := pSelmerGroup(3, Set(S));
> KpS;
Abelian Group isomorphic to Z/3 + Z/3 + Z/3 + Z/3 + Z/3
Defined on 5 generators
Relations:
3*KpS.1 = 0
3*KpS.2 = 0
3*KpS.3 = 0
3*KpS.4 = 0
3*KpS.5 = 0
> mKpS;
Mapping from: RngOrd: m to GrpAb: KpS given by a rule
> mKpS(m!11);
KpS.2
> mKpS(m!11*2);
KpS.2 + 2*KpS.3 + 2*KpS.5
> mKpS(m!11*2*17^3);
KpS.2 + 2*KpS.3 + 2*KpS.5
So as long as the argument to mKpS is only multiplied by cubes, the
image will be stable.
Next, we do the same again, but this time using Raw:
> KpS, mKpS, mB, B := pSelmerGroup(3, Set(S):Raw);
> B;
(-m.1 -11/1*m.1 3/1*m.1 2/1*m.1 13/1*m.1 5/1*m.1 31/1*m.1
3/1*m.1 - 2/1*m.2 3/1*m.1 + 2/1*m.2 m.1 - 2/1*m.2 m.1
+ 2/1*m.2 m.2 m.1 + m.2 m.1 - m.2 -2/1*m.1 - m.2 m.2
3/1*m.1 3/1*m.1 11/1*m.1)
> #Eltseq(B);
19
> mB;
Mapping from: GrpAb: KpS to Full RSpace of degree 19 over
Integer Ring given by a rule [no inverse]
> r := KpS.1 + KpS.2 + 2*KpS.4 + KpS.5;
> r @@ mKpS;
396/1*m.1 + 99/1*m.2
> r @ mB;
( 0 1 -2 0 0 0 0 0 0 0 0 0 1 0 1 0 3 0 0)
> PowerProduct(B, $1);
396/1*m.1 + 99/1*m.2
Given maps m1: G1 to I1, m2: G2 to I2 from some finite abelian groups into the ideals of some maximal order, and a map h:I1 to I2 on the ideals, compute the map induced by h on the abelian groups.For this to work, m1, and m2 need to be maps that can be used to define abelian extensions. This implies that mi has to be a composition of maps where the last component is either the map returned by ClassGroup or by RayClassGroup. The argument c should be a multiple of the minima of the defining moduli.
The result is the map as defined by
hom<G_1 -> G_2 | [ h(r_1(G_1.x)) @@ r_2 : x in [1..Ngens(G_1)]]>For larger modules however, this function is much faster than the straightforward approach. This function tries to find a set of "small" generators for both groups. Experience shows that ray class groups (and their quotients) can usually defined by a "small" set of "small" prime ideals. Since solving the discrete logarithm in ray class groups depends upon solving the discrete logarithm for class groups which is quite slow for "large" ideals, it is much faster in general to use this rather roundabout approach. "Small" ideal in this context means "small" norm.
An abbreviation for InducedMap(r, r, h, c).
> k := NumberField([Polynomial([-10, 0, 1]), CyclotomicPolynomial(16)]);
> k := OptimizedRepresentation(AbsoluteField(k));
> o := MaximalOrder(k);
> ClassGroup(o : Proof := "GRH");
Abelian Group of order 1
Mapping from: Abelian Group of order 1 to Set of ideals of o
> IndependentUnits(o);
Abelian Group isomorphic to Z/16 + Z (7 copies)
Defined on 8 generators
Relations:
16*$.1 = 0
Mapping from: Abelian Group isomorphic to Z/16 + Z (7 copies)
Defined on 8 generators
Relations:
16*$.1 = 0 to RngOrd: o
> SetOrderUnitsAreFundamental(o);
> p := &* [113, 193, 241];
> r, mr := RayClassGroup(p*o);
> #r; Ngens(r);
1706131176377019905236218856143547400125963963181004962861678592\
000000000
26
The automorphisms of k act on this group. One way of obtaining the action
is:
> autk := Automorphisms(k); > time m1 := hom<r -> r | [ autk[2](mr(r.i))@@ mr : i in [1..Ngens(r)]]>; Time: 1.080In contrast, using InducedAutomorphism:
> time InducedAutomorphism(mr, autk[2], p); Time: 1.010Now we increase p:
> p *:= 257*337; > r, mr := RayClassGroup(p*o); > #r; Ngens(r); 3831748420755023278212540125628635035038808247955859769266388851\ 8259419871708134228623706727453425990974892633470189282997043200\ 0000000 42 > time m1 := hom<r -> r | [ autk[2](mr(r.i))@@ mr : i in [1..Ngens(r)]]>; Time: 2.950 > time InducedAutomorphism(mr, autk[2], p); Time: 6.200For "small" examples the direct approach is much faster, but for large ones, especially if one is only interested in certain quotients, the other approach is faster.
The ultimate goal of class field theory is the classification of all abelian extensions of a given number field. Although the theoretical question was settled in the 1930's, it is still difficult to explicitly compute defining equations for class fields. For extensions of imaginary quadratic fields, there are well known analytic methods available. This section explains the basic operations implemented to create class fields in Magma.
Given a map m : G to Ik where G is a finite abelian group and Ik is the set of ideals of some absolute maximal order construct the class field defined by m.More formally, m - 1 must be a homomorphism from some ray class group R onto a finite abelian group G. If either I or I and T are given, they must define R. This implies that I has to be an integral ideal and that T has to be a sequence containing the relevant infinite places. Otherwise, Magma will try to extract this information from m. The class field defined by m has Galois group isomorphic to R/ker(m - 1) under the Artin map.
Note that Magma cannot check whether the map passed in is valid. If an invalid map is supplied, the output will most likely be garbage.
Maps commonly given as m are class group maps, ray class group maps and the composition of the inverse of the canonical map from a ray class group into the quotient of that ray class group by a subgroup and the ray class group map.
Creates the full ray class field modulo the ideal I.
Create the full Ray class field defined modulo the divisor D, ie. an abelian extension that is unramified outside the support of D and such that the (abelian) automorphism group is canonically isomorphic to the ray class group modulo D.
For a map m as in AbelianExtension and a prime number p, create the maximal p-field, i.e. the maximal subfield having degree a p--power.
We demonstrate this by computing the 12-th cyclotomic field using class fields:
Unfortunately, as ray class groups are not defined for Z in Magma, we must work in a degree 1 extension of Q:
> x := ext<Rationals()|>.1; > Q := ext<Rationals()| x-1 :DoLinearExtension>; > M := MaximalOrder(Q);The ray class group that defines Q(ζ12) is defined mod (12, ∞) where ∞ is the unique infinite place of Q. There are at least two ways of looking at this: First, since Q(ζ12) is a totally complex field, the infinite place of Q must ramify (by convention: C is ramified over R), so we must include the infinite place in the definition of the ray class group.
Secondly, the ray class group mod (12) without the infinite place is too small. We know φ(12) = 4, (Z/12Z) * = {1, 5, 7, 11} = {∓ 1, ∓ 5}. As ideals we have (1) = o = ( - 1) = (11) and (5) = ( - 5) = (7) so that Cl12 isomorphic to C2. By introducing T = [1], we distinguish ∓ 1 and ∓ 5.
> G, m := RayClassGroup(12*M, [1]);
> G;
Abelian Group isomorphic to Z/2 + Z/2
Defined on 2 generators
Relations:
2*G.1 = 0
2*G.2 = 0
> A := AbelianExtension(m);
> E := EquationOrder(A);
> Ea := SimpleExtension(E);
> Ma := MaximalOrder(Ea);
> Discriminant(Ma);
144
> Factorization(Polynomial(Ma, CyclotomicPolynomial(12)));
[
<ext<Ma|>.1 + [0, 1, 0, -1], 1>,
<ext<Ma|>.1 + [0, -1, 0, 0], 1>,
<ext<Ma|>.1 + [0, 1, 0, 0], 1>,
<ext<Ma|>.1 + [0, -1, 0, 1], 1>
]
The main advantage of this method over the use of the cyclotomic polynomials
is the fact that we can directly construct certain subfields:
> x := ext<Integers()|>.1;
> M := MaximalOrder(x^2-10);
> G, m := RayClassGroup(3615*M, [1,2]);
> G; m;
Abelian Group isomorphic to Z/2 + Z/2 + Z/4 + Z/80 + Z/240
Defined on 5 generators
Relations:
4*G.1 = 0
80*G.2 = 0
240*G.3 = 0
2*G.4 = 0
2*G.5 = 0
Mapping from: GrpAb: G to Set of ideals of M
We will only compute the 5-part of this field:
> h := hom<G -> G | [5*G.i : i in [1..#Generators(G)]]>;
> Q, mq := quo<G|Image(h)>;
> mm := Inverse(mq) * m;
> mm;
Mapping from: GrpAb: Q to Set of ideals of M
> A := AbelianExtension(mm);
> E := EquationOrder(A);
> E;
Non-simple Equation Order defined by x^5 - [580810, 0]*x^3 +
[24394020, -40656700]*x^2 + [15187310285, 2799504200]*x
+ [1381891263204, 530506045900], x^5 - [580810, 0]*x^3 +
[-109192280, 34848600]*x^2 + [30584583385,
16797025200]*x + [-341203571896, 109180663800] over its
ground order
> C := Components(A);
The function Components gives a list of cyclic extensions of M
that correspond to the cyclic factors of G.
> GaloisGroup(NumberField(C[1]));
Permutation group acting on a set of cardinality 5
Order = 5
(1, 4, 2, 5, 3)
[ -9 + O(41), 15 + O(41), 6 + O(41), 18 + O(41), 11 + O(41) ]
GaloisData over Z_Prime Ideal
Two element generators:
[41, 0]
[25, 1] - relative case
> GaloisGroup(NumberField(C[2]));
Order = 5
(1, 4, 2, 5, 3)
[ 38 + O(79), -28 + O(79), -31 + O(79), 27 + O(79), -6 + O(79) ]
GaloisData over Z_Prime Ideal
Two element generators:
[79, 0]
[57, 1] - relative case
Thus the Galois group is indeed proven to be C5 x C5.
Creates the full ray class field modulo the ideal I and the infinite places in P.
Creates the Hilbert class field of K, i.e. the maximal unramified abelian extension of K. This is equivalent to AbelianExtension(1*MaximalOrder(K)).
Conductor: [RngOrdIdl, [RngIntElt]] Default: [ ]
Let k be the coefficient field of the given number field K. This function creates the maximal abelian extension A of k inside K. If Conductor is given, it must contain a multiple of the true conductor. If no value is specified, the discriminant of K is used.The correctness of this function is based on some heuristics. The algorithm is similar to [Coh00, Algorithm 4.4.3]
Conductor: [RngOrdIdl, [RngIntElt]] Default: [ ]
Creates an abelian extension A of k the coefficient field of the input K that is isomorphic to K. If a value for Conductor is given, it must contain a multiple of the true conductor, otherwise the discriminant of K is used to be more specific, in case K is a number field, the discriminant of it's maximal order is used as an initial guess, while for field of fractions of orders (K of type FldOrd), the defining order gives the initial guess.In contrast to MaximalAbelianSubfield, provided the field is abelian, this function always computes a correct answer.
> m := LLL(MaximalOrder(Polynomial([2601, -153, -144, 93, 6, -3, 1 ])));The call to LLL is not necessary, but quite frequently class group computations are faster if the order basis is LLL-reduced first.
> a, b := ClassGroup(m : Proof := "GRH");
> a;
Abelian Group isomorphic to Z/3 + Z/3
Defined on 2 generators
Relations:
3*a.1 = 0
3*a.2 = 0
HilbertClassField on m computes a Non-simple number field
defining the Hilbert class field of m.
> H := HilbertClassField(NumberField(m)); H;
Number Field with defining polynomial [ $.1^3 + 1/595*(-460*$.1^5
+ 2026*$.1^4 - 4052*$.1^3 - 52572*$.1^2 + 229338*$.1 -
529159), $.1^3 + 1/37485*(82*$.1^5 + 4344*$.1^4 + 8805*$.1^3
+ 15990*$.1^2 + 410931*$.1 + 1098693)] over its ground field
> time _ := MaximalOrder(H);
Time: 2.200
However, in order to access more of the structural information of H
we have to create it as an abelian extension, using b.
> A := AbelianExtension(b); > HH := NumberField(A);Now we are able to compute the maximal order of HH using A and verify the discriminant:
> time M := MaximalOrder(A:Al := "Discriminant"); Time: 0.170 > Discriminant(M); Ideal of m Basis: [1 0 0 0 0 0] [0 1 0 0 0 0] [0 0 1 0 0 0] [0 0 0 1 0 0] [0 0 0 0 1 0] [0 0 0 0 0 1]Note, that as a side effect, the maximal order of HH is now known:
> time MaximalOrder(HH);
Maximal Order of Equation Order with defining polynomials x^3 + [841, 841, 312,
-534, 222, 0], x^3 + [25, -2, -9, 7, -11, -8] over m
Time: 0.000
We will continue this example following the next section.
The model underlying the class field theory as implemented in Magma is based on the (generalized) ideal class groups. Based on this group-theoretical description, certain binary operations are easily possible:
Gives two abelian extensions with the same base field, decide if they are the same.
Gives two abelian extensions with the same base field, decide if they are contained in each other.
Given two abelian extensions with the same base field, find the smallest abelian extension containing both.
Given two abelian extensions with the same base field, find the largest common subfield.