HomogeneousDistributedMultivariatePolynomial(vl, R)

gdpoly.spad line 288 [edit on github]

• vl : List(Symbol)
• R : Ring

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.

* : (%, %) -> %

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, HomogeneousDirectProduct(#(vl), NonNegativeInteger))

0 : () -> %

from AbelianMonoid

1 : () -> %

from MagmaWithUnit

= : (%, %) -> Boolean

from BasicType

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

from PartialDifferentialRing(OrderedVariableList(vl))

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

from PartialDifferentialRing(OrderedVariableList(vl))

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

from PartialDifferentialRing(OrderedVariableList(vl))

D : (%, OrderedVariableList(vl), NonNegativeInteger) -> %

from PartialDifferentialRing(OrderedVariableList(vl))

^ : (%, 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, HomogeneousDirectProduct(#(vl), NonNegativeInteger))

characteristic : () -> NonNegativeInteger

from NonAssociativeRing

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

from CharacteristicNonZero

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

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

coefficient : (%, OrderedVariableList(vl), NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

coefficient : (%, HomogeneousDirectProduct(#(vl), NonNegativeInteger)) -> R

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

coefficients : % -> List(R)

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

coerce : % -> % if R has CommutativeRing

from Algebra(%)

coerce : R -> %

from Algebra(R)

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

from Algebra(Fraction(Integer))

coerce : Integer -> %

from NonAssociativeRing

coerce : OrderedVariableList(vl) -> %

from CoercibleFrom(OrderedVariableList(vl))

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

commutator : (%, %) -> %

from NonAssociativeRng

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

from PolynomialFactorizationExplicit

construct : List(Record(k : HomogeneousDirectProduct(#(vl), NonNegativeInteger), c : R)) -> %

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

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

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

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

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

content : % -> R if R has GcdDomain

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

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

from ConvertibleTo(InputForm)

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

from ConvertibleTo(Pattern(Float))

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

from ConvertibleTo(Pattern(Integer))

degree : % -> HomogeneousDirectProduct(#(vl), NonNegativeInteger)

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

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

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

degree : (%, OrderedVariableList(vl)) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

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

from PartialDifferentialRing(OrderedVariableList(vl))

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

from PartialDifferentialRing(OrderedVariableList(vl))

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

from PartialDifferentialRing(OrderedVariableList(vl))

differentiate : (%, OrderedVariableList(vl), NonNegativeInteger) -> %

from PartialDifferentialRing(OrderedVariableList(vl))

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

from PolynomialCategory(R, HomogeneousDirectProduct(#(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, HomogeneousDirectProduct(#(vl), NonNegativeInteger))

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 : (%, HomogeneousDirectProduct(#(vl), NonNegativeInteger), R, %) -> %

from FiniteAbelianMonoidRing(R, HomogeneousDirectProduct(#(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 PolynomialFactorizationExplicit

ground : % -> R

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

ground? : % -> Boolean

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

hash : % -> SingleInteger if R has Hashable

from Hashable

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

from Hashable

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

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

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

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

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

from PolynomialCategory(R, HomogeneousDirectProduct(#(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

leadingCoefficient : % -> R

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

leadingMonomial : % -> %

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

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

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

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

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

leftPower : (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower : (%, PositiveInteger) -> %

from Magma

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

from MagmaWithUnit

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

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

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

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

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

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

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

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

mapExponents : (Mapping(HomogeneousDirectProduct(#(vl), NonNegativeInteger), HomogeneousDirectProduct(#(vl), NonNegativeInteger)), %) -> %

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

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

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

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

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

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

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

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

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

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

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

monomial : (%, OrderedVariableList(vl), NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

monomial : (R, HomogeneousDirectProduct(#(vl), NonNegativeInteger)) -> %

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

monomial? : % -> Boolean

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

monomials : % -> List(%)

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

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

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

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

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

numberOfMonomials : % -> NonNegativeInteger

from IndexedDirectProductCategory(R, HomogeneousDirectProduct(#(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)

from PatternMatchable(Float)

patternMatch : (%, Pattern(Integer), PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if OrderedVariableList(vl) 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, HomogeneousDirectProduct(#(vl), NonNegativeInteger), %) -> %

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

prime? : % -> Boolean if R has PolynomialFactorizationExplicit

from UniqueFactorizationDomain

primitiveMonomials : % -> List(%)

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

primitivePart : % -> % if R has GcdDomain

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

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

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

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

from MagmaWithUnit

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, HomogeneousDirectProduct(#(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, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

retract : % -> R

from RetractableTo(R)

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

from RetractableTo(Fraction(Integer))

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

from RetractableTo(Integer)

retract : % -> OrderedVariableList(vl)

from RetractableTo(OrderedVariableList(vl))

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

from RetractableTo(R)

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(OrderedVariableList(vl), "failed")

from RetractableTo(OrderedVariableList(vl))

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, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

squareFreePart : % -> % if R has GcdDomain

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

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

from PolynomialFactorizationExplicit

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

from CancellationAbelianMonoid

support : % -> List(HomogeneousDirectProduct(#(vl), NonNegativeInteger))

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

totalDegree : % -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

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

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

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

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

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

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

univariate : % -> SparseUnivariatePolynomial(R)

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

variables : % -> List(OrderedVariableList(vl))

from MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

zero? : % -> Boolean

from AbelianMonoid

~= : (%, %) -> Boolean

from BasicType

CharacteristicNonZero

Module(Fraction(Integer))

NonAssociativeSemiRing

ConvertibleTo(Pattern(Integer))

LeftModule(R)

BiModule(%, %)

ConvertibleTo(InputForm)

canonicalUnitNormal

Rng

CoercibleFrom(Integer)

TwoSidedRecip

FullyRetractableTo(R)

SemiRing

EntireRing

NonAssociativeAlgebra(Fraction(Integer))

unitsKnown

FullyLinearlyExplicitOver(R)

noZeroDivisors

RetractableTo(Fraction(Integer))

UniqueFactorizationDomain

InnerEvalable(%, %)

SemiGroup

Magma

GcdDomain

IntegralDomain

PartialDifferentialRing(OrderedVariableList(vl))

LeftModule(%)

AbelianMonoidRing(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger))

PatternMatchable(Float)

CharacteristicZero

Module(R)

Algebra(%)

PolynomialFactorizationExplicit

BiModule(R, R)

RightModule(Fraction(Integer))

Algebra(R)

LinearlyExplicitOver(R)

InnerEvalable(OrderedVariableList(vl), %)

RightModule(R)

CommutativeRing

NonAssociativeSemiRng

CancellationAbelianMonoid

MaybeSkewPolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

InnerEvalable(OrderedVariableList(vl), R)

Comparable

RetractableTo(Integer)

SetCategory

CommutativeStar

VariablesCommuteWithCoefficients

AbelianMonoid

MagmaWithUnit

IndexedDirectProductCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger))

RightModule(%)

AbelianProductCategory(R)

Hashable

Evalable(%)

Module(%)

CoercibleTo(OutputForm)

PolynomialCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

ConvertibleTo(Pattern(Float))

SemiRng

LinearlyExplicitOver(Integer)

Monoid

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

NonAssociativeAlgebra(R)

LeftOreRing

NonAssociativeAlgebra(%)

Algebra(Fraction(Integer))

CoercibleFrom(OrderedVariableList(vl))

BasicType

Ring

RightModule(Integer)

AbelianSemiGroup

LeftModule(Fraction(Integer))

IndexedProductCategory(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger))

CoercibleFrom(Fraction(Integer))

NonAssociativeRng

NonAssociativeRing

CoercibleFrom(R)

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

RetractableTo(R)

PatternMatchable(Integer)

RetractableTo(OrderedVariableList(vl))

AbelianGroup

FiniteAbelianMonoidRing(R, HomogeneousDirectProduct(#(vl), NonNegativeInteger))