eja: fix parent of empty sum in element inverse().

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

diff --git a/mjo/eja/eja_element.py b/mjo/eja/eja_element.py
index 2c425ca320a5c04e6defee044bd0deb01e76dda4..85ec494e53beaf05c788dbd5b04a23a18c0952d6 100644 (file)
--- a/mjo/eja/eja_element.py
+++ b/mjo/eja/eja_element.py
@@ -484,10 +484,12 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement):
         of an element is the inverse of its left-multiplication operator
         applied to the algebra's identity, when that inverse exists::
 
-            sage: J = random_eja()
-            sage: x = J.random_element()
-            sage: (not x.operator().is_invertible()) or (
-            ....:    x.operator().inverse()(J.one()) == x.inverse() )
+            sage: J = random_eja()                         # long time
+            sage: x = J.random_element()                   # long time
+            sage: (not x.operator().is_invertible()) or (  # long time
+            ....:    x.operator().inverse()(J.one())       # long time
+            ....:    ==                                    # long time
+            ....:    x.inverse() )                         # long time
             True
 
         Check that the fast (cached) and slow algorithms give the same
@@ -504,15 +506,18 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement):
             True
         """
         not_invertible_msg = "element is not invertible"
-        if self.parent()._charpoly_coefficients.is_in_cache():
+
+        algebra = self.parent()
+        if algebra._charpoly_coefficients.is_in_cache():
             # We can invert using our charpoly if it will be fast to
             # compute. If the coefficients are cached, our rank had
             # better be too!
             if self.det().is_zero():
                 raise ZeroDivisionError(not_invertible_msg)
-            r = self.parent().rank()
+            r = algebra.rank()
             a = self.characteristic_polynomial().coefficients(sparse=False)
-            return (-1)**(r+1)*sum(a[i+1]*self**i for i in range(r))/self.det()
+            return (-1)**(r+1)*algebra.sum(a[i+1]*self**i
+                                           for i in range(r))/self.det()
 
         try:
             inv = (~self.quadratic_representation())(self)
@@ -976,9 +981,9 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement):
 
         The minimal polynomial should always kill its element::
 
-            sage: x = random_eja().random_element()
-            sage: p = x.minimal_polynomial()
-            sage: x.apply_univariate_polynomial(p)
+            sage: x = random_eja().random_element()  # long time
+            sage: p = x.minimal_polynomial()         # long time
+            sage: x.apply_univariate_polynomial(p)   # long time
             0
 
         The minimal polynomial is invariant under a change of basis,