X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=60a7ba1ede07bac242eb9aef6bcf9b722340c595;hb=9dfbf47227bdc9a7467e37e04173105fb3b2392b;hp=d460aa029e777f137e64d6028f34a2b55cce6101;hpb=50ea939ce86a7b67f3dc98ba2b3470b9d0dceebd;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index d460aa0..60a7ba1 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -5,35 +5,76 @@ are used in optimization, and have some additional nice methods beyond what can be supported in a general Jordan Algebra. """ +from sage.categories.magmatic_algebras import MagmaticAlgebras +from sage.structure.element import is_Matrix +from sage.structure.category_object import normalize_names + from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra import FiniteDimensionalAlgebra from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra_element import FiniteDimensionalAlgebraElement class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra): @staticmethod - def __classcall__(cls, field, mult_table, names='e', category=None): - fda = super(FiniteDimensionalEuclideanJordanAlgebra, cls) - return fda.__classcall_private__(cls, - field, - mult_table, - names, - category) + def __classcall_private__(cls, + field, + mult_table, + names='e', + assume_associative=False, + category=None, + rank=None): + n = len(mult_table) + mult_table = [b.base_extend(field) for b in mult_table] + for b in mult_table: + b.set_immutable() + if not (is_Matrix(b) and b.dimensions() == (n, n)): + raise ValueError("input is not a multiplication table") + mult_table = tuple(mult_table) + + cat = MagmaticAlgebras(field).FiniteDimensional().WithBasis() + cat.or_subcategory(category) + if assume_associative: + cat = cat.Associative() + + names = normalize_names(n, names) - def __init__(self, field, mult_table, names='e', category=None): + fda = super(FiniteDimensionalEuclideanJordanAlgebra, cls) + return fda.__classcall__(cls, + field, + mult_table, + assume_associative=assume_associative, + names=names, + category=cat, + rank=rank) + + + def __init__(self, field, + mult_table, + names='e', + assume_associative=False, + category=None, + rank=None): + self._rank = rank fda = super(FiniteDimensionalEuclideanJordanAlgebra, self) - fda.__init__(field, mult_table, names, category) + fda.__init__(field, + mult_table, + names=names, + category=category) def _repr_(self): """ Return a string representation of ``self``. """ - return "Euclidean Jordan algebra of degree {} over {}".format(self.degree(), self.base_ring()) + fmt = "Euclidean Jordan algebra of degree {} over {}" + return fmt.format(self.degree(), self.base_ring()) def rank(self): """ Return the rank of this EJA. """ - raise NotImplementedError + if self._rank is None: + raise ValueError("no rank specified at genesis") + else: + return self._rank class Element(FiniteDimensionalAlgebraElement): @@ -44,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 @@ -56,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: @@ -63,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): """ @@ -108,9 +192,46 @@ 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 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 + + 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() @@ -127,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 @@ -137,7 +261,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): @@ -180,13 +308,143 @@ 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. + + 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 characteristic_polynomial(self): @@ -226,7 +484,7 @@ 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) + return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension) def eja_ln(dimension, field=QQ): @@ -276,4 +534,8 @@ def eja_ln(dimension, field=QQ): Qi[0,0] = Qi[0,0] * ~field(2) Qs.append(Qi) - return FiniteDimensionalEuclideanJordanAlgebra(field,Qs) + # 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)