X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=19db8b0ccefef297623d81721d4a774f99a9d3d1;hb=95e949d3fc11b55d39cb3b77a5ec53270c271e1f;hp=ff2b5d7a9c52ff5c13df7d7aa3682899b9a30559;hpb=cd164e717e7224ec1af16d31152555f0c7cf49cf;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index ff2b5d7..19db8b0 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -54,7 +54,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): def __init__(self, field, mult_table, - rank, prefix='e', category=None, natural_basis=None, @@ -91,7 +90,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): # a real embedding. raise ValueError('field is not real') - self._rank = rank self._natural_basis = natural_basis if category is None: @@ -809,7 +807,8 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): SETUP:: - sage: from mjo.eja.eja_algebra import (JordanSpinEJA, + sage: from mjo.eja.eja_algebra import (HadamardEJA, + ....: JordanSpinEJA, ....: RealSymmetricEJA, ....: ComplexHermitianEJA, ....: QuaternionHermitianEJA, @@ -1047,7 +1046,8 @@ class HadamardEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): for i in range(n) ] fdeja = super(HadamardEJA, self) - return fdeja.__init__(field, mult_table, rank=n, **kwargs) + fdeja.__init__(field, mult_table, **kwargs) + self.rank.set_cache(n) def inner_product(self, x, y): """ @@ -1106,7 +1106,7 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra): # field can have dimension 4 (quaternions) too. return 2 - def __init__(self, field, basis, rank, normalize_basis=True, **kwargs): + def __init__(self, field, basis, normalize_basis=True, **kwargs): """ Compared to the superclass constructor, we take a basis instead of a multiplication table because the latter can be computed in terms @@ -1119,7 +1119,7 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra): # time to ensure that it isn't a generator expression. basis = tuple(basis) - if rank > 1 and normalize_basis: + if len(basis) > 1 and normalize_basis: # We'll need sqrt(2) to normalize the basis, and this # winds up in the multiplication table, so the whole # algebra needs to be over the field extension. @@ -1136,14 +1136,12 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra): Qs = self.multiplication_table_from_matrix_basis(basis) fdeja = super(MatrixEuclideanJordanAlgebra, self) - return fdeja.__init__(field, - Qs, - rank=rank, - natural_basis=basis, - **kwargs) + fdeja.__init__(field, Qs, natural_basis=basis, **kwargs) + return - def _rank_computation(self): + @cached_method + def rank(self): r""" Override the parent method with something that tries to compute over a faster (non-extension) field. @@ -1151,7 +1149,7 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra): if self._basis_normalizers is None: # We didn't normalize, so assume that the basis we started # with had entries in a nice field. - return super(MatrixEuclideanJordanAlgebra, self)._rank_computation() + return super(MatrixEuclideanJordanAlgebra, self).rank() else: basis = ( (b/n) for (b,n) in zip(self.natural_basis(), self._basis_normalizers) ) @@ -1161,9 +1159,8 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra): # integers. J = MatrixEuclideanJordanAlgebra(QQ, basis, - self.rank(), normalize_basis=False) - return J._rank_computation() + return J.rank() @cached_method def _charpoly_coeff(self, i): @@ -1182,7 +1179,6 @@ class MatrixEuclideanJordanAlgebra(FiniteDimensionalEuclideanJordanAlgebra): # Do this over the rationals and convert back at the end. J = MatrixEuclideanJordanAlgebra(QQ, basis, - self.rank(), normalize_basis=False) (_,x,_,_) = J._charpoly_matrix_system() p = J._charpoly_coeff(i) @@ -1411,7 +1407,8 @@ class RealSymmetricEJA(RealMatrixEuclideanJordanAlgebra, KnownRankEJA): def __init__(self, n, field=AA, **kwargs): basis = self._denormalized_basis(n, field) - super(RealSymmetricEJA, self).__init__(field, basis, n, **kwargs) + super(RealSymmetricEJA, self).__init__(field, basis, **kwargs) + self.rank.set_cache(n) class ComplexMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra): @@ -1701,7 +1698,8 @@ class ComplexHermitianEJA(ComplexMatrixEuclideanJordanAlgebra, KnownRankEJA): def __init__(self, n, field=AA, **kwargs): basis = self._denormalized_basis(n,field) - super(ComplexHermitianEJA,self).__init__(field, basis, n, **kwargs) + super(ComplexHermitianEJA,self).__init__(field, basis, **kwargs) + self.rank.set_cache(n) class QuaternionMatrixEuclideanJordanAlgebra(MatrixEuclideanJordanAlgebra): @@ -1997,7 +1995,8 @@ class QuaternionHermitianEJA(QuaternionMatrixEuclideanJordanAlgebra, def __init__(self, n, field=AA, **kwargs): basis = self._denormalized_basis(n,field) - super(QuaternionHermitianEJA,self).__init__(field, basis, n, **kwargs) + super(QuaternionHermitianEJA,self).__init__(field, basis, **kwargs) + self.rank.set_cache(n) class BilinearFormEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): @@ -2080,7 +2079,8 @@ class BilinearFormEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): # one-dimensional ambient space (because the rank is bounded # by the ambient dimension). fdeja = super(BilinearFormEJA, self) - return fdeja.__init__(field, mult_table, rank=min(n,2), **kwargs) + fdeja.__init__(field, mult_table, **kwargs) + self.rank.set_cache(min(n,2)) def inner_product(self, x, y): r""" @@ -2208,4 +2208,5 @@ class TrivialEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): fdeja = super(TrivialEJA, self) # The rank is zero using my definition, namely the dimension of the # largest subalgebra generated by any element. - return fdeja.__init__(field, mult_table, rank=0, **kwargs) + fdeja.__init__(field, mult_table, **kwargs) + self.rank.set_cache(0)