X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=389efbf77219acff73db032e848e34d8da1670e9;hb=9632a965029feadbb70d18574f8704812ed71321;hp=26b72480ffd6d18c1bb8ca43ae3358afda951996;hpb=1846049dafeb625173550d00539989e14939544a;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 26b7248..389efbf 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -26,13 +26,30 @@ lazy_import('mjo.eja.eja_subalgebra', from mjo.eja.eja_utils import _mat2vec class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): - # This is an ugly hack needed to prevent the category framework - # from implementing a coercion from our base ring (e.g. the - # rationals) into the algebra. First of all -- such a coercion is - # nonsense to begin with. But more importantly, it tries to do so - # in the category of rings, and since our algebras aren't - # associative they generally won't be rings. - _no_generic_basering_coercion = True + + def _coerce_map_from_base_ring(self): + """ + Disable the map from the base ring into the algebra. + + Performing a nonsense conversion like this automatically + is counterpedagogical. The fallback is to try the usual + element constructor, which should also fail. + + SETUP:: + + sage: from mjo.eja.eja_algebra import random_eja + + TESTS:: + + sage: set_random_seed() + sage: J = random_eja() + sage: J(1) + Traceback (most recent call last): + ... + ValueError: not a naturally-represented algebra element + + """ + return None def __init__(self, field, @@ -149,15 +166,22 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): True """ + msg = "not a naturally-represented algebra element" if elt == 0: # The superclass implementation of random_element() # needs to be able to coerce "0" into the algebra. return self.zero() + elif elt in self.base_ring(): + # Ensure that no base ring -> algebra coercion is performed + # by this method. There's some stupidity in sage that would + # otherwise propagate to this method; for example, sage thinks + # that the integer 3 belongs to the space of 2-by-2 matrices. + raise ValueError(msg) natural_basis = self.natural_basis() basis_space = natural_basis[0].matrix_space() if elt not in basis_space: - raise ValueError("not a naturally-represented algebra element") + raise ValueError(msg) # Thanks for nothing! Matrix spaces aren't vector spaces in # Sage, so we have to figure out its natural-basis coordinates @@ -749,6 +773,108 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): return (J0, J5, J1) + def a_jordan_frame(self): + r""" + Generate a Jordan frame for this algebra. + + This implementation is based on the so-called "central + orthogonal idempotents" implemented for (semisimple) centers + of SageMath ``FiniteDimensionalAlgebrasWithBasis``. Since all + Euclidean Jordan algebas are commutative (and thus equal to + their own centers) and semisimple, the method should work more + or less as implemented, if it ever worked in the first place. + (I don't know the justification for the original implementation. + yet). + + How it works: we loop through the algebras generators, looking + for their eigenspaces. If there's more than one eigenspace, + and if they result in more than one subalgebra, then we split + those subalgebras recursively until we get to subalgebras of + dimension one (whose idempotent is the unit element). Why does + some generator have to produce at least two subalgebras? I + dunno. But it seems to work. + + Beware that Koecher defines the "center" of a Jordan algebra to + be something else, because the usual definition is stupid in a + (necessarily commutative) Jordan algebra. + + SETUP:: + + sage: from mjo.eja.eja_algebra import (random_eja, + ....: JordanSpinEJA, + ....: TrivialEJA) + + EXAMPLES: + + A Jordan frame for the trivial algebra has to be empty + (zero-length) since its rank is zero. More to the point, there + are no non-zero idempotents in the trivial EJA. This does not + cause any problems so long as we adopt the convention that the + empty sum is zero, since then the sole element of the trivial + EJA has an (empty) spectral decomposition:: + + sage: J = TrivialEJA() + sage: J.a_jordan_frame() + () + + A one-dimensional algebra has rank one (equal to its dimension), + and only one primitive idempotent, namely the algebra's unit + element:: + + sage: J = JordanSpinEJA(1) + sage: J.a_jordan_frame() + (e0,) + + TESTS:: + + sage: J = random_eja() + sage: c = J.a_jordan_frame() + sage: all( x^2 == x for x in c ) + True + sage: r = len(c) + sage: all( c[i]*c[j] == c[i]*(i==j) for i in range(r) + ....: for j in range(r) ) + True + + """ + if self.dimension() == 0: + return () + if self.dimension() == 1: + return (self.one(),) + + for g in self.gens(): + eigenpairs = g.operator().matrix().right_eigenspaces() + if len(eigenpairs) >= 2: + subalgebras = [] + for eigval, eigspace in eigenpairs: + # Make sub-EJAs from the matrix eigenspaces... + sb = tuple( self.from_vector(b) for b in eigspace.basis() ) + try: + # This will fail if e.g. the eigenspace basis + # contains two elements and their product + # isn't a linear combination of the two of + # them (i.e. the generated EJA isn't actually + # two dimensional). + s = FiniteDimensionalEuclideanJordanSubalgebra(self, sb) + subalgebras.append(s) + except ArithmeticError as e: + if str(e) == "vector is not in free module": + # Ignore only the "not a sub-EJA" error + pass + + if len(subalgebras) >= 2: + # apply this method recursively. + return tuple( c.superalgebra_element() + for subalgebra in subalgebras + for c in subalgebra.a_jordan_frame() ) + + # If we got here, the algebra didn't decompose, at least not when we looked at + # the eigenspaces corresponding only to basis elements of the algebra. The + # implementation I stole says that this should work because of Schur's Lemma, + # so I personally blame Schur's Lemma if it does not. + raise Exception("Schur's Lemma didn't work!") + + def random_elements(self, count): """ Return ``count`` random elements as a tuple. @@ -1886,7 +2012,8 @@ class BilinearFormEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): SETUP:: - sage: from mjo.eja.eja_algebra import BilinearFormEJA + sage: from mjo.eja.eja_algebra import (BilinearFormEJA, + ....: JordanSpinEJA) EXAMPLES: @@ -1969,23 +2096,20 @@ class BilinearFormEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): TESTS: - Ensure that this is one-half of the trace inner-product:: + Ensure that this is one-half of the trace inner-product when + the algebra isn't just the reals (when ``n`` isn't one). This + is in Faraut and Koranyi, and also my "On the symmetry..." + paper:: sage: set_random_seed() - sage: n = ZZ.random_element(5) - sage: M = matrix.random(QQ, n-1, algorithm='unimodular') + sage: n = ZZ.random_element(2,5) + sage: M = matrix.random(QQ, max(0,n-1), algorithm='unimodular') sage: B = M.transpose()*M sage: J = BilinearFormEJA(n, B=B) - sage: eis = VectorSpace(M.base_ring(), M.ncols()).basis() - sage: V = J.vector_space() - sage: sis = [ J.from_vector(V([0] + (M.inverse()*ei).list())) - ....: for ei in eis ] - sage: actual = [ sis[i]*sis[j] - ....: for i in range(n-1) - ....: for j in range(n-1) ] - sage: expected = [ J.one() if i == j else J.zero() - ....: for i in range(n-1) - ....: for j in range(n-1) ] + sage: x = J.random_element() + sage: y = J.random_element() + sage: x.inner_product(y) == (x*y).trace()/2 + True """ xvec = x.to_vector() @@ -1994,7 +2118,8 @@ class BilinearFormEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): ybar = yvec[1:] return x[0]*y[0] + (self._B*xbar).inner_product(ybar) -class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): + +class JordanSpinEJA(BilinearFormEJA): """ The rank-2 simple EJA consisting of real vectors ``x=(x0, x_bar)`` with the usual inner product and jordan product ``x*y = @@ -2031,42 +2156,9 @@ class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): sage: JordanSpinEJA(2, prefix='B').gens() (B0, B1) - """ - def __init__(self, n, field=QQ, **kwargs): - V = VectorSpace(field, n) - mult_table = [[V.zero() for j in range(n)] for i in range(n)] - for i in range(n): - for j in range(n): - x = V.gen(i) - y = V.gen(j) - x0 = x[0] - xbar = x[1:] - y0 = y[0] - ybar = y[1:] - # z = x*y - z0 = x.inner_product(y) - zbar = y0*xbar + x0*ybar - z = V([z0] + zbar.list()) - mult_table[i][j] = z - - # The rank of the spin algebra is two, unless we're in a - # one-dimensional ambient space (because the rank is bounded by - # the ambient dimension). - fdeja = super(JordanSpinEJA, self) - return fdeja.__init__(field, mult_table, rank=min(n,2), **kwargs) - - def inner_product(self, x, y): - """ - Faster to reimplement than to use natural representations. - - SETUP:: - - sage: from mjo.eja.eja_algebra import JordanSpinEJA - - TESTS: + TESTS: - Ensure that this is the usual inner product for the algebras - over `R^n`:: + Ensure that we have the usual inner product on `R^n`:: sage: set_random_seed() sage: J = JordanSpinEJA.random_instance() @@ -2076,8 +2168,11 @@ class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): sage: x.inner_product(y) == J.natural_inner_product(X,Y) True - """ - return x.to_vector().inner_product(y.to_vector()) + """ + def __init__(self, n, field=QQ, **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) class TrivialEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA):