eja: use the associativity of one-generator subalgebras.

[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 d460aa029e777f137e64d6028f34a2b55cce6101..bb460194970e3da92709082a81f78c86a6c88d5c 100644 (file)
--- a/mjo/eja/euclidean_jordan_algebra.py
+++ b/mjo/eja/euclidean_jordan_algebra.py
@@ -5,35 +5,76 @@ are used in optimization, and have some additional nice methods beyond
 what can be supported in a general Jordan Algebra.
 """
 
+from sage.categories.magmatic_algebras import MagmaticAlgebras
+from sage.structure.element import is_Matrix
+from sage.structure.category_object import normalize_names
+
 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 __classcall_private__(cls,
+                              field,
+                              mult_table,
+                              names='e',
+                              assume_associative=False,
+                              category=None,
+                              rank=None):
+        n = len(mult_table)
+        mult_table = [b.base_extend(field) for b in mult_table]
+        for b in mult_table:
+            b.set_immutable()
+            if not (is_Matrix(b) and b.dimensions() == (n, n)):
+                raise ValueError("input is not a multiplication table")
+        mult_table = tuple(mult_table)
+
+        cat = MagmaticAlgebras(field).FiniteDimensional().WithBasis()
+        cat.or_subcategory(category)
+        if assume_associative:
+            cat = cat.Associative()
+
+        names = normalize_names(n, names)
 
-    def __init__(self, field, mult_table, names='e', category=None):
+        fda = super(FiniteDimensionalEuclideanJordanAlgebra, cls)
+        return fda.__classcall__(cls,
+                                 field,
+                                 mult_table,
+                                 assume_associative=assume_associative,
+                                 names=names,
+                                 category=cat,
+                                 rank=rank)
+
+
+    def __init__(self, field,
+                 mult_table,
+                 names='e',
+                 assume_associative=False,
+                 category=None,
+                 rank=None):
+        self._rank = rank
         fda = super(FiniteDimensionalEuclideanJordanAlgebra, self)
-        fda.__init__(field, mult_table, names, category)
+        fda.__init__(field,
+                     mult_table,
+                     names=names,
+                     category=category)
 
 
     def _repr_(self):
         """
         Return a string representation of ``self``.
         """
-        return "Euclidean Jordan algebra of degree {} over {}".format(self.degree(), self.base_ring())
+        fmt = "Euclidean Jordan algebra of degree {} over {}"
+        return fmt.format(self.degree(), self.base_ring())
 
     def rank(self):
         """
         Return the rank of this EJA.
         """
-        raise NotImplementedError
+        if self._rank is None:
+            raise ValueError("no rank specified at genesis")
+        else:
+            return self._rank
 
 
     class Element(FiniteDimensionalAlgebraElement):
@@ -44,6 +85,10 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
         also the left multiplication matrix and must be symmetric::
 
             sage: set_random_seed()
+            sage: n = ZZ.random_element(1,10).abs()
+            sage: J = eja_rn(5)
+            sage: J.random_element().matrix().is_symmetric()
+            True
             sage: J = eja_ln(5)
             sage: J.random_element().matrix().is_symmetric()
             True
@@ -110,7 +155,22 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
 
         def subalgebra_generated_by(self):
             """
-            Return the subalgebra of the parent EJA generated by this element.
+            Return the associative subalgebra of the parent EJA generated
+            by this element.
+
+            TESTS::
+
+                sage: set_random_seed()
+                sage: n = ZZ.random_element(1,10).abs()
+                sage: J = eja_rn(n)
+                sage: x = J.random_element()
+                sage: x.subalgebra_generated_by().is_associative()
+                True
+                sage: J = eja_ln(n)
+                sage: x = J.random_element()
+                sage: x.subalgebra_generated_by().is_associative()
+                True
+
             """
             # First get the subspace spanned by the powers of myself...
             V = self.span_of_powers()
@@ -137,7 +197,9 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
                 b_right_matrix = matrix(F, b_right_rows)
                 mats.append(b_right_matrix)
 
-            return FiniteDimensionalEuclideanJordanAlgebra(F, mats)
+            # It's an algebra of polynomials in one element, and EJAs
+            # are power-associative.
+            return FiniteDimensionalEuclideanJordanAlgebra(F, mats, assume_associative=True)
 
 
         def minimal_polynomial(self):
@@ -180,13 +242,18 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
                 True
 
             """
+            if self.parent().is_associative():
+                return self.matrix().minimal_polynomial()
+
             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()
+            # Recursive call, but should work since the subalgebra is
+            # associative.
+            return subalg_self.minimal_polynomial()
 
 
         def characteristic_polynomial(self):
@@ -226,7 +293,7 @@ def eja_rn(dimension, field=QQ):
     Qs = [ matrix(field, dimension, dimension, lambda k,j: 1*(k == j == i))
            for i in xrange(dimension) ]
 
-    return FiniteDimensionalEuclideanJordanAlgebra(field,Qs)
+    return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=dimension)
 
 
 def eja_ln(dimension, field=QQ):
@@ -276,4 +343,8 @@ def eja_ln(dimension, field=QQ):
         Qi[0,0] = Qi[0,0] * ~field(2)
         Qs.append(Qi)
 
-    return FiniteDimensionalEuclideanJordanAlgebra(field,Qs)
+    # The rank of the spin factor algebra is two, UNLESS we're in a
+    # one-dimensional ambient space (the rank is bounded by the
+    # ambient dimension).
+    rank = min(dimension,2)
+    return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=rank)