GaloisGroupFactorizer UP

galfact.spad line 362 [edit on github]

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