X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=10b8eb338514a0ec611ced0bb0a9ca169dc67411;hb=16c76a123e1657907d4559518fbb4ea0ef9a8e2f;hp=3846b83ad6d76674f9f82e5f3a662ea5a2aeea4c;hpb=26300571708fdc4e05da64227609a223cfc1cd4c;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 3846b83..10b8eb3 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -296,14 +296,26 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): this algebra was constructed with ``check=False`` and passed an invalid multiplication table. """ + + # Used to check whether or not something is zero in an inexact + # ring. This number is sufficient to allow the construction of + # QuaternionHermitianEJA(2, RDF) with check=True. + epsilon = 1e-16 + for i in range(self.dimension()): for j in range(self.dimension()): for k in range(self.dimension()): x = self.monomial(i) y = self.monomial(j) z = self.monomial(k) - if (x*y).inner_product(z) != x.inner_product(y*z): - return False + diff = (x*y).inner_product(z) - x.inner_product(y*z) + + if self.base_ring().is_exact(): + if diff != 0: + return False + else: + if diff.abs() > epsilon: + return False return True @@ -733,7 +745,9 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): J5 = eigspace else: gens = tuple( self.from_vector(b) for b in eigspace.basis() ) - subalg = FiniteDimensionalEuclideanJordanSubalgebra(self, gens) + subalg = FiniteDimensionalEuclideanJordanSubalgebra(self, + gens, + check=False) if eigval == 0: J0 = subalg elif eigval == 1: @@ -1037,8 +1051,10 @@ class HadamardEJA(FiniteDimensionalEuclideanJordanAlgebra): mult_table = [ [ V.gen(i)*(i == j) for j in range(n) ] for i in range(n) ] - fdeja = super(HadamardEJA, self) - fdeja.__init__(field, mult_table, **kwargs) + super(HadamardEJA, self).__init__(field, + mult_table, + check=False, + **kwargs) self.rank.set_cache(n) def inner_product(self, x, y): @@ -1127,9 +1143,10 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra): Qs = self.multiplication_table_from_matrix_basis(basis) - fdeja = super(MatrixEuclideanJordanAlgebra, self) - fdeja.__init__(field, Qs, natural_basis=basis, **kwargs) - return + super(MatrixEuclideanJordanAlgebra, self).__init__(field, + Qs, + natural_basis=basis, + **kwargs) @cached_method @@ -1148,10 +1165,13 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra): # Do this over the rationals and convert back at the end. # Only works because we know the entries of the basis are - # integers. + # integers. The argument ``check=False`` is required + # because the trace inner-product method for this + # class is a stub and can't actually be checked. J = MatrixEuclideanJordanAlgebra(QQ, basis, - normalize_basis=False) + normalize_basis=False, + check=False) a = J._charpoly_coefficients() # Unfortunately, changing the basis does change the @@ -1394,7 +1414,10 @@ class RealSymmetricEJA(RealMatrixEuclideanJordanAlgebra): def __init__(self, n, field=AA, **kwargs): basis = self._denormalized_basis(n, field) - super(RealSymmetricEJA, self).__init__(field, basis, **kwargs) + super(RealSymmetricEJA, self).__init__(field, + basis, + check=False, + **kwargs) self.rank.set_cache(n) @@ -1690,7 +1713,10 @@ class ComplexHermitianEJA(ComplexMatrixEuclideanJordanAlgebra): def __init__(self, n, field=AA, **kwargs): basis = self._denormalized_basis(n,field) - super(ComplexHermitianEJA,self).__init__(field, basis, **kwargs) + super(ComplexHermitianEJA,self).__init__(field, + basis, + check=False, + **kwargs) self.rank.set_cache(n) @@ -1991,7 +2017,10 @@ class QuaternionHermitianEJA(QuaternionMatrixEuclideanJordanAlgebra): def __init__(self, n, field=AA, **kwargs): basis = self._denormalized_basis(n,field) - super(QuaternionHermitianEJA,self).__init__(field, basis, **kwargs) + super(QuaternionHermitianEJA,self).__init__(field, + basis, + check=False, + **kwargs) self.rank.set_cache(n) @@ -2074,8 +2103,10 @@ class BilinearFormEJA(FiniteDimensionalEuclideanJordanAlgebra): # The rank of this algebra is two, unless we're in a # one-dimensional ambient space (because the rank is bounded # by the ambient dimension). - fdeja = super(BilinearFormEJA, self) - fdeja.__init__(field, mult_table, **kwargs) + super(BilinearFormEJA, self).__init__(field, + mult_table, + check=False, + **kwargs) self.rank.set_cache(min(n,2)) def inner_product(self, x, y): @@ -2167,7 +2198,7 @@ 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. - return super(JordanSpinEJA, self).__init__(n, field, **kwargs) + super(JordanSpinEJA, self).__init__(n, field, **kwargs) class TrivialEJA(FiniteDimensionalEuclideanJordanAlgebra): @@ -2201,10 +2232,12 @@ class TrivialEJA(FiniteDimensionalEuclideanJordanAlgebra): """ def __init__(self, field=AA, **kwargs): mult_table = [] - fdeja = super(TrivialEJA, self) + super(TrivialEJA, self).__init__(field, + mult_table, + check=False, + **kwargs) # The rank is zero using my definition, namely the dimension of the # largest subalgebra generated by any element. - fdeja.__init__(field, mult_table, **kwargs) self.rank.set_cache(0) @@ -2250,6 +2283,8 @@ class DirectSumEJA(FiniteDimensionalEuclideanJordanAlgebra): p = (J2.monomial(i)*J2.monomial(j)).to_vector() mult_table[n1+i][n1+j] = V([field.zero()]*n1 + p.list()) - fdeja = super(DirectSumEJA, self) - fdeja.__init__(field, mult_table, **kwargs) + super(DirectSumEJA, self).__init__(field, + mult_table, + check=False, + **kwargs) self.rank.set_cache(J1.rank() + J2.rank())