X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=bb460194970e3da92709082a81f78c86a6c88d5c;hb=556690d808d614f2c271dc431dd909e353530594;hp=097233fdad86dea01e11483d7b7525f0ab816f2a;hpb=c9f6a4e581371552f8e3340330caa07d76afacf7;p=sage.d.git diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py index 097233f..bb46019 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 @@ -110,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() @@ -137,11 +197,64 @@ 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. + return FiniteDimensionalEuclideanJordanAlgebra(F, mats, assume_associative=True) def minimal_polynomial(self): - return self.matrix().minimal_polynomial() + """ + 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 + + """ + if self.parent().is_associative(): + return self.matrix().minimal_polynomial() + + 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! + subalg_self = assoc_subalg(V.coordinates(self.vector())) + # Recursive call, but should work since the subalgebra is + # associative. + return subalg_self.minimal_polynomial() + def characteristic_polynomial(self): return self.matrix().characteristic_polynomial() @@ -180,7 +293,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): @@ -230,4 +343,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)