From 69dde0cab851cd1839ad11db6b5d807a5ab936a2 Mon Sep 17 00:00:00 2001
From: Michael Orlitzky <michael@orlitzky.com>
Date: Mon, 24 Jun 2019 22:52:09 -0400
Subject: [PATCH] eja/euclidean_jordan_algebra.py: rewrite the classcall/init
 process.

I'm not sure what I just did, but by copying the __classcall_private__
method from FiniteDimensionalAlgebra, I was able to make it take an
extra (optional) "rank" parameter while creating EJAs. This lets us
hard-code the rank for known EJAs, and put off figuring how we might
compute it otherwise.
---
 mjo/eja/euclidean_jordan_algebra.py | 71 +++++++++++++++++++++++------
 1 file changed, 58 insertions(+), 13 deletions(-)

diff --git a/mjo/eja/euclidean_jordan_algebra.py b/mjo/eja/euclidean_jordan_algebra.py
index d460aa0..a1b28a2 100644
--- a/mjo/eja/euclidean_jordan_algebra.py
+++ b/mjo/eja/euclidean_jordan_algebra.py
@@ -5,35 +5,80 @@ 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")
+            if not (b.is_symmetric()):
+                # Euclidean jordan algebras are commutative, so left/right
+                # multiplication is the same.
+                raise ValueError("multiplication table must be symmetric")
+        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):
@@ -226,7 +271,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 +321,4 @@ def eja_ln(dimension, field=QQ):
         Qi[0,0] = Qi[0,0] * ~field(2)
         Qs.append(Qi)
 
-    return FiniteDimensionalEuclideanJordanAlgebra(field,Qs)
+    return FiniteDimensionalEuclideanJordanAlgebra(field,Qs,rank=2)
-- 
2.44.2