PermutationGroupExamples¶

PermutationGroupExamples provides permutation groups for some classes of groups: symmetric, alternating, dihedral, cyclic, direct products of cyclic, which are in fact the finite abelian groups of symmetric groups called Young subgroups. Furthermore, Rubik`'s` group as permutation group of 48 integers and a list of sporadic simple groups derived from the atlas of finite groups.

abelianGroup: List PositiveInteger -> PermutationGroup Integer

`abelianGroup([n1, ..., nk])` constructs the abelian group that is the direct product of cyclic groups with order *`ni`*.

alternatingGroup: List Integer -> PermutationGroup Integer

`alternatingGroup(li)` constructs the alternating group acting on the integers in the list ``li``*, generators are in general the *n-2-cycle (``li``.3, …, ``li``.n) and the 3-cycle (``li``.1, ``li``.2, ``li``.3), if `n` is odd and product of the 2-cycle (``li``.1, ``li``.2) with n-2-cycle (``li``.3, …, ``li``.n) and the 3-cycle (``li``.1, ``li``.2, ``li``.3), if `n` is even. Note: duplicates in the list will be removed.

alternatingGroup: PositiveInteger -> PermutationGroup Integer

`alternatingGroup(n)` constructs the alternating group An acting on the integers 1, …, `n`, generators are in general the n-2-cycle (3, …, n) and the 3-cycle (1, 2, 3) if `n` is odd and the product of the 2-cycle (1, 2) with n-2-cycle (3, …, n) and the 3-cycle (1, 2, 3) if `n` is even.

cyclicGroup: List Integer -> PermutationGroup Integer

`cyclicGroup([i1, ..., ik])` constructs the cyclic group of order `k` acting on the integers i1, …, ik. Note: duplicates in the list will be removed.

cyclicGroup: PositiveInteger -> PermutationGroup Integer

`cyclicGroup(n)` constructs the cyclic group of order `n` acting on the integers 1, …, `n`.

dihedralGroup: List Integer -> PermutationGroup Integer

`dihedralGroup([i1, ..., ik])` constructs the dihedral group of order 2k acting on the integers out of i1, …, ik. Note: duplicates in the list will be removed.

dihedralGroup: PositiveInteger -> PermutationGroup Integer

`dihedralGroup(n)` constructs the dihedral group of order 2n acting on integers 1, …, `N`.

janko2: () -> PermutationGroup Integer

`janko2 constructs` the janko group acting on the integers 1, …, 100.

janko2: List Integer -> PermutationGroup Integer

`janko2(li)` constructs the janko group acting on the 100 integers given in the list *`li`*. Note: duplicates in the list will be removed. Error: if *`li`* has less or more than 100 different entries

mathieu11: () -> PermutationGroup Integer

`mathieu11 constructs` the mathieu group acting on the integers 1, …, 11.

mathieu11: List Integer -> PermutationGroup Integer

`mathieu11(li)` constructs the mathieu group acting on the 11 integers given in the list *`li`*. Note: duplicates in the list will be removed. error, if *`li`* has less or more than 11 different entries.

mathieu12: () -> PermutationGroup Integer

`mathieu12 constructs` the mathieu group acting on the integers 1, …, 12.

mathieu12: List Integer -> PermutationGroup Integer

`mathieu12(li)` constructs the mathieu group acting on the 12 integers given in the list *`li`*. Note: duplicates in the list will be removed Error: if *`li`* has less or more than 12 different entries.

mathieu22: () -> PermutationGroup Integer

`mathieu22 constructs` the mathieu group acting on the integers 1, …, 22.

mathieu22: List Integer -> PermutationGroup Integer

`mathieu22(li)` constructs the mathieu group acting on the 22 integers given in the list *`li`*. Note: duplicates in the list will be removed. Error: if *`li`* has less or more than 22 different entries.

mathieu23: () -> PermutationGroup Integer

`mathieu23 constructs` the mathieu group acting on the integers 1, …, 23.

mathieu23: List Integer -> PermutationGroup Integer

`mathieu23(li)` constructs the mathieu group acting on the 23 integers given in the list *`li`*. Note: duplicates in the list will be removed. Error: if *`li`* has less or more than 23 different entries.

mathieu24: () -> PermutationGroup Integer

`mathieu24 constructs` the mathieu group acting on the integers 1, …, 24.

mathieu24: List Integer -> PermutationGroup Integer

`mathieu24(li)` constructs the mathieu group acting on the 24 integers given in the list *`li`*. Note: duplicates in the list will be removed. Error: if *`li`* has less or more than 24 different entries.

rubiksGroup: () -> PermutationGroup Integer

`rubiksGroup constructs` the permutation group representing Rubic`'s` Cube acting on integers 10*i+j for 1 <= i <= 6, 1 <= j <= 8. The faces of Rubik`'s` Cube are labelled in the obvious way Front, Right, Up, Down, Left, Back and numbered from 1 to 6 in this given ordering, the pieces on each face (except the unmoveable center piece) are clockwise numbered from 1 to 8 starting with the piece in the upper left corner. The moves of the cube are represented as permutations on these pieces, represented as a two digit integer ij where `i` is the numer of theface (1 to 6) and `j` is the number of the piece on this face. The remaining ambiguities are resolved by looking at the 6 generators, which represent a 90 degree turns of the faces, or from the following pictorial description. Permutation group representing Rubic`'s` Cube acting on integers 10*i+j for 1 `<=` `i` `<=` 6, 1 `<=` `j` `<=8`. begin{verbatim}Rubik’s Cube: +—–+ +– B where: marks Side # : / U /|/ / / | F(ront) <-> 1 L --> +-----+ R| R(ight) <-> 2 | | + U(p) <-> 3 | F | / D(own) <-> 4 | |/ L(eft) <-> 5 +-----+ B(ack) <-> 6 ^ | DThe Cube's surface: The pieces on each side +---+ (except the unmoveable center |567| piece) are clockwise numbered |4U8| from 1 to 8 starting with the |321| piece in the upper left +—+—+—+ corner (see figure on the |781|123|345| left). The moves of the cube |6L2|8F4|2R6| are represented as |543|765|187| permutations on these pieces. +—+—+—+ Each of the pieces is |123| represented as a two digit |8D4| integer ij where i is the |765| # of the side ( 1 to 6 for +—+ F to B (see table above )) |567| and j is the # of the piece. |4B8| |321| +—+end{verbatim}

symmetricGroup: List Integer -> PermutationGroup Integer

`symmetricGroup(li)` constructs the symmetric group acting on the integers in the list ``li``*, generators are the cycle given by *``li``* and the 2-cycle *(``li``.1, ``li``.2). Note: duplicates in the list will be removed.

symmetricGroup: PositiveInteger -> PermutationGroup Integer

`symmetricGroup(n)` constructs the symmetric group Sn acting on the integers 1, …, `n`, generators are the n-cycle (1, …, n) and the 2-cycle (1, 2).

youngGroup: List Integer -> PermutationGroup Integer

`youngGroup([n1, ..., nk])` constructs the direct product of the symmetric groups Sn1, …, Snk.

youngGroup: Partition -> PermutationGroup Integer

`youngGroup(lambda)` constructs the direct product of the symmetric groups given by the parts of the partition lambda.