e2
"""
- Qs = []
+ S = _real_symmetric_basis(dimension, field=field)
+ Qs = _multiplication_table_from_matrix_basis(S)
- # 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)
+ return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension)
+
+
+def random_eja():
+ """
+ Return a "random" finite-dimensional Euclidean Jordan Algebra.
+
+ ALGORITHM:
+
+ For now, we choose a random natural number ``n`` (greater than zero)
+ and then give you back one of the following:
+
+ * The cartesian product of the rational numbers ``n`` times; this is
+ ``QQ^n`` with the Hadamard product.
+
+ * The Jordan spin algebra on ``QQ^n``.
+
+ * The ``n``-by-``n`` rational symmetric matrices with the symmetric
+ product.
+
+ Later this might be extended to return Cartesian products of the
+ EJAs above.
+
+ TESTS::
+
+ sage: random_eja()
+ Euclidean Jordan algebra of degree...
+
+ """
+ n = ZZ.random_element(1,10).abs()
+ constructor = choice([eja_rn, eja_ln, eja_sn])
+ return constructor(dimension=n, field=QQ)
+
+
+def _real_symmetric_basis(n, field=QQ):
+ """
+ Return a basis for the space of real symmetric n-by-n matrices.
+ """
# 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() ]
- for s in S:
+ Qs = []
+ for s in basis:
# Brute force the multiplication-by-s matrix by looping
# through all elements of the basis and doing the computation
# to find out what the corresponding row should be. BEWARE:
# constructor uses ROW vectors and not COLUMN vectors. That's
# why we're computing rows here and not columns.
Q_rows = []
- for t in S:
+ for t in basis:
this_row = mat2vec((s*t + t*s)/2)
Q_rows.append(W.coordinates(this_row))
Q = matrix(field,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.
-
- ALGORITHM:
+ 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]]``.
- For now, we choose a random natural number ``n`` (greater than zero)
- and then give you back one of the following:
-
- * The cartesian product of the rational numbers ``n`` times; this is
- ``QQ^n`` with the Hadamard product.
+ EXAMPLES::
- * The Jordan spin algebra on ``QQ^n``.
+ 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 ``n``-by-``n`` rational symmetric matrices with the symmetric
- 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]]))
+ return block_matrix(field, n, blocks)
+
+
+def RealSymmetricSimpleEJA(n):
+ """
+ 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.
+ """
+ pass
- Later this might be extended to return Cartesian products of the
- EJAs above.
+def ComplexHermitianSimpleEJA(n):
+ """
+ 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.
+ """
+ pass
- TESTS::
+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
- sage: random_eja()
- Euclidean Jordan algebra of degree...
+def OctonionHermitianSimpleEJA(n):
+ """
+ This shit be crazy. It has dimension 27 over the reals.
+ """
+ n = 3
+ pass
+def JordanSpinSimpleEJA(n):
"""
- n = ZZ.random_element(1,10).abs()
- constructor = choice([eja_rn, eja_ln, eja_sn])
- return constructor(dimension=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.
+ """
+ pass
projects / sage.d.git / blobdiff