# IndexedProductCategory(A, S)ΒΆ

indexedp.spad line 12 [edit on github]

A: SetCategory

S: SetCategory

This category represents the product of some set with respect to an indexing set. The set `S`

is considered as the `basis elements\ ``''`

and the elements from `A`

as `coefficients\ ``''`

. Elements may have infinite support. For `Comparable`

(ordered) `S`

we assume that support of each element is well-orderd.

- 0: % if A has AbelianMonoid
from AbelianMonoid

- *: (Integer, %) -> % if A has AbelianGroup
from AbelianGroup

- *: (NonNegativeInteger, %) -> % if A has AbelianMonoid
from AbelianMonoid

- *: (PositiveInteger, %) -> % if A has AbelianMonoid
from AbelianSemiGroup

- +: (%, %) -> % if A has AbelianMonoid
from AbelianSemiGroup

- -: % -> % if A has AbelianGroup
from AbelianGroup

- -: (%, %) -> % if A has AbelianGroup
from AbelianGroup

- =: (%, %) -> Boolean if A has AbelianMonoid
from BasicType

- ~=: (%, %) -> Boolean if A has AbelianMonoid
from BasicType

- coerce: % -> OutputForm if A has AbelianMonoid
from CoercibleTo OutputForm

- construct: List Record(k: S, c: A) -> %
`construct(l)`

takes a list of terms and creates the object with these components. First components of elements of`l`

should be different.

- constructOrdered: List Record(k: S, c: A) -> % if S has Comparable
`constructOrdered(l)`

takes a list of terms and creates the object with these components. The list is assumed to be sorted (in reverse order) with respect to the ordering of`S`

. If`R`

is a monoid, then the list is assumend to contain no zero elements. Caution: No checking is performed, so this should only be used in cases where those conditions are assured. If in doubt use`construct`

.

- latex: % -> String if A has AbelianMonoid
from SetCategory

- leadingCoefficient: % -> A if S has Comparable
`leadingCoefficient(z)`

returns the coefficient of the leading (with respect to the ordering on the indexing set) monomial of`z`

. Error: if`z`

has no support.

- leadingMonomial: % -> % if S has Comparable
`leadingMonomial(x)`

returns the monomial supported by the first element from`S`

. Error: if`x`

has no support.

- leadingSupport: % -> S if S has Comparable
`leadingSupport(z)`

returns the index of leading (with respect to the ordering on the indexing set) monomial of`z`

. Error: if`z`

has no support.

- leadingTerm: % -> Record(k: S, c: A) if S has Comparable
`leadingTerm(x)`

returns the leading (with respect to the ordering on the indexing set) term of`z`

. Error: if`z`

has no support.

- map: (A -> A, %) -> %
`map(f, z)`

returns the new element created by applying the function`f`

to each component of the direct product element`z`

.

- monomial?: % -> Boolean
`monomial?(x)`

returns`true`

if`x`

is a single monomial, that is support of`x`

consists of a single element.

- monomial: (A, S) -> %
`monomial(a, s)`

constructs a direct product element with the`s`

component set to`a`

- opposite?: (%, %) -> Boolean if A has AbelianMonoid
from AbelianMonoid

- reductum: % -> % if S has Comparable
`reductum(z)`

returns a new element created by removing the leading coefficient/support pair from the element`z`

. Error: if`z`

has no support.

- sample: % if A has AbelianMonoid
from AbelianMonoid

- subtractIfCan: (%, %) -> Union(%, failed) if A has CancellationAbelianMonoid

- zero?: % -> Boolean if A has AbelianMonoid
from AbelianMonoid

AbelianGroup if A has AbelianGroup

AbelianMonoid if A has AbelianMonoid

AbelianSemiGroup if A has AbelianMonoid

BasicType if A has AbelianMonoid

CancellationAbelianMonoid if A has CancellationAbelianMonoid

CoercibleTo OutputForm if A has AbelianMonoid

SetCategory if A has AbelianMonoid