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
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):
SETUP::
- sage: from mjo.eja.eja_algebra import JordanSpinEJA
+ sage: from mjo.eja.eja_algebra import JordanSpinEJA, TrivialEJA
EXAMPLES:
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()
SETUP::
- sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
+ sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA,
+ ....: TrivialEJA)
EXAMPLES::
sage: J.is_trivial()
False
+ ::
+
+ sage: J = TrivialEJA()
+ sage: J.is_trivial()
+ True
+
"""
return self.dimension() == 0
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.
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)
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
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)
"""
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)
projects / sage.d.git / blobdiff