X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=038de61f481c4036dec9032806f22bdf5d2e2602;hb=eabb7b6ad9c1be19f90c9125e79c00eb09a0b68c;hp=60a7ba1ede07bac242eb9aef6bcf9b722340c595;hpb=9dfbf47227bdc9a7467e37e04173105fb3b2392b;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index 60a7ba1..038de61 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 @@ -126,6 +112,92 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): return A.element_class(A, (self.matrix()**(n-1))*self.vector()) + def characteristic_polynomial(self): + """ + 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. + """ + 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 = eja_ln(2) + sage: e0,e1 = J.gens() + sage: x = e0 + e1 + sage: x.det() + 0 + sage: J = eja_ln(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. @@ -150,17 +222,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): """ return self.degree() == self.parent().rank() - 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 degree(self): """ @@ -205,86 +266,19 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): return fda_elt.matrix().transpose() - def subalgebra_generated_by(self): - """ - Return the associative subalgebra of the parent EJA generated - by this element. - - 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.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: 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 minimal_polynomial(self): """ 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 @@ -329,59 +323,73 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): return elt.minimal_polynomial() - def is_nilpotent(self): + def span_of_powers(self): """ - Return whether or not some power of this element is zero. + 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()) ) - 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: + def subalgebra_generated_by(self): + """ + Return the associative subalgebra of the parent EJA generated + by this element. - The identity element is never nilpotent:: + TESTS:: 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() - False + sage: x = random_eja().random_element() + sage: x.subalgebra_generated_by().is_associative() + True - The additive identity is always nilpotent:: + Squaring in the subalgebra should be the same thing as + squaring in the superalgebra:: 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: x = random_eja().random_element() + sage: u = x.subalgebra_generated_by().random_element() + sage: u.matrix()*u.vector() == (u**2).vector() 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 + # First get the subspace spanned by the powers of myself... + V = self.span_of_powers() + F = self.base_ring() - 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())) + # 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) - # Recursive call, but should work since elt lives in an - # associative algebra. - return elt.is_nilpotent() + # 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): @@ -446,9 +454,24 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): return self.parent().linear_combination(zip(c_coordinates, basis)) + def trace(self): + """ + Return my trace, the sum of my eigenvalues. - def characteristic_polynomial(self): - return self.matrix().characteristic_polynomial() + EXAMPLES:: + + sage: J = eja_ln(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 eja_rn(dimension, field=QQ): @@ -539,3 +562,104 @@ def eja_ln(dimension, field=QQ): # ambient dimension). rank = min(dimension,2) return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=rank) + + +def eja_sn(dimension, field=QQ): + """ + Return the simple Jordan algebra of ``dimension``-by-``dimension`` + symmetric matrices over ``field``. + + 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 + + """ + 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 j in xrange(i+1): + Eij = matrix(field, dimension, lambda k,l: k==i and l==j) + if i == j: + Sij = Eij + else: + Sij = Eij + Eij.transpose() + S.append(Sij) + + def mat2vec(m): + return vector(field, m.list()) + + def vec2mat(v): + return matrix(field, dimension, v.list()) + + W = V.span( mat2vec(s) for s in S ) + + # 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: + # 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,Q_rows) + Qs.append(Q) + + 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)