Class Field Theory

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 {\Q}, the famous Kronnecker-Weber theorem classifies all such fields: a field is abelian if and only if it is contained in some cyclotomic field. For general number fields this is more involved and even for extensions of {\Q} is is not practical.

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 $m_0 \le Z_K$ and a list of real places $m_\infty$, the ray class group modulo $(m_0, m_\infty)$, $C(m)$ is defined as the group of ideals coprime to $m_0$ modulo the elements $a\in K^*$ s.th. $v_p(a-1) \ge v_p(m_0)$ and for all $v\in m_\infty$, $a^{(v)} >0$. This is a finite abelian group. For $m_0 = Z_K$ and $m_\infty = \{\}$ we get $C()$ is the class group, if $m_\infty$ contains all real places, we obtain the narrow class group, or strict class group.

ray_class_group(m::Hecke.NfAbsOrdIdl{Nemo.AnticNumberField,Nemo.nf_elem}, inf_plc::Array{Hecke.InfPlc,1}; p_part, n_quo)
class_group(O::Hecke.NfAbsOrd{Nemo.AnticNumberField,Nemo.nf_elem}; bound, method, redo, unit_method, large)
class_group(K::Nemo.AnticNumberField)
norm_group(f::Nemo.PolyElem, mR::Hecke.MapRayClassGrp, isabelian::Bool)
norm_group(K::NfRel{nf_elem}, mR::Hecke.MapRayClassGrp, isabelian::Bool)

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 {\em lazy} construction: nothing is computed at this point.

Hecke.ray_class_field — Method.
ray_class_field(m::MapClassGrp) -> ClassField
ray_class_field(m::MapRayClassGrp) -> ClassField

Creates the (formal) abelian extension defined by the map $m: A \to I$ where $I$ is the set of ideals coprime to the modulus defining $m$ and $A$ is a quotient of the ray class group (or class group). The map $m$ must be the map returned from a call to {classgroup} or {rayclass_group}.

Hecke.ray_class_field — Method.
ray_class_field(m::Union{MapClassGrp, MapRayClassGrp}, quomap::GrpAbFinGenMap) -> ClassField

For $m$ a map computed by either {rayclassgroup} or {class_group} and $q$ a canonical projection (quotient map) as returned by {quo} for q quotient of the domain of $m$ and a subgroup of $m$, create the (formal) abelian extension where the (relative) automorphism group is canonically isomorphic to the codomain of $q$.

Hecke.ray_class_field — Method.
ray_class_field(I::NfAbsOrdIdl; n_quo = 0) -> ClassField

The ray class field modulo $I$. If {{{n_quo}}} is given, then the largest subfield of exponent $n$ is computed.

Hecke.ray_class_field — Method.
ray_class_field(I::NfAbsOrdIdl, inf::Array{InfPlc, 1}; n_quo = 0) -> ClassField

The ray class field modulo $I$ and the infinite places given. If {{{n_quo}}} is given, then the largest subfield of exponent $n$ is computed.

Hecke.hilbert_class_field — Method.
hilbert_class_field(k::AnticNumberField) -> ClassField

The Hilbert class field of $k$ as a formal (ray-) class field.

Hecke.ring_class_field — Method.
ring_class_field(O::NfAbsOrd) -> ClassField

The ring class field of $O$, ie. the maximal abelian extension ramifed only at primes dividing the conductor with the automorphism group isomorphic to the Picard group.

Example


julia> Qx, x = PolynomialRing(FlintQQ, "x");

julia> K, a = NumberField(x^2 - 10, "a");

julia> c, mc = class_group(K)
(GrpAb: Z/2, ClassGroup map of Set of ideals of Maximal order of Number field over Rational Field with defining polynomial x^2-10
with basis nf_elem[1, a]

)

julia> A = ray_class_field(mc)
Class field defined mod (<1, 1>, InfPlc[]) of structure Abelian group with 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 {{{setverboselevel(:ClassField, n)}}} where $0\le n\le 3$

Hecke.number_field — Method.
NumberField(f::Generic.Poly{T}, s::String; cached::Bool = false, check::Bool = false) where T

Given an irreducible polynomial $f$ over some number field $K$, create the field $K[t]/f$. $f$ must be irreducible - although this is not tested.

NumberField(f::Generic.Poly{T}; cached::Bool = false, check::Bool = false) where T

Given an irreducible polynomial $f$ over some number field $K$, create the field $K[t]/f$. $f$ must be irreducible - although this is not tested.

number_field(f::Array{Generic.Poly{T}, 1}, s::String="_\$") where T -> NfRel_ns

Given polynomials $f = (f_1, \ldots, f_n)$ over some number field $k$, construct $K = k[t_1, \ldots, t_n]/\langle f_1(t_1), \ldots, f_n(t_n)\rangle$ The ideal in the quotient must be maximal - although this is not tested.

NumberField(CF::ClassField) -> Hecke.NfRel_ns{Nemo.nf_elem}

Given a (formal) abelian extension, compute the class field by finding defining polynomials for all prime power cyclic subfields. Note, by type this is always a non-simple extension.


julia> Qx, x = PolynomialRing(FlintQQ, "x");

julia> k, a = NumberField(x^2 - 10, "a");

julia> c, mc = class_group(k);

julia> A = ray_class_field(mc)
Class field defined mod (<1, 1>, InfPlc[]) of structure Abelian group with structure: Z/2

julia> K = number_field(A)
non-simple Relative number field over
Number field over Rational Field with defining polynomial x^2-10
 with defining polynomials AbstractAlgebra.Generic.MPoly{nf_elem}[_$1^2+(-2)]

julia> ZK = maximal_order(K)
Relative maximal order of non-simple Relative number field over
Number field over Rational Field with defining polynomial x^2-10
 with defining polynomials AbstractAlgebra.Generic.MPoly{nf_elem}[_$1^2+(-2)]
with pseudo-basis
(1, 1//1 * <1, 3>)
(_$1+(a), 1//4 * <2, a+2>)

julia> isone(discriminant(ZK))
true
Hecke.ray_class_field — Method.
ray_class_field(K::NfRel{nf_elem}) -> ClassField

For a (relative) abelian extension, compute an abstract representation as a class field.

Hecke.genus_field — Method.
genus_field(A::ClassField, k::AnticNumberField) -> ClassField

The maximal extension contained in $A$ that is the compositum of $K$ with an abelian extension of $k$.

Hecke.maximal_abelian_subfield — Method.
maximal_abelian_subfield(A::ClassField, k::AnticNumberField) -> ClassField

The maximal abelian extension of $k$ contained in $A$. $k$ must be a subfield of the base field of $A$.

Hecke.maximal_abelian_subfield — Method.
maximal_abelian_subfield(K::NfRel{nf_elem}; of_closure::Bool = false) -> ClassField

Using a probabilistic algorithm for the norm group computation, determine tha maximal abelian subfield in $K$ over its base field. If {{{of_closure}}} is set to true, then the algorithm is applied to the normal closure if $K$ (without computing it).

Invariants

AbstractAlgebra.Generic.degree — Method.

degree(A::ClassField)

The degree of $A$ over its base field, ie. the size of the defining ideal group.

AbstractAlgebra.Generic.base_ring — Method.

base_ring(A::ClassField)

The maximal order of the field that $A$ is defined over.

Hecke.base_field — Method.

base_field(A::ClassField)

The number field that $A$ is defined over.

AbstractAlgebra.Generic.discriminant — Method.
discriminant(C::ClassField) -> NfOrdIdl

Using the conductor-discriminant formula, compute the (relative) discriminant of $C$. This does not use the defining equations.

Hecke.conductor — Method.

conductor(C::Hecke.ClassField) -> NfOrdIdl, Array{InfPlc,1}

Return the conductor of the abelian extension corresponding to C

Hecke.defining_modulus — Method.
defining_modulus(CF::ClassField)

The modulus, ie. an ideal the the set of real places, used to create the class field.

Hecke.iscyclic — Method.
iscyclic(C::ClassField)

Tests if the (relative) automorphism group of $C$ is cyclic (by checking the defining ideal group).

Hecke.isconductor — Method.

isconductor(C::Hecke.ClassField, m::NfOrdIdl, inf_plc::Array{InfPlc,1}=InfPlc[]; check) -> NfOrdIdl, Array{InfPlc,1}

Checks if m, inf_plc is the conductor of the abelian extension corresponding to C. If check is false, it assumes that the given modulus is a multiple of the conductor. This is generically faster than computing the conductor.

Hecke.isnormal — Method.
isnormal(C::ClassField) -> Bool

For a class field $C$ defined over a normal base field $k$, decide if $C$ is normal over $Q$.

Hecke.iscentral — Method.
iscentral(C::ClassField) -> Bool

For a class field $C$ defined over a normal base field $k$, decide if $C$ is central over $Q$.

Operations

Base.:* — Method.

*(A::ClassField, B::ClassField) -> ClassField

The compositum of $a$ and $b$ as a (formal) class field.

Hecke.compositum — Method.
compositum(a::ClassField, b::ClassField) -> ClassField
         *(a::ClassField, b::ClassField) -> ClassField

The compositum of $a$ and $b$ as a (formal) class field.

Base.:== — Method.
==(a::ClassField, b::ClassField)

Tests if $a$ and $b$ are equal.

Base.intersect — Method.
intersect(a::ClassField, b::ClassField) -> ClassField

The intersect of $a$ and $b$ as a class field.

Hecke.prime_decomposition_type — Method.
prime_decomposition_type(C::ClassField, p::NfAbsOrdIdl) -> (Int, Int, Int)

For a prime $p$ in the base ring of $r$, determine the splitting type of $p$ in $r$. ie. the tuple $(e, f, g)$ giving the ramification degree, the inertia and the number of primes above $p$.

Hecke.issubfield — Method.
issubfield(a::ClassField, b::ClassField) -> Bool

Determines of $a$ is a subfield of $b$.

Hecke.islocal_norm — Method.
islocal_norm(r::ClassField, a::NfAbsOrdElem) -> Bool

Tests if $a$ is a local norm at all finite places in the extension implictly given by $r$.

Hecke.islocal_norm — Method.
islocal_norm(r::ClassField, a::NfAbsOrdElem, p::NfAbsOrdIdl) -> Bool

Tests if $a$ is a local norm at $p$ in the extension implictly given by $r$. Currently the conductor cannot have infinite places.

Hecke.normal_closure — Method.
normal_closure(C::ClassField) -> ClassField

For a ray class field $C$ extending a normal base field $k$, compute the normal closure over $Q$.

Hecke.subfields — Method.
subfields(C::ClassField) -> Array{ClassField, 1}

Find all subfields of $C$ as class fields. Note: this will not find all subfields over $Q$, but only the ones sharing the same base field.

Hecke.subfields — Method.
subfields(C::ClassField, d::Int) -> Array{ClassField, 1}

Find all subfields of $C$ of degree $d$ as class fields. Note: this will not find all subfields over $Q$, but only the ones sharing the same base field.