eja: add span_of_powers() method.

[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 5ccf2f29fd480f4a499d55fc3d9dad85942dc6f4..ce6f6e55e18b28aabea82c9118758c1dab061c28 100644 (file)
--- a/mjo/eja/euclidean_jordan_algebra.py
+++ b/mjo/eja/euclidean_jordan_algebra.py
@@ -5,12 +5,121 @@ are used in optimization, and have some additional nice methods beyond
 what can be supported in a general Jordan Algebra.
 """
 
-from sage.all import *
+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
+    def __classcall__(cls, field, mult_table, names='e', category=None):
+        fda = super(FiniteDimensionalEuclideanJordanAlgebra, cls)
+        return fda.__classcall_private__(cls,
+                                         field,
+                                         mult_table,
+                                         names,
+                                         category)
+
+    def __init__(self, field, mult_table, names='e', category=None):
+        fda = super(FiniteDimensionalEuclideanJordanAlgebra, self)
+        fda.__init__(field, mult_table, names, category)
+
+
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
+        """
+        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.
+        """
+
+        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
+
+            """
+            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):
     """
     Return the Euclidean Jordan Algebra corresponding to the set
     `R^n` under the Hadamard product.
+
+    EXAMPLES:
+
+    This multiplication table can be verified by hand::
+
+        sage: J = eja_rn(3)
+        sage: e0,e1,e2 = J.gens()
+        sage: e0*e0
+        e0
+        sage: e0*e1
+        0
+        sage: e0*e2
+        0
+        sage: e1*e1
+        e1
+        sage: e1*e2
+        0
+        sage: e2*e2
+        e2
+
     """
     # The FiniteDimensionalAlgebra constructor takes a list of
     # matrices, the ith representing right multiplication by the ith
@@ -19,5 +128,55 @@ def eja_rn(dimension, field=QQ):
     # component of x; and likewise for the ith basis element e_i.
     Qs = [ matrix(field, dimension, dimension, lambda k,j: 1*(k == j == i))
            for i in xrange(dimension) ]
-    A = FiniteDimensionalAlgebra(QQ,Qs,assume_associative=True)
-    return JordanAlgebra(A)
+
+    return FiniteDimensionalEuclideanJordanAlgebra(field,Qs)
+
+
+def eja_ln(dimension, field=QQ):
+    """
+    Return the Jordan algebra corresponding to the Lorentz "ice cream"
+    cone of the given ``dimension``.
+
+    EXAMPLES:
+
+    This multiplication table can be verified by hand::
+
+        sage: J = eja_ln(4)
+        sage: e0,e1,e2,e3 = J.gens()
+        sage: e0*e0
+        e0
+        sage: e0*e1
+        e1
+        sage: e0*e2
+        e2
+        sage: e0*e3
+        e3
+        sage: e1*e2
+        0
+        sage: e1*e3
+        0
+        sage: e2*e3
+        0
+
+    In one dimension, this is the reals under multiplication::
+
+      sage: J1 = eja_ln(1)
+      sage: J2 = eja_rn(1)
+      sage: J1 == J2
+      True
+
+    """
+    Qs = []
+    id_matrix = identity_matrix(field,dimension)
+    for i in xrange(dimension):
+        ei = id_matrix.column(i)
+        Qi = zero_matrix(field,dimension)
+        Qi.set_row(0, ei)
+        Qi.set_column(0, ei)
+        Qi += diagonal_matrix(dimension, [ei[0]]*dimension)
+        # The addition of the diagonal matrix adds an extra ei[0] in the
+        # upper-left corner of the matrix.
+        Qi[0,0] = Qi[0,0] * ~field(2)
+        Qs.append(Qi)
+
+    return FiniteDimensionalEuclideanJordanAlgebra(field,Qs)