X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=56d91bdef13bd76dc7e48f8f1237b02c18ef59a3;hb=52341fdeb29a68a5cb88e53b9ee42c695e24d9d9;hp=ec3dd1141a9f497acca26f6d09c830420dfb5d5d;hpb=4e966338c00181067c4d10f24b3fcaf288ebe207;p=sage.d.git

diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py
index ec3dd11..56d91bd 100644
--- a/mjo/eja/eja_algebra.py
+++ b/mjo/eja/eja_algebra.py
@@ -119,10 +119,12 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
 
         The ``field`` we're given must be real with ``check_field=True``::
 
-            sage: JordanSpinEJA(2,QQbar)
+            sage: JordanSpinEJA(2, QQbar)
             Traceback (most recent call last):
             ...
             ValueError: scalar field is not real
+            sage: JordanSpinEJA(2, QQbar, check_field=False)
+            Euclidean Jordan algebra of dimension 2 over Algebraic Field
 
         The multiplication table must be square with ``check_axioms=True``::
 
@@ -313,8 +315,12 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
         # element's ring because the basis space might be an algebraic
         # closure whereas the base ring of the 3-by-3 identity matrix
         # could be QQ instead of QQbar.
+        #
+        # We pass check=False because the matrix basis is "guaranteed"
+        # to be linearly independent... right? Ha ha.
         V = VectorSpace(self.base_ring(), elt.nrows()*elt.ncols())
-        W = V.span_of_basis( _mat2vec(s) for s in self.matrix_basis() )
+        W = V.span_of_basis( (_mat2vec(s) for s in self.matrix_basis()),
+                             check=False)
 
         try:
             coords =  W.coordinate_vector(_mat2vec(elt))
@@ -1165,6 +1171,12 @@ class RationalBasisEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebr
                  check_field=True,
                  check_axioms=True):
 
+        if check_field:
+            # Abuse the check_field parameter to check that the entries of
+            # out basis (in ambient coordinates) are in the field QQ.
+            if not all( all(b_i in QQ for b_i in b.list()) for b in basis ):
+                raise TypeError("basis not rational")
+
         n = len(basis)
         vector_basis = basis
 
@@ -1214,8 +1226,9 @@ class RationalBasisEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebr
                                           check_axioms=False)
 
             # Compute the deorthonormalized tables before we orthonormalize
-            # the given basis.
-            W = V.span_of_basis( vector_basis )
+            # the given basis. The "check" parameter here guarantees that
+            # the basis is linearly-independent.
+            W = V.span_of_basis( vector_basis, check=check_axioms)
 
             # Note: the Jordan and inner-products are defined in terms
             # of the ambient basis. It's important that their arguments
@@ -1251,22 +1264,20 @@ class RationalBasisEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebr
             else:
                 vector_basis = gram_schmidt(vector_basis, inner_product)
 
-            W = V.span_of_basis( vector_basis )
-
             # Normalize the "matrix" basis, too!
             basis = vector_basis
 
             if basis_is_matrices:
                 basis = tuple( map(_vec2mat,basis) )
 
-        W = V.span_of_basis( vector_basis )
+        W = V.span_of_basis( vector_basis, check=check_axioms)
 
         # Now "W" is the vector space of our algebra coordinates. The
         # variables "X1", "X2",...  refer to the entries of vectors in
         # W. Thus to convert back and forth between the orthonormal
         # coordinates and the given ones, we need to stick the original
         # basis in W.
-        U = V.span_of_basis( deortho_vector_basis )
+        U = V.span_of_basis( deortho_vector_basis, check=check_axioms)
         self._deortho_matrix = matrix( U.coordinate_vector(q)
                                        for q in vector_basis )
 
@@ -1349,9 +1360,11 @@ class RationalBasisEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebr
             Algebraic Real Field
 
         """
-        if self.base_ring() is QQ:
+        if self.base_ring() is QQ or self._rational_algebra is None:
             # There's no need to construct *another* algebra over the
-            # rationals if this one is already over the rationals.
+            # rationals if this one is already over the
+            # rationals. Likewise, if we never orthonormalized our
+            # basis, we might as well just use the given one.
             superclass = super(RationalBasisEuclideanJordanAlgebra, self)
             return superclass._charpoly_coefficients()
 
@@ -2267,10 +2280,16 @@ class HadamardEJA(ConcreteEuclideanJordanAlgebra):
         def inner_product(x,y):
             return x.inner_product(y)
 
+        # Don't orthonormalize because our basis is already
+        # orthonormal with respect to our inner-product. But also
+        # don't pass check_field=False here, because the user can pass
+        # in a field!
         super(HadamardEJA, self).__init__(field,
                                           basis,
                                           jordan_product,
                                           inner_product,
+                                          orthonormalize=False,
+                                          check_axioms=False,
                                           **kwargs)
         self.rank.set_cache(n)
 
@@ -2494,10 +2513,19 @@ class JordanSpinEJA(BilinearFormEJA):
 
     """
     def __init__(self, n, field=AA, **kwargs):
-        # This is a special case of the BilinearFormEJA with the identity
-        # matrix as its bilinear form.
+        # This is a special case of the BilinearFormEJA with the
+        # identity matrix as its bilinear form.
         B = matrix.identity(field, n)
-        super(JordanSpinEJA, self).__init__(B, field, **kwargs)
+
+        # Don't orthonormalize because our basis is already
+        # orthonormal with respect to our inner-product. But
+        # also don't pass check_field=False here, because the
+        # user can pass in a field!
+        super(JordanSpinEJA, self).__init__(B,
+                                            field,
+                                            orthonormalize=False,
+                                            check_axioms=False,
+                                            **kwargs)
 
     @staticmethod
     def _max_random_instance_size():