# RecursivePolynomialCategory(R, E, V)¶

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
*: (%, Integer) -> % if R has LinearlyExplicitOver Integer
*: (%, R) -> %

from RightModule R

*: (Fraction Integer, %) -> % if R has Algebra 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: (%, %) -> %
associates?: (%, %) -> Boolean if R has EntireRing

from EntireRing

associator: (%, %, %) -> %
binomThmExpt: (%, %, NonNegativeInteger) -> % if % has CommutativeRing

from FiniteAbelianMonoidRing(R, E)

characteristic: () -> NonNegativeInteger
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
coerce: % -> Polynomial R if V has ConvertibleTo Symbol
coerce: Fraction Integer -> % if R has Algebra Fraction Integer or R has RetractableTo Fraction Integer
coerce: Integer -> %
coerce: R -> %

from Algebra R

coerce: V -> %

from CoercibleFrom V

commutator: (%, %) -> %
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
convert: % -> Pattern Float if V has ConvertibleTo Pattern Float and R has ConvertibleTo Pattern Float
convert: % -> Pattern Integer if V has ConvertibleTo Pattern Integer and R has ConvertibleTo Pattern Integer
convert: % -> Polynomial R if V has ConvertibleTo Symbol
convert: % -> String if V has ConvertibleTo Symbol and R has RetractableTo Integer
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) -> %
D: (%, List V, List NonNegativeInteger) -> %
D: (%, V) -> %
D: (%, V, NonNegativeInteger) -> %
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) -> %
differentiate: (%, List V, List NonNegativeInteger) -> %
differentiate: (%, V) -> %
differentiate: (%, V, NonNegativeInteger) -> %
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: (%, %) -> % 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(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(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?(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

from IndexedProductCategory(R, E)

`leadingCoefficient(p, v)` returns the leading coefficient of `p`, where `p` is viewed as A univariate polynomial in `v`.

from IndexedProductCategory(R, 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
patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if R has PatternMatchable Integer and V has PatternMatchable Integer
plenaryPower: (%, PositiveInteger) -> % if R has CommutativeRing or R has Algebra Fraction 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
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
retract: % -> Integer if R has 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
retractIfCan: % -> Union(Integer, failed) if R has 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

AbelianGroup

AbelianMonoid

AbelianMonoidRing(R, E)

AbelianSemiGroup

Algebra % if R has CommutativeRing

Algebra R if R has CommutativeRing

BasicType

BiModule(%, %)

BiModule(R, R)

CancellationAbelianMonoid

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 String if V has ConvertibleTo Symbol and R has RetractableTo Integer

EntireRing if R has EntireRing

FiniteAbelianMonoidRing(R, E)

FreeModuleCategory(R, E)

GcdDomain if R has GcdDomain

Hashable if V has Hashable and R has Hashable

IndexedProductCategory(R, E)

InnerEvalable(%, %)

InnerEvalable(V, %)

InnerEvalable(V, R)

IntegralDomain if R has IntegralDomain

LeftOreRing if R has GcdDomain

Magma

MagmaWithUnit

MaybeSkewPolynomialCategory(R, E, V)

Module % if R has CommutativeRing

Module R if R has CommutativeRing

Monoid

NonAssociativeAlgebra % if R has CommutativeRing

NonAssociativeAlgebra R if R has CommutativeRing

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors if R has EntireRing

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

PolynomialCategory(R, E, V)

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip if R has CommutativeRing

unitsKnown

VariablesCommuteWithCoefficients