mjo/**/*.py: drop obsolete set_random_seed().

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

diff --git a/mjo/eja/eja_subalgebra.py b/mjo/eja/eja_subalgebra.py
index 1b86d236c390691939fd84cabb597e6b6159d406..1286a167f4c5ede4fa45252a545fd848f3014ab9 100644 (file)
--- a/mjo/eja/eja_subalgebra.py
+++ b/mjo/eja/eja_subalgebra.py
@@ -1,4 +1,5 @@
 from sage.matrix.constructor import matrix
+from sage.misc.cachefunc import cached_method
 
 from mjo.eja.eja_algebra import FiniteDimensionalEJA
 from mjo.eja.eja_element import FiniteDimensionalEJAElement
@@ -14,7 +15,6 @@ class FiniteDimensionalEJASubalgebraElement(FiniteDimensionalEJAElement):
     The matrix representation of an element in the subalgebra is
     the same as its matrix representation in the superalgebra::
 
-        sage: set_random_seed()
         sage: x = random_eja(field=QQ,orthonormalize=False).random_element()
         sage: A = x.subalgebra_generated_by(orthonormalize=False)
         sage: y = A.random_element()
@@ -27,7 +27,6 @@ class FiniteDimensionalEJASubalgebraElement(FiniteDimensionalEJAElement):
     works like it does in the superalgebra, even if we orthonormalize
     our basis::
 
-        sage: set_random_seed()
         sage: x = random_eja(field=AA).random_element()
         sage: A = x.subalgebra_generated_by(orthonormalize=True)
         sage: y = A.random_element()
@@ -70,7 +69,6 @@ class FiniteDimensionalEJASubalgebraElement(FiniteDimensionalEJAElement):
 
         We can convert back and forth faithfully::
 
-            sage: set_random_seed()
             sage: J = random_eja(field=QQ, orthonormalize=False)
             sage: x = J.random_element()
             sage: A = x.subalgebra_generated_by(orthonormalize=False)
@@ -84,7 +82,7 @@ class FiniteDimensionalEJASubalgebraElement(FiniteDimensionalEJAElement):
             True
 
         """
-        return self.parent().superalgebra()(self.to_matrix())
+        return self.parent().superalgebra_embedding()(self)
 
 
 
@@ -171,6 +169,7 @@ class FiniteDimensionalEJASubalgebra(FiniteDimensionalEJA):
                          jordan_product,
                          inner_product,
                          field=field,
+                         matrix_space=superalgebra.matrix_space(),
                          prefix=prefix,
                          **kwargs)
 
@@ -208,24 +207,21 @@ class FiniteDimensionalEJASubalgebra(FiniteDimensionalEJA):
 
         """
         if elt in self.superalgebra():
-            return super()._element_constructor_(elt.to_matrix())
+            # If the subalgebra is trivial, its _matrix_span will be empty
+            # but we still want to be able convert the superalgebra's zero()
+            # element into the subalgebra's zero() element. There's no great
+            # workaround for this because sage checks that your basis is
+            # linearly-independent everywhere, so we can't just give it a
+            # basis consisting of the zero element.
+            m = elt.to_matrix()
+            if self.is_trivial() and m.is_zero():
+                return self.zero()
+            else:
+                return super()._element_constructor_(m)
         else:
             return super()._element_constructor_(elt)
 
 
-
-    def matrix_space(self):
-        """
-        Return the matrix space of this algebra, which is identical to
-        that of its superalgebra.
-
-        This is correct "by definition," and avoids a mismatch when
-        the subalgebra is trivial (with no matrix basis elements to
-        infer anything from) and the parent is not.
-        """
-        return self.superalgebra().matrix_space()
-
-
     def superalgebra(self):
         """
         Return the superalgebra that this algebra was generated from.
@@ -233,4 +229,39 @@ class FiniteDimensionalEJASubalgebra(FiniteDimensionalEJA):
         return self._superalgebra
 
 
+    @cached_method
+    def superalgebra_embedding(self):
+        r"""
+        Return the embedding from this subalgebra into the superalgebra.
+
+        SETUP::
+
+            sage: from mjo.eja.eja_algebra import HadamardEJA
+
+        EXAMPLES::
+
+            sage: J = HadamardEJA(4)
+            sage: A = J.one().subalgebra_generated_by()
+            sage: iota = A.superalgebra_embedding()
+            sage: iota
+            Linear operator between finite-dimensional Euclidean Jordan algebras represented by the matrix:
+            [1/2]
+            [1/2]
+            [1/2]
+            [1/2]
+            Domain: Euclidean Jordan algebra of dimension 1 over Algebraic Real Field
+            Codomain: Euclidean Jordan algebra of dimension 4 over Algebraic Real Field
+            sage: iota(A.one()) == J.one()
+            True
+
+        """
+        from mjo.eja.eja_operator import FiniteDimensionalEJAOperator
+        mm = self._module_morphism(lambda j: self.superalgebra()(self.monomial(j).to_matrix()),
+                                   codomain=self.superalgebra())
+        return FiniteDimensionalEJAOperator(self,
+                                            self.superalgebra(),
+                                            mm.matrix())
+
+
+
     Element = FiniteDimensionalEJASubalgebraElement