Modules over a General Algebra

Introduction

This section describes the functionality for modules over general algebras in Magma and is independent of the earlier chapters. A left-module over an algebra \(A\) is a module \(M\) together with a bilinear map \(A\times M\to M\). A right-module over \(A\) is a module \(M\) together with a bilinear map \(M\times A\to M\). Magma provides functionality for both kinds of modules.

Construction of Algebra Modules

Module(A, m): Alg, Map[SetCart, ModRng] -> ModAlg

For an algebra \(A\) this function creates a module over \(A\). If the module will be a left-module then \(m\) is a map from the Cartesian product \(A\times M\) to \(M\). If the module will be a right-module then \(m\) is a map from \(M\times A\) to \(M\). Here \(M\) has to be an \(R\)-module, where \(R\) is the coefficient field of \(A\).

Example: Natural Module of a Matrix Algebra (ex-dc2928)

We create the right-module over the full matrix algebra of \(3\times 3\) - matrices acting on its natural module.

> A:= MatrixAlgebra(Rationals(), 3);
> V:= RModule(Rationals(), 3);
> m:= map< CartesianProduct(V, A) -> V | t :-> t[1]*t[2] >;
> Module(A, m);
Right Module of Full Matrix Algebra of degree 3 over Rational Field

Run in calculator (opens in a new tab)

The Action of an Algebra Element

a ^ v: AlgElt, ModAlgElt -> ModAlgElt

Given an element \(v\) of a left-module over an algebra \(A\), and an element \(a\) of \(A\) computes the result of letting \(a\) act on \(v\).

v ^ a: ModAlgElt, AlgElt -> ModAlgElt

Given an element \(v\) of a right-module over an algebra \(A\) and an element \(a\) of \(A\) computes the result of letting \(a\) act on \(v\).

ActionMatrix(M, a): ModAlg, AlgElt -> AlgMatElt

Given a module \(M\) over an algebra \(A\) and an element \(a\) of \(A\) returns the matrix of the action of \(a\) on \(M\). If \(M\) is a left-module then the \(i\)-th column of this matrix contains the coordinates of the image of \(a\) acting on the \(i\)-th basis element of \(M\). If \(A\) is a right-module then the rows contain these coordinates.

Example: Action Matrices of Algebra Elements (ex-72e8cf)
> A:= MatrixAlgebra(Rationals(), 3);
> V:= RModule(Rationals(), 3);
> m:= map< CartesianProduct(V, A) -> V | t :-> t[1]*t[2] >;
> M:=Module(A, m);
> M.1^A.1;
M: (1 0 0)
> ActionMatrix(M, A.2);
[0 1 0]
[0 0 1]
[1 0 0]

Run in calculator (opens in a new tab)

Properties of an Algebra Module

IsLeftModule(M): ModAlg -> BoolElt

This returns true if the algebra module \(M\) is a left-module, and false if it is a right module.

IsRightModule(M): ModAlg -> BoolElt

This returns true if the algebra module \(M\) is a right-module, and false if it is a left module.

Dimension(M): ModAlg -> RngIntElt

The dimension of the algebra module \(M\).

Creation of Algebra Modules from other Algebra Modules

DirectSum(Q): SeqEnum -> ModAlg, SeqEnum, SeqEnum

Given a sequence \(Q\) of algebra modules (all defined over the same algebra, and all left (respectively right) modules), returns the module \(M\) that is the direct sum of the modules in \(Q\). Furthermore, two sequences of mappings are returned. The \(i\)-th element of the first sequence is the embedding of the \(i\)-th element of \(Q\) into \(M\). The \(i\)-th element of the second sequence is the projection of \(M\) onto the \(i\)-th element of \(Q\).

SubalgebraModule(B, M): Alg, ModAlg -> ModAlg

Given an algebra module \(M\) over the algebra \(A\), and a subalgebra \(B\) of \(A\), return \(M\) as a \(B\)-module.

ModuleWithBasis(Q): SeqEnum -> ModAlg

Given a sequence \(Q\) containing the elements of a particular basis of an algebra module \(M\), create an algebra module that is isomorphic to \(M\), but with basis \(Q\). (Or, more precisely, the basis vectors of the module \(V\) that is returned are in bijection with \(Q\). The action of an algebra element on the \(i\)-th basis vector of \(V\) is computed by computing it on the \(i\)-th vector in \(Q\) and expressing the result as a linear combination of the elements of \(Q\). The resulting coordinates are used to form the corresponding element of \(V\).) This can be used to compute the action of algebra elements with respect to a given basis of \(M\).

Example: Direct Sums of Algebra Modules (ex-720705)

Run in calculator (opens in a new tab)

> A:= MatrixAlgebra(Rationals(), 3);
> V:= RModule(Rationals(), 3);
> m:= map< CartesianProduct(V, A) -> V | t :-> t[1]*t[2] >;
> M:=Module(A, m);
> N:=DirectSum([ M, M ]);
> ActionMatrix(N, A.1);
[1 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]
[0 0 0 1 0 0]
[0 0 0 0 0 0]
[0 0 0 0 0 0]
> W:= ModuleWithBasis([ M.1+M.2+M.3, M.2+M.3, M.3 ]);
> ActionMatrix(W, A.1);
[ 1 -1  0]
[ 0  0  0]
[ 0  0  0]

Run in calculator (opens in a new tab)

sub< M | S >: ModAlg, [ModAlgElt] -> ModAlg
sub< M | e1, ..., en >: ModAlg, ModAlgElt, ..., ModAlgElt -> ModAlg

Return the submodule of \(M\) containing the elements in the sequence \(S\) or the elements \(e1\), \(\ldots\), \(en\).

quo< M | S >: ModAlg, [ModAlgElt] -> ModAlg
quo< M | e1, ..., en >: ModAlg, ModAlgElt, ..., ModAlgElt -> ModAlg
quo< M | S >: ModAlg, ModAlg -> ModAlg

Construct the quotient module of \(M\) by the submodule \(S\) of \(M\), the submodule containing the elements in the sequence \(S\) or the elements \(e1, ..., en\).