eja: use single-underscore method names for morphisms.

[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 fcaf10032ebf10885e047a55114fe0506235531b..9414d2cf27fd2728ef205650b128ab37d1b83949 100644 (file)
--- a/mjo/eja/euclidean_jordan_algebra.py
+++ b/mjo/eja/euclidean_jordan_algebra.py
@@ -5,7 +5,7 @@ are used in optimization, and have some additional nice methods beyond
 what can be supported in a general Jordan Algebra.
 """
 
 what can be supported in a general Jordan Algebra.
 """
 

-from sage.categories.magmatic_algebras import MagmaticAlgebras
+from sage.categories.finite_dimensional_algebras_with_basis import FiniteDimensionalAlgebrasWithBasis

 from sage.structure.element import is_Matrix
 from sage.structure.category_object import normalize_names
 
 from sage.structure.element import is_Matrix
 from sage.structure.category_object import normalize_names
 


@@ -16,8 +16,10 @@ from sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra_morphi
 
 class FiniteDimensionalEuclideanJordanAlgebraMorphism(FiniteDimensionalAlgebraMorphism):
     """
 
 class FiniteDimensionalEuclideanJordanAlgebraMorphism(FiniteDimensionalAlgebraMorphism):
     """

-    A very thin wrapper around FiniteDimensionalAlgebraMorphism that
-    does only two things:
+    A linear map between two finite-dimensional EJAs.
+
+    This is a very thin wrapper around FiniteDimensionalAlgebraMorphism
+    that does only a few things:

 
       1. Avoids the ``unitary`` and ``check`` arguments to the constructor
          that will always be ``False``. This is necessary because these
 
       1. Avoids the ``unitary`` and ``check`` arguments to the constructor
          that will always be ``False``. This is necessary because these


@@ -28,11 +30,54 @@ class FiniteDimensionalEuclideanJordanAlgebraMorphism(FiniteDimensionalAlgebraMo
       2. Inputs and outputs the underlying matrix with respect to COLUMN
          vectors, unlike the parent class.
 
       2. Inputs and outputs the underlying matrix with respect to COLUMN
          vectors, unlike the parent class.
 

+      3. Allows us to add, subtract, negate, multiply (compose), and
+         invert morphisms in the obvious way.
+

     If this seems a bit heavyweight, it is. I would have been happy to
     use a the ring morphism that underlies the finite-dimensional
     algebra morphism, but they don't seem to be callable on elements of
     If this seems a bit heavyweight, it is. I would have been happy to
     use a the ring morphism that underlies the finite-dimensional
     algebra morphism, but they don't seem to be callable on elements of

-    our EJA.
+    our EJA, and you can't add/multiply/etc. them.

     """
     """

+
+    def _add_(self, other):
+        """
+        Add two EJA morphisms in the obvious way.
+
+        EXAMPLES::
+
+            sage: J = RealSymmetricEJA(3)
+            sage: x = J.zero()
+            sage: y = J.one()
+            sage: x.operator() + y.operator()
+            Morphism from Euclidean Jordan algebra of degree 6 over Rational
+            Field to Euclidean Jordan algebra of degree 6 over Rational Field
+            given by matrix
+            [1 0 0 0 0 0]
+            [0 1 0 0 0 0]
+            [0 0 1 0 0 0]
+            [0 0 0 1 0 0]
+            [0 0 0 0 1 0]
+            [0 0 0 0 0 1]
+
+        TESTS::
+
+            sage: set_random_seed()
+            sage: J = random_eja()
+            sage: x = J.random_element()
+            sage: y = J.random_element()
+            sage: (x.operator() + y.operator()) in J.Hom(J)
+            True
+
+        """
+        P = self.parent()
+        if not other in P:
+            raise ValueError("summands must live in the same space")
+
+        return FiniteDimensionalEuclideanJordanAlgebraMorphism(
+                  P,
+                  self.matrix() + other.matrix() )
+
+

     def __init__(self, parent, f):
         FiniteDimensionalAlgebraMorphism.__init__(self,
                                                   parent,
     def __init__(self, parent, f):
         FiniteDimensionalAlgebraMorphism.__init__(self,
                                                   parent,


@@ -41,6 +86,112 @@ class FiniteDimensionalEuclideanJordanAlgebraMorphism(FiniteDimensionalAlgebraMo
                                                   check=False)
 
 
                                                   check=False)
 
 

+    def _invert_(self):
+        """
+        EXAMPLES::
+
+            sage: J = RealSymmetricEJA(2)
+            sage: x = J.linear_combination(zip(range(len(J.gens())), J.gens()))
+            sage: x.is_invertible()
+            True
+            sage: ~x.operator()
+            Morphism from Euclidean Jordan algebra of degree 3 over Rational
+            Field to Euclidean Jordan algebra of degree 3 over Rational Field
+            given by matrix
+            [-3/2    2 -1/2]
+            [   1    0    0]
+            [-1/2    0  1/2]
+            sage: x.operator_matrix().inverse()
+            [-3/2    2 -1/2]
+            [   1    0    0]
+            [-1/2    0  1/2]
+
+        TESTS::
+
+            sage: set_random_seed()
+            sage: J = random_eja()
+            sage: x = J.random_element()
+            sage: not x.is_invertible() or (
+            ....:   (~x.operator()).matrix() == x.operator_matrix().inverse() )
+            True
+
+        """
+        A = self.matrix()
+        if not A.is_invertible():
+            raise ValueError("morphism is not invertible")
+
+        P = self.parent()
+        return FiniteDimensionalEuclideanJordanAlgebraMorphism(self.parent(),
+                                                                A.inverse())
+
+    def _lmul_(self, other):
+        """
+        Compose two EJA morphisms using multiplicative notation.
+
+        EXAMPLES::
+
+            sage: J = RealSymmetricEJA(3)
+            sage: x = J.zero()
+            sage: y = J.one()
+            sage: x.operator() * y.operator()
+            Morphism from Euclidean Jordan algebra of degree 6 over Rational
+            Field to Euclidean Jordan algebra of degree 6 over Rational Field
+            given by matrix
+            [0 0 0 0 0 0]
+            [0 0 0 0 0 0]
+            [0 0 0 0 0 0]
+            [0 0 0 0 0 0]
+            [0 0 0 0 0 0]
+            [0 0 0 0 0 0]
+
+        TESTS::
+
+            sage: set_random_seed()
+            sage: J = random_eja()
+            sage: x = J.random_element()
+            sage: y = J.random_element()
+            sage: (x.operator() * y.operator()) in J.Hom(J)
+            True
+
+        """
+        if not other.codomain() is self.domain():
+            raise ValueError("(co)domains must agree for composition")
+
+        return FiniteDimensionalEuclideanJordanAlgebraMorphism(
+                  self.parent(),
+                  self.matrix()*other.matrix() )
+
+
+    def _neg_(self):
+        """
+        Negate this morphism.
+
+        EXAMPLES::
+
+            sage: J = RealSymmetricEJA(2)
+            sage: x = J.one()
+            sage: -x.operator()
+            Morphism from Euclidean Jordan algebra of degree 3 over Rational
+            Field to Euclidean Jordan algebra of degree 3 over Rational Field
+            given by matrix
+            [-1  0  0]
+            [ 0 -1  0]
+            [ 0  0 -1]
+
+        TESTS::
+
+            sage: set_random_seed()
+            sage: J = random_eja()
+            sage: x = J.random_element()
+            sage: -x.operator() in J.Hom(J)
+            True
+
+        """
+        return FiniteDimensionalEuclideanJordanAlgebraMorphism(
+                  self.parent(),
+                  -self.matrix() )
+
+

     def _repr_(self):
         """
         We override only the representation that is shown to the user,
     def _repr_(self):
         """
         We override only the representation that is shown to the user,


@@ -75,6 +226,36 @@ class FiniteDimensionalEuclideanJordanAlgebraMorphism(FiniteDimensionalAlgebraMo
         return "Morphism from {} to {} given by matrix\n{}".format(
             self.domain(), self.codomain(), self.matrix())
 
         return "Morphism from {} to {} given by matrix\n{}".format(
             self.domain(), self.codomain(), self.matrix())
 

+
+    def __sub__(self, other):
+        """
+        Subtract one morphism from another using addition and negation.
+
+        EXAMPLES::
+
+            sage: J = RealSymmetricEJA(2)
+            sage: L1 = J.one().operator()
+            sage: L1 - L1
+            Morphism from Euclidean Jordan algebra of degree 3 over Rational
+            Field to Euclidean Jordan algebra of degree 3 over Rational
+            Field given by matrix
+            [0 0 0]
+            [0 0 0]
+            [0 0 0]
+
+        TESTS::
+
+            sage: set_random_seed()
+            sage: J = random_eja()
+            sage: x = J.random_element()
+            sage: y = J.random_element()
+            sage: x.operator() - y.operator() in J.Hom(J)
+            True
+
+        """
+        return self + (-other)
+
+

     def matrix(self):
         """
         Return the matrix of this morphism with respect to a left-action
     def matrix(self):
         """
         Return the matrix of this morphism with respect to a left-action


@@ -101,7 +282,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
                 raise ValueError("input is not a multiplication table")
         mult_table = tuple(mult_table)
 
                 raise ValueError("input is not a multiplication table")
         mult_table = tuple(mult_table)
 

-        cat = MagmaticAlgebras(field).FiniteDimensional().WithBasis()
+        cat = FiniteDimensionalAlgebrasWithBasis(field)

         cat.or_subcategory(category)
         if assume_associative:
             cat = cat.Associative()
         cat.or_subcategory(category)
         if assume_associative:
             cat = cat.Associative()


@@ -1074,6 +1255,30 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
             return W.linear_combination(zip(self.vector(), B))
 
 
             return W.linear_combination(zip(self.vector(), B))
 
 

+        def operator(self):
+            """
+            Return the left-multiplication-by-this-element
+            operator on the ambient algebra.
+
+            TESTS::
+
+                sage: set_random_seed()
+                sage: J = random_eja()
+                sage: x = J.random_element()
+                sage: y = J.random_element()
+                sage: x.operator()(y) == x*y
+                True
+                sage: y.operator()(x) == x*y
+                True
+
+            """
+            P = self.parent()
+            return FiniteDimensionalEuclideanJordanAlgebraMorphism(
+                     Hom(P,P),
+                     self.operator_matrix() )
+
+
+

         def operator_matrix(self):
             """
             Return the matrix that represents left- (or right-)
         def operator_matrix(self):
             """
             Return the matrix that represents left- (or right-)


@@ -1163,7 +1368,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
                 sage: D = (x0^2 - x_bar.inner_product(x_bar))*D
                 sage: D = D + 2*x_bar.tensor_product(x_bar)
                 sage: Q = block_matrix(2,2,[A,B,C,D])
                 sage: D = (x0^2 - x_bar.inner_product(x_bar))*D
                 sage: D = D + 2*x_bar.tensor_product(x_bar)
                 sage: Q = block_matrix(2,2,[A,B,C,D])

-                sage: Q == x.quadratic_representation()
+                sage: Q == x.quadratic_representation().operator_matrix()

                 True
 
             Test all of the properties from Theorem 11.2 in Alizadeh::
                 True
 
             Test all of the properties from Theorem 11.2 in Alizadeh::


@@ -1172,8 +1377,8 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
                 sage: J = random_eja()
                 sage: x = J.random_element()
                 sage: y = J.random_element()
                 sage: J = random_eja()
                 sage: x = J.random_element()
                 sage: y = J.random_element()

-                sage: Lx = x.operator_matrix()
-                sage: Lxx = (x*x).operator_matrix()
+                sage: Lx = x.operator()
+                sage: Lxx = (x*x).operator()

                 sage: Qx = x.quadratic_representation()
                 sage: Qy = y.quadratic_representation()
                 sage: Qxy = x.quadratic_representation(y)
                 sage: Qx = x.quadratic_representation()
                 sage: Qy = y.quadratic_representation()
                 sage: Qxy = x.quadratic_representation(y)


@@ -1194,17 +1399,16 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
 
             Property 3:
 
 
             Property 3:
 

-                sage: not x.is_invertible() or (
-                ....:     Qx*x.inverse().vector() == x.vector() )
+                sage: not x.is_invertible() or ( Qx(x.inverse()) == x )

                 True
 
                 sage: not x.is_invertible() or (
                 True
 
                 sage: not x.is_invertible() or (

-                ....:   Qx.inverse()
+                ....:   ~Qx

                 ....:   ==
                 ....:   x.inverse().quadratic_representation() )
                 True
 
                 ....:   ==
                 ....:   x.inverse().quadratic_representation() )
                 True
 

-                sage: Qxy*(J.one().vector()) == (x*y).vector()
+                sage: Qxy(J.one()) == x*y

                 True
 
             Property 4:
                 True
 
             Property 4:


@@ -1217,15 +1421,15 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
                 sage: not x.is_invertible() or (
                 ....:   x.quadratic_representation(x.inverse())*Qx
                 ....:   ==
                 sage: not x.is_invertible() or (
                 ....:   x.quadratic_representation(x.inverse())*Qx
                 ....:   ==

-                ....:   2*x.operator_matrix()*Qex - Qx )
+                ....:   2*x.operator()*Qex - Qx )

                 True
 
                 True
 

-                sage: 2*x.operator_matrix()*Qex - Qx == Lxx
+                sage: 2*x.operator()*Qex - Qx == Lxx

                 True
 
             Property 5:
 
                 True
 
             Property 5:
 

-                sage: J(Qy*x.vector()).quadratic_representation() == Qy*Qx*Qy
+                sage: Qy(x).quadratic_representation() == Qy*Qx*Qy

                 True
 
             Property 6:
                 True
 
             Property 6:


@@ -1236,13 +1440,13 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
             Property 7:
 
                 sage: not x.is_invertible() or (
             Property 7:
 
                 sage: not x.is_invertible() or (

-                ....:   Qx*x.inverse().operator_matrix() == Lx )
+                ....:   Qx*x.inverse().operator() == Lx )

                 True
 
             Property 8:
 
                 sage: not x.operator_commutes_with(y) or (
                 True
 
             Property 8:
 
                 sage: not x.operator_commutes_with(y) or (

-                ....:   J(Qx*y.vector())^n == J(Qxn*(y^n).vector()) )
+                ....:   Qx(y)^n == Qxn(y^n) )

                 True
 
             """
                 True
 
             """


@@ -1251,9 +1455,9 @@ class FiniteDimensionalEuclideanJordanAlgebra(FiniteDimensionalAlgebra):
             elif not other in self.parent():
                 raise TypeError("'other' must live in the same algebra")
 
             elif not other in self.parent():
                 raise TypeError("'other' must live in the same algebra")
 

-            L = self.operator_matrix()
-            M = other.operator_matrix()
-            return ( L*M + M*L - (self*other).operator_matrix() )
+            L = self.operator()
+            M = other.operator()
+            return ( L*M + M*L - (self*other).operator() )

 
 
         def span_of_powers(self):
 
 
         def span_of_powers(self):