X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feuclidean_jordan_algebra.py;h=d460aa029e777f137e64d6028f34a2b55cce6101;hb=50ea939ce86a7b67f3dc98ba2b3470b9d0dceebd;hp=52e1383383cac83a8fa91e3f63c39c8795d8b533;hpb=bb8418eb800cae28a844f40b5f04480d64b2250b;p=sage.d.git

diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py
index 52e1383..d460aa0 100644
--- a/mjo/eja/euclidean_jordan_algebra.py
+++ b/mjo/eja/euclidean_jordan_algebra.py
@@ -39,6 +39,15 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
     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):
@@ -57,6 +66,18 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
                 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
@@ -73,17 +94,100 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
                 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
+
             """
-            d = 0
-            V = self.vector().parent()
-            vectors = [(self**d).vector()]
-            while V.span(vectors).dimension() > d:
-                d += 1
-                vectors.append((self**d).vector())
-            return d
+            return self.span_of_powers().dimension()
+
+
+        def subalgebra_generated_by(self):
+            """
+            Return the subalgebra of the parent EJA generated by this element.
+            """
+            # First get the subspace spanned by the powers of myself...
+            V = self.span_of_powers()
+            F = self.base_ring()
+
+            # Now figure out the entries of the right-multiplication
+            # matrix for the successive basis elements b0, b1,... of
+            # that subspace.
+            mats = []
+            for b_right in V.basis():
+                eja_b_right = self.parent()(b_right)
+                b_right_rows = []
+                # The first row of the right-multiplication matrix by
+                # b1 is what we get if we apply that matrix to b1. The
+                # second row of the right multiplication matrix by b1
+                # is what we get when we apply that matrix to b2...
+                for b_left in V.basis():
+                    eja_b_left = self.parent()(b_left)
+                    # Multiply in the original EJA, but then get the
+                    # coordinates from the subalgebra in terms of its
+                    # basis.
+                    this_row = V.coordinates((eja_b_left*eja_b_right).vector())
+                    b_right_rows.append(this_row)
+                b_right_matrix = matrix(F, b_right_rows)
+                mats.append(b_right_matrix)
+
+            return FiniteDimensionalEuclideanJordanAlgebra(F, mats)
+
 
         def minimal_polynomial(self):
-            return self.matrix().minimal_polynomial()
+            """
+            EXAMPLES::
+
+                sage: set_random_seed()
+                sage: n = ZZ.random_element(1,10).abs()
+                sage: J = eja_rn(n)
+                sage: x = J.random_element()
+                sage: x.degree() == x.minimal_polynomial().degree()
+                True
+
+            ::
+
+                sage: set_random_seed()
+                sage: n = ZZ.random_element(1,10).abs()
+                sage: J = eja_ln(n)
+                sage: x = J.random_element()
+                sage: x.degree() == x.minimal_polynomial().degree()
+                True
+
+            The minimal polynomial and the characteristic polynomial coincide
+            and are known (see Alizadeh, Example 11.11) for all elements of
+            the spin factor algebra that aren't scalar multiples of the
+            identity::
+
+                sage: set_random_seed()
+                sage: n = ZZ.random_element(2,10).abs()
+                sage: J = eja_ln(n)
+                sage: y = J.random_element()
+                sage: while y == y.coefficient(0)*J.one():
+                ....:     y = J.random_element()
+                sage: y0 = y.vector()[0]
+                sage: y_bar = y.vector()[1:]
+                sage: actual = y.minimal_polynomial()
+                sage: x = SR.symbol('x', domain='real')
+                sage: expected = x^2 - 2*y0*x + (y0^2 - norm(y_bar)^2)
+                sage: bool(actual == expected)
+                True
+
+            """
+            V = self.span_of_powers()
+            assoc_subalg = self.subalgebra_generated_by()
+            # Mis-design warning: the basis used for span_of_powers()
+            # and subalgebra_generated_by() must be the same, and in
+            # the same order!
+            subalg_self = assoc_subalg(V.coordinates(self.vector()))
+            return subalg_self.matrix().minimal_polynomial()
+
 
         def characteristic_polynomial(self):
             return self.matrix().characteristic_polynomial()
@@ -122,9 +226,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)