eja: add is_minimal_idempotent() for elements.

diff --git a/mjo/eja/eja_element.py b/mjo/eja/eja_element.py
index 166c9d217cf71d43fe4bfc0911e6fe6c3e1ec9d2..575c2a4754ae261f284c53de4d423011c9bf5418 100644 (file)
--- a/mjo/eja/eja_element.py
+++ b/mjo/eja/eja_element.py
@@ -546,6 +546,96 @@ class FiniteDimensionalEuclideanJordanAlgebraElement(IndexedFreeModuleElement):
         return not (p(zero) == zero)
 
 
+    def is_minimal_idempotent(self):
+        """
+        Return whether or not this element is a minimal idempotent.
+
+
+        An element of a Euclidean Jordan algebra is a minimal idempotent
+        if it :meth:`is_idempotent` and if its Peirce subalgebra
+        corresponding to the eigenvalue ``1`` has dimension ``1`` (Baes,
+        Proposition 2.7.17).
+
+        SETUP::
+
+            sage: from mjo.eja.eja_algebra import (JordanSpinEJA,
+            ....:                                  RealSymmetricEJA,
+            ....:                                  random_eja)
+
+        WARNING::
+
+        This method is sloooooow.
+
+        EXAMPLES:
+
+        The spectral decomposition of a non-regular element should always
+        contain at least one non-minimal idempotent::
+
+            sage: J = RealSymmetricEJA(3, AA)
+            sage: x = sum(J.gens())
+            sage: x.is_regular()
+            False
+            sage: [ c.is_minimal_idempotent()
+            ....:   for (l,c) in x.spectral_decomposition() ]
+            [False, True]
+
+        On the other hand, the spectral decomposition of a regular
+        element should always be in terms of minimal idempotents::
+
+            sage: J = JordanSpinEJA(4, AA)
+            sage: x = sum( i*J.gens()[i] for i in range(len(J.gens())) )
+            sage: x.is_regular()
+            True
+            sage: [ c.is_minimal_idempotent()
+            ....:   for (l,c) in x.spectral_decomposition() ]
+            [True, True]
+
+        TESTS:
+
+        The identity element is minimal only in an EJA of rank one::
+
+            sage: set_random_seed()
+            sage: J = random_eja()
+            sage: J.rank() == 1 or not J.one().is_minimal_idempotent()
+            True
+
+        A non-idempotent cannot be a minimal idempotent::
+
+            sage: set_random_seed()
+            sage: J = JordanSpinEJA(4)
+            sage: x = J.random_element()
+            sage: (not x.is_idempotent()) and x.is_minimal_idempotent()
+            False
+
+        Proposition 2.7.19 in Baes says that an element is a minimal
+        idempotent if and only if it's idempotent with trace equal to
+        unity::
+
+            sage: set_random_seed()
+            sage: J = JordanSpinEJA(4)
+            sage: x = J.random_element()
+            sage: expected = (x.is_idempotent() and x.trace() == 1)
+            sage: actual = x.is_minimal_idempotent()
+            sage: actual == expected
+            True
+
+        """
+        # TODO: when the Peirce decomposition is implemented for real,
+        # we can use that instead of finding this eigenspace manually.
+        #
+        # Trivial eigenspaces don't appear in the list, so we default to the
+        # trivial one and override it if there's a nontrivial space in the
+        # list.
+        if not self.is_idempotent():
+            return False
+
+        J1 = VectorSpace(self.parent().base_ring(), 0)
+        for (eigval, eigspace) in self.operator().matrix().left_eigenspaces():
+            if eigval == 1:
+                J1 = eigspace
+        return (J1.dimension() == 1)
+
+
     def is_nilpotent(self):
         """
         Return whether or not some power of this element is zero.