From b3f3ddace19a822cf7df349fee1791830265e875 Mon Sep 17 00:00:00 2001
From: Michael Orlitzky <michael@orlitzky.com>
Date: Fri, 30 Aug 2019 11:50:12 -0400
Subject: [PATCH] eja: fix one() for subalgebras with orthonormal bases.

---
 mjo/eja/eja_subalgebra.py | 70 ++++++++++++++++++++++++++++-----------
 1 file changed, 51 insertions(+), 19 deletions(-)

diff --git a/mjo/eja/eja_subalgebra.py b/mjo/eja/eja_subalgebra.py
index 9326793..2c877f3 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):
@@ -259,22 +270,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 +300,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):
-- 
2.44.2