X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=097233fdad86dea01e11483d7b7525f0ab816f2a;hb=c9f6a4e581371552f8e3340330caa07d76afacf7;hp=7611fe7eef371058bd201dc5888fa63eb58881bd;hpb=92c3da0a3c2f4c7a7d1f9a6a5507957719368062;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index 7611fe7..097233f 100644 --- a/mjo/eja/euclidean_jordan_algebra.py +++ b/mjo/eja/euclidean_jordan_algebra.py @@ -5,7 +5,147 @@ 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.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 __init__(self, field, mult_table, names='e', category=None): + fda = super(FiniteDimensionalEuclideanJordanAlgebra, self) + fda.__init__(field, mult_table, names, category) + + + def _repr_(self): + """ + Return a string representation of ``self``. + """ + return "Euclidean Jordan algebra of degree {} over {}".format(self.degree(), self.base_ring()) + + def rank(self): + """ + Return the rank of this EJA. + """ + raise NotImplementedError + + + 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: 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 subalgebra of the parent EJA generated by this element. + """ + # 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) + + return FiniteDimensionalEuclideanJordanAlgebra(F, mats) + + + def minimal_polynomial(self): + return self.matrix().minimal_polynomial() + + def characteristic_polynomial(self): + return self.matrix().characteristic_polynomial() + def eja_rn(dimension, field=QQ): """ @@ -39,13 +179,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) 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: @@ -90,5 +230,4 @@ 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) + return FiniteDimensionalEuclideanJordanAlgebra(field,Qs)