From c49406021cb8496ead26ef89865f8afbdc96ea6c Mon Sep 17 00:00:00 2001
From: Michael Orlitzky <michael@orlitzky.com>
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