X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=28e2a0b7a7ca354d83b77708382bb17b04028072;hb=1464a12b77a4dad5b96e91a2ab8168a047ed13cb;hp=a0c072bb13bfdac56a3389b4463ed37e7793fafd;hpb=94eadcdcc061b299f5be5bce1450b94bbd7bfa39;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index a0c072b..28e2a0b 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -5,13 +5,323 @@ are used in optimization, and have some additional nice methods beyond what can be supported in a general Jordan Algebra. """ -from sage.all import * +from sage.categories.magmatic_algebras import MagmaticAlgebras +from sage.structure.element import is_Matrix +from sage.structure.category_object import normalize_names -def eja_minimal_polynomial(x): - """ - Return the minimal polynomial of ``x`` in its parent EJA - """ - return x._x.matrix().minimal_polynomial() +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_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) + + 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=names, + category=category) + + + def _repr_(self): + """ + Return a string representation of ``self``. + """ + fmt = "Euclidean Jordan algebra of degree {} over {}" + return fmt.format(self.degree(), self.base_ring()) + + def rank(self): + """ + Return the rank of this EJA. + """ + if self._rank is None: + raise ValueError("no rank specified at genesis") + else: + return self._rank + + + 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): + """ + Return ``self`` raised to the power ``n``. + + Jordan algebras are always power-associative; see for + example Faraut and Koranyi, Proposition II.1.2 (ii). + """ + A = self.parent() + if n == 0: + return A.one() + elif n == 1: + return self + else: + return A.element_class(A, self.vector()*(self.matrix()**(n-1))) + + + 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): + """ + Compute the degree of this element the straightforward way + according to the definition; by appending powers to a list + and figuring out its dimension (that is, whether or not + they're linearly dependent). + + EXAMPLES:: + + sage: J = eja_ln(4) + sage: J.one().degree() + 1 + sage: e0,e1,e2,e3 = J.gens() + sage: (e0 - e1).degree() + 2 + + In the spin factor algebra (of rank two), all elements that + aren't multiples of the identity are regular:: + + sage: set_random_seed() + sage: n = ZZ.random_element(1,10).abs() + sage: J = eja_ln(n) + sage: x = J.random_element() + sage: x == x.coefficient(0)*J.one() or x.degree() == 2 + True + + """ + return self.span_of_powers().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 + + """ + # 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... + 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.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.degree() == x.minimal_polynomial().degree() + True + + The minimal polynomial and the characteristic polynomial coincide + and are known (see Alizadeh, Example 11.11) for all elements of + the spin factor algebra that aren't scalar multiples of the + identity:: + + sage: set_random_seed() + sage: n = ZZ.random_element(2,10).abs() + sage: J = eja_ln(n) + sage: y = J.random_element() + sage: while y == y.coefficient(0)*J.one(): + ....: y = J.random_element() + sage: y0 = y.vector()[0] + sage: y_bar = y.vector()[1:] + sage: actual = y.minimal_polynomial() + sage: x = SR.symbol('x', domain='real') + sage: expected = x^2 - 2*y0*x + (y0^2 - norm(y_bar)^2) + sage: bool(actual == expected) + 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 characteristic_polynomial(self): + return self.matrix().characteristic_polynomial() def eja_rn(dimension, field=QQ): @@ -47,16 +357,12 @@ def eja_rn(dimension, field=QQ): Qs = [ matrix(field, dimension, dimension, lambda k,j: 1*(k == j == i)) for i in xrange(dimension) ] - # Assuming associativity is wrong here, but it works to - # temporarily trick the Jordan algebra constructor into using the - # multiplication table. - A = FiniteDimensionalAlgebra(field,Qs,assume_associative=True) - return JordanAlgebra(A) + return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension) def eja_ln(dimension, field=QQ): """ - Return the Jordan algebra corresponding to the Lorenzt "ice cream" + Return the Jordan algebra corresponding to the Lorentz "ice cream" cone of the given ``dimension``. EXAMPLES: @@ -101,8 +407,8 @@ def eja_ln(dimension, field=QQ): Qi[0,0] = Qi[0,0] * ~field(2) Qs.append(Qi) - # Assuming associativity is wrong here, but it works to - # temporarily trick the Jordan algebra constructor into using the - # multiplication table. - A = FiniteDimensionalAlgebra(field,Qs,assume_associative=True) - return JordanAlgebra(A) + # 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)