Permutations¶
The Permutations module. Use Permutation? to get information about
the Permutation class, and Permutations? to get information about
the combinatorial class of permutations.
Warning
This file defined Permutation which depends upon
CombinatorialElement despite it being deprecated (see
Issue #13742). This is dangerous. In particular, the
Permutation._left_to_right_multiply_on_right() method (which can
be called through multiplication) disables the input checks (see
Permutation()). This should not happen. Do not trust the results.
What does this file define ?¶
The main part of this file consists in the definition of permutation objects,
i.e. the Permutation() method and the
Permutation class. Global options for
elements of the permutation class can be set through the
Permutations.options() object.
Below are listed all methods and classes defined in this file.
Methods of Permutations objects
| Return the product of  | |
| Return the product of  | |
| Return the size of the permutation  | |
| Return the disjoint-cycles representation of  | |
| Return the permutation that follows  | |
| Return the permutation that comes directly before  | |
| Return a tableau of shape  | |
| Return the permutation  | |
| Return  | |
| Return a  | |
| Return the signature of the permutation  | |
| Return  | |
| Return a matrix representing the permutation  | |
| Return the rank of  | |
| Return the inversion vector of a permutation  | |
| Return a list of the inversions of permutation  | |
| Return the permutation obtained by sorting  | |
| Return a digraph representation of  | |
| Display the permutation as a drawing. | |
| Return the number of inversions in the permutation  | |
| Return the  | |
| Return the number of  | |
| Return the Coxeter length of a permutation  | |
| Return the inverse of a permutation  | |
| Return the  | |
| Return the  | |
| Return a list of the runs in the permutation  | |
| Return the length of the longest increasing subsequences of  | |
| Return the list of the longest increasing subsequences of  | |
| Return the number of longest increasing subsequences | |
| Return the cycle type of  | |
| Return the image of the permutation  | |
| Return the image of the permutation  | |
| Return the image of the permutation  | |
| Return the image of the permutation  | |
| Return destandardization of  | |
| Return the Lehmer code of the permutation  | |
| Return the Lehmer cocode of  | |
| Return the reduced word of the permutation  | |
| Return a list of the reduced words of the permutation  | |
| An iterator for the reduced words of the permutation  | |
| Return a lexicographically minimal reduced word of a permutation  | |
| Return a list of the fixed points of the permutation  | |
| Return  | |
| Return  | |
| Return the number of fixed points of the permutation  | |
| Return the list of the positions of the recoils of the permutation  | |
| Return the number of recoils of the permutation  | |
| Return the composition corresponding to the recoils of  | |
| Return the list of the descents of the permutation  | |
| Return a list of the idescents of  | |
| Return the list obtained by mapping each position in  | |
| Return the number of descents of the permutation  | |
| Return the number of idescents of the permutation  | |
| Return the composition corresponding to the descents of  | |
| Return the descent polynomial of the permutation  | |
| Return the major index of the permutation  | |
| Return the inverse major index of the permutation  | |
| Return the major code of the permutation  | |
| Return a list of the peaks of the permutation  | |
| Return the number of peaks of the permutation  | |
| Return a list of the saliances of the permutation  | |
| Return the number of saliances of the permutation  | |
| Return  | |
| Return all the numbers  | |
| Return the list of inversions of  | |
| Return an iterator over Bruhat inversions of  | |
| Return a list of the permutations covering  | |
| An iterator for the permutations covering  | |
| Return a list of the permutations covered by  | |
| An iterator for the permutations covered by  | |
| Return the combinatorial class of permutations smaller than or equal to  | |
| Return the combinatorial class of permutations greater than or equal to  | |
| Return  | |
| Return a list of the permutations covering  | |
| Return a list of the permutations covered by  | |
| Return a list of permutations smaller than or equal to  | |
| Return a list of permutations greater than or equal to  | |
| Return an iterator over permutations in an interval of the permutohedron order. | |
| Return a list of permutations in an interval of the permutohedron order. | |
| Test whether the permutation  | |
| Test whether the permutation  | |
| Return the list of positions where the pattern  | |
| Return the permutation obtained by reversing the 1-line notation of  | |
| Return the complement of the permutation which is obtained by replacing each value \(x\) in the 1-line notation of  | |
| Return the permutation poset of  | |
| Return a dictionary corresponding to the permutation  | |
| Return the action of the permutation  | |
| Return the pair of standard tableaux obtained by running the Robinson-Schensted Algorithm on  | |
| Return the left standard tableau after performing the RSK algorithm. | |
| Return the right standard tableau after performing the RSK algorithm. | |
| Return the increasing tree of  | |
| Return the shape of the increasing tree of  | |
| Return the binary search tree of  | |
| Iterate over the equivalence class of  | |
| Return the shape of the tableaux obtained by the RSK algorithm. | |
| Return the permutation obtained by removing any fixed points at the end of  | |
| Return the plain retract of  | |
| Return the direct-product retract of  | |
| Return the Okounkov-Vershik retract of  | |
| Return the coset-type of  | |
| Return the shape of the binary search tree of  | |
| Return the right (or left) shifted concatenation of  | |
| Return the shifted shuffle of  | 
Other classes defined in this file
Functions defined in this file
| Return the permutation corresponding to major code  | |
| Return a Permutation give a  | |
| Return the permutation with the specified lexicographic rank. | |
| Return the permutation corresponding to inversion vector  | |
| Return the permutation with given disjoint-cycle representation  | |
| Return the permutation with Lehmer code  | |
| Return the permutation corresponding to the reduced word  | |
| Return a given bistochastic matrix as a nonnegative linear combination of permutations. | |
| Return a partial permutation representing the bounded affine permutation of a matrix. | |
| Return a list of all the permutations in a given descent class (i. e., having a given descents composition). | |
| Return the smallest element of a descent class. | |
| Return the largest element of a descent class. | |
| Return  | |
| Return  | |
| Return a standard permutation corresponding to the permutation  | 
AUTHORS:
- Mike Hansen 
- Dan Drake (2008-04-07): allow Permutation() to take lists of tuples 
- Sébastien Labbé (2009-03-17): added robinson_schensted_inverse 
- Travis Scrimshaw: - (2012-08-16): - to_standard()no longer modifies input
- (2013-01-19): Removed RSK implementation and moved to - rsk.
- (2013-07-13): Removed - CombinatorialClassand moved permutations to the category framework.
 
- Darij Grinberg (2013-09-07): added methods; ameliorated Issue #14885 by exposing and documenting methods for global-independent multiplication. 
- Travis Scrimshaw (2014-02-05): Made - StandardPermutations_na finite Weyl group to make it more uniform with- SymmetricGroup. Added ability to compute the conjugacy classes.
- Trevor K. Karn (2022-08-05): Add - Permutation.n_reduced_words()
- Amrutha P, Shriya M, Divya Aggarwal (2022-08-16): Added Multimajor Index. 
Classes and methods¶
- class sage.combinat.permutation.Arrangements[source]¶
- Bases: - Permutations- An arrangement of a multiset - msetis an ordered selection without repetitions. It is represented by a list that contains only elements from- mset, but maybe in a different order.- Arrangementsreturns the combinatorial class of arrangements of the multiset- msetthat contain- kelements.- EXAMPLES: - sage: mset = [1,1,2,3,4,4,5] sage: Arrangements(mset, 2).list() # needs sage.libs.gap [[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [2, 1], [2, 3], [2, 4], [2, 5], [3, 1], [3, 2], [3, 4], [3, 5], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [5, 1], [5, 2], [5, 3], [5, 4]] sage: Arrangements(mset, 2).cardinality() # needs sage.libs.gap 22 sage: Arrangements( ["c","a","t"], 2 ).list() [['c', 'a'], ['c', 't'], ['a', 'c'], ['a', 't'], ['t', 'c'], ['t', 'a']] sage: Arrangements( ["c","a","t"], 3 ).list() [['c', 'a', 't'], ['c', 't', 'a'], ['a', 'c', 't'], ['a', 't', 'c'], ['t', 'c', 'a'], ['t', 'a', 'c']] - >>> from sage.all import * >>> mset = [Integer(1),Integer(1),Integer(2),Integer(3),Integer(4),Integer(4),Integer(5)] >>> Arrangements(mset, Integer(2)).list() # needs sage.libs.gap [[1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [2, 1], [2, 3], [2, 4], [2, 5], [3, 1], [3, 2], [3, 4], [3, 5], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [5, 1], [5, 2], [5, 3], [5, 4]] >>> Arrangements(mset, Integer(2)).cardinality() # needs sage.libs.gap 22 >>> Arrangements( ["c","a","t"], Integer(2) ).list() [['c', 'a'], ['c', 't'], ['a', 'c'], ['a', 't'], ['t', 'c'], ['t', 'a']] >>> Arrangements( ["c","a","t"], Integer(3) ).list() [['c', 'a', 't'], ['c', 't', 'a'], ['a', 'c', 't'], ['a', 't', 'c'], ['t', 'c', 'a'], ['t', 'a', 'c']] - cardinality()[source]¶
- Return the cardinality of - self.- EXAMPLES: - sage: A = Arrangements([1,1,2,3,4,4,5], 2) sage: A.cardinality() # needs sage.libs.gap 22 - >>> from sage.all import * >>> A = Arrangements([Integer(1),Integer(1),Integer(2),Integer(3),Integer(4),Integer(4),Integer(5)], Integer(2)) >>> A.cardinality() # needs sage.libs.gap 22 
 
- class sage.combinat.permutation.Arrangements_msetk(mset, k)[source]¶
- Bases: - Arrangements,- Permutations_msetk- Arrangements of length \(k\) of a multiset \(M\). 
- class sage.combinat.permutation.Arrangements_setk(s, k)[source]¶
- Bases: - Arrangements,- Permutations_setk- Arrangements of length \(k\) of a set \(S\). 
- class sage.combinat.permutation.CyclicPermutations(mset)[source]¶
- Bases: - Permutations_mset- Return the class of all cyclic permutations of - msetin cycle notation. These are the same as necklaces.- INPUT: - mset– a multiset
 - EXAMPLES: - sage: CyclicPermutations(range(4)).list() # needs sage.combinat [[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1], [0, 3, 1, 2], [0, 3, 2, 1]] sage: CyclicPermutations([1,1,1]).list() # needs sage.combinat [[1, 1, 1]] - >>> from sage.all import * >>> CyclicPermutations(range(Integer(4))).list() # needs sage.combinat [[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1], [0, 3, 1, 2], [0, 3, 2, 1]] >>> CyclicPermutations([Integer(1),Integer(1),Integer(1)]).list() # needs sage.combinat [[1, 1, 1]] - iterator(distinct=False)[source]¶
- EXAMPLES: - sage: CyclicPermutations(range(4)).list() # indirect doctest # needs sage.combinat [[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1], [0, 3, 1, 2], [0, 3, 2, 1]] sage: CyclicPermutations([1,1,1]).list() # needs sage.combinat [[1, 1, 1]] sage: CyclicPermutations([1,1,1]).list(distinct=True) # needs sage.combinat [[1, 1, 1], [1, 1, 1]] - >>> from sage.all import * >>> CyclicPermutations(range(Integer(4))).list() # indirect doctest # needs sage.combinat [[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1], [0, 3, 1, 2], [0, 3, 2, 1]] >>> CyclicPermutations([Integer(1),Integer(1),Integer(1)]).list() # needs sage.combinat [[1, 1, 1]] >>> CyclicPermutations([Integer(1),Integer(1),Integer(1)]).list(distinct=True) # needs sage.combinat [[1, 1, 1], [1, 1, 1]] 
 - list(distinct=False)[source]¶
- EXAMPLES: - sage: CyclicPermutations(range(4)).list() # needs sage.combinat [[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1], [0, 3, 1, 2], [0, 3, 2, 1]] - >>> from sage.all import * >>> CyclicPermutations(range(Integer(4))).list() # needs sage.combinat [[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1], [0, 3, 1, 2], [0, 3, 2, 1]] 
 
- class sage.combinat.permutation.CyclicPermutationsOfPartition(partition)[source]¶
- Bases: - Permutations- Combinations of cyclic permutations of each cell of a given partition. - This is the same as a Cartesian product of necklaces. - EXAMPLES: - sage: CyclicPermutationsOfPartition([[1,2,3,4],[5,6,7]]).list() # needs sage.combinat [[[1, 2, 3, 4], [5, 6, 7]], [[1, 2, 4, 3], [5, 6, 7]], [[1, 3, 2, 4], [5, 6, 7]], [[1, 3, 4, 2], [5, 6, 7]], [[1, 4, 2, 3], [5, 6, 7]], [[1, 4, 3, 2], [5, 6, 7]], [[1, 2, 3, 4], [5, 7, 6]], [[1, 2, 4, 3], [5, 7, 6]], [[1, 3, 2, 4], [5, 7, 6]], [[1, 3, 4, 2], [5, 7, 6]], [[1, 4, 2, 3], [5, 7, 6]], [[1, 4, 3, 2], [5, 7, 6]]] - >>> from sage.all import * >>> CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3),Integer(4)],[Integer(5),Integer(6),Integer(7)]]).list() # needs sage.combinat [[[1, 2, 3, 4], [5, 6, 7]], [[1, 2, 4, 3], [5, 6, 7]], [[1, 3, 2, 4], [5, 6, 7]], [[1, 3, 4, 2], [5, 6, 7]], [[1, 4, 2, 3], [5, 6, 7]], [[1, 4, 3, 2], [5, 6, 7]], [[1, 2, 3, 4], [5, 7, 6]], [[1, 2, 4, 3], [5, 7, 6]], [[1, 3, 2, 4], [5, 7, 6]], [[1, 3, 4, 2], [5, 7, 6]], [[1, 4, 2, 3], [5, 7, 6]], [[1, 4, 3, 2], [5, 7, 6]]] - sage: CyclicPermutationsOfPartition([[1,2,3,4],[4,4,4]]).list() # needs sage.combinat [[[1, 2, 3, 4], [4, 4, 4]], [[1, 2, 4, 3], [4, 4, 4]], [[1, 3, 2, 4], [4, 4, 4]], [[1, 3, 4, 2], [4, 4, 4]], [[1, 4, 2, 3], [4, 4, 4]], [[1, 4, 3, 2], [4, 4, 4]]] - >>> from sage.all import * >>> CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3),Integer(4)],[Integer(4),Integer(4),Integer(4)]]).list() # needs sage.combinat [[[1, 2, 3, 4], [4, 4, 4]], [[1, 2, 4, 3], [4, 4, 4]], [[1, 3, 2, 4], [4, 4, 4]], [[1, 3, 4, 2], [4, 4, 4]], [[1, 4, 2, 3], [4, 4, 4]], [[1, 4, 3, 2], [4, 4, 4]]] - sage: CyclicPermutationsOfPartition([[1,2,3],[4,4,4]]).list() # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] - >>> from sage.all import * >>> CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(4),Integer(4)]]).list() # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] - sage: CyclicPermutationsOfPartition([[1,2,3],[4,4,4]]).list(distinct=True) # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]], [[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] - >>> from sage.all import * >>> CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(4),Integer(4)]]).list(distinct=True) # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]], [[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] - class Element[source]¶
- Bases: - ClonableArray- A cyclic permutation of a partition. - check()[source]¶
- Check that - selfis a valid element.- EXAMPLES: - sage: CP = CyclicPermutationsOfPartition([[1,2,3,4],[5,6,7]]) sage: elt = CP[0] # needs sage.combinat sage: elt.check() # needs sage.combinat - >>> from sage.all import * >>> CP = CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3),Integer(4)],[Integer(5),Integer(6),Integer(7)]]) >>> elt = CP[Integer(0)] # needs sage.combinat >>> elt.check() # needs sage.combinat 
 
 - iterator(distinct=False)[source]¶
- AUTHORS: - Robert Miller 
 - EXAMPLES: - sage: CyclicPermutationsOfPartition([[1,2,3,4], # indirect doctest # needs sage.combinat ....: [5,6,7]]).list() [[[1, 2, 3, 4], [5, 6, 7]], [[1, 2, 4, 3], [5, 6, 7]], [[1, 3, 2, 4], [5, 6, 7]], [[1, 3, 4, 2], [5, 6, 7]], [[1, 4, 2, 3], [5, 6, 7]], [[1, 4, 3, 2], [5, 6, 7]], [[1, 2, 3, 4], [5, 7, 6]], [[1, 2, 4, 3], [5, 7, 6]], [[1, 3, 2, 4], [5, 7, 6]], [[1, 3, 4, 2], [5, 7, 6]], [[1, 4, 2, 3], [5, 7, 6]], [[1, 4, 3, 2], [5, 7, 6]]] - >>> from sage.all import * >>> CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3),Integer(4)], # indirect doctest # needs sage.combinat ... [Integer(5),Integer(6),Integer(7)]]).list() [[[1, 2, 3, 4], [5, 6, 7]], [[1, 2, 4, 3], [5, 6, 7]], [[1, 3, 2, 4], [5, 6, 7]], [[1, 3, 4, 2], [5, 6, 7]], [[1, 4, 2, 3], [5, 6, 7]], [[1, 4, 3, 2], [5, 6, 7]], [[1, 2, 3, 4], [5, 7, 6]], [[1, 2, 4, 3], [5, 7, 6]], [[1, 3, 2, 4], [5, 7, 6]], [[1, 3, 4, 2], [5, 7, 6]], [[1, 4, 2, 3], [5, 7, 6]], [[1, 4, 3, 2], [5, 7, 6]]] - sage: CyclicPermutationsOfPartition([[1,2,3,4],[4,4,4]]).list() # needs sage.combinat [[[1, 2, 3, 4], [4, 4, 4]], [[1, 2, 4, 3], [4, 4, 4]], [[1, 3, 2, 4], [4, 4, 4]], [[1, 3, 4, 2], [4, 4, 4]], [[1, 4, 2, 3], [4, 4, 4]], [[1, 4, 3, 2], [4, 4, 4]]] - >>> from sage.all import * >>> CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3),Integer(4)],[Integer(4),Integer(4),Integer(4)]]).list() # needs sage.combinat [[[1, 2, 3, 4], [4, 4, 4]], [[1, 2, 4, 3], [4, 4, 4]], [[1, 3, 2, 4], [4, 4, 4]], [[1, 3, 4, 2], [4, 4, 4]], [[1, 4, 2, 3], [4, 4, 4]], [[1, 4, 3, 2], [4, 4, 4]]] - sage: CyclicPermutationsOfPartition([[1,2,3],[4,4,4]]).list() # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] - >>> from sage.all import * >>> CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(4),Integer(4)]]).list() # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] - sage: CyclicPermutationsOfPartition([[1,2,3],[4,4,4]]).list(distinct=True) # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]], [[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] - >>> from sage.all import * >>> CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(4),Integer(4)]]).list(distinct=True) # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]], [[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] 
 - list(distinct=False)[source]¶
- EXAMPLES: - sage: CyclicPermutationsOfPartition([[1,2,3],[4,4,4]]).list() # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] sage: CyclicPermutationsOfPartition([[1,2,3],[4,4,4]]).list(distinct=True) # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]], [[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] - >>> from sage.all import * >>> CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(4),Integer(4)]]).list() # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] >>> CyclicPermutationsOfPartition([[Integer(1),Integer(2),Integer(3)],[Integer(4),Integer(4),Integer(4)]]).list(distinct=True) # needs sage.combinat [[[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]], [[1, 2, 3], [4, 4, 4]], [[1, 3, 2], [4, 4, 4]]] 
 
- class sage.combinat.permutation.PatternAvoider(parent, patterns)[source]¶
- Bases: - GenericBacktracker- EXAMPLES: - sage: from sage.combinat.permutation import PatternAvoider sage: P = Permutations(4) sage: p = PatternAvoider(P, [[1,2,3]]) sage: loads(dumps(p)) <sage.combinat.permutation.PatternAvoider object at 0x...> - >>> from sage.all import * >>> from sage.combinat.permutation import PatternAvoider >>> P = Permutations(Integer(4)) >>> p = PatternAvoider(P, [[Integer(1),Integer(2),Integer(3)]]) >>> loads(dumps(p)) <sage.combinat.permutation.PatternAvoider object at 0x...> 
- class sage.combinat.permutation.Permutation(parent, l, algorithm='lex', sjt=None, check=True)[source]¶
- Bases: - CombinatorialElement- A permutation. - Converts - lto a permutation on \(\{1, 2, \ldots, n\}\).- INPUT: - l– can be any one of the following:- an instance of - Permutation,
- list of integers, viewed as one-line permutation notation. The construction checks that you give an acceptable entry. To avoid the check, use the - checkoption.
- string, expressing the permutation in cycle notation. 
- list of tuples of integers, expressing the permutation in cycle notation. 
- a - PermutationGroupElement
- a pair of two standard tableaux of the same shape. This yields the permutation obtained from the pair using the inverse of the Robinson-Schensted algorithm. 
 
- check– boolean (default:- True); whether to check that input is correct; slows the function down, but ensures that nothing bad happens
- algorithm– string (default:- 'lex'); the algorithm used to generate the permutations. Supported algorithms are:- 'lex': lexicographic order generation, this is the default algorithm
- 'sjt': Steinhaus-Johnson-Trotter algorithm to generate permutations using only transposition of two elements in the list. It is highly recommended to set- check=True(default value).
 
- sjt– SJT (default:- None); the- SJTobject holding the permutation internal state. This should only be specified when initializing with non-identity permutation.
 - Warning - Since Issue #13742 the input is checked for correctness : it is not accepted unless it actually is a permutation on \(\{1, \ldots, n\}\). It means that some - Permutation()objects cannot be created anymore without setting- check=False, as there is no certainty that its functions can handle them, and this should be fixed in a much better way ASAP (the functions should be rewritten to handle those cases, and new tests be added).- Warning - There are two possible conventions for multiplying permutations, and the one currently enabled in Sage by default is the one which has \((pq)(i) = q(p(i))\) for any permutations \(p \in S_n\) and \(q \in S_n\) and any \(1 \leq i \leq n\). (This equation looks less strange when the action of permutations on numbers is written from the right: then it takes the form \(i^{pq} = (i^p)^q\), which is an associativity law). There is an alternative convention, which has \((pq)(i) = p(q(i))\) instead. The conventions can be switched at runtime using - sage.combinat.permutation.Permutations.options(). It is best for code not to rely on this setting being set to a particular standard, but rather use the methods- left_action_product()and- right_action_product()for multiplying permutations (these methods don’t depend on the setting). See Issue #14885 for more details.- Note - The - bruhat*methods refer to the strong Bruhat order. To use the weak Bruhat order, look under- permutohedron*.- EXAMPLES: - sage: Permutation([2,1]) [2, 1] sage: Permutation([2, 1, 4, 5, 3]) [2, 1, 4, 5, 3] sage: Permutation('(1,2)') [2, 1] sage: Permutation('(1,2)(3,4,5)') [2, 1, 4, 5, 3] sage: Permutation( ((1,2),(3,4,5)) ) [2, 1, 4, 5, 3] sage: Permutation( [(1,2),(3,4,5)] ) [2, 1, 4, 5, 3] sage: Permutation( ((1,2)) ) [2, 1] sage: Permutation( (1,2) ) [2, 1] sage: Permutation( ((1,2),) ) [2, 1] sage: Permutation( ((1,),) ) [1] sage: Permutation( (1,) ) [1] sage: Permutation( () ) [] sage: Permutation( ((),) ) [] sage: p = Permutation((1, 2, 5)); p [2, 5, 3, 4, 1] sage: type(p) <class 'sage.combinat.permutation.StandardPermutations_n_with_category.element_class'> - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1)]) [2, 1] >>> Permutation([Integer(2), Integer(1), Integer(4), Integer(5), Integer(3)]) [2, 1, 4, 5, 3] >>> Permutation('(1,2)') [2, 1] >>> Permutation('(1,2)(3,4,5)') [2, 1, 4, 5, 3] >>> Permutation( ((Integer(1),Integer(2)),(Integer(3),Integer(4),Integer(5))) ) [2, 1, 4, 5, 3] >>> Permutation( [(Integer(1),Integer(2)),(Integer(3),Integer(4),Integer(5))] ) [2, 1, 4, 5, 3] >>> Permutation( ((Integer(1),Integer(2))) ) [2, 1] >>> Permutation( (Integer(1),Integer(2)) ) [2, 1] >>> Permutation( ((Integer(1),Integer(2)),) ) [2, 1] >>> Permutation( ((Integer(1),),) ) [1] >>> Permutation( (Integer(1),) ) [1] >>> Permutation( () ) [] >>> Permutation( ((),) ) [] >>> p = Permutation((Integer(1), Integer(2), Integer(5))); p [2, 5, 3, 4, 1] >>> type(p) <class 'sage.combinat.permutation.StandardPermutations_n_with_category.element_class'> - Generate permutations using the Steinhaus-Johnson Trotter algorithm. The output is not in lexicographic order: - sage: p = Permutation([1, 2, 3, 4], algorithm='sjt'); p [1, 2, 3, 4] sage: p = p.next(); p [1, 2, 4, 3] sage: p = p.next(); p [1, 4, 2, 3] sage: p = Permutation([1, 2, 3], algorithm='sjt') sage: for _ in range(6): ....: p = p.next() sage: p False sage: Permutation([1, 3, 2, 4], algorithm='sjt') Traceback (most recent call last): ... ValueError: no internal state directions were given for non-identity starting permutation for Steinhaus-Johnson-Trotter algorithm - >>> from sage.all import * >>> p = Permutation([Integer(1), Integer(2), Integer(3), Integer(4)], algorithm='sjt'); p [1, 2, 3, 4] >>> p = p.next(); p [1, 2, 4, 3] >>> p = p.next(); p [1, 4, 2, 3] >>> p = Permutation([Integer(1), Integer(2), Integer(3)], algorithm='sjt') >>> for _ in range(Integer(6)): ... p = p.next() >>> p False >>> Permutation([Integer(1), Integer(3), Integer(2), Integer(4)], algorithm='sjt') Traceback (most recent call last): ... ValueError: no internal state directions were given for non-identity starting permutation for Steinhaus-Johnson-Trotter algorithm - Construction from a string in cycle notation: - sage: p = Permutation( '(4,5)' ); p [1, 2, 3, 5, 4] - >>> from sage.all import * >>> p = Permutation( '(4,5)' ); p [1, 2, 3, 5, 4] - The size of the permutation is the maximum integer appearing; add a 1-cycle to increase this: - sage: p2 = Permutation( '(4,5)(10)' ); p2 [1, 2, 3, 5, 4, 6, 7, 8, 9, 10] sage: len(p); len(p2) 5 10 - >>> from sage.all import * >>> p2 = Permutation( '(4,5)(10)' ); p2 [1, 2, 3, 5, 4, 6, 7, 8, 9, 10] >>> len(p); len(p2) 5 10 - We construct a - Permutationfrom a- PermutationGroupElement:- sage: g = PermutationGroupElement([2,1,3]) # needs sage.groups sage: Permutation(g) # needs sage.groups [2, 1, 3] - >>> from sage.all import * >>> g = PermutationGroupElement([Integer(2),Integer(1),Integer(3)]) # needs sage.groups >>> Permutation(g) # needs sage.groups [2, 1, 3] - From a pair of tableaux of the same shape. This uses the inverse of the Robinson-Schensted algorithm: - sage: # needs sage.combinat sage: p = [[1, 4, 7], [2, 5], [3], [6]] sage: q = [[1, 2, 5], [3, 6], [4], [7]] sage: P = Tableau(p) sage: Q = Tableau(q) sage: Permutation( (p, q) ) [3, 6, 5, 2, 7, 4, 1] sage: Permutation( [p, q] ) [3, 6, 5, 2, 7, 4, 1] sage: Permutation( (P, Q) ) [3, 6, 5, 2, 7, 4, 1] sage: Permutation( [P, Q] ) [3, 6, 5, 2, 7, 4, 1] - >>> from sage.all import * >>> # needs sage.combinat >>> p = [[Integer(1), Integer(4), Integer(7)], [Integer(2), Integer(5)], [Integer(3)], [Integer(6)]] >>> q = [[Integer(1), Integer(2), Integer(5)], [Integer(3), Integer(6)], [Integer(4)], [Integer(7)]] >>> P = Tableau(p) >>> Q = Tableau(q) >>> Permutation( (p, q) ) [3, 6, 5, 2, 7, 4, 1] >>> Permutation( [p, q] ) [3, 6, 5, 2, 7, 4, 1] >>> Permutation( (P, Q) ) [3, 6, 5, 2, 7, 4, 1] >>> Permutation( [P, Q] ) [3, 6, 5, 2, 7, 4, 1] - RS_partition()[source]¶
- Return the shape of the tableaux obtained by applying the RSK algorithm to - self.- EXAMPLES: - sage: Permutation([1,4,3,2]).RS_partition() # needs sage.combinat [2, 1, 1] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).RS_partition() # needs sage.combinat [2, 1, 1] 
 - absolute_length()[source]¶
- Return the absolute length of - self- The absolute length is the length of the shortest expression of the element as a product of reflections. - For permutations in the symmetric groups, the absolute length is the size minus the number of its disjoint cycles. - EXAMPLES: - sage: Permutation([4,2,3,1]).absolute_length() # needs sage.combinat 1 - >>> from sage.all import * >>> Permutation([Integer(4),Integer(2),Integer(3),Integer(1)]).absolute_length() # needs sage.combinat 1 
 - action(a)[source]¶
- Return the action of the permutation - selfon a list- a.- The action of a permutation \(p \in S_n\) on an \(n\)-element list \((a_1, a_2, \ldots, a_n)\) is defined to be \((a_{p(1)}, a_{p(2)}, \ldots, a_{p(n)})\). - EXAMPLES: - sage: p = Permutation([2,1,3]) sage: a = list(range(3)) sage: p.action(a) [1, 0, 2] sage: b = [1,2,3,4] sage: p.action(b) Traceback (most recent call last): ... ValueError: len(a) must equal len(self) sage: q = Permutation([2,3,1]) sage: a = list(range(3)) sage: q.action(a) [1, 2, 0] - >>> from sage.all import * >>> p = Permutation([Integer(2),Integer(1),Integer(3)]) >>> a = list(range(Integer(3))) >>> p.action(a) [1, 0, 2] >>> b = [Integer(1),Integer(2),Integer(3),Integer(4)] >>> p.action(b) Traceback (most recent call last): ... ValueError: len(a) must equal len(self) >>> q = Permutation([Integer(2),Integer(3),Integer(1)]) >>> a = list(range(Integer(3))) >>> q.action(a) [1, 2, 0] 
 - avoids(patt)[source]¶
- Test whether the permutation - selfavoids the pattern- patt.- EXAMPLES: - sage: Permutation([6,2,5,4,3,1]).avoids([4,2,3,1]) # needs sage.combinat False sage: Permutation([6,1,2,5,4,3]).avoids([4,2,3,1]) # needs sage.combinat True sage: Permutation([6,1,2,5,4,3]).avoids([3,4,1,2]) # needs sage.combinat True - >>> from sage.all import * >>> Permutation([Integer(6),Integer(2),Integer(5),Integer(4),Integer(3),Integer(1)]).avoids([Integer(4),Integer(2),Integer(3),Integer(1)]) # needs sage.combinat False >>> Permutation([Integer(6),Integer(1),Integer(2),Integer(5),Integer(4),Integer(3)]).avoids([Integer(4),Integer(2),Integer(3),Integer(1)]) # needs sage.combinat True >>> Permutation([Integer(6),Integer(1),Integer(2),Integer(5),Integer(4),Integer(3)]).avoids([Integer(3),Integer(4),Integer(1),Integer(2)]) # needs sage.combinat True 
 - binary_search_tree(left_to_right=True)[source]¶
- Return the binary search tree associated to - self.- If \(w\) is a word, then the binary search tree associated to \(w\) is defined as the result of starting with an empty binary tree, and then inserting the letters of \(w\) one by one into this tree. Here, the insertion is being done according to the method - binary_search_insert(), and the word \(w\) is being traversed from left to right.- A permutation is regarded as a word (using one-line notation), and thus a binary search tree associated to a permutation is defined. - If the optional keyword variable - left_to_rightis set to- False, the word \(w\) is being traversed from right to left instead.- EXAMPLES: - sage: Permutation([1,4,3,2]).binary_search_tree() # needs sage.graphs 1[., 4[3[2[., .], .], .]] sage: Permutation([4,1,3,2]).binary_search_tree() # needs sage.graphs 4[1[., 3[2[., .], .]], .] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).binary_search_tree() # needs sage.graphs 1[., 4[3[2[., .], .], .]] >>> Permutation([Integer(4),Integer(1),Integer(3),Integer(2)]).binary_search_tree() # needs sage.graphs 4[1[., 3[2[., .], .]], .] - By passing the option - left_to_right=Falseone can have the insertion going from right to left:- sage: Permutation([1,4,3,2]).binary_search_tree(False) # needs sage.graphs 2[1[., .], 3[., 4[., .]]] sage: Permutation([4,1,3,2]).binary_search_tree(False) # needs sage.graphs 2[1[., .], 3[., 4[., .]]] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).binary_search_tree(False) # needs sage.graphs 2[1[., .], 3[., 4[., .]]] >>> Permutation([Integer(4),Integer(1),Integer(3),Integer(2)]).binary_search_tree(False) # needs sage.graphs 2[1[., .], 3[., 4[., .]]] 
 - binary_search_tree_shape(left_to_right=True)[source]¶
- Return the shape of the binary search tree of the permutation (a non labelled binary tree). - EXAMPLES: - sage: Permutation([1,4,3,2]).binary_search_tree_shape() # needs sage.graphs [., [[[., .], .], .]] sage: Permutation([4,1,3,2]).binary_search_tree_shape() # needs sage.graphs [[., [[., .], .]], .] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).binary_search_tree_shape() # needs sage.graphs [., [[[., .], .], .]] >>> Permutation([Integer(4),Integer(1),Integer(3),Integer(2)]).binary_search_tree_shape() # needs sage.graphs [[., [[., .], .]], .] - By passing the option - left_to_right=Falseone can have the insertion going from right to left:- sage: Permutation([1,4,3,2]).binary_search_tree_shape(False) # needs sage.graphs [[., .], [., [., .]]] sage: Permutation([4,1,3,2]).binary_search_tree_shape(False) # needs sage.graphs [[., .], [., [., .]]] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).binary_search_tree_shape(False) # needs sage.graphs [[., .], [., [., .]]] >>> Permutation([Integer(4),Integer(1),Integer(3),Integer(2)]).binary_search_tree_shape(False) # needs sage.graphs [[., .], [., [., .]]] 
 - bruhat_greater()[source]¶
- Return the combinatorial class of permutations greater than or equal to - selfin the Bruhat order (on the symmetric group containing- self).- See - bruhat_lequal()for the definition of the Bruhat order.- EXAMPLES: - sage: Permutation([4,1,2,3]).bruhat_greater().list() [[4, 1, 2, 3], [4, 1, 3, 2], [4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1]] - >>> from sage.all import * >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3)]).bruhat_greater().list() [[4, 1, 2, 3], [4, 1, 3, 2], [4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1]] 
 - bruhat_inversions()[source]¶
- Return the list of inversions of - selfsuch that the application of this inversion to- selfdecreases its number of inversions by exactly 1.- Equivalently, it returns the list of pairs \((i,j)\) such that \(i < j\), such that \(p(i) > p(j)\) and such that there exists no \(k\) (strictly) between \(i\) and \(j\) satisfying \(p(i) > p(k) > p(j)\). - EXAMPLES: - sage: Permutation([5,2,3,4,1]).bruhat_inversions() [[0, 1], [0, 2], [0, 3], [1, 4], [2, 4], [3, 4]] sage: Permutation([6,1,4,5,2,3]).bruhat_inversions() [[0, 1], [0, 2], [0, 3], [2, 4], [2, 5], [3, 4], [3, 5]] - >>> from sage.all import * >>> Permutation([Integer(5),Integer(2),Integer(3),Integer(4),Integer(1)]).bruhat_inversions() [[0, 1], [0, 2], [0, 3], [1, 4], [2, 4], [3, 4]] >>> Permutation([Integer(6),Integer(1),Integer(4),Integer(5),Integer(2),Integer(3)]).bruhat_inversions() [[0, 1], [0, 2], [0, 3], [2, 4], [2, 5], [3, 4], [3, 5]] 
 - bruhat_inversions_iterator()[source]¶
- Return the iterator for the inversions of - selfsuch that the application of this inversion to- selfdecreases its number of inversions by exactly 1.- EXAMPLES: - sage: list(Permutation([5,2,3,4,1]).bruhat_inversions_iterator()) [[0, 1], [0, 2], [0, 3], [1, 4], [2, 4], [3, 4]] sage: list(Permutation([6,1,4,5,2,3]).bruhat_inversions_iterator()) [[0, 1], [0, 2], [0, 3], [2, 4], [2, 5], [3, 4], [3, 5]] - >>> from sage.all import * >>> list(Permutation([Integer(5),Integer(2),Integer(3),Integer(4),Integer(1)]).bruhat_inversions_iterator()) [[0, 1], [0, 2], [0, 3], [1, 4], [2, 4], [3, 4]] >>> list(Permutation([Integer(6),Integer(1),Integer(4),Integer(5),Integer(2),Integer(3)]).bruhat_inversions_iterator()) [[0, 1], [0, 2], [0, 3], [2, 4], [2, 5], [3, 4], [3, 5]] 
 - bruhat_lequal(p2)[source]¶
- Return - Trueif- selfis less or equal to- p2in the Bruhat order.- The Bruhat order (also called strong Bruhat order or Chevalley order) on the symmetric group \(S_n\) is the partial order on \(S_n\) determined by the following condition: If \(p\) is a permutation, and \(i\) and \(j\) are two indices satisfying \(p(i) > p(j)\) and \(i < j\) (that is, \((i, j)\) is an inversion of \(p\) with \(i < j\)), then \(p \circ (i, j)\) (the permutation obtained by first switching \(i\) with \(j\) and then applying \(p\)) is smaller than \(p\) in the Bruhat order. - One can show that a permutation \(p \in S_n\) is less or equal to a permutation \(q \in S_n\) in the Bruhat order if and only if for every \(i \in \{ 0, 1, \cdots , n \}\) and \(j \in \{ 1, 2, \cdots , n \}\), the number of the elements among \(p(1), p(2), \cdots, p(j)\) that are greater than \(i\) is \(\leq\) to the number of the elements among \(q(1), q(2), \cdots, q(j)\) that are greater than \(i\). - This method assumes that - selfand- p2are permutations of the same integer \(n\).- EXAMPLES: - sage: Permutation([2,4,3,1]).bruhat_lequal(Permutation([3,4,2,1])) True sage: Permutation([2,1,3]).bruhat_lequal(Permutation([2,3,1])) True sage: Permutation([2,1,3]).bruhat_lequal(Permutation([3,1,2])) True sage: Permutation([2,1,3]).bruhat_lequal(Permutation([1,2,3])) False sage: Permutation([1,3,2]).bruhat_lequal(Permutation([2,1,3])) False sage: Permutation([1,3,2]).bruhat_lequal(Permutation([2,3,1])) True sage: Permutation([2,3,1]).bruhat_lequal(Permutation([1,3,2])) False sage: sorted( [len([b for b in Permutations(3) if a.bruhat_lequal(b)]) ....: for a in Permutations(3)] ) [1, 2, 2, 4, 4, 6] sage: Permutation([]).bruhat_lequal(Permutation([])) True - >>> from sage.all import * >>> Permutation([Integer(2),Integer(4),Integer(3),Integer(1)]).bruhat_lequal(Permutation([Integer(3),Integer(4),Integer(2),Integer(1)])) True >>> Permutation([Integer(2),Integer(1),Integer(3)]).bruhat_lequal(Permutation([Integer(2),Integer(3),Integer(1)])) True >>> Permutation([Integer(2),Integer(1),Integer(3)]).bruhat_lequal(Permutation([Integer(3),Integer(1),Integer(2)])) True >>> Permutation([Integer(2),Integer(1),Integer(3)]).bruhat_lequal(Permutation([Integer(1),Integer(2),Integer(3)])) False >>> Permutation([Integer(1),Integer(3),Integer(2)]).bruhat_lequal(Permutation([Integer(2),Integer(1),Integer(3)])) False >>> Permutation([Integer(1),Integer(3),Integer(2)]).bruhat_lequal(Permutation([Integer(2),Integer(3),Integer(1)])) True >>> Permutation([Integer(2),Integer(3),Integer(1)]).bruhat_lequal(Permutation([Integer(1),Integer(3),Integer(2)])) False >>> sorted( [len([b for b in Permutations(Integer(3)) if a.bruhat_lequal(b)]) ... for a in Permutations(Integer(3))] ) [1, 2, 2, 4, 4, 6] >>> Permutation([]).bruhat_lequal(Permutation([])) True 
 - bruhat_pred()[source]¶
- Return a list of the permutations strictly smaller than - selfin the Bruhat order (on the symmetric group containing- self) such that there is no permutation between one of those and- self.- See - bruhat_lequal()for the definition of the Bruhat order.- EXAMPLES: - sage: Permutation([6,1,4,5,2,3]).bruhat_pred() [[1, 6, 4, 5, 2, 3], [4, 1, 6, 5, 2, 3], [5, 1, 4, 6, 2, 3], [6, 1, 2, 5, 4, 3], [6, 1, 3, 5, 2, 4], [6, 1, 4, 2, 5, 3], [6, 1, 4, 3, 2, 5]] - >>> from sage.all import * >>> Permutation([Integer(6),Integer(1),Integer(4),Integer(5),Integer(2),Integer(3)]).bruhat_pred() [[1, 6, 4, 5, 2, 3], [4, 1, 6, 5, 2, 3], [5, 1, 4, 6, 2, 3], [6, 1, 2, 5, 4, 3], [6, 1, 3, 5, 2, 4], [6, 1, 4, 2, 5, 3], [6, 1, 4, 3, 2, 5]] 
 - bruhat_pred_iterator()[source]¶
- An iterator for the permutations strictly smaller than - selfin the Bruhat order (on the symmetric group containing- self) such that there is no permutation between one of those and- self.- See - bruhat_lequal()for the definition of the Bruhat order.- EXAMPLES: - sage: [x for x in Permutation([6,1,4,5,2,3]).bruhat_pred_iterator()] [[1, 6, 4, 5, 2, 3], [4, 1, 6, 5, 2, 3], [5, 1, 4, 6, 2, 3], [6, 1, 2, 5, 4, 3], [6, 1, 3, 5, 2, 4], [6, 1, 4, 2, 5, 3], [6, 1, 4, 3, 2, 5]] - >>> from sage.all import * >>> [x for x in Permutation([Integer(6),Integer(1),Integer(4),Integer(5),Integer(2),Integer(3)]).bruhat_pred_iterator()] [[1, 6, 4, 5, 2, 3], [4, 1, 6, 5, 2, 3], [5, 1, 4, 6, 2, 3], [6, 1, 2, 5, 4, 3], [6, 1, 3, 5, 2, 4], [6, 1, 4, 2, 5, 3], [6, 1, 4, 3, 2, 5]] 
 - bruhat_smaller()[source]¶
- Return the combinatorial class of permutations smaller than or equal to - selfin the Bruhat order (on the symmetric group containing- self).- See - bruhat_lequal()for the definition of the Bruhat order.- EXAMPLES: - sage: Permutation([4,1,2,3]).bruhat_smaller().list() [[1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 4, 2, 3], [2, 1, 3, 4], [2, 1, 4, 3], [3, 1, 2, 4], [4, 1, 2, 3]] - >>> from sage.all import * >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3)]).bruhat_smaller().list() [[1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 4, 2, 3], [2, 1, 3, 4], [2, 1, 4, 3], [3, 1, 2, 4], [4, 1, 2, 3]] 
 - bruhat_succ()[source]¶
- Return a list of the permutations strictly greater than - selfin the Bruhat order (on the symmetric group containing- self) such that there is no permutation between one of those and- self.- See - bruhat_lequal()for the definition of the Bruhat order.- EXAMPLES: - sage: Permutation([6,1,4,5,2,3]).bruhat_succ() [[6, 4, 1, 5, 2, 3], [6, 2, 4, 5, 1, 3], [6, 1, 5, 4, 2, 3], [6, 1, 4, 5, 3, 2]] - >>> from sage.all import * >>> Permutation([Integer(6),Integer(1),Integer(4),Integer(5),Integer(2),Integer(3)]).bruhat_succ() [[6, 4, 1, 5, 2, 3], [6, 2, 4, 5, 1, 3], [6, 1, 5, 4, 2, 3], [6, 1, 4, 5, 3, 2]] 
 - bruhat_succ_iterator()[source]¶
- An iterator for the permutations that are strictly greater than - selfin the Bruhat order (on the symmetric group containing- self) such that there is no permutation between one of those and- self.- See - bruhat_lequal()for the definition of the Bruhat order.- EXAMPLES: - sage: [x for x in Permutation([6,1,4,5,2,3]).bruhat_succ_iterator()] [[6, 4, 1, 5, 2, 3], [6, 2, 4, 5, 1, 3], [6, 1, 5, 4, 2, 3], [6, 1, 4, 5, 3, 2]] - >>> from sage.all import * >>> [x for x in Permutation([Integer(6),Integer(1),Integer(4),Integer(5),Integer(2),Integer(3)]).bruhat_succ_iterator()] [[6, 4, 1, 5, 2, 3], [6, 2, 4, 5, 1, 3], [6, 1, 5, 4, 2, 3], [6, 1, 4, 5, 3, 2]] 
 - complement()[source]¶
- Return the complement of the permutation - self.- The complement of a permutation \(w \in S_n\) is defined as the permutation in \(S_n\) sending each \(i\) to \(n + 1 - w(i)\). - EXAMPLES: - sage: Permutation([1,2,3]).complement() [3, 2, 1] sage: Permutation([1, 3, 2]).complement() [3, 1, 2] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(2),Integer(3)]).complement() [3, 2, 1] >>> Permutation([Integer(1), Integer(3), Integer(2)]).complement() [3, 1, 2] 
 - cycle_string(singletons=False)[source]¶
- Return a string of the permutation in cycle notation. - If - singletons=True, it includes 1-cycles in the string.- EXAMPLES: - sage: Permutation([1,2,3]).cycle_string() '()' sage: Permutation([2,1,3]).cycle_string() '(1,2)' sage: Permutation([2,3,1]).cycle_string() '(1,2,3)' sage: Permutation([2,1,3]).cycle_string(singletons=True) '(1,2)(3)' - >>> from sage.all import * >>> Permutation([Integer(1),Integer(2),Integer(3)]).cycle_string() '()' >>> Permutation([Integer(2),Integer(1),Integer(3)]).cycle_string() '(1,2)' >>> Permutation([Integer(2),Integer(3),Integer(1)]).cycle_string() '(1,2,3)' >>> Permutation([Integer(2),Integer(1),Integer(3)]).cycle_string(singletons=True) '(1,2)(3)' 
 - cycle_tuples(singletons=True, use_min=True)[source]¶
- Return the permutation - selfas a list of disjoint cycles.- The cycles are returned in the order of increasing smallest elements, and each cycle is returned as a tuple which starts with its smallest element. - If - singletons=Falseis given, the list does not contain the singleton cycles.- If - use_min=Falseis given, the cycles are returned in the order of increasing largest (not smallest) elements, and each cycle starts with its largest element.- EXAMPLES: - sage: Permutation([2,1,3,4]).to_cycles() [(1, 2), (3,), (4,)] sage: Permutation([2,1,3,4]).to_cycles(singletons=False) [(1, 2)] sage: Permutation([2,1,3,4]).to_cycles(use_min=True) [(1, 2), (3,), (4,)] sage: Permutation([2,1,3,4]).to_cycles(use_min=False) [(4,), (3,), (2, 1)] sage: Permutation([2,1,3,4]).to_cycles(singletons=False, use_min=False) [(2, 1)] sage: Permutation([4,1,5,2,6,3]).to_cycles() [(1, 4, 2), (3, 5, 6)] sage: Permutation([4,1,5,2,6,3]).to_cycles(use_min=False) [(6, 3, 5), (4, 2, 1)] sage: Permutation([6, 4, 5, 2, 3, 1]).to_cycles() [(1, 6), (2, 4), (3, 5)] sage: Permutation([6, 4, 5, 2, 3, 1]).to_cycles(use_min=False) [(6, 1), (5, 3), (4, 2)] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1),Integer(3),Integer(4)]).to_cycles() [(1, 2), (3,), (4,)] >>> Permutation([Integer(2),Integer(1),Integer(3),Integer(4)]).to_cycles(singletons=False) [(1, 2)] >>> Permutation([Integer(2),Integer(1),Integer(3),Integer(4)]).to_cycles(use_min=True) [(1, 2), (3,), (4,)] >>> Permutation([Integer(2),Integer(1),Integer(3),Integer(4)]).to_cycles(use_min=False) [(4,), (3,), (2, 1)] >>> Permutation([Integer(2),Integer(1),Integer(3),Integer(4)]).to_cycles(singletons=False, use_min=False) [(2, 1)] >>> Permutation([Integer(4),Integer(1),Integer(5),Integer(2),Integer(6),Integer(3)]).to_cycles() [(1, 4, 2), (3, 5, 6)] >>> Permutation([Integer(4),Integer(1),Integer(5),Integer(2),Integer(6),Integer(3)]).to_cycles(use_min=False) [(6, 3, 5), (4, 2, 1)] >>> Permutation([Integer(6), Integer(4), Integer(5), Integer(2), Integer(3), Integer(1)]).to_cycles() [(1, 6), (2, 4), (3, 5)] >>> Permutation([Integer(6), Integer(4), Integer(5), Integer(2), Integer(3), Integer(1)]).to_cycles(use_min=False) [(6, 1), (5, 3), (4, 2)] - The algorithm is of complexity \(O(n)\) where \(n\) is the size of the given permutation. 
 - cycle_type()[source]¶
- Return a partition of - len(self)corresponding to the cycle type of- self.- This is a non-increasing sequence of the cycle lengths of - self.- EXAMPLES: - sage: Permutation([3,1,2,4]).cycle_type() # needs sage.combinat [3, 1] - >>> from sage.all import * >>> Permutation([Integer(3),Integer(1),Integer(2),Integer(4)]).cycle_type() # needs sage.combinat [3, 1] 
 - decreasing_runs(as_tuple=False)[source]¶
- Decreasing runs of the permutation. - INPUT: - as_tuple– boolean (default:- False); choice of output format
 - OUTPUT: list of lists or a tuple of tuples - See also - EXAMPLES: - sage: s = Permutation([2,8,3,9,6,4,5,1,7]) sage: s.decreasing_runs() [[2], [8, 3], [9, 6, 4], [5, 1], [7]] sage: s.decreasing_runs(as_tuple=True) ((2,), (8, 3), (9, 6, 4), (5, 1), (7,)) - >>> from sage.all import * >>> s = Permutation([Integer(2),Integer(8),Integer(3),Integer(9),Integer(6),Integer(4),Integer(5),Integer(1),Integer(7)]) >>> s.decreasing_runs() [[2], [8, 3], [9, 6, 4], [5, 1], [7]] >>> s.decreasing_runs(as_tuple=True) ((2,), (8, 3), (9, 6, 4), (5, 1), (7,)) 
 - descent_polynomial()[source]¶
- Return the descent polynomial of the permutation - self.- The descent polynomial of a permutation \(p\) is the product of all the - z[p(i)]where- iranges over the descents of- p.- A descent of a permutation - pis an integer- isuch that- p(i) > p(i+1).- REFERENCES: - EXAMPLES: - sage: Permutation([2,1,3]).descent_polynomial() z2 sage: Permutation([4,3,2,1]).descent_polynomial() z2*z3*z4 - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1),Integer(3)]).descent_polynomial() z2 >>> Permutation([Integer(4),Integer(3),Integer(2),Integer(1)]).descent_polynomial() z2*z3*z4 - Todo - This docstring needs to be fixed. This is not defined in [GS1984] (the descent monomial in their (7.23) is different). 
 - descents(final_descent=False, side='right', positive=False, from_zero=False, index_set=None)[source]¶
- Return the list of the descents of - self.- A descent of a permutation \(p\) is an integer \(i\) such that \(p(i) > p(i+1)\). - Warning - By default, the descents are returned as elements in the index set, i.e., starting at \(1\). If you want them to start at \(0\), set the keyword - from_zeroto- True.- INPUT: - final_descent– boolean (default:- False); if- True, the last position of a non-empty permutation is also considered as a descent
- side–- 'right'(default) or- 'left'; if- 'left', return the descents of the inverse permutation
- positive– boolean (default:- False); if- True, return the positions that are not descents
- from_zero– boolean (default:- False); if- True, return the positions starting from \(0\)
- index_set– list (default:- [1, ..., n-1]where- selfis a permutation of- n); the index set to check for descents
 - EXAMPLES: - sage: Permutation([3,1,2]).descents() [1] sage: Permutation([1,4,3,2]).descents() [2, 3] sage: Permutation([1,4,3,2]).descents(final_descent=True) [2, 3, 4] sage: Permutation([1,4,3,2]).descents(index_set=[1,2]) [2] sage: Permutation([1,4,3,2]).descents(from_zero=True) [1, 2] - >>> from sage.all import * >>> Permutation([Integer(3),Integer(1),Integer(2)]).descents() [1] >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).descents() [2, 3] >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).descents(final_descent=True) [2, 3, 4] >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).descents(index_set=[Integer(1),Integer(2)]) [2] >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).descents(from_zero=True) [1, 2] 
 - descents_composition()[source]¶
- Return the descent composition of - self.- The descent composition of a permutation \(p \in S_n\) is defined as the composition of \(n\) whose descent set equals the descent set of \(p\). Here, the descent set of \(p\) is defined as the set of all \(i \in \{ 1, 2, \ldots, n-1 \}\) satisfying \(p(i) > p(i+1)\). The descent set of a composition \(c = (i_1, i_2, \ldots, i_k)\) is defined as the set \(\{ i_1, i_1 + i_2, i_1 + i_2 + i_3, \ldots, i_1 + i_2 + \cdots + i_{k-1} \}\). - EXAMPLES: - sage: Permutation([1,3,2,4]).descents_composition() [2, 2] sage: Permutation([4,1,6,7,2,3,8,5]).descents_composition() [1, 3, 3, 1] sage: Permutation([]).descents_composition() [] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(3),Integer(2),Integer(4)]).descents_composition() [2, 2] >>> Permutation([Integer(4),Integer(1),Integer(6),Integer(7),Integer(2),Integer(3),Integer(8),Integer(5)]).descents_composition() [1, 3, 3, 1] >>> Permutation([]).descents_composition() [] 
 - destandardize(weight, ordered_alphabet=None)[source]¶
- Return destandardization of - selfwith respect to- weightand- ordered_alphabet.- INPUT: - weight– list or tuple of nonnegative integers that sum to \(n\) if- selfis a permutation in \(S_n\)
- ordered_alphabet– (default:- None) a list or tuple specifying the ordered alphabet the destandardized word is over
 - OUTPUT: word over the - ordered_alphabetwhich standardizes to- self- Let \(weight = (w_1,w_2,\ldots,w_\ell)\). Then this methods looks for an increasing sequence of \(1,2,\ldots, w_1\) and labels all letters in it by 1, then an increasing sequence of \(w_1+1,w_1+2,\ldots,w_1+w_2\) and labels all these letters by 2, etc.. If an increasing sequence for the specified - weightdoes not exist, an error is returned. The output is a word- wover the specified ordered alphabet with evaluation- weightsuch that- w.standard_permutation()is- self.- EXAMPLES: - sage: p = Permutation([1,2,5,3,6,4]) sage: p.destandardize([3,1,2]) # needs sage.combinat word: 113132 sage: p = Permutation([2,1,3]) sage: p.destandardize([2,1]) Traceback (most recent call last): ... ValueError: Standardization with weight [2, 1] is not possible! - >>> from sage.all import * >>> p = Permutation([Integer(1),Integer(2),Integer(5),Integer(3),Integer(6),Integer(4)]) >>> p.destandardize([Integer(3),Integer(1),Integer(2)]) # needs sage.combinat word: 113132 >>> p = Permutation([Integer(2),Integer(1),Integer(3)]) >>> p.destandardize([Integer(2),Integer(1)]) Traceback (most recent call last): ... ValueError: Standardization with weight [2, 1] is not possible! 
 - dict()[source]¶
- Return a dictionary corresponding to the permutation. - EXAMPLES: - sage: p = Permutation([2,1,3]) sage: d = p.dict() sage: d[1] 2 sage: d[2] 1 sage: d[3] 3 - >>> from sage.all import * >>> p = Permutation([Integer(2),Integer(1),Integer(3)]) >>> d = p.dict() >>> d[Integer(1)] 2 >>> d[Integer(2)] 1 >>> d[Integer(3)] 3 
 - fixed_points()[source]¶
- Return a list of the fixed points of - self.- EXAMPLES: - sage: Permutation([1,3,2,4]).fixed_points() [1, 4] sage: Permutation([1,2,3,4]).fixed_points() [1, 2, 3, 4] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(3),Integer(2),Integer(4)]).fixed_points() [1, 4] >>> Permutation([Integer(1),Integer(2),Integer(3),Integer(4)]).fixed_points() [1, 2, 3, 4] 
 - foata_bijection()[source]¶
- Return the image of the permutation - selfunder the Foata bijection \(\phi\).- The bijection shows that \(\mathrm{maj}\) (the major index) and \(\mathrm{inv}\) (the number of inversions) are equidistributed: if \(\phi(P) = Q\), then \(\mathrm{maj}(P) = \mathrm{inv}(Q)\). - The Foata bijection \(\phi\) is a bijection on the set of words with no two equal letters. It can be defined by induction on the size of the word: Given a word \(w_1 w_2 \cdots w_n\), start with \(\phi(w_1) = w_1\). At the \(i\)-th step, if \(\phi(w_1 w_2 \cdots w_i) = v_1 v_2 \cdots v_i\), we define \(\phi(w_1 w_2 \cdots w_i w_{i+1})\) by placing \(w_{i+1}\) on the end of the word \(v_1 v_2 \cdots v_i\) and breaking the word up into blocks as follows. If \(w_{i+1} > v_i\), place a vertical line to the right of each \(v_k\) for which \(w_{i+1} > v_k\). Otherwise, if \(w_{i+1} < v_i\), place a vertical line to the right of each \(v_k\) for which \(w_{i+1} < v_k\). In either case, place a vertical line at the start of the word as well. Now, within each block between vertical lines, cyclically shift the entries one place to the right. - For instance, to compute \(\phi([1,4,2,5,3])\), the sequence of words is - \(1\), 
- \(|1|4 \to 14\), 
- \(|14|2 \to 412\), 
- \(|4|1|2|5 \to 4125\), 
- \(|4|125|3 \to 45123\). 
 - So \(\phi([1,4,2,5,3]) = [4,5,1,2,3]\). - See section 2 of [FS1978], and the proof of Proposition 1.4.6 in [EnumComb1]. - See also - foata_bijection_inverse()for the inverse map.- EXAMPLES: - sage: Permutation([1,2,4,3]).foata_bijection() [4, 1, 2, 3] sage: Permutation([2,5,1,3,4]).foata_bijection() [2, 1, 3, 5, 4] sage: P = Permutation([2,5,1,3,4]) sage: P.major_index() == P.foata_bijection().number_of_inversions() True sage: all( P.major_index() == P.foata_bijection().number_of_inversions() ....: for P in Permutations(4) ) True - >>> from sage.all import * >>> Permutation([Integer(1),Integer(2),Integer(4),Integer(3)]).foata_bijection() [4, 1, 2, 3] >>> Permutation([Integer(2),Integer(5),Integer(1),Integer(3),Integer(4)]).foata_bijection() [2, 1, 3, 5, 4] >>> P = Permutation([Integer(2),Integer(5),Integer(1),Integer(3),Integer(4)]) >>> P.major_index() == P.foata_bijection().number_of_inversions() True >>> all( P.major_index() == P.foata_bijection().number_of_inversions() ... for P in Permutations(Integer(4)) ) True - The example from [FS1978]: - sage: Permutation([7,4,9,2,6,1,5,8,3]).foata_bijection() [4, 7, 2, 6, 1, 9, 5, 8, 3] - >>> from sage.all import * >>> Permutation([Integer(7),Integer(4),Integer(9),Integer(2),Integer(6),Integer(1),Integer(5),Integer(8),Integer(3)]).foata_bijection() [4, 7, 2, 6, 1, 9, 5, 8, 3] - Border cases: - sage: Permutation([]).foata_bijection() [] sage: Permutation([1]).foata_bijection() [1] - >>> from sage.all import * >>> Permutation([]).foata_bijection() [] >>> Permutation([Integer(1)]).foata_bijection() [1] 
 - foata_bijection_inverse()[source]¶
- Return the image of the permutation - selfunder the inverse of the Foata bijection \(\phi\).- See - foata_bijection()for the definition of the Foata bijection.- EXAMPLES: - sage: Permutation([4, 1, 2, 3]).foata_bijection() [1, 2, 4, 3] - >>> from sage.all import * >>> Permutation([Integer(4), Integer(1), Integer(2), Integer(3)]).foata_bijection() [1, 2, 4, 3] 
 - forget_cycles()[source]¶
- Return the image of - selfunder the map which forgets cycles.- Consider a permutation \(\sigma\) written in standard cyclic form: \[\sigma = (a_{1,1}, \ldots, a_{1,k_1}) (a_{2,1}, \ldots, a_{2,k_2}) \cdots (a_{m,1}, \ldots, a_{m,k_m}),\]- where \(a_{1,1} < a_{2,1} < \cdots < a_{m,1}\) and \(a_{j,1} < a_{j,i}\) for all \(1 \leq j \leq m\) and \(2 \leq i \leq k_j\) where we include cycles of length 1 as well. The image of the forget cycle map \(\phi\) is given by \[\phi(\sigma) = [a_{1,1}, \ldots, a_{1,k_1}, a_{2,1}, \ldots, a_{2,k_2}, \ldots, a_{m,1}, \ldots, a_{m,k_m}],\]- considered as a permutation in 1-line notation. - See also - fundamental_transformation(), which is a similar map that is defined by instead taking \(a_{j,1} > a_{j,i}\) and is bijective.- EXAMPLES: - sage: P = Permutations(5) sage: x = P([1, 5, 3, 4, 2]) sage: x.forget_cycles() [1, 2, 5, 3, 4] - >>> from sage.all import * >>> P = Permutations(Integer(5)) >>> x = P([Integer(1), Integer(5), Integer(3), Integer(4), Integer(2)]) >>> x.forget_cycles() [1, 2, 5, 3, 4] - We select all permutations with a cycle composition of \([2, 3, 1]\) in \(S_6\): - sage: P = Permutations(6) sage: l = [p for p in P if [len(t) for t in p.to_cycles()] == [1,3,2]] - >>> from sage.all import * >>> P = Permutations(Integer(6)) >>> l = [p for p in P if [len(t) for t in p.to_cycles()] == [Integer(1),Integer(3),Integer(2)]] - Next we apply \(\phi\) and then take the inverse, and then view the results as a poset under the Bruhat order: - sage: l = [p.forget_cycles().inverse() for p in l] sage: B = Poset([l, lambda x,y: x.bruhat_lequal(y)]) # needs sage.combinat sage.graphs sage: R.<q> = QQ[] sage: sum(q^B.rank_function()(x) for x in B) # needs sage.combinat sage.graphs q^5 + 2*q^4 + 3*q^3 + 3*q^2 + 2*q + 1 - >>> from sage.all import * >>> l = [p.forget_cycles().inverse() for p in l] >>> B = Poset([l, lambda x,y: x.bruhat_lequal(y)]) # needs sage.combinat sage.graphs >>> R = QQ['q']; (q,) = R._first_ngens(1) >>> sum(q**B.rank_function()(x) for x in B) # needs sage.combinat sage.graphs q^5 + 2*q^4 + 3*q^3 + 3*q^2 + 2*q + 1 - We check the statement in [CC2013] that the posets \(C_{[1,3,1,1]}\) and \(C_{[1,3,2]}\) are isomorphic: - sage: l2 = [p for p in P if [len(t) for t in p.to_cycles()] == [1,3,1,1]] sage: l2 = [p.forget_cycles().inverse() for p in l2] sage: B2 = Poset([l2, lambda x,y: x.bruhat_lequal(y)]) # needs sage.combinat sage.graphs sage: B.is_isomorphic(B2) # needs sage.combinat sage.graphs True - >>> from sage.all import * >>> l2 = [p for p in P if [len(t) for t in p.to_cycles()] == [Integer(1),Integer(3),Integer(1),Integer(1)]] >>> l2 = [p.forget_cycles().inverse() for p in l2] >>> B2 = Poset([l2, lambda x,y: x.bruhat_lequal(y)]) # needs sage.combinat sage.graphs >>> B.is_isomorphic(B2) # needs sage.combinat sage.graphs True - See also 
 - fundamental_transformation()[source]¶
- Return the image of the permutation - selfunder the Renyi-Foata-Schuetzenberger fundamental transformation.- The fundamental transformation is a bijection from the set of all permutations of \(\{1, 2, \ldots, n\}\) to itself, which transforms any such permutation \(w\) as follows: Write \(w\) in cycle form, with each cycle starting with its highest element, and the cycles being sorted in increasing order of their highest elements. Drop the parentheses in the resulting expression, thus reading it as a one-line notation of a new permutation \(u\). Then, \(u\) is the image of \(w\) under the fundamental transformation. - See [EnumComb1], Proposition 1.3.1. - See also - fundamental_transformation_inverse()for the inverse map.- forget_cycles()for a similar (but non-bijective) map where each cycle is starting from its lowest element.- EXAMPLES: - sage: Permutation([5, 1, 3, 4, 2]).fundamental_transformation() [3, 4, 5, 2, 1] sage: Permutations(5)([1, 5, 3, 4, 2]).fundamental_transformation() [1, 3, 4, 5, 2] sage: Permutation([8, 4, 7, 2, 9, 6, 5, 1, 3]).fundamental_transformation() [4, 2, 6, 8, 1, 9, 3, 7, 5] - >>> from sage.all import * >>> Permutation([Integer(5), Integer(1), Integer(3), Integer(4), Integer(2)]).fundamental_transformation() [3, 4, 5, 2, 1] >>> Permutations(Integer(5))([Integer(1), Integer(5), Integer(3), Integer(4), Integer(2)]).fundamental_transformation() [1, 3, 4, 5, 2] >>> Permutation([Integer(8), Integer(4), Integer(7), Integer(2), Integer(9), Integer(6), Integer(5), Integer(1), Integer(3)]).fundamental_transformation() [4, 2, 6, 8, 1, 9, 3, 7, 5] - Comparison with - forget_cycles():- sage: P = Permutation([(1,3,4),(2,5)]) sage: P [3, 5, 4, 1, 2] sage: P.forget_cycles() [1, 3, 4, 2, 5] sage: P.fundamental_transformation() [4, 1, 3, 5, 2] - >>> from sage.all import * >>> P = Permutation([(Integer(1),Integer(3),Integer(4)),(Integer(2),Integer(5))]) >>> P [3, 5, 4, 1, 2] >>> P.forget_cycles() [1, 3, 4, 2, 5] >>> P.fundamental_transformation() [4, 1, 3, 5, 2] 
 - fundamental_transformation_inverse()[source]¶
- Return the image of the permutation - selfunder the inverse of the Renyi-Foata-Schuetzenberger fundamental transformation.- The inverse of the fundamental transformation is a bijection from the set of all permutations of \(\{1, 2, \ldots, n\}\) to itself, which transforms any such permutation \(w\) as follows: Let \(I = \{ i_1 < i_2 < \cdots < i_k \}\) be the set of all left-to-right maxima of \(w\) (that is, of all indices \(j\) such that \(w(j)\) is bigger than each of \(w(1), w(2), \ldots, w(j-1)\)). The image of \(w\) under the inverse of the fundamental transformation is the permutation \(u\) that sends \(w(i-1)\) to \(w(i)\) for all \(i \notin I\) (notice that this makes sense, since \(1 \in I\) whenever \(n > 0\)), while sending each \(w(i_p - 1)\) (with \(p \geq 2\)) to \(w(i_{p-1})\). Here, we set \(i_{k+1} = n+1\). - See [EnumComb1], Proposition 1.3.1. - See also - fundamental_transformation()for the inverse map.- EXAMPLES: - sage: Permutation([3, 4, 5, 2, 1]).fundamental_transformation_inverse() [5, 1, 3, 4, 2] sage: Permutation([4, 2, 6, 8, 1, 9, 3, 7, 5]).fundamental_transformation_inverse() [8, 4, 7, 2, 9, 6, 5, 1, 3] - >>> from sage.all import * >>> Permutation([Integer(3), Integer(4), Integer(5), Integer(2), Integer(1)]).fundamental_transformation_inverse() [5, 1, 3, 4, 2] >>> Permutation([Integer(4), Integer(2), Integer(6), Integer(8), Integer(1), Integer(9), Integer(3), Integer(7), Integer(5)]).fundamental_transformation_inverse() [8, 4, 7, 2, 9, 6, 5, 1, 3] 
 - grade()[source]¶
- Return the size of - self.- EXAMPLES: - sage: Permutation([3,4,1,2,5]).size() 5 - >>> from sage.all import * >>> Permutation([Integer(3),Integer(4),Integer(1),Integer(2),Integer(5)]).size() 5 
 - has_nth_root(n)[source]¶
- Check if - selfhas \(n\)-th roots.- An \(n\)-th root of the permutation \(\sigma\) is a permutation \(\gamma\) such that \(\gamma^n = \sigma\). - Note that the number of \(n\)-th roots only depends on the cycle type of - self.- EXAMPLES: - sage: # needs sage.combinat sage: sigma = Permutations(5).identity() sage: sigma.has_nth_root(3) True sage: sigma = Permutation('(1, 3)') sage: sigma.has_nth_root(2) False - >>> from sage.all import * >>> # needs sage.combinat >>> sigma = Permutations(Integer(5)).identity() >>> sigma.has_nth_root(Integer(3)) True >>> sigma = Permutation('(1, 3)') >>> sigma.has_nth_root(Integer(2)) False - See also 
 - has_pattern(patt)[source]¶
- Test whether the permutation - selfcontains the pattern- patt.- EXAMPLES: - sage: Permutation([3,5,1,4,6,2]).has_pattern([1,3,2]) # needs sage.combinat True - >>> from sage.all import * >>> Permutation([Integer(3),Integer(5),Integer(1),Integer(4),Integer(6),Integer(2)]).has_pattern([Integer(1),Integer(3),Integer(2)]) # needs sage.combinat True 
 - hyperoctahedral_double_coset_type()[source]¶
- Return the coset-type of - selfas a partition.- selfmust be a permutation of even size \(2n\). The coset-type determines the double class of the permutation, that is its image in \(H_n \backslash S_{2n} / H_n\), where \(H_n\) is the \(n\)-th hyperoctahedral group.- The coset-type is determined as follows. Consider the perfect matching \(\{\{1,2\},\{3,4\},\dots,\{2n-1,2n\}\}\) and its image by - self, and draw them simultaneously as edges of a graph whose vertices are labeled by \(1,2,\dots,2n\). The coset-type is the ordered sequence of the semi-lengths of the cycles of this graph (see Chapter VII of [Mac1995] for more details, particularly Section VII.2).- EXAMPLES: - sage: # needs sage.combinat sage: p = Permutation([3, 4, 6, 1, 5, 7, 2, 8]) sage: p.hyperoctahedral_double_coset_type() [3, 1] sage: all(p.hyperoctahedral_double_coset_type() == ....: p.inverse().hyperoctahedral_double_coset_type() ....: for p in Permutations(4)) True sage: Permutation([]).hyperoctahedral_double_coset_type() [] sage: Permutation([3,1,2]).hyperoctahedral_double_coset_type() Traceback (most recent call last): ... ValueError: [3, 1, 2] is a permutation of odd size and has no coset-type - >>> from sage.all import * >>> # needs sage.combinat >>> p = Permutation([Integer(3), Integer(4), Integer(6), Integer(1), Integer(5), Integer(7), Integer(2), Integer(8)]) >>> p.hyperoctahedral_double_coset_type() [3, 1] >>> all(p.hyperoctahedral_double_coset_type() == ... p.inverse().hyperoctahedral_double_coset_type() ... for p in Permutations(Integer(4))) True >>> Permutation([]).hyperoctahedral_double_coset_type() [] >>> Permutation([Integer(3),Integer(1),Integer(2)]).hyperoctahedral_double_coset_type() Traceback (most recent call last): ... ValueError: [3, 1, 2] is a permutation of odd size and has no coset-type 
 - idescents(final_descent=False, from_zero=False)[source]¶
- Return a list of the idescents of - self, that is the list of the descents of- self’s inverse.- A descent of a permutation - pis an integer- isuch that- p(i) > p(i+1).- Warning - By default, the descents are returned as elements in the index set, i.e., starting at \(1\). If you want them to start at \(0\), set the keyword - from_zeroto- True.- INPUT: - final_descent– boolean (default:- False); if- True, the last position of a non-empty permutation is also considered as a descent
- from_zero– boolean (default:- False); if- False, return the positions starting from \(1\)
 - EXAMPLES: - sage: Permutation([2,3,1]).idescents() [1] sage: Permutation([1,4,3,2]).idescents() [2, 3] sage: Permutation([1,4,3,2]).idescents(final_descent=True) [2, 3, 4] sage: Permutation([1,4,3,2]).idescents(from_zero=True) [1, 2] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(3),Integer(1)]).idescents() [1] >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).idescents() [2, 3] >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).idescents(final_descent=True) [2, 3, 4] >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).idescents(from_zero=True) [1, 2] 
 - idescents_signature(final_descent=False)[source]¶
- Return the list obtained as follows: Each position in - selfis mapped to \(-1\) if it is an idescent and \(1\) if it is not an idescent.- See - idescents()for a definition of idescents.- With the - final_descentoption, the last position of a non-empty permutation is also considered as a descent.- EXAMPLES: - sage: Permutation([1,4,3,2]).idescents() [2, 3] sage: Permutation([1,4,3,2]).idescents_signature() [1, -1, -1, 1] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).idescents() [2, 3] >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).idescents_signature() [1, -1, -1, 1] 
 - imajor_index(final_descent=False)[source]¶
- Return the inverse major index of the permutation - self, which is the major index of the inverse of- self.- The major index of a permutation \(p\) is the sum of the descents of \(p\). Since our permutation indices are 0-based, we need to add the number of descents. - With the - final_descentoption, the last position of a non-empty permutation is also considered as a descent.- EXAMPLES: - sage: Permutation([2,1,3]).imajor_index() 1 sage: Permutation([3,4,1,2]).imajor_index() 2 sage: Permutation([4,3,2,1]).imajor_index() 6 - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1),Integer(3)]).imajor_index() 1 >>> Permutation([Integer(3),Integer(4),Integer(1),Integer(2)]).imajor_index() 2 >>> Permutation([Integer(4),Integer(3),Integer(2),Integer(1)]).imajor_index() 6 
 - increasing_tree(compare=<built-in function min>)[source]¶
- Return the increasing tree associated to - self.- EXAMPLES: - sage: Permutation([1,4,3,2]).increasing_tree() # needs sage.graphs 1[., 2[3[4[., .], .], .]] sage: Permutation([4,1,3,2]).increasing_tree() # needs sage.graphs 1[4[., .], 2[3[., .], .]] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).increasing_tree() # needs sage.graphs 1[., 2[3[4[., .], .], .]] >>> Permutation([Integer(4),Integer(1),Integer(3),Integer(2)]).increasing_tree() # needs sage.graphs 1[4[., .], 2[3[., .], .]] - By passing the option - compare=maxone can have the decreasing tree instead:- sage: Permutation([2,3,4,1]).increasing_tree(max) # needs sage.graphs 4[3[2[., .], .], 1[., .]] sage: Permutation([2,3,1,4]).increasing_tree(max) # needs sage.graphs 4[3[2[., .], 1[., .]], .] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(3),Integer(4),Integer(1)]).increasing_tree(max) # needs sage.graphs 4[3[2[., .], .], 1[., .]] >>> Permutation([Integer(2),Integer(3),Integer(1),Integer(4)]).increasing_tree(max) # needs sage.graphs 4[3[2[., .], 1[., .]], .] 
 - increasing_tree_shape(compare=<built-in function min>)[source]¶
- Return the shape of the increasing tree associated with the permutation. - EXAMPLES: - sage: Permutation([1,4,3,2]).increasing_tree_shape() # needs sage.graphs [., [[[., .], .], .]] sage: Permutation([4,1,3,2]).increasing_tree_shape() # needs sage.graphs [[., .], [[., .], .]] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).increasing_tree_shape() # needs sage.graphs [., [[[., .], .], .]] >>> Permutation([Integer(4),Integer(1),Integer(3),Integer(2)]).increasing_tree_shape() # needs sage.graphs [[., .], [[., .], .]] - By passing the option - compare=maxone can have the decreasing tree instead:- sage: Permutation([2,3,4,1]).increasing_tree_shape(max) # needs sage.graphs [[[., .], .], [., .]] sage: Permutation([2,3,1,4]).increasing_tree_shape(max) # needs sage.graphs [[[., .], [., .]], .] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(3),Integer(4),Integer(1)]).increasing_tree_shape(max) # needs sage.graphs [[[., .], .], [., .]] >>> Permutation([Integer(2),Integer(3),Integer(1),Integer(4)]).increasing_tree_shape(max) # needs sage.graphs [[[., .], [., .]], .] 
 - inverse()[source]¶
- Return the inverse of - self.- EXAMPLES: - sage: Permutation([3,8,5,10,9,4,6,1,7,2]).inverse() [8, 10, 1, 6, 3, 7, 9, 2, 5, 4] sage: Permutation([2, 4, 1, 5, 3]).inverse() [3, 1, 5, 2, 4] sage: ~Permutation([2, 4, 1, 5, 3]) [3, 1, 5, 2, 4] - >>> from sage.all import * >>> Permutation([Integer(3),Integer(8),Integer(5),Integer(10),Integer(9),Integer(4),Integer(6),Integer(1),Integer(7),Integer(2)]).inverse() [8, 10, 1, 6, 3, 7, 9, 2, 5, 4] >>> Permutation([Integer(2), Integer(4), Integer(1), Integer(5), Integer(3)]).inverse() [3, 1, 5, 2, 4] >>> ~Permutation([Integer(2), Integer(4), Integer(1), Integer(5), Integer(3)]) [3, 1, 5, 2, 4] 
 - inversions()[source]¶
- Return a list of the inversions of - self.- An inversion of a permutation \(p\) is a pair \((i, j)\) such that \(i < j\) and \(p(i) > p(j)\). - EXAMPLES: - sage: Permutation([3,2,4,1,5]).inversions() [(1, 2), (1, 4), (2, 4), (3, 4)] - >>> from sage.all import * >>> Permutation([Integer(3),Integer(2),Integer(4),Integer(1),Integer(5)]).inversions() [(1, 2), (1, 4), (2, 4), (3, 4)] 
 - is_derangement()[source]¶
- Return whether - selfis a derangement.- A permutation \(\sigma\) is a derangement if \(\sigma\) has no fixed points. - EXAMPLES: - sage: P = Permutation([1,4,2,3]) sage: P.is_derangement() False sage: P = Permutation([2,3,1]) sage: P.is_derangement() True - >>> from sage.all import * >>> P = Permutation([Integer(1),Integer(4),Integer(2),Integer(3)]) >>> P.is_derangement() False >>> P = Permutation([Integer(2),Integer(3),Integer(1)]) >>> P.is_derangement() True 
 - is_even()[source]¶
- Return - Trueif the permutation- selfis even and- Falseotherwise.- EXAMPLES: - sage: Permutation([1,2,3]).is_even() True sage: Permutation([2,1,3]).is_even() False - >>> from sage.all import * >>> Permutation([Integer(1),Integer(2),Integer(3)]).is_even() True >>> Permutation([Integer(2),Integer(1),Integer(3)]).is_even() False 
 - is_simple()[source]¶
- Return whether - selfis simple.- A permutation is simple if it does not send any proper sub-interval to a sub-interval. - For instance, - [6,1,3,5,2,4]is not simple because it maps the interval- [3,4,5,6]to- [2,3,4,5], whereas- [2,6,3,5,1,4]is simple.- EXAMPLES: - sage: g = Permutation([4,2,3,1]) sage: g.is_simple() False sage: g = Permutation([6,1,3,5,2,4]) sage: g.is_simple() False sage: g = Permutation([2,6,3,5,1,4]) sage: g.is_simple() True sage: [len([pi for pi in Permutations(n) if pi.is_simple()]) ....: for n in range(6)] [1, 1, 2, 0, 2, 6] - >>> from sage.all import * >>> g = Permutation([Integer(4),Integer(2),Integer(3),Integer(1)]) >>> g.is_simple() False >>> g = Permutation([Integer(6),Integer(1),Integer(3),Integer(5),Integer(2),Integer(4)]) >>> g.is_simple() False >>> g = Permutation([Integer(2),Integer(6),Integer(3),Integer(5),Integer(1),Integer(4)]) >>> g.is_simple() True >>> [len([pi for pi in Permutations(n) if pi.is_simple()]) ... for n in range(Integer(6))] [1, 1, 2, 0, 2, 6] 
 - ishift(i)[source]¶
- Return the - i-shift of- self. If an- i-shift of- selfcan’t be performed, then- selfis returned.- An \(i\)-shift can be applied when \(i\) is not inbetween \(i-1\) and \(i+1\). The \(i\)-shift moves \(i\) to the other side, and leaves the relative positions of \(i-1\) and \(i+1\) in place. All other entries of the permutations are also left in place. - EXAMPLES: - Here, \(2\) is to the left of both \(1\) and \(3\). A \(2\)-shift can be applied which moves the \(2\) to the right and leaves \(1\) and \(3\) in their same relative order: - sage: Permutation([2,1,3]).ishift(2) [1, 3, 2] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1),Integer(3)]).ishift(Integer(2)) [1, 3, 2] - All entries other than \(i\), \(i-1\) and \(i+1\) are unchanged: - sage: Permutation([2,4,1,3]).ishift(2) [1, 4, 3, 2] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(4),Integer(1),Integer(3)]).ishift(Integer(2)) [1, 4, 3, 2] - Since \(2\) is between \(1\) and \(3\) in - [1,2,3], a \(2\)-shift cannot be applied to- [1,2,3]- sage: Permutation([1,2,3]).ishift(2) [1, 2, 3] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(2),Integer(3)]).ishift(Integer(2)) [1, 2, 3] 
 - iswitch(i)[source]¶
- Return the - i-switch of- self. If an- i-switch of- selfcan’t be performed, then- selfis returned.- An \(i\)-switch can be applied when the subsequence of - selfformed by the entries \(i-1\), \(i\) and \(i+1\) is neither increasing nor decreasing. In this case, this subsequence is reversed (i. e., its leftmost element and its rightmost element switch places), while all other letters of- selfare kept in place.- EXAMPLES: - Here, \(2\) is to the left of both \(1\) and \(3\). A \(2\)-switch can be applied which moves the \(2\) to the right and switches the relative order between \(1\) and \(3\): - sage: Permutation([2,1,3]).iswitch(2) [3, 1, 2] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1),Integer(3)]).iswitch(Integer(2)) [3, 1, 2] - All entries other than \(i-1\), \(i\) and \(i+1\) are unchanged: - sage: Permutation([2,4,1,3]).iswitch(2) [3, 4, 1, 2] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(4),Integer(1),Integer(3)]).iswitch(Integer(2)) [3, 4, 1, 2] - Since \(2\) is between \(1\) and \(3\) in - [1,2,3], a \(2\)-switch cannot be applied to- [1,2,3]- sage: Permutation([1,2,3]).iswitch(2) [1, 2, 3] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(2),Integer(3)]).iswitch(Integer(2)) [1, 2, 3] 
 - left_action_product(lp)[source]¶
- Return the permutation obtained by composing - selfwith- lpin such an order that- lpis applied first and- selfis applied afterwards.- This is usually denoted by either - self * lpor- lp * selfdepending on the conventions used by the author. If the value of a permutation \(p \in S_n\) on an integer \(i \in \{ 1, 2, \cdots, n \}\) is denoted by \(p(i)\), then this should be denoted by- self * lpin order to have associativity (i.e., in order to have \((p \cdot q)(i) = p(q(i))\) for all \(p\), \(q\) and \(i\)). If, on the other hand, the value of a permutation \(p \in S_n\) on an integer \(i \in \{ 1, 2, \cdots, n \}\) is denoted by \(i^p\), then this should be denoted by- lp * selfin order to have associativity (i.e., in order to have \(i^{p \cdot q} = (i^p)^q\) for all \(p\), \(q\) and \(i\)).- EXAMPLES: - sage: p = Permutation([2,1,3]) sage: q = Permutation([3,1,2]) sage: p.left_action_product(q) [3, 2, 1] sage: q.left_action_product(p) [1, 3, 2] - >>> from sage.all import * >>> p = Permutation([Integer(2),Integer(1),Integer(3)]) >>> q = Permutation([Integer(3),Integer(1),Integer(2)]) >>> p.left_action_product(q) [3, 2, 1] >>> q.left_action_product(p) [1, 3, 2] 
 - left_tableau()[source]¶
- Return the left standard tableau after performing the RSK algorithm on - self.- EXAMPLES: - sage: Permutation([1,4,3,2]).left_tableau() # needs sage.combinat [[1, 2], [3], [4]] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).left_tableau() # needs sage.combinat [[1, 2], [3], [4]] 
 - length()[source]¶
- Return the Coxeter length of - self.- The length of a permutation \(p\) is given by the number of inversions of \(p\). - EXAMPLES: - sage: Permutation([5, 1, 3, 4, 2]).length() 6 - >>> from sage.all import * >>> Permutation([Integer(5), Integer(1), Integer(3), Integer(4), Integer(2)]).length() 6 
 - longest_increasing_subsequence_length()[source]¶
- Return the length of the longest increasing subsequences of - self.- EXAMPLES: - sage: Permutation([2,3,1,4]).longest_increasing_subsequence_length() 3 sage: all(i.longest_increasing_subsequence_length() == len(RSK(i)[0][0]) # needs sage.combinat ....: for i in Permutations(5)) True sage: Permutation([]).longest_increasing_subsequence_length() 0 - >>> from sage.all import * >>> Permutation([Integer(2),Integer(3),Integer(1),Integer(4)]).longest_increasing_subsequence_length() 3 >>> all(i.longest_increasing_subsequence_length() == len(RSK(i)[Integer(0)][Integer(0)]) # needs sage.combinat ... for i in Permutations(Integer(5))) True >>> Permutation([]).longest_increasing_subsequence_length() 0 
 - longest_increasing_subsequences()[source]¶
- Return the list of the longest increasing subsequences of - self.- A theorem of Schensted ([Sch1961]) states that an increasing subsequence of length \(i\) ends with the value entered in the \(i\)-th column of the p-tableau. The algorithm records which column of the p-tableau each value of the permutation is entered into, creates a digraph to record all increasing subsequences, and reads the paths from a source to a sink; these are the longest increasing subsequences. - EXAMPLES: - sage: Permutation([2,3,4,1]).longest_increasing_subsequences() # needs sage.graphs [[2, 3, 4]] sage: Permutation([5, 7, 1, 2, 6, 4, 3]).longest_increasing_subsequences() # needs sage.graphs [[1, 2, 6], [1, 2, 4], [1, 2, 3]] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(3),Integer(4),Integer(1)]).longest_increasing_subsequences() # needs sage.graphs [[2, 3, 4]] >>> Permutation([Integer(5), Integer(7), Integer(1), Integer(2), Integer(6), Integer(4), Integer(3)]).longest_increasing_subsequences() # needs sage.graphs [[1, 2, 6], [1, 2, 4], [1, 2, 3]] - Note - This algorithm could be made faster using a balanced search tree for each column instead of sorted lists. See discussion on Issue #31451. 
 - longest_increasing_subsequences_number()[source]¶
- Return the number of increasing subsequences of maximal length in - self.- The list of longest increasing subsequences of a permutation is given by - longest_increasing_subsequences(), and the length of these subsequences is given by- longest_increasing_subsequence_length().- The algorithm is similar to - longest_increasing_subsequences(). Namely, the longest increasing subsequences are encoded as increasing sequences in a ranked poset from a smallest to a largest element. Their number can be obtained via dynamic programming: for each \(v\) in the poset we compute the number of paths from a smallest element to \(v\).- EXAMPLES: - sage: sum(p.longest_increasing_subsequences_number() ....: for p in Permutations(8)) 120770 sage: p = Permutations(50).random_element() sage: (len(p.longest_increasing_subsequences()) == # needs sage.graphs ....: p.longest_increasing_subsequences_number()) True - >>> from sage.all import * >>> sum(p.longest_increasing_subsequences_number() ... for p in Permutations(Integer(8))) 120770 >>> p = Permutations(Integer(50)).random_element() >>> (len(p.longest_increasing_subsequences()) == # needs sage.graphs ... p.longest_increasing_subsequences_number()) True 
 - major_index(final_descent=False)[source]¶
- Return the major index of - self.- The major index of a permutation \(p\) is the sum of the descents of \(p\). Since our permutation indices are 0-based, we need to add the number of descents. - With the - final_descentoption, the last position of a non-empty permutation is also considered as a descent.- EXAMPLES: - sage: Permutation([2,1,3]).major_index() 1 sage: Permutation([3,4,1,2]).major_index() 2 sage: Permutation([4,3,2,1]).major_index() 6 - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1),Integer(3)]).major_index() 1 >>> Permutation([Integer(3),Integer(4),Integer(1),Integer(2)]).major_index() 2 >>> Permutation([Integer(4),Integer(3),Integer(2),Integer(1)]).major_index() 6 
 - multi_major_index(composition)[source]¶
- Return the multimajor index of this permutation with respect to - composition.- INPUT: - composition– a composition of the- size()of this permutation
 - EXAMPLES: - sage: p = Permutation([5, 6, 2, 1, 3, 7, 4]) sage: p.multi_major_index([3, 2, 2]) [2, 0, 1] sage: p.multi_major_index([7]) == [p.major_index()] True sage: p.multi_major_index([1]*7) [0, 0, 0, 0, 0, 0, 0] sage: Permutation([]).multi_major_index([]) [] - >>> from sage.all import * >>> p = Permutation([Integer(5), Integer(6), Integer(2), Integer(1), Integer(3), Integer(7), Integer(4)]) >>> p.multi_major_index([Integer(3), Integer(2), Integer(2)]) [2, 0, 1] >>> p.multi_major_index([Integer(7)]) == [p.major_index()] True >>> p.multi_major_index([Integer(1)]*Integer(7)) [0, 0, 0, 0, 0, 0, 0] >>> Permutation([]).multi_major_index([]) [] - REFERENCES: 
 - next()[source]¶
- Return the permutation that follows - selfon the symmetric group containing- self. If- selfis the last permutation, then- nextreturns- False. If the- algorithmparameter is specified, the permutations will be generated according to it. Supported algorithms are:- lex: lexicographic order generation, this is the default algorithm.
- sjt: Steinhaus-Johnson-Trotter algorithm to generate permutations using only transposition of two elements in the list. It is highly recommended to set- check=True(default value).
 - EXAMPLES: - sage: p = Permutation([1, 3, 2]) sage: next(p) [2, 1, 3] sage: p = Permutation([4,3,2,1]) sage: next(p) False sage: p = Permutation([1, 2, 3], algorithm='sjt') sage: p = next(p); p [1, 3, 2] sage: p = next(p); p [3, 1, 2] - >>> from sage.all import * >>> p = Permutation([Integer(1), Integer(3), Integer(2)]) >>> next(p) [2, 1, 3] >>> p = Permutation([Integer(4),Integer(3),Integer(2),Integer(1)]) >>> next(p) False >>> p = Permutation([Integer(1), Integer(2), Integer(3)], algorithm='sjt') >>> p = next(p); p [1, 3, 2] >>> p = next(p); p [3, 1, 2] 
 - noninversions(k)[source]¶
- Return the list of all - k-noninversions in- self.- If \(k\) is an integer and \(p \in S_n\) is a permutation, then a \(k\)-noninversion in \(p\) is defined as a strictly increasing sequence \((i_1, i_2, \ldots, i_k)\) of elements of \(\{ 1, 2, \ldots, n \}\) satisfying \(p(i_1) < p(i_2) < \cdots < p(i_k)\). (In other words, a \(k\)-noninversion in \(p\) can be regarded as a \(k\)-element subset of \(\{ 1, 2, \ldots, n \}\) on which \(p\) restricts to an increasing map.) - EXAMPLES: - sage: p = Permutation([3, 2, 4, 1, 5]) sage: p.noninversions(1) [[3], [2], [4], [1], [5]] sage: p.noninversions(2) [[3, 4], [3, 5], [2, 4], [2, 5], [4, 5], [1, 5]] sage: p.noninversions(3) [[3, 4, 5], [2, 4, 5]] sage: p.noninversions(4) [] sage: p.noninversions(5) [] - >>> from sage.all import * >>> p = Permutation([Integer(3), Integer(2), Integer(4), Integer(1), Integer(5)]) >>> p.noninversions(Integer(1)) [[3], [2], [4], [1], [5]] >>> p.noninversions(Integer(2)) [[3, 4], [3, 5], [2, 4], [2, 5], [4, 5], [1, 5]] >>> p.noninversions(Integer(3)) [[3, 4, 5], [2, 4, 5]] >>> p.noninversions(Integer(4)) [] >>> p.noninversions(Integer(5)) [] 
 - nth_roots(n)[source]¶
- Return all \(n\)-th roots of - self(as a generator).- An \(n\)-th root of the permutation \(\sigma\) is a permutation \(\gamma\) such that \(\gamma^n = \sigma\). - Note that the number of \(n\)-th roots only depends on the cycle type of - self.- EXAMPLES: - sage: # needs sage.combinat sage: sigma = Permutations(5).identity() sage: list(sigma.nth_roots(3)) [[1, 4, 3, 5, 2], [1, 5, 3, 2, 4], [1, 2, 4, 5, 3], [1, 2, 5, 3, 4], [4, 2, 3, 5, 1], [5, 2, 3, 1, 4], [3, 2, 5, 4, 1], [5, 2, 1, 4, 3], [2, 5, 3, 4, 1], [5, 1, 3, 4, 2], [2, 3, 1, 4, 5], [3, 1, 2, 4, 5], [2, 4, 3, 1, 5], [4, 1, 3, 2, 5], [3, 2, 4, 1, 5], [4, 2, 1, 3, 5], [1, 3, 4, 2, 5], [1, 4, 2, 3, 5], [1, 3, 5, 4, 2], [1, 5, 2, 4, 3], [1, 2, 3, 4, 5]] sage: sigma = Permutation('(1, 3)') sage: list(sigma.nth_roots(2)) [] - >>> from sage.all import * >>> # needs sage.combinat >>> sigma = Permutations(Integer(5)).identity() >>> list(sigma.nth_roots(Integer(3))) [[1, 4, 3, 5, 2], [1, 5, 3, 2, 4], [1, 2, 4, 5, 3], [1, 2, 5, 3, 4], [4, 2, 3, 5, 1], [5, 2, 3, 1, 4], [3, 2, 5, 4, 1], [5, 2, 1, 4, 3], [2, 5, 3, 4, 1], [5, 1, 3, 4, 2], [2, 3, 1, 4, 5], [3, 1, 2, 4, 5], [2, 4, 3, 1, 5], [4, 1, 3, 2, 5], [3, 2, 4, 1, 5], [4, 2, 1, 3, 5], [1, 3, 4, 2, 5], [1, 4, 2, 3, 5], [1, 3, 5, 4, 2], [1, 5, 2, 4, 3], [1, 2, 3, 4, 5]] >>> sigma = Permutation('(1, 3)') >>> list(sigma.nth_roots(Integer(2))) [] - For \(n \geq 6\), this algorithm begins to be more efficient than naive search (look at all permutations and test their \(n\)-th power). - See also 
 - number_of_descents(final_descent=False)[source]¶
- Return the number of descents of - self.- With the - final_descentoption, the last position of a non-empty permutation is also considered as a descent.- EXAMPLES: - sage: Permutation([1,4,3,2]).number_of_descents() 2 sage: Permutation([1,4,3,2]).number_of_descents(final_descent=True) 3 - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).number_of_descents() 2 >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).number_of_descents(final_descent=True) 3 
 - number_of_fixed_points()[source]¶
- Return the number of fixed points of - self.- EXAMPLES: - sage: Permutation([1,3,2,4]).number_of_fixed_points() 2 sage: Permutation([1,2,3,4]).number_of_fixed_points() 4 - >>> from sage.all import * >>> Permutation([Integer(1),Integer(3),Integer(2),Integer(4)]).number_of_fixed_points() 2 >>> Permutation([Integer(1),Integer(2),Integer(3),Integer(4)]).number_of_fixed_points() 4 
 - number_of_idescents(final_descent=False)[source]¶
- Return the number of idescents of - self.- See - idescents()for a definition of idescents.- With the - final_descentoption, the last position of a non-empty permutation is also considered as a descent.- EXAMPLES: - sage: Permutation([1,4,3,2]).number_of_idescents() 2 sage: Permutation([1,4,3,2]).number_of_idescents(final_descent=True) 3 - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).number_of_idescents() 2 >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).number_of_idescents(final_descent=True) 3 
 - number_of_inversions()[source]¶
- Return the number of inversions in - self.- An inversion of a permutation is a pair of elements \((i, j)\) with \(i < j\) and \(p(i) > p(j)\). - REFERENCES: - EXAMPLES: - sage: Permutation([3, 2, 4, 1, 5]).number_of_inversions() 4 sage: Permutation([1, 2, 6, 4, 7, 3, 5]).number_of_inversions() 6 - >>> from sage.all import * >>> Permutation([Integer(3), Integer(2), Integer(4), Integer(1), Integer(5)]).number_of_inversions() 4 >>> Permutation([Integer(1), Integer(2), Integer(6), Integer(4), Integer(7), Integer(3), Integer(5)]).number_of_inversions() 6 
 - number_of_noninversions(k)[source]¶
- Return the number of - k-noninversions in- self.- If \(k\) is an integer and \(p \in S_n\) is a permutation, then a \(k\)-noninversion in \(p\) is defined as a strictly increasing sequence \((i_1, i_2, \ldots, i_k)\) of elements of \(\{ 1, 2, \ldots, n \}\) satisfying \(p(i_1) < p(i_2) < \cdots < p(i_k)\). (In other words, a \(k\)-noninversion in \(p\) can be regarded as a \(k\)-element subset of \(\{ 1, 2, \ldots, n \}\) on which \(p\) restricts to an increasing map.) - The number of \(k\)-noninversions in \(p\) has been denoted by \(\mathrm{noninv}_k(p)\) in [RSW2011], where conjectures and results regarding this number have been stated. - EXAMPLES: - sage: p = Permutation([3, 2, 4, 1, 5]) sage: p.number_of_noninversions(1) 5 sage: p.number_of_noninversions(2) 6 sage: p.number_of_noninversions(3) 2 sage: p.number_of_noninversions(4) 0 sage: p.number_of_noninversions(5) 0 - >>> from sage.all import * >>> p = Permutation([Integer(3), Integer(2), Integer(4), Integer(1), Integer(5)]) >>> p.number_of_noninversions(Integer(1)) 5 >>> p.number_of_noninversions(Integer(2)) 6 >>> p.number_of_noninversions(Integer(3)) 2 >>> p.number_of_noninversions(Integer(4)) 0 >>> p.number_of_noninversions(Integer(5)) 0 - The number of \(2\)-noninversions of a permutation \(p \in S_n\) is \(\binom{n}{2}\) minus its number of inversions: - sage: b = binomial(5, 2) # needs sage.symbolic sage: all( x.number_of_noninversions(2) == b - x.number_of_inversions() # needs sage.symbolic ....: for x in Permutations(5) ) True - >>> from sage.all import * >>> b = binomial(Integer(5), Integer(2)) # needs sage.symbolic >>> all( x.number_of_noninversions(Integer(2)) == b - x.number_of_inversions() # needs sage.symbolic ... for x in Permutations(Integer(5)) ) True - We also check some corner cases: - sage: all( x.number_of_noninversions(1) == 5 for x in Permutations(5) ) True sage: all( x.number_of_noninversions(0) == 1 for x in Permutations(5) ) True sage: Permutation([]).number_of_noninversions(1) 0 sage: Permutation([]).number_of_noninversions(0) 1 sage: Permutation([2, 1]).number_of_noninversions(3) 0 - >>> from sage.all import * >>> all( x.number_of_noninversions(Integer(1)) == Integer(5) for x in Permutations(Integer(5)) ) True >>> all( x.number_of_noninversions(Integer(0)) == Integer(1) for x in Permutations(Integer(5)) ) True >>> Permutation([]).number_of_noninversions(Integer(1)) 0 >>> Permutation([]).number_of_noninversions(Integer(0)) 1 >>> Permutation([Integer(2), Integer(1)]).number_of_noninversions(Integer(3)) 0 
 - number_of_nth_roots(n)[source]¶
- Return the number of \(n\)-th roots of - self.- An \(n\)-th root of the permutation \(\sigma\) is a permutation \(\gamma\) such that \(\gamma^n = \sigma\). - Note that the number of \(n\)-th roots only depends on the cycle type of - self.- EXAMPLES: - sage: # needs sage.combinat sage: Sigma = Permutations(5).identity() sage: Sigma.number_of_nth_roots(3) 21 sage: Sigma = Permutation('(1, 3)') sage: Sigma.number_of_nth_roots(2) 0 - >>> from sage.all import * >>> # needs sage.combinat >>> Sigma = Permutations(Integer(5)).identity() >>> Sigma.number_of_nth_roots(Integer(3)) 21 >>> Sigma = Permutation('(1, 3)') >>> Sigma.number_of_nth_roots(Integer(2)) 0 - See also 
 - number_of_peaks()[source]¶
- Return the number of peaks of the permutation - self.- A peak of a permutation \(p\) is an integer \(i\) such that \(p(i-1) < p(i)\) and \(p(i) > p(i+1)\). - EXAMPLES: - sage: Permutation([1,3,2,4,5]).number_of_peaks() 1 sage: Permutation([4,1,3,2,6,5]).number_of_peaks() 2 - >>> from sage.all import * >>> Permutation([Integer(1),Integer(3),Integer(2),Integer(4),Integer(5)]).number_of_peaks() 1 >>> Permutation([Integer(4),Integer(1),Integer(3),Integer(2),Integer(6),Integer(5)]).number_of_peaks() 2 
 - number_of_recoils()[source]¶
- Return the number of recoils of the permutation - self.- EXAMPLES: - sage: Permutation([1,4,3,2]).number_of_recoils() 2 - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).number_of_recoils() 2 
 - number_of_reduced_words()[source]¶
- Return the number of reduced words of - selfwithout explicitly computing them all.- EXAMPLES: - sage: p = Permutation([6,4,2,5,1,8,3,7]) sage: len(p.reduced_words()) == p.number_of_reduced_words() # needs sage.combinat True - >>> from sage.all import * >>> p = Permutation([Integer(6),Integer(4),Integer(2),Integer(5),Integer(1),Integer(8),Integer(3),Integer(7)]) >>> len(p.reduced_words()) == p.number_of_reduced_words() # needs sage.combinat True 
 - number_of_saliances()[source]¶
- Return the number of saliances of - self.- A saliance of a permutation \(p\) is an integer \(i\) such that \(p(i) > p(j)\) for all \(j > i\). - EXAMPLES: - sage: Permutation([2,3,1,5,4]).number_of_saliances() 2 sage: Permutation([5,4,3,2,1]).number_of_saliances() 5 - >>> from sage.all import * >>> Permutation([Integer(2),Integer(3),Integer(1),Integer(5),Integer(4)]).number_of_saliances() 2 >>> Permutation([Integer(5),Integer(4),Integer(3),Integer(2),Integer(1)]).number_of_saliances() 5 
 - order()[source]¶
- Return the order of - self.- EXAMPLES: - sage: sigma = Permutation([3,4,1,2,5]) sage: sigma.order() 2 sage: sigma * sigma [1, 2, 3, 4, 5] - >>> from sage.all import * >>> sigma = Permutation([Integer(3),Integer(4),Integer(1),Integer(2),Integer(5)]) >>> sigma.order() 2 >>> sigma * sigma [1, 2, 3, 4, 5] 
 - pattern_positions(patt)[source]¶
- Return the list of positions where the pattern - pattappears in the permutation- self.- EXAMPLES: - sage: Permutation([3,5,1,4,6,2]).pattern_positions([1,3,2]) # needs sage.combinat [[0, 1, 3], [2, 3, 5], [2, 4, 5]] - >>> from sage.all import * >>> Permutation([Integer(3),Integer(5),Integer(1),Integer(4),Integer(6),Integer(2)]).pattern_positions([Integer(1),Integer(3),Integer(2)]) # needs sage.combinat [[0, 1, 3], [2, 3, 5], [2, 4, 5]] 
 - peaks()[source]¶
- Return a list of the peaks of the permutation - self.- A peak of a permutation \(p\) is an integer \(i\) such that \(p(i-1) < p(i)\) and \(p(i) > p(i+1)\). - EXAMPLES: - sage: Permutation([1,3,2,4,5]).peaks() [1] sage: Permutation([4,1,3,2,6,5]).peaks() [2, 4] sage: Permutation([]).peaks() [] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(3),Integer(2),Integer(4),Integer(5)]).peaks() [1] >>> Permutation([Integer(4),Integer(1),Integer(3),Integer(2),Integer(6),Integer(5)]).peaks() [2, 4] >>> Permutation([]).peaks() [] 
 - permutation_poset()[source]¶
- Return the permutation poset of - self.- The permutation poset of a permutation \(p\) is the poset with vertices \((i, p(i))\) for \(i = 1, 2, \ldots, n\) (where \(n\) is the size of \(p\)) and order inherited from \(\ZZ \times \ZZ\). - EXAMPLES: - sage: # needs sage.combinat sage.graphs sage: Permutation([3,1,5,4,2]).permutation_poset().cover_relations() [[(2, 1), (5, 2)], [(2, 1), (3, 5)], [(2, 1), (4, 4)], [(1, 3), (3, 5)], [(1, 3), (4, 4)]] sage: Permutation([]).permutation_poset().cover_relations() [] sage: Permutation([1,3,2]).permutation_poset().cover_relations() [[(1, 1), (2, 3)], [(1, 1), (3, 2)]] sage: Permutation([1,2]).permutation_poset().cover_relations() [[(1, 1), (2, 2)]] sage: P = Permutation([1,5,2,4,3]) - >>> from sage.all import * >>> # needs sage.combinat sage.graphs >>> Permutation([Integer(3),Integer(1),Integer(5),Integer(4),Integer(2)]).permutation_poset().cover_relations() [[(2, 1), (5, 2)], [(2, 1), (3, 5)], [(2, 1), (4, 4)], [(1, 3), (3, 5)], [(1, 3), (4, 4)]] >>> Permutation([]).permutation_poset().cover_relations() [] >>> Permutation([Integer(1),Integer(3),Integer(2)]).permutation_poset().cover_relations() [[(1, 1), (2, 3)], [(1, 1), (3, 2)]] >>> Permutation([Integer(1),Integer(2)]).permutation_poset().cover_relations() [[(1, 1), (2, 2)]] >>> P = Permutation([Integer(1),Integer(5),Integer(2),Integer(4),Integer(3)]) - This should hold for any \(P\): - sage: P.permutation_poset().greene_shape() == P.RS_partition() # needs sage.combinat sage.graphs True - >>> from sage.all import * >>> P.permutation_poset().greene_shape() == P.RS_partition() # needs sage.combinat sage.graphs True 
 - permutohedron_greater(side='right')[source]¶
- Return a list of permutations greater than or equal to - selfin the permutohedron order.- By default, the computations are done in the right permutohedron. If you pass the option - side='left', then they will be done in the left permutohedron.- See - permutohedron_lequal()for the definition of the permutohedron orders.- EXAMPLES: - sage: Permutation([4,2,1,3]).permutohedron_greater() [[4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 2, 1]] sage: Permutation([4,2,1,3]).permutohedron_greater(side='left') [[4, 2, 1, 3], [4, 3, 1, 2], [4, 3, 2, 1]] - >>> from sage.all import * >>> Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]).permutohedron_greater() [[4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 2, 1]] >>> Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]).permutohedron_greater(side='left') [[4, 2, 1, 3], [4, 3, 1, 2], [4, 3, 2, 1]] 
 - permutohedron_join(other, side='right')[source]¶
- Return the join of the permutations - selfand- otherin the right permutohedron order (or, if- sideis set to- 'left', in the left permutohedron order).- The permutohedron orders (see - permutohedron_lequal()) are lattices; the join operation refers to this lattice structure. In more elementary terms, the join of two permutations \(\pi\) and \(\psi\) in the symmetric group \(S_n\) is the permutation in \(S_n\) whose set of inversion is the transitive closure of the union of the set of inversions of \(\pi\) with the set of inversions of \(\psi\).- See also - ALGORITHM: - It is enough to construct the join of any two permutations \(\pi\) and \(\psi\) in \(S_n\) with respect to the right weak order. (The join of \(\pi\) and \(\psi\) with respect to the left weak order is the inverse of the join of \(\pi^{-1}\) and \(\psi^{-1}\) with respect to the right weak order.) Start with an empty list \(l\) (denoted - xsin the actual code). For \(i = 1, 2, \ldots, n\) (in this order), we insert \(i\) into this list in the rightmost possible position such that any letter in \(\{ 1, 2, ..., i-1 \}\) which appears further right than \(i\) in either \(\pi\) or \(\psi\) (or both) must appear further right than \(i\) in the resulting list. After all numbers are inserted, we are left with a list which is precisely the join of \(\pi\) and \(\psi\) (in one-line notation). This algorithm is due to Markowsky, [Mar1994] (Theorem 1 (a)).- AUTHORS: - Viviane Pons and Darij Grinberg, 18 June 2014. - EXAMPLES: - sage: p = Permutation([3,1,2]) sage: q = Permutation([1,3,2]) sage: p.permutohedron_join(q) [3, 1, 2] sage: r = Permutation([2,1,3]) sage: r.permutohedron_join(p) [3, 2, 1] - >>> from sage.all import * >>> p = Permutation([Integer(3),Integer(1),Integer(2)]) >>> q = Permutation([Integer(1),Integer(3),Integer(2)]) >>> p.permutohedron_join(q) [3, 1, 2] >>> r = Permutation([Integer(2),Integer(1),Integer(3)]) >>> r.permutohedron_join(p) [3, 2, 1] - sage: p = Permutation([3,2,4,1]) sage: q = Permutation([4,2,1,3]) sage: p.permutohedron_join(q) [4, 3, 2, 1] sage: r = Permutation([3,1,2,4]) sage: p.permutohedron_join(r) [3, 2, 4, 1] sage: q.permutohedron_join(r) [4, 3, 2, 1] sage: s = Permutation([1,4,2,3]) sage: s.permutohedron_join(r) [4, 3, 1, 2] - >>> from sage.all import * >>> p = Permutation([Integer(3),Integer(2),Integer(4),Integer(1)]) >>> q = Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]) >>> p.permutohedron_join(q) [4, 3, 2, 1] >>> r = Permutation([Integer(3),Integer(1),Integer(2),Integer(4)]) >>> p.permutohedron_join(r) [3, 2, 4, 1] >>> q.permutohedron_join(r) [4, 3, 2, 1] >>> s = Permutation([Integer(1),Integer(4),Integer(2),Integer(3)]) >>> s.permutohedron_join(r) [4, 3, 1, 2] - The universal property of the join operation is satisfied: - sage: def test_uni_join(p, q): ....: j = p.permutohedron_join(q) ....: if not p.permutohedron_lequal(j): ....: return False ....: if not q.permutohedron_lequal(j): ....: return False ....: for r in p.permutohedron_greater(): ....: if q.permutohedron_lequal(r) and not j.permutohedron_lequal(r): ....: return False ....: return True sage: all( test_uni_join(p, q) for p in Permutations(3) for q in Permutations(3) ) True sage: test_uni_join(Permutation([6, 4, 7, 3, 2, 5, 8, 1]), Permutation([7, 3, 1, 2, 5, 4, 6, 8])) True - >>> from sage.all import * >>> def test_uni_join(p, q): ... j = p.permutohedron_join(q) ... if not p.permutohedron_lequal(j): ... return False ... if not q.permutohedron_lequal(j): ... return False ... for r in p.permutohedron_greater(): ... if q.permutohedron_lequal(r) and not j.permutohedron_lequal(r): ... return False ... return True >>> all( test_uni_join(p, q) for p in Permutations(Integer(3)) for q in Permutations(Integer(3)) ) True >>> test_uni_join(Permutation([Integer(6), Integer(4), Integer(7), Integer(3), Integer(2), Integer(5), Integer(8), Integer(1)]), Permutation([Integer(7), Integer(3), Integer(1), Integer(2), Integer(5), Integer(4), Integer(6), Integer(8)])) True - Border cases: - sage: p = Permutation([]) sage: p.permutohedron_join(p) [] sage: p = Permutation([1]) sage: p.permutohedron_join(p) [1] - >>> from sage.all import * >>> p = Permutation([]) >>> p.permutohedron_join(p) [] >>> p = Permutation([Integer(1)]) >>> p.permutohedron_join(p) [1] - The left permutohedron: - sage: p = Permutation([3,1,2]) sage: q = Permutation([1,3,2]) sage: p.permutohedron_join(q, side='left') [3, 2, 1] sage: r = Permutation([2,1,3]) sage: r.permutohedron_join(p, side='left') [3, 1, 2] - >>> from sage.all import * >>> p = Permutation([Integer(3),Integer(1),Integer(2)]) >>> q = Permutation([Integer(1),Integer(3),Integer(2)]) >>> p.permutohedron_join(q, side='left') [3, 2, 1] >>> r = Permutation([Integer(2),Integer(1),Integer(3)]) >>> r.permutohedron_join(p, side='left') [3, 1, 2] 
 - permutohedron_lequal(p2, side='right')[source]¶
- Return - Trueif- selfis less or equal to- p2in the permutohedron order.- By default, the computations are done in the right permutohedron. If you pass the option - side='left', then they will be done in the left permutohedron.- For every nonnegative integer \(n\), the right (resp. left) permutohedron order (also called the right (resp. left) weak order, or the right (resp. left) weak Bruhat order) is a partial order on the symmetric group \(S_n\). It can be defined in various ways, including the following ones: - Two permutations \(u\) and \(v\) in \(S_n\) satisfy \(u \leq v\) in the right (resp. left) permutohedron order if and only if the (Coxeter) length of the permutation \(v^{-1} \circ u\) (resp. of the permutation \(u \circ v^{-1}\)) equals the length of \(v\) minus the length of \(u\). Here, \(p \circ q\) means the permutation obtained by applying \(q\) first and then \(p\). (Recall that the Coxeter length of a permutation is its number of inversions.) 
- Two permutations \(u\) and \(v\) in \(S_n\) satisfy \(u \leq v\) in the right (resp. left) permutohedron order if and only if every pair \((i, j)\) of elements of \(\{ 1, 2, \cdots, n \}\) such that \(i < j\) and \(u^{-1}(i) > u^{-1}(j)\) (resp. \(u(i) > u(j)\)) also satisfies \(v^{-1}(i) > v^{-1}(j)\) (resp. \(v(i) > v(j)\)). 
- A permutation \(v \in S_n\) covers a permutation \(u \in S_n\) in the right (resp. left) permutohedron order if and only if we have \(v = u \circ (i, i + 1)\) (resp. \(v = (i, i + 1) \circ u\)) for some \(i \in \{ 1, 2, \cdots, n - 1 \}\) satisfying \(u(i) < u(i + 1)\) (resp. \(u^{-1}(i) < u^{-1}(i + 1)\)). Here, again, \(p \circ q\) means the permutation obtained by applying \(q\) first and then \(p\). 
 - The right and the left permutohedron order are mutually isomorphic, with the isomorphism being the map sending every permutation to its inverse. Each of these orders endows the symmetric group \(S_n\) with the structure of a graded poset (the rank function being the Coxeter length). - Warning - The permutohedron order is not to be mistaken for the strong Bruhat order ( - bruhat_lequal()), despite both orders being occasionally referred to as the Bruhat order.- EXAMPLES: - sage: p = Permutation([3,2,1,4]) sage: p.permutohedron_lequal(Permutation([4,2,1,3])) False sage: p.permutohedron_lequal(Permutation([4,2,1,3]), side='left') True sage: p.permutohedron_lequal(p) True sage: Permutation([2,1,3]).permutohedron_lequal(Permutation([2,3,1])) True sage: Permutation([2,1,3]).permutohedron_lequal(Permutation([3,1,2])) False sage: Permutation([2,1,3]).permutohedron_lequal(Permutation([1,2,3])) False sage: Permutation([1,3,2]).permutohedron_lequal(Permutation([2,1,3])) False sage: Permutation([1,3,2]).permutohedron_lequal(Permutation([2,3,1])) False sage: Permutation([2,3,1]).permutohedron_lequal(Permutation([1,3,2])) False sage: Permutation([2,1,3]).permutohedron_lequal(Permutation([2,3,1]), side='left') False sage: sorted( [len([b for b in Permutations(3) if a.permutohedron_lequal(b)]) ....: for a in Permutations(3)] ) [1, 2, 2, 3, 3, 6] sage: sorted( [len([b for b in Permutations(3) if a.permutohedron_lequal(b, side='left')]) ....: for a in Permutations(3)] ) [1, 2, 2, 3, 3, 6] sage: Permutation([]).permutohedron_lequal(Permutation([])) True - >>> from sage.all import * >>> p = Permutation([Integer(3),Integer(2),Integer(1),Integer(4)]) >>> p.permutohedron_lequal(Permutation([Integer(4),Integer(2),Integer(1),Integer(3)])) False >>> p.permutohedron_lequal(Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]), side='left') True >>> p.permutohedron_lequal(p) True >>> Permutation([Integer(2),Integer(1),Integer(3)]).permutohedron_lequal(Permutation([Integer(2),Integer(3),Integer(1)])) True >>> Permutation([Integer(2),Integer(1),Integer(3)]).permutohedron_lequal(Permutation([Integer(3),Integer(1),Integer(2)])) False >>> Permutation([Integer(2),Integer(1),Integer(3)]).permutohedron_lequal(Permutation([Integer(1),Integer(2),Integer(3)])) False >>> Permutation([Integer(1),Integer(3),Integer(2)]).permutohedron_lequal(Permutation([Integer(2),Integer(1),Integer(3)])) False >>> Permutation([Integer(1),Integer(3),Integer(2)]).permutohedron_lequal(Permutation([Integer(2),Integer(3),Integer(1)])) False >>> Permutation([Integer(2),Integer(3),Integer(1)]).permutohedron_lequal(Permutation([Integer(1),Integer(3),Integer(2)])) False >>> Permutation([Integer(2),Integer(1),Integer(3)]).permutohedron_lequal(Permutation([Integer(2),Integer(3),Integer(1)]), side='left') False >>> sorted( [len([b for b in Permutations(Integer(3)) if a.permutohedron_lequal(b)]) ... for a in Permutations(Integer(3))] ) [1, 2, 2, 3, 3, 6] >>> sorted( [len([b for b in Permutations(Integer(3)) if a.permutohedron_lequal(b, side='left')]) ... for a in Permutations(Integer(3))] ) [1, 2, 2, 3, 3, 6] >>> Permutation([]).permutohedron_lequal(Permutation([])) True 
 - permutohedron_meet(other, side='right')[source]¶
- Return the meet of the permutations - selfand- otherin the right permutohedron order (or, if- sideis set to- 'left', in the left permutohedron order).- The permutohedron orders (see - permutohedron_lequal()) are lattices; the meet operation refers to this lattice structure. It is connected to the join operation by the following simple symmetry property: If \(\pi\) and \(\psi\) are two permutations \(\pi\) and \(\psi\) in the symmetric group \(S_n\), and if \(w_0\) denotes the permutation \((n, n-1, \ldots, 1) \in S_n\), then\[\pi \wedge \psi = w_0 \circ ((w_0 \circ \pi) \vee (w_0 \circ \psi)) = ((\pi \circ w_0) \vee (\psi \circ w_0)) \circ w_0\]- and \[\pi \vee \psi = w_0 \circ ((w_0 \circ \pi) \wedge (w_0 \circ \psi)) = ((\pi \circ w_0) \wedge (\psi \circ w_0)) \circ w_0,\]- where \(\wedge\) means meet and \(\vee\) means join. - See also - AUTHORS: - Viviane Pons and Darij Grinberg, 18 June 2014. - EXAMPLES: - sage: p = Permutation([3,1,2]) sage: q = Permutation([1,3,2]) sage: p.permutohedron_meet(q) [1, 3, 2] sage: r = Permutation([2,1,3]) sage: r.permutohedron_meet(p) [1, 2, 3] - >>> from sage.all import * >>> p = Permutation([Integer(3),Integer(1),Integer(2)]) >>> q = Permutation([Integer(1),Integer(3),Integer(2)]) >>> p.permutohedron_meet(q) [1, 3, 2] >>> r = Permutation([Integer(2),Integer(1),Integer(3)]) >>> r.permutohedron_meet(p) [1, 2, 3] - sage: p = Permutation([3,2,4,1]) sage: q = Permutation([4,2,1,3]) sage: p.permutohedron_meet(q) [2, 1, 3, 4] sage: r = Permutation([3,1,2,4]) sage: p.permutohedron_meet(r) [3, 1, 2, 4] sage: q.permutohedron_meet(r) [1, 2, 3, 4] sage: s = Permutation([1,4,2,3]) sage: s.permutohedron_meet(r) [1, 2, 3, 4] - >>> from sage.all import * >>> p = Permutation([Integer(3),Integer(2),Integer(4),Integer(1)]) >>> q = Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]) >>> p.permutohedron_meet(q) [2, 1, 3, 4] >>> r = Permutation([Integer(3),Integer(1),Integer(2),Integer(4)]) >>> p.permutohedron_meet(r) [3, 1, 2, 4] >>> q.permutohedron_meet(r) [1, 2, 3, 4] >>> s = Permutation([Integer(1),Integer(4),Integer(2),Integer(3)]) >>> s.permutohedron_meet(r) [1, 2, 3, 4] - The universal property of the meet operation is satisfied: - sage: def test_uni_meet(p, q): ....: m = p.permutohedron_meet(q) ....: if not m.permutohedron_lequal(p): ....: return False ....: if not m.permutohedron_lequal(q): ....: return False ....: for r in p.permutohedron_smaller(): ....: if r.permutohedron_lequal(q) and not r.permutohedron_lequal(m): ....: return False ....: return True sage: all( test_uni_meet(p, q) for p in Permutations(3) for q in Permutations(3) ) True sage: test_uni_meet(Permutation([6, 4, 7, 3, 2, 5, 8, 1]), Permutation([7, 3, 1, 2, 5, 4, 6, 8])) True - >>> from sage.all import * >>> def test_uni_meet(p, q): ... m = p.permutohedron_meet(q) ... if not m.permutohedron_lequal(p): ... return False ... if not m.permutohedron_lequal(q): ... return False ... for r in p.permutohedron_smaller(): ... if r.permutohedron_lequal(q) and not r.permutohedron_lequal(m): ... return False ... return True >>> all( test_uni_meet(p, q) for p in Permutations(Integer(3)) for q in Permutations(Integer(3)) ) True >>> test_uni_meet(Permutation([Integer(6), Integer(4), Integer(7), Integer(3), Integer(2), Integer(5), Integer(8), Integer(1)]), Permutation([Integer(7), Integer(3), Integer(1), Integer(2), Integer(5), Integer(4), Integer(6), Integer(8)])) True - Border cases: - sage: p = Permutation([]) sage: p.permutohedron_meet(p) [] sage: p = Permutation([1]) sage: p.permutohedron_meet(p) [1] - >>> from sage.all import * >>> p = Permutation([]) >>> p.permutohedron_meet(p) [] >>> p = Permutation([Integer(1)]) >>> p.permutohedron_meet(p) [1] - The left permutohedron: - sage: p = Permutation([3,1,2]) sage: q = Permutation([1,3,2]) sage: p.permutohedron_meet(q, side='left') [1, 2, 3] sage: r = Permutation([2,1,3]) sage: r.permutohedron_meet(p, side='left') [2, 1, 3] - >>> from sage.all import * >>> p = Permutation([Integer(3),Integer(1),Integer(2)]) >>> q = Permutation([Integer(1),Integer(3),Integer(2)]) >>> p.permutohedron_meet(q, side='left') [1, 2, 3] >>> r = Permutation([Integer(2),Integer(1),Integer(3)]) >>> r.permutohedron_meet(p, side='left') [2, 1, 3] 
 - permutohedron_pred(side='right')[source]¶
- Return a list of the permutations strictly smaller than - selfin the permutohedron order such that there is no permutation between any of those and- self.- By default, the computations are done in the right permutohedron. If you pass the option - side='left', then they will be done in the left permutohedron.- See - permutohedron_lequal()for the definition of the permutohedron orders.- EXAMPLES: - sage: p = Permutation([4,2,1,3]) sage: p.permutohedron_pred() [[2, 4, 1, 3], [4, 1, 2, 3]] sage: p.permutohedron_pred(side='left') [[4, 1, 2, 3], [3, 2, 1, 4]] - >>> from sage.all import * >>> p = Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]) >>> p.permutohedron_pred() [[2, 4, 1, 3], [4, 1, 2, 3]] >>> p.permutohedron_pred(side='left') [[4, 1, 2, 3], [3, 2, 1, 4]] 
 - permutohedron_smaller(side='right')[source]¶
- Return a list of permutations smaller than or equal to - selfin the permutohedron order.- By default, the computations are done in the right permutohedron. If you pass the option - side='left', then they will be done in the left permutohedron.- See - permutohedron_lequal()for the definition of the permutohedron orders.- EXAMPLES: - sage: Permutation([4,2,1,3]).permutohedron_smaller() [[1, 2, 3, 4], [1, 2, 4, 3], [1, 4, 2, 3], [2, 1, 3, 4], [2, 1, 4, 3], [2, 4, 1, 3], [4, 1, 2, 3], [4, 2, 1, 3]] - >>> from sage.all import * >>> Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]).permutohedron_smaller() [[1, 2, 3, 4], [1, 2, 4, 3], [1, 4, 2, 3], [2, 1, 3, 4], [2, 1, 4, 3], [2, 4, 1, 3], [4, 1, 2, 3], [4, 2, 1, 3]] - sage: Permutation([4,2,1,3]).permutohedron_smaller(side='left') [[1, 2, 3, 4], [1, 3, 2, 4], [2, 1, 3, 4], [2, 3, 1, 4], [3, 1, 2, 4], [3, 2, 1, 4], [4, 1, 2, 3], [4, 2, 1, 3]] - >>> from sage.all import * >>> Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]).permutohedron_smaller(side='left') [[1, 2, 3, 4], [1, 3, 2, 4], [2, 1, 3, 4], [2, 3, 1, 4], [3, 1, 2, 4], [3, 2, 1, 4], [4, 1, 2, 3], [4, 2, 1, 3]] 
 - permutohedron_succ(side='right')[source]¶
- Return a list of the permutations strictly greater than - selfin the permutohedron order such that there is no permutation between any of those and- self.- By default, the computations are done in the right permutohedron. If you pass the option - side='left', then they will be done in the left permutohedron.- See - permutohedron_lequal()for the definition of the permutohedron orders.- EXAMPLES: - sage: p = Permutation([4,2,1,3]) sage: p.permutohedron_succ() [[4, 2, 3, 1]] sage: p.permutohedron_succ(side='left') [[4, 3, 1, 2]] - >>> from sage.all import * >>> p = Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]) >>> p.permutohedron_succ() [[4, 2, 3, 1]] >>> p.permutohedron_succ(side='left') [[4, 3, 1, 2]] 
 - prev()[source]¶
- Return the permutation that comes directly before - selfin lexicographic order on the symmetric group containing- self. If- selfis the first permutation, then it returns- False. Does not support the Steinhaus-Johnson-Trotter algorithm for the moment.- EXAMPLES: - sage: p = Permutation([1,2,3]) sage: p.prev() False sage: p = Permutation([1,3,2]) sage: p.prev() [1, 2, 3] - >>> from sage.all import * >>> p = Permutation([Integer(1),Integer(2),Integer(3)]) >>> p.prev() False >>> p = Permutation([Integer(1),Integer(3),Integer(2)]) >>> p.prev() [1, 2, 3] - Todo - Implement the previous permutation for the Steinhaus-Johnson-Trotter algorithm. 
 - rank()[source]¶
- Return the rank of - selfin the lexicographic ordering on the symmetric group to which- selfbelongs.- EXAMPLES: - sage: Permutation([1,2,3]).rank() 0 sage: Permutation([1, 2, 4, 6, 3, 5]).rank() 10 sage: perms = Permutations(6).list() sage: [p.rank() for p in perms] == list(range(factorial(6))) True - >>> from sage.all import * >>> Permutation([Integer(1),Integer(2),Integer(3)]).rank() 0 >>> Permutation([Integer(1), Integer(2), Integer(4), Integer(6), Integer(3), Integer(5)]).rank() 10 >>> perms = Permutations(Integer(6)).list() >>> [p.rank() for p in perms] == list(range(factorial(Integer(6)))) True 
 - rank_matrix()[source]¶
- Return the rank matrix of - self.- Let \(P = [P_{ij}]_{i, j=1}^n\) be the permutation matrix of \(w \in S_n\). The rank matrix is the \(n \times n\) matrix with entries \[r_w(i, j) = \sum_{a=1}^i \sum_{b=1}^j P_{ij}.\]- EXAMPLES: - sage: w = Permutation([2, 1, 5, 4, 3]) sage: w.to_matrix() [0 1 0 0 0] [1 0 0 0 0] [0 0 0 0 1] [0 0 0 1 0] [0 0 1 0 0] sage: w.rank_matrix() [0 1 1 1 1] [1 2 2 2 2] [1 2 2 2 3] [1 2 2 3 4] [1 2 3 4 5] - >>> from sage.all import * >>> w = Permutation([Integer(2), Integer(1), Integer(5), Integer(4), Integer(3)]) >>> w.to_matrix() [0 1 0 0 0] [1 0 0 0 0] [0 0 0 0 1] [0 0 0 1 0] [0 0 1 0 0] >>> w.rank_matrix() [0 1 1 1 1] [1 2 2 2 2] [1 2 2 2 3] [1 2 2 3 4] [1 2 3 4 5] 
 - recoils()[source]¶
- Return the list of the positions of the recoils of - self.- A recoil of a permutation \(p\) is an integer \(i\) such that \(i+1\) appears to the left of \(i\) in \(p\). Here, the positions are being counted starting at \(0\). (Note that it is the positions, not the recoils themselves, which are being listed.) - EXAMPLES: - sage: Permutation([1,4,3,2]).recoils() [2, 3] sage: Permutation([]).recoils() [] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).recoils() [2, 3] >>> Permutation([]).recoils() [] 
 - recoils_composition()[source]¶
- Return the recoils composition of - self.- The recoils composition of a permutation \(p \in S_n\) is the composition of \(n\) whose descent set is the set of the recoils of \(p\) (not their positions). In other words, this is the descents composition of \(p^{-1}\). - EXAMPLES: - sage: Permutation([1,3,2,4]).recoils_composition() [2, 2] sage: Permutation([]).recoils_composition() [] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(3),Integer(2),Integer(4)]).recoils_composition() [2, 2] >>> Permutation([]).recoils_composition() [] 
 - reduced_word()[source]¶
- Return a reduced word of the permutation - self.- See - reduced_words()for the definition of reduced words and a way to compute them all.- Warning - This does not respect the multiplication convention. - EXAMPLES: - sage: Permutation([3,5,4,6,2,1]).reduced_word() [2, 1, 4, 3, 2, 4, 3, 5, 4, 5] Permutation([1]).reduced_word_lexmin() [] Permutation([]).reduced_word_lexmin() [] - >>> from sage.all import * >>> Permutation([Integer(3),Integer(5),Integer(4),Integer(6),Integer(2),Integer(1)]).reduced_word() [2, 1, 4, 3, 2, 4, 3, 5, 4, 5] Permutation([1]).reduced_word_lexmin() [] Permutation([]).reduced_word_lexmin() [] 
 - reduced_word_lexmin()[source]¶
- Return a lexicographically minimal reduced word of the permutation - self.- See - reduced_words()for the definition of reduced words and a way to compute them all.- EXAMPLES: - sage: Permutation([3,4,2,1]).reduced_word_lexmin() [1, 2, 1, 3, 2] Permutation([1]).reduced_word_lexmin() [] Permutation([]).reduced_word_lexmin() [] - >>> from sage.all import * >>> Permutation([Integer(3),Integer(4),Integer(2),Integer(1)]).reduced_word_lexmin() [1, 2, 1, 3, 2] Permutation([1]).reduced_word_lexmin() [] Permutation([]).reduced_word_lexmin() [] 
 - reduced_words()[source]¶
- Return a list of the reduced words of - self.- The notion of a reduced word is based on the well-known fact that every permutation can be written as a product of adjacent transpositions. In more detail: If \(n\) is a nonnegative integer, we can define the transpositions \(s_i = (i, i+1) \in S_n\) for all \(i \in \{ 1, 2, \ldots, n-1 \}\), and every \(p \in S_n\) can then be written as a product \(s_{i_1} s_{i_2} \cdots s_{i_k}\) for some sequence \((i_1, i_2, \ldots, i_k)\) of elements of \(\{ 1, 2, \ldots, n-1 \}\) (here \(\{ 1, 2, \ldots, n-1 \}\) denotes the empty set when \(n \leq 1\)). Fixing a \(p\), the sequences \((i_1, i_2, \ldots, i_k)\) of smallest length satisfying \(p = s_{i_1} s_{i_2} \cdots s_{i_k}\) are called the reduced words of \(p\). (Their length is the Coxeter length of \(p\), and can be computed using - length().)- Note that the product of permutations is defined here in such a way that \((pq)(i) = p(q(i))\) for all permutations \(p\) and \(q\) and each \(i \in \{ 1, 2, \ldots, n \}\) (this is the same convention as in - left_action_product(), but not the default semantics of the \(*\) operator on permutations in Sage). Thus, for instance, \(s_2 s_1\) is the permutation obtained by first transposing \(1\) with \(2\) and then transposing \(2\) with \(3\).- See also - EXAMPLES: - sage: Permutation([2,1,3]).reduced_words() [[1]] sage: Permutation([3,1,2]).reduced_words() [[2, 1]] sage: Permutation([3,2,1]).reduced_words() [[1, 2, 1], [2, 1, 2]] sage: Permutation([3,2,4,1]).reduced_words() [[1, 2, 3, 1], [1, 2, 1, 3], [2, 1, 2, 3]] Permutation([1]).reduced_words() [[]] Permutation([]).reduced_words() [[]] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1),Integer(3)]).reduced_words() [[1]] >>> Permutation([Integer(3),Integer(1),Integer(2)]).reduced_words() [[2, 1]] >>> Permutation([Integer(3),Integer(2),Integer(1)]).reduced_words() [[1, 2, 1], [2, 1, 2]] >>> Permutation([Integer(3),Integer(2),Integer(4),Integer(1)]).reduced_words() [[1, 2, 3, 1], [1, 2, 1, 3], [2, 1, 2, 3]] Permutation([1]).reduced_words() [[]] Permutation([]).reduced_words() [[]] 
 - reduced_words_iterator()[source]¶
- Return an iterator for the reduced words of - self.- EXAMPLES: - sage: next(Permutation([5,2,3,4,1]).reduced_words_iterator()) [1, 2, 3, 4, 3, 2, 1] - >>> from sage.all import * >>> next(Permutation([Integer(5),Integer(2),Integer(3),Integer(4),Integer(1)]).reduced_words_iterator()) [1, 2, 3, 4, 3, 2, 1] 
 - remove_extra_fixed_points()[source]¶
- Return the permutation obtained by removing any fixed points at the end of - self.- However, return - [1]rather than- []if- selfis the identity permutation.- This is mostly a helper method for - sage.combinat.schubert_polynomial, where it is used to normalize finitary permutations of \(\{1,2,3,\ldots\}\).- EXAMPLES: - sage: Permutation([2,1,3]).remove_extra_fixed_points() [2, 1] sage: Permutation([1,2,3,4]).remove_extra_fixed_points() [1] sage: Permutation([2,1]).remove_extra_fixed_points() [2, 1] sage: Permutation([]).remove_extra_fixed_points() [1] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1),Integer(3)]).remove_extra_fixed_points() [2, 1] >>> Permutation([Integer(1),Integer(2),Integer(3),Integer(4)]).remove_extra_fixed_points() [1] >>> Permutation([Integer(2),Integer(1)]).remove_extra_fixed_points() [2, 1] >>> Permutation([]).remove_extra_fixed_points() [1] - See also 
 - retract_direct_product(m)[source]¶
- Return the direct-product retract of the permutation - self\(\in S_n\) to \(S_m\), where \(m \leq n\). If this retract is undefined, then- Noneis returned.- If \(p \in S_n\) is a permutation, and \(m\) is a nonnegative integer less or equal to \(n\), then the direct-product retract of \(p\) to \(S_m\) is defined only if \(p([m]) = [m]\), where \([m]\) denotes the interval \(\{1, 2, \ldots, m\}\). In this case, it is defined as the permutation written \((p(1), p(2), \ldots, p(m))\) in one-line notation. - EXAMPLES: - sage: Permutation([4,1,2,3,5]).retract_direct_product(4) [4, 1, 2, 3] sage: Permutation([4,1,2,3,5]).retract_direct_product(3) sage: Permutation([1,4,2,3,6,5]).retract_direct_product(5) sage: Permutation([1,4,2,3,6,5]).retract_direct_product(4) [1, 4, 2, 3] sage: Permutation([1,4,2,3,6,5]).retract_direct_product(3) sage: Permutation([1,4,2,3,6,5]).retract_direct_product(2) sage: Permutation([1,4,2,3,6,5]).retract_direct_product(1) [1] sage: Permutation([1,4,2,3,6,5]).retract_direct_product(0) [] sage: all( p.retract_direct_product(3) == p for p in Permutations(3) ) True - >>> from sage.all import * >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3),Integer(5)]).retract_direct_product(Integer(4)) [4, 1, 2, 3] >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3),Integer(5)]).retract_direct_product(Integer(3)) >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_direct_product(Integer(5)) >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_direct_product(Integer(4)) [1, 4, 2, 3] >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_direct_product(Integer(3)) >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_direct_product(Integer(2)) >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_direct_product(Integer(1)) [1] >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_direct_product(Integer(0)) [] >>> all( p.retract_direct_product(Integer(3)) == p for p in Permutations(Integer(3)) ) True - See also 
 - retract_okounkov_vershik(m)[source]¶
- Return the Okounkov-Vershik retract of the permutation - self\(\in S_n\) to \(S_m\), where \(m \leq n\).- If \(p \in S_n\) is a permutation, and \(m\) is a nonnegative integer less or equal to \(n\), then the Okounkov-Vershik retract of \(p\) to \(S_m\) is defined as the permutation in \(S_m\) which sends every \(i \in \{1, 2, \ldots, m\}\) to \(p^{k_i}(i)\), where \(k_i\) is the smallest positive integer \(k\) satisfying \(p^k(i) \leq m\). - In other words, the Okounkov-Vershik retract of \(p\) is the permutation whose disjoint cycle decomposition is obtained by removing all letters strictly greater than \(m\) from the decomposition of \(p\) into disjoint cycles (and removing all cycles which are emptied in the process). - When \(m = n-1\), the Okounkov-Vershik retract (as a map \(S_n \to S_{n-1}\)) is the map \(\widetilde{p}_n\) introduced in Section 7 of [VO2005], and appears as (3.20) in [CST2010]. In the general case, the Okounkov-Vershik retract of a permutation in \(S_n\) to \(S_m\) can be obtained by first taking its Okounkov-Vershik retract to \(S_{n-1}\), then that of the resulting permutation to \(S_{n-2}\), etc. until arriving in \(S_m\). - EXAMPLES: - sage: Permutation([4,1,2,3,5]).retract_okounkov_vershik(4) [4, 1, 2, 3] sage: Permutation([4,1,2,3,5]).retract_okounkov_vershik(3) [3, 1, 2] sage: Permutation([4,1,2,3,5]).retract_okounkov_vershik(2) [2, 1] sage: Permutation([4,1,2,3,5]).retract_okounkov_vershik(1) [1] sage: Permutation([4,1,2,3,5]).retract_okounkov_vershik(0) [] sage: Permutation([1,4,2,3,6,5]).retract_okounkov_vershik(5) [1, 4, 2, 3, 5] sage: Permutation([1,4,2,3,6,5]).retract_okounkov_vershik(4) [1, 4, 2, 3] sage: Permutation([1,4,2,3,6,5]).retract_okounkov_vershik(3) [1, 3, 2] sage: Permutation([1,4,2,3,6,5]).retract_okounkov_vershik(2) [1, 2] sage: Permutation([1,4,2,3,6,5]).retract_okounkov_vershik(1) [1] sage: Permutation([1,4,2,3,6,5]).retract_okounkov_vershik(0) [] sage: Permutation([6,5,4,3,2,1]).retract_okounkov_vershik(5) [1, 5, 4, 3, 2] sage: Permutation([6,5,4,3,2,1]).retract_okounkov_vershik(4) [1, 2, 4, 3] sage: Permutation([1,5,2,6,3,7,4,8]).retract_okounkov_vershik(4) [1, 3, 2, 4] sage: all( p.retract_direct_product(3) == p for p in Permutations(3) ) True - >>> from sage.all import * >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3),Integer(5)]).retract_okounkov_vershik(Integer(4)) [4, 1, 2, 3] >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3),Integer(5)]).retract_okounkov_vershik(Integer(3)) [3, 1, 2] >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3),Integer(5)]).retract_okounkov_vershik(Integer(2)) [2, 1] >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3),Integer(5)]).retract_okounkov_vershik(Integer(1)) [1] >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3),Integer(5)]).retract_okounkov_vershik(Integer(0)) [] >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_okounkov_vershik(Integer(5)) [1, 4, 2, 3, 5] >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_okounkov_vershik(Integer(4)) [1, 4, 2, 3] >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_okounkov_vershik(Integer(3)) [1, 3, 2] >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_okounkov_vershik(Integer(2)) [1, 2] >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_okounkov_vershik(Integer(1)) [1] >>> Permutation([Integer(1),Integer(4),Integer(2),Integer(3),Integer(6),Integer(5)]).retract_okounkov_vershik(Integer(0)) [] >>> Permutation([Integer(6),Integer(5),Integer(4),Integer(3),Integer(2),Integer(1)]).retract_okounkov_vershik(Integer(5)) [1, 5, 4, 3, 2] >>> Permutation([Integer(6),Integer(5),Integer(4),Integer(3),Integer(2),Integer(1)]).retract_okounkov_vershik(Integer(4)) [1, 2, 4, 3] >>> Permutation([Integer(1),Integer(5),Integer(2),Integer(6),Integer(3),Integer(7),Integer(4),Integer(8)]).retract_okounkov_vershik(Integer(4)) [1, 3, 2, 4] >>> all( p.retract_direct_product(Integer(3)) == p for p in Permutations(Integer(3)) ) True - See also 
 - retract_plain(m)[source]¶
- Return the plain retract of the permutation - selfin \(S_n\) to \(S_m\), where \(m \leq n\). If this retract is undefined, then- Noneis returned.- If \(p \in S_n\) is a permutation, and \(m\) is a nonnegative integer less or equal to \(n\), then the plain retract of \(p\) to \(S_m\) is defined only if every \(i > m\) satisfies \(p(i) = i\). In this case, it is defined as the permutation written \((p(1), p(2), \ldots, p(m))\) in one-line notation. - EXAMPLES: - sage: Permutation([4,1,2,3,5]).retract_plain(4) [4, 1, 2, 3] sage: Permutation([4,1,2,3,5]).retract_plain(3) sage: Permutation([1,3,2,4,5,6]).retract_plain(3) [1, 3, 2] sage: Permutation([1,3,2,4,5,6]).retract_plain(2) sage: Permutation([1,2,3,4,5]).retract_plain(1) [1] sage: Permutation([1,2,3,4,5]).retract_plain(0) [] sage: all( p.retract_plain(3) == p for p in Permutations(3) ) True - >>> from sage.all import * >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3),Integer(5)]).retract_plain(Integer(4)) [4, 1, 2, 3] >>> Permutation([Integer(4),Integer(1),Integer(2),Integer(3),Integer(5)]).retract_plain(Integer(3)) >>> Permutation([Integer(1),Integer(3),Integer(2),Integer(4),Integer(5),Integer(6)]).retract_plain(Integer(3)) [1, 3, 2] >>> Permutation([Integer(1),Integer(3),Integer(2),Integer(4),Integer(5),Integer(6)]).retract_plain(Integer(2)) >>> Permutation([Integer(1),Integer(2),Integer(3),Integer(4),Integer(5)]).retract_plain(Integer(1)) [1] >>> Permutation([Integer(1),Integer(2),Integer(3),Integer(4),Integer(5)]).retract_plain(Integer(0)) [] >>> all( p.retract_plain(Integer(3)) == p for p in Permutations(Integer(3)) ) True 
 - reverse()[source]¶
- Return the permutation obtained by reversing the list. - EXAMPLES: - sage: Permutation([3,4,1,2]).reverse() [2, 1, 4, 3] sage: Permutation([1,2,3,4,5]).reverse() [5, 4, 3, 2, 1] - >>> from sage.all import * >>> Permutation([Integer(3),Integer(4),Integer(1),Integer(2)]).reverse() [2, 1, 4, 3] >>> Permutation([Integer(1),Integer(2),Integer(3),Integer(4),Integer(5)]).reverse() [5, 4, 3, 2, 1] 
 - right_action_product(rp)[source]¶
- Return the permutation obtained by composing - selfwith- rpin such an order that- selfis applied first and- rpis applied afterwards.- This is usually denoted by either - self * rpor- rp * selfdepending on the conventions used by the author. If the value of a permutation \(p \in S_n\) on an integer \(i \in \{ 1, 2, \cdots, n \}\) is denoted by \(p(i)\), then this should be denoted by- rp * selfin order to have associativity (i.e., in order to have \((p \cdot q)(i) = p(q(i))\) for all \(p\), \(q\) and \(i\)). If, on the other hand, the value of a permutation \(p \in S_n\) on an integer \(i \in \{ 1, 2, \cdots, n \}\) is denoted by \(i^p\), then this should be denoted by- self * rpin order to have associativity (i.e., in order to have \(i^{p \cdot q} = (i^p)^q\) for all \(p\), \(q\) and \(i\)).- EXAMPLES: - sage: p = Permutation([2,1,3]) sage: q = Permutation([3,1,2]) sage: p.right_action_product(q) [1, 3, 2] sage: q.right_action_product(p) [3, 2, 1] - >>> from sage.all import * >>> p = Permutation([Integer(2),Integer(1),Integer(3)]) >>> q = Permutation([Integer(3),Integer(1),Integer(2)]) >>> p.right_action_product(q) [1, 3, 2] >>> q.right_action_product(p) [3, 2, 1] 
 - right_permutohedron_interval(other)[source]¶
- Return the list of the permutations belonging to the right permutohedron interval where - selfis the minimal element and- otherthe maximal element.- See - permutohedron_lequal()for the definition of the permutohedron orders.- EXAMPLES: - sage: p = Permutation([2, 1, 4, 5, 3]); q = Permutation([2, 5, 4, 1, 3]) sage: p.right_permutohedron_interval(q) # needs sage.graphs sage.modules [[2, 4, 5, 1, 3], [2, 4, 1, 5, 3], [2, 1, 4, 5, 3], [2, 1, 5, 4, 3], [2, 5, 1, 4, 3], [2, 5, 4, 1, 3]] - >>> from sage.all import * >>> p = Permutation([Integer(2), Integer(1), Integer(4), Integer(5), Integer(3)]); q = Permutation([Integer(2), Integer(5), Integer(4), Integer(1), Integer(3)]) >>> p.right_permutohedron_interval(q) # needs sage.graphs sage.modules [[2, 4, 5, 1, 3], [2, 4, 1, 5, 3], [2, 1, 4, 5, 3], [2, 1, 5, 4, 3], [2, 5, 1, 4, 3], [2, 5, 4, 1, 3]] 
 - right_permutohedron_interval_iterator(other)[source]¶
- Return an iterator on the permutations (represented as integer lists) belonging to the right permutohedron interval where - selfis the minimal element and- otherthe maximal element.- See - permutohedron_lequal()for the definition of the permutohedron orders.- EXAMPLES: - sage: p = Permutation([2, 1, 4, 5, 3]); q = Permutation([2, 5, 4, 1, 3]) sage: p.right_permutohedron_interval(q) # indirect doctest # needs sage.graphs sage.modules [[2, 4, 5, 1, 3], [2, 4, 1, 5, 3], [2, 1, 4, 5, 3], [2, 1, 5, 4, 3], [2, 5, 1, 4, 3], [2, 5, 4, 1, 3]] - >>> from sage.all import * >>> p = Permutation([Integer(2), Integer(1), Integer(4), Integer(5), Integer(3)]); q = Permutation([Integer(2), Integer(5), Integer(4), Integer(1), Integer(3)]) >>> p.right_permutohedron_interval(q) # indirect doctest # needs sage.graphs sage.modules [[2, 4, 5, 1, 3], [2, 4, 1, 5, 3], [2, 1, 4, 5, 3], [2, 1, 5, 4, 3], [2, 5, 1, 4, 3], [2, 5, 4, 1, 3]] 
 - right_tableau()[source]¶
- Return the right standard tableau after performing the RSK algorithm on - self.- EXAMPLES: - sage: Permutation([1,4,3,2]).right_tableau() # needs sage.combinat [[1, 2], [3], [4]] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(4),Integer(3),Integer(2)]).right_tableau() # needs sage.combinat [[1, 2], [3], [4]] 
 - robinson_schensted()[source]¶
- Return the pair of standard tableaux obtained by running the Robinson-Schensted algorithm on - self.- This can also be done by running - RSK()on- self(with the optional argument- check_standard=Trueto return standard Young tableaux).- EXAMPLES: - sage: Permutation([6,2,3,1,7,5,4]).robinson_schensted() # needs sage.combinat [[[1, 3, 4], [2, 5], [6, 7]], [[1, 3, 5], [2, 6], [4, 7]]] - >>> from sage.all import * >>> Permutation([Integer(6),Integer(2),Integer(3),Integer(1),Integer(7),Integer(5),Integer(4)]).robinson_schensted() # needs sage.combinat [[[1, 3, 4], [2, 5], [6, 7]], [[1, 3, 5], [2, 6], [4, 7]]] 
 - rothe_diagram()[source]¶
- Return the Rothe diagram of - self.- EXAMPLES: - sage: p = Permutation([4,2,1,3]) sage: D = p.rothe_diagram(); D # needs sage.combinat [(0, 0), (0, 1), (0, 2), (1, 0)] sage: D.pp() # needs sage.combinat O O O . O . . . . . . . . . . . - >>> from sage.all import * >>> p = Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]) >>> D = p.rothe_diagram(); D # needs sage.combinat [(0, 0), (0, 1), (0, 2), (1, 0)] >>> D.pp() # needs sage.combinat O O O . O . . . . . . . . . . . 
 - runs(as_tuple=False)[source]¶
- Return a list of the runs in the nonempty permutation - self.- A run in a permutation is defined to be a maximal (with respect to inclusion) nonempty increasing substring (i. e., contiguous subsequence). For instance, the runs in the permutation - [6,1,7,3,4,5,2]are- [6],- [1,7],- [3,4,5]and- [2].- Runs in an empty permutation are not defined. - INPUT: - as_tuple– boolean (default:- False); choice of output format
 - OUTPUT: list of lists or a tuple of tuples - REFERENCES: - EXAMPLES: - sage: Permutation([1,2,3,4]).runs() [[1, 2, 3, 4]] sage: Permutation([4,3,2,1]).runs() [[4], [3], [2], [1]] sage: Permutation([2,4,1,3]).runs() [[2, 4], [1, 3]] sage: Permutation([1]).runs() [[1]] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(2),Integer(3),Integer(4)]).runs() [[1, 2, 3, 4]] >>> Permutation([Integer(4),Integer(3),Integer(2),Integer(1)]).runs() [[4], [3], [2], [1]] >>> Permutation([Integer(2),Integer(4),Integer(1),Integer(3)]).runs() [[2, 4], [1, 3]] >>> Permutation([Integer(1)]).runs() [[1]] - The example from above: - sage: Permutation([6,1,7,3,4,5,2]).runs() [[6], [1, 7], [3, 4, 5], [2]] sage: Permutation([6,1,7,3,4,5,2]).runs(as_tuple=True) ((6,), (1, 7), (3, 4, 5), (2,)) - >>> from sage.all import * >>> Permutation([Integer(6),Integer(1),Integer(7),Integer(3),Integer(4),Integer(5),Integer(2)]).runs() [[6], [1, 7], [3, 4, 5], [2]] >>> Permutation([Integer(6),Integer(1),Integer(7),Integer(3),Integer(4),Integer(5),Integer(2)]).runs(as_tuple=True) ((6,), (1, 7), (3, 4, 5), (2,)) - The number of runs in a nonempty permutation equals its number of descents plus 1: - sage: all( len(p.runs()) == p.number_of_descents() + 1 ....: for p in Permutations(6) ) True - >>> from sage.all import * >>> all( len(p.runs()) == p.number_of_descents() + Integer(1) ... for p in Permutations(Integer(6)) ) True 
 - saliances()[source]¶
- Return a list of the saliances of the permutation - self.- A saliance of a permutation \(p\) is an integer \(i\) such that \(p(i) > p(j)\) for all \(j > i\). - EXAMPLES: - sage: Permutation([2,3,1,5,4]).saliances() [3, 4] sage: Permutation([5,4,3,2,1]).saliances() [0, 1, 2, 3, 4] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(3),Integer(1),Integer(5),Integer(4)]).saliances() [3, 4] >>> Permutation([Integer(5),Integer(4),Integer(3),Integer(2),Integer(1)]).saliances() [0, 1, 2, 3, 4] 
 - schubert_determinant_ideal()[source]¶
- Return the Schubert determinant ideal of - self.- From Lemma 3.10 [Ful1992], the matrix Schubert variety of a permutation \(w \in S_n\) is defined by the ideal \[I_w = \sum_{(i, j)} I_{r_w(i, j)+1}(i, j),\]- where the sum is over the - essential set, \([r_w(i, j)]_{i, j}\) is the- rank_matrix()of \(w\), and \(I_k(i, j)\) is the ideal generated by the \(k \times k\) minors of the \(i \times j\) matrix \([z_{ab}]_{a, b}\).- These ideals are known to be prime of codimension equal to \(\ell(w)\) (the length of \(w\)) such that \(R / I_w\) is Cohen-Macaulay, where \(R\) is the polynomial ring \(\QQ[z_{ab} | 1 \leq a, b \leq n]\) from Prop. 3.10 of [Ful1992]. - EXAMPLES: - sage: w = Permutation([3, 1, 4, 2]) sage: Iw = w.schubert_determinant_ideal() sage: Iw.gens() [z00, z01, -z01*z10 + z00*z11, -z01*z20 + z00*z21, -z11*z20 + z10*z21] sage: Iw.dimension() 13 sage: Iw.dimension() + w.length() 16 sage: Iw.is_prime() True sage: w = Permutation([2, 1, 5, 4, 3]) sage: Iw = w.schubert_determinant_ideal() sage: Iw.dimension() 21 sage: w.length() + Iw.dimension() 25 sage: Iw.is_prime() True - >>> from sage.all import * >>> w = Permutation([Integer(3), Integer(1), Integer(4), Integer(2)]) >>> Iw = w.schubert_determinant_ideal() >>> Iw.gens() [z00, z01, -z01*z10 + z00*z11, -z01*z20 + z00*z21, -z11*z20 + z10*z21] >>> Iw.dimension() 13 >>> Iw.dimension() + w.length() 16 >>> Iw.is_prime() True >>> w = Permutation([Integer(2), Integer(1), Integer(5), Integer(4), Integer(3)]) >>> Iw = w.schubert_determinant_ideal() >>> Iw.dimension() 21 >>> w.length() + Iw.dimension() 25 >>> Iw.is_prime() True 
 - shifted_concatenation(other, side='right')[source]¶
- Return the right (or left) shifted concatenation of - selfwith a permutation- other. These operations are also known as the Loday-Ronco over and under operations.- INPUT: - other– a permutation, a list, a tuple, or any iterable representing a permutation
- side– string (default:- 'right');- 'left'or- 'right'
 - OUTPUT: - If - sideis- 'right', the method returns the permutation obtained by concatenating- selfwith the letters of- otherincremented by the size of- self. This is what is called- side / otherin [LR0102066], and denoted as the “over” operation. Otherwise, i. e., when- sideis- 'left', the method returns the permutation obtained by concatenating the letters of- otherincremented by the size of- selfwith- self. This is what is called- side \ otherin [LR0102066] (which seems to use the \((\sigma \pi)(i) = \pi(\sigma(i))\) convention for the product of permutations).- EXAMPLES: - sage: Permutation([]).shifted_concatenation(Permutation([]), "right") [] sage: Permutation([]).shifted_concatenation(Permutation([]), "left") [] sage: Permutation([2, 4, 1, 3]).shifted_concatenation(Permutation([3, 1, 2]), "right") [2, 4, 1, 3, 7, 5, 6] sage: Permutation([2, 4, 1, 3]).shifted_concatenation(Permutation([3, 1, 2]), "left") [7, 5, 6, 2, 4, 1, 3] - >>> from sage.all import * >>> Permutation([]).shifted_concatenation(Permutation([]), "right") [] >>> Permutation([]).shifted_concatenation(Permutation([]), "left") [] >>> Permutation([Integer(2), Integer(4), Integer(1), Integer(3)]).shifted_concatenation(Permutation([Integer(3), Integer(1), Integer(2)]), "right") [2, 4, 1, 3, 7, 5, 6] >>> Permutation([Integer(2), Integer(4), Integer(1), Integer(3)]).shifted_concatenation(Permutation([Integer(3), Integer(1), Integer(2)]), "left") [7, 5, 6, 2, 4, 1, 3] 
 - shifted_shuffle(other)[source]¶
- Return the shifted shuffle of two permutations - selfand- other.- INPUT: - other– a permutation, a list, a tuple, or any iterable representing a permutation
 - OUTPUT: - The list of the permutations appearing in the shifted shuffle of the permutations - selfand- other.- EXAMPLES: - sage: # needs sage.graphs sage.modules sage: Permutation([]).shifted_shuffle(Permutation([])) [[]] sage: Permutation([1, 2, 3]).shifted_shuffle(Permutation([1])) [[4, 1, 2, 3], [1, 2, 3, 4], [1, 2, 4, 3], [1, 4, 2, 3]] sage: Permutation([1, 2]).shifted_shuffle(Permutation([2, 1])) [[4, 1, 3, 2], [4, 3, 1, 2], [1, 4, 3, 2], [1, 4, 2, 3], [1, 2, 4, 3], [4, 1, 2, 3]] sage: Permutation([1]).shifted_shuffle([1]) [[2, 1], [1, 2]] sage: p = Permutation([3, 1, 5, 4, 2]) sage: len(p.shifted_shuffle(Permutation([2, 1, 4, 3]))) 126 - >>> from sage.all import * >>> # needs sage.graphs sage.modules >>> Permutation([]).shifted_shuffle(Permutation([])) [[]] >>> Permutation([Integer(1), Integer(2), Integer(3)]).shifted_shuffle(Permutation([Integer(1)])) [[4, 1, 2, 3], [1, 2, 3, 4], [1, 2, 4, 3], [1, 4, 2, 3]] >>> Permutation([Integer(1), Integer(2)]).shifted_shuffle(Permutation([Integer(2), Integer(1)])) [[4, 1, 3, 2], [4, 3, 1, 2], [1, 4, 3, 2], [1, 4, 2, 3], [1, 2, 4, 3], [4, 1, 2, 3]] >>> Permutation([Integer(1)]).shifted_shuffle([Integer(1)]) [[2, 1], [1, 2]] >>> p = Permutation([Integer(3), Integer(1), Integer(5), Integer(4), Integer(2)]) >>> len(p.shifted_shuffle(Permutation([Integer(2), Integer(1), Integer(4), Integer(3)]))) 126 - The shifted shuffle product is associative. We can test this on an admittedly toy example: - sage: all( all( all( sorted(flatten([abs.shifted_shuffle(c) # needs sage.graphs sage.modules ....: for abs in a.shifted_shuffle(b)])) ....: == sorted(flatten([a.shifted_shuffle(bcs) ....: for bcs in b.shifted_shuffle(c)])) ....: for c in Permutations(2) ) ....: for b in Permutations(2) ) ....: for a in Permutations(2) ) True - >>> from sage.all import * >>> all( all( all( sorted(flatten([abs.shifted_shuffle(c) # needs sage.graphs sage.modules ... for abs in a.shifted_shuffle(b)])) ... == sorted(flatten([a.shifted_shuffle(bcs) ... for bcs in b.shifted_shuffle(c)])) ... for c in Permutations(Integer(2)) ) ... for b in Permutations(Integer(2)) ) ... for a in Permutations(Integer(2)) ) True - The - shifted_shufflemethod on permutations gives the same permutations as the- shifted_shufflemethod on words (but is faster):- sage: all( all( sorted(p1.shifted_shuffle(p2)) # needs sage.combinat sage.graphs sage.modules sage.rings.finite_rings ....: == sorted([Permutation(p) for p in ....: Word(p1).shifted_shuffle(Word(p2))]) ....: for p2 in Permutations(3) ) ....: for p1 in Permutations(2) ) True - >>> from sage.all import * >>> all( all( sorted(p1.shifted_shuffle(p2)) # needs sage.combinat sage.graphs sage.modules sage.rings.finite_rings ... == sorted([Permutation(p) for p in ... Word(p1).shifted_shuffle(Word(p2))]) ... for p2 in Permutations(Integer(3)) ) ... for p1 in Permutations(Integer(2)) ) True 
 - show(representation='cycles', orientation='landscape', **args)[source]¶
- Display the permutation as a drawing. - INPUT: - representation– different kinds of drawings are available- 'cycles'– default; the permutation is displayed as a collection of directed cycles
- 'braid'– the permutation is displayed as segments linking each element \(1, ..., n\) to its image on a parallel line- When using this drawing, it is also possible to display the permutation horizontally ( - orientation = "landscape", default option) or vertically (- orientation = "portrait").
- 'chord-diagram'– the permutation is displayed as a directed graph, all of its vertices being located on a circle
 
 - All additional arguments are forwarded to the - showsubcalls.- EXAMPLES: - sage: P20 = Permutations(20) sage: P20.random_element().show(representation='cycles') # needs sage.graphs sage.plot sage: P20.random_element().show(representation='chord-diagram') # needs sage.graphs sage.plot sage: P20.random_element().show(representation='braid') # needs sage.plot sage: P20.random_element().show(representation='braid', # needs sage.plot ....: orientation='portrait') - >>> from sage.all import * >>> P20 = Permutations(Integer(20)) >>> P20.random_element().show(representation='cycles') # needs sage.graphs sage.plot >>> P20.random_element().show(representation='chord-diagram') # needs sage.graphs sage.plot >>> P20.random_element().show(representation='braid') # needs sage.plot >>> P20.random_element().show(representation='braid', # needs sage.plot ... orientation='portrait') 
 - sign()[source]¶
- Return the signature of the permutation - self. This is \((-1)^l\), where \(l\) is the number of inversions of- self.- Note - sign()can be used as an alias for- signature().- EXAMPLES: - sage: Permutation([4, 2, 3, 1, 5]).signature() -1 sage: Permutation([1,3,2,5,4]).sign() 1 sage: Permutation([]).sign() 1 - >>> from sage.all import * >>> Permutation([Integer(4), Integer(2), Integer(3), Integer(1), Integer(5)]).signature() -1 >>> Permutation([Integer(1),Integer(3),Integer(2),Integer(5),Integer(4)]).sign() 1 >>> Permutation([]).sign() 1 
 - signature()[source]¶
- Return the signature of the permutation - self. This is \((-1)^l\), where \(l\) is the number of inversions of- self.- Note - sign()can be used as an alias for- signature().- EXAMPLES: - sage: Permutation([4, 2, 3, 1, 5]).signature() -1 sage: Permutation([1,3,2,5,4]).sign() 1 sage: Permutation([]).sign() 1 - >>> from sage.all import * >>> Permutation([Integer(4), Integer(2), Integer(3), Integer(1), Integer(5)]).signature() -1 >>> Permutation([Integer(1),Integer(3),Integer(2),Integer(5),Integer(4)]).sign() 1 >>> Permutation([]).sign() 1 
 - simion_schmidt(avoid=[1, 2, 3])[source]¶
- Implement the Simion-Schmidt map which sends an arbitrary permutation to a pattern avoiding permutation, where the permutation pattern is one of four length-three patterns. This method also implements the bijection between (for example) - [1,2,3]- and- [1,3,2]-avoiding permutations.- INPUT: - avoid– one of the patterns- [1,2,3],- [1,3,2],- [3,1,2],- [3,2,1]
 - EXAMPLES: - sage: P = Permutations(6) sage: p = P([4,5,1,6,3,2]) sage: pl = [ [1,2,3], [1,3,2], [3,1,2], [3,2,1] ] sage: for q in pl: # needs sage.combinat ....: s = p.simion_schmidt(q) ....: print("{} {}".format(s, s.has_pattern(q))) [4, 6, 1, 5, 3, 2] False [4, 2, 1, 3, 5, 6] False [4, 5, 3, 6, 2, 1] False [4, 5, 1, 6, 2, 3] False - >>> from sage.all import * >>> P = Permutations(Integer(6)) >>> p = P([Integer(4),Integer(5),Integer(1),Integer(6),Integer(3),Integer(2)]) >>> pl = [ [Integer(1),Integer(2),Integer(3)], [Integer(1),Integer(3),Integer(2)], [Integer(3),Integer(1),Integer(2)], [Integer(3),Integer(2),Integer(1)] ] >>> for q in pl: # needs sage.combinat ... s = p.simion_schmidt(q) ... print("{} {}".format(s, s.has_pattern(q))) [4, 6, 1, 5, 3, 2] False [4, 2, 1, 3, 5, 6] False [4, 5, 3, 6, 2, 1] False [4, 5, 1, 6, 2, 3] False 
 - size()[source]¶
- Return the size of - self.- EXAMPLES: - sage: Permutation([3,4,1,2,5]).size() 5 - >>> from sage.all import * >>> Permutation([Integer(3),Integer(4),Integer(1),Integer(2),Integer(5)]).size() 5 
 - stack_sort()[source]¶
- Return the stack sort of a permutation. - This is another permutation obtained through the process of sorting using one stack. If the result is the identity permutation, the original permutation is stack-sortable. - See Wikipedia article Stack-sortable_permutation - EXAMPLES: - sage: p = Permutation([2,1,5,3,4,9,7,8,6]) sage: p.stack_sort() [1, 2, 3, 4, 5, 7, 6, 8, 9] sage: S5 = Permutations(5) sage: len([1 for s in S5 if s.stack_sort() == S5.one()]) 42 - >>> from sage.all import * >>> p = Permutation([Integer(2),Integer(1),Integer(5),Integer(3),Integer(4),Integer(9),Integer(7),Integer(8),Integer(6)]) >>> p.stack_sort() [1, 2, 3, 4, 5, 7, 6, 8, 9] >>> S5 = Permutations(Integer(5)) >>> len([Integer(1) for s in S5 if s.stack_sort() == S5.one()]) 42 
 - sylvester_class(left_to_right=False)[source]¶
- Iterate over the equivalence class of the permutation - selfunder sylvester congruence.- Sylvester congruence is an equivalence relation on the set \(S_n\) of all permutations of \(n\). It is defined as the smallest equivalence relation such that every permutation of the form \(uacvbw\) with \(u\), \(v\) and \(w\) being words and \(a\), \(b\) and \(c\) being letters satisfying \(a \leq b < c\) is equivalent to the permutation \(ucavbw\). (Here, permutations are regarded as words by way of one-line notation.) This definition comes from [HNT2005], Definition 8, where it is more generally applied to arbitrary words. - The equivalence class of a permutation \(p \in S_n\) under sylvester congruence is called the sylvester class of \(p\). It is an interval in the right permutohedron order (see - permutohedron_lequal()) on \(S_n\).- This is related to the - sylvester_class()method in that the equivalence class of a permutation \(\pi\) under sylvester congruence is the sylvester class of the right-to-left binary search tree of \(\pi\). However, the present method yields permutations, while the method on labelled binary trees yields plain lists.- If the variable - left_to_rightis set to- True, the method instead iterates over the equivalence class of- selfwith respect to the left sylvester congruence. The left sylvester congruence is easiest to define by saying that two permutations are equivalent under it if and only if their reverses (- reverse()) are equivalent under (standard) sylvester congruence.- EXAMPLES: - The sylvester class of a permutation in \(S_5\): - sage: p = Permutation([3, 5, 1, 2, 4]) sage: sorted(p.sylvester_class()) # needs sage.combinat sage.graphs [[1, 3, 2, 5, 4], [1, 3, 5, 2, 4], [1, 5, 3, 2, 4], [3, 1, 2, 5, 4], [3, 1, 5, 2, 4], [3, 5, 1, 2, 4], [5, 1, 3, 2, 4], [5, 3, 1, 2, 4]] - >>> from sage.all import * >>> p = Permutation([Integer(3), Integer(5), Integer(1), Integer(2), Integer(4)]) >>> sorted(p.sylvester_class()) # needs sage.combinat sage.graphs [[1, 3, 2, 5, 4], [1, 3, 5, 2, 4], [1, 5, 3, 2, 4], [3, 1, 2, 5, 4], [3, 1, 5, 2, 4], [3, 5, 1, 2, 4], [5, 1, 3, 2, 4], [5, 3, 1, 2, 4]] - The sylvester class of a permutation \(p\) contains \(p\): - sage: all(p in p.sylvester_class() for p in Permutations(4)) # needs sage.combinat sage.graphs True - >>> from sage.all import * >>> all(p in p.sylvester_class() for p in Permutations(Integer(4))) # needs sage.combinat sage.graphs True - Small cases: - sage: list(Permutation([]).sylvester_class()) # needs sage.combinat sage.graphs [[]] sage: list(Permutation([1]).sylvester_class()) # needs sage.combinat sage.graphs [[1]] - >>> from sage.all import * >>> list(Permutation([]).sylvester_class()) # needs sage.combinat sage.graphs [[]] >>> list(Permutation([Integer(1)]).sylvester_class()) # needs sage.combinat sage.graphs [[1]] - The sylvester classes in \(S_3\): - sage: [sorted(p.sylvester_class()) for p in Permutations(3)] # needs sage.combinat sage.graphs [[[1, 2, 3]], [[1, 3, 2], [3, 1, 2]], [[2, 1, 3]], [[2, 3, 1]], [[1, 3, 2], [3, 1, 2]], [[3, 2, 1]]] - >>> from sage.all import * >>> [sorted(p.sylvester_class()) for p in Permutations(Integer(3))] # needs sage.combinat sage.graphs [[[1, 2, 3]], [[1, 3, 2], [3, 1, 2]], [[2, 1, 3]], [[2, 3, 1]], [[1, 3, 2], [3, 1, 2]], [[3, 2, 1]]] - The left sylvester classes in \(S_3\): - sage: [sorted(p.sylvester_class(left_to_right=True)) # needs sage.combinat sage.graphs ....: for p in Permutations(3)] [[[1, 2, 3]], [[1, 3, 2]], [[2, 1, 3], [2, 3, 1]], [[2, 1, 3], [2, 3, 1]], [[3, 1, 2]], [[3, 2, 1]]] - >>> from sage.all import * >>> [sorted(p.sylvester_class(left_to_right=True)) # needs sage.combinat sage.graphs ... for p in Permutations(Integer(3))] [[[1, 2, 3]], [[1, 3, 2]], [[2, 1, 3], [2, 3, 1]], [[2, 1, 3], [2, 3, 1]], [[3, 1, 2]], [[3, 2, 1]]] - A left sylvester class in \(S_5\): - sage: p = Permutation([4, 2, 1, 5, 3]) sage: sorted(p.sylvester_class(left_to_right=True)) # needs sage.combinat sage.graphs [[4, 2, 1, 3, 5], [4, 2, 1, 5, 3], [4, 2, 3, 1, 5], [4, 2, 3, 5, 1], [4, 2, 5, 1, 3], [4, 2, 5, 3, 1], [4, 5, 2, 1, 3], [4, 5, 2, 3, 1]] - >>> from sage.all import * >>> p = Permutation([Integer(4), Integer(2), Integer(1), Integer(5), Integer(3)]) >>> sorted(p.sylvester_class(left_to_right=True)) # needs sage.combinat sage.graphs [[4, 2, 1, 3, 5], [4, 2, 1, 5, 3], [4, 2, 3, 1, 5], [4, 2, 3, 5, 1], [4, 2, 5, 1, 3], [4, 2, 5, 3, 1], [4, 5, 2, 1, 3], [4, 5, 2, 3, 1]] 
 - to_alternating_sign_matrix()[source]¶
- Return a matrix representing the permutation in the - AlternatingSignMatrixclass.- EXAMPLES: - sage: m = Permutation([1,2,3]).to_alternating_sign_matrix(); m # needs sage.combinat sage.modules [1 0 0] [0 1 0] [0 0 1] sage: parent(m) # needs sage.combinat sage.modules Alternating sign matrices of size 3 - >>> from sage.all import * >>> m = Permutation([Integer(1),Integer(2),Integer(3)]).to_alternating_sign_matrix(); m # needs sage.combinat sage.modules [1 0 0] [0 1 0] [0 0 1] >>> parent(m) # needs sage.combinat sage.modules Alternating sign matrices of size 3 
 - to_cycles(singletons=True, use_min=True)[source]¶
- Return the permutation - selfas a list of disjoint cycles.- The cycles are returned in the order of increasing smallest elements, and each cycle is returned as a tuple which starts with its smallest element. - If - singletons=Falseis given, the list does not contain the singleton cycles.- If - use_min=Falseis given, the cycles are returned in the order of increasing largest (not smallest) elements, and each cycle starts with its largest element.- EXAMPLES: - sage: Permutation([2,1,3,4]).to_cycles() [(1, 2), (3,), (4,)] sage: Permutation([2,1,3,4]).to_cycles(singletons=False) [(1, 2)] sage: Permutation([2,1,3,4]).to_cycles(use_min=True) [(1, 2), (3,), (4,)] sage: Permutation([2,1,3,4]).to_cycles(use_min=False) [(4,), (3,), (2, 1)] sage: Permutation([2,1,3,4]).to_cycles(singletons=False, use_min=False) [(2, 1)] sage: Permutation([4,1,5,2,6,3]).to_cycles() [(1, 4, 2), (3, 5, 6)] sage: Permutation([4,1,5,2,6,3]).to_cycles(use_min=False) [(6, 3, 5), (4, 2, 1)] sage: Permutation([6, 4, 5, 2, 3, 1]).to_cycles() [(1, 6), (2, 4), (3, 5)] sage: Permutation([6, 4, 5, 2, 3, 1]).to_cycles(use_min=False) [(6, 1), (5, 3), (4, 2)] - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1),Integer(3),Integer(4)]).to_cycles() [(1, 2), (3,), (4,)] >>> Permutation([Integer(2),Integer(1),Integer(3),Integer(4)]).to_cycles(singletons=False) [(1, 2)] >>> Permutation([Integer(2),Integer(1),Integer(3),Integer(4)]).to_cycles(use_min=True) [(1, 2), (3,), (4,)] >>> Permutation([Integer(2),Integer(1),Integer(3),Integer(4)]).to_cycles(use_min=False) [(4,), (3,), (2, 1)] >>> Permutation([Integer(2),Integer(1),Integer(3),Integer(4)]).to_cycles(singletons=False, use_min=False) [(2, 1)] >>> Permutation([Integer(4),Integer(1),Integer(5),Integer(2),Integer(6),Integer(3)]).to_cycles() [(1, 4, 2), (3, 5, 6)] >>> Permutation([Integer(4),Integer(1),Integer(5),Integer(2),Integer(6),Integer(3)]).to_cycles(use_min=False) [(6, 3, 5), (4, 2, 1)] >>> Permutation([Integer(6), Integer(4), Integer(5), Integer(2), Integer(3), Integer(1)]).to_cycles() [(1, 6), (2, 4), (3, 5)] >>> Permutation([Integer(6), Integer(4), Integer(5), Integer(2), Integer(3), Integer(1)]).to_cycles(use_min=False) [(6, 1), (5, 3), (4, 2)] - The algorithm is of complexity \(O(n)\) where \(n\) is the size of the given permutation. 
 - to_digraph()[source]¶
- Return a digraph representation of - self.- EXAMPLES: - sage: d = Permutation([3, 1, 2]).to_digraph() # needs sage.graphs sage: d.edges(sort=True, labels=False) # needs sage.graphs [(1, 3), (2, 1), (3, 2)] sage: P = Permutations(range(1, 10)) sage: d = Permutation(P.random_element()).to_digraph() # needs sage.graphs sage: all(c.is_cycle() # needs sage.graphs ....: for c in d.strongly_connected_components_subgraphs()) True - >>> from sage.all import * >>> d = Permutation([Integer(3), Integer(1), Integer(2)]).to_digraph() # needs sage.graphs >>> d.edges(sort=True, labels=False) # needs sage.graphs [(1, 3), (2, 1), (3, 2)] >>> P = Permutations(range(Integer(1), Integer(10))) >>> d = Permutation(P.random_element()).to_digraph() # needs sage.graphs >>> all(c.is_cycle() # needs sage.graphs ... for c in d.strongly_connected_components_subgraphs()) True 
 - to_inversion_vector()[source]¶
- Return the inversion vector of - self.- The inversion vector of a permutation \(p \in S_n\) is defined as the vector \((v_1, v_2, \ldots, v_n)\), where \(v_i\) is the number of elements larger than \(i\) that appear to the left of \(i\) in the permutation \(p\). - The algorithm is of complexity \(O(n\log(n))\) where \(n\) is the size of the given permutation. - EXAMPLES: - sage: Permutation([5,9,1,8,2,6,4,7,3]).to_inversion_vector() [2, 3, 6, 4, 0, 2, 2, 1, 0] sage: Permutation([8,7,2,1,9,4,6,5,10,3]).to_inversion_vector() [3, 2, 7, 3, 4, 3, 1, 0, 0, 0] sage: Permutation([3,2,4,1,5]).to_inversion_vector() [3, 1, 0, 0, 0] - >>> from sage.all import * >>> Permutation([Integer(5),Integer(9),Integer(1),Integer(8),Integer(2),Integer(6),Integer(4),Integer(7),Integer(3)]).to_inversion_vector() [2, 3, 6, 4, 0, 2, 2, 1, 0] >>> Permutation([Integer(8),Integer(7),Integer(2),Integer(1),Integer(9),Integer(4),Integer(6),Integer(5),Integer(10),Integer(3)]).to_inversion_vector() [3, 2, 7, 3, 4, 3, 1, 0, 0, 0] >>> Permutation([Integer(3),Integer(2),Integer(4),Integer(1),Integer(5)]).to_inversion_vector() [3, 1, 0, 0, 0] 
 - to_lehmer_cocode()[source]¶
- Return the Lehmer cocode of the permutation - self.- The Lehmer cocode of a permutation \(p\) is defined as the list \((c_1, c_2, \ldots, c_n)\), where \(c_i\) is the number of \(j < i\) such that \(p(j) > p(i)\). - EXAMPLES: - sage: p = Permutation([2,1,3]) sage: p.to_lehmer_cocode() [0, 1, 0] sage: q = Permutation([3,1,2]) sage: q.to_lehmer_cocode() [0, 1, 1] - >>> from sage.all import * >>> p = Permutation([Integer(2),Integer(1),Integer(3)]) >>> p.to_lehmer_cocode() [0, 1, 0] >>> q = Permutation([Integer(3),Integer(1),Integer(2)]) >>> q.to_lehmer_cocode() [0, 1, 1] 
 - to_lehmer_code()[source]¶
- Return the Lehmer code of the permutation - self.- The Lehmer code of a permutation \(p\) is defined as the list \([c[1],c[2],...,c[n]]\), where \(c[i]\) is the number of \(j>i\) such that \(p(j)<p(i)\). - EXAMPLES: - sage: p = Permutation([2,1,3]) sage: p.to_lehmer_code() [1, 0, 0] sage: q = Permutation([3,1,2]) sage: q.to_lehmer_code() [2, 0, 0] sage: Permutation([1]).to_lehmer_code() [0] sage: Permutation([]).to_lehmer_code() [] - >>> from sage.all import * >>> p = Permutation([Integer(2),Integer(1),Integer(3)]) >>> p.to_lehmer_code() [1, 0, 0] >>> q = Permutation([Integer(3),Integer(1),Integer(2)]) >>> q.to_lehmer_code() [2, 0, 0] >>> Permutation([Integer(1)]).to_lehmer_code() [0] >>> Permutation([]).to_lehmer_code() [] 
 - to_major_code(final_descent=False)[source]¶
- Return the major code of the permutation - self.- The major code of a permutation \(p\) is defined as the sequence \((m_1-m_2, m_2-m_3, \ldots, m_n)\), where \(m_i\) is the major index of the permutation obtained by erasing all letters smaller than \(i\) from \(p\). - With the - final_descentoption, the last position of a non-empty permutation is also considered as a descent. This has an effect on the computation of major indices.- REFERENCES: - Carlitz, L. q-Bernoulli and Eulerian Numbers. Trans. Amer. Math. Soc. 76 (1954) 332-350. http://www.ams.org/journals/tran/1954-076-02/S0002-9947-1954-0060538-2/ 
- Skandera, M. An Eulerian Partner for Inversions. Sém. Lothar. Combin. 46 (2001) B46d. http://www.lehigh.edu/~mas906/papers/partner.ps 
 - EXAMPLES: - sage: Permutation([9,3,5,7,2,1,4,6,8]).to_major_code() [5, 0, 1, 0, 1, 2, 0, 1, 0] sage: Permutation([2,8,4,3,6,7,9,5,1]).to_major_code() [8, 3, 3, 1, 4, 0, 1, 0, 0] - >>> from sage.all import * >>> Permutation([Integer(9),Integer(3),Integer(5),Integer(7),Integer(2),Integer(1),Integer(4),Integer(6),Integer(8)]).to_major_code() [5, 0, 1, 0, 1, 2, 0, 1, 0] >>> Permutation([Integer(2),Integer(8),Integer(4),Integer(3),Integer(6),Integer(7),Integer(9),Integer(5),Integer(1)]).to_major_code() [8, 3, 3, 1, 4, 0, 1, 0, 0] 
 - to_matrix()[source]¶
- Return a matrix representing the permutation. - EXAMPLES: - sage: Permutation([1,2,3]).to_matrix() # needs sage.modules [1 0 0] [0 1 0] [0 0 1] - >>> from sage.all import * >>> Permutation([Integer(1),Integer(2),Integer(3)]).to_matrix() # needs sage.modules [1 0 0] [0 1 0] [0 0 1] - Alternatively: - sage: matrix(Permutation([1,3,2])) # needs sage.modules [1 0 0] [0 0 1] [0 1 0] - >>> from sage.all import * >>> matrix(Permutation([Integer(1),Integer(3),Integer(2)])) # needs sage.modules [1 0 0] [0 0 1] [0 1 0] - Notice that matrix multiplication corresponds to permutation multiplication only when the permutation option mult=’r2l’ - sage: Permutations.options.mult='r2l' sage: p = Permutation([2,1,3]) sage: q = Permutation([3,1,2]) sage: (p*q).to_matrix() # needs sage.modules [0 0 1] [0 1 0] [1 0 0] sage: p.to_matrix()*q.to_matrix() # needs sage.modules [0 0 1] [0 1 0] [1 0 0] sage: Permutations.options.mult='l2r' sage: (p*q).to_matrix() # needs sage.modules [1 0 0] [0 0 1] [0 1 0] - >>> from sage.all import * >>> Permutations.options.mult='r2l' >>> p = Permutation([Integer(2),Integer(1),Integer(3)]) >>> q = Permutation([Integer(3),Integer(1),Integer(2)]) >>> (p*q).to_matrix() # needs sage.modules [0 0 1] [0 1 0] [1 0 0] >>> p.to_matrix()*q.to_matrix() # needs sage.modules [0 0 1] [0 1 0] [1 0 0] >>> Permutations.options.mult='l2r' >>> (p*q).to_matrix() # needs sage.modules [1 0 0] [0 0 1] [0 1 0] 
 - to_permutation_group_element()[source]¶
- Return a PermutationGroupElement equal to - self.- EXAMPLES: - sage: Permutation([2,1,4,3]).to_permutation_group_element() # needs sage.groups (1,2)(3,4) sage: Permutation([1,2,3]).to_permutation_group_element() # needs sage.groups () - >>> from sage.all import * >>> Permutation([Integer(2),Integer(1),Integer(4),Integer(3)]).to_permutation_group_element() # needs sage.groups (1,2)(3,4) >>> Permutation([Integer(1),Integer(2),Integer(3)]).to_permutation_group_element() # needs sage.groups () 
 - to_tableau_by_shape(shape)[source]¶
- Return a tableau of shape - shapewith the entries in- self.- The tableau is such that the reading word (i. e., the word obtained by reading the tableau row by row, starting from the top row in English notation, with each row being read from left to right) is - self.- EXAMPLES: - sage: T = Permutation([3,4,1,2,5]).to_tableau_by_shape([3,2]); T # needs sage.combinat [[1, 2, 5], [3, 4]] sage: T.reading_word_permutation() # needs sage.combinat [3, 4, 1, 2, 5] - >>> from sage.all import * >>> T = Permutation([Integer(3),Integer(4),Integer(1),Integer(2),Integer(5)]).to_tableau_by_shape([Integer(3),Integer(2)]); T # needs sage.combinat [[1, 2, 5], [3, 4]] >>> T.reading_word_permutation() # needs sage.combinat [3, 4, 1, 2, 5] 
 
- class sage.combinat.permutation.Permutations[source]¶
- Bases: - UniqueRepresentation,- Parent- Permutations. - Permutations(n)returns the class of permutations of- n, if- nis an integer, list, set, or string.- Permutations(n, k)returns the class of length-- kpartial permutations of- n(where- nis any of the above things);- kmust be a nonnegative integer. A length-\(k\) partial permutation of \(n\) is defined as a \(k\)-tuple of pairwise distinct elements of \(\{ 1, 2, \ldots, n \}\).- Valid keyword arguments are: ‘descents’, ‘bruhat_smaller’, ‘bruhat_greater’, ‘recoils_finer’, ‘recoils_fatter’, ‘recoils’, and ‘avoiding’. With the exception of ‘avoiding’, you cannot specify - nor- kalong with a keyword.- Permutations(descents=(list,n))returns the class of permutations of \(n\) with descents in the positions specified by- list. This uses the slightly nonstandard convention that the images of \(1,2,...,n\) under the permutation are regarded as positions \(0,1,...,n-1\), so for example the presence of \(1\) in- listsignifies that the permutations \(\pi\) should satisfy \(\pi(2) > \pi(3)\). Note that- listis supposed to be a list of positions of the descents, not the descents composition. It does not return the class of permutations with descents composition- list.- Permutations(bruhat_smaller=p)and- Permutations(bruhat_greater=p)return the class of permutations smaller-or-equal or greater-or-equal, respectively, than the given permutation- pin the Bruhat order. (The Bruhat order is defined in- bruhat_lequal(). It is also referred to as the strong Bruhat order.)- Permutations(recoils=p)returns the class of permutations whose recoils composition is- p. Unlike the- descents=(list, n)syntax, this actually takes a composition as input.- Permutations(recoils_fatter=p)and- Permutations(recoils_finer=p)return the class of permutations whose recoils composition is fatter or finer, respectively, than the given composition- p.- Permutations(n, avoiding=P)returns the class of permutations of- navoiding- P. Here- Pmay be a single permutation or a list of permutations; the returned class will avoid all patterns in- P.- EXAMPLES: - sage: p = Permutations(3); p Standard permutations of 3 sage: p.list() [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] - >>> from sage.all import * >>> p = Permutations(Integer(3)); p Standard permutations of 3 >>> p.list() [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] - sage: p = Permutations(3, 2); p Permutations of {1,...,3} of length 2 sage: p.list() [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]] - >>> from sage.all import * >>> p = Permutations(Integer(3), Integer(2)); p Permutations of {1,...,3} of length 2 >>> p.list() [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]] - sage: p = Permutations(['c', 'a', 't']); p Permutations of the set ['c', 'a', 't'] sage: p.list() [['c', 'a', 't'], ['c', 't', 'a'], ['a', 'c', 't'], ['a', 't', 'c'], ['t', 'c', 'a'], ['t', 'a', 'c']] - >>> from sage.all import * >>> p = Permutations(['c', 'a', 't']); p Permutations of the set ['c', 'a', 't'] >>> p.list() [['c', 'a', 't'], ['c', 't', 'a'], ['a', 'c', 't'], ['a', 't', 'c'], ['t', 'c', 'a'], ['t', 'a', 'c']] - sage: p = Permutations(['c', 'a', 't'], 2); p Permutations of the set ['c', 'a', 't'] of length 2 sage: p.list() [['c', 'a'], ['c', 't'], ['a', 'c'], ['a', 't'], ['t', 'c'], ['t', 'a']] - >>> from sage.all import * >>> p = Permutations(['c', 'a', 't'], Integer(2)); p Permutations of the set ['c', 'a', 't'] of length 2 >>> p.list() [['c', 'a'], ['c', 't'], ['a', 'c'], ['a', 't'], ['t', 'c'], ['t', 'a']] - sage: p = Permutations([1,1,2]); p Permutations of the multi-set [1, 1, 2] sage: p.list() [[1, 1, 2], [1, 2, 1], [2, 1, 1]] - >>> from sage.all import * >>> p = Permutations([Integer(1),Integer(1),Integer(2)]); p Permutations of the multi-set [1, 1, 2] >>> p.list() [[1, 1, 2], [1, 2, 1], [2, 1, 1]] - sage: p = Permutations([1,1,2], 2); p Permutations of the multi-set [1, 1, 2] of length 2 sage: p.list() # needs sage.libs.gap [[1, 1], [1, 2], [2, 1]] - >>> from sage.all import * >>> p = Permutations([Integer(1),Integer(1),Integer(2)], Integer(2)); p Permutations of the multi-set [1, 1, 2] of length 2 >>> p.list() # needs sage.libs.gap [[1, 1], [1, 2], [2, 1]] - sage: p = Permutations(descents=([1], 4)); p Standard permutations of 4 with descents [1] sage: p.list() # needs sage.graphs sage.modules [[2, 4, 1, 3], [3, 4, 1, 2], [1, 4, 2, 3], [1, 3, 2, 4], [2, 3, 1, 4]] - >>> from sage.all import * >>> p = Permutations(descents=([Integer(1)], Integer(4))); p Standard permutations of 4 with descents [1] >>> p.list() # needs sage.graphs sage.modules [[2, 4, 1, 3], [3, 4, 1, 2], [1, 4, 2, 3], [1, 3, 2, 4], [2, 3, 1, 4]] - sage: p = Permutations(bruhat_smaller=[1,3,2,4]); p Standard permutations that are less than or equal to [1, 3, 2, 4] in the Bruhat order sage: p.list() [[1, 2, 3, 4], [1, 3, 2, 4]] - >>> from sage.all import * >>> p = Permutations(bruhat_smaller=[Integer(1),Integer(3),Integer(2),Integer(4)]); p Standard permutations that are less than or equal to [1, 3, 2, 4] in the Bruhat order >>> p.list() [[1, 2, 3, 4], [1, 3, 2, 4]] - sage: p = Permutations(bruhat_greater=[4,2,3,1]); p Standard permutations that are greater than or equal to [4, 2, 3, 1] in the Bruhat order sage: p.list() [[4, 2, 3, 1], [4, 3, 2, 1]] - >>> from sage.all import * >>> p = Permutations(bruhat_greater=[Integer(4),Integer(2),Integer(3),Integer(1)]); p Standard permutations that are greater than or equal to [4, 2, 3, 1] in the Bruhat order >>> p.list() [[4, 2, 3, 1], [4, 3, 2, 1]] - sage: p = Permutations(recoils_finer=[2,1]); p Standard permutations whose recoils composition is finer than [2, 1] sage: p.list() # needs sage.graphs sage.modules [[3, 1, 2], [1, 2, 3], [1, 3, 2]] - >>> from sage.all import * >>> p = Permutations(recoils_finer=[Integer(2),Integer(1)]); p Standard permutations whose recoils composition is finer than [2, 1] >>> p.list() # needs sage.graphs sage.modules [[3, 1, 2], [1, 2, 3], [1, 3, 2]] - sage: p = Permutations(recoils_fatter=[2,1]); p Standard permutations whose recoils composition is fatter than [2, 1] sage: p.list() # needs sage.graphs sage.modules [[3, 1, 2], [3, 2, 1], [1, 3, 2]] - >>> from sage.all import * >>> p = Permutations(recoils_fatter=[Integer(2),Integer(1)]); p Standard permutations whose recoils composition is fatter than [2, 1] >>> p.list() # needs sage.graphs sage.modules [[3, 1, 2], [3, 2, 1], [1, 3, 2]] - sage: p = Permutations(recoils=[2,1]); p Standard permutations whose recoils composition is [2, 1] sage: p.list() # needs sage.graphs sage.modules [[3, 1, 2], [1, 3, 2]] - >>> from sage.all import * >>> p = Permutations(recoils=[Integer(2),Integer(1)]); p Standard permutations whose recoils composition is [2, 1] >>> p.list() # needs sage.graphs sage.modules [[3, 1, 2], [1, 3, 2]] - sage: p = Permutations(4, avoiding=[1,3,2]); p Standard permutations of 4 avoiding [[1, 3, 2]] sage: p.list() [[4, 1, 2, 3], [4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1], [3, 4, 1, 2], [3, 4, 2, 1], [2, 3, 4, 1], [3, 2, 4, 1], [1, 2, 3, 4], [2, 1, 3, 4], [2, 3, 1, 4], [3, 1, 2, 4], [3, 2, 1, 4]] - >>> from sage.all import * >>> p = Permutations(Integer(4), avoiding=[Integer(1),Integer(3),Integer(2)]); p Standard permutations of 4 avoiding [[1, 3, 2]] >>> p.list() [[4, 1, 2, 3], [4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1], [3, 4, 1, 2], [3, 4, 2, 1], [2, 3, 4, 1], [3, 2, 4, 1], [1, 2, 3, 4], [2, 1, 3, 4], [2, 3, 1, 4], [3, 1, 2, 4], [3, 2, 1, 4]] - sage: p = Permutations(5, avoiding=[[3,4,1,2], [4,2,3,1]]); p Standard permutations of 5 avoiding [[3, 4, 1, 2], [4, 2, 3, 1]] sage: p.cardinality() # needs sage.combinat 88 sage: p.random_element().parent() is p # needs sage.combinat True - >>> from sage.all import * >>> p = Permutations(Integer(5), avoiding=[[Integer(3),Integer(4),Integer(1),Integer(2)], [Integer(4),Integer(2),Integer(3),Integer(1)]]); p Standard permutations of 5 avoiding [[3, 4, 1, 2], [4, 2, 3, 1]] >>> p.cardinality() # needs sage.combinat 88 >>> p.random_element().parent() is p # needs sage.combinat True - Element[source]¶
- alias of - Permutation
 
- class sage.combinat.permutation.PermutationsNK(s, k)[source]¶
- Bases: - Permutations_setk- This exists solely for unpickling - PermutationsNKobjects created with Sage <= 6.3.
- class sage.combinat.permutation.Permutations_mset(mset)[source]¶
- Bases: - Permutations- Permutations of a multiset \(M\). - A permutation of a multiset \(M\) is represented by a list that contains exactly the same elements as \(M\) (with the same multiplicities), but possibly in different order. If \(M\) is a proper set there are \(|M| !\) such permutations. Otherwise, if the first element appears \(k_1\) times, the second element appears \(k_2\) times and so on, the number of permutations is \(|M|! / (k_1! k_2! \ldots)\), which is sometimes called a multinomial coefficient. - EXAMPLES: - sage: mset = [1,1,2,2,2] sage: from sage.combinat.permutation import Permutations_mset sage: P = Permutations_mset(mset); P Permutations of the multi-set [1, 1, 2, 2, 2] sage: sorted(P) [[1, 1, 2, 2, 2], [1, 2, 1, 2, 2], [1, 2, 2, 1, 2], [1, 2, 2, 2, 1], [2, 1, 1, 2, 2], [2, 1, 2, 1, 2], [2, 1, 2, 2, 1], [2, 2, 1, 1, 2], [2, 2, 1, 2, 1], [2, 2, 2, 1, 1]] sage: # needs sage.modules sage: MS = MatrixSpace(GF(2), 2, 2) sage: A = MS([1,0,1,1]) sage: rows = A.rows() sage: rows[0].set_immutable() sage: rows[1].set_immutable() sage: P = Permutations_mset(rows); P Permutations of the multi-set [(1, 0), (1, 1)] sage: sorted(P) [[(1, 0), (1, 1)], [(1, 1), (1, 0)]] - >>> from sage.all import * >>> mset = [Integer(1),Integer(1),Integer(2),Integer(2),Integer(2)] >>> from sage.combinat.permutation import Permutations_mset >>> P = Permutations_mset(mset); P Permutations of the multi-set [1, 1, 2, 2, 2] >>> sorted(P) [[1, 1, 2, 2, 2], [1, 2, 1, 2, 2], [1, 2, 2, 1, 2], [1, 2, 2, 2, 1], [2, 1, 1, 2, 2], [2, 1, 2, 1, 2], [2, 1, 2, 2, 1], [2, 2, 1, 1, 2], [2, 2, 1, 2, 1], [2, 2, 2, 1, 1]] >>> # needs sage.modules >>> MS = MatrixSpace(GF(Integer(2)), Integer(2), Integer(2)) >>> A = MS([Integer(1),Integer(0),Integer(1),Integer(1)]) >>> rows = A.rows() >>> rows[Integer(0)].set_immutable() >>> rows[Integer(1)].set_immutable() >>> P = Permutations_mset(rows); P Permutations of the multi-set [(1, 0), (1, 1)] >>> sorted(P) [[(1, 0), (1, 1)], [(1, 1), (1, 0)]] - class Element[source]¶
- Bases: - ClonableArray- A permutation of an arbitrary multiset. 
 - cardinality()[source]¶
- Return the cardinality of the set. - EXAMPLES: - sage: Permutations([1,2,2]).cardinality() 3 sage: Permutations([1,1,2,2,2]).cardinality() 10 - >>> from sage.all import * >>> Permutations([Integer(1),Integer(2),Integer(2)]).cardinality() 3 >>> Permutations([Integer(1),Integer(1),Integer(2),Integer(2),Integer(2)]).cardinality() 10 
 - rank(p)[source]¶
- Return the rank of - pin lexicographic order.- INPUT: - p– a permutation of \(M\)
 - ALGORITHM: - The algorithm uses the recurrence from the solution to exercise 4 in [Knu2011], Section 7.2.1.2: \[\mathrm{rank}(p_1 \ldots p_n) = \mathrm{rank}(p_2 \ldots p_n) + \frac{1}{n} \genfrac{(}{)}{0pt}{0}{n}{n_1, \ldots, n_t} \sum_{j=1}^t n_j \left[ x_j < p_1 \right],\]- where \(x_j, n_j\) are the distinct elements of \(p\) with their multiplicities, \(n\) is the sum of \(n_1, \ldots, n_t\), \(\genfrac{(}{)}{0pt}{1}{n}{n_1, \ldots, n_t}\) is the multinomial coefficient \(\frac{n!}{n_1! \ldots n_t!}\), and \(\sum_{j=1}^t n_j \left[ x_j < p_1 \right]\) means “the number of elements to the right of the first element that are less than the first element”. - EXAMPLES: - sage: mset = [1, 1, 2, 3, 4, 5, 5, 6, 9] sage: p = Permutations(mset) sage: p.rank(list(sorted(mset))) 0 sage: p.rank(list(reversed(sorted(mset)))) == p.cardinality() - 1 True sage: p.rank([3, 1, 4, 1, 5, 9, 2, 6, 5]) 30991 - >>> from sage.all import * >>> mset = [Integer(1), Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(5), Integer(6), Integer(9)] >>> p = Permutations(mset) >>> p.rank(list(sorted(mset))) 0 >>> p.rank(list(reversed(sorted(mset)))) == p.cardinality() - Integer(1) True >>> p.rank([Integer(3), Integer(1), Integer(4), Integer(1), Integer(5), Integer(9), Integer(2), Integer(6), Integer(5)]) 30991 
 - unrank(r)[source]¶
- Return the permutation of \(M\) having lexicographic rank - r.- INPUT: - r– integer between- 0and- self.cardinality()-1inclusive
 - ALGORITHM: - The algorithm is adapted from the solution to exercise 4 in [Knu2011], Section 7.2.1.2. - EXAMPLES: - sage: mset = [1, 1, 2, 3, 4, 5, 5, 6, 9] sage: p = Permutations(mset) sage: p.unrank(30991) [3, 1, 4, 1, 5, 9, 2, 6, 5] sage: p.rank(p.unrank(10)) 10 sage: p.unrank(0) == list(sorted(mset)) True sage: p.unrank(p.cardinality()-1) == list(reversed(sorted(mset))) True - >>> from sage.all import * >>> mset = [Integer(1), Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(5), Integer(6), Integer(9)] >>> p = Permutations(mset) >>> p.unrank(Integer(30991)) [3, 1, 4, 1, 5, 9, 2, 6, 5] >>> p.rank(p.unrank(Integer(10))) 10 >>> p.unrank(Integer(0)) == list(sorted(mset)) True >>> p.unrank(p.cardinality()-Integer(1)) == list(reversed(sorted(mset))) True 
 
- class sage.combinat.permutation.Permutations_msetk(mset, k)[source]¶
- Bases: - Permutations_mset- Length-\(k\) partial permutations of a multiset. - A length-\(k\) partial permutation of a multiset \(M\) is represented by a list of length \(k\) whose entries are elements of \(M\), appearing in the list with a multiplicity not higher than their respective multiplicity in \(M\). 
- class sage.combinat.permutation.Permutations_nk(n, k)[source]¶
- Bases: - Permutations- Length-\(k\) partial permutations of \(\{1, 2, \ldots, n\}\). - class Element[source]¶
- Bases: - ClonableArray- A length-\(k\) partial permutation of \([n]\). 
 - cardinality()[source]¶
- EXAMPLES: - sage: Permutations(3,0).cardinality() 1 sage: Permutations(3,1).cardinality() 3 sage: Permutations(3,2).cardinality() 6 sage: Permutations(3,3).cardinality() 6 sage: Permutations(3,4).cardinality() 0 - >>> from sage.all import * >>> Permutations(Integer(3),Integer(0)).cardinality() 1 >>> Permutations(Integer(3),Integer(1)).cardinality() 3 >>> Permutations(Integer(3),Integer(2)).cardinality() 6 >>> Permutations(Integer(3),Integer(3)).cardinality() 6 >>> Permutations(Integer(3),Integer(4)).cardinality() 0 
 
- class sage.combinat.permutation.Permutations_set(s)[source]¶
- Bases: - Permutations- Permutations of an arbitrary given finite set. - Here, a “permutation of a finite set \(S\)” means a list of the elements of \(S\) in which every element of \(S\) occurs exactly once. This is not to be confused with bijections from \(S\) to \(S\), which are also often called permutations in literature. - class Element[source]¶
- Bases: - ClonableArray- A permutation of an arbitrary set. 
 - cardinality()[source]¶
- Return the cardinality of the set. - EXAMPLES: - sage: Permutations([1,2,3]).cardinality() 6 - >>> from sage.all import * >>> Permutations([Integer(1),Integer(2),Integer(3)]).cardinality() 6 
 - random_element()[source]¶
- EXAMPLES: - sage: s = Permutations([1,2,3]).random_element() sage: s.parent() is Permutations([1,2,3]) True - >>> from sage.all import * >>> s = Permutations([Integer(1),Integer(2),Integer(3)]).random_element() >>> s.parent() is Permutations([Integer(1),Integer(2),Integer(3)]) True 
 
- class sage.combinat.permutation.Permutations_setk(s, k)[source]¶
- Bases: - Permutations_set- Length-\(k\) partial permutations of an arbitrary given finite set. - Here, a “length-\(k\) partial permutation of a finite set \(S\)” means a list of length \(k\) whose entries are pairwise distinct and all belong to \(S\). - random_element()[source]¶
- EXAMPLES: - sage: s = Permutations([1,2,4], 2).random_element() sage: s in Permutations([1,2,4], 2) True - >>> from sage.all import * >>> s = Permutations([Integer(1),Integer(2),Integer(4)], Integer(2)).random_element() >>> s in Permutations([Integer(1),Integer(2),Integer(4)], Integer(2)) True 
 
- class sage.combinat.permutation.StandardPermutations_all[source]¶
- Bases: - Permutations- All standard permutations. 
- class sage.combinat.permutation.StandardPermutations_all_avoiding(a)[source]¶
- Bases: - StandardPermutations_all- All standard permutations avoiding a set of patterns. - patterns()[source]¶
- Return the patterns avoided by this class of permutations. - EXAMPLES: - sage: P = Permutations(avoiding=[[2,1,3],[1,2,3]]) sage: P.patterns() ([2, 1, 3], [1, 2, 3]) - >>> from sage.all import * >>> P = Permutations(avoiding=[[Integer(2),Integer(1),Integer(3)],[Integer(1),Integer(2),Integer(3)]]) >>> P.patterns() ([2, 1, 3], [1, 2, 3]) 
 
- class sage.combinat.permutation.StandardPermutations_avoiding_123(n)[source]¶
- Bases: - StandardPermutations_avoiding_generic- cardinality()[source]¶
- EXAMPLES: - sage: Permutations(5, avoiding=[1, 2, 3]).cardinality() 42 sage: len( Permutations(5, avoiding=[1, 2, 3]).list() ) 42 - >>> from sage.all import * >>> Permutations(Integer(5), avoiding=[Integer(1), Integer(2), Integer(3)]).cardinality() 42 >>> len( Permutations(Integer(5), avoiding=[Integer(1), Integer(2), Integer(3)]).list() ) 42 
 
- class sage.combinat.permutation.StandardPermutations_avoiding_132(n)[source]¶
- Bases: - StandardPermutations_avoiding_generic- cardinality()[source]¶
- EXAMPLES: - sage: Permutations(5, avoiding=[1, 3, 2]).cardinality() 42 sage: len( Permutations(5, avoiding=[1, 3, 2]).list() ) 42 - >>> from sage.all import * >>> Permutations(Integer(5), avoiding=[Integer(1), Integer(3), Integer(2)]).cardinality() 42 >>> len( Permutations(Integer(5), avoiding=[Integer(1), Integer(3), Integer(2)]).list() ) 42 
 
- class sage.combinat.permutation.StandardPermutations_avoiding_213(n)[source]¶
- Bases: - StandardPermutations_avoiding_generic- cardinality()[source]¶
- EXAMPLES: - sage: Permutations(5, avoiding=[2, 1, 3]).cardinality() 42 sage: len( Permutations(5, avoiding=[2, 1, 3]).list() ) 42 - >>> from sage.all import * >>> Permutations(Integer(5), avoiding=[Integer(2), Integer(1), Integer(3)]).cardinality() 42 >>> len( Permutations(Integer(5), avoiding=[Integer(2), Integer(1), Integer(3)]).list() ) 42 
 
- class sage.combinat.permutation.StandardPermutations_avoiding_231(n)[source]¶
- Bases: - StandardPermutations_avoiding_generic- cardinality()[source]¶
- EXAMPLES: - sage: Permutations(5, avoiding=[2, 3, 1]).cardinality() 42 sage: len( Permutations(5, avoiding=[2, 3, 1]).list() ) 42 - >>> from sage.all import * >>> Permutations(Integer(5), avoiding=[Integer(2), Integer(3), Integer(1)]).cardinality() 42 >>> len( Permutations(Integer(5), avoiding=[Integer(2), Integer(3), Integer(1)]).list() ) 42 
 
- class sage.combinat.permutation.StandardPermutations_avoiding_312(n)[source]¶
- Bases: - StandardPermutations_avoiding_generic- cardinality()[source]¶
- EXAMPLES: - sage: Permutations(5, avoiding=[3, 1, 2]).cardinality() 42 sage: len( Permutations(5, avoiding=[3, 1, 2]).list() ) 42 - >>> from sage.all import * >>> Permutations(Integer(5), avoiding=[Integer(3), Integer(1), Integer(2)]).cardinality() 42 >>> len( Permutations(Integer(5), avoiding=[Integer(3), Integer(1), Integer(2)]).list() ) 42 
 
- class sage.combinat.permutation.StandardPermutations_avoiding_321(n)[source]¶
- Bases: - StandardPermutations_avoiding_generic- cardinality()[source]¶
- EXAMPLES: - sage: Permutations(5, avoiding=[3, 2, 1]).cardinality() 42 sage: len( Permutations(5, avoiding=[3, 2, 1]).list() ) 42 - >>> from sage.all import * >>> Permutations(Integer(5), avoiding=[Integer(3), Integer(2), Integer(1)]).cardinality() 42 >>> len( Permutations(Integer(5), avoiding=[Integer(3), Integer(2), Integer(1)]).list() ) 42 
 
- class sage.combinat.permutation.StandardPermutations_avoiding_generic(n, a)[source]¶
- Bases: - StandardPermutations_n_abstract- Generic class for subset of permutations avoiding a set of patterns. - cardinality()[source]¶
- Return the cardinality of - self.- EXAMPLES: - sage: P = Permutations(3, avoiding=[[2, 1, 3],[1,2,3]]) sage: P.cardinality() # needs sage.combinat 4 - >>> from sage.all import * >>> P = Permutations(Integer(3), avoiding=[[Integer(2), Integer(1), Integer(3)],[Integer(1),Integer(2),Integer(3)]]) >>> P.cardinality() # needs sage.combinat 4 
 - patterns()[source]¶
- Return the patterns avoided by this class of permutations. - EXAMPLES: - sage: P = Permutations(3, avoiding=[[2,1,3],[1,2,3]]) sage: P.patterns() ([2, 1, 3], [1, 2, 3]) - >>> from sage.all import * >>> P = Permutations(Integer(3), avoiding=[[Integer(2),Integer(1),Integer(3)],[Integer(1),Integer(2),Integer(3)]]) >>> P.patterns() ([2, 1, 3], [1, 2, 3]) 
 
- class sage.combinat.permutation.StandardPermutations_bruhat_greater(p)[source]¶
- Bases: - Permutations- Permutations of \(\{1, \ldots, n\}\) that are greater than or equal to a permutation \(p\) in the Bruhat order. 
- class sage.combinat.permutation.StandardPermutations_bruhat_smaller(p)[source]¶
- Bases: - Permutations- Permutations of \(\{1, \ldots, n\}\) that are less than or equal to a permutation \(p\) in the Bruhat order. 
- class sage.combinat.permutation.StandardPermutations_descents(d, n)[source]¶
- Bases: - StandardPermutations_n_abstract- Permutations of \(\{1, \ldots, n\}\) with a fixed set of descents. - cardinality()[source]¶
- Return the cardinality of - self.- ALGORITHM: - The algorithm described in [Vie1979] is implemented naively. - EXAMPLES: - sage: P = Permutations(descents=([1,0,2], 5)) sage: P.cardinality() 4 - >>> from sage.all import * >>> P = Permutations(descents=([Integer(1),Integer(0),Integer(2)], Integer(5))) >>> P.cardinality() 4 
 - first()[source]¶
- Return the first permutation with descents \(d\). - EXAMPLES: - sage: Permutations(descents=([1,0,4,8],12)).first() [3, 2, 1, 4, 6, 5, 7, 8, 10, 9, 11, 12] - >>> from sage.all import * >>> Permutations(descents=([Integer(1),Integer(0),Integer(4),Integer(8)],Integer(12))).first() [3, 2, 1, 4, 6, 5, 7, 8, 10, 9, 11, 12] 
 - last()[source]¶
- Return the last permutation with descents \(d\). - EXAMPLES: - sage: Permutations(descents=([1,0,4,8],12)).last() [12, 11, 8, 9, 10, 4, 5, 6, 7, 1, 2, 3] - >>> from sage.all import * >>> Permutations(descents=([Integer(1),Integer(0),Integer(4),Integer(8)],Integer(12))).last() [12, 11, 8, 9, 10, 4, 5, 6, 7, 1, 2, 3] 
 
- class sage.combinat.permutation.StandardPermutations_n(n)[source]¶
- Bases: - StandardPermutations_n_abstract- Permutations of the set \(\{1, 2, \ldots, n\}\). - These are also called permutations of size \(n\), or the elements of the \(n\)-th symmetric group. - Todo - Have a - reduced_word()which works in both multiplication conventions.- class Element(parent, l, algorithm='lex', sjt=None, check=True)[source]¶
- Bases: - Permutation- apply_simple_reflection_left(i)[source]¶
- Return - selfmultiplied by the simple reflection- s[i]on the left.- This acts by switching the entries in positions \(i\) and \(i+1\). - Warning - This ignores the multiplication convention in order to be consistent with other Coxeter operations in permutations (e.g., computing - reduced_word()).- EXAMPLES: - sage: W = Permutations(3) sage: w = W([2,3,1]) sage: w.apply_simple_reflection_left(1) [1, 3, 2] sage: w.apply_simple_reflection_left(2) [3, 2, 1] - >>> from sage.all import * >>> W = Permutations(Integer(3)) >>> w = W([Integer(2),Integer(3),Integer(1)]) >>> w.apply_simple_reflection_left(Integer(1)) [1, 3, 2] >>> w.apply_simple_reflection_left(Integer(2)) [3, 2, 1] 
 - apply_simple_reflection_right(i)[source]¶
- Return - selfmultiplied by the simple reflection- s[i]on the right.- This acts by switching the entries \(i\) and \(i+1\). - Warning - This ignores the multiplication convention in order to be consistent with other Coxeter operations in permutations (e.g., computing - reduced_word()).- EXAMPLES: - sage: W = Permutations(3) sage: w = W([2,3,1]) sage: w.apply_simple_reflection_right(1) [3, 2, 1] sage: w.apply_simple_reflection_right(2) [2, 1, 3] - >>> from sage.all import * >>> W = Permutations(Integer(3)) >>> w = W([Integer(2),Integer(3),Integer(1)]) >>> w.apply_simple_reflection_right(Integer(1)) [3, 2, 1] >>> w.apply_simple_reflection_right(Integer(2)) [2, 1, 3] 
 - has_left_descent(i)[source]¶
- Check if - iis a left descent of- self.- A left descent of a permutation \(\pi \in S_n\) means an index \(i \in \{ 1, 2, \ldots, n-1 \}\) such that \(s_i \circ \pi\) has smaller length than \(\pi\). Thus, a left descent of \(\pi\) is an index \(i \in \{ 1, 2, \ldots, n-1 \}\) satisfying \(\pi^{-1}(i) > \pi^{-1}(i+1)\). - Warning - The methods - descents()and- idescents()behave differently than their Weyl group counterparts. In particular, the indexing is 0-based. This could lead to errors. Instead, construct the descent set as in the example.- Warning - This ignores the multiplication convention in order to be consistent with other Coxeter operations in permutations (e.g., computing - reduced_word()).- EXAMPLES: - sage: P = Permutations(4) sage: x = P([3, 2, 4, 1]) sage: (~x).descents() [1, 2] sage: [i for i in P.index_set() if x.has_left_descent(i)] [1, 2] - >>> from sage.all import * >>> P = Permutations(Integer(4)) >>> x = P([Integer(3), Integer(2), Integer(4), Integer(1)]) >>> (~x).descents() [1, 2] >>> [i for i in P.index_set() if x.has_left_descent(i)] [1, 2] 
 - has_right_descent(i, mult=None)[source]¶
- Check if - iis a right descent of- self.- A right descent of a permutation \(\pi \in S_n\) means an index \(i \in \{ 1, 2, \ldots, n-1 \}\) such that \(\pi \circ s_i\) has smaller length than \(\pi\). Thus, a right descent of \(\pi\) is an index \(i \in \{ 1, 2, \ldots, n-1 \}\) satisfying \(\pi(i) > \pi(i+1)\). - Warning - The methods - descents()and- idescents()behave differently than their Weyl group counterparts. In particular, the indexing is 0-based. This could lead to errors. Instead, construct the descent set as in the example.- Warning - This ignores the multiplication convention in order to be consistent with other Coxeter operations in permutations (e.g., computing - reduced_word()).- EXAMPLES: - sage: P = Permutations(4) sage: x = P([3, 2, 4, 1]) sage: x.descents() [1, 3] sage: [i for i in P.index_set() if x.has_right_descent(i)] [1, 3] - >>> from sage.all import * >>> P = Permutations(Integer(4)) >>> x = P([Integer(3), Integer(2), Integer(4), Integer(1)]) >>> x.descents() [1, 3] >>> [i for i in P.index_set() if x.has_right_descent(i)] [1, 3] 
 - inverse()[source]¶
- Return the inverse of - self.- EXAMPLES: - sage: P = Permutations(4) sage: w0 = P([4,3,2,1]) sage: w0.inverse() == w0 True sage: w0.inverse().parent() is P True sage: P([3,2,4,1]).inverse() [4, 2, 1, 3] - >>> from sage.all import * >>> P = Permutations(Integer(4)) >>> w0 = P([Integer(4),Integer(3),Integer(2),Integer(1)]) >>> w0.inverse() == w0 True >>> w0.inverse().parent() is P True >>> P([Integer(3),Integer(2),Integer(4),Integer(1)]).inverse() [4, 2, 1, 3] 
 
 - algebra(base_ring, category=None)[source]¶
- Return the symmetric group algebra associated to - self.- INPUT: - base_ring– a ring
- category– a category (default: the category of- self)
 - EXAMPLES: - sage: # needs sage.groups sage.modules sage: P = Permutations(4) sage: A = P.algebra(QQ); A Symmetric group algebra of order 4 over Rational Field sage: A.category() Join of Category of Coxeter group algebras over Rational Field and Category of finite group algebras over Rational Field and Category of finite dimensional cellular algebras with basis over Rational Field sage: A = P.algebra(QQ, category=Monoids()) sage: A.category() Category of finite dimensional cellular monoid algebras over Rational Field - >>> from sage.all import * >>> # needs sage.groups sage.modules >>> P = Permutations(Integer(4)) >>> A = P.algebra(QQ); A Symmetric group algebra of order 4 over Rational Field >>> A.category() Join of Category of Coxeter group algebras over Rational Field and Category of finite group algebras over Rational Field and Category of finite dimensional cellular algebras with basis over Rational Field >>> A = P.algebra(QQ, category=Monoids()) >>> A.category() Category of finite dimensional cellular monoid algebras over Rational Field 
 - as_permutation_group()[source]¶
- Return - selfas a permutation group.- EXAMPLES: - sage: P = Permutations(4) sage: PG = P.as_permutation_group(); PG # needs sage.groups Symmetric group of order 4! as a permutation group sage: G = SymmetricGroup(4) # needs sage.groups sage: PG is G # needs sage.groups True - >>> from sage.all import * >>> P = Permutations(Integer(4)) >>> PG = P.as_permutation_group(); PG # needs sage.groups Symmetric group of order 4! as a permutation group >>> G = SymmetricGroup(Integer(4)) # needs sage.groups >>> PG is G # needs sage.groups True 
 - cardinality()[source]¶
- Return the number of permutations of size \(n\), which is \(n!\). - EXAMPLES: - sage: Permutations(0).cardinality() 1 sage: Permutations(3).cardinality() 6 sage: Permutations(4).cardinality() 24 - >>> from sage.all import * >>> Permutations(Integer(0)).cardinality() 1 >>> Permutations(Integer(3)).cardinality() 6 >>> Permutations(Integer(4)).cardinality() 24 
 - cartan_type()[source]¶
- Return the Cartan type of - self.- The symmetric group \(S_n\) is a Coxeter group of type \(A_{n-1}\). - EXAMPLES: - sage: A = SymmetricGroup([2,3,7]); A.cartan_type() # needs sage.combinat sage.groups ['A', 2] sage: A = SymmetricGroup([]); A.cartan_type() # needs sage.combinat sage.groups ['A', 0] - >>> from sage.all import * >>> A = SymmetricGroup([Integer(2),Integer(3),Integer(7)]); A.cartan_type() # needs sage.combinat sage.groups ['A', 2] >>> A = SymmetricGroup([]); A.cartan_type() # needs sage.combinat sage.groups ['A', 0] 
 - codegrees()[source]¶
- Return the codegrees of - self.- EXAMPLES: - sage: Permutations(3).codegrees() (0, 1) sage: Permutations(7).codegrees() (0, 1, 2, 3, 4, 5) - >>> from sage.all import * >>> Permutations(Integer(3)).codegrees() (0, 1) >>> Permutations(Integer(7)).codegrees() (0, 1, 2, 3, 4, 5) 
 - conjugacy_class(g)[source]¶
- Return the conjugacy class of - gin- self.- INPUT: - g– a partition or an element of- self
 - EXAMPLES: - sage: G = Permutations(5) sage: g = G([2,3,4,1,5]) sage: G.conjugacy_class(g) # needs sage.combinat sage.graphs sage.groups Conjugacy class of cycle type [4, 1] in Standard permutations of 5 sage: G.conjugacy_class(Partition([2, 1, 1, 1])) # needs sage.combinat sage.graphs sage.groups Conjugacy class of cycle type [2, 1, 1, 1] in Standard permutations of 5 - >>> from sage.all import * >>> G = Permutations(Integer(5)) >>> g = G([Integer(2),Integer(3),Integer(4),Integer(1),Integer(5)]) >>> G.conjugacy_class(g) # needs sage.combinat sage.graphs sage.groups Conjugacy class of cycle type [4, 1] in Standard permutations of 5 >>> G.conjugacy_class(Partition([Integer(2), Integer(1), Integer(1), Integer(1)])) # needs sage.combinat sage.graphs sage.groups Conjugacy class of cycle type [2, 1, 1, 1] in Standard permutations of 5 
 - conjugacy_classes()[source]¶
- Return a list of the conjugacy classes of - self.- EXAMPLES: - sage: G = Permutations(4) sage: G.conjugacy_classes() # needs sage.combinat sage.graphs sage.groups [Conjugacy class of cycle type [1, 1, 1, 1] in Standard permutations of 4, Conjugacy class of cycle type [2, 1, 1] in Standard permutations of 4, Conjugacy class of cycle type [2, 2] in Standard permutations of 4, Conjugacy class of cycle type [3, 1] in Standard permutations of 4, Conjugacy class of cycle type [4] in Standard permutations of 4] - >>> from sage.all import * >>> G = Permutations(Integer(4)) >>> G.conjugacy_classes() # needs sage.combinat sage.graphs sage.groups [Conjugacy class of cycle type [1, 1, 1, 1] in Standard permutations of 4, Conjugacy class of cycle type [2, 1, 1] in Standard permutations of 4, Conjugacy class of cycle type [2, 2] in Standard permutations of 4, Conjugacy class of cycle type [3, 1] in Standard permutations of 4, Conjugacy class of cycle type [4] in Standard permutations of 4] 
 - conjugacy_classes_iterator()[source]¶
- Iterate over the conjugacy classes of - self.- EXAMPLES: - sage: G = Permutations(4) sage: list(G.conjugacy_classes_iterator()) == G.conjugacy_classes() # needs sage.combinat sage.graphs sage.groups True - >>> from sage.all import * >>> G = Permutations(Integer(4)) >>> list(G.conjugacy_classes_iterator()) == G.conjugacy_classes() # needs sage.combinat sage.graphs sage.groups True 
 - conjugacy_classes_representatives()[source]¶
- Return a complete list of representatives of conjugacy classes in - self.- Let \(S_n\) be the symmetric group on \(n\) letters. The conjugacy classes are indexed by partitions \(\lambda\) of \(n\). The ordering of the conjugacy classes is reverse lexicographic order of the partitions. - EXAMPLES: - sage: G = Permutations(5) sage: G.conjugacy_classes_representatives() # needs sage.combinat sage.libs.flint [[1, 2, 3, 4, 5], [2, 1, 3, 4, 5], [2, 1, 4, 3, 5], [2, 3, 1, 4, 5], [2, 3, 1, 5, 4], [2, 3, 4, 1, 5], [2, 3, 4, 5, 1]] - >>> from sage.all import * >>> G = Permutations(Integer(5)) >>> G.conjugacy_classes_representatives() # needs sage.combinat sage.libs.flint [[1, 2, 3, 4, 5], [2, 1, 3, 4, 5], [2, 1, 4, 3, 5], [2, 3, 1, 4, 5], [2, 3, 1, 5, 4], [2, 3, 4, 1, 5], [2, 3, 4, 5, 1]] 
 - degree()[source]¶
- Return the degree of - self.- This is the cardinality \(n\) of the set - selfacts on.- EXAMPLES: - sage: Permutations(0).degree() 0 sage: Permutations(1).degree() 1 sage: Permutations(5).degree() 5 - >>> from sage.all import * >>> Permutations(Integer(0)).degree() 0 >>> Permutations(Integer(1)).degree() 1 >>> Permutations(Integer(5)).degree() 5 
 - degrees()[source]¶
- Return the degrees of - self.- These are the degrees of the fundamental invariants of the ring of polynomial invariants. - EXAMPLES: - sage: Permutations(3).degrees() (2, 3) sage: Permutations(7).degrees() (2, 3, 4, 5, 6, 7) - >>> from sage.all import * >>> Permutations(Integer(3)).degrees() (2, 3) >>> Permutations(Integer(7)).degrees() (2, 3, 4, 5, 6, 7) 
 - element_in_conjugacy_classes(nu)[source]¶
- Return a permutation with cycle type - nu.- If the size of - nuis smaller than the size of permutations in- self, then some fixed points are added.- EXAMPLES: - sage: PP = Permutations(5) sage: PP.element_in_conjugacy_classes([2,2]) # needs sage.combinat [2, 1, 4, 3, 5] sage: PP.element_in_conjugacy_classes([5, 5]) # needs sage.combinat Traceback (most recent call last): ... ValueError: the size of the partition (=10) should be at most the size of the permutations (=5) - >>> from sage.all import * >>> PP = Permutations(Integer(5)) >>> PP.element_in_conjugacy_classes([Integer(2),Integer(2)]) # needs sage.combinat [2, 1, 4, 3, 5] >>> PP.element_in_conjugacy_classes([Integer(5), Integer(5)]) # needs sage.combinat Traceback (most recent call last): ... ValueError: the size of the partition (=10) should be at most the size of the permutations (=5) 
 - gens()[source]¶
- Return a set of generators for - selfas a group.- EXAMPLES: - sage: P4 = Permutations(4) sage: P4.gens() ([2, 1, 3, 4], [1, 3, 2, 4], [1, 2, 4, 3]) - >>> from sage.all import * >>> P4 = Permutations(Integer(4)) >>> P4.gens() ([2, 1, 3, 4], [1, 3, 2, 4], [1, 2, 4, 3]) 
 - identity()[source]¶
- Return the identity permutation of size \(n\). - EXAMPLES: - sage: Permutations(4).identity() [1, 2, 3, 4] sage: Permutations(0).identity() [] - >>> from sage.all import * >>> Permutations(Integer(4)).identity() [1, 2, 3, 4] >>> Permutations(Integer(0)).identity() [] 
 - index_set()[source]¶
- Return the index set for the descents of the symmetric group - self.- This is \(\{ 1, 2, \ldots, n-1 \}\), where - selfis \(S_n\).- EXAMPLES: - sage: P = Permutations(8) sage: P.index_set() (1, 2, 3, 4, 5, 6, 7) - >>> from sage.all import * >>> P = Permutations(Integer(8)) >>> P.index_set() (1, 2, 3, 4, 5, 6, 7) 
 - one()[source]¶
- Return the identity permutation of size \(n\). - EXAMPLES: - sage: Permutations(4).identity() [1, 2, 3, 4] sage: Permutations(0).identity() [] - >>> from sage.all import * >>> Permutations(Integer(4)).identity() [1, 2, 3, 4] >>> Permutations(Integer(0)).identity() [] 
 - random_element()[source]¶
- EXAMPLES: - sage: s = Permutations(4).random_element(); s # random [1, 2, 4, 3] sage: s in Permutations(4) True - >>> from sage.all import * >>> s = Permutations(Integer(4)).random_element(); s # random [1, 2, 4, 3] >>> s in Permutations(Integer(4)) True 
 - rank(p=None)[source]¶
- Return the rank of - selfor- pdepending on input.- If a permutation - pis given, return the rank of- pin- self. Otherwise return the dimension of the underlying vector space spanned by the (simple) roots.- EXAMPLES: - sage: P = Permutations(5) sage: P.rank() 4 sage: SP3 = Permutations(3) sage: list(map(SP3.rank, SP3)) [0, 1, 2, 3, 4, 5] sage: SP0 = Permutations(0) sage: list(map(SP0.rank, SP0)) [0] - >>> from sage.all import * >>> P = Permutations(Integer(5)) >>> P.rank() 4 >>> SP3 = Permutations(Integer(3)) >>> list(map(SP3.rank, SP3)) [0, 1, 2, 3, 4, 5] >>> SP0 = Permutations(Integer(0)) >>> list(map(SP0.rank, SP0)) [0] 
 - reflection(i)[source]¶
- Return the reflection indexed by - iof- self.- This returns the permutation with cycle \(i = (a, b)\). - See also - reflections_index_set()
- reflections()
 - EXAMPLES: - sage: P = Permutations(4) sage: for i in P.reflection_index_set(): ....: print('%s %s'%(i, P.reflection(i))) (1, 2) [2, 1, 3, 4] (1, 3) [3, 2, 1, 4] (1, 4) [4, 2, 3, 1] (2, 3) [1, 3, 2, 4] (2, 4) [1, 4, 3, 2] (3, 4) [1, 2, 4, 3] - >>> from sage.all import * >>> P = Permutations(Integer(4)) >>> for i in P.reflection_index_set(): ... print('%s %s'%(i, P.reflection(i))) (1, 2) [2, 1, 3, 4] (1, 3) [3, 2, 1, 4] (1, 4) [4, 2, 3, 1] (2, 3) [1, 3, 2, 4] (2, 4) [1, 4, 3, 2] (3, 4) [1, 2, 4, 3] 
 - reflection_index_set()[source]¶
- Return the index set of the reflections of - self.- See also 
- reflections()
 - EXAMPLES: - sage: P = Permutations(4) sage: P.reflection_index_set() ((1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)) - >>> from sage.all import * >>> P = Permutations(Integer(4)) >>> P.reflection_index_set() ((1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)) 
 - simple_reflection(i)[source]¶
- For \(i\) in the index set of - self(that is, for \(i\) in \(\{ 1, 2, \ldots, n-1 \}\), where- selfis \(S_n\)), this returns the elementary transposition \(s_i = (i,i+1)\).- EXAMPLES: - sage: P = Permutations(4) sage: P.simple_reflection(2) [1, 3, 2, 4] sage: P.simple_reflections() Finite family {1: [2, 1, 3, 4], 2: [1, 3, 2, 4], 3: [1, 2, 4, 3]} - >>> from sage.all import * >>> P = Permutations(Integer(4)) >>> P.simple_reflection(Integer(2)) [1, 3, 2, 4] >>> P.simple_reflections() Finite family {1: [2, 1, 3, 4], 2: [1, 3, 2, 4], 3: [1, 2, 4, 3]} 
 - unrank(r)[source]¶
- EXAMPLES: - sage: SP3 = Permutations(3) sage: l = list(map(SP3.unrank, range(6))) sage: l == SP3.list() True sage: SP0 = Permutations(0) sage: l = list(map(SP0.unrank, range(1))) sage: l == SP0.list() True - >>> from sage.all import * >>> SP3 = Permutations(Integer(3)) >>> l = list(map(SP3.unrank, range(Integer(6)))) >>> l == SP3.list() True >>> SP0 = Permutations(Integer(0)) >>> l = list(map(SP0.unrank, range(Integer(1)))) >>> l == SP0.list() True 
 
- class sage.combinat.permutation.StandardPermutations_n_abstract(n, category=None)[source]¶
- Bases: - Permutations- Abstract base class for subsets of permutations of the set \(\{1, 2, \ldots, n\}\). - Warning - Anything inheriting from this class should override the - __contains__method.
- class sage.combinat.permutation.StandardPermutations_recoils(recoils)[source]¶
- Bases: - Permutations- Permutations of \(\{1, \ldots, n\}\) with a fixed recoils composition. 
- class sage.combinat.permutation.StandardPermutations_recoilsfatter(recoils)[source]¶
- Bases: - Permutations
- class sage.combinat.permutation.StandardPermutations_recoilsfiner(recoils)[source]¶
- Bases: - Permutations
- sage.combinat.permutation.bistochastic_as_sum_of_permutations(M, check=True)[source]¶
- Return the positive sum of permutations corresponding to the bistochastic matrix - M.- A stochastic matrix is a matrix with nonnegative real entries such that the sum of the elements of any row is equal to \(1\). A bistochastic matrix is a stochastic matrix whose transpose matrix is also stochastic ( there are conditions both on the rows and on the columns ). - According to the Birkhoff-von Neumann Theorem, any bistochastic matrix can be written as a convex combination of permutation matrices, which also means that the polytope of bistochastic matrices is integer. - As a non-bistochastic matrix can obviously not be written as a convex combination of permutations, this theorem is an equivalence. - This function, given a bistochastic matrix, returns the corresponding decomposition. - INPUT: - M– a bistochastic matrix
- check– boolean; set to- True(default) to check that the matrix is indeed bistochastic
 - OUTPUT: - An element of - CombinatorialFreeModule, which is a free \(F\)-module ( where \(F\) is the ground ring of the given matrix ) whose basis is indexed by the permutations.
 - Note - In this function, we just assume 1 to be any constant : for us a matrix \(M\) is bistochastic if there exists \(c>0\) such that \(M/c\) is bistochastic. 
- You can obtain a sequence of pairs - (permutation,coeff), where- permutationis a Sage- Permutationinstance, and- coeffits corresponding coefficient from the result of this function by applying the- listfunction.
- If you are interested in the matrix corresponding to a - Permutationyou will be glad to learn about the- Permutation.to_matrix()method.
- The base ring of the matrix can be anything that can be coerced to - RR.
 - See also - as_sum_of_permutations()to use this method through the- Matrixclass.
 - EXAMPLES: - We create a bistochastic matrix from a convex sum of permutations, then try to deduce the decomposition from the matrix: - sage: from sage.combinat.permutation import bistochastic_as_sum_of_permutations sage: # needs networkx sage.graphs sage.modules sage: L = [] sage: L.append((9,Permutation([4, 1, 3, 5, 2]))) sage: L.append((6,Permutation([5, 3, 4, 1, 2]))) sage: L.append((3,Permutation([3, 1, 4, 2, 5]))) sage: L.append((2,Permutation([1, 4, 2, 3, 5]))) sage: M = sum([c * p.to_matrix() for (c,p) in L]) sage: decomp = bistochastic_as_sum_of_permutations(M) sage: print(decomp) 2*B[[1, 4, 2, 3, 5]] + 3*B[[3, 1, 4, 2, 5]] + 9*B[[4, 1, 3, 5, 2]] + 6*B[[5, 3, 4, 1, 2]] - >>> from sage.all import * >>> from sage.combinat.permutation import bistochastic_as_sum_of_permutations >>> # needs networkx sage.graphs sage.modules >>> L = [] >>> L.append((Integer(9),Permutation([Integer(4), Integer(1), Integer(3), Integer(5), Integer(2)]))) >>> L.append((Integer(6),Permutation([Integer(5), Integer(3), Integer(4), Integer(1), Integer(2)]))) >>> L.append((Integer(3),Permutation([Integer(3), Integer(1), Integer(4), Integer(2), Integer(5)]))) >>> L.append((Integer(2),Permutation([Integer(1), Integer(4), Integer(2), Integer(3), Integer(5)]))) >>> M = sum([c * p.to_matrix() for (c,p) in L]) >>> decomp = bistochastic_as_sum_of_permutations(M) >>> print(decomp) 2*B[[1, 4, 2, 3, 5]] + 3*B[[3, 1, 4, 2, 5]] + 9*B[[4, 1, 3, 5, 2]] + 6*B[[5, 3, 4, 1, 2]] - An exception is raised when the matrix is not positive and bistochastic: - sage: # needs sage.modules sage: M = Matrix([[2,3],[2,2]]) sage: decomp = bistochastic_as_sum_of_permutations(M) Traceback (most recent call last): ... ValueError: The matrix is not bistochastic sage: bistochastic_as_sum_of_permutations(Matrix(GF(7), 2, [2,1,1,2])) Traceback (most recent call last): ... ValueError: The base ring of the matrix must have a coercion map to RR sage: bistochastic_as_sum_of_permutations(Matrix(ZZ, 2, [2,-1,-1,2])) Traceback (most recent call last): ... ValueError: The matrix should have nonnegative entries - >>> from sage.all import * >>> # needs sage.modules >>> M = Matrix([[Integer(2),Integer(3)],[Integer(2),Integer(2)]]) >>> decomp = bistochastic_as_sum_of_permutations(M) Traceback (most recent call last): ... ValueError: The matrix is not bistochastic >>> bistochastic_as_sum_of_permutations(Matrix(GF(Integer(7)), Integer(2), [Integer(2),Integer(1),Integer(1),Integer(2)])) Traceback (most recent call last): ... ValueError: The base ring of the matrix must have a coercion map to RR >>> bistochastic_as_sum_of_permutations(Matrix(ZZ, Integer(2), [Integer(2),-Integer(1),-Integer(1),Integer(2)])) Traceback (most recent call last): ... ValueError: The matrix should have nonnegative entries 
- sage.combinat.permutation.bounded_affine_permutation(A)[source]¶
- Return the bounded affine permutation of a matrix. - The bounded affine permutation of a matrix \(A\) with entries in \(R\) is a partial permutation of length \(n\), where \(n\) is the number of columns of \(A\). The entry in position \(i\) is the smallest value \(j\) such that column \(i\) is in the span of columns \(i+1, \ldots, j\), over \(R\), where column indices are taken modulo \(n\). If column \(i\) is the zero vector, then the permutation has a fixed point at \(i\). - INPUT: - A– matrix with entries in a ring \(R\)
 - EXAMPLES: - sage: from sage.combinat.permutation import bounded_affine_permutation sage: A = Matrix(ZZ, [[1,0,0,0], [0,1,0,0]]) # needs sage.modules sage: bounded_affine_permutation(A) # needs sage.libs.flint sage.modules [5, 6, 3, 4] sage: A = Matrix(ZZ, [[0,1,0,1,0], [0,0,1,1,0]]) # needs sage.modules sage: bounded_affine_permutation(A) # needs sage.libs.flint sage.modules [1, 4, 7, 8, 5] - >>> from sage.all import * >>> from sage.combinat.permutation import bounded_affine_permutation >>> A = Matrix(ZZ, [[Integer(1),Integer(0),Integer(0),Integer(0)], [Integer(0),Integer(1),Integer(0),Integer(0)]]) # needs sage.modules >>> bounded_affine_permutation(A) # needs sage.libs.flint sage.modules [5, 6, 3, 4] >>> A = Matrix(ZZ, [[Integer(0),Integer(1),Integer(0),Integer(1),Integer(0)], [Integer(0),Integer(0),Integer(1),Integer(1),Integer(0)]]) # needs sage.modules >>> bounded_affine_permutation(A) # needs sage.libs.flint sage.modules [1, 4, 7, 8, 5] - REFERENCES: 
- sage.combinat.permutation.bruhat_lequal(p1, p2)[source]¶
- Return - Trueif- p1is less than- p2in the Bruhat order.- Algorithm from mupad-combinat. - EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: permutation.bruhat_lequal([2,4,3,1],[3,4,2,1]) True - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> permutation.bruhat_lequal([Integer(2),Integer(4),Integer(3),Integer(1)],[Integer(3),Integer(4),Integer(2),Integer(1)]) True 
- sage.combinat.permutation.descents_composition_first(dc)[source]¶
- Compute the smallest element of a descent class having a descent composition - dc.- EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: permutation.descents_composition_first([1,1,3,4,3]) [3, 2, 1, 4, 6, 5, 7, 8, 10, 9, 11, 12] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> permutation.descents_composition_first([Integer(1),Integer(1),Integer(3),Integer(4),Integer(3)]) [3, 2, 1, 4, 6, 5, 7, 8, 10, 9, 11, 12] 
- sage.combinat.permutation.descents_composition_last(dc)[source]¶
- Return the largest element of a descent class having a descent composition - dc.- EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: permutation.descents_composition_last([1,1,3,4,3]) [12, 11, 8, 9, 10, 4, 5, 6, 7, 1, 2, 3] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> permutation.descents_composition_last([Integer(1),Integer(1),Integer(3),Integer(4),Integer(3)]) [12, 11, 8, 9, 10, 4, 5, 6, 7, 1, 2, 3] 
- sage.combinat.permutation.descents_composition_list(dc)[source]¶
- Return a list of all the permutations that have the descent composition - dc.- EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: permutation.descents_composition_list([1,2,2]) # needs sage.graphs sage.modules [[5, 2, 4, 1, 3], [5, 3, 4, 1, 2], [4, 3, 5, 1, 2], [4, 2, 5, 1, 3], [3, 2, 5, 1, 4], [2, 1, 5, 3, 4], [3, 1, 5, 2, 4], [4, 1, 5, 2, 3], [5, 1, 4, 2, 3], [5, 1, 3, 2, 4], [4, 1, 3, 2, 5], [3, 1, 4, 2, 5], [2, 1, 4, 3, 5], [3, 2, 4, 1, 5], [4, 2, 3, 1, 5], [5, 2, 3, 1, 4]] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> permutation.descents_composition_list([Integer(1),Integer(2),Integer(2)]) # needs sage.graphs sage.modules [[5, 2, 4, 1, 3], [5, 3, 4, 1, 2], [4, 3, 5, 1, 2], [4, 2, 5, 1, 3], [3, 2, 5, 1, 4], [2, 1, 5, 3, 4], [3, 1, 5, 2, 4], [4, 1, 5, 2, 3], [5, 1, 4, 2, 3], [5, 1, 3, 2, 4], [4, 1, 3, 2, 5], [3, 1, 4, 2, 5], [2, 1, 4, 3, 5], [3, 2, 4, 1, 5], [4, 2, 3, 1, 5], [5, 2, 3, 1, 4]] 
- sage.combinat.permutation.from_cycles(n, cycles, parent=None)[source]¶
- Return the permutation in the \(n\)-th symmetric group whose decomposition into disjoint cycles is - cycles.- This function checks that its input is correct (i.e. that the cycles are disjoint and their elements integers among \(1...n\)). It raises an exception otherwise. - Warning - It assumes that the elements are of - inttype.- EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: permutation.from_cycles(4, [[1,2]]) [2, 1, 3, 4] sage: permutation.from_cycles(4, [[1,2,4]]) [2, 4, 3, 1] sage: permutation.from_cycles(10, [[3,1],[4,5],[6,8,9]]) [3, 2, 1, 5, 4, 8, 7, 9, 6, 10] sage: permutation.from_cycles(10, ((2, 5), (6, 1, 3))) [3, 5, 6, 4, 2, 1, 7, 8, 9, 10] sage: permutation.from_cycles(4, []) [1, 2, 3, 4] sage: permutation.from_cycles(4, [[]]) [1, 2, 3, 4] sage: permutation.from_cycles(0, []) [] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> permutation.from_cycles(Integer(4), [[Integer(1),Integer(2)]]) [2, 1, 3, 4] >>> permutation.from_cycles(Integer(4), [[Integer(1),Integer(2),Integer(4)]]) [2, 4, 3, 1] >>> permutation.from_cycles(Integer(10), [[Integer(3),Integer(1)],[Integer(4),Integer(5)],[Integer(6),Integer(8),Integer(9)]]) [3, 2, 1, 5, 4, 8, 7, 9, 6, 10] >>> permutation.from_cycles(Integer(10), ((Integer(2), Integer(5)), (Integer(6), Integer(1), Integer(3)))) [3, 5, 6, 4, 2, 1, 7, 8, 9, 10] >>> permutation.from_cycles(Integer(4), []) [1, 2, 3, 4] >>> permutation.from_cycles(Integer(4), [[]]) [1, 2, 3, 4] >>> permutation.from_cycles(Integer(0), []) [] - Bad input (see Issue #13742): - sage: Permutation("(-12,2)(3,4)") Traceback (most recent call last): ... ValueError: all elements should be strictly positive integers, but I found -12 sage: Permutation("(1,2)(2,4)") Traceback (most recent call last): ... ValueError: the element 2 appears more than once in the input sage: permutation.from_cycles(4, [[1,18]]) Traceback (most recent call last): ... ValueError: you claimed that this is a permutation on 1...4, but it contains 18 - >>> from sage.all import * >>> Permutation("(-12,2)(3,4)") Traceback (most recent call last): ... ValueError: all elements should be strictly positive integers, but I found -12 >>> Permutation("(1,2)(2,4)") Traceback (most recent call last): ... ValueError: the element 2 appears more than once in the input >>> permutation.from_cycles(Integer(4), [[Integer(1),Integer(18)]]) Traceback (most recent call last): ... ValueError: you claimed that this is a permutation on 1...4, but it contains 18 
- sage.combinat.permutation.from_inversion_vector(iv, parent=None)[source]¶
- Return the permutation corresponding to inversion vector - iv.- See \(~sage.combinat.permutation.Permutation.to_inversion_vector\) for a definition of the inversion vector of a permutation. - EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: permutation.from_inversion_vector([3,1,0,0,0]) [3, 2, 4, 1, 5] sage: permutation.from_inversion_vector([2,3,6,4,0,2,2,1,0]) [5, 9, 1, 8, 2, 6, 4, 7, 3] sage: permutation.from_inversion_vector([0]) [1] sage: permutation.from_inversion_vector([]) [] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> permutation.from_inversion_vector([Integer(3),Integer(1),Integer(0),Integer(0),Integer(0)]) [3, 2, 4, 1, 5] >>> permutation.from_inversion_vector([Integer(2),Integer(3),Integer(6),Integer(4),Integer(0),Integer(2),Integer(2),Integer(1),Integer(0)]) [5, 9, 1, 8, 2, 6, 4, 7, 3] >>> permutation.from_inversion_vector([Integer(0)]) [1] >>> permutation.from_inversion_vector([]) [] 
- sage.combinat.permutation.from_lehmer_cocode(lehmer, parent=Standard permutations)[source]¶
- Return the permutation with Lehmer cocode - lehmer.- The Lehmer cocode of a permutation \(p\) is defined as the list \((c_1, c_2, \ldots, c_n)\), where \(c_i\) is the number of \(j < i\) such that \(p(j) > p(i)\). - EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: lcc = Permutation([2,1,5,4,3]).to_lehmer_cocode(); lcc [0, 1, 0, 1, 2] sage: permutation.from_lehmer_cocode(lcc) [2, 1, 5, 4, 3] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> lcc = Permutation([Integer(2),Integer(1),Integer(5),Integer(4),Integer(3)]).to_lehmer_cocode(); lcc [0, 1, 0, 1, 2] >>> permutation.from_lehmer_cocode(lcc) [2, 1, 5, 4, 3] 
- sage.combinat.permutation.from_lehmer_code(lehmer, parent=None)[source]¶
- Return the permutation with Lehmer code - lehmer.- EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: lc = Permutation([2,1,5,4,3]).to_lehmer_code(); lc [1, 0, 2, 1, 0] sage: permutation.from_lehmer_code(lc) [2, 1, 5, 4, 3] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> lc = Permutation([Integer(2),Integer(1),Integer(5),Integer(4),Integer(3)]).to_lehmer_code(); lc [1, 0, 2, 1, 0] >>> permutation.from_lehmer_code(lc) [2, 1, 5, 4, 3] 
- sage.combinat.permutation.from_major_code(mc, final_descent=False)[source]¶
- Return the permutation with major code - mc.- The major code of a permutation is defined in - to_major_code().- Warning - This function creates illegal permutations (i.e. - Permutation([9]), and this is dangerous as the- Permutation()class is only designed to handle permutations on \(1...n\). This will have to be changed when Sage permutations will be able to handle anything, but right now this should be fixed. Be careful with the results.- Warning - If - mcis not a major index of a permutation, then the return value of this method can be anything. Garbage in, garbage out!- REFERENCES: - Skandera, M. An Eulerian Partner for Inversions. Sem. Lothar. Combin. 46 (2001) B46d. 
 - EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: permutation.from_major_code([5, 0, 1, 0, 1, 2, 0, 1, 0]) [9, 3, 5, 7, 2, 1, 4, 6, 8] sage: permutation.from_major_code([8, 3, 3, 1, 4, 0, 1, 0, 0]) [2, 8, 4, 3, 6, 7, 9, 5, 1] sage: Permutation([2,1,6,4,7,3,5]).to_major_code() [3, 2, 0, 2, 2, 0, 0] sage: permutation.from_major_code([3, 2, 0, 2, 2, 0, 0]) [2, 1, 6, 4, 7, 3, 5] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> permutation.from_major_code([Integer(5), Integer(0), Integer(1), Integer(0), Integer(1), Integer(2), Integer(0), Integer(1), Integer(0)]) [9, 3, 5, 7, 2, 1, 4, 6, 8] >>> permutation.from_major_code([Integer(8), Integer(3), Integer(3), Integer(1), Integer(4), Integer(0), Integer(1), Integer(0), Integer(0)]) [2, 8, 4, 3, 6, 7, 9, 5, 1] >>> Permutation([Integer(2),Integer(1),Integer(6),Integer(4),Integer(7),Integer(3),Integer(5)]).to_major_code() [3, 2, 0, 2, 2, 0, 0] >>> permutation.from_major_code([Integer(3), Integer(2), Integer(0), Integer(2), Integer(2), Integer(0), Integer(0)]) [2, 1, 6, 4, 7, 3, 5] 
- sage.combinat.permutation.from_permutation_group_element(pge, parent=None)[source]¶
- Return a - Permutationgiven a- PermutationGroupElement- pge.- EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: pge = PermutationGroupElement([(1,2),(3,4)]) # needs sage.groups sage: permutation.from_permutation_group_element(pge) # needs sage.groups [2, 1, 4, 3] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> pge = PermutationGroupElement([(Integer(1),Integer(2)),(Integer(3),Integer(4))]) # needs sage.groups >>> permutation.from_permutation_group_element(pge) # needs sage.groups [2, 1, 4, 3] 
- sage.combinat.permutation.from_rank(n, rank)[source]¶
- Return the permutation of the set \(\{1,...,n\}\) with lexicographic rank - rank. This is the permutation whose Lehmer code is the factoradic representation of- rank. In particular, the permutation with rank \(0\) is the identity permutation.- The permutation is computed without iterating through all of the permutations with lower rank. This makes it efficient for large permutations. - Note - The variable - rankis not checked for being in the interval from \(0\) to \(n! - 1\). When outside this interval, it acts as its residue modulo \(n!\).- EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: Permutation([3, 6, 5, 4, 2, 1]).rank() 359 sage: [permutation.from_rank(3, i) for i in range(6)] [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] sage: Permutations(6)[10] [1, 2, 4, 6, 3, 5] sage: permutation.from_rank(6,10) [1, 2, 4, 6, 3, 5] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> Permutation([Integer(3), Integer(6), Integer(5), Integer(4), Integer(2), Integer(1)]).rank() 359 >>> [permutation.from_rank(Integer(3), i) for i in range(Integer(6))] [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] >>> Permutations(Integer(6))[Integer(10)] [1, 2, 4, 6, 3, 5] >>> permutation.from_rank(Integer(6),Integer(10)) [1, 2, 4, 6, 3, 5] 
- sage.combinat.permutation.from_reduced_word(rw, parent=None)[source]¶
- Return the permutation corresponding to the reduced word - rw.- See - reduced_words()for a definition of reduced words and the convention on the order of multiplication used.- EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: permutation.from_reduced_word([3,2,3,1,2,3,1]) [3, 4, 2, 1] sage: permutation.from_reduced_word([]) [] - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> permutation.from_reduced_word([Integer(3),Integer(2),Integer(3),Integer(1),Integer(2),Integer(3),Integer(1)]) [3, 4, 2, 1] >>> permutation.from_reduced_word([]) [] 
- sage.combinat.permutation.permutohedron_lequal(p1, p2, side='right')[source]¶
- Return - Trueif- p1is less than or equal to- p2in the permutohedron order.- By default, the computations are done in the right permutohedron. If you pass the option - side='left', then they will be done in the left permutohedron.- EXAMPLES: - sage: import sage.combinat.permutation as permutation sage: permutation.permutohedron_lequal(Permutation([3,2,1,4]),Permutation([4,2,1,3])) False sage: permutation.permutohedron_lequal(Permutation([3,2,1,4]),Permutation([4,2,1,3]), side='left') True - >>> from sage.all import * >>> import sage.combinat.permutation as permutation >>> permutation.permutohedron_lequal(Permutation([Integer(3),Integer(2),Integer(1),Integer(4)]),Permutation([Integer(4),Integer(2),Integer(1),Integer(3)])) False >>> permutation.permutohedron_lequal(Permutation([Integer(3),Integer(2),Integer(1),Integer(4)]),Permutation([Integer(4),Integer(2),Integer(1),Integer(3)]), side='left') True 
- sage.combinat.permutation.to_standard(p, key=None)[source]¶
- Return a standard permutation corresponding to the iterable - p.- INPUT: - p– an iterable
- key– (optional) a comparison key for the element- xof- p
 - EXAMPLES: - sage: # needs sage.combinat sage: import sage.combinat.permutation as permutation sage: permutation.to_standard([4,2,7]) [2, 1, 3] sage: permutation.to_standard([1,2,3]) [1, 2, 3] sage: permutation.to_standard([]) [] sage: permutation.to_standard([1,2,3], key=lambda x: -x) [3, 2, 1] sage: permutation.to_standard([5,8,2,5], key=lambda x: -x) [2, 1, 4, 3] - >>> from sage.all import * >>> # needs sage.combinat >>> import sage.combinat.permutation as permutation >>> permutation.to_standard([Integer(4),Integer(2),Integer(7)]) [2, 1, 3] >>> permutation.to_standard([Integer(1),Integer(2),Integer(3)]) [1, 2, 3] >>> permutation.to_standard([]) [] >>> permutation.to_standard([Integer(1),Integer(2),Integer(3)], key=lambda x: -x) [3, 2, 1] >>> permutation.to_standard([Integer(5),Integer(8),Integer(2),Integer(5)], key=lambda x: -x) [2, 1, 4, 3]