XFreeAlgebra(vl, R)

xpoly.spad line 28 [edit on github]

This category specifies operations for polynomials and formal series with non-commutative variables.

* : (%, %) -> %
from Magma
* : (%, R) -> %

x * r returns the product of x by r. Useful if R is a non-commutative Ring.

* : (R, %) -> %
from LeftModule(R)
* : (vl, %) -> %

v * x returns the product of a variable x by x.

* : (Integer, %) -> %
from AbelianGroup
* : (NonNegativeInteger, %) -> %
from AbelianMonoid
* : (PositiveInteger, %) -> %
from AbelianSemiGroup
+ : (%, %) -> %
from AbelianSemiGroup
- : % -> %
from AbelianGroup
- : (%, %) -> %
from AbelianGroup
0 : () -> %
from AbelianMonoid
1 : () -> %
from MagmaWithUnit
= : (%, %) -> Boolean
from BasicType
^ : (%, NonNegativeInteger) -> %
from MagmaWithUnit
^ : (%, PositiveInteger) -> %
from Magma
annihilate? : (%, %) -> Boolean
from Rng
antiCommutator : (%, %) -> %
from NonAssociativeSemiRng
associator : (%, %, %) -> %
from NonAssociativeRng
characteristic : () -> NonNegativeInteger
from NonAssociativeRing
coef : (%, %) -> R

coef(x, y) returns scalar product of x by y, the set of words being regarded as an orthogonal basis.

coef : (%, FreeMonoid(vl)) -> R

coef(x, w) returns the coefficient of the word w in x.

coerce : R -> %
from XAlgebra(R)
coerce : vl -> %

coerce(v) returns v.

coerce : FreeMonoid(vl) -> %
from CoercibleFrom(FreeMonoid(vl))
coerce : Integer -> %
from NonAssociativeRing
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
commutator : (%, %) -> %
from NonAssociativeRng
constant : % -> R

constant(x) returns the constant term of x.

constant? : % -> Boolean

constant?(x) returns true if x is constant.

latex : % -> String
from SetCategory
leftPower : (%, NonNegativeInteger) -> %
from MagmaWithUnit
leftPower : (%, PositiveInteger) -> %
from Magma
leftRecip : % -> Union(%, "failed")
from MagmaWithUnit
lquo : (%, %) -> %

lquo(x, y) returns the left simplification of x by y.

lquo : (%, vl) -> %

lquo(x, v) returns the left simplification of x by the variable v.

lquo : (%, FreeMonoid(vl)) -> %

lquo(x, w) returns the left simplification of x by the word w.

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

map(fn, x) returns Sum(fn(r_i) w_i) if x writes Sum(r_i w_i).

mindeg : % -> FreeMonoid(vl)

mindeg(x) returns the little word which appears in x. Error if x=0.

mindegTerm : % -> Record(k : FreeMonoid(vl), c : R)

mindegTerm(x) returns the term whose word is mindeg(x).

mirror : % -> %

mirror(x) returns Sum(r_i mirror(w_i)) if x writes Sum(r_i w_i).

monomial : (R, FreeMonoid(vl)) -> %

monomial(r, w) returns the product of the word w by the coefficient r.

monomial? : % -> Boolean

monomial?(x) returns true if x is a monomial

one? : % -> Boolean
from MagmaWithUnit
opposite? : (%, %) -> Boolean
from AbelianMonoid
plenaryPower : (%, PositiveInteger) -> % if R has CommutativeRing
from NonAssociativeAlgebra(R)
quasiRegular : % -> %

quasiRegular(x) return x minus its constant term.

quasiRegular? : % -> Boolean

quasiRegular?(x) return true if constant(x) is zero.

recip : % -> Union(%, "failed")
from MagmaWithUnit
retract : % -> R
from RetractableTo(R)
retract : % -> FreeMonoid(vl)
from RetractableTo(FreeMonoid(vl))
retractIfCan : % -> Union(R, "failed")
from RetractableTo(R)
retractIfCan : % -> Union(FreeMonoid(vl), "failed")
from RetractableTo(FreeMonoid(vl))
rightPower : (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower : (%, PositiveInteger) -> %
from Magma
rightRecip : % -> Union(%, "failed")
from MagmaWithUnit
rquo : (%, %) -> %

rquo(x, y) returns the right simplification of x by y.

rquo : (%, vl) -> %

rquo(x, v) returns the right simplification of x by the variable v.

rquo : (%, FreeMonoid(vl)) -> %

rquo(x, w) returns the right simplification of x by w.

sample : () -> %
from AbelianMonoid
sh : (%, %) -> % if R has CommutativeRing

sh(x, y) returns the shuffle-product of x by y. This multiplication is associative and commutative.

sh : (%, NonNegativeInteger) -> % if R has CommutativeRing

sh(x, n) returns the shuffle power of x to the n.

subtractIfCan : (%, %) -> Union(%, "failed")
from CancellationAbelianMonoid
varList : % -> List(vl)

varList(x) returns the list of variables which appear in x.

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

noZeroDivisors

CoercibleFrom(R)

Algebra(R)

RightModule(%)

Monoid

BiModule(R, R)

NonAssociativeAlgebra(R)

CoercibleFrom(FreeMonoid(vl))

CancellationAbelianMonoid

MagmaWithUnit

NonAssociativeRing

RightModule(R)

BiModule(%, %)

RetractableTo(FreeMonoid(vl))

LeftModule(%)

LeftModule(R)

SetCategory

CoercibleTo(OutputForm)

Rng

Magma

SemiGroup

XAlgebra(R)

unitsKnown

AbelianGroup

AbelianSemiGroup

NonAssociativeSemiRing

Module(R)

RetractableTo(R)

NonAssociativeRng

Ring

SemiRng

AbelianMonoid

NonAssociativeSemiRng

BasicType

SemiRing