# DistributedMultivariatePolynomial(vl, R)¶

This type supports distributed multivariate polynomials whose variables are from a user specified list of symbols. The coefficient ring may be non commutative, but the variables are assumed to commute. The term ordering is lexicographic specified by the variable list parameter with the most significant variable first in the list.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

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

from RightModule R

*: (Fraction Integer, %) -> % if R has Algebra 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, DirectProduct(# vl, NonNegativeInteger))

=: (%, %) -> Boolean

from BasicType

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

annihilate?: (%, %) -> Boolean

from Rng

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

from EntireRing

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

from FiniteAbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

characteristic: () -> NonNegativeInteger
charthRoot: % -> Union(%, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit or R has CharacteristicNonZero
coefficient: (%, DirectProduct(# vl, NonNegativeInteger)) -> R

from AbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

coefficient: (%, List OrderedVariableList vl, List NonNegativeInteger) -> %
coefficient: (%, OrderedVariableList vl, NonNegativeInteger) -> %
coefficients: % -> List R

from FreeModuleCategory(R, DirectProduct(# vl, NonNegativeInteger))

coerce: % -> % if R has CommutativeRing

from Algebra %

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

from Algebra R

commutator: (%, %) -> %
conditionP: Matrix % -> Union(Vector %, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit
construct: List Record(k: DirectProduct(# vl, NonNegativeInteger), c: R) -> %

from IndexedProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

constructOrdered: List Record(k: DirectProduct(# vl, NonNegativeInteger), c: R) -> %

from IndexedProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

content: % -> R if R has GcdDomain

from FiniteAbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

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

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

convert: % -> InputForm if R has ConvertibleTo InputForm
convert: % -> Pattern Float if R has ConvertibleTo Pattern Float
convert: % -> Pattern Integer if R has ConvertibleTo Pattern Integer
D: (%, List OrderedVariableList vl) -> %
D: (%, List OrderedVariableList vl, List NonNegativeInteger) -> %
D: (%, OrderedVariableList vl) -> %
D: (%, OrderedVariableList vl, NonNegativeInteger) -> %
degree: % -> DirectProduct(# vl, NonNegativeInteger)

from AbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

degree: (%, List OrderedVariableList vl) -> List NonNegativeInteger
degree: (%, OrderedVariableList vl) -> NonNegativeInteger
differentiate: (%, List OrderedVariableList vl) -> %
differentiate: (%, List OrderedVariableList vl, List NonNegativeInteger) -> %
differentiate: (%, OrderedVariableList vl) -> %
differentiate: (%, OrderedVariableList vl, NonNegativeInteger) -> %
discriminant: (%, OrderedVariableList vl) -> % if R has CommutativeRing

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

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

from InnerEvalable(%, %)

eval: (%, Equation %) -> %

from Evalable %

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

from InnerEvalable(%, %)

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

from Evalable %

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

from InnerEvalable(OrderedVariableList vl, %)

eval: (%, List OrderedVariableList vl, List R) -> %

from InnerEvalable(OrderedVariableList vl, R)

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

from InnerEvalable(OrderedVariableList vl, %)

eval: (%, OrderedVariableList vl, R) -> %

from InnerEvalable(OrderedVariableList vl, R)

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

from EntireRing

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

from FiniteAbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

factor: % -> Factored % if R has PolynomialFactorizationExplicit
factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
fmecg: (%, DirectProduct(# vl, NonNegativeInteger), R, %) -> %

from FiniteAbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

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

from GcdDomain

gcd: List % -> % if R has GcdDomain

from GcdDomain

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

from GcdDomain

ground?: % -> Boolean

from FiniteAbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

ground: % -> R

from FiniteAbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

hash: % -> SingleInteger

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

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

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

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

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

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

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

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

from IndexedProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

from IndexedProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

leadingSupport: % -> DirectProduct(# vl, NonNegativeInteger)

from IndexedProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

leadingTerm: % -> Record(k: DirectProduct(# vl, NonNegativeInteger), c: R)

from IndexedProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

linearExtend: (DirectProduct(# vl, NonNegativeInteger) -> R, %) -> R if R has CommutativeRing

from FreeModuleCategory(R, DirectProduct(# vl, NonNegativeInteger))

listOfTerms: % -> List Record(k: DirectProduct(# vl, NonNegativeInteger), c: R)

from IndexedDirectProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

mainVariable: % -> Union(OrderedVariableList vl, failed)
map: (R -> R, %) -> %

from IndexedProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

mapExponents: (DirectProduct(# vl, NonNegativeInteger) -> DirectProduct(# vl, NonNegativeInteger), %) -> %

from FiniteAbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

minimumDegree: % -> DirectProduct(# vl, NonNegativeInteger)

from FiniteAbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

minimumDegree: (%, List OrderedVariableList vl) -> List NonNegativeInteger

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

minimumDegree: (%, OrderedVariableList vl) -> NonNegativeInteger

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

monicDivide: (%, %, OrderedVariableList vl) -> Record(quotient: %, remainder: %)

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

monomial?: % -> Boolean

from IndexedProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

monomial: (%, List OrderedVariableList vl, List NonNegativeInteger) -> %
monomial: (%, OrderedVariableList vl, NonNegativeInteger) -> %
monomial: (R, DirectProduct(# vl, NonNegativeInteger)) -> %

from IndexedProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

monomials: % -> List %
multivariate: (SparseUnivariatePolynomial %, OrderedVariableList vl) -> %

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

multivariate: (SparseUnivariatePolynomial R, OrderedVariableList vl) -> %

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

numberOfMonomials: % -> NonNegativeInteger

from IndexedDirectProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if OrderedVariableList vl has PatternMatchable Float and R has PatternMatchable Float
patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if OrderedVariableList vl has PatternMatchable Integer and R has PatternMatchable Integer
pomopo!: (%, R, DirectProduct(# vl, NonNegativeInteger), %) -> %

from FiniteAbelianMonoidRing(R, DirectProduct(# vl, NonNegativeInteger))

prime?: % -> Boolean if R has PolynomialFactorizationExplicit
primitiveMonomials: % -> List %
primitivePart: % -> % if R has GcdDomain

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

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

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

recip: % -> Union(%, failed)

from MagmaWithUnit

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

from LinearlyExplicitOver R

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

from LinearlyExplicitOver R

reductum: % -> %

from IndexedProductCategory(R, DirectProduct(# vl, NonNegativeInteger))

reorder: (%, List Integer) -> %

reorder(p, perm) applies the permutation perm to the variables in a polynomial and returns the new correctly ordered polynomial

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

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

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

from RetractableTo R

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

from RetractableTo R

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
squareFree: % -> Factored % if R has GcdDomain

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

squareFreePart: % -> % if R has GcdDomain

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
subtractIfCan: (%, %) -> Union(%, failed)
support: % -> List DirectProduct(# vl, NonNegativeInteger)

from FreeModuleCategory(R, DirectProduct(# vl, NonNegativeInteger))

totalDegree: % -> NonNegativeInteger
totalDegree: (%, List OrderedVariableList vl) -> NonNegativeInteger
totalDegreeSorted: (%, List OrderedVariableList vl) -> NonNegativeInteger
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, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

univariate: (%, OrderedVariableList vl) -> SparseUnivariatePolynomial %

from PolynomialCategory(R, DirectProduct(# vl, NonNegativeInteger), OrderedVariableList vl)

variables: % -> List OrderedVariableList vl
zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra % if R has CommutativeRing

Algebra R if R has CommutativeRing

BasicType

BiModule(%, %)

BiModule(R, R)

CancellationAbelianMonoid

CommutativeRing if R has CommutativeRing

CommutativeStar if R has CommutativeRing

Comparable if R has Comparable

EntireRing if R has EntireRing

GcdDomain if R has GcdDomain

InnerEvalable(%, %)

IntegralDomain if R has IntegralDomain

LeftOreRing if R has GcdDomain

Magma

MagmaWithUnit

Module % if R has CommutativeRing

Module R if R has CommutativeRing

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors if R has EntireRing

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip if R has CommutativeRing

unitsKnown

VariablesCommuteWithCoefficients