eja: define matrix basis/space for Cartesian product algebras.

diff --git a/mjo/eja/TODO b/mjo/eja/TODO
index 03bf40459e26805a2b2d6e3bae114779f0de57d3..93aa9fb42e6ec6cdba6963db8dacfddd116ba762 100644 (file)
--- a/mjo/eja/TODO
+++ b/mjo/eja/TODO
@@ -1,10 +1,7 @@
-1. Finish CartesianProductEJA: add to_matrix(),
-   random_instance(),... methods. This will require rethinking what a
-   "matrix representation" and "matrix space" means for a cartesian
-   product algebra. Do we want our matrix basis to consist of ordered
-   pairs (or triples, or...)? Should the matrix_space() of the algebra
-   be the cartesian product of the factors' matrix spaces? Can we just
-   fix the matrix basis/space after we call the FDEJA initializer?
+1. Finish CartesianProductEJA: add to_matrix(), random_instance(),...
+   methods. I guess we should create a separate class hierarchy for
+   Cartesian products of RationalBasisEJA? That way we get fast
+   charpoly and random_instance() defined...
 
 2. Add references and start citing them.
 

diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py
index 850447b38f55b09b707f745959e85dfdfa7d62c1..065339617b4b711dc52cd4a498cf59e59a6c18b1 100644 (file)
--- a/mjo/eja/eja_algebra.py
+++ b/mjo/eja/eja_algebra.py
@@ -2836,6 +2836,45 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct,
         self.one.set_cache(self._cartesian_product_of_elements(ones))
         self.rank.set_cache(sum(J.rank() for J in modules))
 
+        # Now that everything else is ready, we clobber our computed
+        # matrix basis with the "correct" one consisting of ordered
+        # tuples. Since we didn't orthonormalize our basis, we can
+        # create these from the basis that was handed to us; that is,
+        # we don't need to use the one that the earlier __init__()
+        # method came up with.
+        m = len(self.cartesian_factors())
+        MS = self.matrix_space()
+        self._matrix_basis = tuple(
+            MS(tuple( self.cartesian_projection(i)(b).to_matrix()
+                      for i in range(m) ))
+            for b in self.basis()
+        )
+
+    def matrix_space(self):
+        r"""
+        Return the space that our matrix basis lives in as a Cartesian
+        product.
+
+        SETUP::
+
+            sage: from mjo.eja.eja_algebra import (HadamardEJA,
+            ....:                                  RealSymmetricEJA)
+
+        EXAMPLES::
+
+            sage: J1 = HadamardEJA(1)
+            sage: J2 = RealSymmetricEJA(2)
+            sage: J = cartesian_product([J1,J2])
+            sage: J.matrix_space()
+            The Cartesian product of (Full MatrixSpace of 1 by 1 dense
+            matrices over Algebraic Real Field, Full MatrixSpace of 2
+            by 2 dense matrices over Algebraic Real Field)
+
+        """
+        from sage.categories.cartesian_product import cartesian_product
+        return cartesian_product( [J.matrix_space()
+                                   for J in self.cartesian_factors()] )
+
     @cached_method
     def cartesian_projection(self, i):
         r"""
@@ -3096,6 +3135,31 @@ class CartesianProductEJA(CombinatorialFreeModule_CartesianProduct,
         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())
+        z = tuple( self.cartesian_factors()[i](elt[i]) for i in range(m) )
+        return self._cartesian_product_of_elements(z)
+
     Element = FiniteDimensionalEJAElement