X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=0a53667c36284d3a07a218f30e37fae8334861a9;hb=486601c8b12cc184da19c7540011b88ee1f26282;hp=c47f4003690905278904327e63ddaf7dcf9e0b44;hpb=eb48c4d6ce3591d116c85b3f4ab9d1ebb1095367;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index c47f400..0a53667 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -80,19 +80,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): class Element(FiniteDimensionalAlgebraElement): """ An element of a Euclidean Jordan algebra. - - Since EJAs are commutative, the "right multiplication" matrix is - also the left multiplication matrix and must be symmetric:: - - sage: set_random_seed() - sage: n = ZZ.random_element(1,10).abs() - sage: J = eja_rn(5) - sage: J.random_element().matrix().is_symmetric() - True - sage: J = eja_ln(5) - sage: J.random_element().matrix().is_symmetric() - True - """ def __pow__(self, n): @@ -111,8 +98,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): EXAMPLES: sage: set_random_seed() - sage: J = eja_ln(5) - sage: x = J.random_element() + sage: x = random_eja().random_element() sage: x.matrix()*x.vector() == (x**2).vector() True @@ -147,12 +133,12 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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() @@ -181,23 +167,13 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): The identity element is never nilpotent:: sage: set_random_seed() - sage: n = ZZ.random_element(2,10).abs() - sage: J = eja_rn(n) - sage: J.one().is_nilpotent() - False - sage: J = eja_ln(n) - sage: J.one().is_nilpotent() + sage: random_eja().one().is_nilpotent() False The additive identity is always nilpotent:: sage: set_random_seed() - sage: n = ZZ.random_element(2,10).abs() - sage: J = eja_rn(n) - sage: J.zero().is_nilpotent() - True - sage: J = eja_ln(n) - sage: J.zero().is_nilpotent() + sage: random_eja().zero().is_nilpotent() True """ @@ -231,7 +207,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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 @@ -256,7 +232,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): EXAMPLES:: - sage: J = eja_ln(4) + sage: J = JordanSpinSimpleEJA(4) sage: J.one().degree() 1 sage: e0,e1,e2,e3 = J.gens() @@ -268,7 +244,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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 @@ -295,18 +271,14 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): EXAMPLES:: sage: set_random_seed() - sage: n = ZZ.random_element(1,10).abs() - sage: J = eja_rn(n) - sage: x = J.random_element() + sage: x = random_eja().random_element() sage: x.degree() == x.minimal_polynomial().degree() True :: sage: set_random_seed() - sage: n = ZZ.random_element(1,10).abs() - sage: J = eja_ln(n) - sage: x = J.random_element() + sage: x = random_eja().random_element() sage: x.degree() == x.minimal_polynomial().degree() True @@ -317,7 +289,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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() @@ -351,6 +323,35 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): return elt.minimal_polynomial() + def quadratic_representation(self): + """ + Return the quadratic representation of this element. + + EXAMPLES: + + The explicit form in the spin factor algebra is given by + Alizadeh's Example 11.12:: + + sage: n = ZZ.random_element(1,10).abs() + sage: J = JordanSpinSimpleEJA(n) + sage: x = J.random_element() + sage: x_vec = x.vector() + sage: x0 = x_vec[0] + sage: x_bar = x_vec[1:] + sage: A = matrix(QQ, 1, [x_vec.inner_product(x_vec)]) + sage: B = 2*x0*x_bar.row() + sage: C = 2*x0*x_bar.column() + sage: D = identity_matrix(QQ, n-1) + sage: D = (x0^2 - x_bar.inner_product(x_bar))*D + sage: D = D + 2*x_bar.tensor_product(x_bar) + sage: Q = block_matrix(2,2,[A,B,C,D]) + sage: Q == x.quadratic_representation() + True + + """ + return 2*(self.matrix()**2) - (self**2).matrix() + + def span_of_powers(self): """ Return the vector space spanned by successive powers of @@ -371,21 +372,15 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): TESTS:: sage: set_random_seed() - sage: n = ZZ.random_element(1,10).abs() - sage: J = eja_rn(n) - sage: x = J.random_element() - sage: x.subalgebra_generated_by().is_associative() - True - sage: J = eja_ln(n) - sage: x = J.random_element() + sage: x = random_eja().random_element() sage: x.subalgebra_generated_by().is_associative() True Squaring in the subalgebra should be the same thing as squaring in the superalgebra:: - sage: J = eja_ln(5) - sage: x = J.random_element() + sage: set_random_seed() + sage: x = random_eja().random_element() sage: u = x.subalgebra_generated_by().random_element() sage: u.matrix()*u.vector() == (u**2).vector() True @@ -438,7 +433,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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 @@ -494,7 +489,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): EXAMPLES:: - sage: J = eja_ln(3) + sage: J = JordanSpinSimpleEJA(3) sage: e0,e1,e2 = J.gens() sage: x = e0 + e1 + e2 sage: x.trace() @@ -508,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 @@ -544,104 +549,93 @@ def eja_rn(dimension, field=QQ): 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()) - W = V.span( mat2vec(s) for s in S ) + def vec2mat(v): + return matrix(field, dimension, v.list()) + + 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 @@ -654,7 +648,194 @@ def eja_sn(dimension, field=QQ): 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 _embed_complex_matrix(M): + """ + 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]]``. + + EXAMPLES:: + + 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] + + """ + 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]])) + + # We can drop the imaginaries here. + return block_matrix(field.base_ring(), n, blocks) + + +def _unembed_complex_matrix(M): + """ + The inverse of _embed_complex_matrix(). + + EXAMPLES:: + + 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 = + (, 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 + + """ + 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))