matrix_algebra: fix element construction.

diff --git a/mjo/hurwitz.py b/mjo/hurwitz.py
index cad89ca177cbdcfbc065682d4a64af43aad6917a..57f65786ebf564e1f250d5c22c60e35dcd440c08 100644 (file)
--- a/mjo/hurwitz.py
+++ b/mjo/hurwitz.py
@@ -312,19 +312,21 @@ class HurwitzMatrixAlgebraElement(MatrixAlgebraElement):
 
         SETUP::
 
-            sage: from mjo.hurwitz import HurwitzMatrixAlgebra
+            sage: from mjo.hurwitz import ComplexMatrixAlgebra
 
         EXAMPLES::
 
-            sage: A = HurwitzMatrixAlgebra(2, QQbar, ZZ)
+            sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
             sage: M = A([ [ I,   2*I],
             ....:         [ 3*I, 4*I] ])
             sage: M.conjugate_transpose()
             +------+------+
-            | -1*I | -3*I |
+            | -I   | -3*I |
             +------+------+
             | -2*I | -4*I |
             +------+------+
+            sage: M.conjugate_transpose().to_vector()
+            (0, -1, 0, -3, 0, -2, 0, -4)
 
         """
         entries = [ [ self[j,i].conjugate()
@@ -337,16 +339,25 @@ class HurwitzMatrixAlgebraElement(MatrixAlgebraElement):
 
         SETUP::
 
-            sage: from mjo.hurwitz import HurwitzMatrixAlgebra
+            sage: from mjo.hurwitz import (ComplexMatrixAlgebra,
+            ....:                          HurwitzMatrixAlgebra)
 
         EXAMPLES::
 
-            sage: A = HurwitzMatrixAlgebra(2, QQbar, ZZ)
+            sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
             sage: M = A([ [ 0,I],
             ....:         [-I,0] ])
             sage: M.is_hermitian()
             True
 
+        ::
+
+            sage: A = HurwitzMatrixAlgebra(2, AA, QQ)
+            sage: M = A([ [1, 1],
+            ....:         [1, 1] ])
+            sage: M.is_hermitian()
+            True
+
         """
         # A tiny bit faster than checking equality with the conjugate
         # transpose.
@@ -649,9 +660,9 @@ class QuaternionMatrixAlgebra(HurwitzMatrixAlgebra):
             (0, 0, 0, 1)
 
         """
-        from sage.modules.free_module import VectorSpace
+        from sage.modules.free_module import FreeModule
         d = len(self.entry_algebra_gens())
-        V = VectorSpace(self.entry_algebra().base_ring(), d)
+        V = FreeModule(self.entry_algebra().base_ring(), d)
         return V(entry.coefficient_tuple())
 
 class ComplexMatrixAlgebra(HurwitzMatrixAlgebra):
@@ -750,7 +761,7 @@ class ComplexMatrixAlgebra(HurwitzMatrixAlgebra):
             (0, 1)
 
         """
-        from sage.modules.free_module import VectorSpace
+        from sage.modules.free_module import FreeModule
         d = len(self.entry_algebra_gens())
-        V = VectorSpace(self.entry_algebra().base_ring(), d)
+        V = FreeModule(self.entry_algebra().base_ring(), d)
         return V((entry.real(), entry.imag()))

diff --git a/mjo/matrix_algebra.py b/mjo/matrix_algebra.py
index 8491f277d5cc81b955c6ddaed0298549d15aa779..73286ff452adf3323a9fdf534dfbeba8c6777bbd 100644 (file)
--- a/mjo/matrix_algebra.py
+++ b/mjo/matrix_algebra.py
@@ -205,8 +205,8 @@ class MatrixAlgebra(CombinatorialFreeModule):
         # lies to us.
         entry_basis = self.entry_algebra_gens()
 
-        basis_indices = [(i,j,e) for j in range(n)
-                                 for i in range(n)
+        basis_indices = [(i,j,e) for i in range(n)
+                                 for j in range(n)
                                  for e in entry_basis]
 
         super().__init__(scalars,
@@ -300,9 +300,9 @@ class MatrixAlgebra(CombinatorialFreeModule):
         if hasattr(entry, 'to_vector'):
             return entry.to_vector()
 
-        from sage.modules.free_module import VectorSpace
+        from sage.modules.free_module import FreeModule
         d = len(self.entry_algebra_gens())
-        V = VectorSpace(self.entry_algebra().base_ring(), d)
+        V = FreeModule(self.entry_algebra().base_ring(), d)
 
         if hasattr(entry, 'list'):
             # sage matrices
@@ -345,13 +345,16 @@ class MatrixAlgebra(CombinatorialFreeModule):
         (i,j,e1) = mon1
         (k,l,e2) = mon2
         if j == k:
-            # If e1*e2 has a negative sign in front of it,
-            # then (i,l,e1*e2) won't be a monomial!
-            p = e1*e2
-            if (i,l,p) in self.indices():
-                return self.monomial((i,l,p))
-            else:
-                return -self.monomial((i,l,-p))
+            # There's no reason to expect e1*e2 to itself be a monomial,
+            # so we have to do some manual conversion to get one.
+            p = self._entry_algebra_element_to_vector(e1*e2)
+
+            # We have to convert alpha_g because a priori it lives in the
+            # base ring of the entry algebra.
+            R = self.base_ring()
+            return self.sum( R(alpha_g)*self.monomial( (i,l,g) )
+                             for (alpha_g, g)
+                             in zip(p, self.entry_algebra_gens()))
         else:
             return self.zero()
 
@@ -362,17 +365,20 @@ class MatrixAlgebra(CombinatorialFreeModule):
 
         SETUP::
 
-            sage: from mjo.matrix_algebra import MatrixAlgebra
+            sage: from mjo.hurwitz import ComplexMatrixAlgebra
 
         EXAMPLES::
 
-            sage: A = MatrixAlgebra(2, QQbar, ZZ)
-            sage: A.from_list([[0,I],[-I,0]])
+            sage: A = ComplexMatrixAlgebra(2, QQbar, ZZ)
+            sage: M = A.from_list([[0,I],[-I,0]])
+            sage: M
             +----+---+
             | 0  | I |
             +----+---+
             | -I | 0 |
             +----+---+
+            sage: M.to_vector()
+            (0, 0, 0, 1, 0, -1, 0, 0)
 
         """
         nrows = len(entries)
@@ -400,10 +406,22 @@ class MatrixAlgebra(CombinatorialFreeModule):
                 # Octonions(AA).
                 return self.entry_algebra().from_vector(e_ij.to_vector())
 
-        return sum( (self.monomial( (i,j, convert(entries[i][j])) )
-                     for i in range(nrows)
-                     for j in range(ncols) ),
-                    self.zero() )
+        def entry_to_element(i,j,entry):
+            # Convert an entry at i,j to a matrix whose only non-zero
+            # entry is i,j and corresponds to the entry.
+            p = self._entry_algebra_element_to_vector(entry)
+
+            # We have to convert alpha_g because a priori it lives in the
+            # base ring of the entry algebra.
+            R = self.base_ring()
+            return self.sum( R(alpha_g)*self.monomial( (i,j,g) )
+                             for (alpha_g, g)
+                             in zip(p, self.entry_algebra_gens()))
+
+        return self.sum( entry_to_element(i,j,entries[i][j])
+                         for j in range(ncols)
+                         for i in range(nrows) )
+
 
     def _element_constructor_(self, elt):
         if elt in self: