SubgroupLattice - Maple Help
For the best experience, we recommend viewing online help using Google Chrome or Microsoft Edge.

Online Help

All Products    Maple    MapleSim

Home : Support : Online Help : Mathematics : Group Theory : SubgroupLattice





construct the lattice of subgroups of a group


Calling Sequence





Calling Sequence


convert(L, out)

SubgroupLattice(G, output = out)




a group data structure



the result returned by the SubgroupLattice command



one of the keywords list, maximalsubgroups, conjugacyclasses, layers, or graph (possibly with indices described below)



The subgroups of a group form a lattice under inclusion. The SubgroupLattice command computes this lattice and returns a data structure that can be interrogated about some of its properties.


The subgroup lattice displays the group G that was its input, the number of conjugacy classes of subgroups (since the subgroups arise from the computation in conjugacy classes), and the total number of subgroups.


All of the ways to access the information contained in the subgroup lattice L use the convert command as convertL,out, for various values of out. (These are special conversions that are only valid for subgroup lattice data structures, not for general Maple objects.)  Alternatively, if you need only one of the types of output, you can bypass using the convert command by using the corresponding output = out option.


convert(L, 'list') : return a list of subgroups


This returns a list of all subgroups. All subgroups have G as their supergroup.


convert(L, 'maximalsubgroups') : return a list of maximal subgroups


This is similar to convert(L, 'list'), but it returns only those subgroups that are maximal subgroups.


convert(L, 'conjugacyclasses') : return a list of subgroups, grouped by conjugacy class


This returns a list of lists of subgroups. The subgroups occur in the same order as above, but they are grouped by conjugacy class.


convert(L, 'layers') : return a list of conjugacy classes, grouped by layer


The lattice of subgroups is organized naturally in a number of layers, with the trivial subgroup at the bottom and G at the top: the layers are characterized by the number of (not necessarily distinct) prime factors in the order of its subgroups. This calling sequence returns a list of lists of lists of subgroups; the subgroups are first grouped into conjugacy classes, and then the conjugacy classes are grouped into layers.


The conjugacy classes occur in the same order as above. Within a layer, the conjugacy classes are sorted by the order of the subgroup: conjugacy classes of smaller subgroups before conjugacy classes of larger subgroups. For conjugacy classes of equally big subgroups, conjugacy classes with more subgroups in them come before smaller conjugacy classes. Remaining ties are broken arbitrarily.


convert(L, 'list[zuppos]'), convert(L, 'list[group, zuppos]'), convert(L, 'layer[zuppos]'), convert(L, 'maximalsubgroups[group]'), etc : return alternative or additional information for each subgroup


The algorithm for generating the subgroup lattice uses special generating sets for the subgroups, consisting of particular representatives for all cyclic subgroups of G of prime power order, or zuppos (the German-language acronym used for such subgroups). These generating sets can be used to test inclusion relations quickly: H1 is a subgroup of H2 if and only if the set of zuppo representatives in H1 is a subset of the set of zuppo representatives in H2.


Using the indexed forms of the conversions above allows you to access this additional information. This can be used with conversions to list, maximalsubgroups, conjugacyclasses, and layers. You can supply the index zuppos to obtain the set of zuppo representatives of H instead of each subgroup H. You can also supply both of the indices group and zuppos to obtain a list of both H itself and the set of zuppo representatives in H. Supplying no indices is equivalent to supplying just the index group.


Grouping of the resulting information is as before:


'list[...]' and 'maximalsubgroups[...]' will return a list where each element is the requested information for a single subgroup;


'conjugacyclasses[...]' will return a list of lists corresponding to conjugacy classes, where each element of a sublist is the requested information for a single subgroup;


'layers[...]' will return a list of lists of lists corresponding to layers, where each element of the sub-sublist is the requested information for a single subgroup.


For instance, convert(L, 'layers[group, zuppos]') will return a list of layers; each layer is represented by a list of conjugacy classes; each conjugacy class is represented by a list of subgroups; and each subgroup is represented by a two-element list of the subgroup data structure itself and its set of zuppo generators.


convert(L, 'graph') : convert to a GraphTheory graph data structure


This converts the subgroup lattice to a graph data structure as used by the GraphTheory package. The vertices are the numbers 1 through n, where n is the number of subgroups of G; the number i corresponds to the ith subgroup occurring in convert(L, 'list'). The vertices are drawn in horizontal layers corresponding to the layer structure described above and there is an edge from each vertex to each of its covering vertices (that is, its immediate parents in the lattice). Furthermore, in each layer, conjugacy classes of subgroups have their vertices closer together than for subgroups that are not conjugate.


convert(L, 'graph[weighted]') : convert to a GraphTheory weighted graph data structure


This results in a data structure very similar to convert(L, 'graph'), but the edge from subgroup H to subgroup K will have as its associated weight the index K : H - that is, the number of cosets of H in K, or the ratio of the group orders of K to H.


convert(L, 'graph[directed]') or convert(L, 'graph[weighted, directed]') : convert to a GraphTheory directed graph data structure


This results in a data structure very similar to convert(L, 'graph'), but the graph is directed. Each arc runs from a smaller subgroup to the bigger subgroup - that is, to a higher layer.


The algorithm used does not find any perfect subgroups of G, other than potentially G itself, its soluble residual, and the trivial group. If the soluble residual of G is of size at least 360, then it may contain other nontrivial perfect subgroups. These will not be found by the algorithm.



Consider a group of order 48.





sgl1subgroup lattice18 conjugacy classes36 subgroups



graph1Graph 1: an undirected graph with 36 vertices and 83 edge(s)



The bottom layer is only the trivial subgroup. The layer above that (which contains all subgroups of prime order) contains only two subgroups. Since there must be elements of order 2 and of order 3 in a group of order 48 by Sylow's theorems, there is only a single subgroup of order 2 (with a single element of order 2) and a single subgroup of order 3 (with two elements of order 3). These subgroups correspond to groups 2 and 3 in the list below.








From how sgl1 prints, we can already see the number of subgroups and conjugacy classes, but here is how we can obtain them programmatically.








To obtain the maximum amount of information, use the command below.





The following corresponds to the first group in the first conjugacy class in the third layer - subgroup 4 in the diagram above:




We see that sg4 is a list of two elements: a group and a set of elements. These elements are the zuppo representatives that were chosen for the lattice construction. We now take all subgroups in the layer above it:


and find which ones contain all zuppo representatives of sg4:




These correspond exactly to the neighbors of subgroup 4 in the fourth layer of the diagram above, once we add the offset 17 for the number of subgroups in the lower three layers.

We can get the same type of information for a Cayley table group:





g2 < a Cayley table group with 24 elements >



graph2Graph 2: an undirected weighted graph with 10 vertices and 14 edge(s)



For many groups, the maximal subgroups are exactly the ones in the layer just below the topmost one. For the following group, this is not the case.





sgl3subgroup lattice7 conjugacy classes15 subgroups






The alternating group on 6 letters is the smallest group for which the algorithm does not find all subgroups. (Missing are two conjugacy classes of 6 perfect subgroups each, all isomorphic to the alternating group on 5 letters.)


subgroup lattice of A620 conjugacy classes489 subgroups




The GroupTheory[SubgroupLattice] command was introduced in Maple 17.


For more information on Maple 17 changes, see Updates in Maple 17.

See Also