X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_element.py;h=8af3b77698457486af3d5b64eb52bf6f6e7b5ea8;hb=c38ce6eab53954221d4f944ea0ad4ac27f323023;hp=ef6370495333791ca30070fd658e7502ef982433;hpb=6957e7f70a89c4ddcc5d9148e1833188ccd7353d;p=sage.d.git diff --git a/mjo/eja/eja_element.py b/mjo/eja/eja_element.py index ef63704..8af3b77 100644 --- a/mjo/eja/eja_element.py +++ b/mjo/eja/eja_element.py @@ -3,11 +3,11 @@ from sage.misc.cachefunc import cached_method from sage.modules.free_module import VectorSpace from sage.modules.with_basis.indexed_element import IndexedFreeModuleElement -from mjo.eja.eja_operator import FiniteDimensionalEJAOperator +from mjo.eja.eja_operator import EJAOperator from mjo.eja.eja_utils import _scale -class FiniteDimensionalEJAElement(IndexedFreeModuleElement): +class EJAElement(IndexedFreeModuleElement): """ An element of a Euclidean Jordan algebra. """ @@ -1162,7 +1162,7 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): P = self.parent() left_mult_by_self = lambda y: self*y L = P.module_morphism(function=left_mult_by_self, codomain=P) - return FiniteDimensionalEJAOperator(P, P, L.matrix() ) + return EJAOperator(P, P, L.matrix() ) def quadratic_representation(self, other=None): @@ -1455,7 +1455,10 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): if self.is_nilpotent(): raise ValueError("this only works with non-nilpotent elements!") - J = self.subalgebra_generated_by() + # The subalgebra is transient (we return an element of the + # superalgebra, i.e. this algebra) so why bother + # orthonormalizing? + J = self.subalgebra_generated_by(orthonormalize=False) u = J(self) # The image of the matrix of left-u^m-multiplication @@ -1476,14 +1479,12 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): # 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.operator().matrix() c = J.from_vector(A.solve_right(u_next.to_vector())) - # Now c is the idempotent we want, but it still lives in the subalgebra. + # Now c is the idempotent we want, but it still lives in + # the subalgebra. return c.superalgebra_element() @@ -1721,19 +1722,18 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement): return self.trace_inner_product(self).sqrt() -class CartesianProductEJAElement(FiniteDimensionalEJAElement): - def det(self): - r""" - Compute the determinant of this product-element using the - determianants of its factors. - - This result Follows from the spectral decomposition of (say) - the pair `(x,y)` in terms of the Jordan frame `\left\{ (c_1, - 0),(c_2, 0),...,(0,d_1),(0,d_2),... \right\}. - """ - from sage.misc.misc_c import prod - return prod( f.det() for f in self.cartesian_factors() ) +class CartesianProductParentEJAElement(EJAElement): + r""" + An intermediate class for elements that have a Cartesian + product as their parent algebra. + This is needed because the ``to_matrix`` method (which gives you a + representation from the superalgebra) needs to do special stuff + for Cartesian products. Specifically, an EJA subalgebra of a + Cartesian product EJA will not itself be a Cartesian product (it + has its own basis) -- but we want ``to_matrix()`` to be able to + give us a Cartesian product representation. + """ def to_matrix(self): # An override is necessary to call our custom _scale(). B = self.parent().matrix_basis() @@ -1741,7 +1741,20 @@ class CartesianProductEJAElement(FiniteDimensionalEJAElement): # Aaaaand linear combinations don't work in Cartesian # product spaces, even though they provide a method with - # that name. This is hidden behind an "if" because the + # that name. This is hidden in a subclass because the # _scale() function is slow. pairs = zip(B, self.to_vector()) return W.sum( _scale(b, alpha) for (b,alpha) in pairs ) + +class CartesianProductEJAElement(CartesianProductParentEJAElement): + def det(self): + r""" + Compute the determinant of this product-element using the + determianants of its factors. + + This result Follows from the spectral decomposition of (say) + the pair `(x,y)` in terms of the Jordan frame `\left\{ (c_1, + 0),(c_2, 0),...,(0,d_1),(0,d_2),... \right\}. + """ + from sage.misc.misc_c import prod + return prod( f.det() for f in self.cartesian_factors() )