from sage.misc.table import table from sage.categories.magmatic_algebras import MagmaticAlgebras from sage.misc.cachefunc import cached_method from sage.combinat.free_module import CombinatorialFreeModule from sage.modules.with_basis.indexed_element import IndexedFreeModuleElement class MatrixAlgebraElement(IndexedFreeModuleElement): def nrows(self): return self.parent().nrows() ncols = nrows @cached_method def rows(self): r""" SETUP:: sage: from mjo.matrix_algebra import MatrixAlgebra EXAMPLES:: sage: M = MatrixAlgebra(2, QQbar,RDF) sage: A = M.monomial((0,0,1)) + 4*M.monomial((0,1,1)) sage: A +-----+-----+ | 1.0 | 4.0 | +-----+-----+ | 0 | 0 | +-----+-----+ sage: A.rows() [[1.0, 4.0], [0, 0]] """ zero = self.parent().entry_algebra().zero() l = [[zero for j in range(self.ncols())] for i in range(self.nrows())] for (k,v) in self.monomial_coefficients().items(): (i,j,e) = k l[i][j] += v*e return l def _repr_(self): r""" Display this matrix as a table. The SageMath Matrix class representation is not easily reusable, but using a table fakes it. SETUP:: sage: from mjo.matrix_algebra import MatrixAlgebra EXAMPLES:: sage: MatrixAlgebra(2,ZZ,ZZ).zero() +---+---+ | 0 | 0 | +---+---+ | 0 | 0 | +---+---+ TESTS:: sage: MatrixAlgebra(0,ZZ,ZZ).zero() [] """ if self.nrows() == 0 or self.ncols() == 0: # Otherwise we get a crash or a blank space, depending on # how hard we work for it. This is what MatrixSpace(..., # 0) returns. return "[]" return table(self.rows(), frame=True)._repr_() def list(self): r""" Return one long list of this matrix's entries. SETUP:: sage: from mjo.matrix_algebra import MatrixAlgebra EXAMPLES:: sage: A = MatrixAlgebra(2,ZZ,ZZ) sage: A([[1,2],[3,4]]).list() [1, 2, 3, 4] """ return sum( self.rows(), [] ) def __getitem__(self, indices): r""" SETUP:: sage: from mjo.matrix_algebra import MatrixAlgebra EXAMPLES:: sage: M = MatrixAlgebra(2,ZZ,ZZ)([[1,2],[3,4]]) sage: M[0,0] 1 sage: M[0,1] 2 sage: M[1,0] 3 sage: M[1,1] 4 """ i,j = indices d = self.monomial_coefficients() A = self.parent().entry_algebra() return A.sum( d[k]*k[2] for k in d if k[0] == i and k[1] == j ) def trace(self): r""" Return the sum of this matrix's diagonal entries. SETUP:: sage: from mjo.matrix_algebra import MatrixAlgebra EXAMPLES: The trace (being a sum of entries) belongs to the same algebra as those entries, and NOT the scalar ring:: sage: entries = MatrixSpace(ZZ,2) sage: scalars = ZZ 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] """ d = self.monomial_coefficients() A = self.parent().entry_algebra() return A.sum( d[k]*k[2] for k in d if k[0] == k[1] ) def matrix_space(self): r""" SETUP:: sage: from mjo.matrix_algebra import MatrixAlgebra TESTS:: sage: entries = QuaternionAlgebra(QQ,-1,-1) sage: M = MatrixAlgebra(3, entries, QQ) sage: M.random_element().matrix_space() == M True """ return self.parent() class MatrixAlgebra(CombinatorialFreeModule): r""" An algebra of ``n``-by-``n`` matrices over an arbitrary scalar ring whose entries come from a magmatic algebra that need not be the same as the scalars. The usual matrix spaces in SageMath don't support separate spaces for the entries and the scalars; in particular they assume that 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, 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: self.sum( (self.monomial((i,i,entry_one)) for i in range(self.nrows()) ) ) if "Associative" in entry_algebra.category().axioms(): category = category.Associative() self._nrows = n # Since the scalar ring is (say) real but the entries are not, # 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. self._entry_algebra = entry_algebra # 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_basis] super().__init__(scalars, basis_indices, category=category, prefix=prefix, bracket='(') def _repr_(self): return ("Module of %d by %d matrices with entries in %s" " over the scalar ring %s" % (self.nrows(), self.ncols(), self.entry_algebra(), self.base_ring()) ) def entry_algebra(self): r""" Return the algebra that our elements' entries come from. """ 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 def product_on_basis(self, mon1, mon2): 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 | +-----+---+ """ (i,j,e1) = mon1 (k,l,e2) = mon2 if j == k: # 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() def from_list(self, entries): r""" Construct an element of this algebra from a list of lists of entries. SETUP:: sage: from mjo.hurwitz import ComplexMatrixAlgebra EXAMPLES:: 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) ncols = 0 if nrows > 0: ncols = len(entries[0]) if (not all( len(r) == ncols for r in entries )) or (ncols != nrows): raise ValueError("list must be square") def convert(e_ij): 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()) 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: return self else: return self.from_list(elt)