X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=ca344edc709352dea2d1940a7646e058066d4b8d;hb=388d1430380c72c14da47bfab73f7365fa0977f7;hp=1426d5e16be4b6acc7c68a4494e2c6f1c4d61819;hpb=4156fccce1265f500fe432b0f5567e43fbbc23d6;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index 1426d5e..ca344ed 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -20,7 +20,9 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): names='e', assume_associative=False, category=None, - rank=None): + rank=None, + natural_basis=None, + inner_product=None): n = len(mult_table) mult_table = [b.base_extend(field) for b in mult_table] for b in mult_table: @@ -43,7 +45,9 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): assume_associative=assume_associative, names=names, category=cat, - rank=rank) + rank=rank, + natural_basis=natural_basis, + inner_product=inner_product) def __init__(self, field, @@ -51,7 +55,9 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): names='e', assume_associative=False, category=None, - rank=None): + rank=None, + natural_basis=None, + inner_product=None): """ EXAMPLES: @@ -66,6 +72,8 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): """ self._rank = rank + self._natural_basis = natural_basis + self._inner_product = inner_product fda = super(FiniteDimensionalEuclideanJordanAlgebra, self) fda.__init__(field, mult_table, @@ -80,6 +88,63 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): fmt = "Euclidean Jordan algebra of degree {} over {}" return fmt.format(self.degree(), self.base_ring()) + + def inner_product(self, x, y): + """ + The inner product associated with this Euclidean Jordan algebra. + + Will default to the trace inner product if nothing else. + """ + if (not x in self) or (not y in self): + raise TypeError("arguments must live in this algebra") + if self._inner_product is None: + return x.trace_inner_product(y) + else: + return self._inner_product(x,y) + + + def natural_basis(self): + """ + Return a more-natural representation of this algebra's basis. + + Every finite-dimensional Euclidean Jordan Algebra is a direct + sum of five simple algebras, four of which comprise Hermitian + matrices. This method returns the original "natural" basis + for our underlying vector space. (Typically, the natural basis + is used to construct the multiplication table in the first place.) + + Note that this will always return a matrix. The standard basis + in `R^n` will be returned as `n`-by-`1` column matrices. + + EXAMPLES:: + + sage: J = RealSymmetricSimpleEJA(2) + sage: J.basis() + Family (e0, e1, e2) + sage: J.natural_basis() + ( + [1 0] [0 1] [0 0] + [0 0], [1 0], [0 1] + ) + + :: + + sage: J = JordanSpinSimpleEJA(2) + sage: J.basis() + Family (e0, e1) + sage: J.natural_basis() + ( + [1] [0] + [0], [1] + ) + + """ + if self._natural_basis is None: + return tuple( b.vector().column() for b in self.basis() ) + else: + return self._natural_basis + + def rank(self): """ Return the rank of this EJA. @@ -112,7 +177,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): sage: set_random_seed() sage: x = random_eja().random_element() - sage: x.matrix()*x.vector() == (x^2).vector() + sage: x.operator_matrix()*x.vector() == (x^2).vector() True A few examples of power-associativity:: @@ -131,8 +196,8 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): sage: x = random_eja().random_element() sage: m = ZZ.random_element(0,10) sage: n = ZZ.random_element(0,10) - sage: Lxm = (x^m).matrix() - sage: Lxn = (x^n).matrix() + sage: Lxm = (x^m).operator_matrix() + sage: Lxn = (x^n).operator_matrix() sage: Lxm*Lxn == Lxn*Lxm True @@ -143,7 +208,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): elif n == 1: return self else: - return A.element_class(A, (self.matrix()**(n-1))*self.vector()) + return A( (self.operator_matrix()**(n-1))*self.vector() ) def characteristic_polynomial(self): @@ -161,6 +226,81 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): raise NotImplementedError('irregular element') + def inner_product(self, other): + """ + Return the parent algebra's inner product of myself and ``other``. + + EXAMPLES: + + The inner product in the Jordan spin algebra is the usual + inner product on `R^n` (this example only works because the + basis for the Jordan algebra is the standard basis in `R^n`):: + + sage: J = JordanSpinSimpleEJA(3) + sage: x = vector(QQ,[1,2,3]) + sage: y = vector(QQ,[4,5,6]) + sage: x.inner_product(y) + 32 + sage: J(x).inner_product(J(y)) + 32 + + TESTS: + + Ensure that we can always compute an inner product, and that + it gives us back a real number:: + + sage: set_random_seed() + sage: J = random_eja() + sage: x = J.random_element() + sage: y = J.random_element() + sage: x.inner_product(y) in RR + True + + """ + P = self.parent() + if not other in P: + raise TypeError("'other' must live in the same algebra") + + return P.inner_product(self, other) + + + def operator_commutes_with(self, other): + """ + Return whether or not this element operator-commutes + with ``other``. + + EXAMPLES: + + The definition of a Jordan algebra says that any element + operator-commutes with its square:: + + sage: set_random_seed() + sage: x = random_eja().random_element() + sage: x.operator_commutes_with(x^2) + True + + TESTS: + + Test Lemma 1 from Chapter III of Koecher:: + + sage: set_random_seed() + sage: J = random_eja() + sage: u = J.random_element() + sage: v = J.random_element() + sage: lhs = u.operator_commutes_with(u*v) + sage: rhs = v.operator_commutes_with(u^2) + sage: lhs == rhs + True + + """ + if not other in self.parent(): + raise TypeError("'other' must live in the same algebra") + + A = self.operator_matrix() + B = other.operator_matrix() + return (A*B == B*A) + + def det(self): """ Return my determinant, the product of my eigenvalues. @@ -244,7 +384,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): # TODO: we can do better once the call to is_invertible() # doesn't crash on irregular elements. #if not self.is_invertible(): - # raise ArgumentError('element is not invertible') + # raise ValueError('element is not invertible') # We do this a little different than the usual recursive # call to a finite-dimensional algebra element, because we @@ -377,73 +517,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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). - - EXAMPLES: - - Test the first polarization identity from my notes, Koecher Chapter - III, or from Baes (2.3):: - - sage: set_random_seed() - sage: J = random_eja() - sage: x = J.random_element() - sage: y = J.random_element() - sage: Lx = x.matrix() - sage: Ly = y.matrix() - sage: Lxx = (x*x).matrix() - sage: Lxy = (x*y).matrix() - sage: bool(2*Lx*Lxy + Ly*Lxx == 2*Lxy*Lx + Lxx*Ly) - True - - Test the second polarization identity from my notes or from - Baes (2.4):: - - sage: set_random_seed() - sage: J = random_eja() - sage: x = J.random_element() - sage: y = J.random_element() - sage: z = J.random_element() - sage: Lx = x.matrix() - sage: Ly = y.matrix() - sage: Lz = z.matrix() - sage: Lzy = (z*y).matrix() - sage: Lxy = (x*y).matrix() - sage: Lxz = (x*z).matrix() - sage: bool(Lx*Lzy + Lz*Lxy + Ly*Lxz == Lzy*Lx + Lxy*Lz + Lxz*Ly) - True - - Test the third polarization identity from my notes or from - Baes (2.5):: - - sage: set_random_seed() - sage: J = random_eja() - sage: u = J.random_element() - sage: y = J.random_element() - sage: z = J.random_element() - sage: Lu = u.matrix() - sage: Ly = y.matrix() - sage: Lz = z.matrix() - sage: Lzy = (z*y).matrix() - sage: Luy = (u*y).matrix() - sage: Luz = (u*z).matrix() - sage: Luyz = (u*(y*z)).matrix() - sage: lhs = Lu*Lzy + Lz*Luy + Ly*Luz - sage: rhs = Luyz + Ly*Lu*Lz + Lz*Lu*Ly - sage: bool(lhs == rhs) - True - - """ - fda_elt = FiniteDimensionalAlgebraElement(self.parent(), self) - return fda_elt.matrix().transpose() - - def minimal_polynomial(self): """ EXAMPLES:: @@ -501,6 +574,102 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): return elt.minimal_polynomial() + def natural_representation(self): + """ + Return a more-natural representation of this element. + + Every finite-dimensional Euclidean Jordan Algebra is a + direct sum of five simple algebras, four of which comprise + Hermitian matrices. This method returns the original + "natural" representation of this element as a Hermitian + matrix, if it has one. If not, you get the usual representation. + + EXAMPLES:: + + sage: J = ComplexHermitianSimpleEJA(3) + sage: J.one() + e0 + e5 + e8 + sage: J.one().natural_representation() + [1 0 0 0 0 0] + [0 1 0 0 0 0] + [0 0 1 0 0 0] + [0 0 0 1 0 0] + [0 0 0 0 1 0] + [0 0 0 0 0 1] + + """ + B = self.parent().natural_basis() + W = B[0].matrix_space() + return W.linear_combination(zip(self.vector(), B)) + + + def operator_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). + + EXAMPLES: + + Test the first polarization identity from my notes, Koecher Chapter + III, or from Baes (2.3):: + + sage: set_random_seed() + sage: J = random_eja() + sage: x = J.random_element() + sage: y = J.random_element() + sage: Lx = x.operator_matrix() + sage: Ly = y.operator_matrix() + sage: Lxx = (x*x).operator_matrix() + sage: Lxy = (x*y).operator_matrix() + sage: bool(2*Lx*Lxy + Ly*Lxx == 2*Lxy*Lx + Lxx*Ly) + True + + Test the second polarization identity from my notes or from + Baes (2.4):: + + sage: set_random_seed() + sage: J = random_eja() + sage: x = J.random_element() + sage: y = J.random_element() + sage: z = J.random_element() + sage: Lx = x.operator_matrix() + sage: Ly = y.operator_matrix() + sage: Lz = z.operator_matrix() + sage: Lzy = (z*y).operator_matrix() + sage: Lxy = (x*y).operator_matrix() + sage: Lxz = (x*z).operator_matrix() + sage: bool(Lx*Lzy + Lz*Lxy + Ly*Lxz == Lzy*Lx + Lxy*Lz + Lxz*Ly) + True + + Test the third polarization identity from my notes or from + Baes (2.5):: + + sage: set_random_seed() + sage: J = random_eja() + sage: u = J.random_element() + sage: y = J.random_element() + sage: z = J.random_element() + sage: Lu = u.operator_matrix() + sage: Ly = y.operator_matrix() + sage: Lz = z.operator_matrix() + sage: Lzy = (z*y).operator_matrix() + sage: Luy = (u*y).operator_matrix() + sage: Luz = (u*z).operator_matrix() + sage: Luyz = (u*(y*z)).operator_matrix() + sage: lhs = Lu*Lzy + Lz*Luy + Ly*Luz + sage: rhs = Luyz + Ly*Lu*Lz + Lz*Lu*Ly + sage: bool(lhs == rhs) + True + + """ + fda_elt = FiniteDimensionalAlgebraElement(self.parent(), self) + return fda_elt.matrix().transpose() + + def quadratic_representation(self, other=None): """ Return the quadratic representation of this element. @@ -571,11 +740,11 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): if other is None: other=self elif not other in self.parent(): - raise ArgumentError("'other' must live in the same algebra") + raise TypeError("'other' must live in the same algebra") - return ( self.matrix()*other.matrix() - + other.matrix()*self.matrix() - - (self*other).matrix() ) + L = self.operator_matrix() + M = other.operator_matrix() + return ( L*M + M*L - (self*other).operator_matrix() ) def span_of_powers(self): @@ -608,7 +777,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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() + sage: u.operator_matrix()*u.vector() == (u**2).vector() True """ @@ -680,7 +849,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): s = 0 minimal_dim = V.dimension() for i in xrange(1, V.dimension()): - this_dim = (u**i).matrix().image().dimension() + this_dim = (u**i).operator_matrix().image().dimension() if this_dim < minimal_dim: minimal_dim = this_dim s = i @@ -697,7 +866,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): # Beware, solve_right() means that we're using COLUMN vectors. # Our FiniteDimensionalAlgebraElement superclass uses rows. u_next = u**(s+1) - A = u_next.matrix() + A = u_next.operator_matrix() c_coordinates = A.solve_right(u_next.vector()) # Now c_coordinates is the idempotent we want, but it's in @@ -734,7 +903,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): Return the trace inner product of myself and ``other``. """ if not other in self.parent(): - raise ArgumentError("'other' must live in the same algebra") + raise TypeError("'other' must live in the same algebra") return (self*other).trace() @@ -772,7 +941,13 @@ 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,rank=dimension) + # The usual inner product on R^n. + ip = lambda x, y: x.vector().inner_product(y.vector()) + + return FiniteDimensionalEuclideanJordanAlgebra(field, + Qs, + rank=dimension, + inner_product=ip) @@ -827,7 +1002,7 @@ def _real_symmetric_basis(n, field=QQ): # Beware, orthogonal but not normalized! Sij = Eij + Eij.transpose() S.append(Sij) - return S + return tuple(S) def _complex_hermitian_basis(n, field=QQ): @@ -864,7 +1039,7 @@ def _complex_hermitian_basis(n, field=QQ): S.append(Sij_real) Sij_imag = _embed_complex_matrix(I*Eij - I*Eij.transpose()) S.append(Sij_imag) - return S + return tuple(S) def _multiplication_table_from_matrix_basis(basis): @@ -874,7 +1049,10 @@ 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. + 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. """ # In S^2, for example, we nominally have four coordinates even # though the space is of dimension three only. The vector space V @@ -896,7 +1074,7 @@ def _multiplication_table_from_matrix_basis(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() ] + S = tuple( vec2mat(b) for b in W.basis() ) Qs = [] for s in S: @@ -914,7 +1092,7 @@ def _multiplication_table_from_matrix_basis(basis): Q = matrix(field, W.dimension(), Q_rows) Qs.append(Q) - return Qs + return (Qs, S) def _embed_complex_matrix(M): @@ -941,7 +1119,7 @@ def _embed_complex_matrix(M): """ n = M.nrows() if M.ncols() != n: - raise ArgumentError("the matrix 'M' must be square") + raise ValueError("the matrix 'M' must be square") field = M.base_ring() blocks = [] for z in M.list(): @@ -969,9 +1147,9 @@ def _unembed_complex_matrix(M): """ n = ZZ(M.nrows()) if M.ncols() != n: - raise ArgumentError("the matrix 'M' must be square") + raise ValueError("the matrix 'M' must be square") if not n.mod(2).is_zero(): - raise ArgumentError("the matrix 'M' must be a complex embedding") + raise ValueError("the matrix 'M' must be a complex embedding") F = QuadraticField(-1, 'i') i = F.gen() @@ -1021,9 +1199,12 @@ def RealSymmetricSimpleEJA(n, field=QQ): """ S = _real_symmetric_basis(n, field=field) - Qs = _multiplication_table_from_matrix_basis(S) + (Qs, T) = _multiplication_table_from_matrix_basis(S) - return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=n) + return FiniteDimensionalEuclideanJordanAlgebra(field, + Qs, + rank=n, + natural_basis=T) def ComplexHermitianSimpleEJA(n, field=QQ): @@ -1045,8 +1226,11 @@ def ComplexHermitianSimpleEJA(n, field=QQ): """ S = _complex_hermitian_basis(n) - Qs = _multiplication_table_from_matrix_basis(S) - return FiniteDimensionalEuclideanJordanAlgebra(field, Qs, rank=n) + (Qs, T) = _multiplication_table_from_matrix_basis(S) + return FiniteDimensionalEuclideanJordanAlgebra(field, + Qs, + rank=n, + natural_basis=T) def QuaternionHermitianSimpleEJA(n): @@ -1093,13 +1277,6 @@ def JordanSpinSimpleEJA(n, field=QQ): 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) @@ -1114,7 +1291,13 @@ def JordanSpinSimpleEJA(n, field=QQ): Qi[0,0] = Qi[0,0] * ~field(2) Qs.append(Qi) + # The usual inner product on R^n. + ip = lambda x, y: x.vector().inner_product(y.vector()) + # 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)) + return FiniteDimensionalEuclideanJordanAlgebra(field, + Qs, + rank=min(n,2), + inner_product=ip)