X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=618e09cf41d58eec7ade00aca846eb9677f468ae;hb=21fa036e86711c6c28b6d89af2b1bfe4ceb24b29;hp=99cf0d0d078851ec49391c9c2f290716e6e42e22;hpb=d6f51df5e37b30956849e01b70c4aede00f3434e;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 99cf0d0..618e09c 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -31,10 +31,9 @@ from sage.modules.free_module import FreeModule, VectorSpace from sage.rings.all import (ZZ, QQ, AA, QQbar, RR, RLF, CLF, PolynomialRing, QuadraticField) -from mjo.eja.eja_element import (CartesianProductEJAElement, - FiniteDimensionalEJAElement) +from mjo.eja.eja_element import FiniteDimensionalEJAElement from mjo.eja.eja_operator import FiniteDimensionalEJAOperator -from mjo.eja.eja_utils import _mat2vec +from mjo.eja.eja_utils import _all2list, _mat2vec class FiniteDimensionalEJA(CombinatorialFreeModule): r""" @@ -76,6 +75,18 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): check_axioms=True, prefix='e'): + # Keep track of whether or not the matrix basis consists of + # tuples, since we need special cases for them damned near + # everywhere. This is INDEPENDENT of whether or not the + # algebra is a cartesian product, since a subalgebra of a + # cartesian product will have a basis of tuples, but will not + # in general itself be a cartesian product algebra. + self._matrix_basis_is_cartesian = False + n = len(basis) + if n > 0: + if hasattr(basis[0], 'cartesian_factors'): + self._matrix_basis_is_cartesian = True + if check_field: if not field.is_subring(RR): # Note: this does return true for the real algebraic @@ -89,7 +100,13 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): # The field for a cartesian product algebra comes from one # of its factors and is the same for all factors, so # there's no need to "reapply" it on product algebras. - basis = tuple( b.change_ring(field) for b in basis ) + if self._matrix_basis_is_cartesian: + # OK since if n == 0, the basis does not consist of tuples. + P = basis[0].parent() + basis = tuple( P(tuple(b_i.change_ring(field) for b_i in b)) + for b in basis ) + else: + basis = tuple( b.change_ring(field) for b in basis ) if check_axioms: @@ -118,12 +135,12 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): # Call the superclass constructor so that we can use its from_vector() # method to build our multiplication table. - n = len(basis) - super().__init__(field, - range(n), - prefix=prefix, - category=category, - bracket=False) + CombinatorialFreeModule.__init__(self, + field, + range(n), + prefix=prefix, + category=category, + bracket=False) # Now comes all of the hard work. We'll be constructing an # ambient vector space V that our (vectorized) basis lives in, @@ -132,17 +149,9 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): # we see in things like x = 1*e1 + 2*e2. vector_basis = basis - def flatten(b): - # flatten a vector, matrix, or cartesian product of those - # things into a long list. - if cartesian_product: - return sum(( b_i.list() for b_i in b ), []) - else: - return b.list() - degree = 0 if n > 0: - degree = len(flatten(basis[0])) + degree = len(_all2list(basis[0])) # Build an ambient space that fits our matrix basis when # written out as "long vectors." @@ -156,7 +165,7 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): # Save a copy of the un-orthonormalized basis for later. # Convert it to ambient V (vector) coordinates while we're # at it, because we'd have to do it later anyway. - deortho_vector_basis = tuple( V(flatten(b)) for b in basis ) + deortho_vector_basis = tuple( V(_all2list(b)) for b in basis ) from mjo.eja.eja_utils import gram_schmidt basis = tuple(gram_schmidt(basis, inner_product)) @@ -168,7 +177,7 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): # Now create the vector space for the algebra, which will have # its own set of non-ambient coordinates (in terms of the # supplied basis). - vector_basis = tuple( V(flatten(b)) for b in basis ) + vector_basis = tuple( V(_all2list(b)) for b in basis ) W = V.span_of_basis( vector_basis, check=check_axioms) if orthonormalize: @@ -200,7 +209,7 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): # The jordan product returns a matrixy answer, so we # have to convert it to the algebra coordinates. elt = jordan_product(q_i, q_j) - elt = W.coordinate_vector(V(flatten(elt))) + elt = W.coordinate_vector(V(_all2list(elt))) self._multiplication_table[i][j] = self.from_vector(elt) if not orthonormalize: @@ -332,18 +341,6 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): """ return "Associative" in self.category().axioms() - def _is_commutative(self): - r""" - Whether or not this algebra's multiplication table is commutative. - - This method should of course always return ``True``, unless - this algebra was constructed with ``check_axioms=False`` and - passed an invalid multiplication table. - """ - return all( self.product_on_basis(i,j) == self.product_on_basis(i,j) - for i in range(self.dimension()) - for j in range(self.dimension()) ) - def _is_jordanian(self): r""" Whether or not this algebra's multiplication table respects the @@ -351,7 +348,7 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): We only check one arrangement of `x` and `y`, so for a ``True`` result to be truly true, you should also check - :meth:`_is_commutative`. This method should of course always + :meth:`is_commutative`. This method should of course always return ``True``, unless this algebra was constructed with ``check_axioms=False`` and passed an invalid multiplication table. """ @@ -425,6 +422,15 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): ... ValueError: not an element of this algebra + Tuples work as well, provided that the matrix basis for the + algebra consists of them:: + + sage: J1 = HadamardEJA(3) + sage: J2 = RealSymmetricEJA(2) + sage: J = cartesian_product([J1,J2]) + sage: J( (J1.matrix_basis()[1], J2.matrix_basis()[2]) ) + e(0, 1) + e(1, 2) + TESTS: Ensure that we can convert any element of the two non-matrix @@ -470,14 +476,20 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): # closure whereas the base ring of the 3-by-3 identity matrix # could be QQ instead of QQbar. # + # And, we also have to handle Cartesian product bases (when + # the matric basis consists of tuples) here. The "good news" + # is that we're already converting everything to long vectors, + # and that strategy works for tuples as well. + # # We pass check=False because the matrix basis is "guaranteed" # to be linearly independent... right? Ha ha. - V = VectorSpace(self.base_ring(), elt.nrows()*elt.ncols()) - W = V.span_of_basis( (_mat2vec(s) for s in self.matrix_basis()), + elt = _all2list(elt) + V = VectorSpace(self.base_ring(), len(elt)) + W = V.span_of_basis( (V(_all2list(s)) for s in self.matrix_basis()), check=False) try: - coords = W.coordinate_vector(_mat2vec(elt)) + coords = W.coordinate_vector(V(elt)) except ArithmeticError: # vector is not in free module raise ValueError(msg) @@ -1041,14 +1053,12 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): if not c.is_idempotent(): raise ValueError("element is not idempotent: %s" % c) - from mjo.eja.eja_subalgebra import FiniteDimensionalEJASubalgebra - # Default these to what they should be if they turn out to be # trivial, because eigenspaces_left() won't return eigenvalues # corresponding to trivial spaces (e.g. it returns only the # eigenspace corresponding to lambda=1 if you take the # decomposition relative to the identity element). - trivial = FiniteDimensionalEJASubalgebra(self, ()) + trivial = self.subalgebra(()) J0 = trivial # eigenvalue zero J5 = VectorSpace(self.base_ring(), 0) # eigenvalue one-half J1 = trivial # eigenvalue one @@ -1058,9 +1068,7 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): J5 = eigspace else: gens = tuple( self.from_vector(b) for b in eigspace.basis() ) - subalg = FiniteDimensionalEJASubalgebra(self, - gens, - check_axioms=False) + subalg = self.subalgebra(gens, check_axioms=False) if eigval == 0: J0 = subalg elif eigval == 1: @@ -1279,6 +1287,14 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): return len(self._charpoly_coefficients()) + def subalgebra(self, basis, **kwargs): + r""" + Create a subalgebra of this algebra from the given basis. + """ + from mjo.eja.eja_subalgebra import FiniteDimensionalEJASubalgebra + return FiniteDimensionalEJASubalgebra(self, basis, **kwargs) + + def vector_space(self): """ Return the vector space that underlies this algebra. @@ -1297,7 +1313,6 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): return self.zero().to_vector().parent().ambient_vector_space() - Element = FiniteDimensionalEJAElement class RationalBasisEJA(FiniteDimensionalEJA): r""" @@ -2835,19 +2850,6 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, ... ValueError: all factors must share the same base field - The "cached" Jordan and inner products are the componentwise - ones:: - - sage: set_random_seed() - sage: J1 = random_eja() - sage: J2 = random_eja() - sage: J = cartesian_product([J1,J2]) - sage: x,y = J.random_elements(2) - sage: x*y == J.cartesian_jordan_product(x,y) - True - sage: x.inner_product(y) == J.cartesian_inner_product(x,y) - True - The cached unit element is the same one that would be computed:: sage: set_random_seed() # long time @@ -2861,6 +2863,9 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, True """ + Element = FiniteDimensionalEJAElement + + def __init__(self, algebras, **kwargs): CombinatorialFreeModule_CartesianProduct.__init__(self, algebras, @@ -3124,119 +3129,7 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, return FiniteDimensionalEJAOperator(Ji,self,Ei.matrix()) - def cartesian_jordan_product(self, x, y): - r""" - The componentwise Jordan product. - - We project ``x`` and ``y`` onto our factors, and add up the - Jordan products from the subalgebras. This may still be useful - after (if) the default Jordan product in the Cartesian product - algebra is overridden. - - SETUP:: - - sage: from mjo.eja.eja_algebra import (HadamardEJA, - ....: JordanSpinEJA) - - EXAMPLE:: - - sage: J1 = HadamardEJA(3) - sage: J2 = JordanSpinEJA(3) - sage: J = cartesian_product([J1,J2]) - sage: x1 = J1.from_vector(vector(QQ,(1,2,1))) - sage: y1 = J1.from_vector(vector(QQ,(1,0,2))) - sage: x2 = J2.from_vector(vector(QQ,(1,2,3))) - sage: y2 = J2.from_vector(vector(QQ,(1,1,1))) - sage: z1 = J.from_vector(vector(QQ,(1,2,1,1,2,3))) - sage: z2 = J.from_vector(vector(QQ,(1,0,2,1,1,1))) - sage: (x1*y1).to_vector() - (1, 0, 2) - sage: (x2*y2).to_vector() - (6, 3, 4) - sage: J.cartesian_jordan_product(z1,z2).to_vector() - (1, 0, 2, 6, 3, 4) - - """ - m = len(self.cartesian_factors()) - projections = ( self.cartesian_projection(i) for i in range(m) ) - products = ( P(x)*P(y) for P in projections ) - return self._cartesian_product_of_elements(tuple(products)) - - def cartesian_inner_product(self, x, y): - r""" - The standard componentwise Cartesian inner-product. - - We project ``x`` and ``y`` onto our factors, and add up the - inner-products from the subalgebras. This may still be useful - after (if) the default inner product in the Cartesian product - algebra is overridden. - - SETUP:: - - sage: from mjo.eja.eja_algebra import (HadamardEJA, - ....: QuaternionHermitianEJA) - - EXAMPLE:: - - sage: J1 = HadamardEJA(3,field=QQ) - sage: J2 = QuaternionHermitianEJA(2,field=QQ,orthonormalize=False) - sage: J = cartesian_product([J1,J2]) - sage: x1 = J1.one() - sage: x2 = x1 - sage: y1 = J2.one() - sage: y2 = y1 - sage: x1.inner_product(x2) - 3 - sage: y1.inner_product(y2) - 2 - sage: z1 = J._cartesian_product_of_elements((x1,y1)) - sage: z2 = J._cartesian_product_of_elements((x2,y2)) - sage: J.cartesian_inner_product(z1,z2) - 5 - - """ - m = len(self.cartesian_factors()) - projections = ( self.cartesian_projection(i) for i in range(m) ) - return sum( P(x).inner_product(P(y)) for P in projections ) - - - def _element_constructor_(self, elt): - r""" - Construct an element of this algebra from an ordered tuple. - - We just apply the element constructor from each of our factors - to the corresponding component of the tuple, and package up - the result. - - SETUP:: - - sage: from mjo.eja.eja_algebra import (HadamardEJA, - ....: RealSymmetricEJA) - - EXAMPLES:: - - sage: J1 = HadamardEJA(3) - sage: J2 = RealSymmetricEJA(2) - sage: J = cartesian_product([J1,J2]) - sage: J( (J1.matrix_basis()[1], J2.matrix_basis()[2]) ) - e(0, 1) + e(1, 2) - """ - m = len(self.cartesian_factors()) - try: - z = tuple( self.cartesian_factors()[i](elt[i]) for i in range(m) ) - return self._cartesian_product_of_elements(z) - except: - raise ValueError("not an element of this algebra") - - Element = CartesianProductEJAElement - FiniteDimensionalEJA.CartesianProduct = CartesianProductEJA random_eja = ConcreteEJA.random_instance -#def random_eja(*args, **kwargs): -# from sage.categories.cartesian_product import cartesian_product -# J1 = HadamardEJA(1, **kwargs) -# J2 = RealSymmetricEJA(2, **kwargs) -# J = cartesian_product([J1,J2]) -# return J