TensorPower(n, R, B, M)ΒΆ

tensor.spad line 310 [edit on github]

Tensor powers of a free module over a commutative ring. It is represented as a free module over the cartesian power of the basis.

0: %

from AbelianMonoid

1: % if M has Algebra R

from MagmaWithUnit

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

from Magma

*: (%, R) -> %

from RightModule R

*: (Integer, %) -> %

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

*: (R, %) -> %

from LeftModule R

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

=: (%, %) -> Boolean

from BasicType

^: (%, NonNegativeInteger) -> % if M has Algebra R

from MagmaWithUnit

^: (%, PositiveInteger) -> % if M has Algebra R

from Magma

~=: (%, %) -> Boolean

from BasicType

annihilate?: (%, %) -> Boolean if M has Algebra R

from Rng

antiCommutator: (%, %) -> % if M has Algebra R

from NonAssociativeSemiRng

associator: (%, %, %) -> % if M has Algebra R

from NonAssociativeRng

characteristic: () -> NonNegativeInteger if M has Algebra R

from NonAssociativeRing

coefficient: (%, Vector B) -> R

from FreeModuleCategory(R, Vector B)

coefficients: % -> List R

from FreeModuleCategory(R, Vector B)

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: Integer -> % if M has Algebra R

from NonAssociativeRing

coerce: R -> % if M has Algebra R

from Algebra R

commutator: (%, %) -> % if M has Algebra R

from NonAssociativeRng

construct: List Record(k: Vector B, c: R) -> %

from IndexedProductCategory(R, Vector B)

constructOrdered: List Record(k: Vector B, c: R) -> % if Vector B has Comparable

from IndexedProductCategory(R, Vector B)

latex: % -> String

from SetCategory

leadingCoefficient: % -> R if Vector B has Comparable

from IndexedProductCategory(R, Vector B)

leadingMonomial: % -> % if Vector B has Comparable

from IndexedProductCategory(R, Vector B)

leadingSupport: % -> Vector B if Vector B has Comparable

from IndexedProductCategory(R, Vector B)

leadingTerm: % -> Record(k: Vector B, c: R) if Vector B has Comparable

from IndexedProductCategory(R, Vector B)

leftPower: (%, NonNegativeInteger) -> % if M has Algebra R

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> % if M has Algebra R

from Magma

leftRecip: % -> Union(%, failed) if M has Algebra R

from MagmaWithUnit

linearExtend: (Vector B -> R, %) -> R

from FreeModuleCategory(R, Vector B)

listOfTerms: % -> List Record(k: Vector B, c: R)

from IndexedDirectProductCategory(R, Vector B)

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

from IndexedProductCategory(R, Vector B)

monomial?: % -> Boolean

from IndexedProductCategory(R, Vector B)

monomial: (R, Vector B) -> %

from IndexedProductCategory(R, Vector B)

monomials: % -> List %

from FreeModuleCategory(R, Vector B)

numberOfMonomials: % -> NonNegativeInteger

from IndexedDirectProductCategory(R, Vector B)

one?: % -> Boolean if M has Algebra R

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

plenaryPower: (%, PositiveInteger) -> % if M has Algebra R

from NonAssociativeAlgebra R

recip: % -> Union(%, failed) if M has Algebra R

from MagmaWithUnit

reductum: % -> % if Vector B has Comparable

from IndexedProductCategory(R, Vector B)

rightPower: (%, NonNegativeInteger) -> % if M has Algebra R

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> % if M has Algebra R

from Magma

rightRecip: % -> Union(%, failed) if M has Algebra R

from MagmaWithUnit

sample: %

from AbelianMonoid

smaller?: (%, %) -> Boolean if R has Comparable and Vector B has Comparable

from Comparable

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

from CancellationAbelianMonoid

support: % -> List Vector B

from FreeModuleCategory(R, Vector B)

tensor: (M, M) -> %

from TensorProductCategory(R, M, M)

tensor: List B -> %

tensor: List M -> %

from TensorPowerCategory(n, R, M)

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianProductCategory R

AbelianSemiGroup

Algebra R if M has Algebra R

BasicType

BiModule(%, %) if M has Algebra R

BiModule(R, R)

CancellationAbelianMonoid

CoercibleTo OutputForm

Comparable if R has Comparable and Vector B has Comparable

FreeModuleCategory(R, Vector B)

IndexedDirectProductCategory(R, Vector B)

IndexedProductCategory(R, Vector B)

LeftModule % if M has Algebra R

LeftModule R

Magma if M has Algebra R

MagmaWithUnit if M has Algebra R

Module R

Monoid if M has Algebra R

NonAssociativeAlgebra R if M has Algebra R

NonAssociativeRing if M has Algebra R

NonAssociativeRng if M has Algebra R

NonAssociativeSemiRing if M has Algebra R

NonAssociativeSemiRng if M has Algebra R

RightModule % if M has Algebra R

RightModule R

Ring if M has Algebra R

Rng if M has Algebra R

SemiGroup if M has Algebra R

SemiRing if M has Algebra R

SemiRng if M has Algebra R

SetCategory

TensorPowerCategory(n, R, M)

TensorProductCategory(R, M, M)

unitsKnown if M has Algebra R