eja: begin dropping support for vector representations.

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

diff --git a/mjo/eja/eja_element_subalgebra.py b/mjo/eja/eja_element_subalgebra.py
index dceb3b405a4c5a663c61a966993ce890ed516b49..846c13b095cb812edff5c3340c1f0cc8337fe149 100644 (file)
--- a/mjo/eja/eja_element_subalgebra.py
+++ b/mjo/eja/eja_element_subalgebra.py
@@ -9,36 +9,33 @@ class FiniteDimensionalEJAElementSubalgebra(FiniteDimensionalEJASubalgebra):
     def __init__(self, elt, orthonormalize=True, **kwargs):
         superalgebra = elt.parent()
 
+        # TODO: going up to the superalgebra dimension here is
+        # overkill.  We should append p vectors as rows to a matrix
+        # and continually rref() it until the rank stops going
+        # up. When n=10 but the dimension of the algebra is 1, that
+        # can save a shitload of time (especially over AA).
         powers = tuple( elt**k for k in range(superalgebra.dimension()) )
         power_vectors = ( p.to_vector() for p in powers )
         P = matrix(superalgebra.base_ring(), power_vectors)
 
-        if orthonormalize:
-            basis = powers # let god sort 'em out
-        else:
-            # Echelonize the matrix ourselves, because otherwise the
-            # call to P.pivot_rows() below can choose a non-optimal
-            # row-reduction algorithm. In particular, scaling can
-            # help over AA because it avoids the RecursionError that
-            # gets thrown when we have to look too hard for a root.
-            #
-            # Beware: QQ supports an entirely different set of "algorithm"
-            # keywords than do AA and RR.
-            algo = None
-            if superalgebra.base_ring() is not QQ:
-                algo = "scaled_partial_pivoting"
-                P.echelonize(algorithm=algo)
-
-                # In this case, we just need to figure out which elements
-                # of the "powers" list are redundant... First compute the
-                # vector subspace spanned by the powers of the given
-                # element.
-
-                # Figure out which powers form a linearly-independent set.
-                ind_rows = P.pivot_rows()
-
-                # Pick those out of the list of all powers.
-                basis = tuple(map(powers.__getitem__, ind_rows))
+        # Echelonize the matrix ourselves, because otherwise the
+        # call to P.pivot_rows() below can choose a non-optimal
+        # row-reduction algorithm. In particular, scaling can
+        # help over AA because it avoids the RecursionError that
+        # gets thrown when we have to look too hard for a root.
+        #
+        # Beware: QQ supports an entirely different set of "algorithm"
+        # keywords than do AA and RR.
+        algo = None
+        if superalgebra.base_ring() is not QQ:
+            algo = "scaled_partial_pivoting"
+            P.echelonize(algorithm=algo)
+
+            # Figure out which powers form a linearly-independent set.
+            ind_rows = P.pivot_rows()
+
+            # Pick those out of the list of all powers.
+            basis = tuple(map(powers.__getitem__, ind_rows))
 
 
         super().__init__(superalgebra,