From 52341fdeb29a68a5cb88e53b9ee42c695e24d9d9 Mon Sep 17 00:00:00 2001 From: Michael Orlitzky Date: Wed, 2 Dec 2020 21:38:54 -0500 Subject: [PATCH] eja: propagate check_axioms to some other "check" variables. --- mjo/eja/DESIGN | 17 ----------------- mjo/eja/eja_algebra.py | 33 ++++++++++++++++++++------------- mjo/eja/eja_subalgebra.py | 3 ++- 3 files changed, 22 insertions(+), 31 deletions(-) diff --git a/mjo/eja/DESIGN b/mjo/eja/DESIGN index 4e34946..248af84 100644 --- a/mjo/eja/DESIGN +++ b/mjo/eja/DESIGN @@ -31,20 +31,3 @@ need to know how to undo the process. If we run Gram-Schmidt on the basis matrix ourselves, then we can save the matrix that undoes the process. And by undoing the process, we can get to a basis where computations are fast again. - -Question: what's the best way to construct these algebras? We'll -usually know, - - * the multiplication function - * the inner-product function - * a basis in either vector or matrix format - -and want: - - * an orthonormalized copy of the basis, in long-vector format - * the reverse gram-schmidt matrix that deorthonormalizes that - long-vector basis - * a multiplication matrix (for speed) w.r.t. the orthonormal basis - * an inner-product matrix (for speed) w.r.t. the orthonormal basis - * a way to turn those two matrices into multiplication and inner- - product matrices for the deorthonormalized basis. diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index e9f971f..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)) @@ -1220,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 @@ -1257,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 ) @@ -2275,14 +2280,15 @@ 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. + # 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_field=False, check_axioms=False, **kwargs) self.rank.set_cache(n) @@ -2512,11 +2518,12 @@ class JordanSpinEJA(BilinearFormEJA): B = matrix.identity(field, n) # Don't orthonormalize because our basis is already - # orthonormal with respect to our inner-product. + # 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_field=False, check_axioms=False, **kwargs) diff --git a/mjo/eja/eja_subalgebra.py b/mjo/eja/eja_subalgebra.py index fb0f26c..8c0f909 100644 --- a/mjo/eja/eja_subalgebra.py +++ b/mjo/eja/eja_subalgebra.py @@ -173,7 +173,8 @@ class FiniteDimensionalEuclideanJordanSubalgebra(FiniteDimensionalEuclideanJorda # If our superalgebra is a subalgebra of something else, then # these vectors won't have the right coordinates for # V.span_of_basis() unless we use V.from_vector() on them. - W = V.span_of_basis( V.from_vector(b.to_vector()) for b in basis ) + W = V.span_of_basis( (V.from_vector(b.to_vector()) for b in basis), + check=check_axioms) n = len(basis) if check_axioms: -- 2.43.2