X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_element_subalgebra.py;h=3936ac1fe5c7709165b91114b9e52bd8f47ab683;hb=4fcd301b1104a5629e0aa867742f507e882dc25f;hp=67342c6be3df71a63eb4cf82337f52ff7edf5fea;hpb=98da0ce1d1102057e34646889c10dfa01fa9faec;p=sage.d.git

diff --git a/mjo/eja/eja_element_subalgebra.py b/mjo/eja/eja_element_subalgebra.py
index 67342c6..3936ac1 100644
--- a/mjo/eja/eja_element_subalgebra.py
+++ b/mjo/eja/eja_element_subalgebra.py
@@ -1,4 +1,5 @@
 from sage.matrix.constructor import matrix
+from sage.rings.all import QQ
 
 from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanSubalgebra
 
@@ -18,6 +19,19 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
         P = matrix(field, power_vectors)
 
         if orthonormalize_basis == False:
+            # 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 field 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
@@ -28,11 +42,6 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
 
             # Pick those out of the list of all powers.
             superalgebra_basis = tuple(map(powers.__getitem__, ind_rows))
-
-            # If our superalgebra is a subalgebra of something else, then
-            # these vectors won't have the right coordinates for
-            # V.span_of_basis() unless we use V.from_vector() on them.
-            basis_vectors = map(power_vectors.__getitem__, ind_rows)
         else:
             # If we're going to orthonormalize the basis anyway, we
             # might as well just do Gram-Schmidt on the whole list of
@@ -47,7 +56,11 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
             superalgebra_basis = [ self._superalgebra.from_vector(b)
                                    for b in basis_vectors ]
 
-        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,
+                       check_axioms=False)
 
         # The rank is the highest possible degree of a minimal
         # polynomial, and is bounded above by the dimension. We know
@@ -55,37 +68,7 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
         # 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)
-
-
-    def _a_regular_element(self):
-        """
-        Override the superalgebra method to return the one
-        regular element that is sure to exist in this
-        subalgebra, namely the element that generated it.
-
-        SETUP::
-
-            sage: from mjo.eja.eja_algebra import random_eja
-
-        TESTS::
-
-            sage: set_random_seed()
-            sage: J = random_eja().random_element().subalgebra_generated_by()
-            sage: J._a_regular_element().is_regular()
-            True
-
-        """
-        if self.dimension() == 0:
-            return self.zero()
-        else:
-            return self.monomial(1)
+        self.rank.set_cache(self.dimension())
 
 
     def one(self):
@@ -120,7 +103,7 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
         The identity element acts like the identity over the rationals::
 
             sage: set_random_seed()
-            sage: x = random_eja().random_element()
+            sage: x = random_eja(field=QQ).random_element()
             sage: A = x.subalgebra_generated_by()
             sage: x = A.random_element()
             sage: A.one()*x == x and x*A.one() == x
@@ -140,7 +123,7 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
         the rationals::
 
             sage: set_random_seed()
-            sage: x = random_eja().random_element()
+            sage: x = random_eja(field=QQ).random_element()
             sage: A = x.subalgebra_generated_by()
             sage: actual = A.one().operator().matrix()
             sage: expected = matrix.identity(A.base_ring(), A.dimension())
@@ -163,5 +146,10 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
             return self.zero()
         else:
             sa_one = self.superalgebra().one().to_vector()
-            sa_coords = self.vector_space().coordinate_vector(sa_one)
-            return self.from_vector(sa_coords)
+            # The extra hackery is because foo.to_vector() might not
+            # live in foo.parent().vector_space()!
+            coords = sum( a*b for (a,b)
+                          in zip(sa_one,
+                                 self.superalgebra().vector_space().basis()) )
+            return self.from_vector(self.vector_space().coordinate_vector(coords))
+