From df112eac2a51ad6ef080762f91c20592d81b2c30 Mon Sep 17 00:00:00 2001 From: Benjamin Nasmith Date: Sun, 28 Jan 2024 13:07:21 -0600 Subject: [PATCH] Finished chap 3 edit --- doc/alco.xml | 269 +++++++++++++++++++++++++++---------------------- lib/alco.gd | 4 + lib/alco.gi | 39 +++++-- tst/alco03.tst | 189 ++++++++++++++++++++++++++++++++++ 4 files changed, 374 insertions(+), 127 deletions(-) create mode 100644 tst/alco03.tst diff --git a/doc/alco.xml b/doc/alco.xml index 87aa940..fd9c11a 100644 --- a/doc/alco.xml +++ b/doc/alco.xml @@ -529,6 +529,16 @@ true]]> Simple Euclidean Jordan Algebras + + 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 . + 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 .

+ + The simple Euclidean Jordan algebras, in turn, are classified into four families and one exception by rank and degree . 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 ), including their homotope and isotopes algebras (defined in ). Among other applications, these tools can reproduce many of the examples found in and . @@ -536,54 +546,70 @@ true]]> Filters and Basic Attributes Jordan Filters - - + + These filters determine whether an element is a Jordan algebra (IsJordanAlgebra) or is an element in a Jordan algebra (IsJordanAlgebraObj). - A simple Euclidean Jordan algebra V has rank r and degree d. The following methods return the properties of either a Jordan algebra or of the Jordan algebra containing the object. - - - Returns the rank of x when IsJordanAlgebra(x) or the rank of the Jordan algebra containing x when IsJordanAlgebraObj(x). + + 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 when IsJordanAlgebraObj(x). The method Rank(x) returns JordanRank(x) when x satisfies either IsJordanAlgebra or IsJordanAlgebraObj. - - Returns the degree of x when IsJordanAlgebra(x) or the - degree of the Jordan algebra containing x when IsJordanAlgebraObj(x) - . - + + + 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 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 &RR;-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 . - - Returns the Jordan trace of x when IsJordanAlgebraObj(x). + + 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). + - - Returns the Jordan norm of x when IsJordanAlgebraObj(x). The Jordan norm has the value Trace(x^2)/2. - + + 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). - - - Returns the generic minimal polynomial of x when IsJordanAlgebraObj(x) as defined in . The output is given as a list of polynomial coefficients. + + Returns the Jordan norm of x when IsJordanAlgebraObj(x). The Jordan norm has the value Trace(x^2)/2. + - - Returns the Jordan determinant of x when IsJordanAlgebraObj(x) - . + + Returns the generic minimal polynomial of x when IsJordanAlgebraObj(x) as defined in (see also ). 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. + 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]]> + - + + +

Jordan Algebra Constructions @@ -591,11 +617,14 @@ true]]> - Returns a simple Euclidean Jordan algebra over &QQ; in an orthogonal basis. - J := SimpleEuclideanJordanAlgebra(3,8); - -gap> SemiSimpleType(Derivations(Basis(J))); + Returns a simple Euclidean Jordan algebra over &QQ;. The classification of simple Euclidean Jordan algebras is described in . For Jordan algebras of rank rho equal to 2, this construction uses . 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 this function returns JordanSpinFactor(args). 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 this function returns HermitianSimpleJordanAlgebra(rho, args). + Finally, 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, this function returns HermitianSimpleJordanAlgebra(rho, args). + Otherwise, when optional args is empty, this function returns HermitianSimpleJordanAlgebra(rho, B) for B either Basis(Rationals, [1]), Basis(CF(4), [1, E(4)]), Basis(QuaternionAlgebra(Rationals)), or Basis(OctonionAlgebra(Rationals)). + Note that (in constrast to ) the Hermitian Jordan algebras constructed using SimpleEuclideanJordanAlgebra uses the upper triangular entries of the Hermitian matrices define the basis vectors. + J := SimpleEuclideanJordanAlgebra(3,8); + +gap> Derivations(Basis(J));; SemiSimpleType(last); "F4"]]> @@ -604,10 +633,9 @@ gap> SemiSimpleType(Derivations(Basis(J))); - Returns a Jordan spin factor algebra when G is a positive definite Gram matrix. - J := JordanSpinFactor(IdentityMat(8)); - + 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 . + J := JordanSpinFactor(IdentityMat(8)); + gap> One(J); v.1 gap> [JordanRank(J), JordanDegree(J)]; @@ -616,15 +644,14 @@ gap> Derivations(Basis(J)); gap> SemiSimpleType(last); "D4" -gap> x := Random(J); -v.2+(-1)*v.3+(-1)*v.4+(1/2)*v.5+(-2)*v.7+(1/2)*v.8+(-3/2)*v.9 +gap> x := Sum(Basis(J){[4,5,6,7]}); +v.4+v.5+v.6+v.7 gap> [Trace(x), Determinant(x)]; -[ 0, -39/4 ] +[ 0, -4 ] gap> p := GenericMinimalPolynomial(x); -[ -39/4, 0, 1 ] -gap> ValuePol(p, x); -0*v.1 -]]> +[ -4, 0, 1 ] +gap> ValuePol(p,x); +0*v.1]]> @@ -632,35 +659,29 @@ gap> ValuePol(p, x); Returns a simple Euclidean Jordan algebra of rank r with the basis for the off-diagonal components defined using composition algebra basis B. - B := OctonionE8Basis;; -gap> J := HermitianSimpleJordanAlgebra(3,B); - + J := HermitianSimpleJordanAlgebra(3,QuaternionD4Basis); + gap> [JordanRank(J), JordanDegree(J)]; -[ 3, 8 ] -gap> Derivations(Basis(J)); - -gap> SemiSimpleType(last); -"F4"]]> +[ 3, 4 ]]]> - 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. + 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 . J := SimpleEuclideanJordanAlgebra(2,7); - -gap> u := Random(J); -(-1/6)*v.1+(3)*v.2+(1/3)*v.3+(-2)*v.4+(-4)*v.6+(-1)*v.8+(-3)*v.9 + +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); -[ -469/12, 1/3, 1 ] -gap> H := JordanHomotope(J, u); - -gap> SemiSimpleType(Derivations(Basis(J))); -"D4" -gap> SemiSimpleType(Derivations(Basis(H))); -"D4"]]> +[ -2, -2, 1 ] +gap> H := JordanHomotope(J, u, "w."); + +gap> One(H); +(-1/2)*w.1+(1/2)*w.2+(1/2)*w.7+(1/2)*w.8]]> @@ -669,17 +690,19 @@ gap> SemiSimpleType(Derivations(Basis(H)));
The Albert Algebra - The exceptional simple Euclidean Jordan algebra, or Albert algebra, may be constructed using 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 ). The ALCO provides a specific construction of the Albert algebra that uses this convention for defining basis vectors, described below. + The exceptional simple Euclidean Jordan algebra, or Albert algebra, may be constructed using 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 ). The ALCO provides a specific construction of the Albert algebra that uses this convention for defining basis vectors, described below. 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. A := AlbertAlgebra(Rationals); - -gap> i := Basis(A){[1..8]}; j := Basis(A){[9..16]}; k := Basis(A){[17..24]}; e := Basis(A){[ -25..27]}; + +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 ] @@ -687,25 +710,18 @@ gap> i := Basis(A){[1..8]}; j := Basis(A){[9..16]}; k := Basis(A){[17..24]}; e : - - - - The ALCO package includes a loaded instance of the Albert algebra over the rationals. - Alb; -]]> - - - For an element x in Alb (see ), this function returns the corresponding 3 x 3 Hermitian matrix with octonion entries in OctonionAlgebra(Rationals) (see ). + For an element x in AlbertAlgebra(Rationals), this function returns the corresponding 3 x 3 Hermitian matrix with octonion entries in OctonionAlgebra(Rationals). For 3 x 3 Hermitian matrix with elements in OctonionAlgebra( - Rationals) (see ), this function returns the corresponding vector in in Alb (see ). - j := Basis(Alb){[9..16]}; + Rationals), this function returns the corresponding vector in in + AlbertAlgebra(Rationals). + 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 ], @@ -724,43 +740,58 @@ 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 and . The following methods allow for the construction of Jordan operators, including the left translation and the quadratic maps. - + For x and y Jordan algebra elements, satisfying IsJordanAlgebraObj this operation applies two methods. - In the case of P(x, y), this operation returns 2*x*(x*y) - (x^2)*y. - In the case of P(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 P(x) returns the matrix 2 L(x)^2 - L(x^2). + 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 P(x) returns the matrix 2 L(x)^2 - L(x^2). J := JordanSpinFactor(IdentityMat(3)); - -gap> x := Random(J); y := Random(J); + +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> P(x,y); +gap> JordanQuadraticOperator(x,y); (14/9)*v.1+(-79/18)*v.2+(-11/9)*v.3+(-53/18)*v.4 -gap> P(x);; Display(last); +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), P(x)*ExtRepOfObj(y)) = P(x,y); +gap> LinearCombination(Basis(J), JordanQuadraticOperator(x)*ExtRepOfObj(y)) = JordanQuadraticOperator(x,y); true -gap> ExtRepOfObj(P(x,y)) = P(x)*ExtRepOfObj(y); +gap> ExtRepOfObj(JordanQuadraticOperator(x,y)) = JordanQuadraticOperator(x)*ExtRepOfObj(y); true -gap> P(2*x) = 4*P(x); +gap> JordanQuadraticOperator(2*x) = 4*JordanQuadraticOperator(x); true]]> - + - For Jordan algebra elements x, y, z satisfying IsJordanAlgebraObj, JTS(x,y,z) returns the Jordan triple product defined in terms of the Jordan product as x*(y*z) + For Jordan algebra elements x, y, z satisfying IsJordanAlgebraObj, 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*JTS(x,y,z) is equal to P(x+z, y) - P(x, y) - P(z, y). - List(Basis(Alb), x -> JTS(i[1],i[1],x)); -[ i1, i2, i3, i4, i5, i6, i7, i8, (1/2)*j1, (1/2)*j2, (1/2)*j3, (1/2)*j4, (1/2)*j5, - (1/2)*j6, (1/2)*j7, (1/2)*j8, (1/2)*k1, (1/2)*k2, (1/2)*k3, (1/2)*k4, (1/2)*k5, - (1/2)*k6, (1/2)*k7, (1/2)*k8, 0*i1, ej, ek ]]]> + Equivalently, 2*JordanTripleSystem(x,y,z) is equal to JordanQuadraticOperator(x+z, y) - JordanQuadraticOperator(x, y) - JordanQuadraticOperator(z, y). + J := AlbertAlgebra(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 ]]]> @@ -774,9 +805,7 @@ true]]> Returns a set of Hermitian matrices to serve as a basis for the Jordan algebra with or 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. - H := QuaternionAlgebra(Rationals);; AsList(Basis(H)); -[ e, i, j, k ] + H := QuaternionAlgebra(Rationals);; gap> for x in HermitianJordanAlgebraBasis(2, Basis(H)) do Display(x); od; [ [ e, 0*e ], [ 0*e, 0*e ] ] @@ -789,7 +818,9 @@ gap> for x in HermitianJordanAlgebraBasis(2, Basis(H)) do Display(x); od; [ [ 0*e, j ], [ (-1)*j, 0*e ] ] [ [ 0*e, k ], - [ (-1)*k, 0*e ] ]]]> + [ (-1)*k, 0*e ] ] +gap> AsList(Basis(H)); +[ e, i, j, k ]]]> @@ -804,17 +835,24 @@ gap> for x in HermitianJordanAlgebraBasis(2, Basis(H)) do Display(x); od; Converts matrix mat into an element of Jordan algebra J. - - H := QuaternionAlgebra(Rationals);; AsList(Basis(H)); -[ e, i, j, k ] + H := QuaternionAlgebra(Rationals);; gap> J := HermitianSimpleJordanAlgebra(2,Basis(H)); - + gap> AsList(CanonicalBasis(J)); [ v.1, v.2, v.3, v.4, v.5, v.6 ] -gap> JordanMatrixBasis(J); -[ [ [ 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> 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 ]]]> @@ -825,26 +863,19 @@ gap> List(JordanMatrixBasis(J), x -> HermitianMatrixToJordanVector(x, J)); For IsJordanAlgebra( J ), returns the Gram matrix on CanonicalBasis( J ) using inner product Trace(x*y). J := HermitianSimpleJordanAlgebra(2,OctonionE8Basis); - -gap> Display(JordanAlgebraGramMatrix(J)); -[ [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], - [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ], - [ 0, 0, 2, 0, -1, 0, 0, 0, 0, 0 ], - [ 0, 0, 0, 2, 0, -1, 0, 0, 0, 0 ], - [ 0, 0, -1, 0, 2, -1, 0, 0, 0, 0 ], - [ 0, 0, 0, -1, -1, 2, -1, 0, 0, 0 ], - [ 0, 0, 0, 0, 0, -1, 2, -1, 0, 0 ], - [ 0, 0, 0, 0, 0, 0, -1, 2, -1, 0 ], - [ 0, 0, 0, 0, 0, 0, 0, -1, 2, -1 ], - [ 0, 0, 0, 0, 0, 0, 0, 0, -1, 2 ] ] ]]> + +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 ]]]> - 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). + 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). diff --git a/lib/alco.gd b/lib/alco.gd index 9f18c6f..043d298 100644 --- a/lib/alco.gd +++ b/lib/alco.gd @@ -146,6 +146,10 @@ DeclareCategory( "IsJordanAlgebraObj", IsSCAlgebraObj ); DeclareGlobalFunction( "GenericMinimalPolynomial" ); + DeclareAttribute( "JordanRank", IsJordanAlgebraObj ); + + DeclareAttribute( "JordanDegree", IsJordanAlgebraObj ); + DeclareAttribute( "JordanAdjugate", IsJordanAlgebraObj ); DeclareAttribute( "IsPositiveDefinite", IsJordanAlgebraObj ); diff --git a/lib/alco.gi b/lib/alco.gi index 3c05904..b1eef72 100644 --- a/lib/alco.gi +++ b/lib/alco.gi @@ -590,10 +590,22 @@ InstallMethod( Rank, J -> JordanRank(J) ); +InstallMethod( JordanRank, + "for a Jordan algebra element", + [ IsJordanAlgebraObj ], + j -> JordanRank(FamilyObj(j)!.fullSCAlgebra) + ); + InstallMethod( Rank, "for a Jordan algebra element", [ IsJordanAlgebraObj ], - j -> Rank(FamilyObj(j)!.fullSCAlgebra) + j -> JordanRank(j) + ); + +InstallMethod( JordanDegree, + "for a Jordan algebra element", + [ IsJordanAlgebraObj ], + j -> JordanDegree(FamilyObj(j)!.fullSCAlgebra) ); InstallMethod( Degree, @@ -605,7 +617,7 @@ InstallMethod( Degree, InstallMethod( Degree, "for a Jordan algebra element", [ IsJordanAlgebraObj ], - j -> Degree(FamilyObj(j)!.fullSCAlgebra) + j -> JordanDegree(j) ); InstallMethod( Trace, @@ -777,6 +789,9 @@ InstallGlobalFunction( HermitianSimpleJordanAlgebra, function(rho, comp_alg_basi # Record the composition algebra over F. C := UnderlyingLeftModule(comp_alg_basis); K := LeftActingDomain(C); + if Length(F) = 0 and IsSubset(Rationals, K) then + K := Rationals; + fi; # Ensure that the optional field argument contains the left acting domain of the basis. if Length(F) = 1 then F := F[1]; @@ -808,6 +823,7 @@ InstallGlobalFunction( HermitianSimpleJordanAlgebra, function(rho, comp_alg_basi filter:= IsSCAlgebraObj and IsJordanAlgebraObj; algebra := AlgebraByStructureConstantsArg([K, T], filter ); SetFilterObj( algebra, IsJordanAlgebra ); + SetFilterObj( algebra, IsAlgebraWithOne); # Assign various attributes to the algebra. SetJordanRank( algebra, rho ); SetJordanDegree( algebra, Length(comp_alg_basis) ); @@ -822,7 +838,8 @@ end ); InstallGlobalFunction( JordanSpinFactor, function(gram_mat) local result, T, n, m, z, temp, coeffs, filter; - if not IsMatrix(gram_mat) or Inverse(gram_mat) = fail then + if not IsMatrix(gram_mat) or Inverse(gram_mat) = fail or gram_mat <> TransposedMat(gram_mat) then + Display("Usage: JordanSpinFactor(G) requires to be a positive definite symmetric matrix."); return fail; fi; result := rec( ); @@ -844,6 +861,7 @@ InstallGlobalFunction( JordanSpinFactor, function(gram_mat) filter:= IsSCAlgebraObj and IsJordanAlgebraObj; result.algebra := AlgebraByStructureConstantsArg([result.F, T], filter ); SetFilterObj( result.algebra, IsJordanAlgebra ); + SetFilterObj( result.algebra, IsAlgebraWithOne); SetJordanRank( result.algebra, result.rho ); SetJordanDegree( result.algebra, result.d ); SetJordanHomotopeVector( result.algebra, One(result.algebra) ); @@ -887,6 +905,9 @@ InstallGlobalFunction( JordanHomotope , function(ring, u, label...) result.algebra := AlgebraByStructureConstantsArg([result.F, T], filter ); fi; SetFilterObj( result.algebra, IsJordanAlgebra ); + if Inverse(u) <> fail then + SetFilterObj( result.algebra, IsAlgebraWithOne); + fi; SetJordanRank( result.algebra, result.rho ); SetJordanDegree( result.algebra, result.d ); if HasJordanMatrixBasis( result.algebra) then @@ -912,11 +933,12 @@ InstallGlobalFunction( SimpleEuclideanJordanAlgebra, function(rho, d, args...) if rho = 2 then if Length(args) = 0 then return JordanSpinFactor(IdentityMat(d+1) ); - elif IsMatrix(args[1]) and DimensionsMat(args[1]) = [d+1, d+1] and Inverse(args[1]) <> fail then - return JordanSpinFactor(args[1] ); - elif d in [1,2,4,8] and IsBasis(args[1]) then + elif IsMatrix(args[1]) and DimensionsMat(args[1]) = [d+1, d+1] and TransposedMat(args[1]) = args[1] and Inverse(args[1]) <> fail then + return JordanSpinFactor(args[1] ); + elif d in [1,2,4,8] and IsBasis(args[1]) and Dimension(args[1]) = d then return HermitianSimpleJordanAlgebra(rho, args[1] ); - else + else + Display("Usage: SimpleEuclideanJordanAlgebra(2, d [, args]) where is either empty, a symmetric invertible matrix, or when = 1,2,4,8 can also be a basis for a composition algebra."); return fail; fi; fi; @@ -931,7 +953,7 @@ InstallGlobalFunction( SimpleEuclideanJordanAlgebra, function(rho, d, args...) elif d = 1 then return HermitianSimpleJordanAlgebra(rho, Basis(Rationals, [1]) ); fi; - elif IsBasis(args[1]) then + elif IsBasis(args[1]) and Dimension(args[1]) = d then return HermitianSimpleJordanAlgebra(rho, args[1] ); else return fail; @@ -1154,6 +1176,7 @@ InstallGlobalFunction( AlbertAlgebra, function( F ) SetGeneratorsOfAlgebra( A, GeneratorsOfAlgebraWithOne( A ) ); SetIsFullSCAlgebra( A, true ); SetFilterObj( A, IsJordanAlgebra ); + SetFilterObj( A, IsAlgebraWithOne); SetJordanRank( A, 3 ); SetJordanDegree( A, 8 ); SetJordanOffDiagonalBasis( A, Basis(OctonionAlgebra(Rationals)) ); diff --git a/tst/alco03.tst b/tst/alco03.tst new file mode 100644 index 0000000..d74d5bb --- /dev/null +++ b/tst/alco03.tst @@ -0,0 +1,189 @@ +# ALCO, chapter 3 +# +# DO NOT EDIT THIS FILE - EDIT EXAMPLES IN THE SOURCE INSTEAD! +# +# This file has been generated by AutoDoc. It contains examples extracted from +# the package documentation. Each example is preceded by a comment which gives +# the name of a GAPDoc XML file and a line range from which the example were +# taken. Note that the XML file in turn may have been generated by AutoDoc +# from some other input. +# +gap> START_TEST("alco03.tst"); + +# doc/ALCO.xml:593-607 +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 + +# doc/ALCO.xml:625-628 +gap> J := SimpleEuclideanJordanAlgebra(3,8); + +gap> Derivations(Basis(J));; SemiSimpleType(last); +"F4" + +# doc/ALCO.xml:637-654 +gap> J := JordanSpinFactor(IdentityMat(8)); + +gap> One(J); +v.1 +gap> [JordanRank(J), JordanDegree(J)]; +[ 2, 7 ] +gap> Derivations(Basis(J)); + +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 + +# doc/ALCO.xml:662-665 +gap> J := HermitianSimpleJordanAlgebra(3,QuaternionD4Basis); + +gap> [JordanRank(J), JordanDegree(J)]; +[ 3, 4 ] + +# doc/ALCO.xml:673-684 +gap> J := SimpleEuclideanJordanAlgebra(2,7); + +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."); + +gap> One(H); +(-1/2)*w.1+(1/2)*w.2+(1/2)*w.7+(1/2)*w.8 + +# doc/ALCO.xml:699-709 +gap> A := AlbertAlgebra(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 ] + +# doc/ALCO.xml:724-731 +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 + +# doc/ALCO.xml:748-766 +gap> J := JordanSpinFactor(IdentityMat(3)); + +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 + +# doc/ALCO.xml:777-794 +gap> J := AlbertAlgebra(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 ] + +# doc/ALCO.xml:808-823 +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 ] + +# doc/ALCO.xml:838-857 +gap> H := QuaternionAlgebra(Rationals);; +gap> J := HermitianSimpleJordanAlgebra(2,Basis(H)); + +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 ] + +# doc/ALCO.xml:865-870 +gap> J := HermitianSimpleJordanAlgebra(2,OctonionE8Basis); + +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 ] + +# +gap> STOP_TEST("alco03.tst", 1);