From: Michael Orlitzky <michael@orlitzky.com>
Date: Sat, 12 Dec 2020 17:01:58 +0000 (-0500)
Subject: eja: start putting back DirectSumEJA....
X-Git-Url: https://gitweb.michael.orlitzky.com/?a=commitdiff_plain;h=3b3755e21ddd4f1c44fd8a6bb179f4c3a59c5d2d;p=sage.d.git

eja: start putting back DirectSumEJA....

...and give up because sage is broken on my laptop.
---

diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py
index 58d5ce0..db899dd 100644
--- a/mjo/eja/eja_algebra.py
+++ b/mjo/eja/eja_algebra.py
@@ -2652,100 +2652,84 @@ class TrivialEJA(ConcreteEJA):
         # inappropriate for us.
         return cls(**kwargs)
 
-# class DirectSumEJA(ConcreteEJA):
-#     r"""
-#     The external (orthogonal) direct sum of two other Euclidean Jordan
-#     algebras. Essentially the Cartesian product of its two factors.
-#     Every Euclidean Jordan algebra decomposes into an orthogonal
-#     direct sum of simple Euclidean Jordan algebras, so no generality
-#     is lost by providing only this construction.
-
-#     SETUP::
-
-#         sage: from mjo.eja.eja_algebra import (random_eja,
-#         ....:                                  HadamardEJA,
-#         ....:                                  RealSymmetricEJA,
-#         ....:                                  DirectSumEJA)
-
-#     EXAMPLES::
-
-#         sage: J1 = HadamardEJA(2)
-#         sage: J2 = RealSymmetricEJA(3)
-#         sage: J = DirectSumEJA(J1,J2)
-#         sage: J.dimension()
-#         8
-#         sage: J.rank()
-#         5
-
-#     TESTS:
-
-#     The external direct sum construction is only valid when the two factors
-#     have the same base ring; an error is raised otherwise::
-
-#         sage: set_random_seed()
-#         sage: J1 = random_eja(field=AA)
-#         sage: J2 = random_eja(field=QQ,orthonormalize=False)
-#         sage: J = DirectSumEJA(J1,J2)
-#         Traceback (most recent call last):
-#         ...
-#         ValueError: algebras must share the same base field
-
-#     """
-#     def __init__(self, J1, J2, **kwargs):
-#         if J1.base_ring() != J2.base_ring():
-#             raise ValueError("algebras must share the same base field")
-#         field = J1.base_ring()
-
-#         self._factors = (J1, J2)
-#         n1 = J1.dimension()
-#         n2 = J2.dimension()
-#         n = n1+n2
-#         V = VectorSpace(field, n)
-#         mult_table = [ [ V.zero() for j in range(i+1) ]
-#                        for i in range(n) ]
-#         for i in range(n1):
-#             for j in range(i+1):
-#                 p = (J1.monomial(i)*J1.monomial(j)).to_vector()
-#                 mult_table[i][j] = V(p.list() + [field.zero()]*n2)
-
-#         for i in range(n2):
-#             for j in range(i+1):
-#                 p = (J2.monomial(i)*J2.monomial(j)).to_vector()
-#                 mult_table[n1+i][n1+j] = V([field.zero()]*n1 + p.list())
-
-#         # TODO: build the IP table here from the two constituent IP
-#         # matrices (it'll be block diagonal, I think).
-#         ip_table = [ [ field.zero() for j in range(i+1) ]
-#                        for i in range(n) ]
-#         super(DirectSumEJA, self).__init__(field,
-#                                            mult_table,
-#                                            ip_table,
-#                                            check_axioms=False,
-#                                            **kwargs)
-#         self.rank.set_cache(J1.rank() + J2.rank())
-
-
-#     def factors(self):
-#         r"""
-#         Return the pair of this algebra's factors.
+class DirectSumEJA(ConcreteEJA):
+    r"""
+    The external (orthogonal) direct sum of two other Euclidean Jordan
+    algebras. Essentially the Cartesian product of its two factors.
+    Every Euclidean Jordan algebra decomposes into an orthogonal
+    direct sum of simple Euclidean Jordan algebras, so no generality
+    is lost by providing only this construction.
 
-#         SETUP::
+    SETUP::
 
-#             sage: from mjo.eja.eja_algebra import (HadamardEJA,
-#             ....:                                  JordanSpinEJA,
-#             ....:                                  DirectSumEJA)
+        sage: from mjo.eja.eja_algebra import (random_eja,
+        ....:                                  HadamardEJA,
+        ....:                                  RealSymmetricEJA,
+        ....:                                  DirectSumEJA)
 
-#         EXAMPLES::
+    EXAMPLES::
 
-#             sage: J1 = HadamardEJA(2, field=QQ)
-#             sage: J2 = JordanSpinEJA(3, field=QQ)
-#             sage: J = DirectSumEJA(J1,J2)
-#             sage: J.factors()
-#             (Euclidean Jordan algebra of dimension 2 over Rational Field,
-#              Euclidean Jordan algebra of dimension 3 over Rational Field)
+        sage: J1 = HadamardEJA(2)
+        sage: J2 = RealSymmetricEJA(3)
+        sage: J = DirectSumEJA(J1,J2)
+        sage: J.dimension()
+        8
+        sage: J.rank()
+        5
 
-#         """
-#         return self._factors
+    TESTS:
+
+    The external direct sum construction is only valid when the two factors
+    have the same base ring; an error is raised otherwise::
+
+        sage: set_random_seed()
+        sage: J1 = random_eja(field=AA)
+        sage: J2 = random_eja(field=QQ,orthonormalize=False)
+        sage: J = DirectSumEJA(J1,J2)
+        Traceback (most recent call last):
+        ...
+        ValueError: algebras must share the same base field
+
+    """
+    def __init__(self, J1, J2, **kwargs):
+        if J1.base_ring() != J2.base_ring():
+            raise ValueError("algebras must share the same base field")
+        field = J1.base_ring()
+        self._factors = (J1, J2)
+        basis = tuple( (a,b) for a in J1.basis() for b in J2.basis() )
+
+        def jordan_product(x,y):
+            return (x[0]*y[0], x[1]*y[1])
+
+        def inner_product(x,y):
+            return x[0].inner_product(y[0]) + x[1].inner_product(y[1])
+
+        super().__init__(basis, jordan_product, inner_product)
+
+        self.rank.set_cache(J1.rank() + J2.rank())
+
+
+    def factors(self):
+        r"""
+        Return the pair of this algebra's factors.
+
+        SETUP::
+
+            sage: from mjo.eja.eja_algebra import (HadamardEJA,
+            ....:                                  JordanSpinEJA,
+            ....:                                  DirectSumEJA)
+
+        EXAMPLES::
+
+            sage: J1 = HadamardEJA(2, field=QQ)
+            sage: J2 = JordanSpinEJA(3, field=QQ)
+            sage: J = DirectSumEJA(J1,J2)
+            sage: J.factors()
+            (Euclidean Jordan algebra of dimension 2 over Rational Field,
+             Euclidean Jordan algebra of dimension 3 over Rational Field)
+
+        """
+        return self._factors
 
 #     def projections(self):
 #         r"""