X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=ae5baa0eff4a64dac97944bbdaf5a8ec132495bd;hb=1adac51be4b18c6045d69bea652d8f2059e09b26;hp=8a3710cce5498d4d47c23a35bf438f055b8d18e7;hpb=3fca9f08bb6e2485fa81d4bfd4801dc12d1fd83a;p=sage.d.git

diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py
index 8a3710c..ae5baa0 100644
--- a/mjo/eja/eja_algebra.py
+++ b/mjo/eja/eja_algebra.py
@@ -1007,7 +1007,33 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra):
             return tr.coefficient_tuple()[0]
 
 
-class RealSymmetricEJA(MatrixEuclideanJordanAlgebra):
+class RealMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra):
+    @staticmethod
+    def real_embed(M):
+        """
+        Embed the matrix ``M`` into a space of real matrices.
+
+        The matrix ``M`` can have entries in any field at the moment:
+        the real numbers, complex numbers, or quaternions. And although
+        they are not a field, we can probably support octonions at some
+        point, too. This function returns a real matrix that "acts like"
+        the original with respect to matrix multiplication; i.e.
+
+          real_embed(M*N) = real_embed(M)*real_embed(N)
+
+        """
+        return M
+
+
+    @staticmethod
+    def real_unembed(M):
+        """
+        The inverse of :meth:`real_embed`.
+        """
+        return M
+
+
+class RealSymmetricEJA(RealMatrixEuclideanJordanAlgebra):
     """
     The rank-n simple EJA consisting of real symmetric n-by-n
     matrices, the usual symmetric Jordan product, and the trace inner
@@ -1114,30 +1140,6 @@ class RealSymmetricEJA(MatrixEuclideanJordanAlgebra):
     def _max_test_case_size():
         return 5 # Dimension 10
 
-    @staticmethod
-    def real_embed(M):
-        """
-        Embed the matrix ``M`` into a space of real matrices.
-
-        The matrix ``M`` can have entries in any field at the moment:
-        the real numbers, complex numbers, or quaternions. And although
-        they are not a field, we can probably support octonions at some
-        point, too. This function returns a real matrix that "acts like"
-        the original with respect to matrix multiplication; i.e.
-
-          real_embed(M*N) = real_embed(M)*real_embed(N)
-
-        """
-        return M
-
-
-    @staticmethod
-    def real_unembed(M):
-        """
-        The inverse of :meth:`real_embed`.
-        """
-        return M
-
 
 
 class ComplexMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra):
@@ -1259,6 +1261,37 @@ class ComplexMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra):
         return matrix(F, n/2, elements)
 
 
+    @classmethod
+    def natural_inner_product(cls,X,Y):
+        """
+        Compute a natural inner product in this algebra directly from
+        its real embedding.
+
+        SETUP::
+
+            sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
+
+        TESTS:
+
+        This gives the same answer as the slow, default method implemented
+        in :class:`MatrixEuclideanJordanAlgebra`::
+
+            sage: set_random_seed()
+            sage: J = ComplexHermitianEJA.random_instance()
+            sage: x,y = J.random_elements(2)
+            sage: Xe = x.natural_representation()
+            sage: Ye = y.natural_representation()
+            sage: X = ComplexHermitianEJA.real_unembed(Xe)
+            sage: Y = ComplexHermitianEJA.real_unembed(Ye)
+            sage: expected = (X*Y).trace().vector()[0]
+            sage: actual = ComplexHermitianEJA.natural_inner_product(Xe,Ye)
+            sage: actual == expected
+            True
+
+        """
+        return RealMatrixEuclideanJordanAlgebra.natural_inner_product(X,Y)/2
+
+
 class ComplexHermitianEJA(ComplexMatrixEuclideanJordanAlgebra):
     """
     The rank-n simple EJA consisting of complex Hermitian n-by-n
@@ -1507,6 +1540,36 @@ class QuaternionMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra):
         return matrix(Q, n/4, elements)
 
 
+    @classmethod
+    def natural_inner_product(cls,X,Y):
+        """
+        Compute a natural inner product in this algebra directly from
+        its real embedding.
+
+        SETUP::
+
+            sage: from mjo.eja.eja_algebra import QuaternionHermitianEJA
+
+        TESTS:
+
+        This gives the same answer as the slow, default method implemented
+        in :class:`MatrixEuclideanJordanAlgebra`::
+
+            sage: set_random_seed()
+            sage: J = QuaternionHermitianEJA.random_instance()
+            sage: x,y = J.random_elements(2)
+            sage: Xe = x.natural_representation()
+            sage: Ye = y.natural_representation()
+            sage: X = QuaternionHermitianEJA.real_unembed(Xe)
+            sage: Y = QuaternionHermitianEJA.real_unembed(Ye)
+            sage: expected = (X*Y).trace().coefficient_tuple()[0]
+            sage: actual = QuaternionHermitianEJA.natural_inner_product(Xe,Ye)
+            sage: actual == expected
+            True
+
+        """
+        return RealMatrixEuclideanJordanAlgebra.natural_inner_product(X,Y)/4
+
 
 class QuaternionHermitianEJA(QuaternionMatrixEuclideanJordanAlgebra):
     """