Class Field Theory
Introduction
This chapter deals with abelian extensions of number fields and the rational numbers.
Class Field Theory, here specifically, class field theory of global number fields, deals with abelian extension, ie. fields where the group of automorphisms is abelian. For extensions of
In Hecke, abelian extensions are parametrized by quotients of so called ray class groups. The language of ray class groups while dated is more applicable to algorithms than the modern language of idel class groups and quotients.
Ray Class Groups
Given an integral ideal
ray_class_group(m::AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}, inf_plc::Vector{InfPlc}; n_quo::Int, lp::Dict{AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}, Int}) -> FinGenAbGroup, MapRayClassGrp
Given an ideal n_quo
is set, it will return the group modulo n_quo
. The factorization of lp
.
class_group(K::AbsSimpleNumField) -> FinGenAbGroup, Map
Shortcut for class_group(maximal_order(K))
: returns the class group as an abelian group and a map from this group to the set of ideals of the maximal order.
norm_group(f::Nemo.PolyRingElem, mR::Hecke.MapRayClassGrp, is_abelian::Bool = true; of_closure::Bool = false) -> Hecke.FinGenGrpAb, Hecke.FinGenGrpAbMap
norm_group(f::Array{PolyRingElem{AbsSimpleNumFieldElem}}, mR::Hecke.MapRayClassGrp, is_abelian::Bool = true; of_closure::Bool = false) -> Hecke.FinGenGrpAb, Hecke.FinGenGrpAbMap
Computes the subgroup of the Ray Class Group is_abelian
is set to true, then the code assumes the field to be abelian, hence the algorithm stops when the quotient by the norm group has the correct order. Even though the algorithm is probabilistic by nature, in this case the result is guaranteed. If of_closure
is given, then the norm group of the splitting field of the polynomial(s) is computed. It is the callers responsibility to ensure that the ray class group passed in is large enough.
norm_group(K::RelSimpleNumField{AbsSimpleNumFieldElem}, mR::Hecke.MapRayClassGrp) -> Hecke.FinGenGrpAb, Hecke.FinGenGrpAbMap
norm_group(K::RelNonSimpleNumField{AbsSimpleNumFieldElem}, mR::Hecke.MapRayClassGrp) -> Hecke.FinGenGrpAb, Hecke.FinGenGrpAbMap
Computes the subgroup of the Ray Class Group
Ray Class Fields
In general, the construction of a class field starts with a (ray) class group. Each quotient of a ray class group then defines a ray class field, the defining property is that the (relative) automorphism group is canonically isomorphic to the quotient of the ray class group where the isomorphism is given by the Artin (or Frobenius) map. Since, in Hecke, the (ray) class groups have no link to the field, actually this has to be specified using the maps.
It should be noted that this is a lazy construction: nothing is computed at this point.
ray_class_field(m::MapClassGrp) -> ClassField
ray_class_field(m::MapRayClassGrp) -> ClassField
Creates the (formal) abelian extension defined by the map
ray_class_field(m::Union{MapClassGrp, MapRayClassGrp}, quomap::FinGenAbGroupHom) -> ClassField
For
ray_class_field(I::AbsNumFieldOrderIdeal; n_quo = 0) -> ClassField
The ray class field modulo n_quo
is given, then the largest subfield of exponent
ray_class_field(I::AbsNumFieldOrderIdeal, inf::Vector{InfPlc}; n_quo = 0) -> ClassField
The ray class field modulo n_quo
is given, then the largest subfield of exponent
hilbert_class_field(k::AbsSimpleNumField) -> ClassField
The Hilbert class field of
ring_class_field(O::AbsNumFieldOrder) -> ClassField
The ring class field of
Example
julia> Qx, x = polynomial_ring(FlintQQ, "x");
julia> K, a = number_field(x^2 - 10, "a");
julia> c, mc = class_group(K)
(Z/2, ClassGroup map of
Set of ideals of Maximal order of Number field of degree 2 over QQ
with basis AbsSimpleNumFieldElem[1, a])
julia> A = ray_class_field(mc)
Class field defined mod (<1, 1>, InfPlc{AbsSimpleNumField, AbsSimpleNumFieldEmbedding}[]) of structure Z/2
Conversions
Given a ray class field, it is possible to actually compute defining equation(s) for this field. In general, the number field constructed this way will be non-simple by type and is defined by a polynomial for each maximal cyclic quotient of prime power order in the defining group.
The algorithm employed is based on Kummer-theory and requires the addition of a suitable root of unity. Progress can be monitored by setting set_verbose_level(:ClassField, n)
where
number_field(CF::ClassField) -> RelNonSimpleNumField{AbsSimpleNumFieldElem}
Given a (formal) abelian extension, compute the class field by finding defining polynomials for all prime power cyclic subfields.
Note, the return type is always a non-simple extension.
julia> Qx, x = polynomial_ring(FlintQQ, "x");
julia> k, a = number_field(x^2 - 10, "a");
julia> c, mc = class_group(k);
julia> A = ray_class_field(mc)
Class field defined mod (<1, 1>, InfPlc{AbsSimpleNumField, AbsSimpleNumFieldEmbedding}[]) of structure Z/2
julia> K = number_field(A)
Non-simple number field with defining polynomials [x^2 - 2]
over number field with defining polynomial x^2 - 10
over rational field
julia> ZK = maximal_order(K)
Relative maximal order of Non-simple number field of degree 2 over number field
with pseudo-basis
(1, 1//1 * <1, 1>)
(_$1 + a, 1//4 * <2, a>)
julia> isone(discriminant(ZK))
true
ray_class_field(K::RelSimpleNumField{AbsSimpleNumFieldElem}) -> ClassField
ray_class_field(K::AbsSimpleNumField) -> ClassField
For a (relative) abelian extension, compute an abstract representation as a class field.
genus_field(A::ClassField, k::AbsSimpleNumField) -> ClassField
The maximal extension contained in
maximal_abelian_subfield(A::ClassField, k::AbsSimpleNumField) -> ClassField
The maximal abelian extension of
maximal_abelian_subfield(K::RelSimpleNumField{AbsSimpleNumFieldElem}; of_closure::Bool = false) -> ClassField
Using a probabilistic algorithm for the norm group computation, determine the maximal abelian subfield in of_closure
is set to true, then the algorithm is applied to the normal closure of
Invariants
degree(A::ClassField)
The degree of
base_ring(A::ClassField)
The maximal order of the field that
discriminant(C::ClassField) -> AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}
Using the conductor-discriminant formula, compute the (relative) discriminant of
conductor(C::ClassField) -> AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}, Vector{InfPlc}
Return the conductor of the abelian extension corresponding to
defining_modulus(CF::ClassField)
The modulus, i.e. an ideal of the set of real places, used to create the class field.
is_cyclic(C::ClassField)
Tests if the (relative) automorphism group of
is_conductor(C::Hecke.ClassField, m::AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}, inf_plc::Vector{InfPlc}=InfPlc[]; check) -> AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}, Vector{InfPlc}
Checks if (m, inf_plc) is the conductor of the abelian extension corresponding to check
is false
, it assumes that the given modulus is a multiple of the conductor. This is usually faster than computing the conductor.
is_normal(C::ClassField) -> Bool
For a class field
is_central(C::ClassField) -> Bool
For a class field
Operations
*(A::ClassField, B::ClassField) -> ClassField
The compositum of
compositum(a::ClassField, b::ClassField) -> ClassField
The compositum of
intersect(a::ClassField, b::ClassField) -> ClassField
The intersection of
prime_decomposition_type(C::ClassField, p::AbsNumFieldOrderIdeal) -> (Int, Int, Int)
For a prime
is_subfield(a::ClassField, b::ClassField) -> Bool
Determines if
is_local_norm(r::ClassField, a::AbsNumFieldOrderElem) -> Bool
Tests if
is_local_norm(r::ClassField, a::AbsNumFieldOrderElem, p::AbsNumFieldOrderIdeal) -> Bool
Tests if
normal_closure(C::ClassField) -> ClassField
For a ray class field
subfields(C::ClassField; degree::Int) -> Vector{ClassField}
Find all subfields of
If the optional keyword argument degree
is positive, then only those with prescribed degree will be returned.
Note
This will not find all subfields over