Random permutation

A random permutation is a random ordering of a set of objects, that is, a permutation-valued random variable. The use of random permutations is often fundamental to fields that use randomized algorithms such as coding theory, cryptography, and simulation. A good example of a random permutation is the shuffling of a deck of cards: this is ideally a random permutation of the 52 cards.

Generating random permutations

Entry-by-entry brute force method

One method of generating a random permutation of a set of length n uniformly at random (i.e., each of the n! permutations is equally likely to appear) is to generate a sequence by taking a random number between 1 and n sequentially, ensuring that there is no repetition, and interpreting this sequence (x₁, ..., x_n) as the permutation

${\begin{pmatrix}1&2&3&\cdots &n\\x_{1}&x_{2}&x_{3}&\cdots &x_{n}\\\end{pmatrix}},$

shown here in two-line notation.

This brute-force method will require occasional retries whenever the random number picked is a repeat of a number already selected. This can be avoided if, on the ith step (when x₁, ..., x_{i − 1} have already been chosen), one chooses a number j at random between 1 and n − i + 1 and sets x_i equal to the jth largest of the unchosen numbers.

Knuth shuffles

A simple algorithm to generate a permutation of n items uniformly at random without retries, known as the Knuth shuffle, is to start with any permutation (for example, the identity permutation), and then go through the positions 0 through n − 2 (we use a convention where the first element has index 0, and the last element has index n − 1), and for each position i swap the element currently there with a randomly chosen element from positions i through n − 1 (the end), inclusive. It's easy to verify that any permutation of n elements will be produced by this algorithm with probability exactly 1/n!, thus yielding a uniform distribution over all such permutations.

unsigned uniform(unsigned m); /* Returns a random integer 0 <= uniform(m) <= m-1 */

void initialize_and_permute(unsigned permutation[], unsigned n)
{
    unsigned i;
    for (i = 0; i <= n-2; i++) {
        unsigned j = uniform(n-i); /* A random integer such that 0 ≤ j < n-i*/
        swap(permutation[i], permutation[i+j]);   /* Swap an existing element [i+j] to position [i] */
    }
}

Note that the uniform() function can not be implemented simply as random() % (m) unless a bias in the results is acceptable.

Statistics on random permutations

Fixed points

The probability distribution of the number of fixed points of a uniformly distributed random permutation approaches a Poisson distribution with expected value 1 as n grows. In particular, it is an elegant application of the inclusion-exclusion principle to show that the probability that there are no fixed points approaches 1/e. The first n moments of this distribution are exactly those of the Poisson distribution.

Randomness testing

As with all random processes, the quality of the resulting distribution of an implementation of a randomized algorithm such as the Knuth shuffle (i.e., how close it is to the desired uniform distribution) depends on the quality of the underlying source of randomness, such as a pseudorandom number generator. There are many possible randomness tests for random permutations, such as some of the Diehard tests. A typical example of such a test is to take some permutation statistic for which the distribution is known and test whether the distribution of this statistic on a set of randomly generated permutations closely approximates the true distribution.

See also

• Ewens's sampling formula — a connection with population genetics
• Faro shuffle
• Fisher-Yates shuffle
• Golomb–Dickman constant
• Random permutation statistics
• Shuffling algorithms — random sort method, iterative exchange method

External links

• Random permutation at MathWorld
• Random permutation generation -- detailed and practical explanation of Knuth shuffle algorithm and its variants for generating k-permutations (permutations of k elements chosen from a list) and k-subsets (generating a subset of the elements in the list without replacement) with pseudocode