# FiniteRankNonAssociativeAlgebra R¶

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

=: (%, %) -> Boolean

from BasicType

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

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: (%, %, %) -> %
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
commutative?: () -> Boolean

`commutative?()` tests if multiplication in the algebra is commutative.

commutator: (%, %) -> %
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?()` 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?()` 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) -> %
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

AbelianGroup

AbelianMonoid

AbelianSemiGroup

BasicType

BiModule(R, R)

CancellationAbelianMonoid

Magma

NonAssociativeRng

NonAssociativeSemiRng

SetCategory

unitsKnown if R has IntegralDomain