In mathematics, the notion of **permutation** relates to the act of **arranging** all the members of a set into some sequence or order, or if the set is already ordered, **rearranging** (reordering) its elements, a process called **permuting**. These differ from combinations, which are selections of some members of a set where order is disregarded. For example, written as tuples, there are six permutations of the set {1,2,3}, namely: (1,2,3), (1,3,2), (2,1,3), (2,3,1), (3,1,2), and (3,2,1). These are all the possible orderings of this three element set. As another example, an anagram of a word, all of whose letters are different, is a permutation of its letters. In this example, the letters are already ordered in the original word and the anagram is a reordering of the letters. The study of permutations of finite sets is a topic in the field of combinatorics.

Permutations occur, in more or less prominent ways, in almost every area of mathematics. They often arise when different orderings on certain finite sets are considered, possibly only because one wants to ignore such orderings and needs to know how many configurations are thus identified. For similar reasons permutations arise in the study of sorting algorithms in computer science.

The number of permutations of *n* distinct objects is *n* factorial usually written as *n*!, which means the product of all positive integers less than or equal to*n*.

In algebra and particularly in group theory, a permutation of a set *S* is defined as a bijection from *S* to itself. That is, it is a function from *S* to *S* for which every element occurs exactly once as an image value. This is related to the rearrangement of the elements of *S* in which each element *s* is replaced by the corresponding *f*(*s*). The collection of such permutations form a group called the symmetric group of *S*. The key to this group’s structure is the fact that the composition of two permutations (performing two given rearrangements in succession) results in another rearrangement. Permutations may *act* on structured objects by rearranging their components, or by certain replacements (substitutions) of symbols.

In elementary combinatorics, the *k*-permutations, or partial permutations, are the ordered arrangements of *k* distinct elements selected from a set. When *k* is equal to the size of the set, these are the permutations of the set.

In mathematics, when *X* is a finite set of at least two elements, the permutations of *X* (i.e. the bijective functions from *X* to *X*) fall into two classes of equal size: the **even permutations** and the **odd permutations**. If any total ordering of *X* is fixed, the **parity** (**oddness** or**evenness**) of a permutation of *X* can be defined as the parity of the number of inversions for σ, i.e., of pairs of elements x, y of *X* such that and .

The **sign** or **signature** of a permutation σ is denoted **sgn(σ)** and defined as +1 if σ is even and −1 if σ is odd. The signature defines the**alternating character** of the symmetric group *S*_{n}. Another notation for the sign of a permutation is given by the more general Levi-Civita symbol (), which is defined for all maps from *X* to *X*, and has value zero for non-bijective maps.

The sign of a permutation can be explicitly expressed as

- sgn(σ) = (−1)
^{N(σ)}

where *N*(σ) is the number of inversions in σ.

Alternatively, the sign of a permutation σ can be defined from its decomposition into the product of transpositions as

- sgn(σ) = (−1)
^{m}

where m is the number of transpositions in the decomposition. Although such a decomposition is not unique, the parity of the number of transpositions in all decompositions is the same, implying that the sign of a permutation is well-defined.^{[1]}

There are many ways to systematically generate all permutations of a given sequence. One classical algorithm, which is both simple and flexible, is based on finding the next permutation in lexicographic ordering, if it exists. It can handle repeated values, for which case it generates the distinct multiset permutations each once. Even for ordinary permutations it is significantly more efficient than generating values for the Lehmer code in lexicographic order (possibly using the factorial number system) and converting those to permutations. To use it, one starts by sorting the sequence in (weakly) increasing order (which gives its lexicographically minimal permutation), and then repeats advancing to the next permutation as long as one is found. The method goes back to Narayana Pandita in 14th century India, and has been frequently rediscovered ever since.^{[11]}

The following algorithm generates the next permutation lexicographically after a given permutation. It changes the given permutation in-place.

- Find the largest index
*k*such that*a*[*k*] <*a*[*k*+ 1]. If no such index exists, the permutation is the last permutation. - Find the largest index
*l*such that*a*[*k*] <*a*[*l*]. Since*k*+ 1 is such an index,*l*is well defined and satisfies*k*<*l*. - Swap
*a*[*k*] with*a*[*l*]. - Reverse the sequence from
*a*[*k*+ 1] up to and including the final element*a*[*n*].

After step 1, one knows that all of the elements strictly after position *k* form a weakly decreasing sequence, so no permutation of these elements will make it advance in lexicographic order; to advance one must increase *a*[*k*]. Step 2 finds the smallest value *a*[*l*] to replace *a*[*k*] by, and swapping them in step 3 leaves the sequence after position *k* in weakly decreasing order. Reversing this sequence in step 4 then produces its lexicographically minimal permutation, and the lexicographic successor of the initial state for the whole sequence.

An alternative to the above algorithm, the Steinhaus–Johnson–Trotter algorithm, generates an ordering on all the permutations of a given sequence with the property that any two consecutive permutations in its output differ by swapping two adjacent values. This ordering on the permutations was known to 17th-century English bell ringers, among whom it was known as “plain changes”. One advantage of this method is that the small amount of change from one permutation to the next allows the method to be implemented in constant time per permutation. The same can also easily generate the subset of even permutations, again in constant time per permutation, by skipping every other output permutation.^{[11]}