Group Theory Algorithms

This tutorial introduces some basic algorithms for computing with finite permutation groups, other than those introduced in "Permutation Groups".

Coset Representatives

A subgroup H of a group G partitions the list of elements of G into disjoint subsets, called cosets of H in G, such that H is one of them and the rest are of the form H⊙g for some element g of G, with ⊙ denoting the product law. A way of identifying the coset is by selecting a representative from each coset, for example the smallest element in the coset.

Computation of a canonical coset representative.

Take two permutations and the group generated by them:

group=PermutationGroup[{Cycles[{{1,7},{2,4,9},{3,8,10}}],Cycles[{{1,9,7,6},{2,4},{3,10,8,5}}]}];
GroupOrder[group]

This group partitions (Subscript[S, 10]) into 210 disjoint cosets:

10!/GroupOrder[group]

Given any other permutation, it is possible to list the elements of its associated right coset:

perm=Cycles[{{1,9,6,7,10,8,2,5,4,3}}];

Length[rightcosetlist=PermutationProduct[#,perm]&/@GroupElements[group]]

The canonical representative of the right coset is taken to be the least permutation in the order defined by images:

First@Sort[rightcosetlist,LessEqual]

Construct the canonical representative directly, without listing the permutations in the coset:

rep=RightCosetRepresentative[group,perm]

Check that this also agrees with the minimum-rank permutation (in the group (Subscript[S, 10])) in the coset:

rankslist=GroupElementPosition[SymmetricGroup[10],rightcosetlist];

Min[rankslist]

Position[rankslist,%]

rightcosetlist[[6461]]===rep

Take two permutations and construct the group generated by them:

group=PermutationGroup[{Cycles[{{1,28,5,3,13,25,27,8,4,17,11,29,7,2,21,23,10,6},{9,16,22,30,18,15,20,19,14}}],Cycles[{{1,4},{2,5,3}}]}];

This is the number of cosets induced by this group on (Subscript[S, 30]):

30!/GroupOrder[group]

For any permutation belonging to the group itself, the canonical representative is always the identity permutation:

RandomPermutation[group]

RightCosetRepresentative[group,%]

Now take some random permutation in (Subscript[S, 30]):

SeedRandom[1234];perm=RandomPermutation[30]

This is its coset representative:

rep=RightCosetRepresentative[group,perm]

Check that the representative indeed belongs to the same coset. This will be the case if there exists a permutation h in the original group such that perm==(RefLink[PermutationProduct, paclet:ref/PermutationProduct])[h,rep]:

h=PermutationProduct[perm,InversePermutation[rep]]

GroupElementQ[group,h]

Centralizer

The centralizer C of an element g in a group G is the subgroup of elements of G that commute with g.

Computation of centralizers.

Take the group:

group=PermutationGroup[{Cycles[{{1,7,2},{3,10,5,4},{6,8,9}}],Cycles[{{1,4,2,5,3}}]}];
GroupOrder[group]

Choose a permutation:

perm=Cycles[{{3,7},{4,5},{6,8,10,9}}];

This is its centralizer in the group:

centralizer=GroupCentralizer[group,perm]

centralizerlist=GroupElements[centralizer]

Check the result by direct computation of all commutators in the group:

grouplist=GroupElements[group];

commutator[a_,b_]:=PermutationProduct[InversePermutation[a],InversePermutation[b],a,b]

Flatten@Position[commutator[#,perm]&/@grouplist,Cycles[{}]]

centralizerlist===grouplist[[%]]

Setwise Stabilizer

The (pointwise) stabilizer of a group G is the subgroup of elements of G fixing a set of one or several points of the domain of action. This concept can be extended to the setwise stabilizer, which is the subgroup of elements either fixing those points or moving them among themselves.

Computation of setwise stabilizers.

Take the group again:

group=PermutationGroup[{Cycles[{{1,7,2},{3,10,5,4},{6,8,9}}],Cycles[{{1,4,2,5,3}}]}];
GroupOrder[group]

This is the list of points to be stabilized:

list={3,7,1,9};

setwisestabilizer=GroupSetwiseStabilizer[group,list]

The action of the permutations of the setwise stabilizer changes the individual elements of the list, but always to other elements of the list:

GroupOrbits[setwisestabilizer,{list}]

Compare with the (pointwise) stabilizer of the same list of elements. It only contains permutations stabilizing all elements of the list:

pointwisestabilizer=GroupStabilizer[group,list]

GroupOrbits[pointwisestabilizer,{list}]