X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=8f623b4491ca1439d0905b5b91bcfe25cf754ecb;hb=0dc6a110a16f63240e7817fc7529996e885973c8;hp=be281bfb99d0ef86e73fa7d4a2d3643f54d605e3;hpb=83f719b66100fdb5bf5035355c48b5337be6b11e;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index be281bf..8f623b4 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -5,13 +5,266 @@ 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. + return FiniteDimensionalEuclideanJordanAlgebra(F, mats, assume_associative=True) + + + 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 characteristic_polynomial(self): + return self.matrix().characteristic_polynomial() def eja_rn(dimension, field=QQ): @@ -46,13 +299,13 @@ def eja_rn(dimension, field=QQ): # component of x; and likewise for the ith basis element e_i. Qs = [ matrix(field, dimension, dimension, lambda k,j: 1*(k == j == i)) for i in xrange(dimension) ] - A = FiniteDimensionalAlgebra(QQ,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: @@ -97,5 +350,8 @@ def eja_ln(dimension, field=QQ): Qi[0,0] = Qi[0,0] * ~field(2) Qs.append(Qi) - A = FiniteDimensionalAlgebra(QQ,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)