X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=d4ee9b022d8524752d3e15edf37284c2381ce509;hb=ec7dbfb6ce0054f55280412e43870b4019abc40c;hp=5e9c07c01be4bb5ac13644c5335a8b45304c6b7e;hpb=9c35b8d70e384cd98b8ec7eb7a84cf84db1d1137;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 5e9c07c..d4ee9b0 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -5,7 +5,6 @@ are used in optimization, and have some additional nice methods beyond what can be supported in a general Jordan Algebra. """ -#from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra import FiniteDimensionalAlgebra from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra from sage.categories.finite_dimensional_algebras_with_basis import FiniteDimensionalAlgebrasWithBasis from sage.combinat.free_module import CombinatorialFreeModule @@ -18,7 +17,6 @@ from sage.rings.number_field.number_field import QuadraticField from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing from sage.rings.rational_field import QQ from sage.structure.element import is_Matrix -from sage.structure.category_object import normalize_names from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement from mjo.eja.eja_utils import _mat2vec @@ -50,7 +48,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): """ self._rank = rank self._natural_basis = natural_basis - self._multiplication_table = mult_table + if category is None: category = FiniteDimensionalAlgebrasWithBasis(field).Unital() fda = super(FiniteDimensionalEuclideanJordanAlgebra, self) @@ -60,6 +58,79 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): category=category) self.print_options(bracket='') + # The multiplication table we're given is necessarily in terms + # of vectors, because we don't have an algebra yet for + # anything to be an element of. However, it's faster in the + # long run to have the multiplication table be in terms of + # algebra elements. We do this after calling the superclass + # constructor so that from_vector() knows what to do. + self._multiplication_table = matrix( + [ map(lambda x: self.from_vector(x), ls) + for ls in mult_table ] ) + self._multiplication_table.set_immutable() + + + def _element_constructor_(self, elt): + """ + Construct an element of this algebra from its natural + representation. + + This gets called only after the parent element _call_ method + fails to find a coercion for the argument. + + SETUP:: + + sage: from mjo.eja.eja_algebra import (JordanSpinEJA, + ....: RealCartesianProductEJA, + ....: RealSymmetricEJA) + + EXAMPLES: + + The identity in `S^n` is converted to the identity in the EJA:: + + sage: J = RealSymmetricEJA(3) + sage: I = matrix.identity(QQ,3) + sage: J(I) == J.one() + True + + This skew-symmetric matrix can't be represented in the EJA:: + + sage: J = RealSymmetricEJA(3) + sage: A = matrix(QQ,3, lambda i,j: i-j) + sage: J(A) + Traceback (most recent call last): + ... + ArithmeticError: vector is not in free module + + TESTS: + + Ensure that we can convert any element of the two non-matrix + simple algebras (whose natural representations are their usual + vector representations) back and forth faithfully:: + + sage: set_random_seed() + sage: J = RealCartesianProductEJA(5) + sage: x = J.random_element() + sage: J(x.to_vector().column()) == x + True + sage: J = JordanSpinEJA(5) + sage: x = J.random_element() + sage: J(x.to_vector().column()) == x + True + + """ + natural_basis = self.natural_basis() + if elt not in natural_basis[0].matrix_space(): + raise ValueError("not a naturally-represented algebra element") + + # Thanks for nothing! Matrix spaces aren't vector + # spaces in Sage, so we have to figure out its + # natural-basis coordinates ourselves. + V = VectorSpace(elt.base_ring(), elt.nrows()*elt.ncols()) + W = V.span_of_basis( _mat2vec(s) for s in natural_basis ) + coords = W.coordinate_vector(_mat2vec(elt)) + return self.from_vector(coords) + def _repr_(self): """ @@ -84,10 +155,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): return fmt.format(self.dimension(), self.base_ring()) def product_on_basis(self, i, j): - ei = self.basis()[i] - ej = self.basis()[j] - Lei = self._multiplication_table[i] - return self.from_vector(Lei*ej.to_vector()) + return self._multiplication_table[i,j] def _a_regular_element(self): """ @@ -181,10 +249,12 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): # Construct a new algebra over a multivariate polynomial ring... names = tuple('X' + str(i) for i in range(1,n+1)) R = PolynomialRing(self.base_ring(), names) - J = FiniteDimensionalEuclideanJordanAlgebra( - R, - tuple(self._multiplication_table), - r) + # Hack around the fact that our multiplication table is in terms of + # algebra elements but the constructor wants it in terms of vectors. + vmt = [ tuple([ self._multiplication_table[i,j].to_vector() + for j in range(self._multiplication_table.nrows()) ]) + for i in range(self._multiplication_table.ncols()) ] + J = FiniteDimensionalEuclideanJordanAlgebra(R, tuple(vmt), r) idmat = matrix.identity(J.base_ring(), n) @@ -206,7 +276,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): # We want the middle equivalent thing in our matrix, but use # the first equivalent thing instead so that we can pass in # standard coordinates. - x = J(W(R.gens())) + x = J.from_vector(W(R.gens())) # Handle the zeroth power separately, because computing # the unit element in J is mathematically suspect. @@ -312,6 +382,41 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): return x.trace_inner_product(y) + def multiplication_table(self): + """ + Return a readable matrix representation of this algebra's + multiplication table. The (i,j)th entry in the matrix contains + the product of the ith basis element with the jth. + + This is not extraordinarily useful, but it overrides a superclass + method that would otherwise just crash and complain about the + algebra being infinite. + + SETUP:: + + sage: from mjo.eja.eja_algebra import (JordanSpinEJA, + ....: RealCartesianProductEJA) + + EXAMPLES:: + + sage: J = RealCartesianProductEJA(3) + sage: J.multiplication_table() + [e0 0 0] + [ 0 e1 0] + [ 0 0 e2] + + :: + + sage: J = JordanSpinEJA(3) + sage: J.multiplication_table() + [e0 e1 e2] + [e1 e0 0] + [e2 0 e0] + + """ + return self._multiplication_table + + def natural_basis(self): """ Return a more-natural representation of this algebra's basis. @@ -375,7 +480,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): sage: J.one() e0 + e1 + e2 + e3 + e4 - TESTS:: + TESTS: The identity element acts like the identity:: @@ -535,16 +640,12 @@ class RealCartesianProductEJA(FiniteDimensionalEuclideanJordanAlgebra): """ def __init__(self, n, field=QQ): - # The superclass constructor takes a list of matrices, the ith - # representing right multiplication by the ith basis element - # in the vector space. So if e_1 = (1,0,0), then right - # (Hadamard) multiplication of x by e_1 picks out the first - # component of x; and likewise for the ith basis element e_i. - Qs = [ matrix(field, n, n, lambda k,j: 1*(k == j == i)) - for i in xrange(n) ] + V = VectorSpace(field, n) + mult_table = [ [ V.gen(i)*(i == j) for j in range(n) ] + for i in range(n) ] fdeja = super(RealCartesianProductEJA, self) - return fdeja.__init__(field, Qs, rank=n) + return fdeja.__init__(field, mult_table, rank=n) def inner_product(self, x, y): return _usual_ip(x,y) @@ -715,10 +816,7 @@ def _multiplication_table_from_matrix_basis(basis): 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. A reordered copy - of the basis is also returned to work around the fact that - the ``span()`` in this function will change the order of the basis - from what we think it is, to... something else. + 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 @@ -730,20 +828,14 @@ def _multiplication_table_from_matrix_basis(basis): V = VectorSpace(field, dimension**2) W = V.span_of_basis( _mat2vec(s) for s in basis ) + n = len(basis) + mult_table = [[W.zero() for j in range(n)] for i in range(n)] + for i in range(n): + for j in range(n): + mat_entry = (basis[i]*basis[j] + basis[j]*basis[i])/2 + mult_table[i][j] = W.coordinate_vector(_mat2vec(mat_entry)) - 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. - Q_cols = [] - for t in basis: - this_col = _mat2vec((s*t + t*s)/2) - Q_cols.append(W.coordinates(this_col)) - Q = matrix.column(field, W.dimension(), Q_cols) - Qs.append(Q) - - return Qs + return mult_table def _embed_complex_matrix(M): @@ -1008,12 +1100,12 @@ class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra): TESTS: - The degree of this algebra is `(n^2 + n) / 2`:: + The dimension of this algebra is `(n^2 + n) / 2`:: sage: set_random_seed() sage: n = ZZ.random_element(1,5) sage: J = RealSymmetricEJA(n) - sage: J.degree() == (n^2 + n)/2 + sage: J.dimension() == (n^2 + n)/2 True The Jordan multiplication is what we think it is:: @@ -1060,12 +1152,12 @@ class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): TESTS: - The degree of this algebra is `n^2`:: + The dimension of this algebra is `n^2`:: sage: set_random_seed() sage: n = ZZ.random_element(1,5) sage: J = ComplexHermitianEJA(n) - sage: J.degree() == n^2 + sage: J.dimension() == n^2 True The Jordan multiplication is what we think it is:: @@ -1120,12 +1212,12 @@ class QuaternionHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra): TESTS: - The degree of this algebra is `n^2`:: + The dimension of this algebra is `n^2`:: sage: set_random_seed() sage: n = ZZ.random_element(1,5) sage: J = QuaternionHermitianEJA(n) - sage: J.degree() == 2*(n^2) - n + sage: J.dimension() == 2*(n^2) - n True The Jordan multiplication is what we think it is:: @@ -1202,24 +1294,27 @@ class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra): """ def __init__(self, n, field=QQ): - Qs = [] - id_matrix = matrix.identity(field, n) - for i in xrange(n): - ei = id_matrix.column(i) - Qi = matrix.zero(field, n) - Qi.set_row(0, ei) - Qi.set_column(0, ei) - Qi += matrix.diagonal(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) + V = VectorSpace(field, n) + mult_table = [[V.zero() for j in range(n)] for i in range(n)] + for i in range(n): + for j in range(n): + x = V.gen(i) + y = V.gen(j) + x0 = x[0] + xbar = x[1:] + y0 = y[0] + ybar = y[1:] + # z = x*y + z0 = x.inner_product(y) + zbar = y0*xbar + x0*ybar + z = V([z0] + zbar.list()) + mult_table[i][j] = z # The rank of the spin algebra is two, unless we're in a # one-dimensional ambient space (because the rank is bounded by # the ambient dimension). fdeja = super(JordanSpinEJA, self) - return fdeja.__init__(field, Qs, rank=min(n,2)) + return fdeja.__init__(field, mult_table, rank=min(n,2)) def inner_product(self, x, y): return _usual_ip(x,y)