Number field operations
Creation of number fields
General number fields can be created using the function NumberField
, of which number_field
is an alias. To create a simple number field given by a defining polynomial or a non-simple number field given by defining polynomials, the following functions can be used.
NumberField
— MethodNumberField(f::Poly{NumFieldElem}, s::String;
cached::Bool = false, check::Bool = false) -> NumField, NumFieldElem
Given an irreducible polynomial $f \in K[x]$ over some number field $K$, this function creates the simple number field $L = K[x]/(f)$ and returns $(L, b)$, where $b$ is the class of $x$ in $L$. The string s
is used only for printing the primitive element $b$.
check
: Controls whether irreducibility of $f$ is checked.cached
: Controls whether the result is cached.
Examples
julia> K, a = quadratic_field(5);
julia> Kt, t = K["t"];
julia> L, b = NumberField(t^3 - 3, "b");
NumberField
— MethodNumberField(f::Vector{PolyElem{<:NumFieldElem}}, s::String="_\$", check = true)
-> NumField, Vector{NumFieldElem}
Given a list $f_1, \ldots, f_n$ of univariate polynomials in $K[x]$ over some number field $K$, constructs the extension $K[x_1, \ldots, x_n]/(f_1(x_1), \ldots, f_n(x_n))$.
Examples
julia> Qx, x = QQ["x"];
julia> K, a = NumberField([x^2 - 2, x^2 - 3], "a")
(Non-simple number field with defining polynomials fmpq_mpoly[x1^2 - 2, x2^2 - 3], NfAbsNSElem[a1, a2])
Many of the constructors have arguments of type Symbol
or AbstractString
. If used, they define the appearance in printing, and printing only. The named parameter check
can be true
or false
, the default being true
. This parameter controls whether the polynomials defining the number field are tested for irreducibility or not. Given that this can be potentially very time consuming if the degree if large, one can disable this test. Note however, that the behaviour of Hecke is undefined if a reducible polynomial is used to define a field.
The named boolean parameter cached
can be used to disable caching. Two number fields defined using the same polynomial from the identical polynomial ring and the same (identical) symbol/string will be identical if cached == true
and different if cached == false
.
For frequently used number fields like quadratic fields, cyclotomic fields or radical extensions, the following functions are provided:
cyclotomic_field
— Methodcyclotomic_field(n::Int) -> AnticNumberField, nf_elem
The cyclotomic field defined by the $n$-th cyclotomic polynomial.
Examples
julia> cyclotomic_field(10)
(Cyclotomic field of order 10, z_10)
quadratic_field
— Methodquadratic_field(d::IntegerUnion) -> AnticNumberField, nf_elem
Returns the field with defining polynomial $x^2 - d$.
Examples
julia> quadratic_field(5)
(Real quadratic field defined by x^2 - 5, sqrt(5))
wildanger_field
— Methodwildanger_field(n::Int, B::fmpz) -> AnticNumberField, nf_elem
Returns the field with defining polynomial $x^n + \sum_{i=0}^{n-1} (-1)^{n-i}Bx^i$. These fields tend to have non-trivial class groups.
Examples
julia> wildanger_field(3, ZZ(10), "a")
(Number field over Rational Field with defining polynomial x^3 - 10*x^2 + 10*x - 10, a)
radical_extension
— Methodradical_extension(n::Int, a::NumFieldElem, s = "_$";
check = true, cached = true) -> NumField, NumFieldElem
Given an element $a$ of a number field $K$ and an integer $n$, create the simple extension of $K$ with the defining polynomial $x^n - a$.
Examples
julia> radical_extension(5, QQ(2), "a")
(Number field over Rational Field with defining polynomial x^5 - 2, a)
rationals_as_number_field
— Methodrationals_as_number_field() -> AnticNumberField, nf_elem
Returns the rational numbers as the number field defined by $x - 1$.
Examples
julia> rationals_as_number_field()
(Number field over Rational Field with defining polynomial x - 1, 1)
Basic properties
basis
— Methodbasis(L::SimpleNumField) -> Vector{NumFieldElem}
Return the canonical basis of a simple extension $L/K$, that is, the elements $1,a,\dotsc,a^{d - 1}$, where $d$ is the degree of $K$ and $a$ the primitive element.
Examples
julia> Qx, x = QQ["x"];
julia> K, a = NumberField(x^2 - 2, "a");
julia> basis(K)
2-element Vector{nf_elem}:
1
a
basis
— Methodbasis(L::NonSimpleNumField) -> Vector{NumFieldElem}
Returns the canonical basis of a non-simple extension $L/K$. If $L = K(a_1,\dotsc,a_n)$ where each $a_i$ has degree $d_i$, then the basis will be $a_1^{i_1}\dotsm a_d^{i_d}$ with $0 \leq i_j \leq d_j - 1$ for $1 \leq j \leq n$.
Examples
julia> Qx, x = QQ["x"];
julia> K, (a1, a2) = NumberField([x^2 - 2, x^2 - 3], "a");
julia> basis(K)
4-element Vector{NfAbsNSElem}:
1
a1
a2
a1*a2
absolute_basis
— Methodabsolute_basis(K::NumField) -> Vector{NumFieldElem}
Returns an array of elements that form a basis of $K$ (as a vector space) over the rationals.
defining_polynomial
— Methoddefining_polynomial(L::SimpleNumField) -> PolyElem
Given a simple number field $L/K$, constructed as $L = K[x]/(f)$, this function returns $f$.
defining_polynomials
— Methoddefining_polynomials(L::NonSimpleNumField) -> Vector{PolyElem}
Given a non-simple number field $L/K$, constructed as $L = K[x]/(f_1,\dotsc,f_r)$, return the vector containing the $f_i$'s.
absolute_primitive_element
— Methodabsolute_primitive_element(K::NumField) -> NumFieldElem
Given a number field $K$, this function returns an element $\gamma \in K$ such that $K = \mathbf{Q}(\gamma)$.
component
— Methodcomponent(L::NonSimpleNumField, i::Int) -> SimpleNumField, Map
Given a non-simple extension $L/K$, this function returns the simple number field corresponding to the $i$-th component of $L$ together with its embedding.
base_field
— Methodbase_field(L::NumField) -> NumField
Given a number field $L/K$ this function returns the base field $K$. For absolute extensions this returns $\mathbf{Q}$.
Invariants
degree
— Methoddegree(L::NumField) -> Int
Given a number field $L/K$, this function returns the degree of $L$ over $K$.
Examples
julia> Qx, x = QQ["x"];
julia> K, a = NumberField(x^2 - 2, "a");
julia> degree(K)
2
absolute_degree
— Methodabsolute_degree(L::NumField) -> Int
Given a number field $L/K$, this function returns the degree of $L$ over $\mathbf Q$.
signature
— Methodsignature(K::NumField)
Return the signature of the number field of $K$.
Examples
julia> Qx, x = QQ["x"];
julia> K, a = NumberField(x^2 - 2, "a");
julia> signature(K)
(2, 0)
unit_group_rank
— Methodunit_group_rank(K::NumField) -> Int
Return the rank of the unit group of any order of $K$.
class_number
— Methodclass_number(K::AnticNumberField) -> fmpz
Returns the class number of $K$.
relative_class_number
— Methodrelative_class_number(K::AnticNumberField) -> fmpz
Returns the relative class number of $K$. The field must be a CM-field.
regulator
— Methodregulator(K::AnticNumberField)
Computes the regulator of $K$, i.e. the discriminant of the unit lattice for the maximal order of $K$.
discriminant
— Methoddiscriminant(L::SimpleNumField) -> NumFieldElem
The discriminant of the defining polynomial of $L$, not the discriminant of the maximal order of $L$.
absolute_discriminant
— Methodabsolute_discriminant(L::SimpleNumField, QQ) -> fmpq
The absolute discriminant of the defining polynomial of $L$, not the discriminant of the maximal order of $L$. This is the norm of the discriminant times the $d$-th power of the discriminant of the base field, where $d$ is the degree of $L$.
Predicates
is_simple
— Methodis_simple(L::NumField) -> Bool
Given a number field $L/K$ this function returns whether $L$ is simple, that is, whether $L/K$ is defined by a univariate polynomial.
is_absolute
— Methodis_absolute(L::NumField) -> Bool
Returns whether $L$ is an absolute extension, that is, whether the base field of $L$ is $\mathbf{Q}$.
is_totally_real
— Methodis_totally_real(K::NumberField) -> Bool
Returns true if and only if $K$ is totally real, that is, if all roots of the defining polynomial are real.
is_totally_complex
— Methodis_totally_complex(K::AnticNumberField) -> Bool
Returns true if and only if $K$ is totally complex, that is, if all roots of the defining polynomial are not real.
is_cm_field
— Methodis_cm_field(K::AnticNumberField) -> Bool, NfToNfMor
Given a number field $K$, this function returns true and the complex conjugation if the field is CM, false and the identity otherwise.
is_kummer_extension
— Methodis_kummer_extension(L::SimpleNumField) -> Bool
Tests if $L/K$ is a Kummer extension, that is, if the defining polynomial is of the form $x^n - b$ for some $b \in K$ and if $K$ contains the $n$-th roots of unity.
is_radical_extension
— Methodis_radical_extension(L::SimpleNumField) -> Bool
Tests if $L/K$ is pure, that is, if the defining polynomial is of the form $x^n - b$ for some $b \in K$.
is_linearly_disjoint
— Methodis_linearly_disjoint(K::SimpleNumField, L::SimpleNumField) -> Bool
Given two number fields $K$ and $L$ with the same base field $k$, this function returns whether $K$ and $L$ are linear disjoint over $k$.
is_weakly_ramified
— Methodis_weakly_ramified(K::AnticNumberField, P::NfOrdIdl) -> Bool
Given a prime ideal $P$ of a number field $K$, return whether $P$ is weakly ramified, that is, whether the second ramification group is trivial.
is_tamely_ramified
— Methodis_tamely_ramified(K::AnticNumberField) -> Bool
Returns whether the number field $K$ is tamely ramified.
is_tamely_ramified
— Methodis_tamely_ramified(O::NfOrd, p::Union{Int, fmpz}) -> Bool
Returns whether the integer $p$ is tamely ramified in $\mathcal O$. It is assumed that $p$ is prime.
is_abelian
— Methodis_abelian(L::NumField) -> Bool
Check if the number field $L/K$ is abelian over $K$. The function is probabilistic and assumes GRH.
Subfields
is_subfield
— Methodis_subfield(K::SimpleNumField, L::SimpleNumField) -> Bool, Map
Return true
and an injection from $K$ to $L$ if $K$ is a subfield of $L$. Otherwise the function returns false
and a morphism mapping everything to $0$.
subfields
— Methodsubfields(L::SimpleNumField) -> Vector{Tuple{NumField, Map}}
Given a simple extension $L/K$, returns all subfields of $L$ containing $K$ as tuples $(k, \iota)$ consisting of a simple extension $k$ and an embedding $\iota k \to K$.
principal_subfields
— Methodprincipal_subfields(L::SimpleNumField) -> Vector{Tuple{NumField, Map}}
Return the principal subfields of $L$ as pairs consisting of a subfield $k$ and an embedding $k \to L$.
compositum
— Methodcompositum(K::AnticNumberField, L::AnticNumberField) -> AnticNumberField, Map, Map
Assuming $L$ is normal (which is not checked), compute the compositum $C$ of the 2 fields together with the embedding of $K \to C$ and $L \to C$.
embedding
— Methodembedding(k::NumField, K::NumField) -> Map
Assuming $k$ is known to be a subfield of $K$, return the embedding map.
normal_closure
— Methodnormal_closure(K::AnticNumberField) -> AnticNumberField, NfToNfMor
The normal closure of $K$ together with the embedding map.
relative_simple_extension
— Methodrelative_simple_extension(K::NumField, k::NumField) -> NfRel
Given two fields $K\supset k$, it returns $K$ as a simple relative extension $L$ of $k$ and an isomorphism $L \to K$.
is_subfield_normal
— Method is_subfield_normal(K::AnticNumberField, L::AnticNumberField) -> Bool, NfToNfMor
Returns true
and an injection from $K$ to $L$ if $K$ is a subfield of $L$. Otherwise the function returns "false" and a morphism mapping everything to 0.
This function assumes that $K$ is normal.
Conversion
simplify
— Methodsimplify(K::AnticNumberField; canonical::Bool = false) -> AnticNumberField, NfToNfMor
Tries to find an isomorphic field $L$ given by a "simpler" defining polynomial. By default, "simple" is defined to be of smaller index, testing is done only using a LLL-basis of the maximal order.
If canonical
is set to true
, then a canonical defining polynomial is found, where canonical is using the definition of PARI's polredabs
, which is described in http://beta.lmfdb.org/knowledge/show/nf.polredabs.
Both versions require a LLL reduced basis for the maximal order.
absolute_simple_field
— Methodabsolute_simple_field(K::NumField) -> NumField, Map
Given a number field $K$, this function returns an absolute simple number field $M/\mathbf{Q}$ together with a $\mathbf{Q}$-linear isomorphism $M \to K$.
simple_extension
— Methodsimple_extension(L::NonSimpleNumField) -> SimpleNumField, Map
Given a non-simple extension $L/K$, this function computes a simple extension $M/K$ and a $K$-linear isomorphism $M \to L$.
simplified_simple_extension
— Methodsimplified_simple_extension(L::NonSimpleNumField) -> SimpleNumField, Map
Given a non-simple extension $L/K$, this function returns an isomorphic simple number field with a "small" defining equation together with the isomorphism.
Morphisms
is_isomorphic
— Methodis_isomorphic(K::SimpleNumField, L::SimpleNumField) -> Bool
Return true
if $K$ and $L$ are isomorphic, otherwise false
.
is_isomorphic_with_map
— Methodis_isomorphic_with_map(K::SimpleNumField, L::SimpleNumField) -> Bool, Map
Return true
and an isomorphism from $K$ to $L$ if $K$ and $L$ are isomorphic. Otherwise the function returns false
and a morphism mapping everything to $0$.
is_involution
— Methodis_involution(f::NfToNfMor) -> Bool
Returns true if $f$ is an involution, i.e. if $f^2$ is the identity, false otherwise.
fixed_field
— Methodfixed_field(K::SimpleNumField,
sigma::Map;
simplify::Bool = true) -> NumberField, NfToNfMor
Given a number field $K$ and an automorphism $\sigma$ of $K$, this function returns the fixed field of $\sigma$ as a pair $(L, i)$ consisting of a number field $L$ and an embedding of $L$ into $K$.
By default, the function tries to find a small defining polynomial of $L$. This can be disabled by setting simplify = false
.
automorphism_list
— Methodautomorphism_list(L::NumField) -> Vector{NumFieldMor}
Given a number field $L/K$, return a list of all $K$-automorphisms of $L$.
automorphism_group
— Methodautomorphism_group(K::NumField) -> GenGrp, GrpGenToNfMorSet
Given a number field $K$, this function returns a group $G$ and a map from $G$ to the automorphisms of $K$.
complex_conjugation
— Methodcomplex_conjugation(K::AnticNumberField)
Given a totally complex normal number field, this function returns an automorphism which is the restriction of complex conjugation at one embedding.
Galois theory
normal_basis
— Methodnormal_basis(L::NumField) -> NumFieldElem
Given a normal number field $L/K$, this function returns an element $a$ of $L$, such that the orbit of $a$ under the Galois group of $L/K$ is an $K$-basis of $L$.
decomposition_group
— Methoddecomposition_group(K::AnticNumberField, P::NfOrdIdl, m::Map)
-> Grp, GrpToGrp
Given a prime ideal $P$ of a number field $K$ and a map m
return from automorphism_group(K)
, return the decompositon group of $P$ as a subgroup of the domain of m
.
ramification_group
— Methodramification_group(K::AnticNumberField, P::NfOrdIdl, m::Map) -> Grp, GrpToGrp
Given a prime ideal $P$ of a number field $K$ and a map m
return from automorphism_group(K)
, return the ramification group of $P$ as a subgroup of the domain of m
.
inertia_subgroup
— Methodinertia_subgroup(K::AnticNumberField, P::NfOrdIdl, m::Map) -> Grp, GrpToGrp
Given a prime ideal $P$ of a number field $K$ and a map m
return from automorphism_group(K)
, return the intertia subgroup of $P$ as a subgroup of the domain of m
.
Infinite places
infinite_places
— Methodinfinite_places(K::NumField) -> Vector{Plc}
This function returns all infinite places of $K$.
Examples
julia> Qx, x = QQ["x"];
julia> K, a = NumberField(x^2 - 2, "a");
julia> infinite_places(K)
2-element Vector{InfPlc}:
Real place of
Number field over Rational Field with defining polynomial x^2 - 2
corresponding to the root [-1.414213562373095049 +/- 3.90e-19]
Real place of
Number field over Rational Field with defining polynomial x^2 - 2
corresponding to the root [1.414213562373095049 +/- 3.90e-19]
real_places
— Methodreal_places(K::AnticNumberField) -> Vector{InfPlc}
This function returns all infinite real places of $K$.
complex_places
— Methodcomplex_places(K::AnticNumberField) -> Vector{InfPlc}
This function returns all infinite complex places of $K$.
isreal
— Methodisreal(P::Plc)
Return whether the embedding into $\mathbf{C}$ defined by $P$ is real or not.
is_complex
— Methodis_complex(P::Plc) -> Bool
Return whether the embedding into $\mathbf{C}$ defined by $P$ is complex or not.
infinite_places_uniformizers
— Methodinfinite_places_uniformizers(K::AnticNumberField)
Returns a dictionary having as keys the real places of $K$ and the values are uniformizers for the corresponding real place. A uniformizer of a real place $P$ is an element of the field which is negative at $P$ and positive at all the other real places.
Miscellaneous
norm_equation
— Methodnorm_equation(K::AnticNumerField, a) -> nf_elem
For $a$ an integer or rational, try to find $T \in K$ s.th. $N(T) = a$. Raises an error if unsuccessful.
lorenz_module
— Methodlorenz_module(k::AnticNumberField, n::Int) -> NfOrdIdl
Finds an ideal $A$ s.th. for all positive units $e = 1 \bmod A$ we have that $e$ is an $n$-th power. Uses Lorenz, number theory, 9.3.1. If containing
is set, it has to be an integral ideal. The resulting ideal will be a multiple of this.
kummer_failure
— Methodkummer_failure(x::nf_elem, M::Int, N::Int) -> Int
Computes the quotient of $N$ and $[K(\zeta_M, \sqrt[N](x))\colon K(\zeta_M)]$, where $K$ is the field containing $x$ and $N$ divides $M$.
is_defining_polynomial_nice
— Methodis_defining_polynomial_nice(K::AnticNumberField)
Tests if the defining polynomial of $K$ is integral and monic.