# Factored Elements

In many applications in number theory related to the multiplicative structure of number fields, interesting elements, e.g. units, are extremely large when written wrt. to a fxied basis for the field: for the fundamental unit in $Q[\sqrt d]$ it is known that the coefficients wrt. the canonical basis $1, \sqrt d$ can have $O(\exp \sqrt d)$ many digits. All currently known, fast methods construct those elements as power products of smaller elements, allowing the computer to handle them.

Mathematically, one can think of factored elements to formally live in the ring $Z[K]$ the group ring of the non-zero field elements. Thus elements are of the form $\prod ai^{ei}$ where $a_i$ are elements in $K$, typically small and the $e_i\in Z$ are frequently large exponents. We refer to the $a_i$ as the base and the $e_i$ as the exponents of the factored element.

Since $K$ is, in general, no PID, this presentation is non-unique, elements in this form can easily be multiplied, raised to large powers, but in general not compared and not added.

In Hecke, this is caputured more generally by the type FacElem, parametrized by the type of the elements in the base and the type of their parent.

Important special cases are

• FacElem{fmpz, FlintIntegerRing}, factored integers
• FacElem{nf_elem, AnticNumberField}, factored algerbaic numbers
• FacElem{NfAbsOrdIdl, NfAbsOrdIdlSet}, factored ideals

It should be noted that an object of type $FacElem{fmpz, FlintIntegerRing}$ will, in general, not represent an integer as the exponents can be negative.

## Construction

In general one can define factored elements by giving 2 arrays, the base and the exponent, or a dictionary containing the pairs:

FacElemType
FacElem{B}(R, base::Vector{B}, exp::Vector{fmpz}) -> FacElem{B}

Returns the element $\prod b_i^{e_i}$, un-expanded.

FacElem{B}(base::Vector{B}, exp::Vector{fmpz}) -> FacElem{B}

Returns the element $\prod b_i^{e_i}$, un-expanded.

FacElem{B}(R, d::Dict{B, fmpz}) -> FacElem{B}
FacElem{B}(R, d::Dict{B, Integer}) -> FacElem{B}

Returns the element $\prod b^{d[p]}$, un-expanded.

FacElem{B}(d::Dict{B, fmpz}) -> FacElem{B}
FacElem{B}(d::Dict{B, Integer}) -> FacElem{B}

Returns the element $\prod b^{d[p]}$, un-expanded.

FacElemMethod
FacElem{B}(R, base::Vector{B}, exp::Vector{fmpz}) -> FacElem{B}

Returns the element $\prod b_i^{e_i}$, un-expanded.

FacElem{B}(base::Vector{B}, exp::Vector{fmpz}) -> FacElem{B}

Returns the element $\prod b_i^{e_i}$, un-expanded.

FacElem{B}(R, d::Dict{B, fmpz}) -> FacElem{B}
FacElem{B}(R, d::Dict{B, Integer}) -> FacElem{B}

Returns the element $\prod b^{d[p]}$, un-expanded.

FacElem{B}(d::Dict{B, fmpz}) -> FacElem{B}
FacElem{B}(d::Dict{B, Integer}) -> FacElem{B}

Returns the element $\prod b^{d[p]}$, un-expanded.

idealMethod
 ideal(O::NfOrd, a::FacElem{nf_elem, AnticNumberField)

The factored fractional ideal $a*O$.

## Conversion

The process of computing the value defined by a factored element is available as evaluate. Depending on the types involved this can be very efficient.

evaluateMethod
evaluate{T}(x::FacElem{T}) -> T

Expands or evaluates the factored element, i.e. actually computes the value. Does "square-and-multiply" on the exponent vectors.

evaluateMethod
evaluate(x::FacElem{fmpq}) -> fmpq
evaluate(x::FacElem{fmpz}) -> fmpz

Expands or evaluates the factored element, i.e. actually computes the the element. Works by first obtaining a simplified version of the power product into coprime base elements.

evaluateMethod
evaluate{T}(x::FacElem{T}) -> T

Expands or evaluates the factored element, i.e. actually computes the value. Does "square-and-multiply" on the exponent vectors.

evaluate_naiveMethod
evaluate_naive{T}(x::FacElem{T}) -> T

Expands or evaluates the factored element, i.e. actually computes the value. Uses the obvious naive algorithm. Faster for input in finite rings.

## Special functions

In the case where the parent of the base allows for efficient gcd computation, power products can be made unique:

simplifyMethod
simplify(x::FacElem{NfOrdIdl, NfOrdIdlSet}) -> FacElem
simplify(x::FacElem{NfOrdFracIdl, NfOrdFracIdlSet}) -> FacElem

Uses coprime_base to obtain a simplified version of $x$, ie. in the simplified version all base ideals will be pariwise coprime but not neccessarily prime!.

simplifyMethod
simplify(x::FacElem{fmpq}) -> FacElem{fmpq}
simplify(x::FacElem{fmpz}) -> FacElem{fmpz}

Simplfies the factored element, i.e. arranges for the base to be coprime.

The simplified version can then be used further:

isoneMethod
isone(x::FacElem{fmpq}) -> Bool
isone(x::FacElem{fmpz}) -> Bool

Tests if $x$ represents $1$ without an evaluation.

factor_coprimeMethod
factor_coprime(x::FacElem{fmpz}) -> Fac{fmpz}

Computed a partial factorisation of $x$, ie. writes $x$ as a product of pariwise coprime integers.

factor_coprimeMethod
factor_coprime(x::FacElem{NfOrdIdl, NfOrdIdlSet}) -> Dict{NfOrdIdl, Int}

Computed a partial factorisation of $x$, ie. writes $x$ as a product of pariwise coprime integral ideals.

factor_coprimeMethod
factor_coprime(Q::FacElem{NfOrdFracIdl, NfOrdFracIdlSet}) -> Dict{NfOrdIdl, Int}

A coprime factorisation of $Q$: each ideal in $Q$ is split using \code{integral_split} and then a coprime basis is computed. This does {\bf not} use any factorisation.

factor_coprimeMethod
factor_coprime(a::FacElem{nf_elem, AnticNumberField}, I::NfOrdIdlSet) -> Dict{NfOrdIdl, fmpz}

Factors the rincipal ideal generated by $a$ into coprimes by computing a coprime basis from the principal ideals in the factorisation of $a$.

factorMethod
 factor(Q::FacElem{NfOrdFracIdl, NfOrdFracIdlSet}) -> Dict{NfOrdIdl, Int}

The factorisation of $Q$, by refining a coprime factorisation.

factorMethod
factor(a::FacElem{nf_elem, AnticNumberField}, I::NfOrdIdlSet) -> Dict{NfOrdIdl, fmpz}

Factors the principal ideal generated by $a$ by refinind a coprime factorisation.

For factorised algebraic numbers a unique simplification is not possible, however, this allows still do obtain partial results:

compact_presentationFunction
compact_presentation(a::FacElem{nf_elem, AnticNumberField}, n::Int = 2; decom, arb_prec = 100, short_prec = 1000) -> FacElem

Computes a presentation $a = \prod a_i^{n_i}$ where all the exponents $n_i$ are powers of $n$ and, the elements $a_i$ are "small", generically, they have a norm bounded by $d^{n/2}$ where $d$ is the discriminant of the maximal order. As the algorithm needs the factorisation of the principal ideal generated by $a$, it can be passed in in \code{decom}.

valuationMethod
valuation(a::FacElem{nf_elem, AnticNumberField}, P::NfOrdIdl) -> fmpz

The valuation of $a$ at $P$.

valuationMethod
valuation(A::FacElem{NfOrdFracIdl, NfOrdFracIdlSet}, p::NfOrdIdl)
valuation(A::FacElem{NfOrdIdl, NfOrdIdlSet}, p::NfOrdIdl)

The valuation of $A$ at $P$.

evaluate_modMethod
evaluate_mod(a::FacElem{nf_elem, AnticNumberField}, B::NfOrdFracIdl) -> nf_elem

Evaluates $a$ using CRT and small primes. Assumes that the ideal generated by $a$ is in fact $B$. Useful in cases where $a$ has huge exponents, but the evaluated element is actually "small".

reduce_idealMethod
reduce_ideal(A::FacElem{NfOrdIdl}) -> NfOrdIdl, FacElem{nf_elem}

Computes $B$ and $\alpha$ in factored form, such that $\alpha B = A$.

modular_projMethod
modular_proj(a::FacElem{nf_elem, AnticNumberField}, me::modular_env) -> Vector{fq_nmod}

Given an algebraic number $a$ in factored form and data \code{me} as computed by \code{modular_init}, project $a$ onto the residue class fields.

## Positivity & Signs

Factored elements can be used instead of number field elements for the functions sign, signs, is_positive, is_negative and is_totally_positive, see Positivity & Signs

## Miscellaneous

max_expMethod
max_exp(a::FacElem)

Finds the largest exponent in the factored element $a$.

min_expMethod
min_exp(a::FacElem)

Finds the smallest exponent in the factored element $a$.

maxabs_expMethod
maxabs_exp(a::FacElem)`

Finds the largest exponent by absolute value in the factored element $a$.