Let M be an R-module. Magma allows one to create the lattice L of all submodules of M if this is not too large. Various properties of the lattice L can then be examined. The elements of L are called submodule-lattice elements and are numbered from 1 to n where n is the cardinality of L. One can do various lattice operations on these elements like intersection, etc. without doing any actual module computations. Most of the interesting module-theoretical information about M and its submodules can then be obtained by analyzing L. Given an element of L, one can easily create the submodule S of M corresponding to it and one can also create the element of L corresponding to a submodule of M.

Subsections

• Creating Lattices
• Operations on Lattices
• Operations on Lattice Elements

Create the lattice L of submodules of M.

    Limit: RngIntElt                    Default: 0

If a limit n is provided, only up to n submodules are calculated, and the second return value indicates whether the returned lattice L contains all of the submodules of M.

Attempt to create the lattice L of submodules of M with limit N. If the lattice has more than N submodules, abort and return false. Otherwise, return true and the full submodule lattice L.

Turn on verbose printing for the submodule lattice algorithm. The level i can be 2 for maximal printing or 1 for moderate printing. The algorithm works down a composition series of the module and each level considered is mentioned.

> // Set M to be the Permutation Module of CyclicGroup(6) over GF(3)
> M := PermutationModule(CyclicGroup(6), GF(3));
> // Set verbosity to level 1
> SetVerbose("SubmoduleLattice", 1);
> // Create lattice L
> L := SubmoduleLattice(M);
Submodule Lattice; Dimension: 6, Composition length: 6
Starting level 4; Current number of modules: 2
Starting level 3; Current number of modules: 3
Starting level 2; Current number of modules: 6
Starting level 1; Current number of modules: 9
Starting level 0; Current number of modules: 12
Change basis time: 0.010
Jacobson radical time: 0.060
Complement time: 0.070
Total time: 0.250
> // See how many submodules M has
> #L;
16

In the following, L is the lattice of submodules for a module M.

# L : SubModLat -> RngIntElt

The cardinality of L, i.e. the number of submodules of M.

Create the i-th element of the lattice L. The number i is insignificant (i.e. the elements of L are not numbered in any special way), but this allows one to uniquely identify each element of the lattice L.

L ! S: SubModLat, ModRng -> SubModLatElt

Create the element of the lattice L corresponding to the submodule S of M.

Create the bottom of the lattice L, i.e. the element of L corresponding to the zero-submodule of M. If the lattice was created with a limit on the number of submodules and the lattice is partial, the bottom of the lattice may not be the zero submodule.

Create a random element of L.

Create the top of the lattice L, i.e. the element of L corresponding to M.

In the following, L is the lattice of submodules for a module M. Elements of L are identified with the integers [1..#L] but not in any particular order.

IntegerRing() ! e : SubModLatElt -> RngIntElt

The integer corresponding to lattice element e.

The sum of lattice elements e and f, i.e. the lattice element corresponding to the sum of the modules corresponding to e and f.

The dimension of the submodule of M corresponding to e.

True if and only if lattice elements e and f are equal.

The Jacobson radical of e, i.e. the lattice element corresponding to the Jacobson radical of the submodule corresponding to e.

The maximal submodules of e, returned as a set of lattice elements.

The intersection of lattice elements e and f.

The maximal supermodules of e, returned as a set of lattice elements.

The submodule of M corresponding to the element e of the lattice L.

The morphism from the module corresponding to e to M.

True iff e is under f in the lattice L, i.e. the module corresponding to e is a submodule of the module corresponding to f.

> // Create M and L as above
> M := PermutationModule(CyclicGroup(6), GF(3));
> L := SubmoduleLattice(M);
> // See how many submodules M has
> #L;
16
> // Create top T and bottom B of lattice L
> T := Top(L);
> B := Bottom(L);
> T;
1
> B;
13
> // Check that element of L corresponding to M is T
> L ! M;
1
> (L ! M) eq T;
true
> // Check that module corresponding to B is zero-submodule of M
> Module(B);
GModule of dimension 0 with base ring GF(3)
> // Find minimal supermodules (immediate parents) of B
> S := MinimalSupermodules(B);
> S;
{ 14, 10 }
> // Note that these modules have dimension 1 each and check their morphisms to M
> Module(S ! 14);
GModule of dimension 1 with base ring GF(3)
> Module(S ! 10);
GModule of dimension 1 with base ring GF(3)
> Dimension(S ! 14);
1
> Morphism(S ! 14);
[1 1 1 1 1 1]
> Morphism(S ! 10);
[1 2 1 2 1 2]
> // Set A to the sum of these elements
> A := S ! 14 + S ! 10;
> A;
7
> // Note that A has dimension 2 and its morphism is the sum of the previous
> Dimension(A);
2
> Morphism(A);
[1 0 1 0 1 0]
[0 1 0 1 0 1]
> // Check that A contains the previous lattice elements
> MaximalSubmodules(A);
{ 14, 10 }
> S!14 subset A;
true
> // Set A to be a maximal submodule of the lattice L
> MaximalSubmodules(T);  
{ 2, 6 }
> A := L ! 2;
> Dimension(A);   
5
> Morphism(A);
[1 0 0 0 0 1]
[0 1 0 0 0 2]
[0 0 1 0 0 1]
[0 0 0 1 0 2]
[0 0 0 0 1 1]
> // Construct submodule S of M corresponding to A
> S := Module(A);
> S;
GModule S of dimension 5 with base ring GF(3)
> // Form Jacobson radical of S using module machinery
> J := JacobsonRadical(S);
> J;
GModule J of dimension 3 with base ring GF(3)
> // Find the element of L corresponding to J
> L ! J;
4
> // Note that we can find this much more quickly by just asking for the
> // Jacobson radical of A as another lattice element
> JacobsonRadical(A);
4