RecursivePolynomialCategory(R, E, V)ΒΆ

newpoly.spad line 231

A category for general multi-variate polynomials with coefficients in a ring, variables in an ordered set, and exponents from an ordered abelian monoid, with a sup operation. When not constant, such a polynomial is viewed as a univariate polynomial in its main variable w. r. t. to the total ordering on the elements in the ordered set, so that some operations usually defined for univariate polynomials make sense here.

0: %
from AbelianMonoid
1: %
from MagmaWithUnit
*: (%, %) -> %
from Magma
*: (%, Fraction Integer) -> % if R has Algebra Fraction Integer
from RightModule Fraction Integer
*: (%, R) -> %
from RightModule R
*: (Fraction Integer, %) -> % if R has Algebra Fraction Integer
from LeftModule Fraction Integer
*: (Integer, %) -> %
from AbelianGroup
*: (NonNegativeInteger, %) -> %
from AbelianMonoid
*: (PositiveInteger, %) -> %
from AbelianSemiGroup
*: (R, %) -> %
from LeftModule R
+: (%, %) -> %
from AbelianSemiGroup
-: % -> %
from AbelianGroup
-: (%, %) -> %
from AbelianGroup
/: (%, R) -> % if R has Field
from AbelianMonoidRing(R, E)
=: (%, %) -> Boolean
from BasicType
^: (%, NonNegativeInteger) -> %
from MagmaWithUnit
^: (%, PositiveInteger) -> %
from Magma
~=: (%, %) -> Boolean
from BasicType
annihilate?: (%, %) -> Boolean
from Rng
antiCommutator: (%, %) -> %
from NonAssociativeSemiRng
associates?: (%, %) -> Boolean if R has EntireRing
from EntireRing
associator: (%, %, %) -> %
from NonAssociativeRng
binomThmExpt: (%, %, NonNegativeInteger) -> % if % has CommutativeRing
from FiniteAbelianMonoidRing(R, E)
characteristic: () -> NonNegativeInteger
from NonAssociativeRing
charthRoot: % -> Union(%, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit or R has CharacteristicNonZero
from PolynomialFactorizationExplicit
coefficient: (%, E) -> R
from AbelianMonoidRing(R, E)
coefficient: (%, List V, List NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(R, E, V)
coefficient: (%, V, NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(R, E, V)
coefficients: % -> List R
from FiniteAbelianMonoidRing(R, E)
coerce: % -> % if R has CommutativeRing
from Algebra %
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: % -> Polynomial R if V has ConvertibleTo Symbol
from CoercibleTo Polynomial R
coerce: Fraction Integer -> % if R has Algebra Fraction Integer or R has RetractableTo Fraction Integer
from Algebra Fraction Integer
coerce: Integer -> %
from NonAssociativeRing
coerce: R -> %
from Algebra R
coerce: V -> %
from RetractableTo V
commutator: (%, %) -> %
from NonAssociativeRng
conditionP: Matrix % -> Union(Vector %, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
content: % -> R if R has GcdDomain
from FiniteAbelianMonoidRing(R, E)
content: (%, V) -> % if R has GcdDomain
from PolynomialCategory(R, E, V)
convert: % -> InputForm if R has ConvertibleTo InputForm and V has ConvertibleTo InputForm
from ConvertibleTo InputForm
convert: % -> Pattern Float if R has ConvertibleTo Pattern Float and V has ConvertibleTo Pattern Float
from ConvertibleTo Pattern Float
convert: % -> Pattern Integer if R has ConvertibleTo Pattern Integer and V has ConvertibleTo Pattern Integer
from ConvertibleTo Pattern Integer
convert: % -> Polynomial R if V has ConvertibleTo Symbol
from ConvertibleTo Polynomial R
convert: % -> String if R has RetractableTo Integer and V has ConvertibleTo Symbol
from ConvertibleTo String
convert: Polynomial Fraction Integer -> % if R has Algebra Fraction Integer and V has ConvertibleTo Symbol
convert(p) returns the same as retract(p).
convert: Polynomial Integer -> % if R has Algebra Integer and V has ConvertibleTo Symbol
convert(p) returns the same as retract(p).
convert: Polynomial R -> % if V has ConvertibleTo Symbol
convert(p) returns the same as retract(p).
D: (%, List V) -> %
from PartialDifferentialRing V
D: (%, List V, List NonNegativeInteger) -> %
from PartialDifferentialRing V
D: (%, V) -> %
from PartialDifferentialRing V
D: (%, V, NonNegativeInteger) -> %
from PartialDifferentialRing V
deepestInitial: % -> %
deepestInitial(p) returns an error if p belongs to R, otherwise returns the last term of iteratedInitials(p).
deepestTail: % -> %
deepestTail(p) returns 0 if p belongs to R, otherwise returns tail(p), if tail(p) belongs to R or mvar(tail(p)) < mvar(p), otherwise returns deepestTail(tail(p)).
degree: % -> E
from AbelianMonoidRing(R, E)
degree: (%, List V) -> List NonNegativeInteger
from MaybeSkewPolynomialCategory(R, E, V)
degree: (%, V) -> NonNegativeInteger
from MaybeSkewPolynomialCategory(R, E, V)
differentiate: (%, List V) -> %
from PartialDifferentialRing V
differentiate: (%, List V, List NonNegativeInteger) -> %
from PartialDifferentialRing V
differentiate: (%, V) -> %
from PartialDifferentialRing V
differentiate: (%, V, NonNegativeInteger) -> %
from PartialDifferentialRing V
discriminant: (%, V) -> % if R has CommutativeRing
from PolynomialCategory(R, E, V)
eval: (%, %, %) -> %
from InnerEvalable(%, %)
eval: (%, Equation %) -> %
from Evalable %
eval: (%, List %, List %) -> %
from InnerEvalable(%, %)
eval: (%, List Equation %) -> %
from Evalable %
eval: (%, List V, List %) -> %
from InnerEvalable(V, %)
eval: (%, List V, List R) -> %
from InnerEvalable(V, R)
eval: (%, V, %) -> %
from InnerEvalable(V, %)
eval: (%, V, R) -> %
from InnerEvalable(V, R)
exactQuotient!: (%, %) -> % if R has IntegralDomain
exactQuotient!(a, b) replaces a by exactQuotient(a, b)
exactQuotient!: (%, R) -> % if R has IntegralDomain
exactQuotient!(p, r) replaces p by exactQuotient(p, r).
exactQuotient: (%, %) -> % if R has IntegralDomain
exactQuotient(a, b) computes the exact quotient of a by b, which is assumed to be a divisor of a. No error is returned if this exact quotient fails!
exactQuotient: (%, R) -> % if R has IntegralDomain
exactQuotient(p, r) computes the exact quotient of p by r, which is assumed to be a divisor of p. No error is returned if this exact quotient fails!
exquo: (%, %) -> Union(%, failed) if R has EntireRing
from EntireRing
exquo: (%, R) -> Union(%, failed) if R has EntireRing
from FiniteAbelianMonoidRing(R, E)
extendedSubResultantGcd: (%, %) -> Record(gcd: %, coef1: %, coef2: %) if R has IntegralDomain
extendedSubResultantGcd(a, b) returns [ca, cb, r] such that r is subResultantGcd(a, b) and we have ca * a + cb * cb = r .
factor: % -> Factored % if R has PolynomialFactorizationExplicit
from UniqueFactorizationDomain
factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
fmecg: (%, E, R, %) -> %
from FiniteAbelianMonoidRing(R, E)
gcd: (%, %) -> % if R has GcdDomain
from GcdDomain
gcd: (R, %) -> R if R has GcdDomain
gcd(r, p) returns the gcd of r and the content of p.
gcd: List % -> % if R has GcdDomain
from GcdDomain
gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial % if R has GcdDomain
from PolynomialFactorizationExplicit
ground: % -> R
from FiniteAbelianMonoidRing(R, E)
ground?: % -> Boolean
from FiniteAbelianMonoidRing(R, E)
halfExtendedSubResultantGcd1: (%, %) -> Record(gcd: %, coef1: %) if R has IntegralDomain
halfExtendedSubResultantGcd1(a, b) returns [g, ca] if extendedSubResultantGcd(a, b) returns [g, ca, cb] otherwise produces an error.
halfExtendedSubResultantGcd2: (%, %) -> Record(gcd: %, coef2: %) if R has IntegralDomain
halfExtendedSubResultantGcd2(a, b) returns [g, cb] if extendedSubResultantGcd(a, b) returns [g, ca, cb] otherwise produces an error.
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
head: % -> %
head(p) returns p if p belongs to R, otherwise returns its leading term (monomial in the FriCAS sense), where p is viewed as a univariate polynomial in its main variable.
headReduce: (%, %) -> %
headReduce(a, b) returns a polynomial r such that headReduced?(r, b) holds and there exists an integer e such that init(b)^e a - r is zero modulo b.
headReduced?: (%, %) -> Boolean
headReduced?(a, b) returns true iff degree(head(a), mvar(b)) < mdeg(b).
headReduced?: (%, List %) -> Boolean
headReduced?(q, lp) returns true iff headReduced?(q, p) holds for every p in lp.
iexactQuo: (R, R) -> R if R has IntegralDomain
iexactQuo(x, y) should be local but conditional
infRittWu?: (%, %) -> Boolean
infRittWu?(a, b) returns true if a is less than b w.r.t. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.
init: % -> %
init(p) returns an error if p belongs to R, otherwise returns its leading coefficient, where p is viewed as a univariate polynomial in its main variable.
initiallyReduce: (%, %) -> %
initiallyReduce(a, b) returns a polynomial r such that initiallyReduced?(r, b) holds and there exists an integer e such that init(b)^e a - r is zero modulo b.
initiallyReduced?: (%, %) -> Boolean
initiallyReduced?(a, b) returns false iff there exists an iterated initial of a which is not reduced w.r.t b.
initiallyReduced?: (%, List %) -> Boolean
initiallyReduced?(q, lp) returns true iff initiallyReduced?(q, p) holds for every p in lp.
isExpt: % -> Union(Record(var: V, exponent: NonNegativeInteger), failed)
from PolynomialCategory(R, E, V)
isPlus: % -> Union(List %, failed)
from PolynomialCategory(R, E, V)
isTimes: % -> Union(List %, failed)
from PolynomialCategory(R, E, V)
iteratedInitials: % -> List %
iteratedInitials(p) returns [] if p belongs to R, otherwise returns the list of the iterated initials of p.
lastSubResultant: (%, %) -> % if R has IntegralDomain
lastSubResultant(a, b) returns the last non-zero subresultant of a and b where a and b are assumed to have the same main variable v and are viewed as univariate polynomials in v.
latex: % -> String
from SetCategory
LazardQuotient2: (%, %, %, NonNegativeInteger) -> % if R has IntegralDomain
LazardQuotient2(p, a, b, n) returns (a^(n-1) * p) exquo b^(n-1) assuming that this quotient does not fail.
LazardQuotient: (%, %, NonNegativeInteger) -> % if R has IntegralDomain
LazardQuotient(a, b, n) returns a^n exquo b^(n-1) assuming that this quotient does not fail.
lazyPquo: (%, %) -> %
lazyPquo(a, b) returns the polynomial q such that lazyPseudoDivide(a, b) returns [c, g, q, r].
lazyPquo: (%, %, V) -> %
lazyPquo(a, b, v) returns the polynomial q such that lazyPseudoDivide(a, b, v) returns [c, g, q, r].
lazyPrem: (%, %) -> %
lazyPrem(a, b) returns the polynomial r reduced w.r.t. b and such that b divides init(b)^e a - r where e is the number of steps of this pseudo-division.
lazyPrem: (%, %, V) -> %
lazyPrem(a, b, v) returns the polynomial r reduced w.r.t. b viewed as univariate polynomials in the variable v such that b divides init(b)^e a - r where e is the number of steps of this pseudo-division.
lazyPremWithDefault: (%, %) -> Record(coef: %, gap: NonNegativeInteger, remainder: %)
lazyPremWithDefault(a, b) returns [c, g, r] such that r = lazyPrem(a, b) and (c^g)*r = prem(a, b).
lazyPremWithDefault: (%, %, V) -> Record(coef: %, gap: NonNegativeInteger, remainder: %)
lazyPremWithDefault(a, b, v) returns [c, g, r] such that r = lazyPrem(a, b, v) and (c^g)*r = prem(a, b, v).
lazyPseudoDivide: (%, %) -> Record(coef: %, gap: NonNegativeInteger, quotient: %, remainder: %)
lazyPseudoDivide(a, b) returns [c, g, q, r] such that [c, g, r] = lazyPremWithDefault(a, b) and q is the pseudo-quotient computed in this lazy pseudo-division.
lazyPseudoDivide: (%, %, V) -> Record(coef: %, gap: NonNegativeInteger, quotient: %, remainder: %)
lazyPseudoDivide(a, b, v) returns [c, g, q, r] such that r = lazyPrem(a, b, v), (c^g)*r = prem(a, b, v) and q is the pseudo-quotient computed in this lazy pseudo-division.
lazyResidueClass: (%, %) -> Record(polnum: %, polden: %, power: NonNegativeInteger)
lazyResidueClass(a, b) returns [p, q, n] where p / q^n represents the residue class of a modulo b and p is reduced w.r.t. b and q is init(b).
lcm: (%, %) -> % if R has GcdDomain
from GcdDomain
lcm: List % -> % if R has GcdDomain
from GcdDomain
lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %) if R has GcdDomain
from LeftOreRing
leadingCoefficient: % -> R
from AbelianMonoidRing(R, E)
leadingCoefficient: (%, V) -> %
leadingCoefficient(p, v) returns the leading coefficient of p, where p is viewed as A univariate polynomial in v.
leadingMonomial: % -> %
from AbelianMonoidRing(R, E)
leastMonomial: % -> %
leastMonomial(p) returns an error if p is O, otherwise, if p belongs to R returns 1, otherwise, the monomial of p with lowest degree, where p is viewed as a univariate polynomial in its main variable.
leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
leftPower: (%, PositiveInteger) -> %
from Magma
leftRecip: % -> Union(%, failed)
from MagmaWithUnit
mainCoefficients: % -> List %
mainCoefficients(p) returns an error if p is O, otherwise, if p belongs to R returns [p], otherwise returns the list of the coefficients of p, where p is viewed as a univariate polynomial in its main variable.
mainContent: % -> % if R has GcdDomain
mainContent(p) returns the content of p viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over R.
mainMonomial: % -> %
mainMonomial(p) returns an error if p is O, otherwise, if p belongs to R returns 1, otherwise, mvar(p) raised to the power mdeg(p).
mainMonomials: % -> List %
mainMonomials(p) returns an error if p is O, otherwise, if p belongs to R returns [1], otherwise returns the list of the monomials of p, where p is viewed as a univariate polynomial in its main variable.
mainPrimitivePart: % -> % if R has GcdDomain
mainPrimitivePart(p) returns the primitive part of p viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over R.
mainSquareFreePart: % -> % if R has GcdDomain
mainSquareFreePart(p) returns the square free part of p viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over R.
mainVariable: % -> Union(V, failed)
from MaybeSkewPolynomialCategory(R, E, V)
map: (R -> R, %) -> %
from AbelianMonoidRing(R, E)
mapExponents: (E -> E, %) -> %
from FiniteAbelianMonoidRing(R, E)
mdeg: % -> NonNegativeInteger
mdeg(p) returns an error if p is 0, otherwise, if p belongs to R returns 0, otherwise, returns the degree of p in its main variable.
minimumDegree: % -> E
from FiniteAbelianMonoidRing(R, E)
minimumDegree: (%, List V) -> List NonNegativeInteger
from PolynomialCategory(R, E, V)
minimumDegree: (%, V) -> NonNegativeInteger
from PolynomialCategory(R, E, V)
monic?: % -> Boolean
monic?(p) returns false if p belongs to R, otherwise returns true iff p is monic as a univariate polynomial in its main variable.
monicDivide: (%, %, V) -> Record(quotient: %, remainder: %)
from PolynomialCategory(R, E, V)
monicModulo: (%, %) -> %
monicModulo(a, b) computes a mod b, if b is monic as univariate polynomial in its main variable.
monomial: (%, List V, List NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(R, E, V)
monomial: (%, V, NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(R, E, V)
monomial: (R, E) -> %
from AbelianMonoidRing(R, E)
monomial?: % -> Boolean
from AbelianMonoidRing(R, E)
monomials: % -> List %
from MaybeSkewPolynomialCategory(R, E, V)
multivariate: (SparseUnivariatePolynomial %, V) -> %
from PolynomialCategory(R, E, V)
multivariate: (SparseUnivariatePolynomial R, V) -> %
from PolynomialCategory(R, E, V)
mvar: % -> V
mvar(p) returns an error if p belongs to R, otherwise returns its main variable w. r. t. to the total ordering on the elements in V.
next_subResultant2: (%, %, %, %) -> % if R has IntegralDomain
next_subResultant2(p, q, z, s) is the multivariate version of the operation next_sousResultant2 from the PseudoRemainderSequence constructor.
normalized?: (%, %) -> Boolean
normalized?(a, b) returns true iff a and its iterated initials have degree zero w.r.t. the main variable of b
normalized?: (%, List %) -> Boolean
normalized?(q, lp) returns true iff normalized?(q, p) holds for every p in lp.
numberOfMonomials: % -> NonNegativeInteger
from FiniteAbelianMonoidRing(R, E)
one?: % -> Boolean
from MagmaWithUnit
opposite?: (%, %) -> Boolean
from AbelianMonoid
patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if V has PatternMatchable Float and R has PatternMatchable Float
from PatternMatchable Float
patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if V has PatternMatchable Integer and R has PatternMatchable Integer
from PatternMatchable Integer
pomopo!: (%, R, E, %) -> %
from FiniteAbelianMonoidRing(R, E)
pquo: (%, %) -> %
pquo(a, b) computes the pseudo-quotient of a by b, both viewed as univariate polynomials in the main variable of b.
pquo: (%, %, V) -> %
pquo(a, b, v) computes the pseudo-quotient of a by b, both viewed as univariate polynomials in v.
prem: (%, %) -> %
prem(a, b) computes the pseudo-remainder of a by b, both viewed as univariate polynomials in the main variable of b.
prem: (%, %, V) -> %
prem(a, b, v) computes the pseudo-remainder of a by b, both viewed as univariate polynomials in v.
prime?: % -> Boolean if R has PolynomialFactorizationExplicit
from UniqueFactorizationDomain
primitiveMonomials: % -> List %
from MaybeSkewPolynomialCategory(R, E, V)
primitivePart!: % -> % if R has GcdDomain
primitivePart!(p) replaces p by its primitive part.
primitivePart: % -> % if R has GcdDomain
from PolynomialCategory(R, E, V)
primitivePart: (%, V) -> % if R has GcdDomain
from PolynomialCategory(R, E, V)
primPartElseUnitCanonical!: % -> % if R has IntegralDomain
primPartElseUnitCanonical!(p) replaces p by primPartElseUnitCanonical(p).
primPartElseUnitCanonical: % -> % if R has IntegralDomain
primPartElseUnitCanonical(p) returns primitivePart(p) if R is a gcd-domain, otherwise unitCanonical(p).
pseudoDivide: (%, %) -> Record(quotient: %, remainder: %)
pseudoDivide(a, b) computes [pquo(a, b), prem(a, b)], both polynomials viewed as univariate polynomials in the main variable of b, if b is not a constant polynomial.
quasiMonic?: % -> Boolean
quasiMonic?(p) returns false if p belongs to R, otherwise returns true iff the initial of p lies in the base ring R.
recip: % -> Union(%, failed)
from MagmaWithUnit
reduced?: (%, %) -> Boolean
reduced?(a, b) returns true iff degree(a, mvar(b)) < mdeg(b).
reduced?: (%, List %) -> Boolean
reduced?(q, lp) returns true iff reduced?(q, p) holds for every p in lp.
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has LinearlyExplicitOver Integer
from LinearlyExplicitOver Integer
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)
from LinearlyExplicitOver R
reducedSystem: Matrix % -> Matrix Integer if R has LinearlyExplicitOver Integer
from LinearlyExplicitOver Integer
reducedSystem: Matrix % -> Matrix R
from LinearlyExplicitOver R
reductum: % -> %
from AbelianMonoidRing(R, E)
reductum: (%, V) -> %
reductum(p, v) returns the reductum of p, where p is viewed as a univariate polynomial in v.
resultant: (%, %) -> % if R has IntegralDomain
resultant(a, b) computes the resultant of a and b where a and b are assumed to have the same main variable v and are viewed as univariate polynomials in v.
resultant: (%, %, V) -> % if R has CommutativeRing
from PolynomialCategory(R, E, V)
retract: % -> Fraction Integer if R has RetractableTo Fraction Integer
from RetractableTo Fraction Integer
retract: % -> Integer if R has RetractableTo Integer
from RetractableTo Integer
retract: % -> R
from RetractableTo R
retract: % -> V
from RetractableTo V
retract: Polynomial Fraction Integer -> % if R has Algebra Fraction Integer and V has ConvertibleTo Symbol
retract(p) returns p as an element of the current domain, if retractIfCan(p) does not return “failed”, otherwise an error is produced.
retract: Polynomial Integer -> % if R has Algebra Integer and V has ConvertibleTo Symbol
retract(p) returns p as an element of the current domain, if retractIfCan(p) does not return “failed”, otherwise an error is produced.
retract: Polynomial R -> % if V has ConvertibleTo Symbol
retract(p) returns p as an element of the current domain, if retractIfCan(p) does not return “failed”, otherwise an error is produced.
retractIfCan: % -> Union(Fraction Integer, failed) if R has RetractableTo Fraction Integer
from RetractableTo Fraction Integer
retractIfCan: % -> Union(Integer, failed) if R has RetractableTo Integer
from RetractableTo Integer
retractIfCan: % -> Union(R, failed)
from RetractableTo R
retractIfCan: % -> Union(V, failed)
from RetractableTo V
retractIfCan: Polynomial Fraction Integer -> Union(%, failed) if R has Algebra Fraction Integer and V has ConvertibleTo Symbol
retractIfCan(p) returns p as an element of the current domain, if all its variables belong to V.
retractIfCan: Polynomial Integer -> Union(%, failed) if R has Algebra Integer and V has ConvertibleTo Symbol
retractIfCan(p) returns p as an element of the current domain, if all its variables belong to V.
retractIfCan: Polynomial R -> Union(%, failed) if V has ConvertibleTo Symbol
retractIfCan(p) returns p as an element of the current domain, if all its variables belong to V.
rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower: (%, PositiveInteger) -> %
from Magma
rightRecip: % -> Union(%, failed)
from MagmaWithUnit
RittWuCompare: (%, %) -> Union(Boolean, failed)
RittWuCompare(a,b) returns "failed" if a and b have same rank w.r.t. Ritt and Wu Wen Tsun ordering using the refinement of Lazard, otherwise returns infRittWu?(a, b).
sample: %
from AbelianMonoid
smaller?: (%, %) -> Boolean if R has Comparable
from Comparable
solveLinearPolynomialEquation: (List SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial %, failed) if R has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
squareFree: % -> Factored % if R has GcdDomain
from PolynomialCategory(R, E, V)
squareFreePart: % -> % if R has GcdDomain
from PolynomialCategory(R, E, V)
squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
subResultantChain: (%, %) -> List % if R has IntegralDomain
subResultantChain(a, b), where a and b are not constant polynomials with the same main variable, returns the subresultant chain of a and b.
subResultantGcd: (%, %) -> % if R has IntegralDomain
subResultantGcd(a, b) computes a gcd of a and b where a and b are assumed to have the same main variable v and are viewed as univariate polynomials in v with coefficients in the fraction field of the polynomial ring generated by their other variables over R.
subtractIfCan: (%, %) -> Union(%, failed)
from CancellationAbelianMonoid
supRittWu?: (%, %) -> Boolean
supRittWu?(a, b) returns true if a is greater than b w.r.t. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.
tail: % -> %
tail(p) returns its reductum, where p is viewed as a univariate polynomial in its main variable.
totalDegree: % -> NonNegativeInteger
from MaybeSkewPolynomialCategory(R, E, V)
totalDegree: (%, List V) -> NonNegativeInteger
from MaybeSkewPolynomialCategory(R, E, V)
totalDegreeSorted: (%, List V) -> NonNegativeInteger
from MaybeSkewPolynomialCategory(R, E, V)
unit?: % -> Boolean if R has EntireRing
from EntireRing
unitCanonical: % -> % if R has EntireRing
from EntireRing
unitNormal: % -> Record(unit: %, canonical: %, associate: %) if R has EntireRing
from EntireRing
univariate: % -> SparseUnivariatePolynomial R
from PolynomialCategory(R, E, V)
univariate: (%, V) -> SparseUnivariatePolynomial %
from PolynomialCategory(R, E, V)
variables: % -> List V
from MaybeSkewPolynomialCategory(R, E, V)
zero?: % -> Boolean
from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianMonoidRing(R, E)

AbelianSemiGroup

Algebra % if R has CommutativeRing

Algebra Fraction Integer if R has Algebra Fraction Integer

Algebra R if R has CommutativeRing

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer) if R has Algebra Fraction Integer

BiModule(R, R)

CancellationAbelianMonoid

canonicalUnitNormal if R has canonicalUnitNormal

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CoercibleTo OutputForm

CoercibleTo Polynomial R if V has ConvertibleTo Symbol

CommutativeRing if R has CommutativeRing

CommutativeStar if R has CommutativeRing

Comparable if R has Comparable

ConvertibleTo InputForm if R has ConvertibleTo InputForm and V has ConvertibleTo InputForm

ConvertibleTo Pattern Float if R has ConvertibleTo Pattern Float and V has ConvertibleTo Pattern Float

ConvertibleTo Pattern Integer if R has ConvertibleTo Pattern Integer and V has ConvertibleTo Pattern Integer

ConvertibleTo Polynomial R if V has ConvertibleTo Symbol

ConvertibleTo String if R has RetractableTo Integer and V has ConvertibleTo Symbol

EntireRing if R has EntireRing

Evalable %

FiniteAbelianMonoidRing(R, E)

FullyLinearlyExplicitOver R

FullyRetractableTo R

GcdDomain if R has GcdDomain

InnerEvalable(%, %)

InnerEvalable(V, %)

InnerEvalable(V, R)

IntegralDomain if R has IntegralDomain

LeftModule %

LeftModule Fraction Integer if R has Algebra Fraction Integer

LeftModule R

LeftOreRing if R has GcdDomain

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

LinearlyExplicitOver R

Magma

MagmaWithUnit

MaybeSkewPolynomialCategory(R, E, V)

Module % if R has CommutativeRing

Module Fraction Integer if R has Algebra Fraction Integer

Module R if R has CommutativeRing

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors if R has EntireRing

PartialDifferentialRing V

PatternMatchable Float if V has PatternMatchable Float and R has PatternMatchable Float

PatternMatchable Integer if V has PatternMatchable Integer and R has PatternMatchable Integer

PolynomialCategory(R, E, V)

PolynomialFactorizationExplicit if R has PolynomialFactorizationExplicit

RetractableTo Fraction Integer if R has RetractableTo Fraction Integer

RetractableTo Integer if R has RetractableTo Integer

RetractableTo R

RetractableTo V

RightModule %

RightModule Fraction Integer if R has Algebra Fraction Integer

RightModule R

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

UniqueFactorizationDomain if R has PolynomialFactorizationExplicit

unitsKnown

VariablesCommuteWithCoefficients