]> gitweb.michael.orlitzky.com - sage.d.git/blobdiff - mjo/eja/eja_subalgebra.py
eja: choose subalgebra generator prefix smarter.
[sage.d.git] / mjo / eja / eja_subalgebra.py
index 7971e15a095a9a5e4a246bc89fbdf90cb5e97d94..c43e53f2b030ed920e6cc22d10c3097c4b704cec 100644 (file)
@@ -24,39 +24,6 @@ class FiniteDimensionalEuclideanJordanElementSubalgebraElement(FiniteDimensional
         True
 
     """
-    def __init__(self, A, elt):
-        """
-        SETUP::
-
-            sage: from mjo.eja.eja_algebra import RealSymmetricEJA
-            sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanElementSubalgebra
-
-        EXAMPLES::
-
-            sage: J = RealSymmetricEJA(3)
-            sage: x = sum( i*J.gens()[i] for i in range(6) )
-            sage: K = FiniteDimensionalEuclideanJordanElementSubalgebra(x)
-            sage: [ K.element_class(K,x^k) for k in range(J.rank()) ]
-            [f0, f1, f2]
-
-        ::
-
-        """
-        if elt in A.superalgebra():
-            # Try to convert a parent algebra element into a
-            # subalgebra element...
-            try:
-                coords = A.vector_space().coordinate_vector(elt.to_vector())
-                elt = A.from_vector(coords).monomial_coefficients()
-            except AttributeError:
-                # Catches a missing method in elt.to_vector()
-                pass
-
-        s = super(FiniteDimensionalEuclideanJordanElementSubalgebraElement,
-                  self)
-
-        s.__init__(A, elt)
-
 
     def superalgebra_element(self):
         """
@@ -75,9 +42,9 @@ class FiniteDimensionalEuclideanJordanElementSubalgebraElement(FiniteDimensional
             sage: x
             e0 + e1 + e2 + e3 + e4 + e5
             sage: A = x.subalgebra_generated_by()
-            sage: A.element_class(A,x)
+            sage: A(x)
             f1
-            sage: A.element_class(A,x).superalgebra_element()
+            sage: A(x).superalgebra_element()
             e0 + e1 + e2 + e3 + e4 + e5
 
         TESTS:
@@ -88,10 +55,10 @@ class FiniteDimensionalEuclideanJordanElementSubalgebraElement(FiniteDimensional
             sage: J = random_eja()
             sage: x = J.random_element()
             sage: A = x.subalgebra_generated_by()
-            sage: A.element_class(A,x).superalgebra_element() == x
+            sage: A(x).superalgebra_element() == x
             True
             sage: y = A.random_element()
-            sage: A.element_class(A,y.superalgebra_element()) == y
+            sage: A(y.superalgebra_element()) == y
             True
 
         """
@@ -104,6 +71,25 @@ class FiniteDimensionalEuclideanJordanElementSubalgebraElement(FiniteDimensional
 class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclideanJordanAlgebra):
     """
     The subalgebra of an EJA generated by a single element.
+
+    SETUP::
+
+        sage: from mjo.eja.eja_algebra import JordanSpinEJA
+
+    TESTS:
+
+    Ensure that our generator names don't conflict with the superalgebra::
+
+        sage: J = JordanSpinEJA(3)
+        sage: J.one().subalgebra_generated_by().gens()
+        (f0,)
+        sage: J = JordanSpinEJA(3, prefix='f')
+        sage: J.one().subalgebra_generated_by().gens()
+        (g0,)
+        sage: J = JordanSpinEJA(3, prefix='b')
+        sage: J.one().subalgebra_generated_by().gens()
+        (c0,)
+
     """
     def __init__(self, elt):
         superalgebra = elt.parent()
@@ -132,31 +118,24 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
         # matrix for the successive basis elements b0, b1,... of
         # that subspace.
         field = superalgebra.base_ring()
-        mult_table = []
-        for b_right in superalgebra_basis:
-                b_right_rows = []
-                # The first row of the right-multiplication matrix by
-                # b1 is what we get if we apply that matrix to b1. The
-                # second row of the right multiplication matrix by b1
-                # is what we get when we apply that matrix to b2...
-                #
-                # IMPORTANT: this assumes that all vectors are COLUMN
-                # vectors, unlike our superclass (which uses row vectors).
-                for b_left in superalgebra_basis:
-                    # Multiply in the original EJA, but then get the
-                    # coordinates from the subalgebra in terms of its
-                    # basis.
-                    this_row = W.coordinates((b_left*b_right).to_vector())
-                    b_right_rows.append(this_row)
-                b_right_matrix = matrix(field, b_right_rows)
-                mult_table.append(b_right_matrix)
-
-        for m in mult_table:
-            m.set_immutable()
-        mult_table = tuple(mult_table)
-
-        # TODO: We'll have to redo this and make it unique again...
-        prefix = 'f'
+        n = len(superalgebra_basis)
+        mult_table = [[W.zero() for i in range(n)] for j in range(n)]
+        for i in range(n):
+            for j in range(n):
+                product = superalgebra_basis[i]*superalgebra_basis[j]
+                mult_table[i][j] = W.coordinate_vector(product.to_vector())
+
+        # A half-assed attempt to ensure that we don't collide with
+        # the superalgebra's prefix (ignoring the fact that there
+        # could be super-superelgrbas in scope). If possible, we
+        # try to "increment" the parent algebra's prefix, although
+        # this idea goes out the window fast because some prefixen
+        # are off-limits.
+        prefixen = [ 'f', 'g', 'h', 'a', 'b', 'c', 'd' ]
+        try:
+            prefix = prefixen[prefixen.index(superalgebra.prefix()) + 1]
+        except ValueError:
+            prefix = prefixen[0]
 
         # The rank is the highest possible degree of a minimal
         # polynomial, and is bounded above by the dimension. We know
@@ -184,6 +163,94 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
                               natural_basis=natural_basis)
 
 
+    def _element_constructor_(self, elt):
+        """
+        Construct an element of this subalgebra from the given one.
+        The only valid arguments are elements of the parent algebra
+        that happen to live in this subalgebra.
+
+        SETUP::
+
+            sage: from mjo.eja.eja_algebra import RealSymmetricEJA
+            sage: from mjo.eja.eja_subalgebra import FiniteDimensionalEuclideanJordanElementSubalgebra
+
+        EXAMPLES::
+
+            sage: J = RealSymmetricEJA(3)
+            sage: x = sum( i*J.gens()[i] for i in range(6) )
+            sage: K = FiniteDimensionalEuclideanJordanElementSubalgebra(x)
+            sage: [ K(x^k) for k in range(J.rank()) ]
+            [f0, f1, f2]
+
+        ::
+
+        """
+        if elt == 0:
+            # Just as in the superalgebra class, we need to hack
+            # this special case to ensure that random_element() can
+            # coerce a ring zero into the algebra.
+            return self.zero()
+
+        if elt in self.superalgebra():
+            coords = self.vector_space().coordinate_vector(elt.to_vector())
+            return self.from_vector(coords)
+
+
+    def one_basis(self):
+        """
+        Return the basis-element-index of this algebra's unit element.
+        """
+        return 0
+
+
+    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 algebra identity should be our
+        first basis element. We implement this via :meth:`one_basis`
+        because that method can optionally be used by other parts of the
+        category framework.
+
+        SETUP::
+
+            sage: from mjo.eja.eja_algebra import (RealCartesianProductEJA,
+            ....:                                  random_eja)
+
+        EXAMPLES::
+
+            sage: J = RealCartesianProductEJA(5)
+            sage: J.one()
+            e0 + e1 + e2 + e3 + e4
+            sage: x = sum(J.gens())
+            sage: A = x.subalgebra_generated_by()
+            sage: A.one()
+            f0
+            sage: A.one().superalgebra_element()
+            e0 + e1 + e2 + e3 + e4
+
+        TESTS:
+
+        The identity element acts like the identity::
+
+            sage: set_random_seed()
+            sage: J = random_eja().random_element().subalgebra_generated_by()
+            sage: x = J.random_element()
+            sage: J.one()*x == x and x*J.one() == x
+            True
+
+        The matrix of the unit element's operator is the identity::
+
+            sage: set_random_seed()
+            sage: J = random_eja().random_element().subalgebra_generated_by()
+            sage: actual = J.one().operator().matrix()
+            sage: expected = matrix.identity(J.base_ring(), J.dimension())
+            sage: actual == expected
+            True
+        """
+        return self.monomial(self.one_basis())
+
 
     def superalgebra(self):
         """