RecursivePolynomialCategory(R, E, V)

newpoly.spad line 231 [edit on github]

A category for general multi-variate polynomials with coefficients in a ring, variables in an ordered set, and exponents from an ordered abelian monoid, with a sup operation. When not constant, such a polynomial is viewed as a univariate polynomial in its main variable w. r. t. to the total ordering on the elements in the ordered set, so that some operations usually defined for univariate polynomials make sense here.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from Magma

*: (%, Fraction Integer) -> % if R has Algebra Fraction Integer

from RightModule Fraction Integer

*: (%, Integer) -> % if R has LinearlyExplicitOver Integer

from RightModule Integer

*: (%, R) -> %

from RightModule R

*: (Fraction Integer, %) -> % if R has Algebra Fraction Integer

from LeftModule Fraction Integer

*: (Integer, %) -> %

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

*: (R, %) -> %

from LeftModule R

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, R) -> % if R has Field

from AbelianMonoidRing(R, E)

=: (%, %) -> Boolean

from BasicType

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %

from NonAssociativeSemiRng

associates?: (%, %) -> Boolean if R has EntireRing

from EntireRing

associator: (%, %, %) -> %

from NonAssociativeRng

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

from FiniteAbelianMonoidRing(R, E)

characteristic: () -> NonNegativeInteger

from NonAssociativeRing

charthRoot: % -> Union(%, failed) if % 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 FreeModuleCategory(R, E)

coerce: % -> % if R has CommutativeRing

from Algebra %

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: % -> Polynomial R if V has ConvertibleTo Symbol

from CoercibleTo Polynomial R

coerce: Fraction Integer -> % if R has Algebra Fraction Integer or R has RetractableTo Fraction Integer

from Algebra Fraction Integer

coerce: Integer -> %

from NonAssociativeRing

coerce: R -> %

from Algebra R

coerce: V -> %

from CoercibleFrom V

commutator: (%, %) -> %

from NonAssociativeRng

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

from PolynomialFactorizationExplicit

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

from IndexedProductCategory(R, E)

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

from IndexedProductCategory(R, E)

content: % -> R if R has GcdDomain

from FiniteAbelianMonoidRing(R, E)

content: (%, V) -> % if R has GcdDomain

from PolynomialCategory(R, E, V)

convert: % -> InputForm if V has ConvertibleTo InputForm and R has ConvertibleTo InputForm

from ConvertibleTo InputForm

convert: % -> Pattern Float if V has ConvertibleTo Pattern Float and R has ConvertibleTo Pattern Float

from ConvertibleTo Pattern Float

convert: % -> Pattern Integer if V has ConvertibleTo Pattern Integer and R has ConvertibleTo Pattern Integer

from ConvertibleTo Pattern Integer

convert: % -> Polynomial R if V has ConvertibleTo Symbol

from ConvertibleTo Polynomial R

convert: % -> String if V has ConvertibleTo Symbol and R has RetractableTo Integer

from ConvertibleTo String

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

convert(p) returns the same as retract(p).

convert: Polynomial Integer -> % if R has Algebra Integer and V has ConvertibleTo Symbol

convert(p) returns the same as retract(p).

convert: Polynomial R -> % if V has ConvertibleTo Symbol

convert(p) returns the same as retract(p).

D: (%, List V) -> %

from PartialDifferentialRing V

D: (%, List V, List NonNegativeInteger) -> %

from PartialDifferentialRing V

D: (%, V) -> %

from PartialDifferentialRing V

D: (%, V, NonNegativeInteger) -> %

from PartialDifferentialRing V

deepestInitial: % -> %

deepestInitial(p) returns an error if p belongs to R, otherwise returns the last term of iteratedInitials(p).

deepestTail: % -> %

deepestTail(p) returns 0 if p belongs to R, otherwise returns tail(p), if tail(p) belongs to R or mvar(tail(p)) < mvar(p), otherwise returns deepestTail(tail(p)).

degree: % -> E

from AbelianMonoidRing(R, E)

degree: (%, List V) -> List NonNegativeInteger

from MaybeSkewPolynomialCategory(R, E, V)

degree: (%, V) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, E, V)

differentiate: (%, List V) -> %

from PartialDifferentialRing V

differentiate: (%, List V, List NonNegativeInteger) -> %

from PartialDifferentialRing V

differentiate: (%, V) -> %

from PartialDifferentialRing V

differentiate: (%, V, NonNegativeInteger) -> %

from PartialDifferentialRing V

discriminant: (%, V) -> % if R has CommutativeRing

from PolynomialCategory(R, E, V)

eval: (%, %, %) -> %

from InnerEvalable(%, %)

eval: (%, Equation %) -> %

from Evalable %

eval: (%, List %, List %) -> %

from InnerEvalable(%, %)

eval: (%, List Equation %) -> %

from Evalable %

eval: (%, List V, List %) -> %

from InnerEvalable(V, %)

eval: (%, List V, List R) -> %

from InnerEvalable(V, R)

eval: (%, V, %) -> %

from InnerEvalable(V, %)

eval: (%, V, R) -> %

from InnerEvalable(V, R)

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

exactQuotient!(a, b) replaces a by exactQuotient(a, b)

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

exactQuotient!(p, r) replaces p by exactQuotient(p, r).

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

exactQuotient(a, b) computes the exact quotient of a by b, which is assumed to be a divisor of a. No error is returned if this exact quotient fails!

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

exactQuotient(p, r) computes the exact quotient of p by r, which is assumed to be a divisor of p. No error is returned if this exact quotient fails!

exquo: (%, %) -> Union(%, failed) if R has EntireRing

from EntireRing

exquo: (%, R) -> Union(%, failed) if R has EntireRing

from FiniteAbelianMonoidRing(R, E)

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

extendedSubResultantGcd(a, b) returns [g, ca, cb] such that g is subResultantGcd(a, b) and we have ca * a + cb * cb = g.

factor: % -> Factored % if R has PolynomialFactorizationExplicit

from UniqueFactorizationDomain

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

from PolynomialFactorizationExplicit

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

from PolynomialFactorizationExplicit

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

from FiniteAbelianMonoidRing(R, E)

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

from GcdDomain

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

gcd(r, p) returns the gcd of r and the content of p.

gcd: List % -> % if R has GcdDomain

from GcdDomain

gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial % if R has GcdDomain

from PolynomialFactorizationExplicit

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

from Hashable

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

from Hashable

head: % -> %

head(p) returns p if p belongs to R, otherwise returns its leading term (monomial in the FriCAS sense), where p is viewed as a univariate polynomial in its main variable.

headReduce: (%, %) -> %

headReduce(a, b) returns a polynomial r such that headReduced?(r, b) holds and there exists an integer e such that init(b)^e a - r is zero modulo b.

headReduced?: (%, %) -> Boolean

headReduced?(a, b) returns true iff degree(head(a), mvar(b)) < mdeg(b).

headReduced?: (%, List %) -> Boolean

headReduced?(q, lp) returns true iff headReduced?(q, p) holds for every p in lp.

iexactQuo: (R, R) -> R if R has IntegralDomain

iexactQuo(x, y) should be local but conditional

infRittWu?: (%, %) -> Boolean

infRittWu?(a, b) returns true if a is less than b w.r.t. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.

init: % -> %

init(p) returns an error if p belongs to R, otherwise returns its leading coefficient, where p is viewed as a univariate polynomial in its main variable.

initiallyReduce: (%, %) -> %

initiallyReduce(a, b) returns a polynomial r such that initiallyReduced?(r, b) holds and there exists an integer e such that init(b)^e a - r is zero modulo b.

initiallyReduced?: (%, %) -> Boolean

initiallyReduced?(a, b) returns false iff there exists an iterated initial of a which is not reduced w.r.t b.

initiallyReduced?: (%, List %) -> Boolean

initiallyReduced?(q, lp) returns true iff initiallyReduced?(q, p) holds for every p in lp.

isExpt: % -> Union(Record(var: V, exponent: NonNegativeInteger), failed)

from PolynomialCategory(R, E, V)

isPlus: % -> Union(List %, failed)

from PolynomialCategory(R, E, V)

isTimes: % -> Union(List %, failed)

from PolynomialCategory(R, E, V)

iteratedInitials: % -> List %

iteratedInitials(p) returns [] if p belongs to R, otherwise returns the list of the iterated initials of p.

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

lastSubResultant(a, b) returns the last non-zero subresultant of a and b where a and b are assumed to have the same main variable v and are viewed as univariate polynomials in v.

latex: % -> String

from SetCategory

LazardQuotient2: (%, %, %, NonNegativeInteger) -> % if R has IntegralDomain

LazardQuotient2(p, a, b, n) returns (a^(n-1) * p) exquo b^(n-1) assuming that this quotient does not fail.

LazardQuotient: (%, %, NonNegativeInteger) -> % if R has IntegralDomain

LazardQuotient(a, b, n) returns a^n exquo b^(n-1) assuming that this quotient does not fail.

lazyPquo: (%, %) -> %

lazyPquo(a, b) returns the polynomial q such that lazyPseudoDivide(a, b) returns [c, g, q, r].

lazyPquo: (%, %, V) -> %

lazyPquo(a, b, v) returns the polynomial q such that lazyPseudoDivide(a, b, v) returns [c, g, q, r].

lazyPrem: (%, %) -> %

lazyPrem(a, b) returns the polynomial r reduced w.r.t. b and such that b divides init(b)^e a - r where e is the number of steps of this pseudo-division.

lazyPrem: (%, %, V) -> %

lazyPrem(a, b, v) returns the polynomial r reduced w.r.t. b viewed as univariate polynomials in the variable v such that b divides init(b)^e a - r where e is the number of steps of this pseudo-division.

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

lazyPremWithDefault(a, b) returns [c, g, r] such that r = lazyPrem(a, b) and (c^g)*r = prem(a, b).

lazyPremWithDefault: (%, %, V) -> Record(coef: %, gap: NonNegativeInteger, remainder: %)

lazyPremWithDefault(a, b, v) returns [c, g, r] such that r = lazyPrem(a, b, v) and (c^g)*r = prem(a, b, v).

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

lazyPseudoDivide(a, b) returns [c, g, q, r] such that [c, g, r] = lazyPremWithDefault(a, b) and q is the pseudo-quotient computed in this lazy pseudo-division.

lazyPseudoDivide: (%, %, V) -> Record(coef: %, gap: NonNegativeInteger, quotient: %, remainder: %)

lazyPseudoDivide(a, b, v) returns [c, g, q, r] such that r = lazyPrem(a, b, v), (c^g)*r = prem(a, b, v) and q is the pseudo-quotient computed in this lazy pseudo-division.

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

lazyResidueClass(a, b) returns [p, q, n] where p / q^n represents the residue class of a modulo b and p is reduced w.r.t. b and q is init(b).

lcm: (%, %) -> % if R has GcdDomain

from GcdDomain

lcm: List % -> % if R has GcdDomain

from GcdDomain

lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %) if R has GcdDomain

from LeftOreRing

leadingCoefficient: % -> R

from IndexedProductCategory(R, E)

leadingCoefficient: (%, V) -> %

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

leadingMonomial: % -> %

from IndexedProductCategory(R, E)

leadingSupport: % -> E

from IndexedProductCategory(R, E)

leadingTerm: % -> Record(k: E, c: R)

from IndexedProductCategory(R, E)

leastMonomial: % -> %

leastMonomial(p) returns an error if p is O, otherwise, if p belongs to R returns 1, otherwise, the monomial of p with lowest degree, where p is viewed as a univariate polynomial in its main variable.

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

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

from FreeModuleCategory(R, E)

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

from IndexedDirectProductCategory(R, E)

mainCoefficients: % -> List %

mainCoefficients(p) returns an error if p is O, otherwise, if p belongs to R returns [p], otherwise returns the list of the coefficients of p, where p is viewed as a univariate polynomial in its main variable.

mainContent: % -> % if R has GcdDomain

mainContent(p) returns the content of p viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over R.

mainMonomial: % -> %

mainMonomial(p) returns an error if p is O, otherwise, if p belongs to R returns 1, otherwise, mvar(p) raised to the power mdeg(p).

mainMonomials: % -> List %

mainMonomials(p) returns an error if p is O, otherwise, if p belongs to R returns [1], otherwise returns the list of the monomials of p, where p is viewed as a univariate polynomial in its main variable.

mainPrimitivePart: % -> % if R has GcdDomain

mainPrimitivePart(p) returns the primitive part of p viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over R.

mainSquareFreePart: % -> % if R has GcdDomain

mainSquareFreePart(p) returns the square free part of p viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over R.

mainVariable: % -> Union(V, failed)

from MaybeSkewPolynomialCategory(R, E, V)

map: (R -> R, %) -> %

from IndexedProductCategory(R, E)

mapExponents: (E -> E, %) -> %

from FiniteAbelianMonoidRing(R, E)

mdeg: % -> NonNegativeInteger

mdeg(p) returns an error if p is 0, otherwise, if p belongs to R returns 0, otherwise, returns the degree of p in its main variable.

minimumDegree: % -> E

from FiniteAbelianMonoidRing(R, E)

minimumDegree: (%, List V) -> List NonNegativeInteger

from PolynomialCategory(R, E, V)

minimumDegree: (%, V) -> NonNegativeInteger

from PolynomialCategory(R, E, V)

monic?: % -> Boolean

monic?(p) returns false if p belongs to R, otherwise returns true iff p is monic as a univariate polynomial in its main variable.

monicDivide: (%, %, V) -> Record(quotient: %, remainder: %)

from PolynomialCategory(R, E, V)

monicModulo: (%, %) -> %

monicModulo(a, b) computes a mod b, if b is monic as univariate polynomial in its main variable.

monomial?: % -> Boolean

from IndexedProductCategory(R, E)

monomial: (%, List V, List NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, E, V)

monomial: (%, V, NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, E, V)

monomial: (R, E) -> %

from IndexedProductCategory(R, E)

monomials: % -> List %

from MaybeSkewPolynomialCategory(R, E, V)

multivariate: (SparseUnivariatePolynomial %, V) -> %

from PolynomialCategory(R, E, V)

multivariate: (SparseUnivariatePolynomial R, V) -> %

from PolynomialCategory(R, E, V)

mvar: % -> V

mvar(p) returns an error if p belongs to R, otherwise returns its main variable w. r. t. to the total ordering on the elements in V.

next_subResultant2: (%, %, %, %) -> % if R has IntegralDomain

next_subResultant2(p, q, z, s) is the multivariate version of the operation \ ``next_sousResultant2`\ <l50736575646f52656d61696e64657253657175656e6365-5c2060606e6578745f736f7573526573756c74616e743260605c20>` from the PseudoRemainderSequence constructor.

normalized?: (%, %) -> Boolean

normalized?(a, b) returns true iff a and its iterated initials have degree zero w.r.t. the main variable of b

normalized?: (%, List %) -> Boolean

normalized?(q, lp) returns true iff normalized?(q, p) holds for every p in lp.

numberOfMonomials: % -> NonNegativeInteger

from IndexedDirectProductCategory(R, E)

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if 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

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

from NonAssociativeAlgebra %

pomopo!: (%, R, E, %) -> %

from FiniteAbelianMonoidRing(R, E)

pquo: (%, %) -> %

pquo(a, b) computes the pseudo-quotient of a by b, both viewed as univariate polynomials in the main variable of b.

pquo: (%, %, V) -> %

pquo(a, b, v) computes the pseudo-quotient of a by b, both viewed as univariate polynomials in v.

prem: (%, %) -> %

prem(a, b) computes the pseudo-remainder of a by b, both viewed as univariate polynomials in the main variable of b.

prem: (%, %, V) -> %

prem(a, b, v) computes the pseudo-remainder of a by b, both viewed as univariate polynomials in v.

prime?: % -> Boolean if R has PolynomialFactorizationExplicit

from UniqueFactorizationDomain

primitiveMonomials: % -> List %

from MaybeSkewPolynomialCategory(R, E, V)

primitivePart!: % -> % if R has GcdDomain

primitivePart!(p) replaces p by its primitive part.

primitivePart: % -> % if R has GcdDomain

from PolynomialCategory(R, E, V)

primitivePart: (%, V) -> % if R has GcdDomain

from PolynomialCategory(R, E, V)

primPartElseUnitCanonical!: % -> % if R has IntegralDomain

primPartElseUnitCanonical!(p) replaces p by primPartElseUnitCanonical(p).

primPartElseUnitCanonical: % -> % if R has IntegralDomain

primPartElseUnitCanonical(p) returns primitivePart(p) if R is a gcd-domain, otherwise unitCanonical(p).

pseudoDivide: (%, %) -> Record(quotient: %, remainder: %)

pseudoDivide(a, b) computes [pquo(a, b), prem(a, b)], both polynomials viewed as univariate polynomials in the main variable of b, if b is not a constant polynomial.

quasiMonic?: % -> Boolean

quasiMonic?(p) returns false if p belongs to R, otherwise returns true iff the initial of p lies in the base ring R.

recip: % -> Union(%, failed)

from MagmaWithUnit

reduced?: (%, %) -> Boolean

reduced?(a, b) returns true iff degree(a, mvar(b)) < mdeg(b).

reduced?: (%, List %) -> Boolean

reduced?(q, lp) returns true iff reduced?(q, p) holds for every p in lp.

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has LinearlyExplicitOver Integer

from LinearlyExplicitOver Integer

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)

from LinearlyExplicitOver R

reducedSystem: Matrix % -> Matrix Integer if R has LinearlyExplicitOver Integer

from LinearlyExplicitOver Integer

reducedSystem: Matrix % -> Matrix R

from LinearlyExplicitOver R

reductum: % -> %

from IndexedProductCategory(R, E)

reductum: (%, V) -> %

reductum(p, v) returns the reductum of p, where p is viewed as a univariate polynomial in v.

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

resultant(a, b) computes the resultant of a and b where a and b are assumed to have the same main variable v and are viewed as univariate polynomials in v.

resultant: (%, %, V) -> % if R has CommutativeRing

from PolynomialCategory(R, E, V)

retract: % -> Fraction Integer if R has RetractableTo Fraction Integer

from RetractableTo Fraction Integer

retract: % -> Integer if R has RetractableTo Integer

from RetractableTo Integer

retract: % -> R

from RetractableTo R

retract: % -> V

from RetractableTo V

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

retract(p) returns p as an element of the current domain, if retractIfCan(p) does not return “failed”, otherwise an error is produced.

retract: Polynomial Integer -> % if R has Algebra Integer and V has ConvertibleTo Symbol

retract(p) returns p as an element of the current domain, if retractIfCan(p) does not return “failed”, otherwise an error is produced.

retract: Polynomial R -> % if V has ConvertibleTo Symbol

retract(p) returns p as an element of the current domain, if retractIfCan(p) does not return “failed”, otherwise an error is produced.

retractIfCan: % -> Union(Fraction Integer, failed) if R has RetractableTo Fraction Integer

from RetractableTo Fraction Integer

retractIfCan: % -> Union(Integer, failed) if R has RetractableTo Integer

from RetractableTo Integer

retractIfCan: % -> Union(R, failed)

from RetractableTo R

retractIfCan: % -> Union(V, failed)

from RetractableTo V

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

retractIfCan(p) returns p as an element of the current domain, if all its variables belong to V.

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

retractIfCan(p) returns p as an element of the current domain, if all its variables belong to V.

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

retractIfCan(p) returns p as an element of the current domain, if all its variables belong to V.

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

RittWuCompare: (%, %) -> Union(Boolean, failed)

RittWuCompare(a,b) returns "failed" if a and b have same rank w.r.t. Ritt and Wu Wen Tsun ordering using the refinement of Lazard, otherwise returns infRittWu?(a, b).

sample: %

from AbelianMonoid

smaller?: (%, %) -> Boolean if R has Comparable

from Comparable

solveLinearPolynomialEquation: (List SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial %, failed) if R has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

squareFree: % -> Factored % if R has GcdDomain

from PolynomialCategory(R, E, V)

squareFreePart: % -> % if R has GcdDomain

from PolynomialCategory(R, E, V)

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

from PolynomialFactorizationExplicit

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

subResultantChain(a, b), where a and b are not constant polynomials with the same main variable, returns the subresultant chain of a and b.

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

subResultantGcd(a, b) computes a gcd of a and b where a and b are assumed to have the same main variable v and are viewed as univariate polynomials in v with coefficients in the fraction field of the polynomial ring generated by their other variables over R.

subtractIfCan: (%, %) -> Union(%, failed)

from CancellationAbelianMonoid

support: % -> List E

from FreeModuleCategory(R, E)

supRittWu?: (%, %) -> Boolean

supRittWu?(a, b) returns true if a is greater than b w.r.t. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.

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)

AbelianProductCategory R

AbelianSemiGroup

Algebra % if R has CommutativeRing

Algebra Fraction Integer if R has Algebra Fraction Integer

Algebra R if R has CommutativeRing

BasicType

BiModule(%, %)

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

BiModule(R, R)

CancellationAbelianMonoid

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

CoercibleFrom R

CoercibleFrom V

CoercibleTo OutputForm

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)

FullyLinearlyExplicitOver R

FullyRetractableTo R

GcdDomain if R has GcdDomain

Hashable if R has Hashable and V has Hashable

IndexedDirectProductCategory(R, E)

IndexedProductCategory(R, E)

InnerEvalable(%, %)

InnerEvalable(V, %)

InnerEvalable(V, R)

IntegralDomain if R has IntegralDomain

LeftModule %

LeftModule Fraction Integer if R has Algebra Fraction Integer

LeftModule R

LeftOreRing if R has GcdDomain

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

LinearlyExplicitOver R

Magma

MagmaWithUnit

MaybeSkewPolynomialCategory(R, E, V)

Module % if R has CommutativeRing

Module Fraction Integer if R has Algebra Fraction Integer

Module R if R has CommutativeRing

Monoid

NonAssociativeAlgebra % if R has CommutativeRing

NonAssociativeAlgebra Fraction Integer if R has Algebra Fraction Integer

NonAssociativeAlgebra R if R has CommutativeRing

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors if R has EntireRing

PartialDifferentialRing V

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

RetractableTo R

RetractableTo V

RightModule %

RightModule Fraction Integer if R has Algebra Fraction Integer

RightModule Integer if R has LinearlyExplicitOver Integer

RightModule R

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip if R has CommutativeRing

UniqueFactorizationDomain if R has PolynomialFactorizationExplicit

unitsKnown

VariablesCommuteWithCoefficients