From c49406021cb8496ead26ef89865f8afbdc96ea6c Mon Sep 17 00:00:00 2001 From: Michael Orlitzky Date: Fri, 26 Feb 2021 10:40:20 -0500 Subject: [PATCH] eja: partially fix the product_on_basis() in Cartesian products. --- mjo/eja/eja_algebra.py | 66 +++++++++++++++++++++++++++--------------- 1 file changed, 42 insertions(+), 24 deletions(-) diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 00de418..cbe5c08 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -3196,6 +3196,37 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, self.one.set_cache(self._cartesian_product_of_elements(ones)) self.rank.set_cache(sum(J.rank() for J in algebras)) + def _monomial_to_generator(self, mon): + r""" + Convert a monomial index into a generator index. + + SETUP:: + + sage: from mjo.eja.eja_algebra import random_eja() + + TESTS:: + + sage: J1 = random_eja(field=QQ, orthonormalize=False) + sage: J2 = random_eja(field=QQ, orthonormalize=False) + sage: J = cartesian_product([J1,J2]) + sage: all( J.monomial(m) + ....: == + ....: J.gens()[J._monomial_to_generator(m)] + ....: for m in J.basis().keys() ) + + """ + # The superclass method indexes into a matrix, so we have to + # turn the tuples i and j into integers. This is easy enough + # given that the first coordinate of i and j corresponds to + # the factor, and the second coordinate corresponds to the + # index of the generator within that factor. + factor = mon[0] + idx_in_factor = mon[1] + + offset = sum( f.dimension() + for f in self.cartesian_factors()[:factor] ) + return offset + idx_in_factor + def product_on_basis(self, i, j): r""" Return the product of the monomials indexed by ``i`` and ``j``. @@ -3205,37 +3236,24 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct, SETUP:: - sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA, - ....: JordanSpinEJA, + sage: from mjo.eja.eja_algebra import (QuaternionHermitianEJA, ....: RealSymmetricEJA) TESTS:: - sage: J1 = RealSymmetricEJA(2,field=QQ,orthonormalize=False) - sage: J2 = ComplexHermitianEJA(0,field=QQ,orthonormalize=False) - sage: J3 = JordanSpinEJA(2,field=QQ,orthonormalize=False) - sage: J = cartesian_product([J1,J2,J3]) + sage: J1 = RealSymmetricEJA(1,field=QQ) + sage: J2 = QuaternionHermitianEJA(1,field=QQ) + sage: J = cartesian_product([J1,J2]) sage: x = sum(J.gens()) - sage: x*J.one() - e(0, 0) + e(0, 1) + e(0, 2) + e(2, 0) + e(2, 1) - sage: x*x - 2*e(0, 0) + 2*e(0, 1) + 2*e(0, 2) + 2*e(2, 0) + 2*e(2, 1) + sage: x == J.one() + True + sage: x*x == x + True """ - factor = i[0] - assert(j[0] == i[0]) - n = self.cartesian_factors()[factor].dimension() - - # The superclass method indexes into a matrix, so we have to - # turn the tuples i and j into integers. This is easy enough - # given that the first coordinate of i and j corresponds to - # the factor, and the second coordinate corresponds to the - # index of the generator within that factor. And of course - # we should never be multiplying two elements from different - # factors. - l = n*factor + i[1] - m = n*factor + j[1] - super().product_on_basis(l, m) + l = self._monomial_to_generator(i) + m = self._monomial_to_generator(j) + return FiniteDimensionalEJA.product_on_basis(self, l, m) def matrix_space(self): r""" -- 2.44.2