eja: don't pass in a full multiplication table unless necessary.

[sage.d.git] / mjo / eja / eja_algebra.py

diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py
index 107adccdd6c6c44262fda89752f604c9b93c50e8..bab1002ae7d0e2bc1e0fe1332f28871f55efadf2 100644 (file)
--- a/mjo/eja/eja_algebra.py
+++ b/mjo/eja/eja_algebra.py
@@ -1197,11 +1197,19 @@ class RationalBasisEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebr
             # the given basis.
             W = V.span_of_basis( vector_basis )
 
-            # TODO: use symmetry
-            self._deortho_multiplication_table = [ [0 for j in range(n)]
-                                                   for i in range(n) ]
-            self._deortho_inner_product_table = [ [0 for j in range(n)]
-                                                  for i in range(n) ]
+            if check_axioms:
+                # If the superclass constructor is going to verify the
+                # symmetry of this table, it has better at least be
+                # square...
+                self._deortho_multiplication_table = [ [0 for j in range(n)]
+                                                       for i in range(n) ]
+                self._deortho_inner_product_table = [ [0 for j in range(n)]
+                                                      for i in range(n) ]
+            else:
+                self._deortho_multiplication_table = [ [0 for j in range(i+1)]
+                                                       for i in range(n) ]
+                self._deortho_inner_product_table = [ [0 for j in range(i+1)]
+                                                      for i in range(n) ]
 
             # Note: the Jordan and inner-products are defined in terms
             # of the ambient basis. It's important that their arguments
@@ -1224,12 +1232,14 @@ class RationalBasisEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebr
                         # table is in terms of vectors
                         elt = _mat2vec(elt)
 
-                    # TODO: use symmetry
                     elt = W.coordinate_vector(elt)
                     self._deortho_multiplication_table[i][j] = elt
-                    self._deortho_multiplication_table[j][i] = elt
                     self._deortho_inner_product_table[i][j] = ip
-                    self._deortho_inner_product_table[j][i] = ip
+                    if check_axioms:
+                        # The tables are square if we're verifying that they
+                        # are commutative.
+                        self._deortho_multiplication_table[j][i] = elt
+                        self._deortho_inner_product_table[j][i] = ip
 
         if self._deortho_multiplication_table is not None:
             self._deortho_multiplication_table = tuple(map(tuple, self._deortho_multiplication_table))
@@ -1268,9 +1278,15 @@ class RationalBasisEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebr
         self._deortho_matrix = matrix( U.coordinate_vector(q)
                                        for q in vector_basis )
 
-        # TODO: use symmetry
-        mult_table = [ [0 for j in range(n)] for i in range(n) ]
-        ip_table = [ [0 for j in range(n)] for i in range(n) ]
+        # If the superclass constructor is going to verify the
+        # symmetry of this table, it has better at least be
+        # square...
+        if check_axioms:
+            mult_table = [ [0 for j in range(n)] for i in range(n) ]
+            ip_table = [ [0 for j in range(n)] for i in range(n) ]
+        else:
+            mult_table = [ [0 for j in range(i+1)] for i in range(n) ]
+            ip_table = [ [0 for j in range(i+1)] for i in range(n) ]
 
         # Note: the Jordan and inner-products are defined in terms
         # of the ambient basis. It's important that their arguments
@@ -1293,12 +1309,14 @@ class RationalBasisEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebr
                     # table is in terms of vectors
                     elt = _mat2vec(elt)
 
-                # TODO: use symmetry
                 elt = W.coordinate_vector(elt)
                 mult_table[i][j] = elt
-                mult_table[j][i] = elt
                 ip_table[i][j] = ip
-                ip_table[j][i] = ip
+                if check_axioms:
+                    # The tables are square if we're verifying that they
+                    # are commutative.
+                    mult_table[j][i] = elt
+                    ip_table[j][i] = ip
 
         if basis_is_matrices:
             for m in basis:
@@ -2609,21 +2627,22 @@ class DirectSumEJA(FiniteDimensionalEuclideanJordanAlgebra):
         n2 = J2.dimension()
         n = n1+n2
         V = VectorSpace(field, n)
-        mult_table = [ [ V.zero() for j in range(n) ]
+        mult_table = [ [ V.zero() for j in range(i+1) ]
                        for i in range(n) ]
         for i in range(n1):
-            for j in range(n1):
+            for j in range(i+1):
                 p = (J1.monomial(i)*J1.monomial(j)).to_vector()
                 mult_table[i][j] = V(p.list() + [field.zero()]*n2)
 
         for i in range(n2):
-            for j in range(n2):
+            for j in range(i+1):
                 p = (J2.monomial(i)*J2.monomial(j)).to_vector()
                 mult_table[n1+i][n1+j] = V([field.zero()]*n1 + p.list())
 
         # TODO: build the IP table here from the two constituent IP
         # matrices (it'll be block diagonal, I think).
-        ip_table = None
+        ip_table = [ [ field.zero() for j in range(i+1) ]
+                       for i in range(n) ]
         super(DirectSumEJA, self).__init__(field,
                                            mult_table,
                                            ip_table,