]> gitweb.michael.orlitzky.com - sage.d.git/blobdiff - mjo/eja/eja_algebra.py
eja: fix the natural representation in trivial subalgebras.
[sage.d.git] / mjo / eja / eja_algebra.py
index 3855f0ef41e0e95efcadb359d6c7b908960a13b2..42b2474d6971d81c8a1fcda67b079892a3e8af25 100644 (file)
@@ -9,10 +9,11 @@ from sage.algebras.quatalg.quaternion_algebra import QuaternionAlgebra
 from sage.categories.magmatic_algebras import MagmaticAlgebras
 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.prandom import choice
 from sage.misc.table import table
-from sage.modules.free_module import VectorSpace
+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
@@ -207,8 +208,13 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
         determinant).
         """
         z = self._a_regular_element()
-        V = self.vector_space()
-        V1 = V.span_of_basis( (z**k).to_vector() for k in range(self.rank()) )
+        # Don't use the parent vector space directly here in case this
+        # happens to be a subalgebra. In that case, we would be e.g.
+        # two-dimensional but span_of_basis() would expect three
+        # coordinates.
+        V = VectorSpace(self.base_ring(), self.vector_space().dimension())
+        basis = [ (z**k).to_vector() for k in range(self.rank()) ]
+        V1 = V.span_of_basis( basis )
         b =  (V1.basis() + V1.complement().basis())
         return V.span_of_basis(b)
 
@@ -263,7 +269,13 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
         # have multivatiate polynomial entries.
         names = tuple('X' + str(i) for i in range(1,n+1))
         R = PolynomialRing(self.base_ring(), names)
-        V = self.vector_space().change_ring(R)
+
+        # Using change_ring() on the parent's vector space doesn't work
+        # here because, in a subalgebra, that vector space has a basis
+        # and change_ring() tries to bring the basis along with it. And
+        # that doesn't work unless the new ring is a PID, which it usually
+        # won't be.
+        V = FreeModule(R,n)
 
         # Now let x = (X1,X2,...,Xn) be the vector whose entries are
         # indeterminates...
@@ -404,6 +416,29 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
         return x.trace_inner_product(y)
 
 
+    def is_trivial(self):
+        """
+        Return whether or not this algebra is trivial.
+
+        A trivial algebra contains only the zero element.
+
+        SETUP::
+
+            sage: from mjo.eja.eja_algebra import ComplexHermitianEJA
+
+        EXAMPLES::
+
+            sage: J = ComplexHermitianEJA(3)
+            sage: J.is_trivial()
+            False
+            sage: A = J.zero().subalgebra_generated_by()
+            sage: A.is_trivial()
+            True
+
+        """
+        return self.dimension() == 0
+
+
     def multiplication_table(self):
         """
         Return a visual representation of this algebra's multiplication
@@ -480,11 +515,23 @@ class FiniteDimensionalEuclideanJordanAlgebra(CombinatorialFreeModule):
 
         """
         if self._natural_basis is None:
-            return tuple( b.to_vector().column() for b in self.basis() )
+            M = self.natural_basis_space()
+            return tuple( M(b.to_vector()) for b in self.basis() )
         else:
             return self._natural_basis
 
 
+    def natural_basis_space(self):
+        """
+        Return the matrix space in which this algebra's natural basis
+        elements live.
+        """
+        if self._natural_basis is None or len(self._natural_basis) == 0:
+            return MatrixSpace(self.base_ring(), self.dimension(), 1)
+        else:
+            return self._natural_basis[0].matrix_space()
+
+
     @cached_method
     def one(self):
         """
@@ -546,6 +593,15 @@ 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 rank(self):
         """
         Return the rank of this EJA.
@@ -659,14 +715,21 @@ class RealCartesianProductEJA(FiniteDimensionalEuclideanJordanAlgebra):
         sage: e2*e2
         e2
 
+    TESTS:
+
+    We can change the generator prefix::
+
+        sage: RealCartesianProductEJA(3, prefix='r').gens()
+        (r0, r1, r2)
+
     """
-    def __init__(self, n, field=QQ):
+    def __init__(self, n, field=QQ, **kwargs):
         V = VectorSpace(field, n)
         mult_table = [ [ V.gen(i)*(i == j) for j in range(n) ]
                        for i in range(n) ]
 
         fdeja = super(RealCartesianProductEJA, self)
-        return fdeja.__init__(field, mult_table, rank=n)
+        return fdeja.__init__(field, mult_table, rank=n, **kwargs)
 
     def inner_product(self, x, y):
         return _usual_ip(x,y)
@@ -1145,8 +1208,13 @@ class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra):
         sage: J(expected) == x*y
         True
 
+    We can change the generator prefix::
+
+        sage: RealSymmetricEJA(3, prefix='q').gens()
+        (q0, q1, q2, q3, q4, q5)
+
     """
-    def __init__(self, n, field=QQ):
+    def __init__(self, n, field=QQ, **kwargs):
         S = _real_symmetric_basis(n, field=field)
         Qs = _multiplication_table_from_matrix_basis(S)
 
@@ -1154,7 +1222,8 @@ class RealSymmetricEJA(FiniteDimensionalEuclideanJordanAlgebra):
         return fdeja.__init__(field,
                               Qs,
                               rank=n,
-                              natural_basis=S)
+                              natural_basis=S,
+                              **kwargs)
 
     def inner_product(self, x, y):
         return _matrix_ip(x,y)
@@ -1197,8 +1266,13 @@ class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra):
         sage: J(expected) == x*y
         True
 
+    We can change the generator prefix::
+
+        sage: ComplexHermitianEJA(2, prefix='z').gens()
+        (z0, z1, z2, z3)
+
     """
-    def __init__(self, n, field=QQ):
+    def __init__(self, n, field=QQ, **kwargs):
         S = _complex_hermitian_basis(n)
         Qs = _multiplication_table_from_matrix_basis(S)
 
@@ -1206,7 +1280,8 @@ class ComplexHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra):
         return fdeja.__init__(field,
                               Qs,
                               rank=n,
-                              natural_basis=S)
+                              natural_basis=S,
+                              **kwargs)
 
 
     def inner_product(self, x, y):
@@ -1257,8 +1332,13 @@ class QuaternionHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra):
         sage: J(expected) == x*y
         True
 
+    We can change the generator prefix::
+
+        sage: QuaternionHermitianEJA(2, prefix='a').gens()
+        (a0, a1, a2, a3, a4, a5)
+
     """
-    def __init__(self, n, field=QQ):
+    def __init__(self, n, field=QQ, **kwargs):
         S = _quaternion_hermitian_basis(n)
         Qs = _multiplication_table_from_matrix_basis(S)
 
@@ -1266,7 +1346,8 @@ class QuaternionHermitianEJA(FiniteDimensionalEuclideanJordanAlgebra):
         return fdeja.__init__(field,
                               Qs,
                               rank=n,
-                              natural_basis=S)
+                              natural_basis=S,
+                              **kwargs)
 
     def inner_product(self, x, y):
         # Since a+bi+cj+dk on the diagonal is represented as
@@ -1313,8 +1394,13 @@ class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra):
         sage: e2*e3
         0
 
+    We can change the generator prefix::
+
+        sage: JordanSpinEJA(2, prefix='B').gens()
+        (B0, B1)
+
     """
-    def __init__(self, n, field=QQ):
+    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):
@@ -1335,7 +1421,7 @@ class JordanSpinEJA(FiniteDimensionalEuclideanJordanAlgebra):
         # 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))
+        return fdeja.__init__(field, mult_table, rank=min(n,2), **kwargs)
 
     def inner_product(self, x, y):
         return _usual_ip(x,y)