GaloisGroupFactorizer UPΒΆ

galfact.spad line 362

GaloisGroupFactorizer provides functions to factor resolvents.

btwFact: (UP, Boolean, Set NonNegativeInteger, NonNegativeInteger) -> Record(contp: Integer, factors: List Record(irr: UP, pow: Integer))
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. f 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. f 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. f 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. f 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: Integer))
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: Integer)) -> Factored UP
makeFR(flist) turns the final factorization of henselFact into a Factored object.
modularFactor: UP -> Record(prime: Integer, factors: List UP)
modularFactor(f) 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).
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 -> Boolean
tryFunctionalDecomposition(b) chooses whether factorizers have to look for functional decomposition of polynomials (true) or not (false). Returns the previous value.
tryFunctionalDecomposition?: () -> Boolean
tryFunctionalDecomposition?() returns true if factorizers try functional decomposition of polynomials before factoring them.
useEisensteinCriterion: Boolean -> Boolean
useEisensteinCriterion(b) chooses whether factorizers check Eisenstein's criterion before factoring: true for using it, false else. Returns the previous value.
useEisensteinCriterion?: () -> Boolean
useEisensteinCriterion?() returns true if factorizers check Eisenstein's criterion before factoring.
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.
useSingleFactorBound?: () -> Boolean
useSingleFactorBound?() returns true if algorithm with single factor bound is used for factorization, false for algorithm with overall bound.