X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Feja%2Feja_algebra.py;h=c33352c85d92c11022804ac1d2e6ce57aad7177f;hb=372770929343f5a75e8e8231894b466b3382dd9d;hp=725cd7132343ee6f3ba5769d8053aaff32501560;hpb=04f4cf9128e6cad289e78845de177e7b1f7fca6d;p=sage.d.git diff --git a/mjo/eja/eja_algebra.py b/mjo/eja/eja_algebra.py index 725cd71..c33352c 100644 --- a/mjo/eja/eja_algebra.py +++ b/mjo/eja/eja_algebra.py @@ -13,6 +13,7 @@ from sage.combinat.free_module import CombinatorialFreeModule from sage.matrix.constructor import matrix from sage.matrix.matrix_space import MatrixSpace from sage.misc.cachefunc import cached_method +from sage.misc.lazy_import import lazy_import from sage.misc.prandom import choice from sage.misc.table import table from sage.modules.free_module import FreeModule, VectorSpace @@ -20,6 +21,8 @@ from sage.rings.all import (ZZ, QQ, RR, RLF, CLF, PolynomialRing, QuadraticField) from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement +lazy_import('mjo.eja.eja_subalgebra', + 'FiniteDimensionalEuclideanJordanSubalgebra') from mjo.eja.eja_utils import _mat2vec class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): @@ -363,7 +366,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): SETUP:: - sage: from mjo.eja.eja_algebra import JordanSpinEJA + sage: from mjo.eja.eja_algebra import JordanSpinEJA, TrivialEJA EXAMPLES: @@ -377,6 +380,16 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): sage: p(*xvec) t^2 - 2*t + 1 + By definition, the characteristic polynomial is a monic + degree-zero polynomial in a rank-zero algebra. Note that + Cayley-Hamilton is indeed satisfied since the polynomial + ``1`` evaluates to the identity element of the algebra on + any argument:: + + sage: J = TrivialEJA() + sage: J.characteristic_polynomial() + 1 + """ r = self.rank() n = self.dimension() @@ -434,7 +447,8 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): SETUP:: - sage: from mjo.eja.eja_algebra import ComplexHermitianEJA + sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA, + ....: TrivialEJA) EXAMPLES:: @@ -442,6 +456,12 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): sage: J.is_trivial() False + :: + + sage: J = TrivialEJA() + sage: J.is_trivial() + True + """ return self.dimension() == 0 @@ -614,6 +634,42 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule): return self.linear_combination(zip(self.gens(), coeffs)) + def peirce_decomposition(self, c): + """ + The Peirce decomposition of this algebra relative to the + idempotent ``c``. + + In the future, this can be extended to a complete system of + orthogonal idempotents. + """ + if not c.is_idempotent(): + raise ValueError("element is not idempotent: %s" % c) + + # Default these to what they should be if they turn out to be + # trivial, because eigenspaces_left() won't return eigenvalues + # corresponding to trivial spaces (e.g. it returns only the + # eigenspace corresponding to lambda=1 if you take the + # decomposition relative to the identity element). + trivial = FiniteDimensionalEuclideanJordanSubalgebra(self, ()) + J0 = trivial # eigenvalue zero + J2 = trivial # eigenvalue one-half + J1 = trivial # eigenvalue one + + for (eigval, eigspace) in c.operator().matrix().left_eigenspaces(): + gens = tuple( self.from_vector(b) for b in eigspace.basis() ) + subalg = FiniteDimensionalEuclideanJordanSubalgebra(self, gens) + if eigval == 0: + J0 = subalg + elif eigval == ~(self.base_ring()(2)): + J2 = subalg + elif eigval == 1: + J1 = subalg + else: + raise ValueError("unexpected eigenvalue: %s" % eigval) + + return (J0, J2, J1) + + def random_elements(self, count): """ Return ``count`` random elements as a tuple. @@ -759,6 +815,11 @@ class KnownRankEJA(object): Beware, this will crash for "most instances" because the constructor below looks wrong. """ + if cls is TrivialEJA: + # The TrivialEJA class doesn't take an "n" argument because + # there's only one. + return cls(field) + n = ZZ.random_element(cls._max_test_case_size()) + 1 return cls(n, field, **kwargs) @@ -837,32 +898,10 @@ class RealCartesianProductEJA(FiniteDimensionalEuclideanJordanAlgebra, return x.to_vector().inner_product(y.to_vector()) -def random_eja(field=QQ): +def random_eja(field=QQ, nontrivial=False): """ Return a "random" finite-dimensional Euclidean Jordan Algebra. - ALGORITHM: - - For now, we choose a random natural number ``n`` (greater than zero) - and then give you back one of the following: - - * The cartesian product of the rational numbers ``n`` times; this is - ``QQ^n`` with the Hadamard product. - - * The Jordan spin algebra on ``QQ^n``. - - * The ``n``-by-``n`` rational symmetric matrices with the symmetric - product. - - * The ``n``-by-``n`` complex-rational Hermitian matrices embedded - in the space of ``2n``-by-``2n`` real symmetric matrices. - - * The ``n``-by-``n`` quaternion-rational Hermitian matrices embedded - in the space of ``4n``-by-``4n`` real symmetric matrices. - - Later this might be extended to return Cartesian products of the - EJAs above. - SETUP:: sage: from mjo.eja.eja_algebra import random_eja @@ -873,7 +912,10 @@ def random_eja(field=QQ): Euclidean Jordan algebra of dimension... """ - classname = choice(KnownRankEJA.__subclasses__()) + eja_classes = KnownRankEJA.__subclasses__() + if nontrivial: + eja_classes.remove(TrivialEJA) + classname = choice(eja_classes) return classname.random_instance(field=field) @@ -1839,3 +1881,40 @@ class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): """ return x.to_vector().inner_product(y.to_vector()) + + +class TrivialEJA(FiniteDimensionalEuclideanJordanAlgebra, KnownRankEJA): + """ + The trivial Euclidean Jordan algebra consisting of only a zero element. + + SETUP:: + + sage: from mjo.eja.eja_algebra import TrivialEJA + + EXAMPLES:: + + sage: J = TrivialEJA() + sage: J.dimension() + 0 + sage: J.zero() + 0 + sage: J.one() + 0 + sage: 7*J.one()*12*J.one() + 0 + sage: J.one().inner_product(J.one()) + 0 + sage: J.one().norm() + 0 + sage: J.one().subalgebra_generated_by() + Euclidean Jordan algebra of dimension 0 over Rational Field + sage: J.rank() + 0 + + """ + def __init__(self, field=QQ, **kwargs): + mult_table = [] + 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)