X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=fdaccba58a8b99a2f5222054358969ce3e731882;hb=cef21b24d30d942dbaa542a23aab642c884371f7;hp=d07425f6516e0261030afc3052ddbfd8660e6722;hpb=206683c90a5fd290ff4fd16a9ed272d9f981b668;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index d07425f..fdaccba 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -503,6 +503,16 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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 @@ -610,27 +620,79 @@ def eja_sn(dimension, field=QQ): 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()) @@ -638,14 +700,16 @@ def eja_sn(dimension, field=QQ): 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: @@ -654,41 +718,87 @@ def eja_sn(dimension, field=QQ): # 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. + 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: - - 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 = + (, x0*y_bar + y0*x_bar)``. It has dimension `n` over + the reals. + """ + pass