# 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 ^ | DThe 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*.