]> gitweb.michael.orlitzky.com - sage.d.git/blobdiff - mjo/eja/eja_algebra.py
eja: add a new TrivialEJA class and some tests for it.
[sage.d.git] / mjo / eja / eja_algebra.py
index 430f233114b09f36361322e5f2d4b4e408fd2aeb..12207b7c5a8e897738ab21a73361883cae03626f 100644 (file)
@@ -16,12 +16,9 @@ from sage.misc.cachefunc import cached_method
 from sage.misc.prandom import choice
 from sage.misc.table import table
 from sage.modules.free_module import FreeModule, VectorSpace
-from sage.rings.integer_ring import ZZ
-from sage.rings.number_field.number_field import QuadraticField
-from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
-from sage.rings.rational_field import QQ
-from sage.rings.real_lazy import CLF, RLF
-
+from sage.rings.all import (ZZ, QQ, RR, RLF, CLF,
+                            PolynomialRing,
+                            QuadraticField)
 from mjo.eja.eja_element import FiniteDimensionalEuclideanJordanAlgebraElement
 from mjo.eja.eja_utils import _mat2vec
 
@@ -40,11 +37,12 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
                  rank,
                  prefix='e',
                  category=None,
-                 natural_basis=None):
+                 natural_basis=None,
+                 check=True):
         """
         SETUP::
 
-            sage: from mjo.eja.eja_algebra import random_eja
+            sage: from mjo.eja.eja_algebra import (JordanSpinEJA, random_eja)
 
         EXAMPLES:
 
@@ -56,7 +54,23 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
             sage: x*y == y*x
             True
 
+        TESTS:
+
+        The ``field`` we're given must be real::
+
+            sage: JordanSpinEJA(2,QQbar)
+            Traceback (most recent call last):
+            ...
+            ValueError: field is not real
+
         """
+        if check:
+            if not field.is_subring(RR):
+                # Note: this does return true for the real algebraic
+                # field, and any quadratic field where we've specified
+                # a real embedding.
+                raise ValueError('field is not real')
+
         self._rank = rank
         self._natural_basis = natural_basis
 
@@ -237,7 +251,10 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
         """
         (A_of_x, x, xr, detA) = self._charpoly_matrix_system()
         R = A_of_x.base_ring()
-        if i >= self.rank():
+
+        if i == self.rank():
+            return R.one()
+        if i > self.rank():
             # Guaranteed by theory
             return R.zero()
 
@@ -346,7 +363,7 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
 
         SETUP::
 
-            sage: from mjo.eja.eja_algebra import JordanSpinEJA
+            sage: from mjo.eja.eja_algebra import JordanSpinEJA, TrivialEJA
 
         EXAMPLES:
 
@@ -360,12 +377,22 @@ 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()
 
-        # The list of coefficient polynomials a_1, a_2, ..., a_n.
-        a = [ self._charpoly_coeff(i) for i in range(n) ]
+        # The list of coefficient polynomials a_0, a_1, a_2, ..., a_n.
+        a = [ self._charpoly_coeff(i) for i in range(r+1) ]
 
         # We go to a bit of trouble here to reorder the
         # indeterminates, so that it's easier to evaluate the
@@ -377,17 +404,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
         S = PolynomialRing(S, R.variable_names())
         t = S(t)
 
-        # Note: all entries past the rth should be zero. The
-        # coefficient of the highest power (x^r) is 1, but it doesn't
-        # appear in the solution vector which contains coefficients
-        # for the other powers (to make them sum to x^r).
-        if (r < n):
-            a[r] = 1 # corresponds to x^r
-        else:
-            # When the rank is equal to the dimension, trying to
-            # assign a[r] goes out-of-bounds.
-            a.append(1) # corresponds to x^r
-
         return sum( a[k]*(t**k) for k in xrange(len(a)) )
 
 
@@ -428,15 +444,19 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
 
         SETUP::
 
-            sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
+            sage: from mjo.eja.eja_algebra import (ComplexHermitianEJA,
+            ....:                                  TrivialEJA)
 
         EXAMPLES::
 
             sage: J = ComplexHermitianEJA(3)
             sage: J.is_trivial()
             False
-            sage: A = J.zero().subalgebra_generated_by()
-            sage: A.is_trivial()
+
+        ::
+
+            sage: J = TrivialEJA()
+            sage: J.is_trivial()
             True
 
         """
@@ -611,14 +631,6 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
         return self.linear_combination(zip(self.gens(), coeffs))
 
 
-    def random_element(self):
-        # Temporary workaround for https://trac.sagemath.org/ticket/28327
-        if self.is_trivial():
-            return self.zero()
-        else:
-            s = super(FiniteDimensionalEuclideanJordanAlgebra, self)
-            return s.random_element()
-
     def random_elements(self, count):
         """
         Return ``count`` random elements as a tuple.
@@ -683,11 +695,15 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
         TESTS:
 
         Ensure that every EJA that we know how to construct has a
-        positive integer rank::
+        positive integer rank, unless the algebra is trivial in
+        which case its rank will be zero::
 
             sage: set_random_seed()
-            sage: r = random_eja().rank()
-            sage: r in ZZ and r > 0
+            sage: J = random_eja()
+            sage: r = J.rank()
+            sage: r in ZZ
+            True
+            sage: r > 0 or (r == 0 and J.is_trivial())
             True
 
         """
@@ -760,6 +776,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)
 
@@ -838,32 +859,10 @@ class RealCartesianProductEJA(FiniteDimensionalEuclideanJordanAlgebra,
         return x.to_vector().inner_product(y.to_vector())
 
 
-def random_eja():
+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
@@ -874,8 +873,11 @@ def random_eja():
         Euclidean Jordan algebra of dimension...
 
     """
-    classname = choice(KnownRankEJA.__subclasses__())
-    return classname.random_instance()
+    eja_classes = KnownRankEJA.__subclasses__()
+    if nontrivial:
+        eja_classes.remove(TrivialEJA)
+    classname = choice(eja_classes)
+    return classname.random_instance(field=field)
 
 
 
@@ -1840,3 +1842,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)