Number field operations

Creation of number fields

General number fields can be created using the function number_field. 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.

# number_field — Method.

number_field(f::Poly{NumFieldElem}, s::VarName;
            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 = number_field(t^3 - 3, "b");

source

# number_field — Method.

number_field(f::Vector{PolyRingElem{<:NumFieldElem}}, s::VarName="_\$", check = true)
                                          -> NumField, Vector{NumFieldElem}

Given a list $f_1,\dots ,f_n$ of univariate polynomials in $K[x]$ over some number field $K$, constructs the extension $K[x_1,\dots ,x_n]/(f_1(x_1),\dots ,f_n(x_n))$.

Examples

julia> Qx, x = QQ["x"];

julia> K, a = number_field([x^2 - 2, x^2 - 3], "a")
(Non-simple number field of degree 4 over QQ, AbsNonSimpleNumFieldElem[a1, a2])

source

Tip

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 — Method.

cyclotomic_field(n::Int, s::VarName = "z_$n", t = "_\$"; cached::Bool = true)

Return a tuple $R,x$ consisting of the parent object $R$ and generator $x$ of the $n$-th cyclotomic field, $\mathbb{Q}({\zeta }_n)$. The supplied string s specifies how the generator of the number field should be printed. If provided, the string t specifies how the generator of the polynomial ring from which the number field is constructed, should be printed. If it is not supplied, a default dollar sign will be used to represent the variable.

source

# quadratic_field — Method.

quadratic_field(d::IntegerUnion) -> AbsSimpleNumField, AbsSimpleNumFieldElem

Returns the field with defining polynomial $x^2-d$.

Examples

julia> quadratic_field(5)
(Real quadratic field defined by x^2 - 5, sqrt(5))

source

# wildanger_field — Method.

wildanger_field(n::Int, B::ZZRingElem) -> AbsSimpleNumField, AbsSimpleNumFieldElem

Returns the field with defining polynomial $x^n+\sum _{i=0}^{n-1}(-1{)}^{n-i}B{x}^i$. These fields tend to have non-trivial class groups.

Examples

julia> wildanger_field(3, ZZ(10), "a")
(Number field of degree 3 over QQ, a)

source

# radical_extension — Method.

radical_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 of degree 5 over QQ, a)

source

# rationals_as_number_field — Method.

rationals_as_number_field() -> AbsSimpleNumField, AbsSimpleNumFieldElem

Returns the rational numbers as the number field defined by $x-1$.

Examples

julia> rationals_as_number_field()
(Number field of degree 1 over QQ, 1)

source

Basic properties

# basis — Method.

basis(L::SimpleNumField) -> Vector{NumFieldElem}

Return the canonical basis of a simple extension $L/K$, that is, the elements $1,a,\dots ,a^{d-1}$, where $d$ is the degree of $K$ and $a$ the primitive element.

Examples

julia> Qx, x = QQ["x"];

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

julia> basis(K)
2-element Vector{AbsSimpleNumFieldElem}:
 1
 a

source

# basis — Method.

basis(L::NonSimpleNumField) -> Vector{NumFieldElem}

Returns the canonical basis of a non-simple extension $L/K$. If $L=K(a_1,\dots ,a_n)$ where each $a_i$ has degree $d_i$, then the basis will be $a_1^{i_1}\cdots a_d^{i_d}$ with $0\le i_j\le d_j-1$ for $1\le j\le n$.

Examples

julia> Qx, x = QQ["x"];

julia> K, (a1, a2) = number_field([x^2 - 2, x^2 - 3], "a");

julia> basis(K)
4-element Vector{AbsNonSimpleNumFieldElem}:
 1
 a1
 a2
 a1*a2

source

# absolute_basis — Method.

absolute_basis(K::NumField) -> Vector{NumFieldElem}

Returns an array of elements that form a basis of $K$ (as a vector space) over the rationals.

source

# defining_polynomial — Method.

defining_polynomial(L::SimpleNumField) -> PolyRingElem

Given a simple number field $L/K$, constructed as $L=K[x]/(f)$, this function returns $f$.

source

# defining_polynomials — Method.

defining_polynomials(L::NonSimpleNumField) -> Vector{PolyRingElem}

Given a non-simple number field $L/K$, constructed as $L=K[x]/(f_1,\dots ,f_r)$, return the vector containing the $f_i$'s.

source

# absolute_primitive_element — Method.

absolute_primitive_element(K::NumField) -> NumFieldElem

Given a number field $K$, this function returns an element $\gamma \in K$ such that $K=\mathbf{Q}(\gamma )$.

source

# component — Method.

component(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.

source

# base_field — Method.

base_field(L::NumField) -> NumField

Given a number field $L/K$ this function returns the base field $K$. For absolute extensions this returns $\mathbf{Q}$.

source

Invariants

# degree — Method.

degree(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 = number_field(x^2 - 2, "a");

julia> degree(K)
2

source

# absolute_degree — Method.

absolute_degree(L::NumField) -> Int

Given a number field $L/K$, this function returns the degree of $L$ over $\mathbf{Q}$.

source

# signature — Method.

signature(K::NumField)

Return the signature of the number field of $K$.

Examples

julia> Qx, x = QQ["x"];

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

julia> signature(K)
(2, 0)

source

# unit_group_rank — Method.

unit_group_rank(K::NumField) -> Int

Return the rank of the unit group of any order of $K$.

source

# class_number — Method.

class_number(K::AbsSimpleNumField) -> ZZRingElem

Returns the class number of $K$.

source

# relative_class_number — Method.

relative_class_number(K::AbsSimpleNumField) -> ZZRingElem

Returns the relative class number of $K$. The field must be a CM-field.

source

# regulator — Method.

regulator(K::AbsSimpleNumField)

Computes the regulator of $K$, i.e. the discriminant of the unit lattice for the maximal order of $K$.

source

# discriminant — Method.

discriminant(L::SimpleNumField) -> NumFieldElem

The discriminant of the defining polynomial of $L$, not the discriminant of the maximal order of $L$.

source

# absolute_discriminant — Method.

absolute_discriminant(L::SimpleNumField, QQ) -> QQFieldElem

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$.

source

Predicates

# is_simple — Method.

is_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.

source

# is_absolute — Method.

is_absolute(L::NumField) -> Bool

Returns whether $L$ is an absolute extension, that is, whether the base field of $L$ is $\mathbf{Q}$.

source

# is_totally_real — Method.

is_totally_real(K::NumField) -> Bool

Return true if and only if $K$ is totally real, that is, if all roots of the defining polynomial are real.

source

# is_totally_complex — Method.

is_totally_complex(K::NumField) -> Bool

Return true if and only if $K$ is totally complex, that is, if all roots of the defining polynomial are not real.

source

# is_cm_field — Method.

is_cm_field(K::AbsSimpleNumField) -> Bool, NumFieldHom{AbsSimpleNumField, AbsSimpleNumField}

Given a number field $K$, this function returns true and the complex conjugation if the field is CM, false and the identity otherwise.

source

# is_kummer_extension — Method.

is_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.

source

# is_radical_extension — Method.

is_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$.

source

# is_linearly_disjoint — Method.

is_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$.

source

# is_weakly_ramified — Method.

is_weakly_ramified(K::AbsSimpleNumField, P::AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}) -> 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.

source

# is_tamely_ramified — Method.

is_tamely_ramified(K::AbsSimpleNumField) -> Bool

Returns whether the number field $K$ is tamely ramified.

source

# is_tamely_ramified — Method.

is_tamely_ramified(O::AbsSimpleNumFieldOrder, p::Union{Int, ZZRingElem}) -> Bool

Returns whether the integer $p$ is tamely ramified in $\mathcal{O}$. It is assumed that $p$ is prime.

source

# is_abelian — Method.

is_abelian(L::NumField) -> Bool

Check if the number field $L/K$ is abelian over $K$. The function is probabilistic and assumes GRH.

source

Subfields

# is_subfield — Method.

is_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$.

source

# subfields — Method.

subfields(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$.

source

# principal_subfields — Method.

principal_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$.

source

# compositum — Method.

compositum(K::AbsSimpleNumField, L::AbsSimpleNumField) -> AbsSimpleNumField, 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$.

source

# embedding — Method.

embedding(k::NumField, K::NumField) -> Map

Assuming $k$ is known to be a subfield of $K$, return the embedding map.

source

# normal_closure — Method.

normal_closure(K::AbsSimpleNumField) -> AbsSimpleNumField, NumFieldHom{AbsSimpleNumField, AbsSimpleNumField}

The normal closure of $K$ together with the embedding map.

source

# relative_simple_extension — Method.

relative_simple_extension(K::NumField, k::NumField) -> RelSimpleNumField

Given two fields $K\supset k$, it returns $K$ as a simple relative extension $L$ of $k$ and an isomorphism $L\to K$.

source

# is_subfield_normal — Method.

  is_subfield_normal(K::AbsSimpleNumField, L::AbsSimpleNumField) -> Bool, NumFieldHom{AbsSimpleNumField, AbsSimpleNumField}

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.

source

Conversion

# simplify — Method.

simplify(K::AbsSimpleNumField; canonical::Bool = false) -> AbsSimpleNumField, NumFieldHom{AbsSimpleNumField, AbsSimpleNumField}

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.

source

# absolute_simple_field — Method.

absolute_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$.

source

# simple_extension — Method.

simple_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$.

source

# simplified_simple_extension — Method.

simplified_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.

source

Morphisms

# is_isomorphic — Method.

is_isomorphic(K::SimpleNumField, L::SimpleNumField) -> Bool

Return true if $K$ and $L$ are isomorphic, otherwise false.

source

# is_isomorphic_with_map — Method.

is_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$.

source

# is_involution — Method.

is_involution(f::NumFieldHom{AbsSimpleNumField, AbsSimpleNumField}) -> Bool

Returns true if $f$ is an involution, i.e. if $f^2$ is the identity, false otherwise.

source

# fixed_field — Method.

fixed_field(K::SimpleNumField,
            sigma::Map;
            simplify::Bool = true) -> number_field, NumFieldHom{AbsSimpleNumField, AbsSimpleNumField}

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.

source

# automorphism_list — Method.

automorphism_list(L::NumField) -> Vector{NumFieldHom}

Given a number field $L/K$, return a list of all $K$-automorphisms of $L$.

source

# automorphism_group — Method.

automorphism_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$.

source

# complex_conjugation — Method.

complex_conjugation(K::AbsSimpleNumField)

Given a totally complex normal number field, this function returns an automorphism which is the restriction of complex conjugation at one embedding.

source

Galois theory

# normal_basis — Method.

normal_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$.

source

# decomposition_group — Method.

decomposition_group(K::AbsSimpleNumField, P::AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}, 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 decomposition group of $P$ as a subgroup of the domain of m.

source

# ramification_group — Method.

ramification_group(K::AbsSimpleNumField, P::AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}, 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.

source

# inertia_subgroup — Method.

inertia_subgroup(K::AbsSimpleNumField, P::AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}, 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 inertia subgroup of $P$ as a subgroup of the domain of m.

source

Infinite places

# infinite_places — Method.

infinite_places(K::NumField) -> Vector{InfPlc}

Return all infinite places of the number field.

Examples

julia> K,  = quadratic_field(5);

julia> infinite_places(K)
2-element Vector{InfPlc{AbsSimpleNumField, AbsSimpleNumFieldEmbedding}}:
 Infinite place corresponding to (Complex embedding corresponding to -2.24 of real quadratic field)
 Infinite place corresponding to (Complex embedding corresponding to 2.24 of real quadratic field)

source

# real_places — Method.

real_places(K::NumField) -> Vector{InfPlc}

Return all infinite real places of the number field.

Examples

julia> K,  = quadratic_field(5);

julia> infinite_places(K)
2-element Vector{InfPlc{AbsSimpleNumField, AbsSimpleNumFieldEmbedding}}:
 Infinite place corresponding to (Complex embedding corresponding to -2.24 of real quadratic field)
 Infinite place corresponding to (Complex embedding corresponding to 2.24 of real quadratic field)

source

# complex_places — Method.

complex_places(K::NumField) -> Vector{InfPlc}

Return all infinite complex places of $K$.

Examples

julia> K,  = quadratic_field(-5);

julia> complex_places(K)
1-element Vector{InfPlc{AbsSimpleNumField, AbsSimpleNumFieldEmbedding}}:
 Infinite place corresponding to (Complex embedding corresponding to 0.00 + 2.24 * i of imaginary quadratic field)

source

# isreal — Method.

isreal(P::Plc)

Return whether the embedding into $\mathbf{C}$ defined by $P$ is real or not.

source

# is_complex — Method.

is_complex(P::Plc) -> Bool

Return whether the embedding into $\mathbf{C}$ defined by $P$ is complex or not.

source

Miscellaneous

# norm_equation — Method.

norm_equation(K::AnticNumerField, a) -> AbsSimpleNumFieldElem

For $a$ an integer or rational, try to find $T\in K$ s.th. $N(T)=a$. Raises an error if unsuccessful.

source

# lorenz_module — Method.

lorenz_module(k::AbsSimpleNumField, n::Int) -> AbsNumFieldOrderIdeal{AbsSimpleNumField, AbsSimpleNumFieldElem}

Finds an ideal $A$ s.th. for all positive units $e=1modA$ 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.

source

# kummer_failure — Method.

kummer_failure(x::AbsSimpleNumFieldElem, M::Int, N::Int) -> Int

Computes the quotient of $N$ and $[K({\zeta }_M,\sqrt[N]{(}x)):K({\zeta }_M)]$, where $K$ is the field containing $x$ and $N$ divides $M$.

source

# is_defining_polynomial_nice — Method.

is_defining_polynomial_nice(K::AbsSimpleNumField)

Tests if the defining polynomial of $K$ is integral and monic.

source