Number field operations

NumberField(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(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])

cyclotomic_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(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(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(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() -> 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)

basis(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(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(K::NumField) -> Vector{NumFieldElem}

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

defining_polynomial(L::SimpleNumField) -> PolyElem

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

defining_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(K::NumField) -> NumFieldElem

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

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.

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

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

julia> degree(K)
2

absolute_degree(L::NumField) -> Int

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

signature(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(K::NumField) -> Int

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

class_number(K::AnticNumberField) -> fmpz

Returns the class number of $K$.

relative_class_number(K::AnticNumberField) -> fmpz

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

regulator(K::AnticNumberField)

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

discriminant(L::SimpleNumField) -> NumFieldElem

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

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

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.

is_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(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(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(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(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(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(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(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(K::AnticNumberField) -> Bool

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

is_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(L::NumField) -> Bool

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

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

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

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

compositum(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(k::NumField, K::NumField) -> Map

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

normal_closure(K::AnticNumberField) -> AnticNumberField, NfToNfMor

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

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

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

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

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

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

is_involution(f::NfToNfMor) -> Bool

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

fixed_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(L::NumField) -> Vector{NumFieldMor}

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

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

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

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

decomposition_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(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(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(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(K::AnticNumberField) -> Vector{InfPlc}

This function returns all infinite real places of $K$.

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

This function returns all infinite complex places of $K$.

isreal(P::Plc)

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

is_complex(P::Plc) -> Bool

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

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

norm_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(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(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(K::AnticNumberField)

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