# GaloisGroupFactorizer UP¶

GaloisGroupFactorizer provides functions to factor resolvents.

btwFact: (UP, Boolean, Set NonNegativeInteger, NonNegativeInteger) -> Record(contp: Integer, factors: List Record(irr: UP, pow: NonNegativeInteger))

`btwFact(p, sqf, pd, r)` returns the factorization of `p`, the result is a Record such that `contp=`content `p`, `factors=`List of irreducible factors of `p` with exponent. If `sqf=true` the polynomial is assumed to be square free (i.e. without repeated factors). `pd` is the Set of possible degrees. `r` is a lower bound for the number of factors of `p`. Please do not use this function in your code because its design may change.

degreePartition: List Record(factor: UP, degree: Integer) -> Multiset NonNegativeInteger

`degreePartition(ddfactorization)` returns the degree partition of the polynomial `f` modulo `p` where `ddfactorization` is the distinct degree factorization of `f` computed by `ddfact` from modular factorization package for some prime `p`.

eisensteinIrreducible?: UP -> Boolean

`eisensteinIrreducible?(p)` returns `true` if `p` can be shown to be irreducible by Eisenstein`'s` criterion, `false` is inconclusive.

factor: (UP, List NonNegativeInteger) -> Factored UP

`factor(p, listOfDegrees)` factorizes the polynomial `p` using the single factor bound algorithm and knowing that `p` has for possible splitting of its degree listOfDegrees.

factor: (UP, List NonNegativeInteger, NonNegativeInteger) -> Factored UP

`factor(p, listOfDegrees, r)` factorizes the polynomial `p` using the single factor bound algorithm, knowing that `p` has for possible splitting of its degree `listOfDegrees` and that `p` has at least `r` factors.

factor: (UP, NonNegativeInteger) -> Factored UP

`factor(p, r)` factorizes the polynomial `p` using the single factor bound algorithm and knowing that `p` has at least `r` factors.

factor: (UP, NonNegativeInteger, NonNegativeInteger) -> Factored UP

`factor(p, d, r)` factorizes the polynomial `p` using the single factor bound algorithm, knowing that `d` divides the degree of all factors of `p` and that `p` has at least `r` factors.

factor: UP -> Factored UP

`factor(p)` returns the factorization of `p` over the integers.

factorOfDegree: (PositiveInteger, UP) -> Union(UP, failed)

`factorOfDegree(d, p)` returns a factor of `p` of degree `d`.

factorOfDegree: (PositiveInteger, UP, List NonNegativeInteger) -> Union(UP, failed)

`factorOfDegree(d, p, listOfDegrees)` returns a factor of `p` of degree `d` knowing that `p` has for possible splitting of its degree listOfDegrees.

factorOfDegree: (PositiveInteger, UP, List NonNegativeInteger, NonNegativeInteger) -> Union(UP, failed)

`factorOfDegree(d, p, listOfDegrees, r)` returns a factor of `p` of degree `d` knowing that `p` has for possible splitting of its degree `listOfDegrees`, and that `p` has at least `r` factors.

factorOfDegree: (PositiveInteger, UP, List NonNegativeInteger, NonNegativeInteger, Boolean) -> Union(UP, failed)

`factorOfDegree(d, p, listOfDegrees, r, sqf)` returns a factor of `p` of degree `d` knowing that `p` has for possible splitting of its degree `listOfDegrees`, and that `p` has at least `r` factors. If `sqf=true` the polynomial is assumed to be square free (i.e. without repeated factors).

factorOfDegree: (PositiveInteger, UP, NonNegativeInteger) -> Union(UP, failed)

`factorOfDegree(d, p, r)` returns a factor of `p` of degree `d` knowing that `p` has at least `r` factors.

factorSquareFree: (UP, List NonNegativeInteger) -> Factored UP

`factorSquareFree(p, listOfDegrees)` factorizes the polynomial `p` using the single factor bound algorithm and knowing that `p` has for possible splitting of its degree listOfDegrees. `p` is supposed not having any repeated factor (this is not checked).

factorSquareFree: (UP, List NonNegativeInteger, NonNegativeInteger) -> Factored UP

`factorSquareFree(p, listOfDegrees, r)` factorizes the polynomial `p` using the single factor bound algorithm, knowing that `p` has for possible splitting of its degree `listOfDegrees` and that `p` has at least `r` factors. `p` is supposed not having any repeated factor (this is not checked).

factorSquareFree: (UP, NonNegativeInteger) -> Factored UP

`factorSquareFree(p, r)` factorizes the polynomial `p` using the single factor bound algorithm and knowing that `p` has at least `r` factors. `p` is supposed not having any repeated factor (this is not checked).

factorSquareFree: (UP, NonNegativeInteger, NonNegativeInteger) -> Factored UP

`factorSquareFree(p, d, r)` factorizes the polynomial `p` using the single factor bound algorithm, knowing that `d` divides the degree of all factors of `p` and that `p` has at least `r` factors. `p` is supposed not having any repeated factor (this is not checked).

factorSquareFree: UP -> Factored UP

`factorSquareFree(p)` returns the factorization of `p` which is supposed not having any repeated factor (this is not checked).

henselFact: (UP, Boolean) -> Record(contp: Integer, factors: List Record(irr: UP, pow: NonNegativeInteger))

`henselFact(p, sqf)` returns the factorization of `p`, the result is a Record such that `contp=`content `p`, `factors=`List of irreducible factors of `p` with exponent. If `sqf=true` the polynomial is assumed to be square free (i.e. without repeated factors).

makeFR: Record(contp: Integer, factors: List Record(irr: UP, pow: NonNegativeInteger)) -> Factored UP

`makeFR(flist)` turns the final factorization of henselFact into a Factored object.

modularFactor: (UP, Set NonNegativeInteger) -> Record(prime: Integer, factors: List UP)

`modularFactor(f, d)` chooses a “good” prime and returns the factorization of `f` modulo this prime in a form that may be used by completeHensel. If prime is zero it means that `f` has been proved to be irreducible over the integers or that `f` is a unit (i.e. 1 or `-1`). `f` shall be primitive (i.e. content(`p`)`=1`) and square free (i.e. without repeated factors). `d` is set of possible degrees of factors.

musserTrials: () -> PositiveInteger

`musserTrials()` returns the number of primes that are tried in modularFactor.

musserTrials: PositiveInteger -> PositiveInteger

`musserTrials(n)` sets to `n` the number of primes to be tried in modularFactor and returns the previous value.

numberOfFactors: List Record(factor: UP, degree: Integer) -> NonNegativeInteger

`numberOfFactors(ddfactorization)` returns the number of factors of the polynomial `f` modulo `p` where `ddfactorization` is the distinct degree factorization of `f` computed by modular factorization package for some prime `p`.

stopMusserTrials: () -> PositiveInteger

`stopMusserTrials()` returns the bound on the number of factors for which modularFactor stops to look for an other prime. You will have to remember that the step of recombining the extraneous factors may take up to `2^stopMusserTrials()` trials.

stopMusserTrials: PositiveInteger -> PositiveInteger

`stopMusserTrials(n)` sets to `n` the bound on the number of factors for which modularFactor stops to look for an other prime. You will have to remember that the step of recombining the extraneous factors may take up to `2^n` trials. Returns the previous value.

tryFunctionalDecomposition?: () -> Boolean

`tryFunctionalDecomposition?()` returns `true` if factorizers try functional decomposition of polynomials before factoring them.

tryFunctionalDecomposition: Boolean -> Boolean

`tryFunctionalDecomposition(b)` chooses whether factorizers have to look for functional decomposition of polynomials (`true`) or not (`false`). Returns the previous value.

useEisensteinCriterion?: () -> Boolean

`useEisensteinCriterion?()` returns `true` if factorizers check Eisenstein`'s` criterion before factoring.

useEisensteinCriterion: Boolean -> Boolean

`useEisensteinCriterion(b)` chooses whether factorizers check Eisenstein`'s` criterion before factoring: `true` for using it, `false` else. Returns the previous value.

useSingleFactorBound?: () -> Boolean

`useSingleFactorBound?()` returns `true` if algorithm with single factor bound is used for factorization, `false` for algorithm with overall bound.

useSingleFactorBound: Boolean -> Boolean

`useSingleFactorBound(b)` chooses the algorithm to be used by the factorizers: `true` for algorithm with single factor bound, `false` for algorithm with overall bound. Returns the previous value.