# 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.

hash: % -> SingleInteger

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

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