\hVSSKrSSKJr SSKJr SSKJr SSKJr SSK J r SSK J r SSK Jr SS K Jr SS KJr SS KJr SS KJr SS KJr SSKJrJrJrJrJrJr SSKJ r SSK!J"r" SSK#J$r$ Sr%Sr&Sr'Sr(Sr)Sr*"SS\+5r,"SS\ 5r-Sr.\-r/\/R`r0"SS\ 5r1\$"\-\-5S5r2g) N) defaultdict)Iterable)reduce)global_parameters)Atom)Expr) int_valued)Integer)_sympify)zeros)lcmsrepr)flatten has_varietyminlexhas_dupsruns is_sequenceas_int)ifac)dispatchc6UVs/sHo UPM sn$s snf)a Return the product b*a; input and output are array forms. The ith value is a[b[i]]. Examples ======== >>> from sympy.combinatorics.permutations import _af_rmul, Permutation >>> a, b = [1, 0, 2], [0, 2, 1] >>> _af_rmul(a, b) [1, 2, 0] >>> [a[b[i]] for i in range(3)] [1, 2, 0] This handles the operands in reverse order compared to the ``*`` operator: >>> a = Permutation(a) >>> b = Permutation(b) >>> list(a*b) [2, 0, 1] >>> [b(a(i)) for i in range(3)] [2, 0, 1] See Also ======== rmul, _af_rmuln )abis X/var/www/auris/envauris/lib/python3.13/site-packages/sympy/combinatorics/permutations.py_af_rmulr s< !QaD!  sc :Un[U5nUS:XaUup4nUVs/sH ocXFPM sn$US:XaUup4pWUVs/sH ocXEUPM sn$US:Xa"Uup4pWnUVs/sHocXEXvPM sn$US:Xa%Uup4pWpU Vs/sHocXEXxUPM sn$US:Xa(Uup4pWpn U Vs/sHocXEXxXPM sn$US:Xa+Uup4pWppU Vs/sHocXEXxXUPM sn$US:XaUSS S $US :XaUupU Vs/sHoaUPM sn$US:Xa [S 5e[US US -6n[XS -S 6nUVs/sHocUPM sn$s snfs snfs snfs snfs snfs snfs snfs snf) a Given [a, b, c, ...] return the product of ...*c*b*a using array forms. The ith value is a[b[c[i]]]. Examples ======== >>> from sympy.combinatorics.permutations import _af_rmul, Permutation >>> a, b = [1, 0, 2], [0, 2, 1] >>> _af_rmul(a, b) [1, 2, 0] >>> [a[b[i]] for i in range(3)] [1, 2, 0] This handles the operands in reverse order compared to the ``*`` operator: >>> a = Permutation(a); b = Permutation(b) >>> list(a*b) [2, 0, 1] >>> [b(a(i)) for i in range(3)] [2, 0, 1] See Also ======== rmul, _af_rmul rNzString must not be empty)len ValueError _af_rmuln) abcrmp0p1p2rp3p4p5p6p7rs rr,r,6s: A AAAv #%&2a25 2&&Av')*r!2e9 r**Av+-.2a2i=!2..Av!"/12r!2qEm$%r22Av%&"3562a2ruI'()266Av)*&79:r!2rQ%yM*+,-r::AvtAwAv a!a  Av344 Aeq!tH B AdeH B 2aqE2 3'+/37; ! s.E5E:%E? F9F 'F#F$Fc[U5nS/U-nSn[U5H4nX$S:XdM US- nSX$'UnXU:wdM"XnSX%'XU:waMM6 X- S-$)a Computes the parity of a permutation in array form. Explanation =========== The parity of a permutation reflects the parity of the number of inversions in the permutation, i.e., the number of pairs of x and y such that x > y but p[x] < p[y]. Examples ======== >>> from sympy.combinatorics.permutations import _af_parity >>> _af_parity([0, 1, 2, 3]) 0 >>> _af_parity([3, 2, 0, 1]) 1 See Also ======== Permutation rr(r))r*range)pinrcjrs r _af_parityr=ssy2 BA aA A 1X 419 FAADA%1*E%1*  EQ;cTS/[U5-n[U5H up#X!U'M U$)a Finds the inverse, ~A, of a permutation, A, given in array form. Examples ======== >>> from sympy.combinatorics.permutations import _af_invert, _af_rmul >>> A = [1, 2, 0, 3] >>> _af_invert(A) [2, 0, 1, 3] >>> _af_rmul(_, A) [0, 1, 2, 3] See Also ======== Permutation, __invert__ r)r* enumerate)rinv_formrais r _af_invertrCs/&sSV|H1  Or>cUS:Xa[[[U555$US:a[[ U5U*5$US:XaUSS$US:XaUVs/sHo UPM nnU$US:XaUVs/sH o XPM nnU$US:XaUVs/sH o XUPM nnU$[[[U555nUS-(a#UVs/sHo#UPM nnUS-nU(dU$US-S:XaUVs/sH o XUPM nnUS-nO"US-S:XaUVs/sHo UPM nnUS-nMys snfs snfs snfs snfs snfs snf)a Routine for finding powers of a permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy.combinatorics.permutations import _af_pow >>> p = Permutation([2, 0, 3, 1]) >>> p.order() 4 >>> _af_pow(p._array_form, 4) [0, 1, 2, 3] rr(Nr)r"r#)listr8r*_af_powrC)rr:rrs rrFrFs AvE#a&M""1uz!}qb))Avt a 1aqT1 ( H' a aqtWa $ H# a!" #Aq1wZ # H s1v 1u#$%1aqT1%Q H 1uz)*+Aq1wZ+FQ!#$%1aqT1%F  # & ,&s$D=1EEE >E&Ecf^^[UU4Sj[[T5S- 555(+$)a  Checks if the two permutations with array forms given by ``a`` and ``b`` commute. Examples ======== >>> from sympy.combinatorics.permutations import _af_commutes_with >>> _af_commutes_with([1, 2, 0], [0, 2, 1]) False See Also ======== Permutation, commutes_with c3F># UHnTTUTTU:gv M g7fNr.0rrrs r $_af_commutes_with..s(A/@!1QqT7a!g%/@s!r()anyr8r*)rrs``r_af_commutes_withrOs&"AuSVaZ/@AA AAr>c\\rSrSrSrSrSrSrSSjrSr S r S r \ S 5r S rS rg)Cyclea_ Wrapper around dict which provides the functionality of a disjoint cycle. Explanation =========== A cycle shows the rule to use to move subsets of elements to obtain a permutation. The Cycle class is more flexible than Permutation in that 1) all elements need not be present in order to investigate how multiple cycles act in sequence and 2) it can contain singletons: >>> from sympy.combinatorics.permutations import Perm, Cycle A Cycle will automatically parse a cycle given as a tuple on the rhs: >>> Cycle(1, 2)(2, 3) (1 3 2) The identity cycle, Cycle(), can be used to start a product: >>> Cycle()(1, 2)(2, 3) (1 3 2) The array form of a Cycle can be obtained by calling the list method (or passing it to the list function) and all elements from 0 will be shown: >>> a = Cycle(1, 2) >>> a.list() [0, 2, 1] >>> list(a) [0, 2, 1] If a larger (or smaller) range is desired use the list method and provide the desired size -- but the Cycle cannot be truncated to a size smaller than the largest element that is out of place: >>> b = Cycle(2, 4)(1, 2)(3, 1, 4)(1, 3) >>> b.list() [0, 2, 1, 3, 4] >>> b.list(b.size + 1) [0, 2, 1, 3, 4, 5] >>> b.list(-1) [0, 2, 1] Singletons are not shown when printing with one exception: the largest element is always shown -- as a singleton if necessary: >>> Cycle(1, 4, 10)(4, 5) (1 5 4 10) >>> Cycle(1, 2)(4)(5)(10) (1 2)(10) The array form can be used to instantiate a Permutation so other properties of the permutation can be investigated: >>> Perm(Cycle(1, 2)(3, 4).list()).transpositions() [(1, 2), (3, 4)] Notes ===== The underlying structure of the Cycle is a dictionary and although the __iter__ method has been redefined to give the array form of the cycle, the underlying dictionary items are still available with the such methods as items(): >>> list(Cycle(1, 2).items()) [(1, 2), (2, 1)] See Also ======== Permutation c[U5$)z)Enter arg into dictionary and return arg.r)selfargs r __missing__Cycle.__missing__@s c{r>c#@# UR5ShvN gN7frI)rErTs r__iter__Cycle.__iter__Ds99;s c [U6n[[UR55UR5Vs/sH o2XPM sn5H up4XBU'M U$s snf)aReturn product of cycles processed from R to L. Examples ======== >>> from sympy.combinatorics import Cycle >>> Cycle(1, 2)(2, 3) (1 3 2) An instance of a Cycle will automatically parse list-like objects and Permutations that are on the right. It is more flexible than the Permutation in that all elements need not be present: >>> a = Cycle(1, 2) >>> a(2, 3) (1 3 2) >>> a(2, 3)(4, 5) (1 3 2)(4 5) )rQziprEkeys)rTotherrvkvs r__call__Cycle.__call__GsW,E]TYY[)+MAtwK+MNDAqEO ,NsA Nc(U(dUc [S5eUbG[UR5Vs/sHo UU:wdM UPM snS/-5n[XS-5nO URn[ U5Vs/sHo UPM sn$s snfs snf)aOReturn the cycles as an explicit list starting from 0 up to the greater of the largest value in the cycles and size. Truncation of trailing unmoved items will occur when size is less than the maximum element in the cycle; if this is desired, setting ``size=-1`` will guarantee such trimming. Examples ======== >>> from sympy.combinatorics import Cycle >>> p = Cycle(2, 3)(4, 5) >>> p.list() [0, 1, 3, 2, 5, 4] >>> p.list(10) [0, 1, 3, 2, 5, 4, 6, 7, 8, 9] Passing a length too small will trim trailing, unchanged elements in the permutation: >>> Cycle(2, 4)(1, 2, 4).list(-1) [0, 2, 1] must give size for empty Cyclerr()r+maxr^sizer8)rTrhrbigs rrE Cycle.listbs0 => >  $))+>+QaAq+>!DECt1W%D99D!&t-AQ-- ?.s B B 9Bc^U(dg[U5RnSRSU55nURS- m[ U4SjU55(dUST-- nSU-$)zWe want it to print as a Cycle, not as a dict. Examples ======== >>> from sympy.combinatorics import Cycle >>> Cycle(1, 2) (1 2) >>> print(_) (1 2) >>> list(Cycle(1, 2).items()) [(1, 2), (2, 1)] zCycle()c3J# UHn[[U55v M g7frIstrtuplerKr;s rrL!Cycle.__repr__..26aCaMM6!#r(c3>># UHoH o"T:Hv M M g7frIrrKr;rris rrLrr7VQ8Q8V(%s)zCycle%s) Permutation cyclic_formjoinrhrNrTcyclessris @r__repr__Cycle.__repr__seT".. GG262 2ii!m7V777 # A1}r>c^U(dg[U5RnSRSU55nURS- m[ U4SjU55(dUST-- nUR SS5nU$)zWe want it to be printed in a Cycle notation with no comma in-between. Examples ======== >>> from sympy.combinatorics import Cycle >>> Cycle(1, 2) (1 2) >>> Cycle(1, 2, 4)(5, 6) (1 2 4)(5 6) z()rlc3J# UHn[[U55v M g7frIrnrqs rrL Cycle.__str__..rsrtr(c3>># UHoH o"T:Hv M M g7frIrrvs rrLrrwrxry,)rzr{r|rhrNreplacer}s @r__str__ Cycle.__str__spT".. GG262 2ii!m7V777 # A IIc2 r>c6U(dg[U5S:Xa|[US[5(a+USRHnUR U"U65 M g[US[ 5(a!USR 5H up4X@U'M gUVs/sHn[U5PM nn[SU55(a [S5e[U5(a [S5e[[U5*S5HnXS-XU'M gs snf)zLoad up a Cycle instance with the values for the cycle. Examples ======== >>> from sympy.combinatorics import Cycle >>> Cycle(1, 2, 6) (1 2 6) Nr(rc3*# UH oS:v M g7f)rNr)rKrs rrL!Cycle.__init__..s#d1udsz-negative integers are not allowed in a cycle.z'All elements must be unique in a cycle.) r* isinstancerzr{updaterQitemsrrNr+rr8)rTargsr;rarbrrs r__init__Cycle.__init__s  t9>$q';//a,,AKKa)-DGU++ GMMODAG,#'(4aq 4( #d# # #LM M D>>FG GD z1%A QKDaM& )sDcJU(dg[UR55S-$Nrr()rgr^rYs rrh Cycle.sizes499;!##r>c[U5$rI)rQrYs rcopy Cycle.copy T{r>rrI)__name__ __module__ __qualname____firstlineno____doc__rVrZrcrErrrpropertyrhr__static_attributes__rr>rrQrQsFJV6.B..(<$$ r>rQc^\rSrSrSrSrSrSrSrSr Sr SS.Sjr \ U4Sj5r SrS rS r\S 5rSNS jr\S 5r\S5r\S5rSrSrSr\S5r\ S5rSrSrSrSr Sr!Sr"Sr#Sr$\ SNSj5r%Sr&Sr'S r(S!r)S"r*S#r+S$r,\ S%5r-SNS&jr.S'r/S(r0\S)5r1S*r2\S+5r3\S,5r4\S-5r5\S.5r6\S/5r7\S05r8S1r9S2r:S3\;4S4jrS7r?S8r@S9rAS:rB\S;5rC\S<5rDS=rES>rFS?rGS@rH\ SA5rISBrJSCrKSDrLSErMSFrNSGrO\ SOSHj5rP\ SI5rQ\ SJ5rR\ SK5rSSLrTSrUSMrVU=rW$)Przia1 A permutation, alternatively known as an 'arrangement number' or 'ordering' is an arrangement of the elements of an ordered list into a one-to-one mapping with itself. The permutation of a given arrangement is given by indicating the positions of the elements after re-arrangement [2]_. For example, if one started with elements ``[x, y, a, b]`` (in that order) and they were reordered as ``[x, y, b, a]`` then the permutation would be ``[0, 1, 3, 2]``. Notice that (in SymPy) the first element is always referred to as 0 and the permutation uses the indices of the elements in the original ordering, not the elements ``(a, b, ...)`` themselves. >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) Permutations Notation ===================== Permutations are commonly represented in disjoint cycle or array forms. Array Notation and 2-line Form ------------------------------------ In the 2-line form, the elements and their final positions are shown as a matrix with 2 rows: [0 1 2 ... n-1] [p(0) p(1) p(2) ... p(n-1)] Since the first line is always ``range(n)``, where n is the size of p, it is sufficient to represent the permutation by the second line, referred to as the "array form" of the permutation. This is entered in brackets as the argument to the Permutation class: >>> p = Permutation([0, 2, 1]); p Permutation([0, 2, 1]) Given i in range(p.size), the permutation maps i to i^p >>> [i^p for i in range(p.size)] [0, 2, 1] The composite of two permutations p*q means first apply p, then q, so i^(p*q) = (i^p)^q which is i^p^q according to Python precedence rules: >>> q = Permutation([2, 1, 0]) >>> [i^p^q for i in range(3)] [2, 0, 1] >>> [i^(p*q) for i in range(3)] [2, 0, 1] One can use also the notation p(i) = i^p, but then the composition rule is (p*q)(i) = q(p(i)), not p(q(i)): >>> [(p*q)(i) for i in range(p.size)] [2, 0, 1] >>> [q(p(i)) for i in range(p.size)] [2, 0, 1] >>> [p(q(i)) for i in range(p.size)] [1, 2, 0] Disjoint Cycle Notation ----------------------- In disjoint cycle notation, only the elements that have shifted are indicated. For example, [1, 3, 2, 0] can be represented as (0, 1, 3)(2). This can be understood from the 2 line format of the given permutation. In the 2-line form, [0 1 2 3] [1 3 2 0] The element in the 0th position is 1, so 0 -> 1. The element in the 1st position is three, so 1 -> 3. And the element in the third position is again 0, so 3 -> 0. Thus, 0 -> 1 -> 3 -> 0, and 2 -> 2. Thus, this can be represented as 2 cycles: (0, 1, 3)(2). In common notation, singular cycles are not explicitly written as they can be inferred implicitly. Only the relative ordering of elements in a cycle matter: >>> Permutation(1,2,3) == Permutation(2,3,1) == Permutation(3,1,2) True The disjoint cycle notation is convenient when representing permutations that have several cycles in them: >>> Permutation(1, 2)(3, 5) == Permutation([[1, 2], [3, 5]]) True It also provides some economy in entry when computing products of permutations that are written in disjoint cycle notation: >>> Permutation(1, 2)(1, 3)(2, 3) Permutation([0, 3, 2, 1]) >>> _ == Permutation([[1, 2]])*Permutation([[1, 3]])*Permutation([[2, 3]]) True Caution: when the cycles have common elements between them then the order in which the permutations are applied matters. This module applies the permutations from *left to right*. >>> Permutation(1, 2)(2, 3) == Permutation([(1, 2), (2, 3)]) True >>> Permutation(1, 2)(2, 3).list() [0, 3, 1, 2] In the above case, (1,2) is computed before (2,3). As 0 -> 0, 0 -> 0, element in position 0 is 0. As 1 -> 2, 2 -> 3, element in position 1 is 3. As 2 -> 1, 1 -> 1, element in position 2 is 1. As 3 -> 3, 3 -> 2, element in position 3 is 2. If the first and second elements had been swapped first, followed by the swapping of the second and third, the result would have been [0, 2, 3, 1]. If, you want to apply the cycles in the conventional right to left order, call the function with arguments in reverse order as demonstrated below: >>> Permutation([(1, 2), (2, 3)][::-1]).list() [0, 2, 3, 1] Entering a singleton in a permutation is a way to indicate the size of the permutation. The ``size`` keyword can also be used. Array-form entry: >>> Permutation([[1, 2], [9]]) Permutation([0, 2, 1], size=10) >>> Permutation([[1, 2]], size=10) Permutation([0, 2, 1], size=10) Cyclic-form entry: >>> Permutation(1, 2, size=10) Permutation([0, 2, 1], size=10) >>> Permutation(9)(1, 2) Permutation([0, 2, 1], size=10) Caution: no singleton containing an element larger than the largest in any previous cycle can be entered. This is an important difference in how Permutation and Cycle handle the ``__call__`` syntax. A singleton argument at the start of a Permutation performs instantiation of the Permutation and is permitted: >>> Permutation(5) Permutation([], size=6) A singleton entered after instantiation is a call to the permutation -- a function call -- and if the argument is out of range it will trigger an error. For this reason, it is better to start the cycle with the singleton: The following fails because there is no element 3: >>> Permutation(1, 2)(3) Traceback (most recent call last): ... IndexError: list index out of range This is ok: only the call to an out of range singleton is prohibited; otherwise the permutation autosizes: >>> Permutation(3)(1, 2) Permutation([0, 2, 1, 3]) >>> Permutation(1, 2)(3, 4) == Permutation(3, 4)(1, 2) True Equality testing ---------------- The array forms must be the same in order for permutations to be equal: >>> Permutation([1, 0, 2, 3]) == Permutation([1, 0]) False Identity Permutation -------------------- The identity permutation is a permutation in which no element is out of place. It can be entered in a variety of ways. All the following create an identity permutation of size 4: >>> I = Permutation([0, 1, 2, 3]) >>> all(p == I for p in [ ... Permutation(3), ... Permutation(range(4)), ... Permutation([], size=4), ... Permutation(size=4)]) True Watch out for entering the range *inside* a set of brackets (which is cycle notation): >>> I == Permutation([range(4)]) False Permutation Printing ==================== There are a few things to note about how Permutations are printed. .. deprecated:: 1.6 Configuring Permutation printing by setting ``Permutation.print_cyclic`` is deprecated. Users should use the ``perm_cyclic`` flag to the printers, as described below. 1) If you prefer one form (array or cycle) over another, you can set ``init_printing`` with the ``perm_cyclic`` flag. >>> from sympy import init_printing >>> p = Permutation(1, 2)(4, 5)(3, 4) >>> p Permutation([0, 2, 1, 4, 5, 3]) >>> init_printing(perm_cyclic=True, pretty_print=False) >>> p (1 2)(3 4 5) 2) Regardless of the setting, a list of elements in the array for cyclic form can be obtained and either of those can be copied and supplied as the argument to Permutation: >>> p.array_form [0, 2, 1, 4, 5, 3] >>> p.cyclic_form [[1, 2], [3, 4, 5]] >>> Permutation(_) == p True 3) Printing is economical in that as little as possible is printed while retaining all information about the size of the permutation: >>> init_printing(perm_cyclic=False, pretty_print=False) >>> Permutation([1, 0, 2, 3]) Permutation([1, 0, 2, 3]) >>> Permutation([1, 0, 2, 3], size=20) Permutation([1, 0], size=20) >>> Permutation([1, 0, 2, 4, 3, 5, 6], size=20) Permutation([1, 0, 2, 4, 3], size=20) >>> p = Permutation([1, 0, 2, 3]) >>> init_printing(perm_cyclic=True, pretty_print=False) >>> p (3)(0 1) >>> init_printing(perm_cyclic=False, pretty_print=False) The 2 was not printed but it is still there as can be seen with the array_form and size methods: >>> p.array_form [1, 0, 2, 3] >>> p.size 4 Short introduction to other methods =================================== The permutation can act as a bijective function, telling what element is located at a given position >>> q = Permutation([5, 2, 3, 4, 1, 0]) >>> q.array_form[1] # the hard way 2 >>> q(1) # the easy way 2 >>> {i: q(i) for i in range(q.size)} # showing the bijection {0: 5, 1: 2, 2: 3, 3: 4, 4: 1, 5: 0} The full cyclic form (including singletons) can be obtained: >>> p.full_cyclic_form [[0, 1], [2], [3]] Any permutation can be factored into transpositions of pairs of elements: >>> Permutation([[1, 2], [3, 4, 5]]).transpositions() [(1, 2), (3, 5), (3, 4)] >>> Permutation.rmul(*[Permutation([ti], size=6) for ti in _]).cyclic_form [[1, 2], [3, 4, 5]] The number of permutations on a set of n elements is given by n! and is called the cardinality. >>> p.size 4 >>> p.cardinality 24 A given permutation has a rank among all the possible permutations of the same elements, but what that rank is depends on how the permutations are enumerated. (There are a number of different methods of doing so.) The lexicographic rank is given by the rank method and this rank is used to increment a permutation with addition/subtraction: >>> p.rank() 6 >>> p + 1 Permutation([1, 0, 3, 2]) >>> p.next_lex() Permutation([1, 0, 3, 2]) >>> _.rank() 7 >>> p.unrank_lex(p.size, rank=7) Permutation([1, 0, 3, 2]) The product of two permutations p and q is defined as their composition as functions, (p*q)(i) = q(p(i)) [6]_. >>> p = Permutation([1, 0, 2, 3]) >>> q = Permutation([2, 3, 1, 0]) >>> list(q*p) [2, 3, 0, 1] >>> list(p*q) [3, 2, 1, 0] >>> [q(p(i)) for i in range(p.size)] [3, 2, 1, 0] The permutation can be 'applied' to any list-like object, not only Permutations: >>> p(['zero', 'one', 'four', 'two']) ['one', 'zero', 'four', 'two'] >>> p('zo42') ['o', 'z', '4', '2'] If you have a list of arbitrary elements, the corresponding permutation can be found with the from_sequence method: >>> Permutation.from_sequence('SymPy') Permutation([1, 3, 2, 0, 4]) Checking if a Permutation is contained in a Group ================================================= Generally if you have a group of permutations G on n symbols, and you're checking if a permutation on less than n symbols is part of that group, the check will fail. Here is an example for n=5 and we check if the cycle (1,2,3) is in G: >>> from sympy import init_printing >>> init_printing(perm_cyclic=True, pretty_print=False) >>> from sympy.combinatorics import Cycle, Permutation >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> G = PermutationGroup(Cycle(2, 3)(4, 5), Cycle(1, 2, 3, 4, 5)) >>> p1 = Permutation(Cycle(2, 5, 3)) >>> p2 = Permutation(Cycle(1, 2, 3)) >>> a1 = Permutation(Cycle(1, 2, 3).list(6)) >>> a2 = Permutation(Cycle(1, 2, 3)(5)) >>> a3 = Permutation(Cycle(1, 2, 3),size=6) >>> for p in [p1,p2,a1,a2,a3]: p, G.contains(p) ((2 5 3), True) ((1 2 3), False) ((5)(1 2 3), True) ((5)(1 2 3), True) ((5)(1 2 3), True) The check for p2 above will fail. Checking if p1 is in G works because SymPy knows G is a group on 5 symbols, and p1 is also on 5 symbols (its largest element is 5). For ``a1``, the ``.list(6)`` call will extend the permutation to 5 symbols, so the test will work as well. In the case of ``a2`` the permutation is being extended to 5 symbols by using a singleton, and in the case of ``a3`` it's extended through the constructor argument ``size=6``. There is another way to do this, which is to tell the ``contains`` method that the number of symbols the group is on does not need to match perfectly the number of symbols for the permutation: >>> G.contains(p2,strict=False) True This can be via the ``strict`` argument to the ``contains`` method, and SymPy will try to extend the permutation on its own and then perform the containment check. See Also ======== Cycle References ========== .. [1] Skiena, S. 'Permutations.' 1.1 in Implementing Discrete Mathematics Combinatorics and Graph Theory with Mathematica. Reading, MA: Addison-Wesley, pp. 3-16, 1990. .. [2] Knuth, D. E. The Art of Computer Programming, Vol. 4: Combinatorial Algorithms, 1st ed. Reading, MA: Addison-Wesley, 2011. .. [3] Wendy Myrvold and Frank Ruskey. 2001. Ranking and unranking permutations in linear time. Inf. Process. Lett. 79, 6 (September 2001), 281-284. DOI=10.1016/S0020-0190(01)00141-7 .. [4] D. L. Kreher, D. R. Stinson 'Combinatorial Algorithms' CRC Press, 1999 .. [5] Graham, R. L.; Knuth, D. E.; and Patashnik, O. Concrete Mathematics: A Foundation for Computer Science, 2nd ed. Reading, MA: Addison-Wesley, 1994. .. [6] https://en.wikipedia.org/w/index.php?oldid=499948155#Product_and_inverse .. [7] https://en.wikipedia.org/wiki/Lehmer_code TNrhc ZUb [U5nSnU(d,UR[[U=(d S555$[ U5S:a&UR[ U6RU55$[ U5S:XaUSn[ XP5(a%UbXR:XaU$U"URUS9$[ U[ 5(a URURU55$[U5(d@UbUS-U:a[SU-5eUR[[US-555$[SU55(aSnOSnU(d [S5e[US5nU=(a [US5nU(a.UVVs/sHowVs/sHn[U5PM snPM nnnOUVs/sHn[U5PM nn[U5n [U 5(aU(d [S 5e[U 5n U(deU [[[ U 555:wa[S [U 5-5eUb*U (a#[U 5S-U:a[S US- -5eU(a)[ 5nUHn U"U 6nM UR5n O [U5n U(a<U[ U 5:a-U R![[[ U 5U555 URU 5$s snfs snnfs snf) ap Constructor for the Permutation object from a list or a list of lists in which all elements of the permutation may appear only once. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) Permutations entered in array-form are left unaltered: >>> Permutation([0, 2, 1]) Permutation([0, 2, 1]) Permutations entered in cyclic form are converted to array form; singletons need not be entered, but can be entered to indicate the largest element: >>> Permutation([[4, 5, 6], [0, 1]]) Permutation([1, 0, 2, 3, 5, 6, 4]) >>> Permutation([[4, 5, 6], [0, 1], [19]]) Permutation([1, 0, 2, 3, 5, 6, 4], size=20) All manipulation of permutations assumes that the smallest element is 0 (in keeping with 0-based indexing in Python) so if the 0 is missing when entering a permutation in array form, an error will be raised: >>> Permutation([2, 1]) Traceback (most recent call last): ... ValueError: Integers 0 through 2 must be present. If a permutation is entered in cyclic form, it can be entered without singletons and the ``size`` specified so those values can be filled in, otherwise the array form will only extend to the maximum value in the cycles: >>> Permutation([[1, 4], [3, 5, 2]], size=10) Permutation([0, 4, 3, 5, 1, 2], size=10) >>> _.array_form [0, 4, 3, 5, 1, 2, 6, 7, 8, 9] Trr(rz size is too small when max is %sc38# UHn[U5v M g7frI)r)rKrBs rrL&Permutation.__new__..s7Qr;r??QsFzSPermutation argument must be a list of ints, a list of lists, Permutation or Cycle.zthere were repeated elements.z&Integers 0 through %s must be present.z max element should not exceed %s)int_af_newrEr8r*rQrrh array_formrr+rrrsetrgextend) clsrhrkwargsokris_cycler;rtempciaforms r__new__Permutation.__new__s^  t9D;;tE$)!$456 6 Y];;ud|0067 7 t9>QA!!!<466>H1<>#A $%G!%KLL{{4a!e #5667Q777BFG G DG}0KQ0 156AQ'QSVQ'D6D$()DqCFDD)t} D>>(<= =4ys5T+,, !ID "DSY]T-A !Ctax!PQQ ArFFFHEJE D3u:% LLeCJ56 7{{5!!I(6)s& L"/L L"L(L"cR>[TU]U5nXl[U5UlU$)a9A method to produce a Permutation object from a list; the list is bound to the _array_form attribute, so it must not be modified; this method is meant for internal use only; the list ``a`` is supposed to be generated as a temporary value in a method, so p = Perm._af_new(a) is the only object to hold a reference to ``a``:: Examples ======== >>> from sympy.combinatorics.permutations import Perm >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> a = [2, 1, 3, 0] >>> p = Perm._af_new(a) >>> p Permutation([2, 1, 3, 0]) )superr _array_formr*_size)rpermp __class__s rrPermutation._af_news(* GOC  d)r>c8URUR5$rI)rrrYs rrPermutation.copys~~doo..r>cUR4$rIrrYs r__getnewargs__Permutation.__getnewargs__!s!!r>c,[UR5$rI)rprrYs r_hashable_contentPermutation._hashable_content$sT__%%r>c URSS$)aa Return a copy of the attribute _array_form Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([[2, 0], [3, 1]]) >>> p.array_form [2, 3, 0, 1] >>> Permutation([[2, 0, 3, 1]]).array_form [3, 2, 0, 1] >>> Permutation([2, 0, 3, 1]).array_form [2, 0, 3, 1] >>> Permutation([[1, 2], [4, 5]]).array_form [0, 2, 1, 3, 5, 4] N)rrYs rrPermutation.array_form)s$""r>cLU(dUc [S5eURnUbXR:a0UR[ [ URU555 U$URS- nU(a*USU:waU$UR 5 US-nU(aM*U$)a-Return the permutation as an explicit list, possibly trimming unmoved elements if size is less than the maximum element in the permutation; if this is desired, setting ``size=-1`` will guarantee such trimming. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation(2, 3)(4, 5) >>> p.list() [0, 1, 3, 2, 5, 4] >>> p.list(10) [0, 1, 3, 2, 5, 4, 6, 7, 8, 9] Passing a length too small will trim trailing, unchanged elements in the permutation: >>> Permutation(2, 4)(1, 2, 4).list(-1) [0, 2, 1] >>> Permutation(3).list(-1) [] rfr()r+rrhrrEr8pop)rTrhr`rs rrEPermutation.list=s0 => > __  ii $uTYY567 IIM"v{ FFHFA b  r>c*URb[UR5$URnS/[U5-n/n[ [U55HnX$(dM/nUR U5 SX$'UnX!U(a'XnUR U5 SX&'X!U(aM'[U5S:dMkUR U5 U[[ U55:XaMe UR5 UR5UlU$)a[ This is used to convert to the cyclic notation from the canonical notation. Singletons are omitted. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 3, 1, 2]) >>> p.cyclic_form [[1, 3, 2]] >>> Permutation([1, 0, 2, 4, 3, 5]).cyclic_form [[0, 1], [3, 4]] See Also ======== array_form, full_cyclic_form TFr() _cyclic_formrErr*r8appendrsortr)rTr uncheckedr{rcycler<s rr{Permutation.cyclic_formes*    ())* *__ FS_,  s:'A|| Q$ 1 ." ALLO#(IL 1 ..u:>&&u- D$7777( ',,.r>c[[UR55[[UR55- nURUVs/sHo"/PM sn-nUR 5 U$s snf)zReturn permutation in cyclic form including singletons. Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation([0, 2, 1]).full_cyclic_form [[0], [1, 2]] )rr8rhrr{r)rTneedrr`s rfull_cyclic_formPermutation.full_cyclic_forms^5#$s743C3C+D'EE   d 3dd 3 3   !4s A0cUR$)z Returns the number of elements in the permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation([[3, 2], [0, 1]]).size 4 See Also ======== cardinality, length, order, rank )rrYs rrhPermutation.sizes"zzr>ctURn[U5VVs/sHup#X2:wdM UPM snn$s snnf)zReturn the elements in permutation, P, for which P[i] != i. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([[3, 2], [0, 1], [4]]) >>> p.array_form [1, 0, 3, 2, 4] >>> p.support() [0, 1, 2, 3] )rr@)rTrres rsupportPermutation.supports/ OO'l5ldaafl555s 44cUR5U-UR-nURURU5nX#lU$)adReturn permutation that is other higher in rank than self. The rank is the lexicographical rank, with the identity permutation having rank of 0. Examples ======== >>> from sympy.combinatorics import Permutation >>> I = Permutation([0, 1, 2, 3]) >>> a = Permutation([2, 1, 3, 0]) >>> I + a.rank() == a True See Also ======== __sub__, inversion_vector )rank cardinality unrank_lexrh_rank)rTr_rr`s r__add__Permutation.__add__s=* e#t'7'77 __TYY - r>c&URU*5$)zZReturn the permutation that is other lower in rank than self. See Also ======== __add__ )r)rTr_s r__sub__Permutation.__sub__s||UF##r>cVUSn[S[U55H nXU-nM U$)a/ Return product of Permutations [a, b, c, ...] as the Permutation whose ith value is a(b(c(i))). a, b, c, ... can be Permutation objects or tuples. Examples ======== >>> from sympy.combinatorics import Permutation >>> a, b = [1, 0, 2], [0, 2, 1] >>> a = Permutation(a); b = Permutation(b) >>> list(Permutation.rmul(a, b)) [1, 2, 0] >>> [a(b(i)) for i in range(3)] [1, 2, 0] This handles the operands in reverse order compared to the ``*`` operator: >>> a = Permutation(a); b = Permutation(b) >>> list(a*b) [2, 0, 1] >>> [b(a(i)) for i in range(3)] [2, 0, 1] Notes ===== All items in the sequence will be parsed by Permutation as necessary as long as the first item is a Permutation: >>> Permutation.rmul(a, [0, 2, 1]) == Permutation.rmul(a, b) True The reverse order of arguments will raise a TypeError. rr()r8r*)rr`rs rrmulPermutation.rmuls3P!Wq#d)$AB% r>ctUVs/sHo"RPM nnUR[U65nU$s snf)zW same as rmul, but the elements of args are Permutation objects which have _array_form )rrr,)rrxrr`s r rmul_with_afPermutation.rmul_with_afs6 %) )Dq]]D ) [[A '  *s5cx[UR5nURnUR[X#55$)z. other*~self, self and other have _array_form )rCrrr rTr_rrs rmul_invPermutation.mul_invs2 t'' (   ||HQN++r>c.[U5nU"U5U-$)z6This is needed to coerce other to Permutation in rmul.)type)rTr_rs r__rmul__Permutation.__rmul__&s4j5z$r>c dSSKJnJn [X5(aU"XSS9$URnURnU(dUnOZUR [ [[U5[U5555 UVs/sHouUPM snU[U5S-nURU5$s snf)ab Return the product a*b as a Permutation; the ith value is b(a(i)). Examples ======== >>> from sympy.combinatorics.permutations import _af_rmul, Permutation >>> a, b = [1, 0, 2], [0, 2, 1] >>> a = Permutation(a); b = Permutation(b) >>> list(a*b) [2, 0, 1] >>> [b(a(i)) for i in range(3)] [2, 0, 1] This handles operands in reverse order compared to _af_rmul and rmul: >>> al = list(a); bl = list(b) >>> _af_rmul(al, bl) [1, 2, 0] >>> [al[bl[i]] for i in range(3)] [1, 2, 0] It is acceptable for the arrays to have different lengths; the shorter one will be padded to match the longer one: >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> b*Permutation([1, 0]) Permutation([1, 2, 0]) >>> Permutation([1, 0])*b Permutation([2, 0, 1]) It is also acceptable to allow coercion to handle conversion of a single list to the left of a Permutation: >>> [0, 1]*a # no change: 2-element identity Permutation([1, 0, 2]) >>> [[0, 1]]*a # exchange first two elements Permutation([0, 1, 2]) You cannot use more than 1 cycle notation in a product of cycles since coercion can only handle one argument to the left. To handle multiple cycles it is convenient to use Cycle instead of Permutation: >>> [[1, 2]]*[[2, 3]]*Permutation([]) # doctest: +SKIP >>> from sympy.combinatorics.permutations import Cycle >>> Cycle(1, 2)(2, 3) (1 3 2) r)PermutationGroupCoset-)dirN) sympy.combinatorics.perm_groupsrrrrrrEr8r*r)rTr_rrrrrrs r__mul__Permutation.__mul__+sh L e . .#. . OO   D HHT%AA/0 1"#$!QaD!$qQz1D||D!!%s<B-cHURnURn[X#5$)a Checks if the elements are commuting. Examples ======== >>> from sympy.combinatorics import Permutation >>> a = Permutation([1, 4, 3, 0, 2, 5]) >>> b = Permutation([0, 1, 2, 3, 4, 5]) >>> a.commutes_with(b) True >>> b = Permutation([2, 3, 5, 4, 1, 0]) >>> a.commutes_with(b) False )rrOrs r commutes_withPermutation.commutes_withls# OO    &&r>c[U[5(a [S5e[U5nUR [ UR U55$)a$ Routine for finding powers of a permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> p = Permutation([2, 0, 3, 1]) >>> p.order() 4 >>> p**4 Permutation([0, 1, 2, 3]) z1p**p is not defined; do you mean p^p (conjugate)?)rrzNotImplementedErrorrrrFr)rTr:s r__pow__Permutation.__pow__sF a % %%CE E F||GDOOQ788r>cN[U5(aU"U5$[SU-5e)zReturn self(i) when ``i`` is an int. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation(1, 2, 9) >>> 2^p == p(2) == 9 True z(i^p = p(i) when i is an integer, not %s.)r r)rTrs r__rxor__Permutation.__rxor__s- a==7N%:Q>@ @r>cURUR:wa [S5eS/UR-nURnURn[UR5HnXUX!U'M UR U5$)aReturn the conjugate permutation ``~h*self*h` `. Explanation =========== If ``a`` and ``b`` are conjugates, ``a = h*b*~h`` and ``b = ~h*a*h`` and both have the same cycle structure. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation(1, 2, 9) >>> q = Permutation(6, 9, 8) >>> p*q != q*p True Calculate and check properties of the conjugate: >>> c = p^q >>> c == ~q*p*q and p == q*c*~q True The expression q^p^r is equivalent to q^(p*r): >>> r = Permutation(9)(4, 6, 8) >>> q^p^r == q^(p*r) True If the term to the left of the conjugate operator, i, is an integer then this is interpreted as selecting the ith element from the permutation to the right: >>> all(i^p == p(i) for i in range(p.size)) True Note that the * operator as higher precedence than the ^ operator: >>> q^r*p^r == q^(r*p)^r == Permutation(9)(1, 6, 4) True Notes ===== In Python the precedence rule is p^q^r = (p^q)^r which differs in general from p^(q^r) >>> q^p^r (9)(1 4 8) >>> q^(p^r) (9)(1 8 6) For a given r and p, both of the following are conjugates of p: ~r*p*r and r*p*~r. But these are not necessarily the same: >>> ~r*p*r == r*p*~r True >>> p = Permutation(1, 2, 9)(5, 6) >>> ~r*p*r == r*p*~r False The conjugate ~r*p*r was chosen so that ``p^q^r`` would be equivalent to ``p^(q*r)`` rather than ``p^(r*q)``. To obtain r*p*~r, pass ~r to this method: >>> p^~r == r*p*~r True 'The permutations must be of equal size.N)rhr+rr8r)rThrrrs r__xor__Permutation.__xor__swN 99 FG G F499  MM   tyy!A!gAdG"||Ar>c^URn/nUH`n[U5nUS:XaUR[U55 M0US:dM8USmUR U4SjX4S- SS255 Mb U$)a Return the permutation decomposed into a list of transpositions. Explanation =========== It is always possible to express a permutation as the product of transpositions, see [1] Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([[1, 2, 3], [0, 4, 5, 6, 7]]) >>> t = p.transpositions() >>> t [(0, 7), (0, 6), (0, 5), (0, 4), (1, 3), (1, 2)] >>> print(''.join(str(c) for c in t)) (0, 7)(0, 6)(0, 5)(0, 4)(1, 3)(1, 2) >>> Permutation.rmul(*[Permutation([ti], size=p.size) for ti in t]) == p True References ========== .. [1] https://en.wikipedia.org/wiki/Transposition_%28mathematics%29#Properties r)rc3,># UH nTU4v M g7frIr)rKyfirsts rrL-Permutation.transpositions..s>~!E1:~sr(r)r{r*rrpr)rTrresrnxrs @rtranspositionsPermutation.transpositionsst:   AQBQw 58$a! >qa"~>>  r>c ^[[U[[[U55555nT(aUR U4SjS9 OUR 5 [ UVs/sHoSPM sn5)$s snf)ayReturn the permutation needed to obtain ``i`` from the sorted elements of ``i``. If custom sorting is desired, a key can be given. Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation.from_sequence('SymPy') (4)(0 1 3) >>> _(sorted("SymPy")) ['S', 'y', 'm', 'P', 'y'] >>> Permutation.from_sequence('SymPy', key=lambda x: x.lower()) (4)(0 2)(1 3) c>T"US5$)Nrr)rkeys r+Permutation.from_sequence..2s #ad)r>)rr()rEr]r8r*rrz)rTrrics ` r from_sequencePermutation.from_sequences`"#aeCFm,- .  GG+G , GGI2.2aqT2.///.s&A<cJUR[UR55$)a Return the inverse of the permutation. A permutation multiplied by its inverse is the identity permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> p = Permutation([[2, 0], [3, 1]]) >>> ~p Permutation([2, 3, 0, 1]) >>> _ == p**-1 True >>> p*~p == ~p*p == Permutation([0, 1, 2, 3]) True )rrCrrYs r __invert__Permutation.__invert__7s(||Jt'7'7899r>c#8# URShvN gN7f)zYield elements from array form. Examples ======== >>> from sympy.combinatorics import Permutation >>> list(Permutation(range(3))) [0, 1, 2] NrrYs rrZPermutation.__iter__Ms??""s c[U5$rIrrYs rrPermutation.__repr__Yrr>c[U5S:XaUSn[U[5(dV[U5nUS:dXR:a'[ SR XRS- 55eURU$[U5UR:wa$[ SR XR55eURVs/sHo!UPM sn$U[[U6URS9-$s snf)a Allows applying a permutation instance as a bijective function. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([[2, 0], [3, 1]]) >>> p.array_form [2, 3, 0, 1] >>> [p(i) for i in range(4)] [2, 3, 0, 1] If an array is given then the permutation selects the items from the array (i.e. the permutation is applied to the array): >>> from sympy.abc import x >>> p([x, 1, 0, x**2]) [0, x**2, x, 1] r(r({} should be an integer between 0 and {}z{} should have the length {}.r) r*rrrrh TypeErrorformatrrzrQ)rTrr<s rrcPermutation.__call__\s0 q6Q;!Aa**1Iq5A M#B99Q;/11''**1v"3::1iiHJJ"&"2"23"2QaD"23 3Kq  :::4s C9c,[UR5$)z Returns all the elements of a permutation Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation([0, 1, 2, 3, 4, 5]).atoms() {0, 1, 2, 3, 4, 5} >>> Permutation([[0, 1], [2, 3], [4, 5]]).atoms() {0, 1, 2, 3, 4, 5} )rrrYs ratomsPermutation.atomss4??##r>cF[U5nURSLa[SRU55eURnUS:S:XdX:S:Xa[SRXS- 55eUR (a[ URU5$[X5$)ajApply the permutation to an expression. Parameters ========== i : Expr It should be an integer between $0$ and $n-1$ where $n$ is the size of the permutation. If it is a symbol or a symbolic expression that can have integer values, an ``AppliedPermutation`` object will be returned which can represent an unevaluated function. Notes ===== Any permutation can be defined as a bijective function $\sigma : \{ 0, 1, \dots, n-1 \} \rightarrow \{ 0, 1, \dots, n-1 \}$ where $n$ denotes the size of the permutation. The definition may even be extended for any set with distinctive elements, such that the permutation can even be applied for real numbers or such, however, it is not implemented for now for computational reasons and the integrity with the group theory module. This function is similar to the ``__call__`` magic, however, ``__call__`` magic already has some other applications like permuting an array or attaching new cycles, which would not always be mathematically consistent. This also guarantees that the return type is a SymPy integer, which guarantees the safety to use assumptions. Fz{} should be an integer.rTr%r() r is_integerrr'rh is_Integerr rAppliedPermutation)rTrr:s rapplyPermutation.applysH QK <<5 %&@&G&G&JK K II Ed?qv$.%:AA!qSIK K <<4++A./ /!$**r>cfURSSn[U5nUS- nXS-X:aUS-nXS-X:aMUS:XagUS- nXX:aUS-nXX:aMXXsX'X'US- nUS- nX4:aXXsX'X'US- nUS-nX4:aMURU5$)at Returns the next permutation in lexicographical order. If self is the last permutation in lexicographical order it returns None. See [4] section 2.4. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([2, 3, 1, 0]) >>> p = Permutation([2, 3, 1, 0]); p.rank() 17 >>> p = p.next_lex(); p.rank() 18 See Also ======== rank, unrank_lex Nr)r(r)rr*r)rTrr:rr<s rnext_lexPermutation.next_lexs.q! I Eq5kDG# FAq5kDG# 7AA'DG#Q'DG##w DGTW FAAA%#'7DG QQ%||D!!r>c^U4Sjm[[U55n[U5nU[U5-nT"XU5 UR U5$)a This is a linear time unranking algorithm that does not respect lexicographic order [3]. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> Permutation.unrank_nonlex(4, 5) Permutation([2, 0, 3, 1]) >>> Permutation.unrank_nonlex(4, -1) Permutation([0, 1, 2, 3]) See Also ======== next_nonlex, rank_nonlex cd>US:a)X!U-X S- sX S- 'X!U-'T"US- X-U5 ggrr)r:rr_unrank1s rr8+Permutation.unrank_nonlex.._unrank1sE1u%&1uXqQx"a%!E(Qa(r>)rEr8rrr)rTr:r7id_permr8s @r unrank_nonlexPermutation.unrank_nonlexsF, ) uQx. F QKw||G$$r>c^U4SjmUc U)RnU(dgURSSnT"[U5X!5nU$)a This is a linear time ranking algorithm that does not enforce lexicographic order [3]. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 1, 2, 3]) >>> p.rank_nonlex() 23 See Also ======== next_nonlex, unrank_nonlex c>US:XagXS- nX S- nXUsXS- 'X'X#UsX S- 'X#'X0T"US- X5--$)Nr(rr)r:rinv_permrt_rank1s rrA'Permutation.rank_nonlex.._rank1$shAvU AQA#'7A DQK+3; (HUOX[At666 6r>Nr)rr*)rTr?rr7rAs @r rank_nonlexPermutation.rank_nonlexsF& 7  ))Hq! 3t9d -r>cUR5nU[UR5S- :XagURURUS-5$)a Returns the next permutation in nonlex order [3]. If self is the last permutation in this order it returns None. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> p = Permutation([2, 0, 3, 1]); p.rank_nonlex() 5 >>> p = p.next_nonlex(); p Permutation([3, 0, 1, 2]) >>> p.rank_nonlex() 6 See Also ======== rank_nonlex, unrank_nonlex r(N)rCrrhr;)rTr7s r next_nonlexPermutation.next_nonlex5sE.     TYY!# #!!$))QU33r>cbURb UR$SnURSSnURS- nUS-n[[ U55n[ US- 5HDnXUU-- n[ US-U5HnX'X&:dMX'==S-ss'M XS-nUS-nMF XlU$)a& Returns the lexicographic rank of the permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 1, 2, 3]) >>> p.rank() 0 >>> p = Permutation([3, 2, 1, 0]) >>> p.rank() 23 See Also ======== next_lex, unrank_lex, cardinality, length, order, size Nrr()rrrhrrr8)rTrrhor:rhpsizer<rs rrPermutation.rankQs( :: !:: ooa  IIM1uDG taxA F5L D1q5$'6CF?FaKF( KE FA !  r>c>[[UR55$)z Returns the number of all possible permutations. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 1, 2, 3]) >>> p.cardinality 24 See Also ======== length, order, rank, size )rrrhrYs rrPermutation.cardinalityvs$4 ?##r>c~URbURUR- S-$[UR5$)a Computes the parity of a permutation. Explanation =========== The parity of a permutation reflects the parity of the number of inversions in the permutation, i.e., the number of pairs of x and y such that ``x > y`` but ``p[x] < p[y]``. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 1, 2, 3]) >>> p.parity() 0 >>> p = Permutation([3, 2, 0, 1]) >>> p.parity() 1 See Also ======== _af_parity r))rrhr~r=rrYs rparityPermutation.paritys76    (II +q0 0$//**r>c$UR(+$)z Checks if a permutation is even. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 1, 2, 3]) >>> p.is_even True >>> p = Permutation([3, 2, 1, 0]) >>> p.is_even True See Also ======== is_odd )is_oddrYs ris_evenPermutation.is_evens*;;r>c:[UR5S-5$)z Checks if a permutation is odd. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 1, 2, 3]) >>> p.is_odd False >>> p = Permutation([3, 2, 0, 1]) >>> p.is_odd True See Also ======== is_even r))boolrOrYs rrRPermutation.is_odds*DKKMA%&&r>c URS:H$)a/ Checks to see if the permutation contains only one number and is thus the only possible permutation of this set of numbers Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation([0]).is_Singleton True >>> Permutation([0, 1]).is_Singleton False See Also ======== is_Empty r(rrYs r is_SingletonPermutation.is_Singletons(yyA~r>c URS:H$)z Checks to see if the permutation is a set with zero elements Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation([]).is_Empty True >>> Permutation([0]).is_Empty False See Also ======== is_Singleton rrrYs ris_EmptyPermutation.is_Emptys&yyA~r>cUR$rI) is_IdentityrYs r is_identityPermutation.is_identitysr>c^URmT(+=(d( [U4Sj[UR555$)as Returns True if the Permutation is an identity permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([]) >>> p.is_Identity True >>> p = Permutation([[0], [1], [2]]) >>> p.is_Identity True >>> p = Permutation([0, 1, 2]) >>> p.is_Identity True >>> p = Permutation([0, 2, 1]) >>> p.is_Identity False See Also ======== order c32># UH oTU:Hv M g7frIr)rKrafs rrL*Permutation.is_Identity..#sB1AA"Q%Z1As)rallr8rh)rTrds @rr_Permutation.is_Identitys/6__vBBtyy1ABBBr>cURn[[U5S- 5Vs/sHo!UXS-:dMUPM nnU$s snf)a  Returns the positions of ascents in a permutation, ie, the location where p[i] < p[i+1] Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([4, 0, 1, 3, 2]) >>> p.ascents() [1, 2] See Also ======== descents, inversions, min, max r(rr8r*rTrrposs rascentsPermutation.ascents%I$ OOA +?+QtaAhq+? @ AAcURn[[U5S- 5Vs/sHo!UXS-:dMUPM nnU$s snf)a  Returns the positions of descents in a permutation, ie, the location where p[i] > p[i+1] Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([4, 0, 1, 3, 2]) >>> p.descents() [0, 3] See Also ======== ascents, inversions, min, max r(rirjs rdescentsPermutation.descents;rnroreturnc`URnU(dg[S[U555$)z The maximum element moved by the permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([1, 0, 2, 3, 4]) >>> p.max() 1 See Also ======== min, descents, ascents, inversions rc38# UHupX!:wdM Uv M g7frIrrKr_as rrL"Permutation.max..e;<%!2722<  )rrgr@rTrs rrgPermutation.maxQ(" OO;9Q<;;;r>c`URnU(dg[S[U555$)z The minimum element moved by the permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 1, 4, 3, 2]) >>> p.min() 2 See Also ======== max, descents, ascents, inversions rc38# UHupX!:wdM Uv M g7frIrrvs rrL"Permutation.min..{ryrz)rminr@r{s rrPermutation.mingr}r>cpSnURn[U5nUS:a5[US- 5H!nX$nX$S-SHnXV:dM US- nM M# U$SnSnUSSn USSn Xs:aNSnXG-U:a8XGS--S- nX:aUS- nU[XXDU-U5- nXGS--nXG-U:aM8US-nXs:aMNU$)a Computes the number of inversions of a permutation. Explanation =========== An inversion is where i > j but p[i] < p[j]. For small length of p, it iterates over all i and j values and calculates the number of inversions. For large length of p, it uses a variation of merge sort to calculate the number of inversions. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 1, 2, 3, 4, 5]) >>> p.inversions() 0 >>> Permutation([3, 2, 1, 0]).inversions() 6 See Also ======== descents, ascents, min, max References ========== .. [1] https://www.cp.eng.chula.ac.th/~prabhas//teaching/algo/algo2008/count-inv.htm rr(Nr))rr*r8_merge) rT inversionsrr:rrr;rarightarrrs rrPermutation.inversions}sF OO F s71q5\Dq56Au"a #"&AEA$CQ4D%eaiAIMEz !A&A1ue"DDJE A eai E%r>c PURnURn[U5n[U5U:wa [S5eS/U-n[U5H nXeX&'M S/U-n[U5H nXgX6'M UR UVs/sH obX5UPM sn5$s snf)aMReturn the commutator of ``self`` and ``x``: ``~x*~self*x*self`` If f and g are part of a group, G, then the commutator of f and g is the group identity iff f and g commute, i.e. fg == gf. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> p = Permutation([0, 2, 3, 1]) >>> x = Permutation([2, 0, 3, 1]) >>> c = p.commutator(x); c Permutation([2, 1, 3, 0]) >>> c == ~x*~p*x*p True >>> I = Permutation(3) >>> p = [I + i for i in range(6)] >>> for i in range(len(p)): ... for j in range(len(p)): ... c = p[i].commutator(p[j]) ... if p[i]*p[j] == p[j]*p[i]: ... assert c == I ... else: ... assert c != I ... References ========== .. [1] https://en.wikipedia.org/wiki/Commutator rN)rr*r+r8r)rTrrrr:invarinvbs r commutatorPermutation.commutatorsH OO LL F q6Q;FG GvaxqAJvaxqAJ||D9Dqqaz]D9::9s B#c(UR(agg)a Gives the signature of the permutation needed to place the elements of the permutation in canonical order. The signature is calculated as (-1)^ Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 1, 2]) >>> p.inversions() 0 >>> p.signature() 1 >>> q = Permutation([0,2,1]) >>> q.inversions() 1 >>> q.signature() -1 See Also ======== inversions r(r)rSrYs r signaturePermutation.signatures6 <<r>c v[[URVs/sHn[U5PM snS5$s snf)a Computes the order of a permutation. When the permutation is raised to the power of its order it equals the identity permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> p = Permutation([3, 1, 5, 2, 4, 0]) >>> p.order() 4 >>> (p**(p.order())) Permutation([], size=6) See Also ======== identity, cardinality, length, rank, size r()rr r{r*)rTrs rorderPermutation.order s12cD4D4DE4D5CJ4DEqIIEs6 c4[UR55$)a Returns the number of integers moved by a permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation([0, 3, 2, 1]).length() 2 >>> Permutation([[0, 1], [2, 3]]).length() 4 See Also ======== min, max, support, cardinality, order, rank, size )r*rrYs rlengthPermutation.length$ s&4<<>""r>cUR(a URnOc[[5nURnURH'nU[ U5==S- ss'U[ U5-nM) U(aX!S'Xl[ U5$)a Return the cycle structure of the permutation as a dictionary indicating the multiplicity of each cycle length. Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation(3).cycle_structure {1: 4} >>> Permutation(0, 4, 3)(1, 2)(5, 6).cycle_structure {2: 2, 3: 1} r()_cycle_structurerrrhr{r*dict)rTr` singletonsr;s rcycle_structurePermutation.cycle_structure9 su  &&BS!BJ%%3q6 a c!f$ &"1$& !Bxr>c,[UR5$)a^ Returns the number of cycles contained in the permutation (including singletons). Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation([0, 1, 2]).cycles 3 >>> Permutation([0, 1, 2]).full_cyclic_form [[0], [1], [2]] >>> Permutation(0, 1)(2, 3).cycles 2 See Also ======== sympy.functions.combinatorial.numbers.stirling )r*rrYs rr~Permutation.cyclesT s*4(())r>cp^URm[U4Sj[[T5S- 555$)a Returns the index of a permutation. The index of a permutation is the sum of all subscripts j such that p[j] is greater than p[j+1]. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([3, 0, 2, 1, 4]) >>> p.index() 2 c3J># UHnTUTUS-:dMUv M g7f)r(Nr)rKr<rs rrL$Permutation.index..| s'C/1Q4!AE(?11/s# #r()rsumr8r*r{s @rindexPermutation.indexk s, OOCeCFQJ/CCCr>c,[UR5$)aE Returns the runs of a permutation. An ascending sequence in a permutation is called a run [5]. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([2, 5, 7, 3, 6, 0, 1, 4, 8]) >>> p.runs() [[2, 5, 7], [3, 6], [0, 1, 4, 8]] >>> q = Permutation([1,3,2,0]) >>> q.runs() [[1, 3], [2], [0]] )rrrYs rrPermutation.runs~ s$DOO$$r>cURn[U5nS/US- -n[US- 5H0nSn[US-U5HnXX:dMUS- nM XSU'M2 U$)aReturn the inversion vector of the permutation. The inversion vector consists of elements whose value indicates the number of elements in the permutation that are lesser than it and lie on its right hand side. The inversion vector is the same as the Lehmer encoding of a permutation. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([4, 8, 0, 7, 1, 5, 3, 6, 2]) >>> p.inversion_vector() [4, 7, 0, 5, 0, 2, 1, 1] >>> p = Permutation([3, 2, 1, 0]) >>> p.inversion_vector() [3, 2, 1] The inversion vector increases lexicographically with the rank of the permutation, the -ith element cycling through 0..i. >>> p = Permutation(2) >>> while p: ... print('%s %s %s' % (p, p.inversion_vector(), p.rank())) ... p = p.next_lex() (2) [0, 0] 0 (1 2) [0, 1] 1 (2)(0 1) [1, 0] 2 (0 1 2) [1, 1] 3 (0 2 1) [2, 0] 4 (0 2) [2, 1] 5 See Also ======== from_inversion_vector rr()rr*r8)rTself_array_formr:inversion_vectorrvalr<s rrPermutation.inversion_vector s|P//  3!a%=q1uAC1q5!_"%(::1HC%#&Q    r>cbUR/:XdUR(agURSS/:XagURnURnSn[SU5HOnSnSnXU:waXU:aUS- nUS- nXU:waMUS-nUS-S:Xa Xs-U-U- nMEXs-U-S- nMQ U$)ak Returns the Trotter Johnson rank, which we get from the minimal change algorithm. See [4] section 2.4. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 1, 2, 3]) >>> p.rank_trotterjohnson() 0 >>> p = Permutation([0, 2, 1, 3]) >>> p.rank_trotterjohnson() 7 See Also ======== unrank_trotterjohnson, next_trotterjohnson rr(r))rr_rhr8)rTrr:rr<rarj1s rrank_trotterjohnsonPermutation.rank_trotterjohnson s* ??b D$4$4 ??q!f $ IIq!AAA'Q,7Q;FAQ'Q,QBax1}w|a'w{Q r>chS/U-nSn[U5nSn[SUS-5HznXg-nX&-U-nXU-- n US-S:Xa3[US- Xy- S- S5H n X:S- X:'M US- X7U - S- 'O'[US- U S5H n X:S- X:'M US- X9'UnM| URU5$)ae Trotter Johnson permutation unranking. See [4] section 2.4. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> Permutation.unrank_trotterjohnson(5, 10) Permutation([0, 3, 1, 2, 4]) See Also ======== rank_trotterjohnson, next_trotterjohnson rr(r)r)rr8r) rrhrrr2r:pjr<r1rars runrank_trotterjohnson!Permutation.unrank_trotterjohnson s&s4x  J q$(#A GB)!BrT AAv{q1uaeai4A"q5kDG5"#a%UQYq1ua,A"q5kDG-a%B${{4  r>cURSSn[U5nSnUSSnSnUS- nUS:aU(dURU5n[Xv5H nXHS-XH'M [ USU5n U S:Xa-Xv:XaUS-nOTXU-S-XU-sXU-'XU-S-'SnO2US:Xa US-nUS- nO!XU-S- XU-sXU-'XU-S- 'SnUS:a U(dMUS:XagUR U5$)a Returns the next permutation in Trotter-Johnson order. If self is the last permutation it returns None. See [4] section 2.4. If it is desired to generate all such permutations, they can be generated in order more quickly with the ``generate_bell`` function. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> p = Permutation([3, 0, 2, 1]) >>> p.rank_trotterjohnson() 4 >>> p = p.next_trotterjohnson(); p Permutation([0, 3, 2, 1]) >>> p.rank_trotterjohnson() 5 See Also ======== rank_trotterjohnson, unrank_trotterjohnson, sympy.utilities.iterables.generate_bell NrFr(T)rr*rr8r=r) rTr9r:strIdoner.drpars rnext_trotterjohnsonPermutation.next_trotterjohnson s06__Q  G e aC!eD ! A1[U!S!W%Cax6FA13FQJF.BAvJ6A:D6FA!GB13FQJF.BAvJ6A:D#!eDD$ 6||Br>c[UR5nURn[UR5H.n[US-UR 5HnSXUX$4'M M0 U$)aF Gets the precedence matrix. This is used for computing the distance between two permutations. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> p = Permutation.josephus(3, 6, 1) >>> p Permutation([2, 5, 3, 1, 4, 0]) >>> p.get_precedence_matrix() Matrix([ [0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 1, 0], [1, 1, 0, 1, 1, 1], [1, 1, 0, 0, 1, 0], [1, 0, 0, 0, 0, 0], [1, 1, 0, 1, 1, 0]]) See Also ======== get_precedence_distance, get_adjacency_matrix, get_adjacency_distance r()r rhrr8rowscols)rTr.rrr<s rget_precedence_matrix!Permutation.get_precedence_matrixM s`8 $)) qvvA1q5!&&)&'q'47"#*r>cURUR:wa [S5eUR5nUR5nSn[UR5H>n[UR5H"nXV:XaM X%U4X5U4-S:XdMUS- nM$ M@ URURS- -S-U- nU$)a! Computes the precedence distance between two permutations. Explanation =========== Suppose p and p' represent n jobs. The precedence metric counts the number of times a job j is preceded by job i in both p and p'. This metric is commutative. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([2, 0, 4, 3, 1]) >>> q = Permutation([3, 1, 2, 4, 0]) >>> p.get_precedence_distance(q) 7 >>> q.get_precedence_distance(p) 7 See Also ======== get_precedence_matrix, get_adjacency_matrix, get_adjacency_distance rrr(r))rhr+rr8)rTr_ self_prec_matother_prec_matn_precrr<rs rget_precedence_distance#Permutation.get_precedence_distancep s6 99 "FG G224 446tyy!A499%6 A&1)==BaKF &" IIQ ' *V 3r>c[UR5nURn[URS- 5HnSXUX#S-4'M U$)a Computes the adjacency matrix of a permutation. Explanation =========== If job i is adjacent to job j in a permutation p then we set m[i, j] = 1 where m is the adjacency matrix of p. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation.josephus(3, 6, 1) >>> p.get_adjacency_matrix() Matrix([ [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1], [0, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0]]) >>> q = Permutation([0, 1, 2, 3]) >>> q.get_adjacency_matrix() Matrix([ [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [0, 0, 0, 0]]) See Also ======== get_precedence_matrix, get_precedence_distance, get_adjacency_distance r()r rhrr8)rTr.rrs rget_adjacency_matrix Permutation.get_adjacency_matrix sOJ $)) tyy1}%A&'A1gtE{" #&r>cfURUR:wa [S5eUR5nUR5nSn[UR5H>n[UR5H"nXV:XaM X%U4X5U4-S:XdMUS- nM$ M@ URU- S- nU$)a Computes the adjacency distance between two permutations. Explanation =========== This metric counts the number of times a pair i,j of jobs is adjacent in both p and p'. If n_adj is this quantity then the adjacency distance is n - n_adj - 1 [1] [1] Reeves, Colin R. Landscapes, Operators and Heuristic search, Annals of Operational Research, 86, pp 473-490. (1999) Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 3, 1, 2, 4]) >>> q = Permutation.josephus(4, 5, 2) >>> p.get_adjacency_distance(q) 3 >>> r = Permutation([0, 2, 1, 4, 3]) >>> p.get_adjacency_distance(r) 4 See Also ======== get_precedence_matrix, get_precedence_distance, get_adjacency_matrix *The permutations must be of the same size.rr()rhr+rr8)rTr_ self_adj_mat other_adj_matn_adjrr<rs rget_adjacency_distance"Permutation.get_adjacency_distance s@ 99 "IJ J002 224 tyy!A499%61% d(;;q@QJE &" II  !r>c^^URmURm[T5[T5:wa [S5e[UU4Sj[ [T5555$)a| Computes the positional distance between two permutations. Examples ======== >>> from sympy.combinatorics import Permutation >>> p = Permutation([0, 3, 1, 2, 4]) >>> q = Permutation.josephus(4, 5, 2) >>> r = Permutation([3, 1, 4, 0, 2]) >>> p.get_positional_distance(q) 12 >>> p.get_positional_distance(r) 12 See Also ======== get_precedence_distance, get_adjacency_distance rc3L># UHn[TUTU- 5v M g7frI)absrJs rrL6Permutation.get_positional_distance.. s%;]3qtad{##]s!$)rr*r+rr8rs @@rget_positional_distance#Permutation.get_positional_distance sN* OO    q6SV IJ J;U3q6];;;r>cSSKJn US-nU"[[U555n/n[ U5[ US5:ak[U5H"nUR UR55 M$ UR UR55 [ U5[ US5:aMkUR[U55 U"U5$)aReturn as a permutation the shuffling of range(n) using the Josephus scheme in which every m-th item is selected until all have been chosen. The returned permutation has elements listed by the order in which they were selected. The parameter ``s`` stops the selection process when there are ``s`` items remaining and these are selected by continuing the selection, counting by 1 rather than by ``m``. Consider selecting every 3rd item from 6 until only 2 remain:: choices chosen ======== ====== 012345 01 345 2 01 34 25 01 4 253 0 4 2531 0 25314 253140 Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation.josephus(3, 6, 2).array_form [2, 5, 3, 1, 4, 0] References ========== .. [1] https://en.wikipedia.org/wiki/Flavius_Josephus .. [2] https://en.wikipedia.org/wiki/Josephus_problem .. [3] https://web.archive.org/web/20171008094331/http://www.wou.edu/~burtonl/josephus.html r)dequer() collectionsrrEr8r*rgrpopleftr)rr.r:rrQrdps rjosephusPermutation.josephus sL & Q $uQx. !!fs1ay Ah% KK $!fs1ay  DG4yr>c8[U5n[[US-55n/n[U5H,nX1UnURU5 UR U5 M. URU5 URU5$![ a [ S5ef=f)a0 Calculates the permutation from the inversion vector. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> Permutation.from_inversion_vector([3, 2, 1, 0, 0]) Permutation([3, 2, 1, 0, 4, 5]) r(z"The inversion vector is not valid.) r*rEr8rremove IndexErrorr+rr)r inversionrhNrrars rfrom_inversion_vector!Permutation.from_inversion_vector> s9~ tax ! C4[! o C  ! A{{4   CAB B Cs ;BBcx[[U55n[R"U5 UR U5$)z Generates a random permutation of length ``n``. Uses the underlying Python pseudo-random number generator. Examples ======== >>> from sympy.combinatorics import Permutation >>> Permutation.random(2) in (Permutation([1, 0]), Permutation([0, 1])) True )rEr8randomshuffler)rr: perm_arrays rrPermutation.randomZ s,%(^ z"{{:&&r>cS/U-nSn[U5HQnXES--nX&-U-nX'U--nXsX- S- '[X- U5HnX8US- :dMX8==S- ss'M UnMS URU5$)aC Lexicographic permutation unranking. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy import init_printing >>> init_printing(perm_cyclic=False, pretty_print=False) >>> a = Permutation.unrank_lex(5, 10) >>> a.rank() 10 >>> a Permutation([0, 2, 4, 1, 3]) See Also ======== rank, next_lex rr()r8r) rrhrrrJr new_psizerr<s rrPermutation.unrank_lexm s,S4Z tA1u I!e+A eGOD'(tx!| $48T*=1q5(MQ&M+E{{:&&r>c URn[U5nX:a,U[[X155- n[R U5$X:aUR n/nUH`n[U5n[U5nXqS- ::dM#XS- :a$[SRU[U555eURU5 Mb [ U5$U$)aResize the permutation to the new size ``n``. Parameters ========== n : int The new size of the permutation. Raises ====== ValueError If the permutation cannot be resized to the given size. This may only happen when resized to a smaller size than the original. Examples ======== >>> from sympy.combinatorics import Permutation Increasing the size of a permutation: >>> p = Permutation(0, 1, 2) >>> p = p.resize(5) >>> p (4)(0 1 2) Decreasing the size of the permutation: >>> p = p.resize(4) >>> p (3)(0 1 2) If resizing to the specific size breaks the cycles: >>> p.resize(2) Traceback (most recent call last): ... ValueError: The permutation cannot be resized to 2 because the cycle (0, 1, 2) may break. r(zGThe permutation cannot be resized to {} because the cycle {} may break.) rr*rEr8rzrrrrgr+r'rpr) rTr:rlr{new_cyclic_formr cycle_min cycle_maxs rresizePermutation.resize sV J 5 T%+& &E&&u- - U//K O$J J !# Q3(>#VAuU|466 $**51%/ / r>)rrrrI)r()Xrrrrris_Permutationrrrrrr classmethodrrrrrrrEr{rrhrrr staticmethodrrrrrrrrr rrrrZrrcr*r0r3r;rCrFrrrOrSrRrYr\r`r_rlrqrrgrrrrrrrr~rrrrrrrrrrrrrrrr print_cyclicr __classcell__rs@rrzrzsbH NKL E E!%|"|2/"& ##&&P((T  $6 4$**X, ?"B'(9,@"N`&P00.:, #';R $/+b)"V%%@"H48#J$$&+@,'',*(  CC:,,J6#*4**,D&%(2 h(T#!#!J5 n!F'R)V,\<6..`!!6''$ ' 'DAHLr>rzcBU=pVUnSnXS:aCXt::a>XX:aXX'US- nUS- nOXX'US- nUS- nXU- - nXS:aXt::aM>XS:aXX'US- nUS- nXS:aMXt::a"XdU- S-- nXtU- S-- nXUS-XUS-&U$XUS-XUS-&U$)z Merges two sorted arrays and calculates the inversion count. Helper function for calculating inversions. This method is for internal use only. rr(r) rrleftmidrrrar< inv_counts rrr s LA AI 'aj 6CF?fDG FA FAfDG FA FA q& !I 'aj '& Q Q ' z QY] QY]AE*Q # 2 r>c0^\rSrSrSrSU4SjjrSrU=r$)r/i amA permutation applied to a symbolic variable. Parameters ========== perm : Permutation x : Expr Examples ======== >>> from sympy import Symbol >>> from sympy.combinatorics import Permutation Creating a symbolic permutation function application: >>> x = Symbol('x') >>> p = Permutation(0, 1, 2) >>> p.apply(x) AppliedPermutation((0 1 2), x) >>> _.subs(x, 1) 2 c*>Uc[Rn[U5n[U5n[U[5(d[ SR U55eU(a"UR(aURU5$[TU])XU5nU$)Nz"{} must be a Permutation instance.) revaluater rrzr+r'r.r0rr)rrrrobjrs rrAppliedPermutation.__new__ s{  (11H~ QK$ ,,A  ||zz!}$goc+ r>rrI)rrrrrrrrrs@rr/r/ s.r>r/cjURUR:wagURUR:H$rI)rr)lhsrhss r _eval_is_eqr & s( yyCII ??coo --r>)3rrrcollections.abcr functoolsrsympy.core.parametersrsympy.core.basicrsympy.core.exprrsympy.core.numbersr r sympy.core.sympifyr sympy.matricesr sympy.polys.polytoolsr sympy.printing.reprrsympy.utilities.iterablesrrrrrrsympy.utilities.miscrmpmath.libmp.libintmathrsympy.multipledispatchrr r,r=rCrFrOrrQrzrPermrr/r rr>rrs #$3! )&' %%!!'(+B:z$N2* ZB(bDbJ{'${'|O@ ,,((V +{#.$.r>