Ideals

(Integral) ideals in orders are always free $Z$-module of the same rank as the order, hence have a representation via a $Z$-basis. This can be made unique by normalising the corresponding matrix to be in reduced row echelon form (HNF).

For ideals in maximal orders $Z_K$, we also have a second presentation coming from the $Z_K$ module structure and the fact that $Z_K$ is a Dedekind ring: ideals can be generated by 2 elements, one of which can be any non-zero element in the ideal.

For efficiency, we will choose the 1st generator to be an integer.

Ideals here are of type NfAbsOrdIdl, which is, similar to the elements above, also indexed by the type of the field and their elements: NfAbsOrdIdl{AnticNumberField,nf_elem} for ideals in simple absolute fields.

Different to elements, the parentof an ideal is the set of all ideals in the ring, of type NfAbsOrdIdlSet.

Creation

ideal — Method

ideal(O::NfOrd, a::ZZRingElem) -> NfAbsOrdIdl
ideal(O::NfOrd, a::Integer) -> NfAbsOrdIdl

Returns the ideal of $\mathcal O$ which is generated by $a$.

ideal — Method

ideal(O::NfOrd, x::ZZMatrix, check::Bool = false, x_in_hnf::Bool = false) -> NfAbsOrdIdl

Creates the ideal of $\mathcal O$ with basis matrix $x$. If check is set, then it is checked whether $x$ defines an ideal (expensive). If x_in_hnf is set, then it is assumed that $x$ is already in lower left HNF.

ideal — Method

ideal(O::NfOrd, x::NfOrdElem) -> NfAbsOrdIdl

Creates the principal ideal $(x)$ of $\mathcal O$.

ideal — Method

ideal(O::NfOrd, x::ZZRingElem, y::NfOrdElem) -> NfAbsOrdIdl
ideal(O::NfOrd, x::Integer, y::NfOrdElem) -> NfAbsOrdIdl

Creates the ideal $(x, y)$ of $\mathcal O$.

ideal — Method

ideal(O::NfOrd, x::ZZRingElem, y::NfOrdElem) -> NfAbsOrdIdl
ideal(O::NfOrd, x::Integer, y::NfOrdElem) -> NfAbsOrdIdl

Creates the ideal $(x, y)$ of $\mathcal O$.

ideal — Method

ideal(O::NfOrd, a::ZZRingElem) -> NfAbsOrdIdl
ideal(O::NfOrd, a::Integer) -> NfAbsOrdIdl

Returns the ideal of $\mathcal O$ which is generated by $a$.

ideal — Method

ideal(O::NfOrd, x::NfOrdElem) -> NfAbsOrdIdl

Creates the principal ideal $(x)$ of $\mathcal O$.

* — Method

*(O::NfOrd, x::NfOrdElem) -> NfAbsOrdIdl
*(x::NfAbsOrdElem, O::NfAbsOrd) -> NfAbsOrdIdl

Returns the principal ideal $(x)$ of $\mathcal O$.

factor — Method

factor(A::NfOrdIdl) -> Dict{NfOrdIdl, Int}

Computes the prime ideal factorization $A$ as a dictionary, the keys being the prime ideal divisors: If lp = factor_dict(A), then keys(lp) are the prime ideal divisors of $A$ and lp[P] is the $P$-adic valuation of $A$ for all $P$ in keys(lp).

factor — Method

factor(a::nf_elem, I::NfOrdIdlSet) -> Dict{NfOrdIdl, ZZRingElem}

Factors the principal ideal generated by $a$.

coprime_base — Method

coprime_base(A::Vector{NfOrdIdl}) -> Vector{NfOrdIdl}
coprime_base(A::Vector{NfOrdElem}) -> Vector{NfOrdIdl}

A coprime base for the (principal) ideals in $A$, i.e. the returned array generated multiplicatively the same ideals as the input and are pairwise coprime.

Arithmetic

All the usual operations are supported:

==, +, *
divexact, divides
lcm, gcd
in

intersect — Method

intersect(x::NfOrdIdl, y::NfOrdIdl) -> NfOrdIdl

Returns $x \cap y$.

colon — Method

colon(a::NfAbsOrdIdl, b::NfAbsOrdIdl) -> NfOrdFracIdl

The ideal $(a:b) = \{x \in K | xb \subseteq a\} = \hom(b, a)$ where $K$ is the number field.

in — Method

in(x::NumFieldOrdElem, y::NumFieldOrdIdl)
in(x::NumFieldElem, y::NumFieldOrdIdl)
in(x::ZZRingElem, y::NumFieldOrdIdl)

Returns whether $x$ is contained in $y$.

is_power — Method

is_power(A::NfAbsOrdIdl, n::Int) -> Bool, NfAbsOrdIdl
is_power(A::NfOrdFracIdl, n::Int) -> Bool, NfOrdFracIdl

Computes, if possible, an ideal $B$ s.th. $B^n==A$ holds. In this case, true and $B$ are returned.

is_power — Method

is_power(I::NfAbsOrdIdl) -> Int, NfAbsOrdIdl
is_power(a::NfOrdFracIdl) -> Int, NfOrdFracIdl

Writes $a = r^e$ with $e$ maximal. Note: $1 = 1^0$.

is_invertible — Method

is_invertible(A::NfAbsOrdIdl) -> Bool, NfOrdFracIdl

Returns true and an inverse of $A$ or false and an ideal $B$ such that $A*B \subsetneq order(A)$, if $A$ is not invertible.

isone — Method

isone(A::NfAbsOrdIdl) -> Bool
is_unit(A::NfAbsOrdIdl) -> Bool

Tests if $A$ is the trivial ideal generated by $1$.

Class Group

The group of invertable ideals in any order forms a group and the principal ideals a subgroup. The finite quotient is called class group for maximal orders and Picard group or ring class group in general.

class_group — Method

class_group(O::NfOrd; bound = -1, method = 3, redo = false, large = 1000) -> GrpAbFinGen, Map

Returns a group $A$ and a map $f$ from $A$ to the set of ideals of $O$. The inverse of the map is the projection onto the group of ideals modulo the group of principal ideals. redo allows to trigger a re-computation, thus avoiding the cache. bound, when given, is the bound for the factor base.

narrow_class_group — Method

narrow_class_group(O::NfOrd) -> GrpAbFinGen, Map

Computes the narrow (or strict) class group of $O$, ie. the group of invertable ideals modulo principal ideals generated by elements that are positive at all real places.

picard_group — Method

picard_group(O::NfOrd) -> GrpAbFinGen, MapClassGrp

Returns the Picard group of $O$ and a map from the group in the set of (invertible) ideals of $O$.

ring_class_group — Method

ring_class_group(O::NfAbsOrd)

The ring class group (Picard group) of $O$.


julia> k, a = wildanger_field(3, 13);
julia> zk = maximal_order(k);
julia> c, mc = class_group(zk)(GrpAb: Z/9, ClassGroup map of
Set of ideals of Maximal order of Number field of degree 3 over QQ
with basis nf_elem[1, _$, 1//2*_$^2 + 1//2]
)
julia> lp = prime_ideals_up_to(zk, 20);
julia> [ mc \ I for I = lp]10-element Vector{GrpAbFinGenElem}:
 Element of
GrpAb: Z/9
with components [1]
 Element of
GrpAb: Z/9
with components [7]
 Element of
GrpAb: Z/9
with components [1]
 Element of
GrpAb: Z/9
with components [8]
 Element of
GrpAb: Z/9
with components [3]
 Element of
GrpAb: Z/9
with components [5]
 Element of
GrpAb: Z/9
with components [4]
 Element of
GrpAb: Z/9
with components [7]
 Element of
GrpAb: Z/9
with components [0]
 Element of
GrpAb: Z/9
with components [5]
julia> mc(c[1])<2, 1//2*_$^2 + 1//2>
Norm: 2
Minimum: 2
two normal wrt: 2
julia> order(c[1])9
julia> mc(c[1])^Int(order(c[1]))<32, 839363119461049//2*_$^2 - 416530152896637*_$ + 908741397904759//2>
Norm: 512
Minimum: 32
two normal wrt: 2
julia> mc \ ansElement of
GrpAb: Z/9
with components [0]

The class group, or more precisely the information used to compute it also allows for principal ideal testing and related tasks. In general, due to the size of the objects, the fac_elem versions are more effcient.

is_principal — Method

is_principal(A::NfOrdIdl) -> Bool, NfOrdElem
is_principal(A::NfOrdFracIdl) -> Bool, NfOrdElem

Tests if $A$ is principal and returns $(\mathtt{true}, \alpha)$ if $A = \langle \alpha\rangle$ or $(\mathtt{false}, 1)$ otherwise.

is_principal_fac_elem — Method

is_principal_fac_elem(A::NfOrdIdl) -> Bool, FacElem{nf_elem, number_field}

Tests if $A$ is principal and returns $(\mathtt{true}, \alpha)$ if $A = \langle \alpha\rangle$ or $(\mathtt{false}, 1)$ otherwise. The generator will be in factored form.

power_class — Method

power_class(A::NfOrdIdl, e::ZZRingElem) -> NfOrdIdl

Computes a (small) ideal in the same class as $A^e$.

power_product_class — Method

power_product_class(A::Vector{NfOrdIdl}, e::Vector{ZZRingElem}) -> NfOrdIdl

Computes a (small) ideal in the same class as $\prod A_i^{e_i}$.

power_reduce — Method

power_reduce(A::NfOrdIdl, e::ZZRingElem) -> NfOrdIdl, FacElem{nf_elem}

Computes $B$ and $\alpha$ in factored form, such that $\alpha B = A^e$ $B$ has small norm.

class_group_ideal_relation — Method

class_group_ideal_relation(I::NfOrdIdl, c::ClassGrpCtx) -> nf_elem, SRow{ZZRingElem}

Finds a number field element $\alpha$ such that $\alpha I$ factors over the factor base in $c$.

factor_base_bound_grh — Method

factor_base_bound_grh(O::NfOrd) -> Int

Returns an integer $B$, such that under GRH the ideal class group of $\mathcal O$ is generated by the prime ideals of norm bounded by $B$.

factor_base_bound_bach — Method

factor_base_bound_bach(O::NfOrd) -> Int

Use the theorem of Bach to find $B$ such that under GRH the ideal class group of $\mathcal O$ is generated by the prime ideals of norm bounded by $B$.

prime_ideals_up_to — Function

prime_ideals_up_to(O::NfOrd,
                   B::Int;
                   degree_limit::Int = 0, index_divisors::Bool = true) -> Vector{NfOrdIdl}

Computes the prime ideals $\mathcal O$ with norm up to $B$.

If degree_limit is a nonzero integer $k$, then prime ideals $\mathfrak p$ with $\deg(\mathfrak p) > k$ will be discarded. If 'index_divisors' is set to false, only primes not dividing the index of the order will be computed.

prime_ideals_up_to(O::NfOrd,
                   B::Int;
                   complete::Bool = false,
                   degree_limit::Int = 0,
                   F::Function,
                   bad::ZZRingElem)

Computes the prime ideals $\mathcal O$ with norm up to $B$.

If degree_limit is a nonzero integer $k$, then prime ideals $\mathfrak p$ with $\deg(\mathfrak p) > k$ will be discarded.

The function $F$ must be a function on prime numbers not dividing bad such that $F(p) = \deg(\mathfrak p)$ for all prime ideals $\mathfrak p$ lying above $p$.

julia> I = mc(c[1])<2, 1//2*_$^2 + 1//2>
Norm: 2
Minimum: 2
two normal wrt: 2
julia> Hecke.is_principal(I)(false, 1)
julia> I = I^Int(order(c[1]))<32, 839363119461049//2*_$^2 - 416530152896637*_$ + 908741397904759//2>
Norm: 512
Minimum: 32
two normal wrt: 2
julia> Hecke.is_principal(I)(true, 1//2*_$^2 - 5*_$ - 17//2)
julia> Hecke.is_principal_fac_elem(I)(true, Factored element with data
Dict{nf_elem, ZZRingElem}(1//2*_$^2 - 5*_$ - 17//2 => 1))

The computation of $S$-units is also tied to the class group:

torsion_units — Method

torsion_units(O::NfOrd) -> Vector{NfOrdElem}

Given an order $O$, compute the torsion units of $O$.

torsion_unit_group — Method

torsion_unit_group(O::NfOrd) -> GrpAb, Map

Given an order $\mathcal O$, returns the torsion units as an abelian group $G$ together with a map $G \to \mathcal O^\times$.

torsion_units_generator — Method

torsion_units_generator(O::NfOrd) -> NfOrdElem

Given an order $O$, compute a generator of the torsion units of $O$.

torsion_units_gen_order — Method

torsion_units_gen_order(O::NfOrd) -> NfOrdElem

Given an order $O$, compute a generator of the torsion units of $O$ as well as its order.

unit_group — Method

unit_group(O::NfOrd) -> GrpAbFinGen, Map

Returns a group $U$ and an isomorphism map $f \colon U \to \mathcal O^\times$. A set of fundamental units of $\mathcal O$ can be obtained via [ f(U[1+i]) for i in 1:unit_group_rank(O) ]. f(U[1]) will give a generator for the torsion subgroup.

unit_group_fac_elem — Method

unit_group_fac_elem(O::NfOrd) -> GrpAbFinGen, Map

sunit_group — Method

sunit_group(I::Vector{NfOrdIdl}) -> GrpAb, Map

For an array $I$ of (coprime prime) ideals, find the $S$-unit group defined by $I$, ie. the group of non-zero field elements which are only divisible by ideals in $I$.

sunit_group_fac_elem — Method

sunit_group_fac_elem(I::Vector{NfOrdIdl}) -> GrpAb, Map

For an array $I$ of (coprime prime) ideals, find the $S$-unit group defined by $I$, ie. the group of non-zero field elements which are only divisible by ideals in $I$. The map will return elements in factored form.

sunit_mod_units_group_fac_elem — Method

sunit_mod_units_group_fac_elem(I::Vector{NfOrdIdl}) -> GrpAb, Map

For an array $I$ of (coprime prime) ideals, find the $S$-unit group defined by $I$, ie. the group of non-zero field elements which are only divisible by ideals in $I$ modulo the units of the field. The map will return elements in factored form.

julia> u, mu = unit_group(zk)(GrpAb: Z/2 x Z, UnitGroup map of Maximal order of Number field of degree 3 over QQ
with basis nf_elem[1, _$, 1//2*_$^2 + 1//2]
)
julia> mu(u[2])_$ - 12
julia> u, mu = unit_group_fac_elem(zk)(GrpAb: Z/2 x Z, UnitGroup map of Factored elements over Number field of degree 3 over QQ
)
julia> mu(u[2])Factored element with data
Dict{nf_elem, ZZRingElem}(_$^2 + 1 => -1, -15//2*_$^2 + 84*_$ + 53//2 => 1, 7*_$^2 - 90*_$ + 127 => 1, -3*_$^2 + 20*_$ - 62 => -1, 3 => 1, 7//2*_$^2 - 45*_$ + 127//2 => -1)
julia> evaluate(ans)_$ - 12
julia> lp = factor(6*zk)Dict{NfOrdIdl, Int64} with 4 entries:
  <3, _$ + 5>                  => 1
  <3, _$^2 + 1>                => 1
  <2, 5//2*_$^2 + 2*_$ + 5//2> => 2
  <2, 7//2*_$^2 + 5//2>        => 1
julia> s, ms = Hecke.sunit_group(collect(keys(lp)))(GrpAb: Z/2 x Z^(5), SUnits  map of Number field of degree 3 over QQ for NfOrdIdl[<3, _$ + 5>
Norm: 3
Minimum: 3
basis_matrix
[3 0 0; 2 1 0; 2 0 1]
two normal wrt: 3, <3, _$^2 + 1>
Norm: 9
Minimum: 3
basis_matrix
[3 0 0; 0 3 0; 0 0 1]
two normal wrt: 3, <2, 5//2*_$^2 + 2*_$ + 5//2>
Norm: 2
Minimum: 2
basis_matrix
[2 0 0; 1 1 0; 0 0 1]
two normal wrt: 2, <2, 7//2*_$^2 + 5//2>
Norm: 2
Minimum: 2
basis_matrix
[2 0 0; 1 1 0; 1 0 1]
two normal wrt: 2]
)
julia> ms(s[4])-1//2*_$^2 + 6*_$ + 5//2
julia> norm(ans)144
julia> factor(numerator(ans))1 * 2^4 * 3^2

Miscaellenous

order — Method

order(I::NumFieldOrdIdl) -> NfOrd

Returns the order of $I$.

order — Method

order(a::NfAbsOrdFracIdl) -> NfAbsOrd

The order that was used to define the ideal $a$.

order — Method

order(I::NumFieldOrdIdl) -> NfOrd

Returns the order of $I$.

order — Method

order(a::NfRelOrdFracIdl) -> NfRelOrd

Returns the order of $a$.

nf — Method

nf(x::NumFieldOrdIdl) -> AnticNumberField

Returns the number field, of which $x$ is an integral ideal.

basis — Method

basis(A::NfAbsOrdIdl) -> Vector{NfOrdElem}

Returns the basis of $A$.

basis(I::NfAbsOrdFracIdl) -> Vector{nf_elem}

Returns the $\mathbf Z$-basis of $I$.

lll_basis — Method

lll_basis(I::NumFieldOrdIdl) -> Vector{NumFieldElem}

A basis for $I$ that is reduced using the LLL algorithm for the Minkowski metric.

basis_matrix — Method

basis_matrix(A::NfAbsOrdIdl) -> ZZMatrix

Returns the basis matrix of $A$.

basis_mat_inv — Method

basis_mat_inv(A::NfAbsOrdIdl) -> ZZMatrix

Returns the inverse basis matrix of $A$.

basis_mat_inv(A::GenOrdIdl) -> FakeFracFldMat

Return the inverse of the basis matrix of $A$.

assure_has_basis_mat_inv — Method

basis_mat_inv(A::NfAbsOrdIdl) -> FakeFmpqMat

Returns the inverse of the basis matrix of $A$.

has_basis — Method

has_basis(A::NfAbsOrdIdl) -> Bool

Returns whether $A$ has a basis already computed.

has_basis_matrix — Method

has_basis_matrix(A::NfAbsOrdIdl) -> Bool

Returns whether $A$ knows its basis matrix.

has_2_elem — Method

has_2_elem(A::NfAbsOrdIdl) -> Bool

Returns whether $A$ is generated by two elements.

has_2_elem_normal — Method

has_2_elem_normal(A::NfAbsOrdIdl) -> Bool

Returns whether $A$ has normal two element generators.

has_weakly_normal — Method

has_weakly_normal(A::NfAbsOrdIdl) -> Bool

Returns whether $A$ has weakly normal two element generators.

has_princ_gen_special — Method

has_princ_gen_special(A::NfAbsOrdIdl) -> Bool

Returns whether $A$ knows if it is generated by a rational integer.

principal_generator — Method

principal_generator(A::NfOrdIdl) -> NfOrdElem

For a principal ideal $A$, find a generator.

principal_generator_fac_elem — Method

principal_generator_fac_elem(A::NfOrdIdl) -> FacElem{nf_elem, number_field}

For a principal ideal $A$, find a generator in factored form.

minimum — Method

minimum(A::NfAbsOrdIdl) -> ZZRingElem

Returns the smallest nonnegative element in $A \cap \mathbf Z$.

  minimum(A::NfRelOrdIdl) -> NfOrdIdl
  minimum(A::NfRelOrdIdl) -> NfRelOrdIdl

Returns the ideal $A \cap O$ where $O$ is the maximal order of the coefficient ideals of $A$.

minimum — Method

  minimum(A::NfRelOrdIdl) -> NfOrdIdl
  minimum(A::NfRelOrdIdl) -> NfRelOrdIdl

Returns the ideal $A \cap O$ where $O$ is the maximal order of the coefficient ideals of $A$.

minimum — Method

minimum(A::NfAbsOrdIdl) -> ZZRingElem

Returns the smallest nonnegative element in $A \cap \mathbf Z$.

has_minimum — Method

has_minimum(A::NfAbsOrdIdl) -> Bool

Returns whether $A$ knows its minimum.

norm — Method

norm(A::NfAbsOrdIdl) -> ZZRingElem

Returns the norm of $A$, that is, the cardinality of $\mathcal O/A$, where $\mathcal O$ is the order of $A$.

norm(a::NfRelOrdIdl) -> NfOrdIdl

Returns the norm of $a$.

norm(a::NfRelOrdFracIdl{T, S}) -> S

Returns the norm of $a$.

norm(a::AlgAssAbsOrdIdl, O::AlgAssAbsOrd; copy::Bool = true) -> QQFieldElem

Returns the norm of $a$ considered as an (possibly fractional) ideal of $O$.

norm(a::AlgAssRelOrdIdl{S, T, U}, O::AlgAssRelOrd{S, T, U}; copy::Bool = true)
  where { S, T, U } -> T

Returns the norm of $a$ considered as an (possibly fractional) ideal of $O$.

has_norm — Method

has_norm(A::NfAbsOrdIdl) -> Bool

Returns whether $A$ knows its norm.

idempotents — Method

idempotents(x::NfOrdIdl, y::NfOrdIdl) -> NfOrdElem, NfOrdElem

Returns a tuple (e, f) consisting of elements e in x, f in y such that 1 = e + f.

If the ideals are not coprime, an error is raised.

is_prime — Method

is_prime(A::NfOrdIdl) -> Bool

Returns whether $A$ is a prime ideal.

is_prime_known — Method

is_prime_known(A::NfOrdIdl) -> Bool

Returns whether $A$ knows if it is prime.

is_ramified — Method

is_ramified(O::NfOrd, p::Int) -> Bool

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

ramification_index — Method

ramification_index(P::NfOrdIdl) -> Int

The ramification index of the prime-ideal $P$.

degree — Method

degree(P::NfOrdIdl) -> Int

The inertia degree of the prime-ideal $P$.

valuation — Method

valuation(a::NumFieldElem, p::NfOrdIdl) -> ZZRingElem

Computes the $\mathfrak p$-adic valuation of $a$, that is, the largest $i$ such that $a$ is contained in $\mathfrak p^i$.

valuation — Method

valuation(a::nf_elem, p::NfOrdIdl) -> ZZRingElem
valuation(a::NfOrdElem, p::NfOrdIdl) -> ZZRingElem
valuation(a::ZZRingElem, p::NfOrdIdl) -> ZZRingElem

Computes the $\mathfrak p$-adic valuation of $a$, that is, the largest $i$ such that $a$ is contained in $\mathfrak p^i$.

valuation — Method

valuation(A::NfOrdIdl, p::NfOrdIdl) -> ZZRingElem

Computes the $\mathfrak p$-adic valuation of $A$, that is, the largest $i$ such that $A$ is contained in $\mathfrak p^i$.

valuation — Method

valuation(a::Integer, p::NfOrdIdl) -> ZZRingElem

Computes the $\mathfrak p$-adic valuation of $a$, that is, the largest $i$ such that $a$ is contained in $\mathfrak p^i$.

valuation — Method

valuation(a::nf_elem, p::NfOrdIdl) -> ZZRingElem
valuation(a::NfOrdElem, p::NfOrdIdl) -> ZZRingElem
valuation(a::ZZRingElem, p::NfOrdIdl) -> ZZRingElem

Computes the $\mathfrak p$-adic valuation of $a$, that is, the largest $i$ such that $a$ is contained in $\mathfrak p^i$.

valuation — Method

valuation(A::NfAbsOrdFracIdl, p::NfAbsOrdIdl)

The valuation of $A$ at $p$.

idempotents — Method

idempotents(x::NfOrdIdl, y::NfOrdIdl) -> NfOrdElem, NfOrdElem

Returns a tuple (e, f) consisting of elements e in x, f in y such that 1 = e + f.

If the ideals are not coprime, an error is raised.

Quotient Rings

quo — Method

quo(O::NfOrd, I::NfOrdIdl) -> NfOrdQuoRing, Map
quo(O::AlgAssAbsOrd, I::AlgAssAbsOrdIdl) -> AbsOrdQuoRing, Map

The quotient ring $O/I$ as a ring together with the section $M: O/I \to O$. The pointwise inverse of $M$ is the canonical projection $O\to O/I$.

residue_ring — Method

residue_ring(O::NfOrd, I::NfOrdIdl) -> NfOrdQuoRing
residue_ring(O::AlgAssAbsOrd, I::AlgAssAbsOrdIdl) -> AbsOrdQuoRing

The quotient ring $O$ modulo $I$ as a new ring.

residue_field — Method

residue_field(O::NfOrd, P::NfOrdIdl, check::Bool = true) -> Field, Map

Returns the residue field of the prime ideal $P$ together with the projection map. If check is true, the ideal is checked for being prime.

mod — Method

mod(x::NfOrdElem, I::NfAbsOrdIdl)

Returns the unique element $y$ of the ambient order of $x$ with $x \equiv y \bmod I$ and the following property: If $a_1,\dotsc,a_d \in \mathbf{Z}_{\geq 1}$ are the diagonal entries of the unique HNF basis matrix of $I$ and $(b_1,\dotsc,b_d)$ is the coefficient vector of $y$, then $0 \leq b_i < a_i$ for $1 \leq i \leq d$.

crt — Method

crt(r1::NfOrdElem, i1::NfOrdIdl, r2::NfOrdElem, i2::NfOrdIdl) -> NfOrdElem

Find $x$ such that $x \equiv r_1 \bmod i_1$ and $x \equiv r_2 \bmod i_2$ using idempotents.

euler_phi — Method

euler_phi(A::NfOrdIdl) -> ZZRingElem

The ideal version of the totient function returns the size of the unit group of the residue ring modulo the ideal.

multiplicative_group — Method

multiplicative_group(Q::NfOrdQuoRing) -> GrpAbFinGen, Map{GrpAbFinGen, NfOrdQuoRing}
unit_group(Q::NfOrdQuoRing) -> GrpAbFinGen, Map{GrpAbFinGen, NfOrdQuoRing}

Returns the unit group of $Q$ as an abstract group $A$ and an isomorphism map $f \colon A \to Q^\times$.

multiplicative_group_generators — Method

multiplicative_group_generators(Q::NfOrdQuoRing) -> Vector{NfOrdQuoRingElem}

Return a set of generators for $Q^\times$.