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.

* : (%, %) -> %: from Magma

* : (%, R) -> %: from RightModule(R)

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

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

* : (R, %) -> %: from LeftModule(R)

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

* : (Integer, %) -> %: from AbelianGroup

* : (NonNegativeInteger, %) -> %: from AbelianMonoid

* : (PositiveInteger, %) -> %: from AbelianSemiGroup

+ : (%, %) -> %: from AbelianSemiGroup

- : % -> %: from AbelianGroup

- : (%, %) -> %: from AbelianGroup

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

0 : () -> %: from AbelianMonoid

1 : () -> %: from MagmaWithUnit

= : (%, %) -> Boolean: from BasicType

D : (%, V) -> %: from PartialDifferentialRing(V)

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

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

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

LazardQuotient : (%, %, NonNegativeInteger) -> % if R has IntegralDomain: LazardQuotient(a, b, n) returns a^n exquo b^(n-1) assuming that this quotient does not fail.

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.

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

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

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

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 : (%, V, NonNegativeInteger) -> %: from MaybeSkewPolynomialCategory(R, E, V)

coefficient : (%, List(V), List(NonNegativeInteger)) -> %: from MaybeSkewPolynomialCategory(R, E, V)

coefficient : (%, E) -> R: from AbelianMonoidRing(R, E)

coefficients : % -> List(R): from FreeModuleCategory(R, E)

coerce : % -> % if R has CommutativeRing: from Algebra(%)

coerce : R -> %: from Algebra(R)

coerce : V -> %: from CoercibleFrom(V)

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

coerce : Integer -> %: from NonAssociativeRing

coerce : % -> OutputForm: from CoercibleTo(OutputForm)

coerce : % -> Polynomial(R) if V has ConvertibleTo(Symbol): from CoercibleTo(Polynomial(R))

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 : (%, V) -> % if R has GcdDomain: from PolynomialCategory(R, E, V)

content : % -> R if R has GcdDomain: from FiniteAbelianMonoidRing(R, E)

convert : Polynomial(R) -> % if V has ConvertibleTo(Symbol): convert(p) returns the same as retract(p).

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

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 : (%, V) -> %: from PartialDifferentialRing(V)

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

differentiate : (%, List(V)) -> %: from PartialDifferentialRing(V)

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

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

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

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

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

eval : (%, Equation(%)) -> %: from Evalable(%)

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

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

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

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

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!

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

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 : List(%) -> % 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.

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

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 : (%, V) -> %: leadingCoefficient(p, v) returns the leading coefficient of p, where p is viewed as A univariate polynomial in v.

leadingCoefficient : % -> R: from IndexedProductCategory(R, E)

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 : (Mapping(R, E), %) -> 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 : (Mapping(R, R), %) -> %: from IndexedProductCategory(R, E)

mapExponents : (Mapping(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 : (%, V, NonNegativeInteger) -> %: from MaybeSkewPolynomialCategory(R, E, V)

monomial : (%, List(V), List(NonNegativeInteger)) -> %: from MaybeSkewPolynomialCategory(R, E, V)

monomial : (R, E) -> %: from IndexedProductCategory(R, E)

monomial? : % -> Boolean: 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 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.

primPartElseUnitCanonical : % -> % if R has IntegralDomain: primPartElseUnitCanonical(p) returns primitivePart(p) if R is a gcd-domain, otherwise unitCanonical(p).

primPartElseUnitCanonical! : % -> % if R has IntegralDomain: primPartElseUnitCanonical!(p) replaces p by primPartElseUnitCanonical(p).

prime? : % -> Boolean if R has PolynomialFactorizationExplicit: from UniqueFactorizationDomain

primitiveMonomials : % -> List(%): from MaybeSkewPolynomialCategory(R, E, V)

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

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

primitivePart! : % -> % if R has GcdDomain: primitivePart!(p) replaces p by its primitive part.

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(%) -> Matrix(R): from LinearlyExplicitOver(R)

reducedSystem : Matrix(%) -> Matrix(Integer) if R has LinearlyExplicitOver(Integer): from LinearlyExplicitOver(Integer)

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

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

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

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 : % -> R: from RetractableTo(R)

retract : % -> V: from RetractableTo(V)

retract : % -> Fraction(Integer) if R has RetractableTo(Fraction(Integer)): from RetractableTo(Fraction(Integer))

retract : % -> Integer if R has RetractableTo(Integer): from RetractableTo(Integer)

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.

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 : % -> Union(R, "failed"): from RetractableTo(R)

retractIfCan : % -> Union(V, "failed"): from RetractableTo(V)

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)

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

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

rightRecip : % -> Union(%, "failed"): from MagmaWithUnit

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.