X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=55b8207ddc3f881e8d98f245bf0275bc4b947334;hb=11d8f0663525f469a0557b3f543338709c8e5148;hp=e82e74171f05ffd2c3a6da36fdfdb481f7945c8f;hpb=84081fcf2ce850b8d2f4dc6bbef5981b094b0560;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index e82e741..55b8207 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,25 +2742,47 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, """ def __init__(self, modules, **kwargs): - CombinatorialFreeModule_CartesianProduct.__init__(self, modules, **kwargs) + CombinatorialFreeModule_CartesianProduct.__init__(self, + modules, + **kwargs) 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) + 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. We can't orthonormalize by default because + # there's no way to pass "orthonormalize=False" to + # cartesian_product(...) when the base ring is QQ and + # orthonormalizing would give us irrational entries. + # + # TODO: create a separate constructor that is capable of + # orthonormalizing and is only used by the cartesian_product() + # thingy. + FiniteDimensionalEJA.__init__(self, + basis, + jordan_product, + inner_product, + field=field, + orthonormalize=False, + check_field=False, + check_axioms=False, + category=self.category()) # TODO: # # Initialize the FDEJA class, too. Does this override the @@ -2778,10 +2802,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 +2837,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 +2867,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 +2877,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 +2916,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,12 +2952,31 @@ 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()) @@ -2970,114 +3056,8 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, return sum( P(x).inner_product(P(y)) for P in projections ) -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) - - + Element = FiniteDimensionalEJAElement +FiniteDimensionalEJA.CartesianProduct = CartesianProductEJA random_eja = ConcreteEJA.random_instance