|
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.
RayClassGroup(I) : RngOrdIdl -> GrpAb, Map
RayClassGroup(I, T) : RngOrdIdl, SeqEnum[RngIntElt] -> GrpAb, Map
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]).
RayClassGroup(P) : PlcNumElt -> GrpAb, Map
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]).
Some ray class groups are computed below. The example merely illustrates
the fact that ray class groups tend to grow if their defining module grows
and can be arbitrarily large. This should be compared to class groups
where it is rather difficult to give examples of fields having "large"
class groups --- unless one takes imaginary quadratic fields.
> 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 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
RayResidueRing(I, T) : RngOrdIdl, SeqEnum[RngIntElt] -> GrpAb, Map
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.
RayResidueRing(P) : PlcNumElt -> GrpAb, Map
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.
pSelmerGroup(p, S) : RngIntElt, { RngOrdIdl } -> GrpAb, Map
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.
We compute the 3-Selmer group of Q(√(10)) with respect to the primes
above 2, 3, 11:
> 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(m_1(G_1.x)) @@ m_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).
Consider a "large" ray class group over k := Q[Sqrt(10), ζ 16]
> 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.080
In contrast, using InducedAutomorphism:
> time InducedAutomorphism(mr, autk[2], p);
Time: 1.010
Now 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.200
For "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.
RayClassField(m, I, T) : Map, RngOrdIdl, [RngIntElt] -> FldAb
AbelianExtension(m, I, T) : Map, RngOrdIdl, [RngIntElt] -> FldAb
RayClassField(m, I) : Map, RngOrdIdl -> FldAb
AbelianExtension(m, I) : Map, RngOrdIdl -> FldAb
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.
RayClassField(P) : PlcNumElt -> FldAb
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.
The abelian extensions of Q are known to lie
in some cyclotomic field.
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 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)).
MaximalAbelianSubfield(F): FldOrd -> FldAb
MaximalAbelianSubfield(K) : FldNum -> FldAb
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]
AbelianExtension(M): RngOrd -> FldAb
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.
We will compute the Hilbert class field of the sextic field defined by
a zero of the polynomial x 6 - 3x 5 + 6x 4 + 93x 3 - 144x 2 - 153x + 2601
which has a class group
isomorphic to C 3 x C 3.
> 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.
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|