X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=mjo%2Fmatrix_algebra.py;h=84aa8d28bb3de9e6797b9b0a209eb96c3a14dc22;hb=43783fbb6e8292a67506f6df876ab1de6dab68b1;hp=a695b0b7919edfb243cd96fd2592aa2f9fa916df;hpb=c67a336953407573e133313151a42d17efd53d07;p=sage.d.git diff --git a/mjo/matrix_algebra.py b/mjo/matrix_algebra.py index a695b0b..84aa8d2 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 +-----+-----+ @@ -37,7 +37,7 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): l[i][j] += v*e return l - def __repr__(self): + def _repr_(self): r""" Display this matrix as a table. @@ -50,11 +50,11 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): EXAMPLES:: - sage: MatrixAlgebra(ZZ,ZZ,2).one() + sage: MatrixAlgebra(2,ZZ,ZZ).zero() +---+---+ - | 1 | 0 | + | 0 | 0 | +---+---+ - | 0 | 1 | + | 0 | 0 | +---+---+ """ @@ -71,8 +71,9 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): EXAMPLES:: - sage: MatrixAlgebra(ZZ,ZZ,2).one().list() - [1, 0, 0, 1] + sage: A = MatrixAlgebra(2,ZZ,ZZ) + sage: A([[1,2],[3,4]]).list() + [1, 2, 3, 4] """ return sum( self.rows(), [] ) @@ -87,15 +88,15 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): EXAMPLES:: - sage: M = MatrixAlgebra(ZZ,ZZ,2).one() + sage: M = MatrixAlgebra(2,ZZ,ZZ)([[1,2],[3,4]]) sage: M[0,0] 1 sage: M[0,1] - 0 + 2 sage: M[1,0] - 0 + 3 sage: M[1,1] - 1 + 4 """ i,j = indices @@ -116,8 +117,10 @@ class MatrixAlgebraElement(IndexedFreeModuleElement): sage: entries = MatrixSpace(ZZ,2) sage: scalars = ZZ - sage: M = MatrixAlgebra(entries, scalars, 2) - sage: M.one().trace() + sage: M = MatrixAlgebra(2, entries, scalars) + sage: I = entries.one() + sage: Z = entries.zero() + sage: M([[I,Z],[Z,I]]).trace() [2 0] [0 2] @@ -136,32 +139,13 @@ 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 """ return self.parent() - # onlt valid in HurwitzMatrixAlgebra subclass - # def is_hermitian(self): - # r""" - - # SETUP:: - - # sage: from mjo.octonions import OctonionMatrixAlgebra - - # EXAMPLES:: - - # sage: MS = OctonionMatrixAlgebra(3) - # sage: MS.one().is_hermitian() - # True - - # """ - # return all( self[i,j] == self[j,i].conjugate() - # for i in range(self.nrows()) - # for j in range(self.ncols()) ) - class MatrixAlgebra(CombinatorialFreeModule): r""" @@ -174,16 +158,37 @@ class MatrixAlgebra(CombinatorialFreeModule): the entries come from a commutative and associative ring. This is problematic in several interesting matrix algebras, like those where the entries are quaternions or octonions. + + SETUP:: + + sage: from mjo.matrix_algebra import MatrixAlgebra + + EXAMPLES:: + + The existence of a unit element is determined dynamically:: + + sage: MatrixAlgebra(2,ZZ,ZZ).one() + +---+---+ + | 1 | 0 | + +---+---+ + | 0 | 1 | + +---+---+ + """ 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() 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() ) + if "Associative" in entry_algebra.category().axioms(): category = category.Associative() @@ -193,15 +198,17 @@ 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. - from sage.sets.finite_enumerated_set import FiniteEnumeratedSet - from sage.categories.sets_cat import cartesian_product - - I = FiniteEnumeratedSet(range(n)) - J = FiniteEnumeratedSet(range(n)) self._entry_algebra = entry_algebra - entry_basis = entry_algebra.gens() - basis_indices = cartesian_product([I,J,entry_basis]) + # 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 j in range(n) + for i in range(n) + for e in entry_basis] + super().__init__(scalars, basis_indices, category=category, @@ -222,28 +229,56 @@ 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 nrows(self): return self._nrows ncols = nrows def product_on_basis(self, mon1, mon2): - (i,j,oct1) = mon1 - (k,l,oct2) = mon2 - if j == k: - return self.monomial((i,l,oct1*oct2)) - else: - return self.zero() - - def one(self): r""" + SETUP:: + sage: from mjo.hurwitz import Octonions sage: from mjo.matrix_algebra import MatrixAlgebra + TESTS:: + + sage: O = Octonions(QQ) + sage: e = O.gens() + sage: e[2]*e[1] + -e3 + sage: A = MatrixAlgebra(2,O,QQ) + sage: A.product_on_basis( (0,0,e[2]), (0,0,e[1]) ) + +-----+---+ + | -e3 | 0 | + +-----+---+ + | 0 | 0 | + +-----+---+ + """ - return sum( (self.monomial((i,i,self.entry_algebra().one())) - for i in range(self.nrows()) ), - self.zero() ) + (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)) + else: + return self.zero() def from_list(self, entries): r""" @@ -254,6 +289,16 @@ class MatrixAlgebra(CombinatorialFreeModule): sage: from mjo.matrix_algebra import MatrixAlgebra + EXAMPLES:: + + sage: A = MatrixAlgebra(2, QQbar, ZZ) + sage: A.from_list([[0,I],[-I,0]]) + +----+---+ + | 0 | I | + +----+---+ + | -I | 0 | + +----+---+ + """ nrows = len(entries) ncols = 0 @@ -264,13 +309,29 @@ class MatrixAlgebra(CombinatorialFreeModule): raise ValueError("list must be square") def convert(e_ij): - # We have to pass through vectors to convert from the - # given entry algebra to ours. Otherwise we can fail - # to convert an element of (for example) Octonions(QQ) - # to Octonions(AA). - return self.entry_algebra().from_vector(e_ij.to_vector()) + if e_ij in self.entry_algebra(): + # Don't re-create an element if it already lives where + # it should! + return e_ij + + try: + # This branch works with e.g. QQbar, where no + # to/from_vector() methods are available. + return self.entry_algebra()(e_ij) + except TypeError: + # We have to pass through vectors to convert from the + # given entry algebra to ours. Otherwise we can fail to + # convert an element of (for example) Octonions(QQ) to + # 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 _element_constructor_(self, elt): + if elt in self: + return self + else: + return self.from_list(elt)