X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_subalgebra.py;h=0f641416366ef7ee72d4703e070c69e2d60e30a9;hb=08aba469c5f8d8947a543f8882fa676ed165e7ee;hp=9326793f9dfd1a1619241c3dcd2e5bb8dcda1351;hpb=a46ed57c4d013b9b2509639849a6ba62d7713f8f;p=sage.d.git

diff --git a/mjo/eja/eja_subalgebra.py b/mjo/eja/eja_subalgebra.py
index 9326793..0f64141 100644
--- a/mjo/eja/eja_subalgebra.py
+++ b/mjo/eja/eja_subalgebra.py
@@ -23,6 +23,17 @@ class FiniteDimensionalEuclideanJordanElementSubalgebraElement(FiniteDimensional
         sage: actual == expected
         True
 
+    The left-multiplication-by operator for elements in the subalgebra
+    works like it does in the superalgebra, even if we orthonormalize
+    our basis::
+
+        sage: set_random_seed()
+        sage: x = random_eja(AA).random_element()
+        sage: A = x.subalgebra_generated_by(orthonormalize_basis=True)
+        sage: y = A.random_element()
+        sage: y.operator()(A.one()) == y
+        True
+
     """
 
     def superalgebra_element(self):
@@ -117,24 +128,6 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
         except ValueError:
             prefix = prefixen[0]
 
-        if elt.is_zero():
-            # Short circuit because 0^0 == 1 is going to make us
-            # think we have a one-dimensional algebra otherwise.
-            natural_basis = tuple()
-            mult_table = tuple()
-            rank = 0
-            self._vector_space = V.zero_subspace()
-            self._superalgebra_basis = []
-            fdeja = super(FiniteDimensionalEuclideanJordanElementSubalgebra,
-                          self)
-            return fdeja.__init__(field,
-                                  mult_table,
-                                  rank,
-                                  prefix=prefix,
-                                  category=category,
-                                  natural_basis=natural_basis)
-
-
         # This list is guaranteed to contain all independent powers,
         # because it's the maximal set of powers that could possibly
         # be independent (by a dimension argument).
@@ -259,22 +252,16 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
             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.
+        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 migth
+        have been scaled if we orthonormalized the basis.
 
         SETUP::
 
@@ -295,27 +282,54 @@ class FiniteDimensionalEuclideanJordanElementSubalgebra(FiniteDimensionalEuclide
 
         TESTS:
 
-        The identity element acts like the identity::
+        The identity element acts like the identity over the rationals::
 
             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
+            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::
+        The identity element acts like the identity over the algebraic
+        reals with an orthonormal basis::
 
             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: x = random_eja(AA).random_element()
+            sage: A = x.subalgebra_generated_by(orthonormalize_basis=True)
+            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().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
+
+        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(AA).random_element()
+            sage: A = x.subalgebra_generated_by(orthonormalize_basis=True)
+            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()
         else:
-            return self.monomial(self.one_basis())
+            sa_one = self.superalgebra().one().to_vector()
+            sa_coords = self.vector_space().coordinate_vector(sa_one)
+            return self.from_vector(sa_coords)
 
 
     def natural_basis_space(self):