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
*: (%, 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

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

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?: (%, 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 , 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
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

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

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