SparseMultivariatePolynomial(R, VarSet)

multpoly.spad line 80 [edit on github]

This type is the basic representation of sparse recursive multivariate polynomials. It is parameterized by the coefficient ring and the variable set which may be infinite. The variable ordering is determined by the variable set parameter. The coefficient ring may be non-commutative, but the variables are assumed to commute.

* : (%, %) -> %
from Magma
* : (%, R) -> %
from RightModule(R)
* : (%, Fraction(Integer)) -> % if R has Algebra(Fraction(Integer))
from RightModule(Fraction(Integer))
* : (%, Integer) -> % if R has LinearlyExplicitOver(Integer) and R has Ring
from RightModule(Integer)
* : (R, %) -> %
from LeftModule(R)
* : (Fraction(Integer), %) -> % if R has Algebra(Fraction(Integer))
from LeftModule(Fraction(Integer))
* : (Integer, %) -> % if R has AbelianGroup or % has AbelianGroup
from AbelianGroup
* : (NonNegativeInteger, %) -> %
from AbelianMonoid
* : (PositiveInteger, %) -> %
from AbelianSemiGroup
+ : (%, %) -> %
from AbelianSemiGroup
- : % -> % if R has AbelianGroup or % has AbelianGroup
from AbelianGroup
- : (%, %) -> % if R has AbelianGroup or % has AbelianGroup
from AbelianGroup
/ : (%, R) -> % if R has Field
from AbelianMonoidRing(R, IndexedExponents(VarSet))
0 : () -> %
from AbelianMonoid
1 : () -> % if R has SemiRing
from MagmaWithUnit
= : (%, %) -> Boolean
from BasicType
D : (%, VarSet) -> % if R has Ring
from PartialDifferentialRing(VarSet)
D : (%, VarSet, NonNegativeInteger) -> % if R has Ring
from PartialDifferentialRing(VarSet)
D : (%, List(VarSet)) -> % if R has Ring
from PartialDifferentialRing(VarSet)
D : (%, List(VarSet), List(NonNegativeInteger)) -> % if R has Ring
from PartialDifferentialRing(VarSet)
^ : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
^ : (%, PositiveInteger) -> %
from Magma
annihilate? : (%, %) -> Boolean if R has Ring
from Rng
antiCommutator : (%, %) -> %
from NonAssociativeSemiRng
associates? : (%, %) -> Boolean if R has EntireRing
from EntireRing
associator : (%, %, %) -> % if R has Ring
from NonAssociativeRng
binomThmExpt : (%, %, NonNegativeInteger) -> % if % has CommutativeRing
from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))
characteristic : () -> NonNegativeInteger if R has Ring
from NonAssociativeRing
charthRoot : % -> Union(%, "failed") if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit or R has CharacteristicNonZero
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 -> % if R has SemiRing
from CoercibleFrom(VarSet)
coerce : Fraction(Integer) -> % if R has Algebra(Fraction(Integer)) or R has RetractableTo(Fraction(Integer))
from Algebra(Fraction(Integer))
coerce : Integer -> % if R has Ring or R has RetractableTo(Integer)
from NonAssociativeRing
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
commutator : (%, %) -> % if R has Ring
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 : % -> 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)) and R has Ring
from ConvertibleTo(Pattern(Float))
convert : % -> Pattern(Integer) if VarSet has ConvertibleTo(Pattern(Integer)) and R has ConvertibleTo(Pattern(Integer)) and R has Ring
from ConvertibleTo(Pattern(Integer))
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) -> % if R has Ring
from PartialDifferentialRing(VarSet)
differentiate : (%, VarSet, NonNegativeInteger) -> % if R has Ring
from PartialDifferentialRing(VarSet)
differentiate : (%, List(VarSet)) -> % if R has Ring
from PartialDifferentialRing(VarSet)
differentiate : (%, List(VarSet), List(NonNegativeInteger)) -> % if R has Ring
from PartialDifferentialRing(VarSet)
discriminant : (%, VarSet) -> % if R has CommutativeRing
from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)
eval : (%, %, %) -> % if R has SemiRing
from InnerEvalable(%, %)
eval : (%, VarSet, %) -> %
from InnerEvalable(VarSet, %)
eval : (%, VarSet, R) -> %
from InnerEvalable(VarSet, R)
eval : (%, Equation(%)) -> % if R has SemiRing
from Evalable(%)
eval : (%, List(%), List(%)) -> % if R has SemiRing
from InnerEvalable(%, %)
eval : (%, List(VarSet), List(%)) -> %
from InnerEvalable(VarSet, %)
eval : (%, List(VarSet), List(R)) -> %
from InnerEvalable(VarSet, R)
eval : (%, List(Equation(%))) -> % if R has SemiRing
from Evalable(%)
exquo : (%, %) -> Union(%, "failed") if R has EntireRing
from EntireRing
exquo : (%, R) -> Union(%, "failed") if R has EntireRing
from FiniteAbelianMonoidRing(R, IndexedExponents(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, %) -> % if R has Ring
from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))
gcd : (%, %) -> % if R has GcdDomain
from GcdDomain
gcd : List(%) -> % if R has GcdDomain
from GcdDomain
gcdPolynomial : (SparseUnivariatePolynomial(%), SparseUnivariatePolynomial(%)) -> SparseUnivariatePolynomial(%) if R has GcdDomain
from PolynomialFactorizationExplicit
ground : % -> R
from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))
ground? : % -> Boolean
from FiniteAbelianMonoidRing(R, IndexedExponents(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
isExpt : % -> Union(Record(var : VarSet, exponent : NonNegativeInteger), "failed") if R has SemiRing
from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)
isPlus : % -> Union(List(%), "failed")
from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)
isTimes : % -> Union(List(%), "failed") if R has SemiRing
from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)
latex : % -> String
from SetCategory
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, 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))
leftPower : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
leftPower : (%, PositiveInteger) -> %
from Magma
leftRecip : % -> Union(%, "failed") if R has SemiRing
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))
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))
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)
monicDivide : (%, %, VarSet) -> Record(quotient : %, remainder : %) if R has Ring
from PolynomialCategory(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)
numberOfMonomials : % -> NonNegativeInteger
from IndexedDirectProductCategory(R, IndexedExponents(VarSet))
one? : % -> Boolean if R has SemiRing
from MagmaWithUnit
opposite? : (%, %) -> Boolean
from AbelianMonoid
patternMatch : (%, Pattern(Float), PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if VarSet has PatternMatchable(Float) and R has PatternMatchable(Float) and R has Ring
from PatternMatchable(Float)
patternMatch : (%, Pattern(Integer), PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if VarSet has PatternMatchable(Integer) and R has PatternMatchable(Integer) and R has Ring
from PatternMatchable(Integer)
plenaryPower : (%, PositiveInteger) -> % if R has CommutativeRing or R has Algebra(Fraction(Integer))
from NonAssociativeAlgebra(%)
pomopo! : (%, R, IndexedExponents(VarSet), %) -> %
from FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))
prime? : % -> Boolean if R has PolynomialFactorizationExplicit
from UniqueFactorizationDomain
primitiveMonomials : % -> List(%) if R has SemiRing
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)
recip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
reducedSystem : Matrix(%) -> Matrix(R) if R has Ring
from LinearlyExplicitOver(R)
reducedSystem : Matrix(%) -> Matrix(Integer) if R has LinearlyExplicitOver(Integer) and R has Ring
from LinearlyExplicitOver(Integer)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(R), vec : Vector(R)) if R has Ring
from LinearlyExplicitOver(R)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(Integer), vec : Vector(Integer)) if R has LinearlyExplicitOver(Integer) and R has Ring
from LinearlyExplicitOver(Integer)
reductum : % -> %
from IndexedProductCategory(R, IndexedExponents(VarSet))
resultant : (%, %, VarSet) -> % if R has CommutativeRing
from PolynomialCategory(R, IndexedExponents(VarSet), VarSet)
retract : % -> R
from RetractableTo(R)
retract : % -> VarSet if R has SemiRing
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)
retractIfCan : % -> Union(R, "failed")
from RetractableTo(R)
retractIfCan : % -> Union(VarSet, "failed") if R has SemiRing
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)
rightPower : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
rightPower : (%, PositiveInteger) -> %
from Magma
rightRecip : % -> Union(%, "failed") if R has SemiRing
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
subtractIfCan : (%, %) -> Union(%, "failed")
from CancellationAbelianMonoid
support : % -> List(IndexedExponents(VarSet))
from FreeModuleCategory(R, IndexedExponents(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

CharacteristicNonZero

Module(Fraction(Integer))

NonAssociativeSemiRing

LeftModule(R)

BiModule(%, %)

ConvertibleTo(InputForm)

canonicalUnitNormal

Rng

RetractableTo(VarSet)

CoercibleFrom(Integer)

TwoSidedRecip

FullyRetractableTo(R)

SemiRing

EntireRing

InnerEvalable(VarSet, R)

NonAssociativeAlgebra(Fraction(Integer))

FreeModuleCategory(R, IndexedExponents(VarSet))

unitsKnown

FullyLinearlyExplicitOver(R)

PatternMatchable(Float)

MaybeSkewPolynomialCategory(R, IndexedExponents(VarSet), VarSet)

IndexedProductCategory(R, IndexedExponents(VarSet))

AbelianSemiGroup

noZeroDivisors

UniqueFactorizationDomain

InnerEvalable(%, %)

SemiGroup

Magma

GcdDomain

IntegralDomain

LeftModule(%)

NonAssociativeRing

CharacteristicZero

Module(R)

Algebra(%)

BiModule(R, R)

RightModule(Fraction(Integer))

Algebra(R)

LinearlyExplicitOver(R)

RightModule(R)

NonAssociativeRng

InnerEvalable(VarSet, %)

CommutativeRing

LeftOreRing

CancellationAbelianMonoid

RetractableTo(Integer)

SetCategory

CoercibleFrom(VarSet)

AbelianMonoidRing(R, IndexedExponents(VarSet))

CommutativeStar

VariablesCommuteWithCoefficients

AbelianMonoid

MagmaWithUnit

Comparable

FiniteAbelianMonoidRing(R, IndexedExponents(VarSet))

RightModule(%)

AbelianProductCategory(R)

Hashable

PartialDifferentialRing(VarSet)

Evalable(%)

PolynomialCategory(R, IndexedExponents(VarSet), VarSet)

LinearlyExplicitOver(Integer)

CoercibleTo(OutputForm)

SemiRng

ConvertibleTo(Pattern(Float))

Monoid

PolynomialFactorizationExplicit

NonAssociativeAlgebra(R)

NonAssociativeAlgebra(%)

Algebra(Fraction(Integer))

BasicType

Ring

RightModule(Integer)

IndexedDirectProductCategory(R, IndexedExponents(VarSet))

Module(%)

ConvertibleTo(Pattern(Integer))

CoercibleFrom(Fraction(Integer))

LeftModule(Fraction(Integer))

NonAssociativeSemiRng

CoercibleFrom(R)

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

RetractableTo(Fraction(Integer))

RetractableTo(R)

PatternMatchable(Integer)

AbelianGroup