MaybeSkewPolynomialCategory(R, E, VarSet)

polycat.spad line 165 [edit on github]

The category for general multi-variate possibly skew polynomials over a ring R, in variables from VarSet, with exponents from the OrderedAbelianMonoidSup.

* : (%, %) -> %
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, E)
0 : () -> %
from AbelianMonoid
1 : () -> % if R has SemiRing
from MagmaWithUnit
= : (%, %) -> Boolean
from BasicType
^ : (%, 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, E)
characteristic : () -> NonNegativeInteger if R has Ring
from NonAssociativeRing
charthRoot : % -> Union(%, "failed") if R has CharacteristicNonZero
from CharacteristicNonZero
coefficient : (%, VarSet, NonNegativeInteger) -> %

coefficient(p, v, n) views the polynomial p as a univariate polynomial in v and returns the coefficient of the v^n term.

coefficient : (%, List(VarSet), List(NonNegativeInteger)) -> %

coefficient(p, lv, ln) views the polynomial p as a polynomial in the variables of lv and returns the coefficient of the term lv^ln, i.e. prod(lv_i ^ ln_i).

coefficient : (%, E) -> R
from AbelianMonoidRing(R, E)
coefficients : % -> List(R)
from FreeModuleCategory(R, E)
coerce : % -> % if R has CommutativeRing and % has VariablesCommuteWithCoefficients or R has IntegralDomain and % has VariablesCommuteWithCoefficients
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 -> % if R has RetractableTo(Integer) or R has Ring
from NonAssociativeRing
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
commutator : (%, %) -> % if R has Ring
from NonAssociativeRng
construct : List(Record(k : E, c : R)) -> %
from IndexedProductCategory(R, E)
constructOrdered : List(Record(k : E, c : R)) -> %
from IndexedProductCategory(R, E)
content : % -> R if R has GcdDomain
from FiniteAbelianMonoidRing(R, E)
degree : % -> E
from AbelianMonoidRing(R, E)
degree : (%, List(VarSet)) -> List(NonNegativeInteger)

degree(p, lv) gives the list of degrees of polynomial p with respect to each of the variables in the list lv.

degree : (%, VarSet) -> NonNegativeInteger

degree(p, v) gives the degree of polynomial p with respect to the variable v.

exquo : (%, %) -> Union(%, "failed") if R has EntireRing
from EntireRing
exquo : (%, R) -> Union(%, "failed") if R has EntireRing
from FiniteAbelianMonoidRing(R, E)
fmecg : (%, E, R, %) -> % if R has Ring
from FiniteAbelianMonoidRing(R, E)
ground : % -> R
from FiniteAbelianMonoidRing(R, E)
ground? : % -> Boolean
from FiniteAbelianMonoidRing(R, E)
latex : % -> String
from SetCategory
leadingCoefficient : % -> R
from IndexedProductCategory(R, E)
leadingMonomial : % -> %
from IndexedProductCategory(R, E)
leadingSupport : % -> E
from IndexedProductCategory(R, E)
leadingTerm : % -> Record(k : E, c : R)
from IndexedProductCategory(R, E)
leftPower : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
leftPower : (%, PositiveInteger) -> %
from Magma
leftRecip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
linearExtend : (Mapping(R, E), %) -> R if R has CommutativeRing
from FreeModuleCategory(R, E)
listOfTerms : % -> List(Record(k : E, c : R))
from IndexedDirectProductCategory(R, E)
mainVariable : % -> Union(VarSet, "failed")

mainVariable(p) returns the biggest variable which actually occurs in the polynomial p, or "failed" if no variables are present. fails precisely if polynomial satisfies ground?

map : (Mapping(R, R), %) -> %
from IndexedProductCategory(R, E)
mapExponents : (Mapping(E, E), %) -> %
from FiniteAbelianMonoidRing(R, E)
minimumDegree : % -> E
from FiniteAbelianMonoidRing(R, E)
monomial : (%, VarSet, NonNegativeInteger) -> %

monomial(a, x, n) creates the monomial a*x^n where a is a polynomial, x is a variable and n is a nonnegative integer.

monomial : (%, List(VarSet), List(NonNegativeInteger)) -> %

monomial(a, [v1..vn], [e1..en]) returns a*prod(vi^ei).

monomial : (R, E) -> %
from IndexedProductCategory(R, E)
monomial? : % -> Boolean
from IndexedProductCategory(R, E)
monomials : % -> List(%)

monomials(p) returns the list of non-zero monomials of polynomial p, i.e. monomials(sum(a_(i) X^(i))) = [a_(1) X^(1), ..., a_(n) X^(n)].

numberOfMonomials : % -> NonNegativeInteger
from IndexedDirectProductCategory(R, E)
one? : % -> Boolean if R has SemiRing
from MagmaWithUnit
opposite? : (%, %) -> Boolean
from AbelianMonoid
plenaryPower : (%, PositiveInteger) -> % if R has IntegralDomain and % has VariablesCommuteWithCoefficients or R has Algebra(Fraction(Integer)) or R has CommutativeRing and % has VariablesCommuteWithCoefficients
from NonAssociativeAlgebra(%)
pomopo! : (%, R, E, %) -> %
from FiniteAbelianMonoidRing(R, E)
primitiveMonomials : % -> List(%) if R has SemiRing

primitiveMonomials(p) gives the list of monomials of the polynomial p with their coefficients removed. Note: primitiveMonomials(sum(a_(i) X^(i))) = [X^(1), ..., X^(n)].

primitivePart : % -> % if R has GcdDomain
from FiniteAbelianMonoidRing(R, E)
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, E)
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)
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)
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
subtractIfCan : (%, %) -> Union(%, "failed")
from CancellationAbelianMonoid
support : % -> List(E)
from FreeModuleCategory(R, E)
totalDegree : % -> NonNegativeInteger

totalDegree(p) returns the largest sum over all monomials of all exponents of a monomial.

totalDegree : (%, List(VarSet)) -> NonNegativeInteger

totalDegree(p, lv) returns the maximum sum (over all monomials of polynomial p) of the variables in the list lv.

totalDegreeSorted : (%, List(VarSet)) -> NonNegativeInteger

totalDegreeSorted(p, lv) returns the maximum sum (over all monomials of polynomial p) of the degree in variables in the list lv. lv is assumed to be sorted in decreasing order.

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
variables : % -> List(VarSet)

variables(p) returns the list of those variables actually appearing in the polynomial p.

zero? : % -> Boolean
from AbelianMonoid
~= : (%, %) -> Boolean
from BasicType

CharacteristicNonZero

Module(Fraction(Integer))

Comparable

LeftModule(Fraction(Integer))

CoercibleFrom(R)

RightModule(%)

Monoid

NonAssociativeAlgebra(%)

Algebra(%)

Algebra(R)

AbelianMonoid

BiModule(R, R)

FiniteAbelianMonoidRing(R, E)

NonAssociativeAlgebra(Fraction(Integer))

FreeModuleCategory(R, E)

MagmaWithUnit

AbelianGroup

RightModule(Fraction(Integer))

RetractableTo(Integer)

unitsKnown

LinearlyExplicitOver(Integer)

AbelianMonoidRing(R, E)

Module(R)

LeftModule(%)

LeftModule(R)

canonicalUnitNormal

noZeroDivisors

CommutativeStar

Module(%)

SetCategory

Ring

Algebra(Fraction(Integer))

Rng

CommutativeRing

IntegralDomain

SemiRing

Magma

NonAssociativeAlgebra(R)

CoercibleFrom(Fraction(Integer))

NonAssociativeSemiRng

SemiGroup

CoercibleFrom(Integer)

CoercibleTo(OutputForm)

AbelianSemiGroup

FullyLinearlyExplicitOver(R)

RetractableTo(Fraction(Integer))

NonAssociativeSemiRing

CancellationAbelianMonoid

IndexedProductCategory(R, E)

IndexedDirectProductCategory(R, E)

AbelianProductCategory(R)

RightModule(R)

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

CharacteristicZero

RetractableTo(R)

RightModule(Integer)

NonAssociativeRng

LinearlyExplicitOver(R)

NonAssociativeRing

SemiRng

EntireRing

BasicType

BiModule(%, %)

FullyRetractableTo(R)

TwoSidedRecip