# HomogeneousDistributedMultivariatePolynomial(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 total degree ordering refined by reverse lexicographic ordering with respect to the position that the variables appear in the list of variables parameter.

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, HomogeneousDirectProduct(# 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
characteristic: () -> NonNegativeInteger
charthRoot: % -> Union(%, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit or R has CharacteristicNonZero
coefficient: (%, HomogeneousDirectProduct(# vl, NonNegativeInteger)) -> R

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

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

from FreeModuleCategory(R, HomogeneousDirectProduct(# 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: HomogeneousDirectProduct(# vl, NonNegativeInteger), c: R) -> %
constructOrdered: List Record(k: HomogeneousDirectProduct(# vl, NonNegativeInteger), c: R) -> %
content: % -> R if R has GcdDomain
content: (%, OrderedVariableList vl) -> % if R has GcdDomain
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: % -> HomogeneousDirectProduct(# vl, NonNegativeInteger)

from AbelianMonoidRing(R, HomogeneousDirectProduct(# 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
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
factor: % -> Factored % if R has PolynomialFactorizationExplicit
factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
fmecg: (%, HomogeneousDirectProduct(# vl, NonNegativeInteger), R, %) -> %
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
ground: % -> R
hash: % -> SingleInteger

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

isExpt: % -> Union(Record(var: OrderedVariableList vl, exponent: NonNegativeInteger), failed)
isPlus: % -> Union(List %, failed)
isTimes: % -> Union(List %, failed)
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

leadingSupport: % -> HomogeneousDirectProduct(# vl, NonNegativeInteger)
leadingTerm: % -> Record(k: HomogeneousDirectProduct(# vl, NonNegativeInteger), c: R)
leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

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

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

listOfTerms: % -> List Record(k: HomogeneousDirectProduct(# vl, NonNegativeInteger), c: R)
mainVariable: % -> Union(OrderedVariableList vl, failed)
map: (R -> R, %) -> %
mapExponents: (HomogeneousDirectProduct(# vl, NonNegativeInteger) -> HomogeneousDirectProduct(# vl, NonNegativeInteger), %) -> %
minimumDegree: % -> HomogeneousDirectProduct(# vl, NonNegativeInteger)
minimumDegree: (%, List OrderedVariableList vl) -> List NonNegativeInteger
minimumDegree: (%, OrderedVariableList vl) -> NonNegativeInteger
monicDivide: (%, %, OrderedVariableList vl) -> Record(quotient: %, remainder: %)
monomial?: % -> Boolean
monomial: (%, List OrderedVariableList vl, List NonNegativeInteger) -> %
monomial: (%, OrderedVariableList vl, NonNegativeInteger) -> %
monomial: (R, HomogeneousDirectProduct(# vl, NonNegativeInteger)) -> %
monomials: % -> List %
multivariate: (SparseUnivariatePolynomial %, OrderedVariableList vl) -> %
multivariate: (SparseUnivariatePolynomial R, OrderedVariableList vl) -> %
numberOfMonomials: % -> 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, HomogeneousDirectProduct(# vl, NonNegativeInteger), %) -> %
prime?: % -> Boolean if R has PolynomialFactorizationExplicit
primitiveMonomials: % -> List %
primitivePart: % -> % if R has GcdDomain
primitivePart: (%, OrderedVariableList vl) -> % if R has GcdDomain
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: % -> %
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
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
squareFreePart: % -> % if R has GcdDomain
squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
subtractIfCan: (%, %) -> Union(%, failed)
support: % -> List HomogeneousDirectProduct(# vl, NonNegativeInteger)

from FreeModuleCategory(R, HomogeneousDirectProduct(# 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
univariate: (%, OrderedVariableList vl) -> SparseUnivariatePolynomial %
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