X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Fmatrix_algebra.py;h=bd173eaba835b8b82632587e62fcf6a8e7ec4e44;hb=77d2d169ac8a3e46030ee98e6bdb45df418a59c2;hp=94a8410f9929986a8737f9bbb846c04490751fe5;hpb=e28bd3518185e3a87866c61d973876f84fdeea66;p=sage.d.git diff --git a/mjo/matrix_algebra.py b/mjo/matrix_algebra.py index 94a8410..bd173ea 100644 --- a/mjo/matrix_algebra.py +++ b/mjo/matrix_algebra.py @@ -18,7 +18,7 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): EXAMPLES:: - sage: M = MatrixAlgebra(QQbar,RDF,2) + sage: M = MatrixAlgebra(2, QQbar,RDF) sage: A = M.monomial((0,0,1)) + 4*M.monomial((0,1,1)) sage: A +-----+-----+ @@ -50,7 +50,7 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): EXAMPLES:: - sage: MatrixAlgebra(ZZ,ZZ,2).zero() + sage: MatrixAlgebra(2,ZZ,ZZ).zero() +---+---+ | 0 | 0 | +---+---+ @@ -71,7 +71,7 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): EXAMPLES:: - sage: A = MatrixAlgebra(ZZ,ZZ,2) + sage: A = MatrixAlgebra(2,ZZ,ZZ) sage: A([[1,2],[3,4]]).list() [1, 2, 3, 4] @@ -88,7 +88,7 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): EXAMPLES:: - sage: M = MatrixAlgebra(ZZ,ZZ,2)([[1,2],[3,4]]) + sage: M = MatrixAlgebra(2,ZZ,ZZ)([[1,2],[3,4]]) sage: M[0,0] 1 sage: M[0,1] @@ -117,7 +117,7 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): sage: entries = MatrixSpace(ZZ,2) sage: scalars = ZZ - sage: M = MatrixAlgebra(entries, scalars, 2) + sage: M = MatrixAlgebra(2, entries, scalars) sage: I = entries.one() sage: Z = entries.zero() sage: M([[I,Z],[Z,I]]).trace() @@ -139,7 +139,7 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): sage: set_random_seed() sage: entries = QuaternionAlgebra(QQ,-1,-1) - sage: M = MatrixAlgebra(entries, QQ, 3) + sage: M = MatrixAlgebra(3, entries, QQ) sage: M.random_element().matrix_space() == M True @@ -167,7 +167,7 @@ class MatrixAlgebra(CombinatorialFreeModule): The existence of a unit element is determined dynamically:: - sage: MatrixAlgebra(ZZ,ZZ,2).one() + sage: MatrixAlgebra(2,ZZ,ZZ).one() +---+---+ | 1 | 0 | +---+---+ @@ -177,7 +177,7 @@ class MatrixAlgebra(CombinatorialFreeModule): """ Element = MatrixAlgebraElement - def __init__(self, entry_algebra, scalars, n, prefix="A", **kwargs): + def __init__(self, n, entry_algebra, scalars, prefix="A", **kwargs): category = MagmaticAlgebras(scalars).FiniteDimensional() category = category.WithBasis() @@ -185,9 +185,8 @@ class MatrixAlgebra(CombinatorialFreeModule): if "Unital" in entry_algebra.category().axioms(): category = category.Unital() entry_one = entry_algebra.one() - self.one = lambda: sum( (self.monomial((i,i,entry_one)) - for i in range(self.nrows()) ), - self.zero() ) + self.one = lambda: self.sum( (self.monomial((i,i,entry_one)) + for i in range(self.nrows()) ) ) if "Associative" in entry_algebra.category().axioms(): category = category.Associative() @@ -198,14 +197,16 @@ class MatrixAlgebra(CombinatorialFreeModule): # sticking a "1" in each position doesn't give us a basis for # the space. We actually need to stick each of e0, e1, ... (a # basis for the entry algebra itself) into each position. - I = range(n) - J = range(n) self._entry_algebra = entry_algebra - entry_basis = entry_algebra.gens() + + # Needs to make the (overridden) method call when, for example, + # the entry algebra is the complex numbers and its gens() method + # lies to us. + entry_basis = self.entry_algebra_gens() basis_indices = [(i,j,e) for i in range(n) for j in range(n) - for e in entry_algebra.gens()] + for e in entry_basis] super().__init__(scalars, basis_indices, @@ -227,6 +228,92 @@ class MatrixAlgebra(CombinatorialFreeModule): """ return self._entry_algebra + def entry_algebra_gens(self): + r""" + Return a tuple of the generators of (that is, a basis for) the + entries of this matrix algebra. + + This can be overridden in subclasses to work around the + inconsistency in the ``gens()`` methods of the various + entry algebras. + """ + return self.entry_algebra().gens() + + def _entry_algebra_element_to_vector(self, entry): + r""" + Return a vector representation (of length equal to the cardinality + of :meth:`entry_algebra_gens`) of the given ``entry``. + + This can be overridden in subclasses to work around the fact that + real numbers, complex numbers, quaternions, et cetera, all require + different incantations to turn them into a vector. + + It only makes sense to "guess" here in the superclass when no + subclass that overrides :meth:`entry_algebra_gens` exists. So + if you have a special subclass for your annoying entry algebra, + override this with the correct implementation there instead of + adding a bunch of awkward cases to this superclass method. + + SETUP:: + + sage: from mjo.hurwitz import Octonions + sage: from mjo.matrix_algebra import MatrixAlgebra + + EXAMPLES: + + Real numbers:: + + sage: A = MatrixAlgebra(1, AA, QQ) + sage: A._entry_algebra_element_to_vector(AA(17)) + (17) + + Octonions:: + + sage: A = MatrixAlgebra(1, Octonions(), QQ) + sage: e = A.entry_algebra_gens() + sage: A._entry_algebra_element_to_vector(e[0]) + (1, 0, 0, 0, 0, 0, 0, 0) + sage: A._entry_algebra_element_to_vector(e[1]) + (0, 1, 0, 0, 0, 0, 0, 0) + sage: A._entry_algebra_element_to_vector(e[2]) + (0, 0, 1, 0, 0, 0, 0, 0) + sage: A._entry_algebra_element_to_vector(e[3]) + (0, 0, 0, 1, 0, 0, 0, 0) + sage: A._entry_algebra_element_to_vector(e[4]) + (0, 0, 0, 0, 1, 0, 0, 0) + sage: A._entry_algebra_element_to_vector(e[5]) + (0, 0, 0, 0, 0, 1, 0, 0) + sage: A._entry_algebra_element_to_vector(e[6]) + (0, 0, 0, 0, 0, 0, 1, 0) + sage: A._entry_algebra_element_to_vector(e[7]) + (0, 0, 0, 0, 0, 0, 0, 1) + + Sage matrices:: + + sage: MS = MatrixSpace(QQ,2) + sage: A = MatrixAlgebra(1, MS, QQ) + sage: A._entry_algebra_element_to_vector(MS([[1,2],[3,4]])) + (1, 2, 3, 4) + + """ + if hasattr(entry, 'to_vector'): + return entry.to_vector() + + from sage.modules.free_module import FreeModule + d = len(self.entry_algebra_gens()) + V = FreeModule(self.entry_algebra().base_ring(), d) + + if hasattr(entry, 'list'): + # sage matrices + return V(entry.list()) + + # This works in AA, and will crash if it doesn't know what to + # do, and that's fine because then I don't know what to do + # either. + return V((entry,)) + + + def nrows(self): return self._nrows ncols = nrows @@ -245,7 +332,7 @@ class MatrixAlgebra(CombinatorialFreeModule): sage: e = O.gens() sage: e[2]*e[1] -e3 - sage: A = MatrixAlgebra(O,QQ,2) + sage: A = MatrixAlgebra(2,O,QQ) sage: A.product_on_basis( (0,0,e[2]), (0,0,e[1]) ) +-----+---+ | -e3 | 0 | @@ -257,13 +344,17 @@ 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_of_terms( (((i,l,g), R(alpha_g)) + for (alpha_g, g) + in zip(p, self.entry_algebra_gens()) ), + distinct=True) else: return self.zero() @@ -274,17 +365,20 @@ class MatrixAlgebra(CombinatorialFreeModule): SETUP:: - sage: from mjo.matrix_algebra import MatrixAlgebra + sage: from mjo.hurwitz import ComplexMatrixAlgebra EXAMPLES:: - sage: A = MatrixAlgebra(QQbar, ZZ, 2) - 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) @@ -312,10 +406,23 @@ 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_of_terms( (((i,j,g), R(alpha_g)) + for (alpha_g, g) + in zip(p, self.entry_algebra_gens()) ), + distinct=True) + + 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: