Creation#
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.
Ray Class 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 \([ i_1, \ldots, i_r]\) 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 ([Heß et al., 1997, Pauli, 1996]) and Cohen’s method ([Cohen, 2000, Cohen et al., n.d., Cohen et al., 1998]).
- RayClassGroup(D): DivNumElt -> GrpAb, Map#
- 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 ([Heß et al., 1997, Pauli, 1996]) and Cohen’s method ([Cohen, 2000, Cohen et al., n.d., Cohen et al., 1998]).
- Example: Ideal Ray (ex-0ba809)#
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): RngOrdIdl -> GrpAb, Map#
- 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 \(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\leq i\leq 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 \(\mathop{\rm mod}\nolimits^* (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(D): DivNumElt -> GrpAb, Map#
- 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\).
Selmer Groups#
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
\(K_p(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 \(K_p(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 \(K_p(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
pSelmerGroupare \(\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 parameterRawis related to the same parameter inSUnitGroup, see RngOrd:SUnitGroup for more information. If the parameter is set totrue, the objects returned as images of thepSelmerGroupmap 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,
Rawalso implies a reduction of the results, elements returned underRaware reduced by removing the projection of the lattice generated by \(p\)th powers of \(\tilde S\)-units. As a side effect of this reduction, elements are no longer guaranteed to be integral. To offset this, the parameterIntegralcan be set totrue, 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.
- Example: Selmer Group (ex-2ae671)#
We compute the \(3\)-Selmer group of \({\mathbb{Q}}(\sqrt {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
mKpSis only multiplied by cubes, the image will be stable. Next, we do the same again, but this time usingRaw:> 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
Maps#
- InducedMap(m1, m2, h, c): Map, Map, Map, RngIntElt -> Map#
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. This implies that \(m_i\) has to be a composition of maps where the last component is either the map returned by
ClassGroupor byRayClassGroup. 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.
- InducedAutomorphism(r, h, c): Map, Map, RngIntElt -> Map#
An abbreviation for
InducedMap(r, r, h, c).
- Example: induced Map (ex-110f86)#
Consider a “large” ray class group over \(k := {\mathbb{Q}}[\sqrt{10}, \zeta_{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.
Abelian Extensions#
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): Map -> FldAb#
- AbelianExtension(m): Map -> FldAb#
- 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 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 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.
- AbelianExtension(I): RngOrdIdl -> FldAb#
Creates the full ray class field modulo the ideal \(I\).
- RayClassField(D): DivNumElt -> FldAb#
- 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\).
- AbelianpExtension(m, p): Map, RngIntElt -> FldAb#
For a map \(m\) as in
AbelianExtensionand a prime number \(p\), create the maximal \(p\)-field, i.e. the maximal subfield having degree a \(p\)–power.
- Example: Class Field (ex-cfc4e4)#
The abelian extensions of \({\mathbb{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 \({\mathbb{Z}}\) in Magma, we must work in a degree \(1\) extension of \({\mathbb{Q}}\):
> x := ext<Rationals()|>.1; > Q := ext<Rationals()| x-1 :DoLinearExtension>; > M := MaximalOrder(Q);
The ray class group that defines \({\mathbb{Q}}(\zeta_{12})\) is defined \(\mathop{\rm mod}\nolimits(12, \infty)\) where \(\infty\) is the unique infinite place of \({\mathbb{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 \({\mathbb{Q}}\) must ramify (by convention: \({\mathbb{C}}\) is ramified over \({\mathbb{R}}\)), so we must include the infinite place in the definition of the ray class group.
Secondly, the ray class group \(\mathop{\rm mod}\nolimits(12)\) without the infinite place is too small. We know \(\phi(12) = 4\), \(({\mathbb{Z}}/12{\mathbb{Z}})^* = \{1, 5, 7, 11\} = \{\pm 1, \pm 5\}\). As ideals we have \((1) = o = (-1) = (11)\) and \((5) = (-5) = (7)\) so that \({\operatorname{Cl}}_{12} \cong C_2\). By introducing \(T = [1]\), we distinguish \(\pm1\) and \(\pm 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
Componentsgives 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 \times C_5\).
- AbelianExtension(I, P): RngOrdIdl, [RngIntElt] -> FldAb#
Creates the full ray class field modulo the ideal \(I\) and the infinite places in \(P\).
- HilbertClassField(K): FldAlg -> FldAb#
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(M): RngOrd -> FldAb#
- 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
Conductoris 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 [Cohen, 2000, Algorithm 4.4.3]
- AbelianExtension(K): FldAlg -> FldAb#
- 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
Conductoris 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 typeFldOrd), the defining order gives the initial guess.In contrast to
MaximalAbelianSubfield, provided the field is abelian, this function always computes a correct answer.
- Example: Hilbert Class Field (ex-1fc01e)#
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\times 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
HilbertClassFieldonmcomputes a Non-simple number field defining the Hilbert class field ofm.> 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
Hwe have to create it as an abelian extension, usingb.> A := AbelianExtension(b); > HH := NumberField(A);
Now we are able to compute the maximal order of
HHusingAand 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
HHis 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.
Binary Operations#
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:
- A eq B: FldAb, FldAb -> BoolElt#
Gives two abelian extensions with the same base field, decide if they are the same.
- A subset B: FldAb, FldAb -> BoolElt#
Gives two abelian extensions with the same base field, decide if they are contained in each other.
- A * B: FldAb, FldAb -> FldAb#
Given two abelian extensions with the same base field, find the smallest abelian extension containing both.
- A meet B: FldAb, FldAb -> FldAb#
Given two abelian extensions with the same base field, find the largest common subfield.