X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=2ec45cf537661f359ef6cf4e34c578c238f80b31;hb=b479f3bb0d3aae8c598a6ec6459688c4be3202af;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..2ec45cf 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 @@ -151,7 +155,22 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): def subalgebra_generated_by(self): """ - Return the subalgebra of the parent EJA generated by this element. + 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 + """ # First get the subspace spanned by the powers of myself... V = self.span_of_powers() @@ -178,7 +197,11 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): b_right_matrix = matrix(F, b_right_rows) mats.append(b_right_matrix) - return FiniteDimensionalEuclideanJordanAlgebra(F, mats) + # 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): @@ -221,13 +244,131 @@ 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 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. + """ + 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? + 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. + # + # + # TODO: this is buggy, but it's probably because the + # multiplication table for the subalgebra is wrong! The + # matrices should be symmetric I bet. + basis = [self.parent(v) for v in V.basis()] + return self.parent().linear_combination(zip(c_coordinates, basis)) + def characteristic_polynomial(self): @@ -317,4 +458,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)