FiniteRankNonAssociativeAlgebra RΒΆ

naalgc.spad line 217

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: (%, %) -> %
from NonAssociativeSemiRng
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.
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?: () -> 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)
from CancellationAbelianMonoid
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

CoercibleTo OutputForm

LeftModule R

Magma

Module R

NonAssociativeAlgebra R

NonAssociativeRng

NonAssociativeSemiRng

RightModule R

SetCategory

unitsKnown if R has IntegralDomain