X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=8487e0ecea385d00f45c176bdc43b45d31d617ff;hb=0898205b7a8dc3a44e9fddd371814be6c94107bb;hp=624806fddac93c9292b229d6afd7954224827e87;hpb=7c384faefd026dd4010e30399646e2e4cb5b4b27;p=sage.d.git

diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py
index 624806f..8487e0e 100644
--- a/mjo/eja/euclidean_jordan_algebra.py
+++ b/mjo/eja/euclidean_jordan_algebra.py
@@ -5,8 +5,8 @@ are used in optimization, and have some additional nice methods beyond
 what can be supported in a general Jordan Algebra.
 """
 
-from sage.structure.unique_representation import UniqueRepresentation
 from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra import FiniteDimensionalAlgebra
+from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra_element import FiniteDimensionalAlgebraElement
 
 class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
     @staticmethod
@@ -29,6 +29,90 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
         """
         return "Euclidean Jordan algebra of degree {} over {}".format(self.degree(), self.base_ring())
 
+    def rank(self):
+        """
+        Return the rank of this EJA.
+        """
+        raise NotImplementedError
+
+
+    class Element(FiniteDimensionalAlgebraElement):
+        """
+        An element of a Euclidean Jordan algebra.
+
+        Since EJAs are commutative, the "right multiplication" matrix is
+        also the left multiplication matrix and must be symmetric::
+
+            sage: set_random_seed()
+            sage: J = eja_ln(5)
+            sage: J.random_element().matrix().is_symmetric()
+            True
+
+        """
+
+        def __pow__(self, n):
+            """
+            Return ``self`` raised to the power ``n``.
+
+            Jordan algebras are always power-associative; see for
+            example Faraut and Koranyi, Proposition II.1.2 (ii).
+            """
+            A = self.parent()
+            if n == 0:
+                return A.one()
+            elif n == 1:
+                return self
+            else:
+                return A.element_class(A, self.vector()*(self.matrix()**(n-1)))
+
+
+        def span_of_powers(self):
+            """
+            Return the vector space spanned by successive powers of
+            this element.
+            """
+            # The dimension of the subalgebra can't be greater than
+            # the big algebra, so just put everything into a list
+            # and let span() get rid of the excess.
+            V = self.vector().parent()
+            return V.span( (self**d).vector() for d in xrange(V.dimension()) )
+
+
+        def degree(self):
+            """
+            Compute the degree of this element the straightforward way
+            according to the definition; by appending powers to a list
+            and figuring out its dimension (that is, whether or not
+            they're linearly dependent).
+
+            EXAMPLES::
+
+                sage: J = eja_ln(4)
+                sage: J.one().degree()
+                1
+                sage: e0,e1,e2,e3 = J.gens()
+                sage: (e0 - e1).degree()
+                2
+
+            In the spin factor algebra (of rank two), all elements that
+            aren't multiples of the identity are regular::
+
+                sage: set_random_seed()
+                sage: n = ZZ.random_element(1,10).abs()
+                sage: J = eja_ln(n)
+                sage: x = J.random_element()
+                sage: x == x.coefficient(0)*J.one() or x.degree() == 2
+                True
+
+            """
+            return self.span_of_powers().dimension()
+
+
+        def minimal_polynomial(self):
+            return self.matrix().minimal_polynomial()
+
+        def characteristic_polynomial(self):
+            return self.matrix().characteristic_polynomial()
 
 
 def eja_rn(dimension, field=QQ):
@@ -64,9 +148,6 @@ def eja_rn(dimension, field=QQ):
     Qs = [ matrix(field, dimension, dimension, lambda k,j: 1*(k == j == i))
            for i in xrange(dimension) ]
 
-    # Assuming associativity is wrong here, but it works to
-    # temporarily trick the Jordan algebra constructor into using the
-    # multiplication table.
     return FiniteDimensionalEuclideanJordanAlgebra(field,Qs)