eja: finally enable tests for the trace inner product.

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

diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py
index a0ba1c68bb30bf54383807c52961ad82e4a69f03..c37ace0b2bbf1ce19f20e3127a4a5c80b7191b4e 100644 (file)
--- a/mjo/eja/euclidean_jordan_algebra.py
+++ b/mjo/eja/euclidean_jordan_algebra.py
@@ -548,22 +548,37 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
 
                 sage: J = JordanSpinEJA(2)
                 sage: e0,e1 = J.gens()
-                sage: x = e0 + e1
+                sage: x = sum( J.gens() )
                 sage: x.det()
                 0
+
+            ::
+
                 sage: J = JordanSpinEJA(3)
                 sage: e0,e1,e2 = J.gens()
-                sage: x = e0 + e1 + e2
+                sage: x = sum( J.gens() )
                 sage: x.det()
                 -1
 
+            TESTS:
+
+            An element is invertible if and only if its determinant is
+            non-zero::
+
+                sage: set_random_seed()
+                sage: x = random_eja().random_element()
+                sage: x.is_invertible() == (x.det() != 0)
+                True
+
             """
-            cs = self.characteristic_polynomial().coefficients(sparse=False)
-            r = len(cs) - 1
-            if r >= 0:
-                return cs[0] * (-1)**r
-            else:
-                raise ValueError('charpoly had no coefficients')
+            P = self.parent()
+            r = P.rank()
+            p = P._charpoly_coeff(0)
+            # The _charpoly_coeff function already adds the factor of
+            # -1 to ensure that _charpoly_coeff(0) is really what
+            # appears in front of t^{0} in the charpoly. However,
+            # we want (-1)^r times THAT for the determinant.
+            return ((-1)**r)*p(*self.vector())
 
 
         def inverse(self):
@@ -602,17 +617,12 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
                 sage: J.one().inverse() == J.one()
                 True
 
-            If an element has an inverse, it acts like one. TODO: this
-            can be a lot less ugly once ``is_invertible`` doesn't crash
-            on irregular elements::
+            If an element has an inverse, it acts like one::
 
                 sage: set_random_seed()
                 sage: J = random_eja()
                 sage: x = J.random_element()
-                sage: try:
-                ....:     x.inverse()*x == J.one()
-                ....: except:
-                ....:     True
+                sage: (not x.is_invertible()) or (x.inverse()*x == J.one())
                 True
 
             """
@@ -1223,6 +1233,47 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
         def trace_inner_product(self, other):
             """
             Return the trace inner product of myself and ``other``.
+
+            TESTS:
+
+            The trace inner product is commutative::
+
+                sage: set_random_seed()
+                sage: J = random_eja()
+                sage: x = J.random_element(); y = J.random_element()
+                sage: x.trace_inner_product(y) == y.trace_inner_product(x)
+                True
+
+            The trace inner product is bilinear::
+
+                sage: set_random_seed()
+                sage: J = random_eja()
+                sage: x = J.random_element()
+                sage: y = J.random_element()
+                sage: z = J.random_element()
+                sage: a = QQ.random_element();
+                sage: actual = (a*(x+z)).trace_inner_product(y)
+                sage: expected = ( a*x.trace_inner_product(y) +
+                ....:              a*z.trace_inner_product(y) )
+                sage: actual == expected
+                True
+                sage: actual = x.trace_inner_product(a*(y+z))
+                sage: expected = ( a*x.trace_inner_product(y) +
+                ....:              a*x.trace_inner_product(z) )
+                sage: actual == expected
+                True
+
+            The trace inner product satisfies the compatibility
+            condition in the definition of a Euclidean Jordan algebra::
+
+                sage: set_random_seed()
+                sage: J = random_eja()
+                sage: x = J.random_element()
+                sage: y = J.random_element()
+                sage: z = J.random_element()
+                sage: (x*y).trace_inner_product(z) == y.trace_inner_product(x*z)
+                True
+
             """
             if not other in self.parent():
                 raise TypeError("'other' must live in the same algebra")