# FiniteRankNonAssociativeAlgebra R¶

naalgc.spad line 224 [edit on github]

A FiniteRankNonAssociativeAlgebra is a non associative algebra over a commutative ring `R`

which is a free `R`

-module of finite rank.

- 0: %
from AbelianMonoid

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

- ^: (%, PositiveInteger) -> %
from Magma

- alternative?: () -> Boolean
`alternative?()`

tests if`2*associator(a, a, b) = 0 = 2*associator(a, b, b)`

for all`a`

,`b`

in the algebra. Note: we only can test this; in general we don`'t`

know whether`2*a=0`

implies`a=0`

.

- antiAssociative?: () -> Boolean
`antiAssociative?()`

tests if multiplication in algebra is anti-associative, i.e.`(a*b)*c + a*(b*c) = 0`

for all`a`

,`b`

,`c`

in the algebra.

- antiCommutative?: () -> Boolean
`antiCommutative?()`

tests if`a*a = 0`

for all`a`

in the algebra. Note: this implies`a*b + b*a = 0`

for all`a`

and`b`

.

- antiCommutator: (%, %) -> %

- associative?: () -> Boolean
`associative?()`

tests if multiplication in algebra is associative.

- associator: (%, %, %) -> %
from NonAssociativeRng

- associatorDependence: () -> List Vector R if R has IntegralDomain
`associatorDependence()`

looks for the associator identities, i.e. finds a basis of the solutions of the linear combinations of the six permutations of`associator(a, b, c)`

which yield 0, for all`a`

,`b`

,`c`

in the algebra. The order of the permutations is`123 231 312 132 321 213`

.

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- commutative?: () -> Boolean
`commutative?()`

tests if multiplication in the algebra is commutative.

- commutator: (%, %) -> %
from NonAssociativeRng

- conditionsForIdempotents: Vector % -> List Polynomial R
`conditionsForIdempotents([v1, ..., vn])`

determines a complete list of polynomial equations for the coefficients of idempotents with respect to the`R`

-module basis`v1`

, …,`vn`

.

- coordinates: (%, Vector %) -> Vector R
`coordinates(a, [v1, ..., vn])`

returns the coordinates of`a`

with respect to the`R`

-module basis`v1`

, …,`vn`

.

- coordinates: (Vector %, Vector %) -> Matrix R
`coordinates([a1, ..., am], [v1, ..., vn])`

returns a matrix whose`i`

-th row is formed by the coordinates of`ai`

with respect to the`R`

-module basis`v1`

, …,`vn`

.

- flexible?: () -> Boolean
`flexible?()`

tests if`2*associator(a, b, a) = 0`

for all`a`

,`b`

in the algebra. Note: we only can test this; in general we don`'t`

know whether`2*a=0`

implies`a=0`

.

- jacobiIdentity?: () -> Boolean
`jacobiIdentity?()`

tests if`(a*b)*c + (b*c)*a + (c*a)*b = 0`

for all`a`

,`b`

,`c`

in the algebra. For example, this holds for crossed products of 3-dimensional vectors.

- jordanAdmissible?: () -> Boolean
`jordanAdmissible?()`

tests if 2 is invertible in the coefficient domain and the multiplication defined by`(1/2)(a*b+b*a)`

determines a Jordan algebra, i.e. satisfies the Jordan identity. The property of CommutativeStar follows from by definition.

- jordanAlgebra?: () -> Boolean
`jordanAlgebra?()`

tests if the algebra is commutative, characteristic is not 2, and`(a*b)*a^2 - a*(b*a^2) = 0`

for all`a`

,`b`

,`c`

in the algebra (Jordan identity). Example: for every associative algebra`(A, +, @)`

we can construct a Jordan algebra`(A, +, *)`

, where`a*b := (a@b+b@a)/2`

.

- latex: % -> String
from SetCategory

- leftAlternative?: () -> Boolean
`leftAlternative?()`

tests if`2*associator(a, a, b) = 0`

for all`a`

,`b`

in the algebra. Note: we only can test this; in general we don`'t`

know whether`2*a=0`

implies`a=0`

.

- leftCharacteristicPolynomial: % -> SparseUnivariatePolynomial R
`leftCharacteristicPolynomial(a)`

returns the characteristic polynomial of the left regular representation of`a`

with respect to any basis.

- leftDiscriminant: Vector % -> R
`leftDiscriminant([v1, ..., vn])`

returns the determinant of the`n`

-by-`n`

matrix whose element at the`i`

`-`

th row and`j`

`-`

th column is given by the left trace of the product`vi*vj`

. Note: the same as`determinant(leftTraceMatrix([v1, ..., vn]))`

.

- leftMinimalPolynomial: % -> SparseUnivariatePolynomial R if R has IntegralDomain
`leftMinimalPolynomial(a)`

returns the polynomial determined by the smallest non-trivial linear combination of left powers of`a`

. Note: the polynomial never has a constant term as in general the algebra has no unit.

- leftNorm: % -> R
`leftNorm(a)`

returns the determinant of the left regular representation of`a`

.

- leftPower: (%, PositiveInteger) -> %
from Magma

- leftRecip: % -> Union(%, failed) if R has IntegralDomain
`leftRecip(a)`

returns an element, which is a left inverse of`a`

, or`"failed"`

if there is no unit element, if such an element doesn`'t`

exist or cannot be determined (see unitsKnown).

- leftRegularRepresentation: (%, Vector %) -> Matrix R
`leftRegularRepresentation(a, [v1, ..., vn])`

returns the matrix`m`

of the linear map defined by left multiplication by`a`

with respect to the`R`

-module basis`b = [v1, ..., vn]`

. That is for all`x`

`coordinates(a*x, b) = m*coordinates(x, b)`

.

- leftTrace: % -> R
`leftTrace(a)`

returns the trace of the left regular representation of`a`

.

- leftTraceMatrix: Vector % -> Matrix R
`leftTraceMatrix([v1, ..., vn])`

is the`n`

-by-`n`

matrix whose element at the`i`

`-`

th row and`j`

`-`

th column is given by the left trace of the product`vi*vj`

.

- leftUnit: () -> Union(%, failed) if R has IntegralDomain
`leftUnit()`

returns a left unit of the algebra (not necessarily unique), or`"failed"`

if there is none.

- leftUnits: () -> Union(Record(particular: %, basis: List %), failed) if R has IntegralDomain
`leftUnits()`

returns the affine space of all left units of the algebra, or`"failed"`

if there is none.

- lieAdmissible?: () -> Boolean
`lieAdmissible?()`

tests if the algebra defined by the commutators is a Lie algebra, i.e. satisfies the Jacobi identity. The property of anticommutativity follows from definition.

- lieAlgebra?: () -> Boolean
`lieAlgebra?()`

tests if the algebra is anticommutative and`(a*b)*c + (b*c)*a + (c*a)*b = 0`

for all`a`

,`b`

,`c`

in the algebra (Jacobi identity). Example: for every associative algebra`(A, +, @)`

we can construct a Lie algebra`(A, +, *)`

, where`a*b := a@b-b@a`

.

- noncommutativeJordanAlgebra?: () -> Boolean
`noncommutativeJordanAlgebra?()`

tests if the algebra is flexible and Jordan admissible.

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

- plenaryPower: (%, PositiveInteger) -> %
from NonAssociativeAlgebra R

- powerAssociative?: () -> Boolean
`powerAssociative?()`

tests if all subalgebras generated by a single element are associative.

- rank: () -> PositiveInteger
`rank()`

returns the rank of the algebra as`R`

-module.

- recip: % -> Union(%, failed) if R has IntegralDomain
`recip(a)`

returns an element, which is both a left and a right inverse of`a`

, or`"failed"`

if there is no unit element, if such an element doesn`'t`

exist or cannot be determined (see unitsKnown).

- represents: (Vector R, Vector %) -> %
`represents([a1, ..., am], [v1, ..., vm])`

returns the linear combination`a1*vm + ... + an*vm`

.

- rightAlternative?: () -> Boolean
`rightAlternative?()`

tests if`2*associator(a, b, b) = 0`

for all`a`

,`b`

in the algebra. Note: we only can test this; in general we don`'t`

know whether`2*a=0`

implies`a=0`

.

- rightCharacteristicPolynomial: % -> SparseUnivariatePolynomial R
`rightCharacteristicPolynomial(a)`

returns the characteristic polynomial of the right regular representation of`a`

with respect to any basis.

- rightDiscriminant: Vector % -> R
`rightDiscriminant([v1, ..., vn])`

returns the determinant of the`n`

-by-`n`

matrix whose element at the`i`

`-`

th row and`j`

`-`

th column is given by the right trace of the product`vi*vj`

. Note: the same as`determinant(rightTraceMatrix([v1, ..., vn]))`

.

- rightMinimalPolynomial: % -> SparseUnivariatePolynomial R if R has IntegralDomain
`rightMinimalPolynomial(a)`

returns the polynomial determined by the smallest non-trivial linear combination of right powers of`a`

. Note: the polynomial never has a constant term as in general the algebra has no unit.

- rightNorm: % -> R
`rightNorm(a)`

returns the determinant of the right regular representation of`a`

.

- rightPower: (%, PositiveInteger) -> %
from Magma

- rightRecip: % -> Union(%, failed) if R has IntegralDomain
`rightRecip(a)`

returns an element, which is a right inverse of`a`

, or`"failed"`

if there is no unit element, if such an element doesn`'t`

exist or cannot be determined (see unitsKnown).

- rightRegularRepresentation: (%, Vector %) -> Matrix R
`rightRegularRepresentation(a, [v1, ..., vn])`

returns the matrix`m`

of the linear map defined by right multiplication by`a`

with respect to the`R`

-module basis`b = [v1, ..., vn]`

. That is for all`x`

`coordinates(x*a, b) = m*coordinates(x, b)`

.

- rightTrace: % -> R
`rightTrace(a)`

returns the trace of the right regular representation of`a`

.

- rightTraceMatrix: Vector % -> Matrix R
`rightTraceMatrix([v1, ..., vn])`

is the`n`

-by-`n`

matrix whose element at the`i`

`-`

th row and`j`

`-`

th column is given by the right trace of the product`vi*vj`

.

- rightUnit: () -> Union(%, failed) if R has IntegralDomain
`rightUnit()`

returns a right unit of the algebra (not necessarily unique), or`"failed"`

if there is none.

- rightUnits: () -> Union(Record(particular: %, basis: List %), failed) if R has IntegralDomain
`rightUnits()`

returns the affine space of all right units of the algebra, or`"failed"`

if there is none.

- sample: %
from AbelianMonoid

- someBasis: () -> Vector %
`someBasis()`

returns some`R`

-module basis.

- structuralConstants: Vector % -> Vector Matrix R
`structuralConstants([v1, v2, ..., vm])`

calculates the structural constants`[(gammaijk) for k in 1..m]`

defined by`vi * vj = gammaij1 * v1 + ... + gammaijm * vm`

, where`[v1, ..., vm]`

is an`R`

-module basis of a subalgebra.

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

- unit: () -> Union(%, failed) if R has IntegralDomain
`unit()`

returns a unit of the algebra (necessarily unique), or`"failed"`

if there is none.

- zero?: % -> Boolean
from AbelianMonoid

BiModule(R, R)

Module R

unitsKnown if R has IntegralDomain