A Jordan algebra is a commutative yet nonassociative algebra with product \circ that satisfies the Jordan identity x\circ(x^2 \circ y) = x^2 \circ (x\circ y). Given an associative algebra, we can define a Jordan algebra on the same elements using the product x \circ y = (xy + yx)/2. A Jordan algebra V is Euclidean when there exists an inner product (x,y) on V that satisfies (x\circ y, z) = (y, x\circ z) for all x,y,z in V [FK94, p. 42]. Euclidean Jordan algebras are in one-to-one correspondence with structures known as symmetric cones, and any Euclidean Jordan algebra is the direct sum of simple Euclidean Jordan algebras [FK94, chap. 3].
The simple Euclidean Jordan algebras, in turn, are classified by rank and degree into four families and one exception [FK94, chap. 5]. The first family consists of rank 2 algebras with degree any positive integer. The remaining three families consist Jordan algebras with degree 1, 2, or 4 with rank a positive integer greater than 2. The exceptional algebra has rank 3 and degree 8.
The ALCO package provides a number of tools to construct and manipulate simple Euclidean Jordan algebras (described well in [FK94]), including their homotope and isotopes algebras (defined in [McC04, p. 86]). Among other applications, these tools can reproduce many of the examples found in [EG96] and [EG01].
‣ IsJordanAlgebra | ( filter ) |
‣ IsJordanAlgebraObj | ( filter ) |
These filters determine whether an element is a Jordan algebra (IsJordanAlgebra) or is an element in a Jordan algebra (IsJordanAlgebraObj).
‣ JordanRank( x ) | ( method ) |
‣ Rank( x ) | ( method ) |
The rank of a Jordan algeba is the size of a maximal set of mutually orthogonal primitive idempotents in the algebra. The rank and degree are used to classify the simple Euclidean Jordan algebras. This method returns the rank of x when IsJordanAlgebra(x) or the rank of the Jordan algebra containing x (computed as FamilyObj(x)!.fullSCAlgebra) when IsJordanAlgebraObj(x). The method Rank(x) returns JordanRank(x) when x satisfies either IsJordanAlgebra or IsJordanAlgebraObj.
‣ JordanDegree( x ) | ( method ) |
‣ Degree( x ) | ( method ) |
The degree of a Jordan algebra is the dimension of the off-diagonal entries in a Pierce decomposition of the Jordan algebra. For example, a Jordan algebra of quaternion hermitian matrices has degree 4. This method returns the degree of x when IsJordanAlgebra(x) or the degree of the Jordan algebra containing x (computed as FamilyObj(x)!.fullSCAlgebra) when IsJordanAlgebraObj(x). The method Degree(x) returns JordanDegree(x) when x satisfies either IsJordanAlgebra or IsJordanAlgebraObj.
Each vector in a simple Euclidean Jordan algebra can be written as a ℝ-linear combination of mutually orthogonal primitive idempotents. This is called the spectral decomposition of a Jordan algebra element. The coefficients in the decomposition are the eigenvalues of the element. The Jordan trace and determinant, described below, are respectively the sum and product of these eigenvalues with multiplicities included [FK94, p. 44].
‣ Trace( x ) | ( method ) |
Returns the Jordan trace of x when IsJordanAlgebraObj(x). The trace of a Jordan algebra element is the sum of the eigenvalues of that element (with multiplicies included).
‣ Determinant( x ) | ( method ) |
Returns the Jordan determinant of x when IsJordanAlgebraObj(x). The determinant of a Jordan algebra element is the product of the eigenvalues of that element (with multiplicies included).
‣ Norm( x ) | ( method ) |
Returns the Jordan norm of x when IsJordanAlgebraObj(x). The Jordan norm has the value Trace(x^2)/2.
‣ GenericMinimalPolynomial( x ) | ( attribute ) |
Returns the generic minimal polynomial of x when IsJordanAlgebraObj(x) as defined in [FKK+00, p. 478] (see also [FK94, pp. 27-31]). The output is given as a list of polynomial coefficients. Note that the generic minimal polynomial is a monic polynomial of degree equal to the rank of the Jordan algebra. The trace and determinant of a Jordan algebra element are, to within a sign, given by the coefficients of the second highest degree term and the constant term.
gap> J := AlbertAlgebra(Rationals);; gap> x := Sum(Basis(J){[4,5,6,25,26,27]}); i4+i5+i6+ei+ej+ek gap> [JordanRank(J), JordanDegree(J)]; [ 3, 8 ] gap> [JordanRank(x), JordanDegree(x)]; [ 3, 8 ] gap> p := GenericMinimalPolynomial(x); [ 2, 0, -3, 1 ] gap> Trace(x); 3 gap> Determinant(x); -2 gap> Norm(x); 9/2
The classification of simple Euclidean Jordan algebras is described in [FK94, chap. 5]. A simple Euclidean Jordan algebra can be constructed in the following two ways. A rank 2 algebra can be constructed from a positive definite Gram matrix in the manner described in [FK94, p. 25]. A degree 1, 2, 4, or 8 algebra can be constructed using Hermitian matrices over a composition algebra of dimension equal to the degree with the product (xy+yx)/2. In certain cases both constructions are possible. The ALCO package provides tools to use both constructions to create simple Euclidean Jordan algebras with elements that satisfy IsSCAlgebraObj.
‣ SimpleEuclideanJordanAlgebra( rho, d[, args] ) | ( function ) |
Returns a simple Euclidean Jordan algebra over ℚ. The construction used depends on the arguments given in the following manner.
For Jordan algebras of rank rho equal to 2, the JordanSpinFactor (3.2-2) construction is used. If optional args is empty then the result is JordanSpinFactor(IdentityMat(d+1)). If optional args is a symmetric matrix of dimension d+1, then JordanSpinFactor(args) is used. If neither of these rank 2 cases apply, and d is equal to 1,2,4, or 8, and if args is a composition algebra basis, then HermitianSimpleJordanAlgebra(rho, args) is used.
In the cases where rank rho is greater than 2, we must have d equal to one of 1, 2, 4, or 8. Note that d equals 8 is only permitted when rho equals 3. When optional args is a composition algebra basis of dimension d, HermitianSimpleJordanAlgebra(rho, args) is used. Otherwise, when optional args is empty, this function uses HermitianSimpleJordanAlgebra(rho, B) for B either CanonicalBasis(Rationals), Basis(CF(4), [1, E(4)]), CanonicalBasis(QuaternionAlgebra(Rationals)), or CanonicalBasis(OctonionAlgebra(Rationals)).
Note that (in contrast to AlbertAlgebra (3.3-1)) the Hermitian Jordan algebras constructed using SimpleEuclideanJordanAlgebra uses the upper triangular entries of the Hermitian matrices define the basis vectors.
gap> J := SimpleEuclideanJordanAlgebra(3,8); <algebra-with-one of dimension 27 over Rationals> gap> Derivations(Basis(J));; SemiSimpleType(last); "F4"
‣ JordanSpinFactor( G ) | ( function ) |
Returns a Jordan spin factor algebra when G is a positive definite Gram matrix. This is the Jordan algebra of rank 2 constructed from a symmetric bilinear form, as described in [FK94, p. 25].
gap> J := JordanSpinFactor(IdentityMat(8)); <algebra-with-one of dimension 9 over Rationals> gap> One(J); v.1 gap> [JordanRank(J), JordanDegree(J)]; [ 2, 7 ] gap> Derivations(Basis(J)); <Lie algebra of dimension 28 over Rationals> gap> SemiSimpleType(last); "D4" gap> x := Sum(Basis(J){[4,5,6,7]}); v.4+v.5+v.6+v.7 gap> [Trace(x), Determinant(x)]; [ 0, -4 ] gap> p := GenericMinimalPolynomial(x); [ -4, 0, 1 ] gap> ValuePol(p,x); 0*v.1
‣ HermitianSimpleJordanAlgebra( r, B ) | ( function ) |
Returns a simple Euclidean Jordan algebra of rank r with the basis for the off-diagonal components defined using composition algebra basis B.
gap> J := HermitianSimpleJordanAlgebra(3,QuaternionD4Basis); <algebra-with-one of dimension 15 over Rationals> gap> [JordanRank(J), JordanDegree(J)]; [ 3, 4 ]
‣ JordanHomotope( J, u[, s] ) | ( function ) |
For J a Jordan algebra satisfying IsJordanAlgebra(J ), and for u a vector in J, this function returns the corresponding u-homotope algebra with the product of x and y defined as x(uy)+(xu)y - u(xy). The u-homotope algebra also belongs to the filter IsJordanAlgebra.
Of note, if u is invertible in J then the corresponding u-homotope algebra is called a u-isotope. The optional argument s is a string that determines the labels of the canonical basis vectors in the new algebra. The main definitions and properties of Jordan homotopes and isotopes are given in [McC04, pp.82-86].
gap> J := SimpleEuclideanJordanAlgebra(2,7); <algebra-with-one of dimension 9 over Rationals> gap> u := Sum(Basis(J){[1,2,7,8]}); v.1+v.2+v.7+v.8 gap> Inverse(u); (-1/2)*v.1+(1/2)*v.2+(1/2)*v.7+(1/2)*v.8 gap> GenericMinimalPolynomial(u); [ -2, -2, 1 ] gap> H := JordanHomotope(J, u, "w."); <algebra-with-one of dimension 9 over Rationals> gap> One(H); (-1/2)*w.1+(1/2)*w.2+(1/2)*w.7+(1/2)*w.8
The exceptional simple Euclidean Jordan algebra, or Albert algebra, may be constructed using SimpleEuclideanJordanAlgebra (3.2-1) with rank 3 and degree 8. However, that construction uses the upper triangular entries of the Hermitian matrices define the basis vectors (i.e., the [1][2], [2][3], [1][3] entries). Much of the literature on the Albert algebra instead uses the [1][2], [2][3], [3][1] entries of the Hermitian matrices to define the basis vectors (see for example [Wil09a, pp. 147-148]). The ALCO package provides a specific construction of the Albert algebra that uses this convention for defining basis vectors, described below.
‣ AlbertAlgebra( F ) | ( function ) |
For F a field, this function returns an Albert algebra over F. For F = Rationals, this algebra is isomorphic to HermitianSimpleJordanAlgebra(3,8,Basis(Oct)) but in a basis that is more convenient for reproducing certain calculations in the literature. Specifically, while HermitianSimpleJordanAlgebra(3,8,Basis(Oct)) uses the upper-triangular elements of a Hermitian matrix as representative, AlbertAlgebra(F) uses the [1][2], [2][3], [3][1] entries as representative. These are respectively labeled using k,i,j.
gap> A := AlbertAlgebra(Rationals); <algebra-with-one of dimension 27 over Rationals> gap> i := Basis(A){[1..8]};; gap> j := Basis(A){[9..16]};; gap> k := Basis(A){[17..24]};; gap> e := Basis(A){[25..27]};; gap> Display(i); Display(j); Display(k); Display(e); [ i1, i2, i3, i4, i5, i6, i7, i8 ] [ j1, j2, j3, j4, j5, j6, j7, j8 ] [ k1, k2, k3, k4, k5, k6, k7, k8 ] [ ei, ej, ek ]
‣ AlbertVectorToHermitianMatrix( x ) | ( function ) |
For an element x in AlbertAlgebra(Rationals), this function returns the corresponding 3 x 3 Hermitian matrix with octonion entries in OctonionAlgebra(Rationals).
‣ HermitianMatrixToAlbertVector( x ) | ( function ) |
For 3 x 3 Hermitian matrix with elements in OctonionAlgebra(Rationals), this function returns the corresponding vector in in AlbertAlgebra(Rationals).
gap> j := Basis(AlbertAlgebra(Rationals)){[9..16]}; [ j1, j2, j3, j4, j5, j6, j7, j8 ] gap> mat := AlbertVectorToHermitianMatrix(j[3]);; Display(mat); [ [ 0*e1, 0*e1, (-1)*e3 ], [ 0*e1, 0*e1, 0*e1 ], [ e3, 0*e1, 0*e1 ] ] gap> HermitianMatrixToAlbertVector(mat); j3
Many important features of simple Euclidean Jordan algebra and their isotopes are related to the quadratic representation. This aspect of Jordan algebras is described well in [McC04, pp.82-86] and [FK94, pp. 32-38]. The following methods allow for the construction of Jordan quadratic maps and the standard triple product on a Jordan algebra.
‣ JordanQuadraticOperator( x[, y] ) | ( operation ) |
For x and y Jordan algebra elements, satisfying IsJordanAlgebraObj this operation applies two methods. In the case of JordanQuadraticOperator(x, y), this operation returns 2*x*(x*y) - (x^2)*y. In the case of JordanQuadraticOperator(x), this operation returns the matrix representing the quadratic map in the canonical basis of the Jordan algebra J containing x. For L(x) the matrix AdjointMatrix(CanonicalBasis(J), x), the operation JordanQuadraticOperator(x) returns the matrix 2 L(x)^2 - L(x^2).
gap> J := JordanSpinFactor(IdentityMat(3)); <algebra-with-one of dimension 4 over Rationals> gap> x := [-1,4/3,-1,1]*Basis(J); (-1)*v.1+(4/3)*v.2+(-1)*v.3+v.4 gap> y := [-1, -1/2, 2, -1/2]*Basis(J); (-1)*v.1+(-1/2)*v.2+(2)*v.3+(-1/2)*v.4 gap> JordanQuadraticOperator(x,y); (14/9)*v.1+(-79/18)*v.2+(-11/9)*v.3+(-53/18)*v.4 gap> JordanQuadraticOperator(x);; Display(last); [ [ 43/9, -8/3, 2, -2 ], [ -8/3, 7/9, -8/3, 8/3 ], [ 2, -8/3, -7/9, -2 ], [ -2, 8/3, -2, -7/9 ] ] gap> LinearCombination(Basis(J), JordanQuadraticOperator(x) > *ExtRepOfObj(y)) = JordanQuadraticOperator(x,y); true gap> ExtRepOfObj(JordanQuadraticOperator(x,y)) = > JordanQuadraticOperator(x)*ExtRepOfObj(y); true gap> JordanQuadraticOperator(2*x) = 4*JordanQuadraticOperator(x); true
‣ JordanTripleSystem( x, y, z ) | ( operation ) |
For Jordan algebra elements x, y, z satisfying IsJordanAlgebraObj, the operation JordanTripleSystem(x,y,z) returns the Jordan triple product defined in terms of the Jordan product as x*(y*z) + (x*y)*z - y*(x*z). Equivalently, 2*JordanTripleSystem(x,y,z) is equal to JordanQuadraticOperator(x+z, y) - JordanQuadraticOperator(x, y) - JordanQuadraticOperator(z, y).
gap> J := AlbertAlgebra(Rationals); <algebra-with-one of dimension 27 over Rationals> gap> i := Basis(J){[1..8]}; [ i1, i2, i3, i4, i5, i6, i7, i8 ] gap> j := Basis(J){[9..16]}; [ j1, j2, j3, j4, j5, j6, j7, j8 ] gap> k := Basis(J){[17..24]}; [ k1, k2, k3, k4, k5, k6, k7, k8 ] gap> e := Basis(J){[25..27]}; [ ei, ej, ek ] gap> List(i, x -> JordanTripleSystem(i[1],i[1],x)); [ i1, i2, i3, i4, i5, i6, i7, i8 ] gap> List(j, x -> 2*JordanTripleSystem(i[1],i[1],x)); [ j1, j2, j3, j4, j5, j6, j7, j8 ] gap> List(k, x -> 2*JordanTripleSystem(i[1],i[1],x)); [ k1, k2, k3, k4, k5, k6, k7, k8 ] gap> List(e, x -> JordanTripleSystem(i[1],i[1],x)); [ 0*i1, ej, ek ]
‣ HermitianJordanAlgebraBasis( r, B ) | ( function ) |
Returns a set of Hermitian matrices to serve as a basis for the Jordan algebra of rank r and degree given by the cardinality of composition algebra basis B. The elements spanning each off-diagonal components are determined by basis B.
gap> H := QuaternionAlgebra(Rationals);; gap> for x in HermitianJordanAlgebraBasis(2, Basis(H)) do Display(x); od; [ [ e, 0*e ], [ 0*e, 0*e ] ] [ [ 0*e, 0*e ], [ 0*e, e ] ] [ [ 0*e, e ], [ e, 0*e ] ] [ [ 0*e, i ], [ (-1)*i, 0*e ] ] [ [ 0*e, j ], [ (-1)*j, 0*e ] ] [ [ 0*e, k ], [ (-1)*k, 0*e ] ] gap> AsList(Basis(H)); [ e, i, j, k ]
‣ JordanMatrixBasis( J ) | ( attribute ) |
If IsJordanAlgebra( J ) and J has been constructed using HermitianSimpleJordanAlgebra (3.2-3), then the set of matrices corresponding to CanonicalBasis( J ) can be obtained using JordanMatrixBasis( J ).
‣ HermitianMatrixToJordanVector( mat, J ) | ( function ) |
Converts matrix mat into an element of Jordan algebra J.
gap> H := QuaternionAlgebra(Rationals);; gap> J := HermitianSimpleJordanAlgebra(2,Basis(H)); <algebra-with-one of dimension 6 over Rationals> gap> AsList(CanonicalBasis(J)); [ v.1, v.2, v.3, v.4, v.5, v.6 ] gap> JordanMatrixBasis(J);; for x in last do Display(x); od; [ [ e, 0*e ], [ 0*e, 0*e ] ] [ [ 0*e, 0*e ], [ 0*e, e ] ] [ [ 0*e, e ], [ e, 0*e ] ] [ [ 0*e, i ], [ (-1)*i, 0*e ] ] [ [ 0*e, j ], [ (-1)*j, 0*e ] ] [ [ 0*e, k ], [ (-1)*k, 0*e ] ] gap> List(JordanMatrixBasis(J), x -> HermitianMatrixToJordanVector(x, J)); [ v.1, v.2, v.3, v.4, v.5, v.6 ]
‣ JordanAlgebraGramMatrix( J ) | ( attribute ) |
For IsJordanAlgebra( J ), returns the Gram matrix on CanonicalBasis( J ) using inner product Trace(x*y).
gap> J := HermitianSimpleJordanAlgebra(2,OctonionE8Basis); <algebra-with-one of dimension 10 over Rationals> gap> List(Basis(J), x -> List(Basis(J), y -> Trace(x*y))) = > JordanAlgebraGramMatrix(J); true gap> DiagonalOfMat(JordanAlgebraGramMatrix(J)); [ 1, 1, 2, 2, 2, 2, 2, 2, 2, 2 ]
‣ JordanAdjugate( x ) | ( function ) |
For IsJordanAlgebraObj( x ), returns the adjugate of x, which satisfies x*JordanAdjugate(x) = One(x)*Determinant(x). When Determinant(x) is non-zero, JordanAdjugate(x) is proportional to Inverse(x).
‣ IsPositiveDefinite( x ) | ( filter ) |
For IsJordanAlgebraObj( x ), returns true when x is positive definite and false otherwise. This filter uses GenericMinimalPolynomial (3.1-7) to determine whether x is positive definite.
generated by GAPDoc2HTML