RecursivePolynomialCategory(R, E, V)¶

newpoly.spad line 231 [edit on github]

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 LeftModule %
*: (%, Fraction Integer) -> % if R has Algebra Fraction Integer: from RightModule Fraction Integer
*: (%, Integer) -> % if R has LinearlyExplicitOver Integer: from RightModule 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 R has CharacteristicNonZero or % has CharacteristicNonZero and R has PolynomialFactorizationExplicit: from CharacteristicNonZero

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 FreeModuleCategory(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 CoercibleFrom V

commutator: (%, %) -> %: from NonAssociativeRng

conditionP: Matrix % -> Union(Vector %, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit: from PolynomialFactorizationExplicit

construct: List Record(k: E, c: R) -> %: from IndexedProductCategory(R, E)

constructOrdered: List Record(k: E, c: R) -> %: from IndexedProductCategory(R, E)

content: % -> R if R has GcdDomain: from FiniteAbelianMonoidRing(R, E)
content: (%, V) -> % if R has GcdDomain: from PolynomialCategory(R, E, V)

convert: % -> InputForm if V has ConvertibleTo InputForm and R has ConvertibleTo InputForm: from ConvertibleTo InputForm
convert: % -> Pattern Float if V has ConvertibleTo Pattern Float and R has ConvertibleTo Pattern Float: from ConvertibleTo Pattern Float
convert: % -> Pattern Integer if V has ConvertibleTo Pattern Integer and R has ConvertibleTo Pattern Integer: from ConvertibleTo Pattern Integer
convert: % -> Polynomial R if V has ConvertibleTo Symbol: from ConvertibleTo Polynomial R
convert: % -> String if V has ConvertibleTo Symbol and R has RetractableTo Integer: 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 [g, ca, cb] such that g is subResultantGcd(a, b) and we have ca * a + cb * cb = g.

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 GcdDomain

ground?: % -> Boolean: from FiniteAbelianMonoidRing(R, E)

ground: % -> R: 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 if V has Hashable and R has Hashable: from Hashable

hashUpdate!: (HashState, %) -> HashState if V has Hashable and R has Hashable: from Hashable

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 IndexedProductCategory(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 IndexedProductCategory(R, E)

leadingSupport: % -> E: from IndexedProductCategory(R, E)

leadingTerm: % -> Record(k: E, c: R): from IndexedProductCategory(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

linearExtend: (E -> R, %) -> R if R has CommutativeRing: from FreeModuleCategory(R, E)

listOfTerms: % -> List Record(k: E, c: R): from IndexedDirectProductCategory(R, E)

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 IndexedProductCategory(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?: % -> Boolean: from IndexedProductCategory(R, E)

monomial: (%, List V, List NonNegativeInteger) -> %: from MaybeSkewPolynomialCategory(R, E, V)
monomial: (%, V, NonNegativeInteger) -> %: from MaybeSkewPolynomialCategory(R, E, V)
monomial: (R, E) -> %: from IndexedProductCategory(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`\ <l50736575646f52656d61696e64657253657175656e6365-5c2060606e6578745f736f7573526573756c74616e743260605c20>` 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 IndexedDirectProductCategory(R, E)

one?: % -> Boolean: from MagmaWithUnit

opposite?: (%, %) -> Boolean: from AbelianMonoid

patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if R has PatternMatchable Float and V has PatternMatchable Float: from PatternMatchable Float
patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if R has PatternMatchable Integer and V has PatternMatchable Integer: from PatternMatchable Integer

plenaryPower: (%, PositiveInteger) -> % if R has CommutativeRing or R has Algebra Fraction Integer: from NonAssociativeAlgebra %

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 IndexedProductCategory(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

support: % -> List E: from FreeModuleCategory(R, E)

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.