X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=1302ca18bf9988f57048cdd9035e79212aa7ca3d;hb=cc309b502850fd99abc742ee4ee4e015312f65ac;hp=08ad700d77938c2bacaab4e337088ee1efc81afa;hpb=8c02b1e4b574267d7571759315164ade1b26f6ce;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 08ad700..1302ca1 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -64,7 +64,8 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): associative=False, check_field=True, check_axioms=True, - prefix='e'): + prefix='e', + category=None): if check_field: if not field.is_subring(RR): @@ -93,11 +94,12 @@ class FiniteDimensionalEJA(CombinatorialFreeModule): raise ValueError("inner-product is not commutative") - category = MagmaticAlgebras(field).FiniteDimensional() - category = category.WithBasis().Unital() - if associative: - # Element subalgebras can take advantage of this. - category = category.Associative() + if category is None: + category = MagmaticAlgebras(field).FiniteDimensional() + category = category.WithBasis().Unital() + if associative: + # Element subalgebras can take advantage of this. + category = category.Associative() # Call the superclass constructor so that we can use its from_vector() # method to build our multiplication table. @@ -2740,35 +2742,38 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, """ def __init__(self, modules, **kwargs): - CombinatorialFreeModule_CartesianProduct.__init__(self, modules, **kwargs) + CombinatorialFreeModule_CartesianProduct.__init__(self, modules) field = modules[0].base_ring() if not all( J.base_ring() == field for J in modules ): raise ValueError("all factors must share the same base field") - M = cartesian_product( [J.matrix_space() for J in modules] ) - - m = len(modules) - W = VectorSpace(field,m) - self._matrix_basis = [] - for k in range(m): - for a in modules[k].matrix_basis(): - v = W.zero().list() - v[k] = a - self._matrix_basis.append(M(v)) - - self._matrix_basis = tuple(self._matrix_basis) - - n = len(self._matrix_basis) - # TODO: - # - # Initialize the FDEJA class, too. Does this override the - # initialization that we did for the - # CombinatorialFreeModule_CartesianProduct class? If not, we - # will probably have to duplicate some of the work (i.e. one - # of the constructors). Since the CartesianProduct one is - # smaller, that makes the most sense to copy/paste if it comes - # down to that. - # + basis = tuple( b.to_vector().column() for b in self.basis() ) + + # Define jordan/inner products that operate on the basis. + def jordan_product(x_mat,y_mat): + x = self.from_vector(_mat2vec(x_mat)) + y = self.from_vector(_mat2vec(y_mat)) + return self.cartesian_jordan_product(x,y).to_vector().column() + + def inner_product(x_mat, y_mat): + x = self.from_vector(_mat2vec(x_mat)) + y = self.from_vector(_mat2vec(y_mat)) + return self.cartesian_inner_product(x,y) + + # Use whatever category the superclass came up with. Usually + # some join of the EJA and Cartesian product + # categories. There's no need to check the field since it + # already came from an EJA. Likewise the axioms are guaranteed + # to be satisfied. + FiniteDimensionalEJA.__init__(self, + basis, + jordan_product, + inner_product, + field=field, + check_field=False, + check_axioms=False, + category=self.category(), + **kwargs) self.rank.set_cache(sum(J.rank() for J in modules)) @@ -2778,10 +2783,15 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, SETUP:: sage: from mjo.eja.eja_algebra import (random_eja, + ....: JordanSpinEJA, ....: HadamardEJA, - ....: RealSymmetricEJA) + ....: RealSymmetricEJA, + ....: ComplexHermitianEJA) - EXAMPLES:: + EXAMPLES: + + The projection morphisms are Euclidean Jordan algebra + operators:: sage: J1 = HadamardEJA(2) sage: J2 = RealSymmetricEJA(2) @@ -2808,6 +2818,21 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, Codomain: Euclidean Jordan algebra of dimension 3 over Algebraic Real Field + The projections work the way you'd expect on the vector + representation of an element:: + + sage: J1 = JordanSpinEJA(2) + sage: J2 = ComplexHermitianEJA(2) + sage: J = cartesian_product([J1,J2]) + sage: pi_left = J.cartesian_projection(0) + sage: pi_right = J.cartesian_projection(1) + sage: pi_left(J.one()).to_vector() + (1, 0) + sage: pi_right(J.one()).to_vector() + (1, 0, 0, 1) + sage: J.one().to_vector() + (1, 0, 1, 0, 0, 1) + TESTS: The answer never changes:: @@ -2823,12 +2848,8 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, """ Ji = self.cartesian_factors()[i] - # We reimplement the CombinatorialFreeModule superclass method - # because if we don't, something gets messed up with the caching - # and the answer changes the second time you run it. See the TESTS. - Pi = self._module_morphism(lambda j_t: Ji.monomial(j_t[1]) - if i == j_t[0] else Ji.zero(), - codomain=Ji) + # Requires the fix on Trac 31421/31422 to work! + Pi = super().cartesian_projection(i) return FiniteDimensionalEJAOperator(self,Ji,Pi.matrix()) @cached_method @@ -2837,10 +2858,14 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, SETUP:: sage: from mjo.eja.eja_algebra import (random_eja, + ....: JordanSpinEJA, ....: HadamardEJA, ....: RealSymmetricEJA) - EXAMPLES:: + EXAMPLES: + + The embedding morphisms are Euclidean Jordan algebra + operators:: sage: J1 = HadamardEJA(2) sage: J2 = RealSymmetricEJA(2) @@ -2872,6 +2897,29 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, Algebraic Real Field (+) Euclidean Jordan algebra of dimension 3 over Algebraic Real Field + The embeddings work the way you'd expect on the vector + representation of an element:: + + sage: J1 = JordanSpinEJA(3) + sage: J2 = RealSymmetricEJA(2) + sage: J = cartesian_product([J1,J2]) + sage: iota_left = J.cartesian_embedding(0) + sage: iota_right = J.cartesian_embedding(1) + sage: iota_left(J1.zero()) == J.zero() + True + sage: iota_right(J2.zero()) == J.zero() + True + sage: J1.one().to_vector() + (1, 0, 0) + sage: iota_left(J1.one()).to_vector() + (1, 0, 0, 0, 0, 0) + sage: J2.one().to_vector() + (1, 0, 1) + sage: iota_right(J2.one()).to_vector() + (0, 0, 0, 1, 0, 1) + sage: J.one().to_vector() + (1, 0, 0, 1, 0, 1) + TESTS: The answer never changes:: @@ -2885,161 +2933,130 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, sage: E0 == E1 True + Composing a projection with the corresponding inclusion should + produce the identity map, and mismatching them should produce + the zero map:: + + sage: set_random_seed() + sage: J1 = random_eja() + sage: J2 = random_eja() + sage: J = cartesian_product([J1,J2]) + sage: iota_left = J.cartesian_embedding(0) + sage: iota_right = J.cartesian_embedding(1) + sage: pi_left = J.cartesian_projection(0) + sage: pi_right = J.cartesian_projection(1) + sage: pi_left*iota_left == J1.one().operator() + True + sage: pi_right*iota_right == J2.one().operator() + True + sage: (pi_left*iota_right).is_zero() + True + sage: (pi_right*iota_left).is_zero() + True + """ Ji = self.cartesian_factors()[i] - # We reimplement the CombinatorialFreeModule superclass method - # because if we don't, something gets messed up with the caching - # and the answer changes the second time you run it. See the TESTS. - Ei = Ji._module_morphism(lambda t: self.monomial((i, t)), codomain=self) + # Requires the fix on Trac 31421/31422 to work! + Ei = super().cartesian_embedding(i) return FiniteDimensionalEJAOperator(Ji,self,Ei.matrix()) -FiniteDimensionalEJA.CartesianProduct = CartesianProductEJA - - -# def projections(self): -# r""" -# Return a pair of projections onto this algebra's factors. - -# SETUP:: - -# sage: from mjo.eja.eja_algebra import (JordanSpinEJA, -# ....: ComplexHermitianEJA, -# ....: DirectSumEJA) - -# EXAMPLES:: - -# sage: J1 = JordanSpinEJA(2) -# sage: J2 = ComplexHermitianEJA(2) -# sage: J = DirectSumEJA(J1,J2) -# sage: (pi_left, pi_right) = J.projections() -# sage: J.one().to_vector() -# (1, 0, 1, 0, 0, 1) -# sage: pi_left(J.one()).to_vector() -# (1, 0) -# sage: pi_right(J.one()).to_vector() -# (1, 0, 0, 1) - -# """ -# (J1,J2) = self.factors() -# m = J1.dimension() -# n = J2.dimension() -# V_basis = self.vector_space().basis() -# # Need to specify the dimensions explicitly so that we don't -# # wind up with a zero-by-zero matrix when we want e.g. a -# # zero-by-two matrix (important for composing things). -# P1 = matrix(self.base_ring(), m, m+n, V_basis[:m]) -# P2 = matrix(self.base_ring(), n, m+n, V_basis[m:]) -# pi_left = FiniteDimensionalEJAOperator(self,J1,P1) -# pi_right = FiniteDimensionalEJAOperator(self,J2,P2) -# return (pi_left, pi_right) - -# def inclusions(self): -# r""" -# Return the pair of inclusion maps from our factors into us. - -# SETUP:: - -# sage: from mjo.eja.eja_algebra import (random_eja, -# ....: JordanSpinEJA, -# ....: RealSymmetricEJA, -# ....: DirectSumEJA) - -# EXAMPLES:: - -# sage: J1 = JordanSpinEJA(3) -# sage: J2 = RealSymmetricEJA(2) -# sage: J = DirectSumEJA(J1,J2) -# sage: (iota_left, iota_right) = J.inclusions() -# sage: iota_left(J1.zero()) == J.zero() -# True -# sage: iota_right(J2.zero()) == J.zero() -# True -# sage: J1.one().to_vector() -# (1, 0, 0) -# sage: iota_left(J1.one()).to_vector() -# (1, 0, 0, 0, 0, 0) -# sage: J2.one().to_vector() -# (1, 0, 1) -# sage: iota_right(J2.one()).to_vector() -# (0, 0, 0, 1, 0, 1) -# sage: J.one().to_vector() -# (1, 0, 0, 1, 0, 1) - -# TESTS: - -# Composing a projection with the corresponding inclusion should -# produce the identity map, and mismatching them should produce -# the zero map:: - -# sage: set_random_seed() -# sage: J1 = random_eja() -# sage: J2 = random_eja() -# sage: J = DirectSumEJA(J1,J2) -# sage: (iota_left, iota_right) = J.inclusions() -# sage: (pi_left, pi_right) = J.projections() -# sage: pi_left*iota_left == J1.one().operator() -# True -# sage: pi_right*iota_right == J2.one().operator() -# True -# sage: (pi_left*iota_right).is_zero() -# True -# sage: (pi_right*iota_left).is_zero() -# True - -# """ -# (J1,J2) = self.factors() -# m = J1.dimension() -# n = J2.dimension() -# V_basis = self.vector_space().basis() -# # Need to specify the dimensions explicitly so that we don't -# # wind up with a zero-by-zero matrix when we want e.g. a -# # two-by-zero matrix (important for composing things). -# I1 = matrix.column(self.base_ring(), m, m+n, V_basis[:m]) -# I2 = matrix.column(self.base_ring(), n, m+n, V_basis[m:]) -# iota_left = FiniteDimensionalEJAOperator(J1,self,I1) -# iota_right = FiniteDimensionalEJAOperator(J2,self,I2) -# return (iota_left, iota_right) - -# def inner_product(self, x, y): -# r""" -# The standard Cartesian inner-product. - -# We project ``x`` and ``y`` onto our factors, and add up the -# inner-products from the subalgebras. - -# SETUP:: - - -# sage: from mjo.eja.eja_algebra import (HadamardEJA, -# ....: QuaternionHermitianEJA, -# ....: DirectSumEJA) - -# EXAMPLE:: - -# sage: J1 = HadamardEJA(3,field=QQ) -# sage: J2 = QuaternionHermitianEJA(2,field=QQ,orthonormalize=False) -# sage: J = DirectSumEJA(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: J.one().inner_product(J.one()) -# 5 - -# """ -# (pi_left, pi_right) = self.projections() -# x1 = pi_left(x) -# x2 = pi_right(x) -# y1 = pi_left(y) -# y2 = pi_right(y) - -# return (x1.inner_product(y1) + x2.inner_product(y2)) + 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 ) + + + Element = FiniteDimensionalEJAElement + +class FiniteDimensionalEJA_CartesianProduct(CartesianProductEJA): + r""" + A wrapper around the :class:`CartesianProductEJA` class that gets + used by the ``cartesian_product`` functor. Its one job is to set + ``orthonormalize=False``, since ``cartesian_product()`` can't be + made to pass that option through. And if we try to orthonormalize + over the rationals, we get conversion errors. If you want a non- + standard Jordan product or inner product, or if you want to + orthonormalize the basis, use :class:`CartesianProductEJA` + directly. + """ + def __init__(self, modules, **options): + CombinatorialFreeModule_CartesianProduct.__init__(self, + modules, + **options) + CartesianProductEJA.__init__(self, modules, orthonormalize=False) +FiniteDimensionalEJA.CartesianProduct = FiniteDimensionalEJA_CartesianProduct random_eja = ConcreteEJA.random_instance