Let C be a vector space over field k equipped with a non-degenerate quadratic form N:C \rightarrow k. If C is also an algebra with a product that satifies the composition rule N(x y) = N(x) N(y) for all x,y in C then we call C a composition algebra. Quaternions and octonions are examples of composition algebras.
As described in [SV00, Theorm 1.6.2], a composition algebra has dimension 1, 2, 4, or 8. Compositions algebras of dimension 1 or 2 are commutative and associative. A quaternion algebra is a composition algebra of dimension 4. Quaternion algebras are associative but noncommutative. An octonion algebra is a composition algebra of dimension 8. Octonion algebras are both noncommutative and nonassociative but still have many interesting properties.
The non-degenerate quadratic form N of a composition algebra is called the norm of that algebra. In fact, a composition algebra is determined up to isomorphism by its norm so the task of classifying composition algebras is equivalent to the task of classifying the possible norms in that vector space [SV00, chap. 1, sec. 7]. A norm is either isotropic or anisotropic according to whether or not there exists a non-zero element x such that N(x) = 0. A composition algebra with a isotropic norm is called a split composition algebra. A composition algebra with an anisotropic norm is called a division composition algebra since each non-zero element has an inverse. An important theorem [SV00, Theorem 1.8.1] shows that for each field k there exists up to isomorphism one split composition algebra of dimension 2, 4, and 8. The built-in OctaveAlgebra(F) function in GAP constructs the split-octonion algebra over the field given as the argument.
As described in [SV00, chap. 1, sec. 10], there are precisely one division composition algebra of dimension 4 and one of dimension 8 over the real number field (likewise over the rationals). The ALCO package provides constructions of non-split octonion algebras, provided that the algebra is constructed over a suitable field (e.g., octonions over any finite field are split).
‣ IsOctonion | ( filter ) |
‣ IsOctonionCollection | ( filter ) |
‣ IsOctonionAlgebra | ( filter ) |
These filters determine whether an element is an octonion, an octonion collection, or an octonion algebra.
‣ OctonionAlgebra( F ) | ( function ) |
Returns an octonion algebra over field F in a standard orthonormal basis \{e_{i}, i = 1,...,8\} such that 1 = e_8 is the identity element and e_{i} = e_{i+1}e_{i+3} = - e_{i+3}e_{i+1} for i = 1,...,7, with indices evaluated modulo 7. This corresponds to the basis provided in [Bae02] and [CS03] (except that e7 corresponds to e_0 in the literature, since the first entry in a GAP list has index 1). Whether or not the algebra constructed is a division algebra or a split-octonion algebra depends on the choice of field F. For example, OctonionAlgebra(Rationals) is a division composition algebra, but OctonionAlgebra(GF(3)) is a split composition algebra. Other examples are discussed in [SV00, chap. 1, sec. 10].
gap> O := OctonionAlgebra(Rationals); <algebra-with-one of dimension 8 over Rationals> gap> LeftActingDomain(O); Rationals gap> IsAssociative(O); false gap> e := BasisVectors(Basis(O)); [ e1, e2, e3, e4, e5, e6, e7, e8 ] gap> One(O); e8 gap> e[1]*e[2]; e4 gap> e[2]*e[1]; (-1)*e4 gap> Derivations(Basis(O)); <Lie algebra of dimension 14 over Rationals> gap> SemiSimpleType(last); "G2"
‣ OctavianIntegers | ( global variable ) |
‣ IsOctavianInt( x ) | ( operation ) |
The OctavianIntegers are a subring of the octonion algebra with elements that have the geometry of scaled E_8 lattice. This ring is named and studied in [CS03, p. 105]. CanonicalBasis(OctavianIntegers) returns OctonionE8Basis (2.1-4). We can test whether an octonion is in OctavianIntegers using the operation IsOctavianInt(x).
gap> a := BasisVectors(Basis(OctavianIntegers));; gap> for x in a do Display(x); od; (-1/2)*e1+(1/2)*e5+(1/2)*e6+(1/2)*e7 (-1/2)*e1+(-1/2)*e2+(-1/2)*e4+(-1/2)*e7 (1/2)*e2+(1/2)*e3+(-1/2)*e5+(-1/2)*e7 (1/2)*e1+(-1/2)*e3+(1/2)*e4+(1/2)*e5 (-1/2)*e2+(1/2)*e3+(-1/2)*e5+(1/2)*e7 (1/2)*e2+(-1/2)*e4+(1/2)*e5+(-1/2)*e6 (-1/2)*e1+(-1/2)*e3+(1/2)*e4+(-1/2)*e5 (1/2)*e1+(-1/2)*e4+(1/2)*e6+(-1/2)*e8 gap> ForAll(a, IsOctavianInt); true gap> ForAll(a/2, IsOctavianInt); false
‣ OctonionE8Basis | ( global variable ) |
The ALCO package also loads a basis for OctonionAlgebra(Rationals) which also serves as generators for OctavianIntegers (2.1-3). This octonion integer lattice has the geometry of a E_8 (Gossett) lattice relative to the inner product defined by the octonion norm.
gap> BasisVectors(OctonionE8Basis) = BasisVectors(Basis(OctavianIntegers)); true gap> g := List(OctonionE8Basis, x -> List(OctonionE8Basis, y -> > Norm(x+y) - Norm(x) - Norm(y)));; gap> IsGossetLatticeGramMatrix(g); true
‣ Norm( x ) | ( method ) |
Returns the norm of octonion x. Recall that an octonion algebra with norm N satisfies the composition property N(xy) = N(x)N(y). In the canonical basis for OctonionAlgebra (2.1-2), the norm is the sum of the squares of the coefficients.
gap> Oct := OctonionAlgebra(Rationals);; gap> List(Basis(Oct), Norm); [ 1, 1, 1, 1, 1, 1, 1, 1 ] gap> x := Random(Oct);; y := Random(Oct);; gap> Norm(x*y) = Norm(x)*Norm(y); true
‣ Trace( x ) | ( method ) |
Returns the trace of octonion x. In the canonical basis for OctonionAlgebra (2.1-2), the trace is twice the coefficient of the identity element e8. The trace and real part are related via RealPart(x) = Trace(x)*One(x)/2. Note that Trace(x) is an element of LeftActingDomain(A), where A is the octonion algebra containing x.
gap> e := BasisVectors(Basis(OctonionAlgebra(Rationals))); [ e1, e2, e3, e4, e5, e6, e7, e8 ] gap> List(e, Trace); [ 0, 0, 0, 0, 0, 0, 0, 2 ] gap> List(e, RealPart); [ 0*e1, 0*e1, 0*e1, 0*e1, 0*e1, 0*e1, 0*e1, e8 ]
‣ ComplexConjugate( x ) | ( method ) |
Returns the octonion conjugate of octonion x, defined by One(x)*Trace(x) - x. In the canonical basis of OctonionAlgebra (2.1-2), this method negates the coefficients of e_1, e_2, \ldots, e_7 but leaves the identity e_8 fixed.
gap> e := BasisVectors(Basis(OctonionAlgebra(Rationals))); [ e1, e2, e3, e4, e5, e6, e7, e8 ] gap> List(e, ComplexConjugate); [ (-1)*e1, (-1)*e2, (-1)*e3, (-1)*e4, (-1)*e5, (-1)*e6, (-1)*e7, e8 ]
‣ RealPart( x ) | ( method ) |
Returns the real component of octonion x, defined by (1/2)*One(x)*Trace(x). Note that RealPart returns an octonion in the subspace spanned by the octonion identity element while Trace returns an element in the coefficient field of the octonion algebra.
gap> e := BasisVectors(Basis(OctonionAlgebra(Rationals))); [ e1, e2, e3, e4, e5, e6, e7, e8 ] gap> List(e, RealPart); [ 0*e1, 0*e1, 0*e1, 0*e1, 0*e1, 0*e1, 0*e1, e8 ]
‣ OctonionToRealVector( B, x ) | ( function ) |
‣ RealToOctonionVector( B, y ) | ( function ) |
Let x be an octonion vector of the form x = (x_1, x_2, ..., x_n), for x_i octonion valued coefficients. Let B be a basis for the octonion algebra containing coefficients x_i. The function OctonionToRealVector(B, x) returns a vector y of length 8n containing the concatenation of the coefficients of x_i in the octonion basis given by B. The function RealToOctonionVector(B, y) provides the inverse operation.
gap> O := UnderlyingLeftModule(OctonionE8Basis); <algebra-with-one of dimension 8 over Rationals> gap> BasisVectors(CanonicalBasis(O)); [ e1, e2, e3, e4, e5, e6, e7, e8 ] gap> x := 2*OctonionE8Basis{[1,2]}; [ (-1)*e1+e5+e6+e7, (-1)*e1+(-1)*e2+(-1)*e4+(-1)*e7 ] gap> y := OctonionToRealVector(CanonicalBasis(O), x); [ -1, 0, 0, 0, 1, 1, 1, 0, -1, -1, 0, -1, 0, 0, -1, 0 ] gap> RealToOctonionVector(CanonicalBasis(O), y); [ (-1)*e1+e5+e6+e7, (-1)*e1+(-1)*e2+(-1)*e4+(-1)*e7 ]
‣ VectorToIdempotentMatrix( x ) | ( function ) |
Let x be a vector satisfying IsHomogeneousList and IsAssociative with elements that satisfy IsCyc, IsQuaternion, or IsOctonion. Then this function returns the idempotent matrix M/Trace(M) where M = TransposedMat([ComplexConjugate(x)])*[x].
gap> Oct := OctonionAlgebra(Rationals);; gap> x := Basis(Oct){[8,1,2]}; [ e8, e1, e2 ] gap> y := VectorToIdempotentMatrix(x);; Display(y); [ [ (1/3)*e8, (1/3)*e1, (1/3)*e2 ], [ (-1/3)*e1, (1/3)*e8, (-1/3)*e4 ], [ (-1/3)*e2, (1/3)*e4, (1/3)*e8 ] ] gap> IsIdempotent(y); true
‣ WeylReflection( r, x ) | ( function ) |
Let r be a vector satisfying IsHomogeneousList and IsAssociative with elements in IsCyc, IsQuaternion, or IsOctonion and let IsHomogeneousList(Flat([r,x])). Then this function returns the Weyl reflection of vector x using the projector defined by VectorToIdempotentMatrix(r). Specifically, the result is x - 2*x*VectorToIdempotentMatrix(r).
gap> WeylReflection([1,0,1],[0,1,1]); [ -1, 1, 0 ]
The ALCO package provides some additional tools for studying quaternion algebras in GAP. These tools include methods to compute the quaternion norm and trace, certain important bases, and the subrings generated by those bases. GAP already provides some built-in tools to construct and study the quaternion algebra in the standard Hamiltonian basis. The following example illustrates these tools:
gap> H := QuaternionAlgebra(Rationals); <algebra-with-one of dimension 4 over Rationals> gap> IsQuaternion(Random(H)); true gap> IsAssociative(H); true gap> IsCommutative(H); false gap> One(H); e gap> b := BasisVectors(CanonicalBasis(H)); [ e, i, j, k ] gap> List(b, ComplexConjugate); [ e, (-1)*i, (-1)*j, (-1)*k ] gap> List(b, Inverse); [ e, (-1)*i, (-1)*j, (-1)*k ] gap> List(b, RealPart); [ e, 0*e, 0*e, 0*e ] gap> List(b, ImaginaryPart); [ 0*e, e, k, (-1)*j ]
Note that the GAP method ImaginaryPart acting on objects that satisfy IsQuaternion involves dividing by i, which yields a different result than the x - RealPart(x) that some users may expect. The ALCO package does not define an ImaginaryPart method for octonions in order to avoid confusion about the behaviour of that method when applied to quaternions or octonions.
‣ Norm( x ) | ( method ) |
Returns the norm of quaternion x. Recall that a quaternion algebra with norm N satisfies the composition property N(xy) = N(x)N(y). In the canonical basis of QuaternionAlgebra, the norm is the sum of the squares of the coefficients.
gap> H := QuaternionAlgebra(Rationals);; gap> b := BasisVectors(CanonicalBasis(H)); [ e, i, j, k ] gap> List(b, Norm); [ 1, 1, 1, 1 ] gap> x := Random(H);; y := Random(H);; gap> Norm(x*y) = Norm(x)*Norm(y); true
‣ Trace( x ) | ( method ) |
Returns the trace of quaternion x, such that RealPart(x) = Trace(x)*One(x)/2. In the canonical basis of QuaternionAlgebra, the trace is twice the coefficient of the identity element.
gap> H := QuaternionAlgebra(Rationals);; gap> b := BasisVectors(CanonicalBasis(H)); [ e, i, j, k ] gap> List(b, Trace); [ 2, 0, 0, 0 ]
‣ HurwitzIntegers | ( global variable ) |
‣ IsHurwitzInt( x ) | ( operation ) |
The HurwitzIntegers are a subring of the quaternion algebra with elements that have the geometry of scaled D_4 lattice. This ring is named and studied in [CS03, p. 55]. CanonicalBasis(HurwitzIntegers) returns QuaternionD4Basis (2.4-4). We can test whether a quaternion is in HurwitzIntegers using the operation IsHurwitzInt(x).
gap> f := BasisVectors(Basis(HurwitzIntegers));; gap> for x in f do Display(x); od; (-1/2)*e+(-1/2)*i+(-1/2)*j+(1/2)*k (-1/2)*e+(-1/2)*i+(1/2)*j+(-1/2)*k (-1/2)*e+(1/2)*i+(-1/2)*j+(-1/2)*k e gap> ForAll(f, IsHurwitzInt); true gap> ForAll(f/2, IsHurwitzInt); false
‣ QuaternionD4Basis | ( global variable ) |
The ALCO package loads a basis for a quaternion algebra over ℚ with the geometry of a D_4 simple root system. The ℤ-span of this basis is the HurwitzIntegers (2.4-3) ring. These basis vectors close under pairwise reflection or multiplication to form a D_4 root system.
gap> B := QuaternionD4Basis;; gap> for x in BasisVectors(B) do Display(x); od; (-1/2)*e+(-1/2)*i+(-1/2)*j+(1/2)*k (-1/2)*e+(-1/2)*i+(1/2)*j+(-1/2)*k (-1/2)*e+(1/2)*i+(-1/2)*j+(-1/2)*k e
The icosian ring is a subring of the quaternion algebra over the "golden field" \mathbb{Q}(\sqrt{5}) This ring is described and studied in [CS13, pp. 207-211] and [Wil09a, p. 220]. The icosian ring has 120 units, or elements with quaternion norm of 1. These units are closed under quaternion multiplication. These icosian units also exhibit a H_4 geometry in the sense that they are closed under Weyl reflection relative to the standard Euclidean inner product defined by the quaternion norm. The Coxeter group generated by these reflections is the group W(H_4). The coefficients of an icosian in the standard quaternion basis belong to the integer subring of the golden field, meaning that these coefficients have the form a + b \sigma, where a,b are rational integers and \sigma = (1-\sqrt{5})/2. The Euclidean inner product between any two icosians will be a golden field integer. As described in the references given above, if we define a new inner product between icosians that discards the \sigma-coefficient b then the icosian ring will exhibit the geometry of an E_8 lattice relative to this new inner product. It is also possible to define a Leech lattice geometry on icosian triples.
The ALCO package provides tools to explore these icosian properties and construct certain important lattices using icosians. Note that the golden field can be constructed in GAP as NF(5, [ 1, 4 ]) or Field(Sqrt(5)) and that \sigma is given by -EB(5).
‣ IcosianRing | ( global variable ) |
‣ IsIcosian( x ) | ( operation ) |
The IcosianRing is a subring of the the quaternion algebra over NF(5,[1,4]) generated by a set of vectors with an H_4 geometry. This ring is described well in [Wil09a, p. 220]. CanonicalBasis(IcosianRing) returns IcosianH4Generators (2.5-2). We can test whether a quaternion is in IcosianRing using the operation IsIcosian(x). Note that a quaternion is an icosian when it is a ℤ-linear combination of the union of Basis(IcosianRing) and Basis(IcosianRing)*EB(5).
gap> f := BasisVectors(Basis(IcosianRing));; gap> for x in f do Display(x); od; (-1)*i (-1/2*E(5)^2-1/2*E(5)^3)*i+(1/2)*j+(-1/2*E(5)-1/2*E(5)^4)*k (-1)*j (-1/2*E(5)-1/2*E(5)^4)*e+(1/2)*j+(-1/2*E(5)^2-1/2*E(5)^3)*k gap> ForAll(f, IsIcosian); true gap> ForAll(f/2, IsIcosian); false gap> ForAll(f*EB(5), IsIcosian); true gap> ForAll(f*Sqrt(5), IsIcosian); true gap> ForAll(f*(1-Sqrt(5))/2, IsIcosian); true gap> ForAll(f*(1+Sqrt(5))/2, IsIcosian); true
‣ IcosianH4Generators | ( global variable ) |
The ALCO package loads this variable as a basis for a quaternion algebra over NF(5,[1,4]). Note that a quaternion is an icosian when it is a ℤ-linear combination of the union of IcosianH4Generators and IcosianH4Generators*EB(5). These basis vectors close under pairwise reflection or multiplication to form a H_4 set of vectors.
gap> f := BasisVectors(IcosianH4Generators);; gap> for x in f do Display(x); od; (-1)*i (-1/2*E(5)^2-1/2*E(5)^3)*i+(1/2)*j+(-1/2*E(5)-1/2*E(5)^4)*k (-1)*j (-1/2*E(5)-1/2*E(5)^4)*e+(1/2)*j+(-1/2*E(5)^2-1/2*E(5)^3)*k
‣ GoldenModSigma( x ) | ( function ) |
For x in the golden field NF(5,[ 1, 4 ]), this function returns the rational coefficient of 1 in the basis Basis(NF(5,[ 1, 4 ]), [1, (1-Sqrt(5))/2]).
gap> sigma := (1-Sqrt(5))/2;; tau := (1+Sqrt(5))/2;; gap> x := 5 + 3*sigma;; GoldenModSigma(x); 5 gap> GoldenModSigma(sigma); 0 gap> GoldenModSigma(tau); 1
Certain addition integer subrings of elements satisfying IsCyc are also included in the ALCO package. The rings constructed below are described in [CS03, pp. 16-18].
‣ EisensteinIntegers | ( global variable ) |
‣ IsEisenInt( x ) | ( operation ) |
The EisensteinIntegers is a subring of the complex numbers generated by 1 and E(3). This subring has the geometry of an A_2 lattice. This ring is described well in [CS03, p. 16]. We can test whether an element in IsCyc is an Eisenstein integer using the operation IsEisenInt(x).
gap> f := BasisVectors(Basis(EisensteinIntegers)); [ 1, E(3) ] gap> IsEisenInt(E(4)); false gap> IsEisenInt(1+E(3)^2); true
‣ KleinianIntegers | ( global variable ) |
‣ IsKleinInt( x ) | ( operation ) |
The KleinianIntegers is a subring of the complex numbers generated by 1 and (1/2)*(-1+Sqrt(-7)). This ring is described in [CS03, p. 18]. We can test whether an element in IsCyc is an Kleinian integer using the operation IsKleinInt(x).
gap> f := BasisVectors(Basis(KleinianIntegers)); [ 1, E(7)+E(7)^2+E(7)^4 ] gap> IsKleinInt(E(4)); false gap> IsKleinInt(1+E(7)+E(7)^2+E(7)^4); true
generated by GAPDoc2HTML