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
+-----+-----+
l[i][j] += v*e
return l
- def __repr__(self):
+ def _repr_(self):
r"""
Display this matrix as a table.
EXAMPLES::
- sage: MatrixAlgebra(ZZ,ZZ,2).zero()
+ sage: MatrixAlgebra(2,ZZ,ZZ).zero()
+---+---+
| 0 | 0 |
+---+---+
EXAMPLES::
- sage: A = MatrixAlgebra(ZZ,ZZ,2)
+ sage: A = MatrixAlgebra(2,ZZ,ZZ)
sage: A([[1,2],[3,4]]).list()
[1, 2, 3, 4]
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]
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()
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
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()
# 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()
- basis_indices = [(i,j,e) for i in range(n)
- for j in range(n)
- for e in 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 j in range(n)
+ for i in range(n)
+ for e in entry_basis]
super().__init__(scalars,
basis_indices,
"""
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):
+ 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:
- return self.monomial((i,l,e1*e2))
+ # 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()
EXAMPLES::
- sage: A = MatrixAlgebra(QQbar, ZZ, 2)
+ sage: A = MatrixAlgebra(2, QQbar, ZZ)
sage: A.from_list([[0,I],[-I,0]])
+----+---+
| 0 | I |
return self
else:
return self.from_list(elt)
-
-
-class HurwitzMatrixAlgebraElement(MatrixAlgebraElement):
- def is_hermitian(self):
- r"""
-
- SETUP::
-
- sage: from mjo.matrix_algebra import HurwitzMatrixAlgebra
-
- EXAMPLES::
-
- sage: A = HurwitzMatrixAlgebra(QQbar, ZZ, 2)
- sage: M = A([ [ 0,I],
- ....: [-I,0] ])
- sage: M.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 HurwitzMatrixAlgebra(MatrixAlgebra):
- Element = HurwitzMatrixAlgebraElement
-
- def one(self):
- r"""
- SETUP::
-
- sage: from mjo.matrix_algebra import HurwitzMatrixAlgebra
-
- """
- return sum( (self.monomial((i,i,self.entry_algebra().one()))
- for i in range(self.nrows()) ),
- self.zero() )
-
-
projects / sage.d.git / blobdiff