eja: add is_self_adjoint() for operators.

[sage.d.git] / mjo / eja / eja_operator.py

diff --git a/mjo/eja/eja_operator.py b/mjo/eja/eja_operator.py
index 667e3d5acba051e08bf461e12aafd9ae2437cc74..0b52f555d51f58341fe56f5b63984f88cdf99da0 100644 (file)
--- a/mjo/eja/eja_operator.py
+++ b/mjo/eja/eja_operator.py
@@ -3,12 +3,48 @@ from sage.categories.all import FreeModules
 from sage.categories.map import Map
 
 class FiniteDimensionalEuclideanJordanAlgebraOperator(Map):
+    r"""
+    An operator between two finite-dimensional Euclidean Jordan algebras.
+
+    SETUP::
+
+        sage: from mjo.eja.eja_algebra import HadamardEJA
+        sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
+
+    EXAMPLES:
+
+    The domain and codomain must be finite-dimensional Euclidean
+    Jordan algebras; if either is not, then an error is raised::
+
+        sage: J = HadamardEJA(3)
+        sage: V = VectorSpace(J.base_ring(), 3)
+        sage: M = matrix.identity(J.base_ring(), 3)
+        sage: FiniteDimensionalEuclideanJordanAlgebraOperator(V,J,M)
+        Traceback (most recent call last):
+        ...
+        TypeError: domain must be a finite-dimensional Euclidean
+        Jordan algebra
+        sage: FiniteDimensionalEuclideanJordanAlgebraOperator(J,V,M)
+        Traceback (most recent call last):
+        ...
+        TypeError: codomain must be a finite-dimensional Euclidean
+        Jordan algebra
+
+    """
+
     def __init__(self, domain_eja, codomain_eja, mat):
-        # if not (
-        #   isinstance(domain_eja, FiniteDimensionalEuclideanJordanAlgebra) and
-        #   isinstance(codomain_eja, FiniteDimensionalEuclideanJordanAlgebra) ):
-        #     raise ValueError('(co)domains must be finite-dimensional Euclidean '
-        #                      'Jordan algebras')
+        from mjo.eja.eja_algebra import FiniteDimensionalEuclideanJordanAlgebra
+
+        # I guess we should check this, because otherwise you could
+        # pass in pretty much anything algebraish.
+        if not isinstance(domain_eja,
+                          FiniteDimensionalEuclideanJordanAlgebra):
+            raise TypeError('domain must be a finite-dimensional '
+                            'Euclidean Jordan algebra')
+        if not isinstance(codomain_eja,
+                          FiniteDimensionalEuclideanJordanAlgebra):
+            raise TypeError('codomain must be a finite-dimensional '
+                            'Euclidean Jordan algebra')
 
         F = domain_eja.base_ring()
         if not (F == codomain_eja.base_ring()):
@@ -383,6 +419,73 @@ class FiniteDimensionalEuclideanJordanAlgebraOperator(Map):
         return (self + (-other))
 
 
+    def is_self_adjoint(self):
+        r"""
+        Return whether or not this operator is self-adjoint.
+
+        At least in Sage, the fact that the base field is real means
+        that the algebra elements have to be real as well (this is why
+        we embed the complex numbers and quaternions). As a result, the
+        matrix of this operator will contain only real entries, and it
+        suffices to check only symmetry, not conjugate symmetry.
+
+        SETUP::
+
+            sage: from mjo.eja.eja_algebra import (JordanSpinEJA)
+
+        EXAMPLES::
+
+            sage: J = JordanSpinEJA(4)
+            sage: J.one().operator().is_self_adjoint()
+            True
+
+        """
+        return self.matrix().is_symmetric()
+
+
+    def is_zero(self):
+        r"""
+        Return whether or not this map is the zero operator.
+
+        SETUP::
+
+            sage: from mjo.eja.eja_operator import FiniteDimensionalEuclideanJordanAlgebraOperator
+            sage: from mjo.eja.eja_algebra import (random_eja,
+            ....:                                  JordanSpinEJA,
+            ....:                                  RealSymmetricEJA)
+
+        EXAMPLES::
+
+            sage: J1 = JordanSpinEJA(2)
+            sage: J2 = RealSymmetricEJA(2)
+            sage: R = J1.base_ring()
+            sage: M = matrix(R, [ [0, 0],
+            ....:                 [0, 0],
+            ....:                 [0, 0] ])
+            sage: L = FiniteDimensionalEuclideanJordanAlgebraOperator(J1,J2,M)
+            sage: L.is_zero()
+            True
+            sage: M = matrix(R, [ [0, 0],
+            ....:                 [0, 1],
+            ....:                 [0, 0] ])
+            sage: L = FiniteDimensionalEuclideanJordanAlgebraOperator(J1,J2,M)
+            sage: L.is_zero()
+            False
+
+        TESTS:
+
+        The left-multiplication-by-zero operation on a given algebra
+        is its zero map::
+
+            sage: set_random_seed()
+            sage: J = random_eja()
+            sage: J.zero().operator().is_zero()
+            True
+
+        """
+        return self.matrix().is_zero()
+
+
     def inverse(self):
         """
         Return the inverse of this operator, if it exists.