X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=d6235d33ee2edd77f24d1b304e8d4d80b4342d9f;hb=5f2deba7b079cfe5a0a290f810e569bfb480d186;hp=ce6f6e55e18b28aabea82c9118758c1dab061c28;hpb=3cee3d24af1c7606b4c2f30c16a7f6f3e51fd1bd;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index ce6f6e5..d6235d3 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -5,35 +5,76 @@ are used in optimization, and have some additional nice methods beyond what can be supported in a general Jordan Algebra. """ +from sage.categories.magmatic_algebras import MagmaticAlgebras +from sage.structure.element import is_Matrix +from sage.structure.category_object import normalize_names + from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra import FiniteDimensionalAlgebra from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra_element import FiniteDimensionalAlgebraElement class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): @staticmethod - def __classcall__(cls, field, mult_table, names='e', category=None): - fda = super(FiniteDimensionalEuclideanJordanAlgebra, cls) - return fda.__classcall_private__(cls, - field, - mult_table, - names, - category) + def __classcall_private__(cls, + field, + mult_table, + names='e', + assume_associative=False, + category=None, + rank=None): + n = len(mult_table) + mult_table = [b.base_extend(field) for b in mult_table] + for b in mult_table: + b.set_immutable() + if not (is_Matrix(b) and b.dimensions() == (n, n)): + raise ValueError("input is not a multiplication table") + mult_table = tuple(mult_table) + + cat = MagmaticAlgebras(field).FiniteDimensional().WithBasis() + cat.or_subcategory(category) + if assume_associative: + cat = cat.Associative() + + names = normalize_names(n, names) - def __init__(self, field, mult_table, names='e', category=None): + fda = super(FiniteDimensionalEuclideanJordanAlgebra, cls) + return fda.__classcall__(cls, + field, + mult_table, + assume_associative=assume_associative, + names=names, + category=cat, + rank=rank) + + + def __init__(self, field, + mult_table, + names='e', + assume_associative=False, + category=None, + rank=None): + self._rank = rank fda = super(FiniteDimensionalEuclideanJordanAlgebra, self) - fda.__init__(field, mult_table, names, category) + fda.__init__(field, + mult_table, + names=names, + category=category) def _repr_(self): """ Return a string representation of ``self``. """ - return "Euclidean Jordan algebra of degree {} over {}".format(self.degree(), self.base_ring()) + fmt = "Euclidean Jordan algebra of degree {} over {}" + return fmt.format(self.degree(), self.base_ring()) def rank(self): """ Return the rank of this EJA. """ - raise NotImplementedError + if self._rank is None: + raise ValueError("no rank specified at genesis") + else: + return self._rank class Element(FiniteDimensionalAlgebraElement): @@ -47,6 +88,20 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): Jordan algebras are always power-associative; see for example Faraut and Koranyi, Proposition II.1.2 (ii). + + .. WARNING: + + We have to override this because our superclass uses row vectors + instead of column vectors! We, on the other hand, assume column + vectors everywhere. + + EXAMPLES: + + sage: set_random_seed() + sage: x = random_eja().random_element() + sage: x.matrix()*x.vector() == (x**2).vector() + True + """ A = self.parent() if n == 0: @@ -54,19 +109,118 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): elif n == 1: return self else: - return A.element_class(A, self.vector()*(self.matrix()**(n-1))) + return A.element_class(A, (self.matrix()**(n-1))*self.vector()) - def span_of_powers(self): + def characteristic_polynomial(self): """ - Return the vector space spanned by successive powers of - this element. + Return my characteristic polynomial (if I'm a regular + element). + + Eventually this should be implemented in terms of the parent + algebra's characteristic polynomial that works for ALL + elements. """ - # The dimension of the subalgebra can't be greater than - # the big algebra, so just put everything into a list - # and let span() get rid of the excess. - V = self.vector().parent() - return V.span( (self**d).vector() for d in xrange(V.dimension()) ) + if self.is_regular(): + return self.minimal_polynomial() + else: + raise NotImplementedError('irregular element') + + + def det(self): + """ + Return my determinant, the product of my eigenvalues. + + EXAMPLES:: + + sage: J = JordanSpinSimpleEJA(2) + sage: e0,e1 = J.gens() + sage: x = e0 + e1 + sage: x.det() + 0 + sage: J = JordanSpinSimpleEJA(3) + sage: e0,e1,e2 = J.gens() + sage: x = e0 + e1 + e2 + sage: x.det() + -1 + + """ + cs = self.characteristic_polynomial().coefficients(sparse=False) + r = len(cs) - 1 + if r >= 0: + return cs[0] * (-1)**r + else: + raise ValueError('charpoly had no coefficients') + + + def is_nilpotent(self): + """ + Return whether or not some power of this element is zero. + + The superclass method won't work unless we're in an + associative algebra, and we aren't. However, we generate + an assocoative subalgebra and we're nilpotent there if and + only if we're nilpotent here (probably). + + TESTS: + + The identity element is never nilpotent:: + + sage: set_random_seed() + sage: random_eja().one().is_nilpotent() + False + + The additive identity is always nilpotent:: + + sage: set_random_seed() + sage: random_eja().zero().is_nilpotent() + True + + """ + # The element we're going to call "is_nilpotent()" on. + # Either myself, interpreted as an element of a finite- + # dimensional algebra, or an element of an associative + # subalgebra. + elt = None + + if self.parent().is_associative(): + elt = FiniteDimensionalAlgebraElement(self.parent(), self) + else: + V = self.span_of_powers() + assoc_subalg = self.subalgebra_generated_by() + # Mis-design warning: the basis used for span_of_powers() + # and subalgebra_generated_by() must be the same, and in + # the same order! + elt = assoc_subalg(V.coordinates(self.vector())) + + # Recursive call, but should work since elt lives in an + # associative algebra. + return elt.is_nilpotent() + + + def is_regular(self): + """ + Return whether or not this is a regular element. + + EXAMPLES: + + The identity element always has degree one, but any element + linearly-independent from it is regular:: + + sage: J = JordanSpinSimpleEJA(5) + sage: J.one().is_regular() + False + sage: e0, e1, e2, e3, e4 = J.gens() # e0 is the identity + sage: for x in J.gens(): + ....: (J.one() + x).is_regular() + False + True + True + True + True + + """ + return self.degree() == self.parent().rank() def degree(self): @@ -78,22 +232,285 @@ 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() sage: (e0 - e1).degree() 2 + In the spin factor algebra (of rank two), all elements that + aren't multiples of the identity are regular:: + + sage: set_random_seed() + sage: n = ZZ.random_element(1,10).abs() + sage: J = JordanSpinSimpleEJA(n) + sage: x = J.random_element() + sage: x == x.coefficient(0)*J.one() or x.degree() == 2 + True + """ return self.span_of_powers().dimension() + def matrix(self): + """ + Return the matrix that represents left- (or right-) + multiplication by this element in the parent algebra. + + We have to override this because the superclass method + returns a matrix that acts on row vectors (that is, on + the right). + """ + fda_elt = FiniteDimensionalAlgebraElement(self.parent(), self) + return fda_elt.matrix().transpose() + + def minimal_polynomial(self): - return self.matrix().minimal_polynomial() + """ + EXAMPLES:: + + sage: set_random_seed() + sage: x = random_eja().random_element() + sage: x.degree() == x.minimal_polynomial().degree() + True + + :: + + sage: set_random_seed() + sage: x = random_eja().random_element() + sage: x.degree() == x.minimal_polynomial().degree() + True + + The minimal polynomial and the characteristic polynomial coincide + and are known (see Alizadeh, Example 11.11) for all elements of + the spin factor algebra that aren't scalar multiples of the + identity:: + + sage: set_random_seed() + sage: n = ZZ.random_element(2,10).abs() + sage: J = JordanSpinSimpleEJA(n) + sage: y = J.random_element() + sage: while y == y.coefficient(0)*J.one(): + ....: y = J.random_element() + sage: y0 = y.vector()[0] + sage: y_bar = y.vector()[1:] + sage: actual = y.minimal_polynomial() + sage: x = SR.symbol('x', domain='real') + sage: expected = x^2 - 2*y0*x + (y0^2 - norm(y_bar)^2) + sage: bool(actual == expected) + True + + """ + # The element we're going to call "minimal_polynomial()" on. + # Either myself, interpreted as an element of a finite- + # dimensional algebra, or an element of an associative + # subalgebra. + elt = None + + if self.parent().is_associative(): + elt = FiniteDimensionalAlgebraElement(self.parent(), self) + else: + V = self.span_of_powers() + assoc_subalg = self.subalgebra_generated_by() + # Mis-design warning: the basis used for span_of_powers() + # and subalgebra_generated_by() must be the same, and in + # the same order! + elt = assoc_subalg(V.coordinates(self.vector())) + + # Recursive call, but should work since elt lives in an + # associative algebra. + 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 characteristic_polynomial(self): - return self.matrix().characteristic_polynomial() + + def span_of_powers(self): + """ + Return the vector space spanned by successive powers of + this element. + """ + # The dimension of the subalgebra can't be greater than + # the big algebra, so just put everything into a list + # and let span() get rid of the excess. + V = self.vector().parent() + return V.span( (self**d).vector() for d in xrange(V.dimension()) ) + + + def subalgebra_generated_by(self): + """ + Return the associative subalgebra of the parent EJA generated + by this element. + + TESTS:: + + sage: set_random_seed() + 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: 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 + + """ + # First get the subspace spanned by the powers of myself... + V = self.span_of_powers() + F = self.base_ring() + + # Now figure out the entries of the right-multiplication + # matrix for the successive basis elements b0, b1,... of + # that subspace. + mats = [] + for b_right in V.basis(): + eja_b_right = self.parent()(b_right) + b_right_rows = [] + # The first row of the right-multiplication matrix by + # b1 is what we get if we apply that matrix to b1. The + # second row of the right multiplication matrix by b1 + # is what we get when we apply that matrix to b2... + # + # IMPORTANT: this assumes that all vectors are COLUMN + # vectors, unlike our superclass (which uses row vectors). + for b_left in V.basis(): + eja_b_left = self.parent()(b_left) + # Multiply in the original EJA, but then get the + # coordinates from the subalgebra in terms of its + # basis. + this_row = V.coordinates((eja_b_left*eja_b_right).vector()) + b_right_rows.append(this_row) + b_right_matrix = matrix(F, b_right_rows) + mats.append(b_right_matrix) + + # It's an algebra of polynomials in one element, and EJAs + # are power-associative. + # + # TODO: choose generator names intelligently. + return FiniteDimensionalEuclideanJordanAlgebra(F, mats, assume_associative=True, names='f') + + + def subalgebra_idempotent(self): + """ + Find an idempotent in the associative subalgebra I generate + using Proposition 2.3.5 in Baes. + + TESTS:: + + sage: set_random_seed() + sage: J = eja_rn(5) + sage: c = J.random_element().subalgebra_idempotent() + sage: c^2 == c + True + sage: J = JordanSpinSimpleEJA(5) + sage: c = J.random_element().subalgebra_idempotent() + sage: c^2 == c + True + + """ + if self.is_nilpotent(): + raise ValueError("this only works with non-nilpotent elements!") + + V = self.span_of_powers() + J = self.subalgebra_generated_by() + # Mis-design warning: the basis used for span_of_powers() + # and subalgebra_generated_by() must be the same, and in + # the same order! + u = J(V.coordinates(self.vector())) + + # The image of the matrix of left-u^m-multiplication + # will be minimal for some natural number s... + s = 0 + minimal_dim = V.dimension() + for i in xrange(1, V.dimension()): + this_dim = (u**i).matrix().image().dimension() + if this_dim < minimal_dim: + minimal_dim = this_dim + s = i + + # Now minimal_matrix should correspond to the smallest + # non-zero subspace in Baes's (or really, Koecher's) + # proposition. + # + # However, we need to restrict the matrix to work on the + # subspace... or do we? Can't we just solve, knowing that + # A(c) = u^(s+1) should have a solution in the big space, + # too? + # + # Beware, solve_right() means that we're using COLUMN vectors. + # Our FiniteDimensionalAlgebraElement superclass uses rows. + u_next = u**(s+1) + A = u_next.matrix() + c_coordinates = A.solve_right(u_next.vector()) + + # Now c_coordinates is the idempotent we want, but it's in + # the coordinate system of the subalgebra. + # + # We need the basis for J, but as elements of the parent algebra. + # + basis = [self.parent(v) for v in V.basis()] + return self.parent().linear_combination(zip(c_coordinates, basis)) + + + def trace(self): + """ + Return my trace, the sum of my eigenvalues. + + EXAMPLES:: + + sage: J = JordanSpinSimpleEJA(3) + sage: e0,e1,e2 = J.gens() + sage: x = e0 + e1 + e2 + sage: x.trace() + 2 + + """ + cs = self.characteristic_polynomial().coefficients(sparse=False) + if len(cs) >= 2: + return -1*cs[-2] + else: + 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): @@ -129,19 +546,311 @@ def eja_rn(dimension, field=QQ): Qs = [ matrix(field, dimension, dimension, lambda k,j: 1*(k == j == i)) for i in xrange(dimension) ] - return FiniteDimensionalEuclideanJordanAlgebra(field,Qs) + 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,5).abs() + constructor = choice([eja_rn, + JordanSpinSimpleEJA, + RealSymmetricSimpleEJA, + ComplexHermitianSimpleEJA]) + return constructor(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(n): + for j in xrange(i+1): + 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 _complex_hermitian_basis(n, field=QQ): + """ + Returns a basis for the space of complex Hermitian n-by-n matrices. + + TESTS:: + + sage: set_random_seed() + sage: n = ZZ.random_element(1,5).abs() + sage: all( M.is_symmetric() for M in _complex_hermitian_basis(n) ) + True + + """ + F = QuadraticField(-1, 'I') + I = F.gen() + + # This is like the symmetric case, but we need to be careful: + # + # * We want conjugate-symmetry, not just symmetry. + # * The diagonal will (as a result) be real. + # + S = [] + for i in xrange(n): + for j in xrange(i+1): + Eij = matrix(field, n, lambda k,l: k==i and l==j) + if i == j: + Sij = _embed_complex_matrix(Eij) + S.append(Sij) + else: + # Beware, orthogonal but not normalized! The second one + # has a minus because it's conjugated. + Sij_real = _embed_complex_matrix(Eij + Eij.transpose()) + S.append(Sij_real) + Sij_imag = _embed_complex_matrix(I*Eij - I*Eij.transpose()) + S.append(Sij_imag) + 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()) + + 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 + # to find out what the corresponding row should be. BEWARE: + # these multiplication tables won't be symmetric! It therefore + # becomes REALLY IMPORTANT that the underlying algebra + # 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: + this_row = mat2vec((s*t + t*s)/2) + Q_rows.append(W.coordinates(this_row)) + Q = matrix(field, W.dimension(), Q_rows) + Qs.append(Q) + + 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 + + TESTS: + + The degree of this algebra is `(n^2 + n) / 2`:: + + sage: set_random_seed() + sage: n = ZZ.random_element(1,5).abs() + sage: J = RealSymmetricSimpleEJA(n) + sage: J.degree() == (n^2 + n)/2 + True + + """ + 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. + + TESTS: + + The degree of this algebra is `n^2`:: + + sage: set_random_seed() + sage: n = ZZ.random_element(1,5).abs() + sage: J = ComplexHermitianSimpleEJA(n) + sage: J.degree() == n^2 + True + + """ + S = _complex_hermitian_basis(n) + Qs = _multiplication_table_from_matrix_basis(S) + 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 eja_ln(dimension, field=QQ): +def JordanSpinSimpleEJA(n, field=QQ): """ - Return the Jordan algebra corresponding to the Lorentz "ice cream" - cone of the given ``dimension``. + 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 = eja_ln(4) + sage: J = JordanSpinSimpleEJA(4) sage: e0,e1,e2,e3 = J.gens() sage: e0*e0 e0 @@ -160,23 +869,26 @@ def eja_ln(dimension, field=QQ): In one dimension, this is the reals under multiplication:: - sage: J1 = eja_ln(1) + sage: J1 = JordanSpinSimpleEJA(1) sage: J2 = eja_rn(1) sage: J1 == J2 True """ Qs = [] - id_matrix = identity_matrix(field,dimension) - for i in xrange(dimension): + id_matrix = identity_matrix(field, n) + for i in xrange(n): ei = id_matrix.column(i) - Qi = zero_matrix(field,dimension) + Qi = zero_matrix(field, n) Qi.set_row(0, ei) Qi.set_column(0, ei) - Qi += diagonal_matrix(dimension, [ei[0]]*dimension) + 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) - return FiniteDimensionalEuclideanJordanAlgebra(field,Qs) + # 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))