A permutation is a bijective mapping from the set$\left\{1\,2\,\dots \,n\right\}$ to itself, for some positive integer $n$.

The set of all such permutations forms the symmetric group of degree $n$, and subgroups of symmetric groups are permutation groups.

Permutations are typically represented as products of disjoint cycles, each of which is an orbit of the permutation.  This is a list of the form$\left[c_1\,c_2\,\dots \,c_k\right]$ in which each $c_i$ is itself a list$\left[i_1\,i_2\,\dots \,i_m\right]$ representing a cycle of the form$i_1\mapsto i_2\mapsto i_m\mapsto i_1$ .

The Perm constructor creates a permutation, given a specification of its disjoint cycle structure in the form of a list of lists.  You can also use a permutation list, which is just the representation of the permutation as a list L of points in which L[ i ] specifies the image of i under the permutation.

The image of a point i under a permutation p is returned by the indexed expression p[ i ].  You can also use the procedure PermApply for this purpose. The expression PermApply( p, i ) returns the image of i under the permutation p.  The PermApply command is primarily intended for use with procedures such as map and map2.

The procedures described in this help page operate on permutation objects returned by the Perm constructor, and are part of the GroupTheory package (whereas Perm itself is global).

The degree of a permutation is the number of points upon which it acts. The PermDegree( p ) command returns the degree of the permutation p.

The product of two permutations a and b can be computed by using the PermProduct( a, b ) command.  Note that permutation multiplication is non-commutative; that is, in general, PermProduct( a, b ) and PermProduct( b, a ) are different. You can also compute the product of the permutations a and b by using the non-commutative multiplication operator `.`, as a . b.

The inverse of the permutation p is computed using the command PermInverse( p ).  It can also be computed using the syntax p^(-1).

An integral power of a permutation p is computed using the command PermPower( p, n ), which computes the n-th power of p, defined in the natural way. You can also use the syntax p^n.

The PermOrder( p ) command computes the order of a permutation p. That is the least positive integer k for which p^k is the identity.

The identity permutation can be constructed using the expression Perm( [] ).

Every permutation can be written as a product of transpositions, permutations which interchange exactly two points. Although this factorization is not unique, the number of transpositions in such a product is either always even or always odd. A permutation is said to be even (respectively, odd) according to whether is has a decomposition as a product of an even (respectively, odd) number of transpositions. An even permutation is defined to have parity equal to $1$, while an odd permutation is defined to have parity equal to $\mathrm{-1}$. (This defines a homomorphism from the full symmetric group onto the multiplicative group $\left\{\mathrm{-1}\,1\right\}$, whose kernel, consisting of the even permutations, is the alternating group.) The parity of a permutation p is returned by the PermParity( p ) command.

A transposition is a particular example of an involution, that is, an element of order $2$. An involution is its own inverse. The PermIsInvolution( p ) command returns true if the permutation p is an involution, and false otherwise.

The left quotient $p^{-1}\dot{}q$ of permutations p and q is computed using the PermLeftQuotient( p, q ) command.  Similarly, the command PermRightQuotient( p, q ) computes the right quotient $p\dot{}{q}^{-1}$ of p and q.

The conjugate $p^q$ of $p$ by $q$ is defined to be $p^{-1}\dot{}q\dot{}p$ and may be computed by the PermConjugate( p, q ) command. The syntax p^q is also available for this computation.

The commutator of permutations p and q is defined to be the permutation $p^{-1}\dot{}{q}^{-1}\dot{}p\dot{}q$ and is computed using the command PermCommutator( p, q ).

The PermCycleType( p ) command returns the cycle type of the permutation p. This is defined to be the list consisting of the lengths of the cycles of p, in sorted order.

A point $i$ is fixed by a permutation $p$ if $i^p=i$; its complement (in the domain of the permutation) is called the support of $p$. The set of fixed points of a permutation p is returned by the command PermFixed( p ), and the support of p is returned by the command PermSupport( p ). The smallest positive integer in the support of p is returned by the command PermMinSupport( p ), while the command PermMaxSupport( p ) returns the largest member of the support of p.

If an invariant subset dom of a permutation p exists (i.e., a union of cycles of p), then the restriction of p to dom is a permutation that can be computed by using the PermRestrict( p, dom ) command.

The PermShift( p, n ) command returns a permutation conjugate to p but acting on the result of adding the integer n to each point of the support of p, provided that the result is a set of positive integers.

The conjugacy class of an even permutation p in the symmetric group to which it belongs may or may not split into two conjugacy classes in the alternating group. The PermAltSplit( p ) command returns the value true if this happens, and returns the value false otherwise.

The PermCompare( a, b ) command compares two permutations a and b, according to the lexicographic plus degree ordering.  The PermCompare command is intended for use as the second argument in a a call to sort on a list of permutations.

To generate a random permutation of degree n, use the PermRandom( n ) command. Because the resulting permutation p is randomly produced, the degree of p will be at most n, but may not be exactly n. To ensure that the resulting permutation p has degree exactly equal to n, use the exact = true (or just exact) option.

$a≔\mathrm{Perm}\left(\left[\left[1\,2\right]\,\left[3\,4\,5\right]\right]\right)$

$a≔\left(1\,2\right)\left(3\,4\,5\right)$

$a\left[1\right]$

$2$

$a\left[2\right]$

$1$

$a\left[3\right]$

$4$

$a\left[4\right]$

$5$

$a\left[5\right]$

$3$

$b≔\mathrm{Perm}\left(\left[\left[1\,3\right]\,\left[2\,6\right]\right]\right)$

$b≔\left(1\,3\right)\left(2\,6\right)$

$\mathrm{with}\left(\mathrm{GroupTheory}\right)\:$

$\mathrm{PermApply}\left(a\,2\right)$

$1$

$\mathrm{PermDegree}\left(a\right)$

$5$

$\mathrm{PermDegree}\left(b\right)$

$6$

$\mathrm{PermProduct}\left(a\,b\right)$

$\left(1\,6\,2\,3\,4\,5\right)$

$a·b$

$\left(1\,6\,2\,3\,4\,5\right)$

$\mathrm{PermProduct}\left(b\,a\right)$

$\left(1\,4\,5\,3\,2\,6\right)$

$\mathrm{PermLeftQuotient}\left(a\,b\right)$

$\left(1\,6\,2\,3\,5\,4\right)$

$a^{-1}·b$

$\left(1\,6\,2\,3\,5\,4\right)$

$\mathrm{PermRightQuotient}\left(a\,b\right)$

$\left(1\,6\,2\,3\,4\,5\right)$

$a·b^{-1}$

$\left(1\,6\,2\,3\,4\,5\right)$

$\mathrm{PermPower}\left(a\,10\right)$

$\left(3\,4\,5\right)$

$a^{10}$

$\left(3\,4\,5\right)$

$\mathrm{PermConjugate}\left(a\,b\right)$

$\left(1\,4\,5\right)\left(3\,6\right)$

$a^b$

$\left(1\,4\,5\right)\left(3\,6\right)$

$\mathrm{PermCommutator}\left(a\,b\right)$

$\left(1\,2\,4\,6\,3\right)$

$\mathrm{PermParity}\left(a\right)$

$\mathrm{-1}$

$\mathrm{PermParity}\left(b\right)$

$1$

$\mathrm{PermOrder}\left(a\right)$

$6$

$\mathrm{PermOrder}\left(b\right)$

$2$

$\mathrm{evalb}\left(b·b=\mathrm{Perm}\left(\left[\right]\right)\right)$

$\mathrm{true}$

$\mathrm{PermInverse}\left(a\right)$

$\left(1\,2\right)\left(3\,5\,4\right)$

$\mathrm{PermInverse}\left(b\right)$

$\left(1\,3\right)\left(2\,6\right)$

$\mathrm{PermIsInvolution}\left(b\right)$

$\mathrm{true}$

$\mathrm{PermCycleType}\left(a\right)$

$\left[2\,3\right]$

$\mathrm{PermCycleType}\left(b\right)$

$\left[2\,2\right]$

$\mathrm{PermSupport}\left(a\right)$

$\left\{1\,2\,3\,4\,5\right\}$

$\mathrm{PermSupport}\left(b\right)$

$\left\{1\,2\,3\,6\right\}$

$\mathrm{PermMinSupport}\left(b\right)$

$1$

$\mathrm{PermMaxSupport}\left(b\right)$

$6$

$c≔\mathrm{PermRestrict}\left(b\,\left\{2\,6\right\}\right)$

$c≔\left(2\,6\right)$

$\mathrm{PermShift}\left(c\,-1\right)$

$\left(1\,5\right)$

$\mathrm{PermShift}\left(c\,3000\right)$

$\left(3002\,3006\right)$

$\mathrm{PermShift}\left(c\,-3\right)$

Error, (in Perm:-extShift) invalid shift value -3

$\mathrm{PermFixed}\left(b\right)$

$\left\{4\,5\right\}$

$a≔\mathrm{Perm}\left(\left[\left[1\,2\,3\right]\right]\right)\;$$b≔\mathrm{Perm}\left(\left[\left[1\,2\right]\right]\right)\;$$c≔\mathrm{Perm}\left(\left[\left[1\,2\,3\right]\,\left[4\,5\right]\right]\right)$

$a≔\left(1\,2\,3\right)$

$b≔\left(1\,2\right)$

$c≔\left(1\,2\,3\right)\left(4\,5\right)$

$\mathrm{PermCompare}\left(a\,b\right)$

$\mathrm{false}$

$\mathrm{PermCompare}\left(a\,c\right)$

$\mathrm{true}$

$\mathrm{sort}\left(\left[a\,b\,c\right]\,\mathrm{PermCompare}\right)$

$\left[\left(1\,2\right)\,\left(1\,2\,3\right)\,\left(1\,2\,3\right)\left(4\,5\right)\right]$

$p≔\mathrm{PermRandom}\left(12\right)$

$p≔\left(1\,9\,11\,3\,7\,6\,12\,10\,2\,5\,4\right)$

$p≔\mathrm{PermRandom}\left(12\,'\mathrm{exact}'\right)$

$p≔\left(2\,10\,11\,5\,3\,12\,4\,7\,8\,6\,9\right)$

$\mathrm{PermDegree}\left(p\right)$

$12$

The GroupTheory[PermApply], GroupTheory[PermAltSplit], GroupTheory[PermDegree], GroupTheory[PermOrder], GroupTheory[PermParity], GroupTheory[PermProduct], GroupTheory[PermInverse], GroupTheory[PermIsInvolution], GroupTheory[PermPower], GroupTheory[PermLeftQuotient], GroupTheory[PermRightQuotient], GroupTheory[PermConjugate], GroupTheory[PermCommutator], GroupTheory[PermCycleType], GroupTheory[PermFixed], GroupTheory[PermRestrict], GroupTheory[PermShift], GroupTheory[PermSupport], GroupTheory[PermMinSupport], GroupTheory[PermMaxSupport] and GroupTheory[PermRandom] commands were introduced in Maple 17.

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

The GroupTheory[PermCompare] command was introduced in Maple 2017.

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