X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=60a7ba1ede07bac242eb9aef6bcf9b722340c595;hb=9dfbf47227bdc9a7467e37e04173105fb3b2392b;hp=8f623b4491ca1439d0905b5b91bcfe25cf754ecb;hpb=0dc6a110a16f63240e7817fc7529996e885973c8;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index 8f623b4..60a7ba1 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -101,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: @@ -108,8 +123,32 @@ 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 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 span_of_powers(self): """ @@ -153,6 +192,19 @@ 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). + """ + fda_elt = FiniteDimensionalAlgebraElement(self.parent(), self) + return fda_elt.matrix().transpose() + + def subalgebra_generated_by(self): """ Return the associative subalgebra of the parent EJA generated @@ -171,6 +223,15 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): 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() @@ -187,6 +248,9 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): # 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 @@ -199,7 +263,9 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): # It's an algebra of polynomials in one element, and EJAs # are power-associative. - return FiniteDimensionalEuclideanJordanAlgebra(F, mats, assume_associative=True) + # + # TODO: choose generator names intelligently. + return FiniteDimensionalEuclideanJordanAlgebra(F, mats, assume_associative=True, names='f') def minimal_polynomial(self): @@ -263,6 +329,124 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): return elt.minimal_polynomial() + 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 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() + 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 characteristic_polynomial(self): return self.matrix().characteristic_polynomial()