# RecursivePolynomialCategory(R, E, V)¶

newpoly.spad line 231 [edit on github]

R: Ring

V: OrderedSet

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)

- ^: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- ^: (%, PositiveInteger) -> %
from Magma

- annihilate?: (%, %) -> Boolean
from Rng

- antiCommutator: (%, %) -> %

- 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

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

- 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

- factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit

- factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit

- fmecg: (%, E, R, %) -> %
from FiniteAbelianMonoidRing(R, E)

- 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

- 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)`

.

- 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

- 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
- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)
from LinearlyExplicitOver R

- reducedSystem: Matrix % -> Matrix Integer if R has 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

- 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

- 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)

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

- 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

AbelianMonoidRing(R, E)

Algebra % if R has CommutativeRing

Algebra Fraction Integer if R has Algebra Fraction Integer

Algebra R if R has CommutativeRing

BiModule(%, %)

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

BiModule(R, R)

canonicalUnitNormal if R has canonicalUnitNormal

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CoercibleFrom Fraction Integer if R has RetractableTo Fraction Integer

CoercibleFrom Integer if R has RetractableTo Integer

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 V has ConvertibleTo InputForm and R has ConvertibleTo InputForm

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

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

ConvertibleTo Polynomial R if V has ConvertibleTo Symbol

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

EntireRing if R has EntireRing

Evalable %

FiniteAbelianMonoidRing(R, E)

FreeModuleCategory(R, E)

Hashable if V has Hashable and R has Hashable

IndexedDirectProductCategory(R, E)

IndexedProductCategory(R, E)

InnerEvalable(%, %)

InnerEvalable(V, %)

InnerEvalable(V, R)

IntegralDomain if R has IntegralDomain

LeftModule Fraction Integer if R has Algebra Fraction Integer

LeftOreRing if R has GcdDomain

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

MaybeSkewPolynomialCategory(R, E, V)

Module % if R has CommutativeRing

Module Fraction Integer if R has Algebra Fraction Integer

Module R if R has CommutativeRing

NonAssociativeAlgebra % if R has CommutativeRing

NonAssociativeAlgebra Fraction Integer if R has Algebra Fraction Integer

NonAssociativeAlgebra R if R has CommutativeRing

noZeroDivisors if R has EntireRing

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

PatternMatchable Integer if R has PatternMatchable Integer and V 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

RightModule Fraction Integer if R has Algebra Fraction Integer

RightModule Integer if R has LinearlyExplicitOver Integer

TwoSidedRecip if R has CommutativeRing

UniqueFactorizationDomain if R has PolynomialFactorizationExplicit