X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=2404af03d7f249fec64caab63e9954aca91af7ab;hb=59177e7be6376f64fe24061d576a9fde77588d57;hp=849243c81d56a2781a8b0abe5c9e6ae795f264eb;hpb=6d4b7ff3cf1b285953f0f3d3c5797067c0f52587;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index 849243c..2404af0 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -85,6 +85,10 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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 @@ -97,6 +101,21 @@ 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: J = eja_ln(5) + sage: x = J.random_element() + sage: x.matrix()*x.vector() == (x**2).vector() + True + """ A = self.parent() if n == 0: @@ -104,19 +123,128 @@ 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 = 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: 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 + + 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() + 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 = eja_ln(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): @@ -149,36 +277,17 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): return self.span_of_powers().dimension() - def subalgebra_generated_by(self): - """ - Return the subalgebra of the parent EJA generated by this element. + def matrix(self): """ - # First get the subspace spanned by the powers of myself... - V = self.span_of_powers() - F = self.base_ring() + Return the matrix that represents left- (or right-) + multiplication by this element in the parent algebra. - # 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... - 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) - - return FiniteDimensionalEuclideanJordanAlgebra(F, mats) + 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): @@ -221,17 +330,182 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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 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: 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 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 = eja_ln(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() - assoc_subalg = self.subalgebra_generated_by() + 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! - subalg_self = assoc_subalg(V.coordinates(self.vector())) - return subalg_self.matrix().minimal_polynomial() + 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 = eja_ln(3) + sage: e0,e1,e2 = J.gens() + sage: x = e0 + e1 + e2 + sage: x.trace() + 2 - def characteristic_polynomial(self): - return self.matrix().characteristic_polynomial() + """ + 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): @@ -317,4 +591,8 @@ def eja_ln(dimension, field=QQ): Qi[0,0] = Qi[0,0] * ~field(2) Qs.append(Qi) - return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=2) + # 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)