X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=4bef201cd2d0bbda251dbfd347cd9006185d82a5;hb=e9cb8f877cfca9934dc67b6ab4f6ea585bba92d5;hp=7f7b1f9f1c09703a2d8f48e295b203604fa5556c;hpb=ef91dedb7fecddd4c0a5472e501188739b3d3d88;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 7f7b1f9..4bef201 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -745,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: @@ -1049,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): @@ -1139,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 @@ -1160,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 @@ -1250,16 +1258,11 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra): Yu = cls.real_unembed(Y) tr = (Xu*Yu).trace() - if tr in RLF: - # It's real already. - return tr - - # Otherwise, try the thing that works for complex numbers; and - # if that doesn't work, the thing that works for quaternions. try: - return tr.vector()[0] # real part, imag part is index 1 + # Works in QQ, AA, RDF, et cetera. + return tr.real() except AttributeError: - # A quaternions doesn't have a vector() method, but does + # A quaternion doesn't have a real() method, but does # have coefficient_tuple() method that returns the # coefficients of 1, i, j, and k -- in that order. return tr.coefficient_tuple()[0] @@ -1406,7 +1409,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) @@ -1702,7 +1708,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) @@ -2003,7 +2012,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) @@ -2086,8 +2098,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): @@ -2179,7 +2193,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): @@ -2213,10 +2227,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) @@ -2262,6 +2278,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())