# RecursivePolynomialCategory(R, E, V)ΒΆ

- R: Ring
- E: OrderedAbelianMonoidSup
- 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 Magma
- *: (%, Fraction Integer) -> % if R has Algebra Fraction Integer
- from RightModule Fraction Integer
- *: (%, R) -> %
- from RightModule R
- *: (Fraction Integer, %) -> % if R has Algebra Fraction Integer
- from LeftModule Fraction Integer
- *: (Integer, %) -> %
- from AbelianGroup
- *: (NonNegativeInteger, %) -> %
- from AbelianMonoid
- *: (PositiveInteger, %) -> %
- from AbelianSemiGroup
- *: (R, %) -> %
- from LeftModule R
- +: (%, %) -> %
- from AbelianSemiGroup
- -: % -> %
- from AbelianGroup
- -: (%, %) -> %
- from AbelianGroup
- /: (%, R) -> % if R has Field
- from AbelianMonoidRing(R, E)
- =: (%, %) -> Boolean
- from BasicType
- ^: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- ^: (%, PositiveInteger) -> %
- from Magma
- ~=: (%, %) -> Boolean
- from BasicType
- annihilate?: (%, %) -> Boolean
- from Rng
- antiCommutator: (%, %) -> %
- from NonAssociativeSemiRng
- associates?: (%, %) -> Boolean if R has EntireRing
- from EntireRing
- associator: (%, %, %) -> %
- from NonAssociativeRng
- binomThmExpt: (%, %, NonNegativeInteger) -> % if % has CommutativeRing
- from FiniteAbelianMonoidRing(R, E)
- characteristic: () -> NonNegativeInteger
- from NonAssociativeRing
- charthRoot: % -> Union(%, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit or R has CharacteristicNonZero
- from PolynomialFactorizationExplicit
- coefficient: (%, E) -> R
- from AbelianMonoidRing(R, E)
- coefficient: (%, List V, List NonNegativeInteger) -> %
- from MaybeSkewPolynomialCategory(R, E, V)
- coefficient: (%, V, NonNegativeInteger) -> %
- from MaybeSkewPolynomialCategory(R, E, V)
- coefficients: % -> List R
- from FiniteAbelianMonoidRing(R, E)
- coerce: % -> % if R has CommutativeRing
- from Algebra %
- coerce: % -> OutputForm
- from CoercibleTo OutputForm
- coerce: % -> Polynomial R if V has ConvertibleTo Symbol
- from CoercibleTo Polynomial R
- coerce: Fraction Integer -> % if R has Algebra Fraction Integer or R has RetractableTo Fraction Integer
- from Algebra Fraction Integer
- coerce: Integer -> %
- from NonAssociativeRing
- coerce: R -> %
- from Algebra R
- coerce: V -> %
- from RetractableTo V
- commutator: (%, %) -> %
- from NonAssociativeRng
- conditionP: Matrix % -> Union(Vector %, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit
- from PolynomialFactorizationExplicit
- content: % -> R if R has GcdDomain
- from FiniteAbelianMonoidRing(R, E)
- content: (%, V) -> % if R has GcdDomain
- from PolynomialCategory(R, E, V)
- convert: % -> InputForm if R has ConvertibleTo InputForm and V has ConvertibleTo InputForm
- from ConvertibleTo InputForm
- convert: % -> Pattern Float if R has ConvertibleTo Pattern Float and V has ConvertibleTo Pattern Float
- from ConvertibleTo Pattern Float
- convert: % -> Pattern Integer if R has ConvertibleTo Pattern Integer and V has ConvertibleTo Pattern Integer
- from ConvertibleTo Pattern Integer
- convert: % -> Polynomial R if V has ConvertibleTo Symbol
- from ConvertibleTo Polynomial R
- convert: % -> String if R has RetractableTo Integer and V has ConvertibleTo Symbol
- from ConvertibleTo String

- convert: Polynomial Fraction Integer -> % if R has Algebra Fraction Integer and V has ConvertibleTo Symbol
`convert(p)`

returns the same as`retract(p)`

.

- convert: Polynomial Integer -> % if R has Algebra Integer and V has ConvertibleTo Symbol
`convert(p)`

returns the same as`retract(p)`

.

- convert: Polynomial R -> % if V has ConvertibleTo Symbol
`convert(p)`

returns the same as`retract(p)`

.- D: (%, List V) -> %
- from PartialDifferentialRing V
- D: (%, List V, List NonNegativeInteger) -> %
- from PartialDifferentialRing V
- D: (%, V) -> %
- from PartialDifferentialRing V
- D: (%, V, NonNegativeInteger) -> %
- from PartialDifferentialRing V

- deepestInitial: % -> %
`deepestInitial(p)`

returns an error if`p`

belongs to`R`

, otherwise returns the last term of`iteratedInitials(p)`

.

- deepestTail: % -> %
`deepestTail(p)`

returns`0`

if`p`

belongs to`R`

, otherwise returns tail(`p`

), if`tail(p)`

belongs to`R`

or`mvar(tail(p)) < mvar(p)`

, otherwise returns`deepestTail(tail(p))`

.- degree: % -> E
- from AbelianMonoidRing(R, E)
- degree: (%, List V) -> List NonNegativeInteger
- from MaybeSkewPolynomialCategory(R, E, V)
- degree: (%, V) -> NonNegativeInteger
- from MaybeSkewPolynomialCategory(R, E, V)
- differentiate: (%, List V) -> %
- from PartialDifferentialRing V
- differentiate: (%, List V, List NonNegativeInteger) -> %
- from PartialDifferentialRing V
- differentiate: (%, V) -> %
- from PartialDifferentialRing V
- differentiate: (%, V, NonNegativeInteger) -> %
- from PartialDifferentialRing V
- discriminant: (%, V) -> % if R has CommutativeRing
- from PolynomialCategory(R, E, V)
- eval: (%, %, %) -> %
- from InnerEvalable(%, %)
- eval: (%, Equation %) -> %
- from Evalable %
- eval: (%, List %, List %) -> %
- from InnerEvalable(%, %)
- eval: (%, List Equation %) -> %
- from Evalable %
- eval: (%, List V, List %) -> %
- from InnerEvalable(V, %)
- eval: (%, List V, List R) -> %
- from InnerEvalable(V, R)
- eval: (%, V, %) -> %
- from InnerEvalable(V, %)
- eval: (%, V, R) -> %
- from InnerEvalable(V, R)

- exactQuotient!: (%, %) -> % if R has IntegralDomain
`exactQuotient!(a, b)`

replaces`a`

by`exactQuotient(a, b)`

- exactQuotient!: (%, R) -> % if R has IntegralDomain
`exactQuotient!(p, r)`

replaces`p`

by`exactQuotient(p, r)`

.

- exactQuotient: (%, %) -> % if R has IntegralDomain
`exactQuotient(a, b)`

computes the exact quotient of`a`

by`b`

, which is assumed to be a divisor of`a`

. No error is returned if this exact quotient fails!

- exactQuotient: (%, R) -> % if R has IntegralDomain
`exactQuotient(p, r)`

computes the exact quotient of`p`

by`r`

, which is assumed to be a divisor of`p`

. No error is returned if this exact quotient fails!- exquo: (%, %) -> Union(%, failed) if R has EntireRing
- from EntireRing
- exquo: (%, R) -> Union(%, failed) if R has EntireRing
- from FiniteAbelianMonoidRing(R, E)

- extendedSubResultantGcd: (%, %) -> Record(gcd: %, coef1: %, coef2: %) if R has IntegralDomain
`extendedSubResultantGcd(a, b)`

returns`[ca, cb, r]`

such that`r`

is`subResultantGcd(a, b)`

and we have`ca * a + cb * cb = r`

.- factor: % -> Factored % if R has PolynomialFactorizationExplicit
- from UniqueFactorizationDomain
- factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
- from PolynomialFactorizationExplicit
- factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
- from PolynomialFactorizationExplicit
- fmecg: (%, E, R, %) -> %
- from FiniteAbelianMonoidRing(R, E)
- gcd: (%, %) -> % if R has GcdDomain
- from GcdDomain

- gcd: (R, %) -> R if R has GcdDomain
`gcd(r, p)`

returns the`gcd`

of`r`

and the content of`p`

.- gcd: List % -> % if R has GcdDomain
- from GcdDomain
- gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial % if R has GcdDomain
- from PolynomialFactorizationExplicit
- ground: % -> R
- from FiniteAbelianMonoidRing(R, E)
- ground?: % -> Boolean
- from FiniteAbelianMonoidRing(R, E)

- halfExtendedSubResultantGcd1: (%, %) -> Record(gcd: %, coef1: %) if R has IntegralDomain
`halfExtendedSubResultantGcd1(a, b)`

returns`[g, ca]`

if`extendedSubResultantGcd(a, b)`

returns`[g, ca, cb]`

otherwise produces an error.

- halfExtendedSubResultantGcd2: (%, %) -> Record(gcd: %, coef2: %) if R has IntegralDomain
`halfExtendedSubResultantGcd2(a, b)`

returns`[g, cb]`

if`extendedSubResultantGcd(a, b)`

returns`[g, ca, cb]`

otherwise produces an error.- hash: % -> SingleInteger
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState
- from SetCategory

- head: % -> %
`head(p)`

returns`p`

if`p`

belongs to`R`

, otherwise returns its leading term (monomial in the FriCAS sense), where`p`

is viewed as a univariate polynomial in its main variable.

- headReduce: (%, %) -> %
`headReduce(a, b)`

returns a polynomial`r`

such that`headReduced?(r, b)`

holds and there exists an integer`e`

such that`init(b)^e a - r`

is zero modulo`b`

.

- headReduced?: (%, %) -> Boolean
`headReduced?(a, b)`

returns`true`

iff`degree(head(a), mvar(b)) < mdeg(b)`

.

- headReduced?: (%, List %) -> Boolean
`headReduced?(q, lp)`

returns`true`

iff`headReduced?(q, p)`

holds for every`p`

in`lp`

.

- iexactQuo: (R, R) -> R if R has IntegralDomain
`iexactQuo(x, y)`

should be local but conditional

- infRittWu?: (%, %) -> Boolean
`infRittWu?(a, b)`

returns`true`

if`a`

is less than`b`

`w`

.`r`

.`t`

. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.

- init: % -> %
`init(p)`

returns an error if`p`

belongs to`R`

, otherwise returns its leading coefficient, where`p`

is viewed as a univariate polynomial in its main variable.

- initiallyReduce: (%, %) -> %
`initiallyReduce(a, b)`

returns a polynomial`r`

such that`initiallyReduced?(r, b)`

holds and there exists an integer`e`

such that`init(b)^e a - r`

is zero modulo`b`

.

- initiallyReduced?: (%, %) -> Boolean
`initiallyReduced?(a, b)`

returns`false`

iff there exists an iterated initial of`a`

which is not reduced`w`

.`r`

.`t`

`b`

.

- initiallyReduced?: (%, List %) -> Boolean
`initiallyReduced?(q, lp)`

returns`true`

iff`initiallyReduced?(q, p)`

holds for every`p`

in`lp`

.- isExpt: % -> Union(Record(var: V, exponent: NonNegativeInteger), failed)
- from PolynomialCategory(R, E, V)
- isPlus: % -> Union(List %, failed)
- from PolynomialCategory(R, E, V)
- isTimes: % -> Union(List %, failed)
- from PolynomialCategory(R, E, V)

- iteratedInitials: % -> List %
`iteratedInitials(p)`

returns`[]`

if`p`

belongs to`R`

, otherwise returns the list of the iterated initials of`p`

.

- lastSubResultant: (%, %) -> % if R has IntegralDomain
`lastSubResultant(a, b)`

returns the last non-zero subresultant of`a`

and`b`

where`a`

and`b`

are assumed to have the same main variable`v`

and are viewed as univariate polynomials in`v`

.- latex: % -> String
- from SetCategory

- LazardQuotient2: (%, %, %, NonNegativeInteger) -> % if R has IntegralDomain
`LazardQuotient2(p, a, b, n)`

returns`(a^(n-1) * p) exquo b^(n-1)`

assuming that this quotient does not fail.

- LazardQuotient: (%, %, NonNegativeInteger) -> % if R has IntegralDomain
`LazardQuotient(a, b, n)`

returns`a^n exquo b^(n-1)`

assuming that this quotient does not fail.

- lazyPquo: (%, %) -> %
`lazyPquo(a, b)`

returns the polynomial`q`

such that`lazyPseudoDivide(a, b)`

returns`[c, g, q, r]`

.

- lazyPquo: (%, %, V) -> %
`lazyPquo(a, b, v)`

returns the polynomial`q`

such that`lazyPseudoDivide(a, b, v)`

returns`[c, g, q, r]`

.

- lazyPrem: (%, %) -> %
`lazyPrem(a, b)`

returns the polynomial`r`

reduced`w`

.`r`

.`t`

.`b`

and such that`b`

divides`init(b)^e a - r`

where`e`

is the number of steps of this pseudo-division.

- lazyPrem: (%, %, V) -> %
`lazyPrem(a, b, v)`

returns the polynomial`r`

reduced`w`

.`r`

.`t`

.`b`

viewed as univariate polynomials in the variable`v`

such that`b`

divides`init(b)^e a - r`

where`e`

is the number of steps of this pseudo-division.

- lazyPremWithDefault: (%, %) -> Record(coef: %, gap: NonNegativeInteger, remainder: %)
`lazyPremWithDefault(a, b)`

returns`[c, g, r]`

such that`r = lazyPrem(a, b)`

and`(c^g)*r = prem(a, b)`

.

- lazyPremWithDefault: (%, %, V) -> Record(coef: %, gap: NonNegativeInteger, remainder: %)
`lazyPremWithDefault(a, b, v)`

returns`[c, g, r]`

such that`r = lazyPrem(a, b, v)`

and`(c^g)*r = prem(a, b, v)`

.

- lazyPseudoDivide: (%, %) -> Record(coef: %, gap: NonNegativeInteger, quotient: %, remainder: %)
`lazyPseudoDivide(a, b)`

returns`[c, g, q, r]`

such that`[c, g, r] = lazyPremWithDefault(a, b)`

and`q`

is the pseudo-quotient computed in this lazy pseudo-division.

- lazyPseudoDivide: (%, %, V) -> Record(coef: %, gap: NonNegativeInteger, quotient: %, remainder: %)
`lazyPseudoDivide(a, b, v)`

returns`[c, g, q, r]`

such that`r = lazyPrem(a, b, v)`

,`(c^g)*r = prem(a, b, v)`

and`q`

is the pseudo-quotient computed in this lazy pseudo-division.

- lazyResidueClass: (%, %) -> Record(polnum: %, polden: %, power: NonNegativeInteger)
`lazyResidueClass(a, b)`

returns`[p, q, n]`

where`p / q^n`

represents the residue class of`a`

modulo`b`

and`p`

is reduced`w`

.`r`

.`t`

.`b`

and`q`

is`init(b)`

.- lcm: (%, %) -> % if R has GcdDomain
- from GcdDomain
- lcm: List % -> % if R has GcdDomain
- from GcdDomain
- lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %) if R has GcdDomain
- from LeftOreRing
- leadingCoefficient: % -> R
- from AbelianMonoidRing(R, E)

- leadingCoefficient: (%, V) -> %
`leadingCoefficient(p, v)`

returns the leading coefficient of`p`

, where`p`

is viewed as A univariate polynomial in`v`

.- leadingMonomial: % -> %
- from AbelianMonoidRing(R, E)

- leastMonomial: % -> %
`leastMonomial(p)`

returns an error if`p`

is`O`

, otherwise, if`p`

belongs to`R`

returns`1`

, otherwise, the monomial of`p`

with lowest degree, where`p`

is viewed as a univariate polynomial in its main variable.- leftPower: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- leftPower: (%, PositiveInteger) -> %
- from Magma
- leftRecip: % -> Union(%, failed)
- from MagmaWithUnit

- mainCoefficients: % -> List %
`mainCoefficients(p)`

returns an error if`p`

is`O`

, otherwise, if`p`

belongs to`R`

returns [`p`

], otherwise returns the list of the coefficients of`p`

, where`p`

is viewed as a univariate polynomial in its main variable.

- mainContent: % -> % if R has GcdDomain
`mainContent(p)`

returns the content of`p`

viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over`R`

.

- mainMonomial: % -> %
`mainMonomial(p)`

returns an error if`p`

is`O`

, otherwise, if`p`

belongs to`R`

returns`1`

, otherwise,`mvar(p)`

raised to the power`mdeg(p)`

.

- mainMonomials: % -> List %
`mainMonomials(p)`

returns an error if`p`

is`O`

, otherwise, if`p`

belongs to`R`

returns [1], otherwise returns the list of the monomials of`p`

, where`p`

is viewed as a univariate polynomial in its main variable.

- mainPrimitivePart: % -> % if R has GcdDomain
`mainPrimitivePart(p)`

returns the primitive part of`p`

viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over`R`

.

- mainSquareFreePart: % -> % if R has GcdDomain
`mainSquareFreePart(p)`

returns the square free part of`p`

viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over`R`

.- mainVariable: % -> Union(V, failed)
- from MaybeSkewPolynomialCategory(R, E, V)
- map: (R -> R, %) -> %
- from AbelianMonoidRing(R, E)
- mapExponents: (E -> E, %) -> %
- from FiniteAbelianMonoidRing(R, E)

- mdeg: % -> NonNegativeInteger
`mdeg(p)`

returns an error if`p`

is`0`

, otherwise, if`p`

belongs to`R`

returns`0`

, otherwise, returns the degree of`p`

in its main variable.- minimumDegree: % -> E
- from FiniteAbelianMonoidRing(R, E)
- minimumDegree: (%, List V) -> List NonNegativeInteger
- from PolynomialCategory(R, E, V)
- minimumDegree: (%, V) -> NonNegativeInteger
- from PolynomialCategory(R, E, V)

- monic?: % -> Boolean
`monic?(p)`

returns`false`

if`p`

belongs to`R`

, otherwise returns`true`

iff`p`

is monic as a univariate polynomial in its main variable.- monicDivide: (%, %, V) -> Record(quotient: %, remainder: %)
- from PolynomialCategory(R, E, V)

- monicModulo: (%, %) -> %
`monicModulo(a, b)`

computes`a mod b`

, if`b`

is monic as univariate polynomial in its main variable.- monomial: (%, List V, List NonNegativeInteger) -> %
- from MaybeSkewPolynomialCategory(R, E, V)
- monomial: (%, V, NonNegativeInteger) -> %
- from MaybeSkewPolynomialCategory(R, E, V)
- monomial: (R, E) -> %
- from AbelianMonoidRing(R, E)
- monomial?: % -> Boolean
- from AbelianMonoidRing(R, E)
- monomials: % -> List %
- from MaybeSkewPolynomialCategory(R, E, V)
- multivariate: (SparseUnivariatePolynomial %, V) -> %
- from PolynomialCategory(R, E, V)
- multivariate: (SparseUnivariatePolynomial R, V) -> %
- from PolynomialCategory(R, E, V)

- mvar: % -> V
`mvar(p)`

returns an error if`p`

belongs to`R`

, otherwise returns its main variable`w`

.`r`

.`t`

. to the total ordering on the elements in`V`

.

- next_subResultant2: (%, %, %, %) -> % if R has IntegralDomain
`next_subResultant2(p, q, z, s)`

is the multivariate version of the operation next_sousResultant2 from the PseudoRemainderSequence constructor.

- normalized?: (%, %) -> Boolean
`normalized?(a, b)`

returns`true`

iff`a`

and its iterated initials have degree zero`w`

.`r`

.`t`

. the main variable of`b`

- normalized?: (%, List %) -> Boolean
`normalized?(q, lp)`

returns`true`

iff`normalized?(q, p)`

holds for every`p`

in`lp`

.- numberOfMonomials: % -> NonNegativeInteger
- from FiniteAbelianMonoidRing(R, E)
- one?: % -> Boolean
- from MagmaWithUnit
- opposite?: (%, %) -> Boolean
- from AbelianMonoid
- patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if V has PatternMatchable Float and R has PatternMatchable Float
- from PatternMatchable Float
- patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if V has PatternMatchable Integer and R has PatternMatchable Integer
- from PatternMatchable Integer
- pomopo!: (%, R, E, %) -> %
- from FiniteAbelianMonoidRing(R, E)

- pquo: (%, %) -> %
`pquo(a, b)`

computes the pseudo-quotient of`a`

by`b`

, both viewed as univariate polynomials in the main variable of`b`

.

- pquo: (%, %, V) -> %
`pquo(a, b, v)`

computes the pseudo-quotient of`a`

by`b`

, both viewed as univariate polynomials in`v`

.

- prem: (%, %) -> %
`prem(a, b)`

computes the pseudo-remainder of`a`

by`b`

, both viewed as univariate polynomials in the main variable of`b`

.

- prem: (%, %, V) -> %
`prem(a, b, v)`

computes the pseudo-remainder of`a`

by`b`

, both viewed as univariate polynomials in`v`

.- prime?: % -> Boolean if R has PolynomialFactorizationExplicit
- from UniqueFactorizationDomain
- primitiveMonomials: % -> List %
- from MaybeSkewPolynomialCategory(R, E, V)

- primitivePart!: % -> % if R has GcdDomain
`primitivePart!(p)`

replaces`p`

by its primitive part.- primitivePart: % -> % if R has GcdDomain
- from PolynomialCategory(R, E, V)
- primitivePart: (%, V) -> % if R has GcdDomain
- from PolynomialCategory(R, E, V)

- primPartElseUnitCanonical!: % -> % if R has IntegralDomain
`primPartElseUnitCanonical!(p)`

replaces`p`

by`primPartElseUnitCanonical(p)`

.

- primPartElseUnitCanonical: % -> % if R has IntegralDomain
`primPartElseUnitCanonical(p)`

returns`primitivePart(p)`

if`R`

is a`gcd`

-domain, otherwise`unitCanonical(p)`

.

- pseudoDivide: (%, %) -> Record(quotient: %, remainder: %)
`pseudoDivide(a, b)`

computes`[pquo(a, b), prem(a, b)]`

, both polynomials viewed as univariate polynomials in the main variable of`b`

, if`b`

is not a constant polynomial.

- quasiMonic?: % -> Boolean
`quasiMonic?(p)`

returns`false`

if`p`

belongs to`R`

, otherwise returns`true`

iff the initial of`p`

lies in the base ring`R`

.- recip: % -> Union(%, failed)
- from MagmaWithUnit

- reduced?: (%, %) -> Boolean
`reduced?(a, b)`

returns`true`

iff`degree(a, mvar(b)) < mdeg(b)`

.

- reduced?: (%, List %) -> Boolean
`reduced?(q, lp)`

returns`true`

iff`reduced?(q, p)`

holds for every`p`

in`lp`

.- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has LinearlyExplicitOver Integer
- from LinearlyExplicitOver Integer
- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)
- from LinearlyExplicitOver R
- reducedSystem: Matrix % -> Matrix Integer if R has LinearlyExplicitOver Integer
- from LinearlyExplicitOver Integer
- reducedSystem: Matrix % -> Matrix R
- from LinearlyExplicitOver R
- reductum: % -> %
- from AbelianMonoidRing(R, E)

- reductum: (%, V) -> %
`reductum(p, v)`

returns the reductum of`p`

, where`p`

is viewed as a univariate polynomial in`v`

.

- resultant: (%, %) -> % if R has IntegralDomain
`resultant(a, b)`

computes the resultant of`a`

and`b`

where`a`

and`b`

are assumed to have the same main variable`v`

and are viewed as univariate polynomials in`v`

.- resultant: (%, %, V) -> % if R has CommutativeRing
- from PolynomialCategory(R, E, V)
- retract: % -> Fraction Integer if R has RetractableTo Fraction Integer
- from RetractableTo Fraction Integer
- retract: % -> Integer if R has RetractableTo Integer
- from RetractableTo Integer
- retract: % -> R
- from RetractableTo R
- retract: % -> V
- from RetractableTo V

- retract: Polynomial Fraction Integer -> % if R has Algebra Fraction Integer and V has ConvertibleTo Symbol
`retract(p)`

returns`p`

as an element of the current domain, if`retractIfCan(p)`

does not return “failed”, otherwise an error is produced.

- retract: Polynomial Integer -> % if R has Algebra Integer and V has ConvertibleTo Symbol
`retract(p)`

returns`p`

as an element of the current domain, if`retractIfCan(p)`

does not return “failed”, otherwise an error is produced.

- retract: Polynomial R -> % if V has ConvertibleTo Symbol
`retract(p)`

returns`p`

as an element of the current domain, if`retractIfCan(p)`

does not return “failed”, otherwise an error is produced.- retractIfCan: % -> Union(Fraction Integer, failed) if R has RetractableTo Fraction Integer
- from RetractableTo Fraction Integer
- retractIfCan: % -> Union(Integer, failed) if R has RetractableTo Integer
- from RetractableTo Integer
- retractIfCan: % -> Union(R, failed)
- from RetractableTo R
- retractIfCan: % -> Union(V, failed)
- from RetractableTo V

- retractIfCan: Polynomial Fraction Integer -> Union(%, failed) if R has Algebra Fraction Integer and V has ConvertibleTo Symbol
`retractIfCan(p)`

returns`p`

as an element of the current domain, if all its variables belong to`V`

.

- retractIfCan: Polynomial Integer -> Union(%, failed) if R has Algebra Integer and V has ConvertibleTo Symbol
`retractIfCan(p)`

returns`p`

as an element of the current domain, if all its variables belong to`V`

.

- retractIfCan: Polynomial R -> Union(%, failed) if V has ConvertibleTo Symbol
`retractIfCan(p)`

returns`p`

as an element of the current domain, if all its variables belong to`V`

.- rightPower: (%, NonNegativeInteger) -> %
- from MagmaWithUnit
- rightPower: (%, PositiveInteger) -> %
- from Magma
- rightRecip: % -> Union(%, failed)
- from MagmaWithUnit

- RittWuCompare: (%, %) -> Union(Boolean, failed)
`RittWuCompare(a,b)`

returns`"failed"`

if`a`

and`b`

have same rank`w`

.`r`

.`t`

. Ritt and Wu Wen Tsun ordering using the refinement of Lazard, otherwise returns`infRittWu?(a, b)`

.- sample: %
- from AbelianMonoid
- smaller?: (%, %) -> Boolean if R has Comparable
- from Comparable
- solveLinearPolynomialEquation: (List SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial %, failed) if R has PolynomialFactorizationExplicit
- from PolynomialFactorizationExplicit
- squareFree: % -> Factored % if R has GcdDomain
- from PolynomialCategory(R, E, V)
- squareFreePart: % -> % if R has GcdDomain
- from PolynomialCategory(R, E, V)
- squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
- from PolynomialFactorizationExplicit

- subResultantChain: (%, %) -> List % if R has IntegralDomain
`subResultantChain(a, b)`

, where`a`

and`b`

are not constant polynomials with the same main variable, returns the subresultant chain of`a`

and`b`

.

- subResultantGcd: (%, %) -> % if R has IntegralDomain
`subResultantGcd(a, b)`

computes a`gcd`

of`a`

and`b`

where`a`

and`b`

are assumed to have the same main variable`v`

and are viewed as univariate polynomials in`v`

with coefficients in the fraction field of the polynomial ring generated by their other variables over`R`

.- subtractIfCan: (%, %) -> Union(%, failed)
- from CancellationAbelianMonoid

- supRittWu?: (%, %) -> Boolean
`supRittWu?(a, b)`

returns`true`

if`a`

is greater than`b`

`w`

.`r`

.`t`

. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.

- tail: % -> %
`tail(p)`

returns its reductum, where`p`

is viewed as a univariate polynomial in its main variable.- totalDegree: % -> NonNegativeInteger
- from MaybeSkewPolynomialCategory(R, E, V)
- totalDegree: (%, List V) -> NonNegativeInteger
- from MaybeSkewPolynomialCategory(R, E, V)
- totalDegreeSorted: (%, List V) -> NonNegativeInteger
- from MaybeSkewPolynomialCategory(R, E, V)
- unit?: % -> Boolean if R has EntireRing
- from EntireRing
- unitCanonical: % -> % if R has EntireRing
- from EntireRing
- unitNormal: % -> Record(unit: %, canonical: %, associate: %) if R has EntireRing
- from EntireRing
- univariate: % -> SparseUnivariatePolynomial R
- from PolynomialCategory(R, E, V)
- univariate: (%, V) -> SparseUnivariatePolynomial %
- from PolynomialCategory(R, E, V)
- variables: % -> List V
- from MaybeSkewPolynomialCategory(R, E, V)
- zero?: % -> Boolean
- from AbelianMonoid

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

CoercibleTo Polynomial R if V has ConvertibleTo Symbol

CommutativeRing if R has CommutativeRing

CommutativeStar if R has CommutativeRing

Comparable if R has Comparable

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

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

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

ConvertibleTo Polynomial R if V has ConvertibleTo Symbol

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

EntireRing if R has EntireRing

Evalable %

FiniteAbelianMonoidRing(R, E)

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

noZeroDivisors if R has EntireRing

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

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

PolynomialCategory(R, E, V)

PolynomialFactorizationExplicit if R has PolynomialFactorizationExplicit

RetractableTo Fraction Integer if R has RetractableTo Fraction Integer

RetractableTo Integer if R has RetractableTo Integer

RightModule Fraction Integer if R has Algebra Fraction Integer

UniqueFactorizationDomain if R has PolynomialFactorizationExplicit