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 computations, 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 [ i_1, ..., i_r] of certain real infinite places. When the sequence is supplied, the generators of the principal ideals have to take positive values at the places indicated by T. The sequence T must be strictly ascending containing only positive integers, each less or equal to 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], [HPP03]) and Cohen's method ([CDO96], [CDO97], [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 C_2
factor to the group. In general a set of infinite places containing n
elements can at most add n C_2 factors to the group without
infinite places.
Now we enlarge the modulus by small primes. As one can see, the ray class group grows.
> 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 C_2 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 <= r_1 where r_1 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 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.
SetVerbose("ClassGroup", n): Maximum: 5
Let S be a finite set of prime ideals of the absolute maximal order O of some number field k. Let p be a prime number. The p-Selmer group with respect to S is the abelian group defined by: K_p(S) := { x in K | v_a(x) = 0 mod p forall a notin S}. Equivalently: K_p(S) := { x in K | exists ( ideals) a, b: a^p b = (x) ( and )b( coprime to )S}.This group is of interest in algebraic geometry and class field theory as K(( KpS)^(1/n) is the maximal abelian extension of k of exponent n that is unramified outside S (if zeta_n in k and S is "large enough").
> 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.
Given maps m_1: G_1 to I_1, m_2: G_2 to I_2 from some finite abelian groups into the ideals of some maximal order, and a map h:I_1 to I_2 on the ideals, compute the map induced by h on the abelian groups.For this to work, m_1, and m_2 need to be maps that can be used to define abelian extensions. That means m_i 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:Bound := 500); Abelian Group of order 1 Mapping from: Abelian Group of order 1 to Set of ideals of o > IndependentUnits(o); > SetOrderUnitsAreFundamental(o); > p := &* [113, 193, 241]; > r, mr := RayClassGroup(p*o); > #r; Ngens(r); 1706131176377019905236218856143547400125963963181004962861678592\ 000000000 26The 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: 26.300In contrast, using InducedAutomorphism:
> time InducedAutomorphism(mr, autk[2], p); Time: 19.080Now 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: 115.120 > time InducedAutomorphism(mr, autk[2], p); Time: 82.390For "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 I_k where G is a finite abelian group and I_k 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 an finite abelian group G. If either I or I and T are given, they must define R. That means, I has to be an integral ideal and T 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 passed in the output is most likely garbage.
Creates the full ray class field modulo the ideal I.
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(zeta_(12)) is defined mod (12, Infinity) where Infinity is the unique infinite place of Q. There are at least two ways of looking at this: First, since Q(zeta_(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 phi(12) = 4, (Z/12Z)^ * = {1, 5, 7, 11} = {+- 1, +- 5}. As ideals we have (1) = o = ( - 1) = (11) and (5) = ( - 5) = (7) so that Cl_(12) isomorphic to C_2. 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(C[1]);
Permutation group acting on a set of cardinality 5
(1, 2, 3, 4, 5)
[ 32, 18, 15, 11, 6 ]
Prime Ideal of M
Two element generators:
[41, 0]
[25, 1]
> GaloisGroup(C[2]);
Permutation group acting on a set of cardinality 5
(1, 2, 3, 4, 5)
[ w^201693, w^22965, w^298545, w^168165, w^329685 ]
Prime Ideal of M
Two element generators:
[13, 0]
[6, 1]
Thus the Galois group is indeed proven to be C_5 x C_5.
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.In contrast to MaximalAbelianSubfield, provided the field is abelian, this function always computes a correct anwser.
> 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:Bound := 300);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: 56.150
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 := "Disc"); Time: 3.260 > 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.