eja: eliminate the special element subalgebra class.

diff --git a/mjo/eja/TODO b/mjo/eja/TODO
index 0e969cdfe4a2062c6a531b3fa84520c49e88de8f..25ef99df92da5f41595c609cdea9ae5d245cd1fe 100644 (file)
--- a/mjo/eja/TODO
+++ b/mjo/eja/TODO
@@ -20,7 +20,4 @@ sage: a0 = (1/4)*X[4]**2*X[6]**2 - (1/2)*X[2]*X[5]*X[6]**2 - (1/2)*X[3]*X[4]*X[6
 
 6. Profile the construction of "large" matrix algebras (like the
    15-dimensional QuaternionHermitianAlgebra(3)) to find out why
-   they're so slow.
-
-7. Drop the element-subalgebra in favor of a regular subalgebra. The
-   cached "one" can be set in the method.
+   they're so slow.
\ No newline at end of file

diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py
index 3bc296446da3021ea8913996fa9932580e022934..83ec50e5a215417811fe09d72c61251081772160 100644 (file)
--- a/mjo/eja/eja_algebra.py
+++ b/mjo/eja/eja_algebra.py
@@ -750,23 +750,57 @@ class FiniteDimensionalEJA(CombinatorialFreeModule):
             sage: from mjo.eja.eja_algebra import (HadamardEJA,
             ....:                                  random_eja)
 
-        EXAMPLES::
+        EXAMPLES:
+
+        We can compute unit element in the Hadamard EJA::
+
+            sage: J = HadamardEJA(5)
+            sage: J.one()
+            e0 + e1 + e2 + e3 + e4
+
+        The unit element in the Hadamard EJA is inherited in the
+        subalgebras generated by its elements::
 
             sage: J = HadamardEJA(5)
             sage: J.one()
             e0 + e1 + e2 + e3 + e4
+            sage: x = sum(J.gens())
+            sage: A = x.subalgebra_generated_by(orthonormalize=False)
+            sage: A.one()
+            f0
+            sage: A.one().superalgebra_element()
+            e0 + e1 + e2 + e3 + e4
 
         TESTS:
 
-        The identity element acts like the identity::
+        The identity element acts like the identity, regardless of
+        whether or not we orthonormalize::
 
             sage: set_random_seed()
             sage: J = random_eja()
             sage: x = J.random_element()
             sage: J.one()*x == x and x*J.one() == x
             True
+            sage: A = x.subalgebra_generated_by()
+            sage: y = A.random_element()
+            sage: A.one()*y == y and y*A.one() == y
+            True
+
+        ::
+
+            sage: set_random_seed()
+            sage: J = random_eja(field=QQ, orthonormalize=False)
+            sage: x = J.random_element()
+            sage: J.one()*x == x and x*J.one() == x
+            True
+            sage: A = x.subalgebra_generated_by(orthonormalize=False)
+            sage: y = A.random_element()
+            sage: A.one()*y == y and y*A.one() == y
+            True
 
-        The matrix of the unit element's operator is the identity::
+        The matrix of the unit element's operator is the identity,
+        regardless of the base field and whether or not we
+        orthonormalize::
 
             sage: set_random_seed()
             sage: J = random_eja()
@@ -774,6 +808,27 @@ class FiniteDimensionalEJA(CombinatorialFreeModule):
             sage: expected = matrix.identity(J.base_ring(), J.dimension())
             sage: actual == expected
             True
+            sage: x = J.random_element()
+            sage: A = x.subalgebra_generated_by()
+            sage: actual = A.one().operator().matrix()
+            sage: expected = matrix.identity(A.base_ring(), A.dimension())
+            sage: actual == expected
+            True
+
+        ::
+
+            sage: set_random_seed()
+            sage: J = random_eja(field=QQ, orthonormalize=False)
+            sage: actual = J.one().operator().matrix()
+            sage: expected = matrix.identity(J.base_ring(), J.dimension())
+            sage: actual == expected
+            True
+            sage: x = J.random_element()
+            sage: A = x.subalgebra_generated_by(orthonormalize=False)
+            sage: actual = A.one().operator().matrix()
+            sage: expected = matrix.identity(A.base_ring(), A.dimension())
+            sage: actual == expected
+            True
 
         Ensure that the cached unit element (often precomputed by
         hand) agrees with the computed one::
@@ -785,6 +840,15 @@ class FiniteDimensionalEJA(CombinatorialFreeModule):
             sage: J.one() == cached
             True
 
+        ::
+
+            sage: set_random_seed()
+            sage: J = random_eja(field=QQ, orthonormalize=False)
+            sage: cached = J.one()
+            sage: J.one.clear_cache()
+            sage: J.one() == cached
+            True
+
         """
         # We can brute-force compute the matrices of the operators
         # that correspond to the basis elements of this algebra.

diff --git a/mjo/eja/eja_element.py b/mjo/eja/eja_element.py
index d3e9a33ceba6e1fc4e58b417f3b953e2e2d1c3d7..e30dbb13f39d06b6d49c6bfd34c829ab30d6112d 100644 (file)
--- a/mjo/eja/eja_element.py
+++ b/mjo/eja/eja_element.py
@@ -1411,8 +1411,14 @@ class FiniteDimensionalEJAElement(IndexedFreeModuleElement):
             True
 
         """
-        from mjo.eja.eja_element_subalgebra import FiniteDimensionalEJAElementSubalgebra
-        return FiniteDimensionalEJAElementSubalgebra(self, **kwargs)
+        from mjo.eja.eja_subalgebra import FiniteDimensionalEJASubalgebra
+        powers = tuple( self**k for k in range(self.degree()) )
+        A = FiniteDimensionalEJASubalgebra(self.parent(),
+                                           powers,
+                                           associative=True,
+                                           **kwargs)
+        A.one.set_cache(A(self.parent().one()))
+        return A
 
 
     def subalgebra_idempotent(self):

diff --git a/mjo/eja/eja_element_subalgebra.py b/mjo/eja/eja_element_subalgebra.py
deleted file mode 100644 (file)
index 34a63af..0000000
--- a/mjo/eja/eja_element_subalgebra.py
+++ /dev/null
@@ -1,109 +0,0 @@
-from sage.matrix.constructor import matrix
-from sage.misc.cachefunc import cached_method
-from sage.rings.all import QQ
-
-from mjo.eja.eja_subalgebra import FiniteDimensionalEJASubalgebra
-
-
-class FiniteDimensionalEJAElementSubalgebra(FiniteDimensionalEJASubalgebra):
-    def __init__(self, elt, **kwargs):
-        superalgebra = elt.parent()
-
-        # TODO: going up to the superalgebra dimension here is
-        # overkill.  We should append p vectors as rows to a matrix
-        # and continually rref() it until the rank stops going
-        # up. When n=10 but the dimension of the algebra is 1, that
-        # can save a shitload of time (especially over AA).
-        powers = tuple( elt**k for k in range(elt.degree()) )
-
-        super().__init__(superalgebra,
-                         powers,
-                         associative=True,
-                         **kwargs)
-
-        # The rank is the highest possible degree of a minimal
-        # polynomial, and is bounded above by the dimension. We know
-        # in this case that there's an element whose minimal
-        # polynomial has the same degree as the space's dimension
-        # (remember how we constructed the space?), so that must be
-        # its rank too.
-        self.rank.set_cache(self.dimension())
-
-
-    @cached_method
-    def one(self):
-        """
-        Return the multiplicative identity element of this algebra.
-
-        The superclass method computes the identity element, which is
-        beyond overkill in this case: the superalgebra identity
-        restricted to this algebra is its identity. Note that we can't
-        count on the first basis element being the identity -- it might
-        have been scaled if we orthonormalized the basis.
-
-        SETUP::
-
-            sage: from mjo.eja.eja_algebra import (HadamardEJA,
-            ....:                                  random_eja)
-
-        EXAMPLES::
-
-            sage: J = HadamardEJA(5)
-            sage: J.one()
-            e0 + e1 + e2 + e3 + e4
-            sage: x = sum(J.gens())
-            sage: A = x.subalgebra_generated_by(orthonormalize=False)
-            sage: A.one()
-            f0
-            sage: A.one().superalgebra_element()
-            e0 + e1 + e2 + e3 + e4
-
-        TESTS:
-
-        The identity element acts like the identity over the rationals::
-
-            sage: set_random_seed()
-            sage: x = random_eja(field=QQ,orthonormalize=False).random_element()
-            sage: A = x.subalgebra_generated_by()
-            sage: x = A.random_element()
-            sage: A.one()*x == x and x*A.one() == x
-            True
-
-        The identity element acts like the identity over the algebraic
-        reals with an orthonormal basis::
-
-            sage: set_random_seed()
-            sage: x = random_eja().random_element()
-            sage: A = x.subalgebra_generated_by()
-            sage: x = A.random_element()
-            sage: A.one()*x == x and x*A.one() == x
-            True
-
-        The matrix of the unit element's operator is the identity over
-        the rationals::
-
-            sage: set_random_seed()
-            sage: x = random_eja(field=QQ,orthonormalize=False).random_element()
-            sage: A = x.subalgebra_generated_by(orthonormalize=False)
-            sage: actual = A.one().operator().matrix()
-            sage: expected = matrix.identity(A.base_ring(), A.dimension())
-            sage: actual == expected
-            True
-
-        The matrix of the unit element's operator is the identity over
-        the algebraic reals with an orthonormal basis::
-
-            sage: set_random_seed()
-            sage: x = random_eja().random_element()
-            sage: A = x.subalgebra_generated_by()
-            sage: actual = A.one().operator().matrix()
-            sage: expected = matrix.identity(A.base_ring(), A.dimension())
-            sage: actual == expected
-            True
-
-        """
-        if self.dimension() == 0:
-            return self.zero()
-
-        return self(self.superalgebra().one())
-