HomogeneousDistributedMultivariatePolynomial(vl, R)ΒΆ

gdpoly.spad line 289 [edit on github]

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

from RightModule Fraction Integer

*: (%, R) -> %

from RightModule R

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

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

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 % has CharacteristicNonZero and R has PolynomialFactorizationExplicit or R has CharacteristicNonZero

from PolynomialFactorizationExplicit

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

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

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)

coefficients: % -> List R

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

coerce: % -> % if R has CommutativeRing

from Algebra %

coerce: % -> OutputForm

from CoercibleTo OutputForm

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: R -> %

from Algebra R

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

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

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

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

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

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

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 GcdDomain

ground?: % -> Boolean

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

ground: % -> R

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

hash: % -> SingleInteger

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

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

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

mapExponents: (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?: % -> Boolean

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

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))

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

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 %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has LinearlyExplicitOver Integer

from LinearlyExplicitOver Integer

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)

from LinearlyExplicitOver R

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

from LinearlyExplicitOver Integer

reducedSystem: Matrix % -> Matrix R

from LinearlyExplicitOver R

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: % -> 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

retract: % -> R

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

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

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: % -> SparseUnivariatePolynomial R

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

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

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

variables: % -> List OrderedVariableList vl

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

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

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

AbelianProductCategory R

AbelianSemiGroup

Algebra % if R has CommutativeRing

Algebra Fraction Integer if R has Algebra Fraction Integer

Algebra R if R has CommutativeRing

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer) if R has Algebra Fraction Integer

BiModule(R, R)

CancellationAbelianMonoid

canonicalUnitNormal if R has canonicalUnitNormal

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CoercibleFrom Fraction Integer if R has RetractableTo Fraction Integer

CoercibleFrom Integer if R has RetractableTo Integer

CoercibleFrom OrderedVariableList vl

CoercibleFrom R

CoercibleTo OutputForm

CommutativeRing if R has CommutativeRing

CommutativeStar if R has CommutativeRing

Comparable if R has Comparable

ConvertibleTo InputForm if R has ConvertibleTo InputForm

ConvertibleTo Pattern Float if R has ConvertibleTo Pattern Float

ConvertibleTo Pattern Integer if R has ConvertibleTo Pattern Integer

EntireRing if R has EntireRing

Evalable %

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

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

FullyLinearlyExplicitOver R

FullyRetractableTo R

GcdDomain if R has GcdDomain

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

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

InnerEvalable(%, %)

InnerEvalable(OrderedVariableList vl, %)

InnerEvalable(OrderedVariableList vl, R)

IntegralDomain if R has IntegralDomain

LeftModule %

LeftModule Fraction Integer if R has Algebra Fraction Integer

LeftModule R

LeftOreRing if R has GcdDomain

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

LinearlyExplicitOver R

Magma

MagmaWithUnit

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

Module % if R has CommutativeRing

Module Fraction Integer if R has Algebra Fraction Integer

Module R if R has CommutativeRing

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors if R has EntireRing

PartialDifferentialRing OrderedVariableList vl

PatternMatchable Float if OrderedVariableList vl has PatternMatchable Float and R has PatternMatchable Float

PatternMatchable Integer if OrderedVariableList vl has PatternMatchable Integer and R has PatternMatchable Integer

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

PolynomialFactorizationExplicit if R has PolynomialFactorizationExplicit

RetractableTo Fraction Integer if R has RetractableTo Fraction Integer

RetractableTo Integer if R has RetractableTo Integer

RetractableTo OrderedVariableList vl

RetractableTo R

RightModule %

RightModule Fraction Integer if R has Algebra Fraction Integer

RightModule R

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip if R has CommutativeRing

UniqueFactorizationDomain if R has PolynomialFactorizationExplicit

unitsKnown

VariablesCommuteWithCoefficients