EXAMPLES::
- sage: J = eja_ln(2)
+ sage: J = JordanSpinSimpleEJA(2)
sage: e0,e1 = J.gens()
sage: x = e0 + e1
sage: x.det()
0
- sage: J = eja_ln(3)
+ sage: J = JordanSpinSimpleEJA(3)
sage: e0,e1,e2 = J.gens()
sage: x = e0 + e1 + e2
sage: x.det()
The identity element always has degree one, but any element
linearly-independent from it is regular::
- sage: J = eja_ln(5)
+ sage: J = JordanSpinSimpleEJA(5)
sage: J.one().is_regular()
False
sage: e0, e1, e2, e3, e4 = J.gens() # e0 is the identity
EXAMPLES::
- sage: J = eja_ln(4)
+ sage: J = JordanSpinSimpleEJA(4)
sage: J.one().degree()
1
sage: e0,e1,e2,e3 = J.gens()
sage: set_random_seed()
sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_ln(n)
+ sage: J = JordanSpinSimpleEJA(n)
sage: x = J.random_element()
sage: x == x.coefficient(0)*J.one() or x.degree() == 2
True
sage: set_random_seed()
sage: n = ZZ.random_element(2,10).abs()
- sage: J = eja_ln(n)
+ sage: J = JordanSpinSimpleEJA(n)
sage: y = J.random_element()
sage: while y == y.coefficient(0)*J.one():
....: y = J.random_element()
Alizadeh's Example 11.12::
sage: n = ZZ.random_element(1,10).abs()
- sage: J = eja_ln(n)
+ sage: J = JordanSpinSimpleEJA(n)
sage: x = J.random_element()
sage: x_vec = x.vector()
sage: x0 = x_vec[0]
sage: c = J.random_element().subalgebra_idempotent()
sage: c^2 == c
True
- sage: J = eja_ln(5)
+ sage: J = JordanSpinSimpleEJA(5)
sage: c = J.random_element().subalgebra_idempotent()
sage: c^2 == c
True
EXAMPLES::
- sage: J = eja_ln(3)
+ sage: J = JordanSpinSimpleEJA(3)
sage: e0,e1,e2 = J.gens()
sage: x = e0 + e1 + e2
sage: x.trace()
raise ValueError('charpoly had fewer than 2 coefficients')
+ def trace_inner_product(self, other):
+ """
+ Return the trace inner product of myself and ``other``.
+ """
+ if not other in self.parent():
+ raise ArgumentError("'other' must live in the same algebra")
+
+ return (self*other).trace()
+
+
def eja_rn(dimension, field=QQ):
"""
Return the Euclidean Jordan Algebra corresponding to the set
return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension)
-def eja_ln(dimension, field=QQ):
+
+def random_eja():
"""
- Return the Jordan algebra corresponding to the Lorentz "ice cream"
- cone of the given ``dimension``.
+ Return a "random" finite-dimensional Euclidean Jordan Algebra.
- EXAMPLES:
+ ALGORITHM:
- This multiplication table can be verified by hand::
+ For now, we choose a random natural number ``n`` (greater than zero)
+ and then give you back one of the following:
- sage: J = eja_ln(4)
- sage: e0,e1,e2,e3 = J.gens()
- sage: e0*e0
- e0
- sage: e0*e1
- e1
- sage: e0*e2
- e2
- sage: e0*e3
- e3
- sage: e1*e2
- 0
- sage: e1*e3
- 0
- sage: e2*e3
- 0
+ * The cartesian product of the rational numbers ``n`` times; this is
+ ``QQ^n`` with the Hadamard product.
- In one dimension, this is the reals under multiplication::
+ * The Jordan spin algebra on ``QQ^n``.
- sage: J1 = eja_ln(1)
- sage: J2 = eja_rn(1)
- sage: J1 == J2
- True
+ * The ``n``-by-``n`` rational symmetric matrices with the symmetric
+ product.
- """
- Qs = []
- id_matrix = identity_matrix(field,dimension)
- for i in xrange(dimension):
- ei = id_matrix.column(i)
- Qi = zero_matrix(field,dimension)
- Qi.set_row(0, ei)
- Qi.set_column(0, ei)
- Qi += diagonal_matrix(dimension, [ei[0]]*dimension)
- # The addition of the diagonal matrix adds an extra ei[0] in the
- # upper-left corner of the matrix.
- Qi[0,0] = Qi[0,0] * ~field(2)
- Qs.append(Qi)
+ Later this might be extended to return Cartesian products of the
+ EJAs above.
- # The rank of the spin factor algebra is two, UNLESS we're in a
- # one-dimensional ambient space (the rank is bounded by the
- # ambient dimension).
- rank = min(dimension,2)
- return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=rank)
+ TESTS::
+ sage: random_eja()
+ Euclidean Jordan algebra of degree...
-def eja_sn(dimension, field=QQ):
"""
- Return the simple Jordan algebra of ``dimension``-by-``dimension``
- symmetric matrices over ``field``.
+ n = ZZ.random_element(1,5).abs()
+ constructor = choice([eja_rn,
+ JordanSpinSimpleEJA,
+ RealSymmetricSimpleEJA,
+ ComplexHermitianSimpleEJA])
+ return constructor(n, field=QQ)
- EXAMPLES::
- sage: J = eja_sn(2)
- sage: e0, e1, e2 = J.gens()
- sage: e0*e0
- e0
- sage: e1*e1
- e0 + e2
- sage: e2*e2
- e2
+def _real_symmetric_basis(n, field=QQ):
+ """
+ Return a basis for the space of real symmetric n-by-n matrices.
"""
- Qs = []
-
- # In S^2, for example, we nominally have four coordinates even
- # though the space is of dimension three only. The vector space V
- # is supposed to hold the entire long vector, and the subspace W
- # of V will be spanned by the vectors that arise from symmetric
- # matrices. Thus for S^2, dim(V) == 4 and dim(W) == 3.
- V = VectorSpace(field, dimension**2)
-
# The basis of symmetric matrices, as matrices, in their R^(n-by-n)
# coordinates.
S = []
-
- for i in xrange(dimension):
+ for i in xrange(n):
for j in xrange(i+1):
- Eij = matrix(field, dimension, lambda k,l: k==i and l==j)
+ Eij = matrix(field, n, lambda k,l: k==i and l==j)
if i == j:
Sij = Eij
else:
+ # Beware, orthogonal but not normalized!
Sij = Eij + Eij.transpose()
S.append(Sij)
+ return S
+
+
+def _multiplication_table_from_matrix_basis(basis):
+ """
+ At least three of the five simple Euclidean Jordan algebras have the
+ symmetric multiplication (A,B) |-> (AB + BA)/2, where the
+ multiplication on the right is matrix multiplication. Given a basis
+ for the underlying matrix space, this function returns a
+ multiplication table (obtained by looping through the basis
+ elements) for an algebra of those matrices.
+ """
+ # In S^2, for example, we nominally have four coordinates even
+ # though the space is of dimension three only. The vector space V
+ # is supposed to hold the entire long vector, and the subspace W
+ # of V will be spanned by the vectors that arise from symmetric
+ # matrices. Thus for S^2, dim(V) == 4 and dim(W) == 3.
+ field = basis[0].base_ring()
+ dimension = basis[0].nrows()
def mat2vec(m):
return vector(field, m.list())
def vec2mat(v):
return matrix(field, dimension, v.list())
- W = V.span( mat2vec(s) for s in S )
+ V = VectorSpace(field, dimension**2)
+ W = V.span( mat2vec(s) for s in basis )
# Taking the span above reorders our basis (thanks, jerk!) so we
# need to put our "matrix basis" in the same order as the
# (reordered) vector basis.
S = [ vec2mat(b) for b in W.basis() ]
+ Qs = []
for s in S:
# Brute force the multiplication-by-s matrix by looping
# through all elements of the basis and doing the computation
for t in S:
this_row = mat2vec((s*t + t*s)/2)
Q_rows.append(W.coordinates(this_row))
- Q = matrix(field,Q_rows)
+ Q = matrix(field, W.dimension(), Q_rows)
Qs.append(Q)
- return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension)
+ return Qs
-def random_eja():
+def _embed_complex_matrix(M):
"""
- Return a "random" finite-dimensional Euclidean Jordan Algebra.
+ Embed the n-by-n complex matrix ``M`` into the space of real
+ matrices of size 2n-by-2n via the map the sends each entry `z = a +
+ bi` to the block matrix ``[[a,b],[-b,a]]``.
- ALGORITHM:
+ EXAMPLES::
- For now, we choose a random natural number ``n`` (greater than zero)
- and then give you back one of the following:
+ sage: F = QuadraticField(-1,'i')
+ sage: x1 = F(4 - 2*i)
+ sage: x2 = F(1 + 2*i)
+ sage: x3 = F(-i)
+ sage: x4 = F(6)
+ sage: M = matrix(F,2,[x1,x2,x3,x4])
+ sage: _embed_complex_matrix(M)
+ [ 4 2| 1 -2]
+ [-2 4| 2 1]
+ [-----+-----]
+ [ 0 1| 6 0]
+ [-1 0| 0 6]
- * The cartesian product of the rational numbers ``n`` times; this is
- ``QQ^n`` with the Hadamard product.
+ """
+ n = M.nrows()
+ if M.ncols() != n:
+ raise ArgumentError("the matrix 'M' must be square")
+ field = M.base_ring()
+ blocks = []
+ for z in M.list():
+ a = z.real()
+ b = z.imag()
+ blocks.append(matrix(field, 2, [[a,-b],[b,a]]))
- * The Jordan spin algebra on ``QQ^n``.
+ # We can drop the imaginaries here.
+ return block_matrix(field.base_ring(), n, blocks)
- * The ``n``-by-``n`` rational symmetric matrices with the symmetric
- product.
- Later this might be extended to return Cartesian products of the
- EJAs above.
+def _unembed_complex_matrix(M):
+ """
+ The inverse of _embed_complex_matrix().
- TESTS::
+ EXAMPLES::
- sage: random_eja()
- Euclidean Jordan algebra of degree...
+ sage: A = matrix(QQ,[ [ 1, 2, 3, 4],
+ ....: [-2, 1, -4, 3],
+ ....: [ 9, 10, 11, 12],
+ ....: [-10, 9, -12, 11] ])
+ sage: _unembed_complex_matrix(A)
+ [ -2*i + 1 -4*i + 3]
+ [ -10*i + 9 -12*i + 11]
+ """
+ n = ZZ(M.nrows())
+ if M.ncols() != n:
+ raise ArgumentError("the matrix 'M' must be square")
+ if not n.mod(2).is_zero():
+ raise ArgumentError("the matrix 'M' must be a complex embedding")
+
+ F = QuadraticField(-1, 'i')
+ i = F.gen()
+
+ # Go top-left to bottom-right (reading order), converting every
+ # 2-by-2 block we see to a single complex element.
+ elements = []
+ for k in xrange(n/2):
+ for j in xrange(n/2):
+ submat = M[2*k:2*k+2,2*j:2*j+2]
+ if submat[0,0] != submat[1,1]:
+ raise ArgumentError('bad real submatrix')
+ if submat[0,1] != -submat[1,0]:
+ raise ArgumentError('bad imag submatrix')
+ z = submat[0,0] + submat[1,0]*i
+ elements.append(z)
+
+ return matrix(F, n/2, elements)
+
+
+def RealSymmetricSimpleEJA(n, field=QQ):
+ """
+ The rank-n simple EJA consisting of real symmetric n-by-n
+ matrices, the usual symmetric Jordan product, and the trace inner
+ product. It has dimension `(n^2 + n)/2` over the reals.
+
+ EXAMPLES::
+
+ sage: J = RealSymmetricSimpleEJA(2)
+ sage: e0, e1, e2 = J.gens()
+ sage: e0*e0
+ e0
+ sage: e1*e1
+ e0 + e2
+ sage: e2*e2
+ e2
+ """
+ S = _real_symmetric_basis(n, field=field)
+ Qs = _multiplication_table_from_matrix_basis(S)
+
+ return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=n)
+
+
+def ComplexHermitianSimpleEJA(n, field=QQ):
+ """
+ The rank-n simple EJA consisting of complex Hermitian n-by-n
+ matrices over the real numbers, the usual symmetric Jordan product,
+ and the real-part-of-trace inner product. It has dimension `n^2 over
+ the reals.
+ """
+ F = QuadraticField(-1, 'i')
+ i = F.gen()
+ S = _real_symmetric_basis(n, field=F)
+ T = []
+ for s in S:
+ T.append(s)
+ T.append(i*s)
+ embed_T = [ _embed_complex_matrix(t) for t in T ]
+ Qs = _multiplication_table_from_matrix_basis(embed_T)
+ return FiniteDimensionalEuclideanJordanAlgebra(field, Qs, rank=n)
+
+def QuaternionHermitianSimpleEJA(n):
+ """
+ The rank-n simple EJA consisting of self-adjoint n-by-n quaternion
+ matrices, the usual symmetric Jordan product, and the
+ real-part-of-trace inner product. It has dimension `2n^2 - n` over
+ the reals.
+ """
+ pass
+
+def OctonionHermitianSimpleEJA(n):
+ """
+ This shit be crazy. It has dimension 27 over the reals.
+ """
+ n = 3
+ pass
+
+def JordanSpinSimpleEJA(n, field=QQ):
+ """
+ The rank-2 simple EJA consisting of real vectors ``x=(x0, x_bar)``
+ with the usual inner product and jordan product ``x*y =
+ (<x_bar,y_bar>, x0*y_bar + y0*x_bar)``. It has dimension `n` over
+ the reals.
+
+ EXAMPLES:
+
+ This multiplication table can be verified by hand::
+
+ sage: J = JordanSpinSimpleEJA(4)
+ sage: e0,e1,e2,e3 = J.gens()
+ sage: e0*e0
+ e0
+ sage: e0*e1
+ e1
+ sage: e0*e2
+ e2
+ sage: e0*e3
+ e3
+ sage: e1*e2
+ 0
+ sage: e1*e3
+ 0
+ sage: e2*e3
+ 0
+
+ In one dimension, this is the reals under multiplication::
+
+ sage: J1 = JordanSpinSimpleEJA(1)
+ sage: J2 = eja_rn(1)
+ sage: J1 == J2
+ True
"""
- n = ZZ.random_element(1,10).abs()
- constructor = choice([eja_rn, eja_ln, eja_sn])
- return constructor(dimension=n, field=QQ)
+ Qs = []
+ id_matrix = identity_matrix(field, n)
+ for i in xrange(n):
+ ei = id_matrix.column(i)
+ Qi = zero_matrix(field, n)
+ Qi.set_row(0, ei)
+ Qi.set_column(0, ei)
+ Qi += diagonal_matrix(n, [ei[0]]*n)
+ # The addition of the diagonal matrix adds an extra ei[0] in the
+ # upper-left corner of the matrix.
+ Qi[0,0] = Qi[0,0] * ~field(2)
+ Qs.append(Qi)
+
+ # The rank of the spin factor algebra is two, UNLESS we're in a
+ # one-dimensional ambient space (the rank is bounded by the
+ # ambient dimension).
+ return FiniteDimensionalEuclideanJordanAlgebra(field, Qs, rank=min(n,2))