NewSparseMultivariatePolynomial(R, VarSet)

newpoly.spad line 1315 [edit on github]

• R : Ring
• VarSet : OrderedSet

A post-facto extension for SMP in order to speed up operations related to pseudo-division and gcd. This domain is based on the NSUP constructor which is itself a post-facto extension of the SUP constructor.

* : (%, %) -> %

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, IndexedExponents(VarSet))

0 : () -> %

from AbelianMonoid

1 : () -> %

from MagmaWithUnit

= : (%, %) -> Boolean

from BasicType

D : (%, VarSet) -> %

from PartialDifferentialRing(VarSet)

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

from PartialDifferentialRing(VarSet)

D : (%, List(VarSet)) -> %

from PartialDifferentialRing(VarSet)

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

from PartialDifferentialRing(VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

^ : (%, 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, IndexedExponents(VarSet))

characteristic : () -> NonNegativeInteger

from NonAssociativeRing

charthRoot : % -> Union(%, "failed") if R has CharacteristicNonZero or % has CharacteristicNonZero and R has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

coefficient : (%, VarSet, NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

coefficient : (%, List(VarSet), List(NonNegativeInteger)) -> %

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

coefficient : (%, IndexedExponents(VarSet)) -> R

from AbelianMonoidRing(R, IndexedExponents(VarSet))

coefficients : % -> List(R)

from FreeModuleCategory(R, IndexedExponents(VarSet))

coerce : % -> % if R has CommutativeRing

from Algebra(%)

coerce : R -> %

from Algebra(R)

coerce : VarSet -> %

from CoercibleFrom(VarSet)

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

from Algebra(Fraction(Integer))

coerce : Integer -> %

from NonAssociativeRing

coerce : SparseMultivariatePolynomial(R, VarSet) -> %

from CoercibleFrom(SparseMultivariatePolynomial(R, VarSet))

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

coerce : % -> Polynomial(R) if VarSet has ConvertibleTo(Symbol)

from CoercibleTo(Polynomial(R))

coerce : % -> SparseMultivariatePolynomial(R, VarSet)

from CoercibleTo(SparseMultivariatePolynomial(R, VarSet))

commutator : (%, %) -> %

from NonAssociativeRng

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

from PolynomialFactorizationExplicit

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

from IndexedProductCategory(R, IndexedExponents(VarSet))

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

from IndexedProductCategory(R, IndexedExponents(VarSet))

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

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

content : % -> R if R has GcdDomain

from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))

convert : Polynomial(R) -> % if VarSet has ConvertibleTo(Symbol)

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

convert : % -> InputForm if VarSet has ConvertibleTo(InputForm) and R has ConvertibleTo(InputForm)

from ConvertibleTo(InputForm)

convert : % -> Pattern(Float) if VarSet has ConvertibleTo(Pattern(Float)) and R has ConvertibleTo(Pattern(Float))

from ConvertibleTo(Pattern(Float))

convert : % -> Pattern(Integer) if VarSet has ConvertibleTo(Pattern(Integer)) and R has ConvertibleTo(Pattern(Integer))

from ConvertibleTo(Pattern(Integer))

convert : % -> Polynomial(R) if VarSet has ConvertibleTo(Symbol)

from ConvertibleTo(Polynomial(R))

convert : % -> String if R has RetractableTo(Integer) and VarSet has ConvertibleTo(Symbol)

from ConvertibleTo(String)

deepestInitial : % -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

deepestTail : % -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

degree : % -> IndexedExponents(VarSet)

from AbelianMonoidRing(R, IndexedExponents(VarSet))

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

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

degree : (%, VarSet) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

differentiate : (%, VarSet) -> %

from PartialDifferentialRing(VarSet)

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

from PartialDifferentialRing(VarSet)

differentiate : (%, List(VarSet)) -> %

from PartialDifferentialRing(VarSet)

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

from PartialDifferentialRing(VarSet)

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

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from InnerEvalable(%, %)

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

from InnerEvalable(VarSet, %)

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

from InnerEvalable(VarSet, R)

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

from Evalable(%)

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

from InnerEvalable(%, %)

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

from InnerEvalable(VarSet, %)

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

from InnerEvalable(VarSet, R)

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

from Evalable(%)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from EntireRing

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

from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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 : (%, IndexedExponents(VarSet), R, %) -> %

from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))

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

from GcdDomain

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

from GcdDomain

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from PolynomialFactorizationExplicit

ground : % -> R

from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))

ground? : % -> Boolean

from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

hash : % -> SingleInteger if VarSet has Hashable and R has Hashable

from Hashable

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

from Hashable

head : % -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

headReduce : (%, %) -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

headReduced? : (%, %) -> Boolean

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

infRittWu? : (%, %) -> Boolean

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

init : % -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

initiallyReduce : (%, %) -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

initiallyReduced? : (%, %) -> Boolean

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

iteratedInitials : % -> List(%)

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

latex : % -> String

from SetCategory

lazyPquo : (%, %) -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

lazyPrem : (%, %) -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

leadingCoefficient : % -> R

from IndexedProductCategory(R, IndexedExponents(VarSet))

leadingMonomial : % -> %

from IndexedProductCategory(R, IndexedExponents(VarSet))

leadingSupport : % -> IndexedExponents(VarSet)

from IndexedProductCategory(R, IndexedExponents(VarSet))

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

from IndexedProductCategory(R, IndexedExponents(VarSet))

leastMonomial : % -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

leftPower : (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower : (%, PositiveInteger) -> %

from Magma

leftRecip : % -> Union(%, "failed")

from MagmaWithUnit

linearExtend : (Mapping(R, IndexedExponents(VarSet)), %) -> R if R has CommutativeRing

from FreeModuleCategory(R, IndexedExponents(VarSet))

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

from IndexedDirectProductCategory(R, IndexedExponents(VarSet))

mainCoefficients : % -> List(%)

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

mainContent : % -> % if R has GcdDomain

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

mainMonomial : % -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

mainMonomials : % -> List(%)

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

mainPrimitivePart : % -> % if R has GcdDomain

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

mainSquareFreePart : % -> % if R has GcdDomain

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

mainVariable : % -> Union(VarSet, "failed")

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from IndexedProductCategory(R, IndexedExponents(VarSet))

mapExponents : (Mapping(IndexedExponents(VarSet), IndexedExponents(VarSet)), %) -> %

from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))

mdeg : % -> NonNegativeInteger

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

minimumDegree : % -> IndexedExponents(VarSet)

from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))

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

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

minimumDegree : (%, VarSet) -> NonNegativeInteger

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

monic? : % -> Boolean

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

monicModulo : (%, %) -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

monomial : (R, IndexedExponents(VarSet)) -> %

from IndexedProductCategory(R, IndexedExponents(VarSet))

monomial? : % -> Boolean

from IndexedProductCategory(R, IndexedExponents(VarSet))

monomials : % -> List(%)

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

multivariate : (SparseUnivariatePolynomial(%), VarSet) -> %

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

multivariate : (SparseUnivariatePolynomial(R), VarSet) -> %

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

mvar : % -> VarSet

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

normalized? : (%, %) -> Boolean

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

numberOfMonomials : % -> NonNegativeInteger

from IndexedDirectProductCategory(R, IndexedExponents(VarSet))

one? : % -> Boolean

from MagmaWithUnit

opposite? : (%, %) -> Boolean

from AbelianMonoid

patternMatch : (%, Pattern(Float), PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if VarSet has PatternMatchable(Float) and R has PatternMatchable(Float)

from PatternMatchable(Float)

patternMatch : (%, Pattern(Integer), PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if VarSet has PatternMatchable(Integer) and R has PatternMatchable(Integer)

from PatternMatchable(Integer)

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

from NonAssociativeAlgebra(%)

pomopo! : (%, R, IndexedExponents(VarSet), %) -> %

from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))

pquo : (%, %) -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

prem : (%, %) -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

primPartElseUnitCanonical : % -> % if R has IntegralDomain

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

primPartElseUnitCanonical! : % -> % if R has IntegralDomain

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

prime? : % -> Boolean if R has PolynomialFactorizationExplicit

from UniqueFactorizationDomain

primitiveMonomials : % -> List(%)

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

primitivePart : % -> % if R has GcdDomain

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

primitivePart! : % -> % if R has GcdDomain

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

quasiMonic? : % -> Boolean

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

recip : % -> Union(%, "failed")

from MagmaWithUnit

reduced? : (%, %) -> Boolean

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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, IndexedExponents(VarSet))

reductum : (%, VarSet) -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

retract : Polynomial(R) -> % if VarSet has ConvertibleTo(Symbol)

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

retract : % -> R

from RetractableTo(R)

retract : % -> VarSet

from RetractableTo(VarSet)

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

from RetractableTo(Fraction(Integer))

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

from RetractableTo(Integer)

retract : % -> SparseMultivariatePolynomial(R, VarSet)

from RetractableTo(SparseMultivariatePolynomial(R, VarSet))

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

retractIfCan : % -> Union(R, "failed")

from RetractableTo(R)

retractIfCan : % -> Union(VarSet, "failed")

from RetractableTo(VarSet)

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(SparseMultivariatePolynomial(R, VarSet), "failed")

from RetractableTo(SparseMultivariatePolynomial(R, VarSet))

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, IndexedExponents(VarSet), VarSet)

squareFreePart : % -> % if R has GcdDomain

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from PolynomialFactorizationExplicit

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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

from CancellationAbelianMonoid

supRittWu? : (%, %) -> Boolean

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

support : % -> List(IndexedExponents(VarSet))

from FreeModuleCategory(R, IndexedExponents(VarSet))

tail : % -> %

from RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

totalDegree : % -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

totalDegree : (%, List(VarSet)) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

totalDegreeSorted : (%, List(VarSet)) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

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 : (%, VarSet) -> SparseUnivariatePolynomial(%)

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

univariate : % -> SparseUnivariatePolynomial(R)

from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

variables : % -> List(VarSet)

from MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

zero? : % -> Boolean

from AbelianMonoid

~= : (%, %) -> Boolean

from BasicType

CoercibleTo(Polynomial(R))

Ring

CommutativeStar

ConvertibleTo(Pattern(Integer))

LinearlyExplicitOver(Integer)

SemiGroup

Hashable

VariablesCommuteWithCoefficients

RightModule(R)

Monoid

InnerEvalable(VarSet, %)

LeftModule(%)

BiModule(Fraction(Integer), Fraction(Integer))

Algebra(R)

Module(%)

IndexedDirectProductCategory(R, IndexedExponents(VarSet))

BasicType

LeftOreRing

PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

noZeroDivisors

ConvertibleTo(InputForm)

SemiRing

NonAssociativeAlgebra(%)

SetCategory

IndexedProductCategory(R, IndexedExponents(VarSet))

AbelianMonoidRing(R, IndexedExponents(VarSet))

NonAssociativeSemiRing

unitsKnown

CharacteristicNonZero

PolynomialFactorizationExplicit

TwoSidedRecip

InnerEvalable(VarSet, R)

CoercibleFrom(Fraction(Integer))

NonAssociativeRing

MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

NonAssociativeRng

BiModule(R, R)

Comparable

RetractableTo(R)

RetractableTo(VarSet)

NonAssociativeAlgebra(R)

FullyRetractableTo(R)

ConvertibleTo(Polynomial(R))

CommutativeRing

CoercibleFrom(SparseMultivariatePolynomial(R, VarSet))

AbelianSemiGroup

Rng

canonicalUnitNormal

LeftModule(Fraction(Integer))

PatternMatchable(Float)

FreeModuleCategory(R, IndexedExponents(VarSet))

FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))

CoercibleFrom(VarSet)

LeftModule(R)

IntegralDomain

RightModule(Integer)

RecursivePolynomialCategory(R, IndexedExponents(VarSet), VarSet)

CoercibleTo(SparseMultivariatePolynomial(R, VarSet))

CoercibleFrom(R)

PartialDifferentialRing(VarSet)

Evalable(%)

NonAssociativeAlgebra(Fraction(Integer))

RetractableTo(SparseMultivariatePolynomial(R, VarSet))

LinearlyExplicitOver(R)

EntireRing

NonAssociativeSemiRng

GcdDomain

CharacteristicZero

Algebra(Fraction(Integer))

AbelianGroup

CancellationAbelianMonoid

AbelianProductCategory(R)

MagmaWithUnit

CoercibleFrom(Integer)

AbelianMonoid

PatternMatchable(Integer)

CoercibleTo(OutputForm)

BiModule(%, %)

RetractableTo(Fraction(Integer))

Algebra(%)

SemiRng

ConvertibleTo(String)

RightModule(Fraction(Integer))

Module(R)

InnerEvalable(%, %)

FullyLinearlyExplicitOver(R)

UniqueFactorizationDomain

ConvertibleTo(Pattern(Float))

Module(Fraction(Integer))

RightModule(%)

RetractableTo(Integer)

Magma