eja: fix tests and pre-cache ranks.

diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py
index ff2b5d7a9c52ff5c13df7d7aa3682899b9a30559..19db8b0ccefef297623d81721d4a774f99a9d3d1 100644 (file)
--- a/mjo/eja/eja_algebra.py
+++ b/mjo/eja/eja_algebra.py
@@ -54,7 +54,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
     def __init__(self,
                  field,
                  mult_table,
-                 rank,
                  prefix='e',
                  category=None,
                  natural_basis=None,
@@ -91,7 +90,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
                 # a real embedding.
                 raise ValueError('field is not real')
 
-        self._rank = rank
         self._natural_basis = natural_basis
 
         if category is None:
@@ -809,7 +807,8 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
 
         SETUP::
 
-            sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
+            sage: from mjo.eja.eja_algebra import (HadamardEJA,
+            ....:                                  JordanSpinEJA,
             ....:                                  RealSymmetricEJA,
             ....:                                  ComplexHermitianEJA,
             ....:                                  QuaternionHermitianEJA,
@@ -1047,7 +1046,8 @@ class HadamardEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA):
                        for i in range(n) ]
 
         fdeja = super(HadamardEJA, self)
-        return fdeja.__init__(field, mult_table, rank=n, **kwargs)
+        fdeja.__init__(field, mult_table, **kwargs)
+        self.rank.set_cache(n)
 
     def inner_product(self, x, y):
         """
@@ -1106,7 +1106,7 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra):
         # field can have dimension 4 (quaternions) too.
         return 2
 
-    def __init__(self, field, basis, rank, normalize_basis=True, **kwargs):
+    def __init__(self, field, basis, normalize_basis=True, **kwargs):
         """
         Compared to the superclass constructor, we take a basis instead of
         a multiplication table because the latter can be computed in terms
@@ -1119,7 +1119,7 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra):
         # time to ensure that it isn't a generator expression.
         basis = tuple(basis)
 
-        if rank > 1 and normalize_basis:
+        if len(basis) > 1 and normalize_basis:
             # We'll need sqrt(2) to normalize the basis, and this
             # winds up in the multiplication table, so the whole
             # algebra needs to be over the field extension.
@@ -1136,14 +1136,12 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra):
         Qs = self.multiplication_table_from_matrix_basis(basis)
 
         fdeja = super(MatrixEuclideanJordanAlgebra, self)
-        return fdeja.__init__(field,
-                              Qs,
-                              rank=rank,
-                              natural_basis=basis,
-                              **kwargs)
+        fdeja.__init__(field, Qs, natural_basis=basis, **kwargs)
+        return
 
 
-    def _rank_computation(self):
+    @cached_method
+    def rank(self):
         r"""
         Override the parent method with something that tries to compute
         over a faster (non-extension) field.
@@ -1151,7 +1149,7 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra):
         if self._basis_normalizers is None:
             # We didn't normalize, so assume that the basis we started
             # with had entries in a nice field.
-            return super(MatrixEuclideanJordanAlgebra, self)._rank_computation()
+            return super(MatrixEuclideanJordanAlgebra, self).rank()
         else:
             basis = ( (b/n) for (b,n) in zip(self.natural_basis(),
                                              self._basis_normalizers) )
@@ -1161,9 +1159,8 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra):
             # integers.
             J = MatrixEuclideanJordanAlgebra(QQ,
                                              basis,
-                                             self.rank(),
                                              normalize_basis=False)
-            return J._rank_computation()
+            return J.rank()
 
     @cached_method
     def _charpoly_coeff(self, i):
@@ -1182,7 +1179,6 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra):
             # Do this over the rationals and convert back at the end.
             J = MatrixEuclideanJordanAlgebra(QQ,
                                              basis,
-                                             self.rank(),
                                              normalize_basis=False)
             (_,x,_,_) = J._charpoly_matrix_system()
             p = J._charpoly_coeff(i)
@@ -1411,7 +1407,8 @@ class RealSymmetricEJA(RealMatrixEuclideanJordanAlgebra, KnownRankEJA):
 
     def __init__(self, n, field=AA, **kwargs):
         basis = self._denormalized_basis(n, field)
-        super(RealSymmetricEJA, self).__init__(field, basis, n, **kwargs)
+        super(RealSymmetricEJA, self).__init__(field, basis, **kwargs)
+        self.rank.set_cache(n)
 
 
 class ComplexMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra):
@@ -1701,7 +1698,8 @@ class ComplexHermitianEJA(ComplexMatrixEuclideanJordanAlgebra, KnownRankEJA):
 
     def __init__(self, n, field=AA, **kwargs):
         basis = self._denormalized_basis(n,field)
-        super(ComplexHermitianEJA,self).__init__(field, basis, n, **kwargs)
+        super(ComplexHermitianEJA,self).__init__(field, basis, **kwargs)
+        self.rank.set_cache(n)
 
 
 class QuaternionMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra):
@@ -1997,7 +1995,8 @@ class QuaternionHermitianEJA(QuaternionMatrixEuclideanJordanAlgebra,
 
     def __init__(self, n, field=AA, **kwargs):
         basis = self._denormalized_basis(n,field)
-        super(QuaternionHermitianEJA,self).__init__(field, basis, n, **kwargs)
+        super(QuaternionHermitianEJA,self).__init__(field, basis, **kwargs)
+        self.rank.set_cache(n)
 
 
 class BilinearFormEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA):
@@ -2080,7 +2079,8 @@ class BilinearFormEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA):
         # one-dimensional ambient space (because the rank is bounded
         # by the ambient dimension).
         fdeja = super(BilinearFormEJA, self)
-        return fdeja.__init__(field, mult_table, rank=min(n,2), **kwargs)
+        fdeja.__init__(field, mult_table, **kwargs)
+        self.rank.set_cache(min(n,2))
 
     def inner_product(self, x, y):
         r"""
@@ -2208,4 +2208,5 @@ class TrivialEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA):
         fdeja = super(TrivialEJA, self)
         # The rank is zero using my definition, namely the dimension of the
         # largest subalgebra generated by any element.
-        return fdeja.__init__(field, mult_table, rank=0, **kwargs)
+        fdeja.__init__(field, mult_table, **kwargs)
+        self.rank.set_cache(0)

diff --git a/mjo/eja/eja_element_subalgebra.py b/mjo/eja/eja_element_subalgebra.py
index cff8b4e8bbc8e1f2119061ca5a5bb84842393a03..608cbc2ed2004235b1f0a356d4a9f89119a2f6c0 100644 (file)
--- a/mjo/eja/eja_element_subalgebra.py
+++ b/mjo/eja/eja_element_subalgebra.py
@@ -49,19 +49,18 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
 
         W = V.span_of_basis( V.from_vector(v) for v in basis_vectors )
 
+        fdeja = super(FiniteDimensionalEuclideanJordanElementSubalgebra, self)
+        fdeja.__init__(self._superalgebra,
+                       superalgebra_basis,
+                       category=category)
+
         # The rank is the highest possible degree of a minimal
         # polynomial, and is bounded above by the dimension. We know
         # in this case that there's an element whose minimal
         # polynomial has the same degree as the space's dimension
         # (remember how we constructed the space?), so that must be
         # its rank too.
-        rank = W.dimension()
-
-        fdeja = super(FiniteDimensionalEuclideanJordanElementSubalgebra, self)
-        return fdeja.__init__(self._superalgebra,
-                              superalgebra_basis,
-                              rank=rank,
-                              category=category)
+        self.rank.set_cache(W.dimension())
 
 
     def _a_regular_element(self):

diff --git a/mjo/eja/eja_subalgebra.py b/mjo/eja/eja_subalgebra.py
index 4355e9f20e40d1a396f42a686d474c77e18f1b47..045c16e7ed691532e016c89192a43903bc0cc7ce 100644 (file)
--- a/mjo/eja/eja_subalgebra.py
+++ b/mjo/eja/eja_subalgebra.py
@@ -130,7 +130,7 @@ class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJorda
         1
 
     """
-    def __init__(self, superalgebra, basis, rank=None, category=None):
+    def __init__(self, superalgebra, basis, category=None):
         self._superalgebra = superalgebra
         V = self._superalgebra.vector_space()
         field = self._superalgebra.base_ring()
@@ -175,12 +175,11 @@ class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJorda
 
 
         fdeja = super(FiniteDimensionalEuclideanJordanSubalgebra, self)
-        return fdeja.__init__(field,
-                              mult_table,
-                              rank,
-                              prefix=prefix,
-                              category=category,
-                              natural_basis=natural_basis)
+        fdeja.__init__(field,
+                       mult_table,
+                       prefix=prefix,
+                       category=category,
+                       natural_basis=natural_basis)