\hSSKJrJrJr SSKJrJr SSKJ r SSK J r J r J r JrJrJr SSKJrJrJrJrJrJrJrJr SSKJr SSKJrJrJr SSK J!r! SS K"J#r# SS K$Jr SS K%J&r&J'r' SS K(J)r)J*r* SS K+J,r, SSK-J.r.J/r/J0r0 \ Rbr2\ Rfr3"SS\5r4SSjr5Sr6SSjr7Sr8\4r9"SS\5r:"SS\5r;g)) factoriallogprod)chainproduct) Permutation)_af_commutes_with _af_invert_af_rmul _af_rmuln_af_powCycle)_check_cycles_alt_sym_distribute_gens_by_base_orbits_transversals_from_bsgs_handle_precomputed_bsgs_base_ordering_strong_gens_from_distr_strip _strip_af)Basic) _randrange randrangechoice)Symbol)_sympify)r) primefactorssieve) factorint multiplicity)isprime) has_variety is_sequenceuniqc\rSrSrSrSrSS.SjrSrSrSr S r S r S r ScS jr SrSr\S5rSdSjr\S5r\S5r\S5rSrSrSrSrSrSrSrSeSjrSeSjrSrSeSjr \S 5r!\S!5r"\S"5r#S#r$S$r%SfS%jr&SeS&jr'SeS'jr(\S(5r)SgS)jr*\S*5r+\S+5r,S,r-S-r.ShS.jr/SiS/jr0SiS0jr1\S15r2SgS2jr3SgS3jr4SgS4jr5\S55r6SgS6jr7\S75r8SgS8jr9\S95r:S:r;\S;5rS>r?SjS?jr@SkS@jrAScSAjrBSeSBjrCSeSCjrDSDrESErF\SF5rG\SG5rH\ISH5rJ\SI5rK\SJ5rLSgSKjrMScSLjrNSeSMjrOSlSNjrPSmSOjrQSPrRScSQjrSSnSRjrTSoSSjrUSTrVSUrW\SV5rXSWrYSpSXjrZ\SY5r[SZr\S[r]S\r^S]r_S^r`S_raSgS`jrbSarcSbrdg )qPermutationGroupaJ The class defining a Permutation group. Explanation =========== ``PermutationGroup([p1, p2, ..., pn])`` returns the permutation group generated by the list of permutations. This group can be supplied to Polyhedron if one desires to decorate the elements to which the indices of the permutation refer. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> from sympy.combinatorics import Polyhedron The permutations corresponding to motion of the front, right and bottom face of a $2 \times 2$ Rubik's cube are defined: >>> F = Permutation(2, 19, 21, 8)(3, 17, 20, 10)(4, 6, 7, 5) >>> R = Permutation(1, 5, 21, 14)(3, 7, 23, 12)(8, 10, 11, 9) >>> D = Permutation(6, 18, 14, 10)(7, 19, 15, 11)(20, 22, 23, 21) These are passed as permutations to PermutationGroup: >>> G = PermutationGroup(F, R, D) >>> G.order() 3674160 The group can be supplied to a Polyhedron in order to track the objects being moved. An example involving the $2 \times 2$ Rubik's cube is given there, but here is a simple demonstration: >>> a = Permutation(2, 1) >>> b = Permutation(1, 0) >>> G = PermutationGroup(a, b) >>> P = Polyhedron(list('ABC'), pgroup=G) >>> P.corners (A, B, C) >>> P.rotate(0) # apply permutation 0 >>> P.corners (A, C, B) >>> P.reset() >>> P.corners (A, B, C) Or one can make a permutation as a product of selected permutations and apply them to an iterable directly: >>> P10 = G.make_perm([0, 1]) >>> P10('ABC') ['C', 'A', 'B'] See Also ======== sympy.combinatorics.polyhedron.Polyhedron, sympy.combinatorics.permutations.Permutation References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of Computational Group Theory" .. [2] Seress, A. "Permutation Group Algorithms" .. [3] https://en.wikipedia.org/wiki/Schreier_vector .. [4] https://en.wikipedia.org/wiki/Nielsen_transformation#Product_replacement_algorithm .. [5] Frank Celler, Charles R.Leedham-Green, Scott H.Murray, Alice C.Niemeyer, and E.A.O'Brien. "Generating Random Elements of a Finite Group" .. [6] https://en.wikipedia.org/wiki/Block_%28permutation_group_theory%29 .. [7] https://algorithmist.com/wiki/Union_find .. [8] https://en.wikipedia.org/wiki/Multiply_transitive_group#Multiply_transitive_groups .. [9] https://en.wikipedia.org/wiki/Center_%28group_theory%29 .. [10] https://en.wikipedia.org/wiki/Centralizer_and_normalizer .. [11] https://groupprops.subwiki.org/wiki/Derived_subgroup .. [12] https://en.wikipedia.org/wiki/Nilpotent_group .. [13] https://www.math.colostate.edu/~hulpke/CGT/cgtnotes.pdf .. [14] https://docs.gap-system.org/doc/ref/manual.pdf T)dupsc  U(d [5/nO5[[US5(aUSOU5nU(d [5/n[SU55(aUVs/sHn[U5PM nn[ SU55(adUR SS5nUc[ SU55n[[U55H%nX&RU:wdM[X&US9X&'M' U(a7[[UVs/sHn[[U55PM sn55n[U5S:a$UVs/sHowR(aMUPM nn[R"U/UQ70UD6$s snfs snfs snf) zwThe default constructor. Accepts Cycle and Permutation forms. Removes duplicates unless ``dups`` keyword is ``False``. rc3B# UHn[U[5v M g7fN) isinstancer.0as W/var/www/auris/envauris/lib/python3.13/site-packages/sympy/combinatorics/perm_groups.py +PermutationGroup.__new__..s2Tz!U##Tsc38# UHoRv M g7fr+sizer-s r0r1r2s,t!vvtdegreeNc38# UHoRv M g7fr+r4r-s r0r1r2s2TVVTr6r4)rlistr#anyr"popmaxrangelenr5r$_af_new is_identityr__new__)clsr(argskwargsr/r7igs r0rBPermutationGroup.__new__|s?M?D;tAw#7#7QTBD#  2T2 2 2,01DqKNDD1 ,t, , ,ZZ$/F~2T223t9%7<<6))$'?DG& =1gd1g.=>?D t9q=#9t!==AtD9}}S2426222>9s$F F F F c[UR5UlSUl/UlSUlSUlSUlSUlSUl SUl SUl SUl SUl SUlSUlSUlSUlSUl['UR5UlURSR*Ul/Ul/Ul/Ul/Ul/Ul/Ul/UlSUlgNr)r:rD _generators_order _elements_center _is_abelian_is_transitive_is_sym_is_alt _is_primitive _is_nilpotent _is_solvable _is_trivial_transitivity_degree_max_div _is_perfect _is_cyclic _is_dihedralr?_rr5_degree_base _strong_gens_strong_gens_slp _basic_orbits _transversals_transversal_slp _random_gens_fp_presentationselfrDrEs r0__init__PermutationGroup.__init__s ?  "  !! $(!  d&&'''*//   " "!%c URU$r+rKrgrFs r0 __getitem__PermutationGroup.__getitem__s""rjc|[U[5(d[S[U5-5eUR U5$)zReturn ``True`` if *i* is contained in PermutationGroup. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> p = Permutation(1, 2, 3) >>> Permutation(3) in PermutationGroup(p) True zRA PermutationGroup contains only Permutations as elements, not elements of type %s)r,r TypeErrortypecontainsrms r0 __contains__PermutationGroup.__contains__sB![))@BFq'JK K}}Qrjc,[UR5$r+)r?rKrgs r0__len__PermutationGroup.__len__s4##$$rjc[U[5(dg[UR5n[UR5nX#:XagUHnUR U5(aM g UHnUR U5(aM g g)aReturn ``True`` if PermutationGroup generated by elements in the group are same i.e they represent the same PermutationGroup. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> p = Permutation(0, 1, 2, 3, 4, 5) >>> G = PermutationGroup([p, p**2]) >>> H = PermutationGroup([p**2, p]) >>> G.generators == H.generators False >>> G.equals(H) True FT)r,r&set generatorsrs)rgother set_self_gensset_other_gensgen1gen2s r0equalsPermutationGroup.equalss"%!122DOO, U--.  *"D>>$''"#D==&&#rjc[U[5(a [XSS9$URVs/sHo"RPM nnURVs/sHo"RPM nnUR nUR n[ [U55n[ [XUU-55n[[U55Hn XIV s/sHoU-PM sn XI'M UV s/sHoU -PM nn UV s/sHoU-PM nn X4-n U V s/sHn [U 5PM n n [U 5$s snfs snfs sn fs sn fs sn fs sn f)a Return the direct product of two permutation groups as a permutation group. Explanation =========== This implementation realizes the direct product by shifting the index set for the generators of the second group: so if we have ``G`` acting on ``n1`` points and ``H`` acting on ``n2`` points, ``G*H`` acts on ``n1 + n2`` points. Examples ======== >>> from sympy.combinatorics.named_groups import CyclicGroup >>> G = CyclicGroup(5) >>> H = G*G >>> H PermutationGroup([ (9)(0 1 2 3 4), (5 6 7 8 9)]) >>> H.order() 25 +)dir) r,rCosetr| _array_formr]r:r>r?r@r&)rgr}permgens1gens2n1n2startendrFxgentogethergenss r0__mul__PermutationGroup.__mul__s%6 e[ ) )#. ..2oo>od!!o>.3.>.>?.>d!!.>? \\ ]]U2Y5"W%&s5z"A(-11B1EH#(-..&+,esse,=$,-Hq H-%%?? 2.,-s#D3D8 D=%E9EE NcURnURVs/sHoURPM nn[U5nXq:a([ Xq5HnUR XhU- 5 M [ [ U55n UR U 5 X`lUc#[ U5HnUR5 M g[ U5HnURX8S9 M gs snf)a&Initialize random generators for the product replacement algorithm. Explanation =========== The implementation uses a modification of the original product replacement algorithm due to Leedham-Green, as described in [1], pp. 69-71; also, see [2], pp. 27-29 for a detailed theoretical analysis of the original product replacement algorithm, and [4]. The product replacement algorithm is used for producing random, uniformly distributed elements of a group `G` with a set of generators `S`. For the initialization ``_random_pr_init``, a list ``R`` of `\max\{r, |S|\}` group generators is created as the attribute ``G._random_gens``, repeating elements of `S` if necessary, and the identity element of `G` is appended to ``R`` - we shall refer to this last element as the accumulator. Then the function ``random_pr()`` is called ``n`` times, randomizing the list ``R`` while preserving the generation of `G` by ``R``. The function ``random_pr()`` itself takes two random elements ``g, h`` among all elements of ``R`` but the accumulator and replaces ``g`` with a randomly chosen element from `\{gh, g(~h), hg, (~h)g\}`. Then the accumulator is multiplied by whatever ``g`` was replaced by. The new value of the accumulator is then returned by ``random_pr()``. The elements returned will eventually (for ``n`` large enough) become uniformly distributed across `G` ([5]). For practical purposes however, the values ``n = 50, r = 11`` are suggested in [1]. Notes ===== THIS FUNCTION HAS SIDE EFFECTS: it changes the attribute self._random_gens See Also ======== random_pr N) _random_prec) r7r|rr?r>appendr:rd random_pr) rgrn_random_prec_ndegr random_genskrFaccs r0_random_pr_init PermutationGroup._random_pr_init!sTkk.2oo>o}}o >   51["";1u#56!5:3'  !1X 1XN,=>?sCcURX5nURX$5nXg:waBX6X7:aXgpOXvpX8X9-n XR:agXU 'XU'URU 5 gg)aMerges two classes in a union-find data structure. Explanation =========== Used in the implementation of Atkinson's algorithm as suggested in [1], pp. 83-87. The class merging process uses union by rank as an optimization. ([7]) Notes ===== THIS FUNCTION HAS SIDE EFFECTS: the list of class representatives, ``parents``, the list of class sizes, ``ranks``, and the list of elements that are not representatives, ``not_rep``, are changed due to class merging. See Also ======== minimal_block, _union_find_rep References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of computational group theory" .. [7] https://algorithmist.com/wiki/Union_find r9r)_union_find_repmax_divr) rgfirstsecondranksparentsnot_rep rep_first rep_secondnew_1new_2 total_ranks r0_union_find_merge"PermutationGroup._union_find_merge]s~@((8 ))&:  "5#44(u)u 4JLL("EN%%L NN5 !rjcjXUpCXC:wa UnX#nXC:waM XUpEXC:waX2U'UnX%nXC:waMU$)aFind representative of a class in a union-find data structure. Explanation =========== Used in the implementation of Atkinson's algorithm as suggested in [1], pp. 83-87. After the representative of the class to which ``num`` belongs is found, path compression is performed as an optimization ([7]). Notes ===== THIS FUNCTION HAS SIDE EFFECTS: the list of class representatives, ``parents``, is altered due to path compression. See Also ======== minimal_block, _union_find_merge References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of computational group theory" .. [7] https://algorithmist.com/wiki/Union_find )rgnumrrepparenttemps r0r PermutationGroup._union_find_repsV>3>> from sympy.combinatorics import Permutation, PermutationGroup >>> G = PermutationGroup([Permutation(0, 1, 3)(2, 4)]) >>> G.base [0, 2] See Also ======== strong_gens, basic_transversals, basic_orbits, basic_stabilizers )r^ schreier_simsrws r0basePermutationGroup.bases&> ::     zzrjc [XUXg5upVn[U5nURn [Xc5[XcS-5-[[XUXS-55-n US-US- :a/n O XsS-SSn USLa[ Xs5n U R XS-5n [[XX55U :waCU R XS-U S9nU RU5 [[XX55U :waMCGO![Xc5nURX5 XS-U;aURXS-5 [[XX55U :wa[[U55nXSUnURRXS-5nUXcS-;aU[XU5- nORXSS-Un[UU5nU"X5[XX5;a"U RU5 U[XX5- n[[XX55U :waMUSSnU UUS-'USSnUUS-UUsUU'UUS-'[U5nU HnUU;dM URU5 M UU4$)aSwap two consecutive base points in base and strong generating set. Explanation =========== If a base for a group `G` is given by `(b_1, b_2, \dots, b_k)`, this function returns a base `(b_1, b_2, \dots, b_{i+1}, b_i, \dots, b_k)`, where `i` is given by ``pos``, and a strong generating set relative to that base. The original base and strong generating set are not modified. The randomized version (default) is of Las Vegas type. Parameters ========== base, strong_gens The base and strong generating set. pos The position at which swapping is performed. randomized A switch between randomized and deterministic version. transversals The transversals for the basic orbits, if known. basic_orbits The basic orbits, if known. strong_gens_distr The strong generators distributed by basic stabilizers, if known. Returns ======= (base, strong_gens) ``base`` is the new base, and ``strong_gens`` is a generating set relative to it. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.testutil import _verify_bsgs >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> S = SymmetricGroup(4) >>> S.schreier_sims() >>> S.base [0, 1, 2] >>> base, gens = S.baseswap(S.base, S.strong_gens, 1, randomized=False) >>> base, gens ([0, 2, 1], [(0 1 2 3), (3)(0 1), (1 3 2), (2 3), (1 3)]) check that base, gens is a BSGS >>> S1 = PermutationGroup(gens) >>> _verify_bsgs(S1, base, gens) True See Also ======== schreier_sims Notes ===== The deterministic version of the algorithm is discussed in [1], pp. 102-103; the randomized version is discussed in [1], p.103, and [2], p.98. It is of Las Vegas type. Notice that [1] contains a mistake in the pseudocode and discussion of BASESWAP: on line 3 of the pseudocode, `|\beta_{i+1}^{\left\langle T\right\rangle}|` should be replaced by `|\beta_{i}^{\left\langle T\right\rangle}|`, and the same for the discussion of the algorithm. r9NT)schreier_vector)rr?r7_orbitr&r random_stabrr{removenextiterrindexrmulr)rgr strong_genspos randomized transversals basic_orbitsstrong_gens_distrbase_lenr7r5Tstab_posrnewGammagammarryelstrong_gens_new_distrbase_newstrong_gens_newrs r0baseswapPermutationGroup.baseswapsb %T !- B 6 $5t9<$%c,Qw*?&@@&3!7AgGHI 7X\ !A!'*1-A  '(9(>?H&66t!G}EOfV 23t;**4a=;J+L fV 23t;  )*E LL #!G}% T']+fV 23t;T%[) %e,}}**4a=9|!G44!F6e$<>> from sympy.combinatorics.named_groups import SymmetricGroup >>> S = SymmetricGroup(4) >>> S.basic_orbits [[0, 1, 2, 3], [1, 2, 3], [2, 3]] See Also ======== base, strong_gens, basic_transversals, basic_stabilizers )rarrws r0rPermutationGroup.basic_orbitsbs*8    #    !!!rjcUR/:XaUR5 URnURnU(d/$[ X!5n/nUHnUR [ U55 M U$)at Return a chain of stabilizers relative to a base and strong generating set. Explanation =========== The ``i``-th basic stabilizer `G^{(i)}` relative to a base `(b_1, b_2, \dots, b_k)` is `G_{b_1, b_2, \dots, b_{i-1}}`. For more information, see [1], pp. 87-89. Examples ======== >>> from sympy.combinatorics.named_groups import AlternatingGroup >>> A = AlternatingGroup(4) >>> A.schreier_sims() >>> A.base [0, 1] >>> for g in A.basic_stabilizers: ... print(g) ... PermutationGroup([ (3)(0 1 2), (1 2 3)]) PermutationGroup([ (1 2 3)]) See Also ======== base, strong_gens, basic_orbits, basic_transversals )rbrr_r^rrr&)rgrrrbasic_stabilizersrs r0r"PermutationGroup.basic_stabilizersspJ    #    '' zzI4TG%D  $ $%5d%; <&  rjcZUR/:XaUR5 UR$)a Return basic transversals relative to a base and strong generating set. Explanation =========== The basic transversals are transversals of the basic orbits. They are provided as a list of dictionaries, each dictionary having keys - the elements of one of the basic orbits, and values - the corresponding transversal elements. See [1], pp. 87-89 for more information. Examples ======== >>> from sympy.combinatorics.named_groups import AlternatingGroup >>> A = AlternatingGroup(4) >>> A.basic_transversals [{0: (3), 1: (3)(0 1 2), 2: (3)(0 2 1), 3: (0 3 1)}, {1: (3), 2: (1 2 3), 3: (1 3 2)}] See Also ======== strong_gens, base, basic_orbits, basic_stabilizers )rbrrws r0basic_transversals#PermutationGroup.basic_transversalss*:    #    !!!rjc UR5n[SUSR55(d [S5e/n[ [ U5S- 5HnXS-n/nXRHn[ U/UR-5nUR5UR5-n/n [U5R5HCup[ U 5H/n U R[ U/UR-55 Xj-nM1 ME X-nUnM XUS'URU5 M URUS5 U$)a~ Return the composition series for a group as a list of permutation groups. Explanation =========== The composition series for a group `G` is defined as a subnormal series `G = H_0 > H_1 > H_2 \ldots` A composition series is a subnormal series such that each factor group `H(i+1) / H(i)` is simple. A subnormal series is a composition series only if it is of maximum length. The algorithm works as follows: Starting with the derived series the idea is to fill the gap between `G = der[i]` and `H = der[i+1]` for each `i` independently. Since, all subgroups of the abelian group `G/H` are normal so, first step is to take the generators `g` of `G` and add them to generators of `H` one by one. The factor groups formed are not simple in general. Each group is obtained from the previous one by adding one generator `g`, if the previous group is denoted by `H` then the next group `K` is generated by `g` and `H`. The factor group `K/H` is cyclic and it's order is `K.order()//G.order()`. The series is then extended between `K` and `H` by groups generated by powers of `g` and `H`. The series formed is then prepended to the already existing series. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.named_groups import CyclicGroup >>> S = SymmetricGroup(12) >>> G = S.sylow_subgroup(2) >>> C = G.composition_series() >>> [H.order() for H in C] [1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1] >>> G = S.sylow_subgroup(3) >>> C = G.composition_series() >>> [H.order() for H in C] [243, 81, 27, 9, 3, 1] >>> G = CyclicGroup(12) >>> C = G.composition_series() >>> [H.order() for H in C] [12, 6, 3, 1] c38# UHoRv M g7fr+)rAr.rGs r0r16PermutationGroup.composition_series..s=*r?r&orderritemsrextend) rgderseriesrFHup_segrGKrdown_segpe_s r0composition_series#PermutationGroup.composition_seriess3f!!#=#b'*<*<===%&@A As3xz"AaCAFV&&$aS1<<%78 QWWY.%e,224DA"1X (8!q||9K(LMD&5"*'F1I MM& !#  c"g rjc^^^^^URU5(d [S5eUR5S:Xa UR$UR UR S9 UR m[ TUR5m[URS- 5nURSSn[U5H'umn[UR5UUU4SjS9UT'M) URnURnURn[Xv5VV s/sH&upUR5U R5-PM( n nn [!U5[!U5:aU[!U5Rn OU/n [!U5S- m[!U 5n TS:a/n UTHnX:XaM TTTU- mU HNnXN-m[#UUU4SjUT55(aU R%T5 U [!U 5-U T:XdMN O U [!U 5-U T:XdM O X- n U [!U 5- n TS-mTS:aMU R'U5 U/U -n U $s sn nf) zReturn a transversal of the right cosets of self by its subgroup H using the second method described in [1], Subsection 4.6.7 The argument must be a subgroupr9rNc>TTTU- $r+r)rr base_orderingls r04PermutationGroup.coset_transversal..6s d1gai0Hrjkeyrc3:># UHnTUT- T:v M g7fr+r)r.hbrrs r0r15PermutationGroup.coset_transversal..PsFIq=1-2I) is_subgroup ValueErrorrelements_schreier_simsrrr7rr enumeratesortedvaluesrrzipr?rrr)rgridentityrtorbitsh_stabsg_stabsrrindicesrt_lenT_nexturrrrrs @@@@@r0coset_transversal"PermutationGroup.coset_transversals- }}T"">? ? 779>==  (yy&tT[[9 t{{Q/..q1 l+DAq$QXXZ&HJLO,%%((474IJ4IDA1779aggi'4IJ w<#g, &G %..A A LNA"fF!!_=!$q'!),AAFF1IFFF a(s6{*gaj8  3v;&'!*4% KA S[ E FA!"f"  JN?Ks-Ic:^^^^^^ UR5S:XaU$URS[UR5UR:XdURURS9 URSSmUR Vs/sHn[ UR55PM snmUR Vs/sHn[ UR55PM snm URm[TUR5mUUUUUU 4SjmT"SU5$s snfs snf)zoReturn the representative of Hg from the transversal that would be computed by ``self.coset_transversal(H)``. r9Nrc2>^[T UUU4SjS9nTUVs/sH nTUU- PM snRU5nTUUT-mU[T 5S- :a5T UHnTUU- TUT- :XdM O T "US-TWS--5U-mT$s snf)Nc>TUT- $r+r)rrrs r0rFPermutationGroup._coset_representative..step..ms=13Erjrr9r)minrr?) rrrrrFrrrh_transversalsrsteprs ` r0r 4PermutationGroup._coset_representative..steplsq )EFE$21$56$5qa$56<Hyy#aff+&!&&0   QVV  ,"454H4HI4Hq$qxxz*4HI262I2IJ2IQQXXZ(2IJ yy&tT[[9   AqzJJs #D7#Dc.URU5(d [S5eURU5n[U5n[ [ R "SUR555n/n[U5HZnUVs/sHopRX&U-U5PM nnUV s/sHoRU 5PM nn URU5 M\ [[U55nSn [[U5U5HupX[U n X:agX:a]UHWnXZUnX]UXZU'XU U'[U5H+nXVUU :Xa XUU'MXVUU :XdM$XUU'M- MY U S- n XS- :dMUs $ gs snfs sn f)zMReturn the standardised (right) coset table of self in H as a list of lists. rc3.# UH nXS-4v M g7f)rNr)r.rs r0r1/PermutationGroup.coset_table..s%0.'*7^.sr9N) rrrr?r:r from_iterabler|r>r"rrr)rgrrrAtablerFrrowrralphar/betazs r0 coset_tablePermutationGroup.coset_tablexs}}T"">? ?  " "1 % F $$%0#%00 1qABCD!Q--ad1fa8!CD'*+s!771:sC+ LL  #a&Ma!,HE<?D}<!LO*/+a. Q)*d A!&qA$x{d2.3a !&!!5.2a "*  !| -E+s  F (FchUR(dURU5UlUR$)aU Return the center of a permutation group. Explanation =========== The center for a group `G` is defined as `Z(G) = \{z\in G | \forall g\in G, zg = gz \}`, the set of elements of `G` that commute with all elements of `G`. It is equal to the centralizer of `G` inside `G`, and is naturally a subgroup of `G` ([9]). Examples ======== >>> from sympy.combinatorics.named_groups import DihedralGroup >>> D = DihedralGroup(4) >>> G = D.center() >>> G.order() 2 See Also ======== centralizer Notes ===== This is a naive implementation that is a straightforward application of ``.centralizer()`` )rN centralizerrws r0centerPermutationGroup.centers(D||++D1DL||rjc^^^^^[TS5(GaTR(dUR(aU$URn[[ [ U555nTR 5n[U5nURSS9 /nS/U-mS/U-nS/U-m[ U5H7n[ XH5n U STU'[U5Xx'U Hn UTU 'M Xi-nM9 URUS9umn [TU 5n Sn[ [T55HnXU/:XdM O TSUmUn [ U5HnTU S- XN;dM O USWS-n[U5nS/U-m[ U5H$nTUn[TRUSS 95TU'M& S nS/U -n[ U 5H$nTUT;aUUU'MU4UUUU4S jjnUUU'M& U4S jnURUTU US 9$[TS5(a%[ T5nUR[U55$[TS5(aUR[T/55$g)ao Return the centralizer of a group/set/element. Explanation =========== The centralizer of a set of permutations ``S`` inside a group ``G`` is the set of elements of ``G`` that commute with all elements of ``S``:: `C_G(S) = \{ g \in G | gs = sg \forall s \in S\}` ([10]) Usually, ``S`` is a subset of ``G``, but if ``G`` is a proper subgroup of the full symmetric group, we allow for ``S`` to have elements outside ``G``. It is naturally a subgroup of ``G``; the centralizer of a permutation group is equal to the centralizer of any set of generators for that group, since any element commuting with the generators commutes with any product of the generators. Parameters ========== other a permutation group/list of permutations/single permutation Examples ======== >>> from sympy.combinatorics.named_groups import (SymmetricGroup, ... CyclicGroup) >>> S = SymmetricGroup(6) >>> C = CyclicGroup(6) >>> H = S.centralizer(C) >>> H.is_subgroup(C) True See Also ======== subgroup_search Notes ===== The implementation is an application of ``.subgroup_search()`` with tests using a specific base for the group ``G``. r|c[U5*$r+r?rs r0r.PermutationGroup.centralizer..s s1vgrjrNrrr9TpairscgNTrr7s r0rr8"Trjc>XnT TUnT UnURTUnURUnT UTUnXWRU:H$r+r) computed_wordsrrG rep_orb_indexrimim_reptr_elr orbit_descr orbit_repsrs r0test*PermutationGroup.centralizer..test(sl*-(3DG(< (7]]473!"s!3 ,] ;DG D "%6%6v%>>>rjc>TRVs/sHn[X5PM snTRVs/sHn[X5PM sn:H$s snfs snfr+)r|r)rGrr}s r0prop*PermutationGroup.centralizer..prop6sQ050@0@A0@Q 0@A050@0@A0@S 0@ABBAAs AA)rrtestsrn array_form)hasattr is_trivialr7r@r:r>rr?sortschreier_sims_incrementalrdictorbit_transversalsubgroup_searchr1r&)rgr}r7rr num_orbits long_baseorbit_reps_indicesrForbitpointrrrj rel_orbitsnum_rel_orbitsr trivial_testrLrrGrJrrrErFrs ` @@@@r0r1PermutationGroup.centralizersf 5, ' '4?? [[FtE&M23H\\^FVJ KK-K .I *J"& !2 &-K:&VY %a 1 (+I"%"E)*K&#%- '!% > >I > N D+ 8{ K A3t9%$'H:5&8DH:&1 %2' !a%J _N 6.0L>* m"&++Ct+<#> Q+*LF8OE8_7j(+E!H/0 ? ? $E!H!%$ B''44?u(N N UM * *;D##$4T$:; ; UL ) )##$4eW$=> >*rjcURnURn/nUH3nUH*n[XvU)U)5nX;dMURU5 M, M5 URU5n U $)a Return the commutator of two subgroups. Explanation =========== For a permutation group ``K`` and subgroups ``G``, ``H``, the commutator of ``G`` and ``H`` is defined as the group generated by all the commutators `[g, h] = hgh^{-1}g^{-1}` for ``g`` in ``G`` and ``h`` in ``H``. It is naturally a subgroup of ``K`` ([1], p.27). Examples ======== >>> from sympy.combinatorics.named_groups import (SymmetricGroup, ... AlternatingGroup) >>> S = SymmetricGroup(5) >>> A = AlternatingGroup(5) >>> G = S.commutator(S, A) >>> G.is_subgroup(A) True See Also ======== derived_subgroup Notes ===== The commutator of two subgroups `H, G` is equal to the normal closure of the commutators of all the generators, i.e. `hgh^{-1}g^{-1}` for `h` a generator of `H` and `g` a generator of `G` ([1], p.28) )r|rrnormal_closure) rgGrggenshgens commutatorsggenhgen commutatorress r0rgPermutationGroup.commutatorAsmH   D!$tedU; 0&&z2 !!+. rjc[U[[45(aUR5n[ U5UR :wa [ S5e[[UR 55nURnURn/nURnUn[[ U55Hhn XU n XU :XaURU 5 M%XU ;a/s $XYU Rn [[U 5U5nURU 5 Mj X:wa/$U(aU$URn [[ U55V s/sH oU XiPM nn U$s sn f)a8Return ``G``'s (self's) coset factorization of ``g`` Explanation =========== If ``g`` is an element of ``G`` then it can be written as the product of permutations drawn from the Schreier-Sims coset decomposition, The permutations returned in ``f`` are those for which the product gives ``g``: ``g = f[n]*...f[1]*f[0]`` where ``n = len(B)`` and ``B = G.base``. f[i] is one of the permutations in ``self._basic_orbits[i]``. If factor_index==True, returns a tuple ``[b[0],..,b[n]]``, where ``b[i]`` belongs to ``self._basic_orbits[i]`` Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation(0, 1, 3, 7, 6, 4)(2, 5) >>> b = Permutation(0, 1, 3, 2)(4, 5, 7, 6) >>> G = PermutationGroup([a, b]) Define g: >>> g = Permutation(7)(1, 2, 4)(3, 6, 5) Confirm that it is an element of G: >>> G.contains(g) True Thus, it can be written as a product of factors (up to 3) drawn from u. See below that a factor from u1 and u2 and the Identity permutation have been used: >>> f = G.coset_factor(g) >>> f[2]*f[1]*f[0] == g True >>> f1 = G.coset_factor(g, True); f1 [0, 4, 4] >>> tr = G.basic_transversals >>> f[0] == tr[0][f1[0]] True If g is not an element of G then [] is returned: >>> c = Permutation(5, 6, 7) >>> G.coset_factor(c) [] See Also ======== sympy.combinatorics.util._strip z.g should be the same size as permutations of G)r,rrr:r?r]rr>rrbrrrr r r) rgrG factor_indexIrrfactorsrrrFr,rtrs r0 coset_factorPermutationGroup.coset_factorpsAx a%- . .A q6T\\ !MN N t||$ %(( )) yy s4y!A!W:DAwt$?* %11AA*A NN4 " 6I N  $ $.3CI.>?.>a5$.>?@sEc j/nUR(a/$XR;aSU(aXR;aU/$URUnUH#nUR"UR USS95 M% U$US-UR;aUS-nU(aXR;aUS-/$URUnUH#nUR"UR USS95 M% [ U5n[U5Vs/sHosXg- S- S-PM nnU$URUS5n[U5HwupyURUU nUHZnU(d!UR"URU5 M+URUnUR"UR USS95 M\ My U$s snf)z Return a list of strong generators `[s1, \dots, sn]` s.t `g = sn \times \dots \times s1`. If ``original=True``, make the list contain only the original group generators Toriginalrr9) rArr|r`rgenerator_productr?r>ror rcr) rgrGrsrslpsrrFfrZs r0rt"PermutationGroup.generator_products ==I   qOO3s ++A.ANN4#9#9!d#9#KL Ud&& &2AqOO32w++A.ANN4#9#9!d#9#KLL72-x@   a &aLDA''*1-CNN4#3#3A#67((+ANN4#9#9!d#9#KL !As<F0cURUS5nU(dgSnSnURnURnURn[ [ U55H1nX(n XxR U 5n X4U -- nU[ XX5-nM3 U$)arank using Schreier-Sims representation. Explanation =========== The coset rank of ``g`` is the ordering number in which it appears in the lexicographic listing according to the coset decomposition The ordering is the same as in G.generate(method='coset'). If ``g`` does not belong to the group it returns None. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation(0, 1, 3, 7, 6, 4)(2, 5) >>> b = Permutation(0, 1, 3, 2)(4, 5, 7, 6) >>> G = PermutationGroup([a, b]) >>> c = Permutation(7)(2, 4)(3, 5) >>> G.coset_rank(c) 16 >>> G.coset_unrank(16) (7)(2 4)(3 5) See Also ======== coset_factor TNrr9)rorbr^rar>r?r) rgrGrmrankrrrrrFrrZs r0 coset_rankPermutationGroup.coset_ranks@##At, )) zz)) s4y!A A%%a(A aCKD#lo&&A "  rjcUS:dXR5:agURnURnURn[ U5nS/U-n[ U5H%n[ U[ XH55upXXU Xx'M' [ U5Vs/sHoUXxRPM n n[U 6n U(aU $[U 5$s snf)zunrank using Schreier-Sims representation coset_unrank is the inverse operation of coset_rank if 0 <= rank < order; otherwise it returns None. rN) rrrrr?r>divmodrr r@) rgrzafrrrmvrFcr/rs r0 coset_unrankPermutationGroup.coset_unrank#s !8tzz|+yy.. (( I CEqAT3|#78GD?1%AD9>a A1!_QT " . . A qM H1:  BsC cUR$)aReturns the size of the permutations in the group. Explanation =========== The number of permutations comprising the group is given by ``len(group)``; the number of permutations that can be generated by the group is given by ``group.order()``. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([1, 0, 2]) >>> G = PermutationGroup([a]) >>> G.degree 3 >>> len(G) 1 >>> G.order() 2 >>> list(G.generate()) [(2), (2)(0 1)] See Also ======== order )r]rws r0r7PermutationGroup.degree;s>||rjcP[[[UR555$)z8 Return the identity element of the permutation group. )r@r:r>r7rws r0rPermutationGroup.identity\s tE$++./00rjcxUR(d[UR55UlUR$)aReturns all the elements of the permutation group as a list Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> p = PermutationGroup(Permutation(1, 3), Permutation(1, 2)) >>> p.elements [(3), (3)(1 2), (1 3), (2 3), (1 2 3), (1 3 2)] )rMr:generaterws r0r PermutationGroup.elementsds'~~!$--/2DN~~rjcU/nUnUR5nURU5(d;URU5 UnUR5nURU5(dM;U$)aaReturn the derived series for the group. Explanation =========== The derived series for a group `G` is defined as `G = G_0 > G_1 > G_2 > \ldots` where `G_i = [G_{i-1}, G_{i-1}]`, i.e. `G_i` is the derived subgroup of `G_{i-1}`, for `i\in\mathbb{N}`. When we have `G_k = G_{k-1}` for some `k\in\mathbb{N}`, the series terminates. Returns ======= A list of permutation groups containing the members of the derived series in the order `G = G_0, G_1, G_2, \ldots`. Examples ======== >>> from sympy.combinatorics.named_groups import (SymmetricGroup, ... AlternatingGroup, DihedralGroup) >>> A = AlternatingGroup(5) >>> len(A.derived_series()) 1 >>> S = SymmetricGroup(4) >>> len(S.derived_series()) 4 >>> S.derived_series()[1].is_subgroup(AlternatingGroup(4)) True >>> S.derived_series()[2].is_subgroup(DihedralGroup(2)) True See Also ======== derived_subgroup )derived_subgrouprrrgrhcurrentnxts r0rPermutationGroup.derived_seriesvshPf##%%%c** JJsOG&&(C%%c** rjcURnURVs/sHo"RPM nn[5nURn[ [ U55n[ U5Hkn[ U5HYnX7n X8n [ [ U55n UHn XU XX'M [U 5n X;dMHURU 5 M[ Mm UVs/sHn[U5PM nnURU5nU$s snfs snf)asCompute the derived subgroup. Explanation =========== The derived subgroup, or commutator subgroup is the subgroup generated by all commutators `[g, h] = hgh^{-1}g^{-1}` for `g, h\in G` ; it is equal to the normal closure of the set of commutators of the generators ([1], p.28, [11]). Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([1, 0, 2, 4, 3]) >>> b = Permutation([0, 1, 3, 2, 4]) >>> G = PermutationGroup([a, b]) >>> C = G.derived_subgroup() >>> list(C.generate(af=True)) [[0, 1, 2, 3, 4], [0, 1, 3, 4, 2], [0, 1, 4, 2, 3]] See Also ======== derived_series ) r\r|rr{r]r:r>tupleaddr@r`)rgrrrset_commutatorsr7rngrFrZp1p2rrctcmsG2s r0r!PermutationGroup.derived_subgroups8 GG'+7! 7%5=!qA1XWWv'A#%e9AiL1X,#''+$33?awqz?3   % !84s DD czUS:XaURU5$US:XaURU5$[SU-5e)aReturn iterator to generate the elements of the group. Explanation =========== Iteration is done with one of these methods:: method='coset' using the Schreier-Sims coset representation method='dimino' using the Dimino method If ``af = True`` it yields the array form of the permutations Examples ======== >>> from sympy.combinatorics import PermutationGroup >>> from sympy.combinatorics.polyhedron import tetrahedron The permutation group given in the tetrahedron object is also true groups: >>> G = tetrahedron.pgroup >>> G.is_group True Also the group generated by the permutations in the tetrahedron pgroup -- even the first two -- is a proper group: >>> H = PermutationGroup(G[0], G[1]) >>> J = PermutationGroup(list(H.generate())); J PermutationGroup([ (0 1)(2 3), (1 2 3), (1 3 2), (0 3 1), (0 2 3), (0 3)(1 2), (0 1 3), (3)(0 2 1), (0 3 2), (3)(0 1 2), (0 2)(1 3)]) >>> _.is_group True cosetdiminozNo generation defined for %s)generate_schreier_simsgenerate_diminor)rgmethodrs r0rPermutationGroup.generatesH\ W ..r2 2 x ''+ +%&Dv&MN Nrjc ## [[UR55nSnU/n[U51nU(aUv O [ U5v UR Vs/sHofR PM nn[[U55HnUR5n U/n U (dMU n /n U Hn USUS-Hn [X5n[U5U;dMU HjnUS- n[X5nU(aUv O[ U5nUv URU5 UR[U55 U RU5 Ml M M U (aMM [U5Ul gs snf7f)aLYield group elements using Dimino's algorithm. If ``af == True`` it yields the array form of the permutations. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1, 3]) >>> b = Permutation([0, 2, 3, 1]) >>> g = PermutationGroup([a, b]) >>> list(g.generate_dimino(af=True)) [[0, 1, 2, 3], [0, 2, 1, 3], [0, 2, 3, 1], [0, 1, 3, 2], [0, 3, 2, 1], [0, 3, 1, 2]] References ========== .. [1] The Implementation of Various Algorithms for Permutation Groups in the Computer Algebra System: AXIOM, N.J. Doye, M.Sc. Thesis rNr9) r:r>r7rr@r|rr?copyr rrrL)rgridnr element_listset_element_listrrrFDNr(r/rGagdaps r0r PermutationGroup.generate_dimino s@.5%&u !#J< I#, '+7! 7s4y!A!!#AA!A!&1q5\%a^ 9,<<%& % %-a_#%*,H(/ A*+G , 3 3B 7 0 4 4U2Y ? ! &' *! ".,' 38s%AE.E).1E.#,E.A?E.E.c#&# URnURnURn[U5S:Xa/URHnU(aUR v MUv M g[U5S:Xa4USH*nU(aUSUR v M USUv M, g[ [U55nUSSS2n[ [U55/nUVs/sHn[U5PM nn[U5S- n S/U -n Sn XX:a"U S:XagSX'U S-n UR5 M-[X;XKXR US5n X==S- ss'URU 5 U S- n X:XaU(a0USH&n[USUR US5n U v M( O:USH1n[USUR US5n [U 5n U v M3 UR5 U S-n GMs snf7f)aYield group elements using the Schreier-Sims representation in coset_rank order If ``af = True`` it yields the array form of the permutations Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1, 3]) >>> b = Permutation([0, 2, 3, 1]) >>> g = PermutationGroup([a, b]) >>> list(g.generate_schreier_sims(af=True)) [[0, 1, 2, 3], [0, 2, 1, 3], [0, 3, 2, 1], [0, 1, 3, 2], [0, 2, 3, 1], [0, 3, 1, 2]] rNr9r) r]rrar?r|rr:reversedr>r<r rr@)rgrrrrrrFstgposmaxrrrrrs r0r'PermutationGroup.generate_schreier_simsEs$ LL  # #)) q6Q;__--'G %  q6Q;!!_A$q'---A$q'M %  ! #DbD) E!H~"#$!Q#a&!$ [1_c"f v"6Q locf56BBCGLA FaKF JJqM FAw)"-$QrU1X%9%93r7C.*"-$QrU1X%9%93r7C$QZ . Q1 %sCHH 2DHcUR$)zReturns the generators of the group. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1]) >>> b = Permutation([1, 0, 2]) >>> G = PermutationGroup([a, b]) >>> G.generators [(1 2), (2)(0 1)] rlrws r0r|PermutationGroup.generatorssrjc[U[5(dgURUR:waU(ag[XRS9nXR;ag[ UR URS55$)a_Test if permutation ``g`` belong to self, ``G``. Explanation =========== If ``g`` is an element of ``G`` it can be written as a product of factors drawn from the cosets of ``G``'s stabilizers. To see if ``g`` is one of the actual generators defining the group use ``G.has(g)``. If ``strict`` is not ``True``, ``g`` will be resized, if necessary, to match the size of permutations in ``self``. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation(1, 2) >>> b = Permutation(2, 3, 1) >>> G = PermutationGroup(a, b, degree=5) >>> G.contains(G[0]) # trivial check True >>> elem = Permutation([[2, 3]], size=5) >>> G.contains(elem) True >>> G.contains(Permutation(4)(0, 1, 2, 3)) False If strict is False, a permutation will be resized, if necessary: >>> H = PermutationGroup(Permutation(5)) >>> H.contains(Permutation(3)) False >>> H.contains(Permutation(3), strict=False) True To test if a given permutation is present in the group: >>> elem in G.generators False >>> G.has(elem) False See Also ======== coset_factor, sympy.core.basic.Basic.has, __contains__ Fr4T)r,rr5r7r|boolrorM)rgrGstricts r0rsPermutationGroup.containssbh![)) 66T[[ AKK0A  D%%allD9::rjc|URc$URUR55UlUR$)a0Return ``True`` if the group is perfect. A group is perfect if it equals to its derived subgroup. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation(1,2,3)(4,5) >>> b = Permutation(1,2,3,4,5) >>> G = PermutationGroup([a, b]) >>> G.is_perfect False )rYrrrws r0 is_perfectPermutationGroup.is_perfects6    ##{{4+@+@+BCD rjcURb UR$SUlURVs/sHoRPM nnUH-nUH$nXC::aM [X45(aMSUl g M/ gs snf)a>Test if the group is Abelian. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1]) >>> b = Permutation([1, 0, 2]) >>> G = PermutationGroup([a, b]) >>> G.is_abelian False >>> a = Permutation([0, 2, 1]) >>> G = PermutationGroup([a]) >>> G.is_abelian True TF)rOr|rr )rgrrrrs r0 is_abelianPermutationGroup.is_abeliansz&    '## #'+7! 7A6(..',D$ 8sA:cUR(a/$URn/nUnUR5nURn[UR 55Hn/n/nUH0n X-n UR U 5(aMUR U 5 M2 U(a [XX-5OUn UR 5U R 5-n U nUnU S:XaOUR [Xl55 MU(dMS/US-nUHn [U 5H nXU-X'M M URU5 M UR5 U$)aF Returns the abelian invariants for the given group. Let ``G`` be a nontrivial finite abelian group. Then G is isomorphic to the direct product of finitely many nontrivial cyclic groups of prime-power order. Explanation =========== The prime-powers that occur as the orders of the factors are uniquely determined by G. More precisely, the primes that occur in the orders of the factors in any such decomposition of ``G`` are exactly the primes that divide ``|G|`` and for any such prime ``p``, if the orders of the factors that are p-groups in one such decomposition of ``G`` are ``p^{t_1} >= p^{t_2} >= ... p^{t_r}``, then the orders of the factors that are p-groups in any such decomposition of ``G`` are ``p^{t_1} >= p^{t_2} >= ... p^{t_r}``. The uniquely determined integers ``p^{t_1} >= p^{t_2} >= ... p^{t_r}``, taken for all primes that divide ``|G|`` are called the invariants of the nontrivial group ``G`` as suggested in ([14], p. 542). Notes ===== We adopt the convention that the invariants of a trivial group are []. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1]) >>> b = Permutation([1, 0, 2]) >>> G = PermutationGroup([a, b]) >>> G.abelian_invariants() [2] >>> from sympy.combinatorics import CyclicGroup >>> G = CyclicGroup(7) >>> G.abelian_invariants() [7] r9r) rOr|rrrrsrr&r r>rrP)rggnsinvrarHgensrrpowsrGelmrrrFrZs r0abelian_invariants#PermutationGroup.abelian_invariantss3T ??Ioo     aggi(AEA$C::c?? C(7;$U\2GGIqwwy(6 \!/0us58|A"1X"&'!)& 4 +),   rjch^UR=(a [U4SjUR55$)aReturn ``True`` if the group is elementary abelian. An elementary abelian group is a finite abelian group, where every nontrivial element has order `p`, where `p` is a prime. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1]) >>> G = PermutationGroup([a]) >>> G.is_elementary(2) True >>> a = Permutation([0, 2, 1, 3]) >>> b = Permutation([3, 1, 2, 0]) >>> G = PermutationGroup([a, b]) >>> G.is_elementary(2) True >>> G.is_elementary(3) False c3H># UHoR5T:Hv M g7fr+r)r.rGrs r0r11PermutationGroup.is_elementary..os&O!wwyA~s")rrr|)rgrs `r0 is_elementaryPermutationGroup.is_elementaryYs#,O3&Ot&O#OOrjcU(a!U(a[SRX55eURn[U5nUR 5nXT:XaSUlSUlU(+$SU-U:XaSUlSUlU(+$g)z#A naive test using the group order.z$Both {} and {} cannot be set to TrueTFr)rformatr7 _factorialrrQrR)rgonly_symonly_altr sym_orderrs r0_eval_is_alt_sym_naive'PermutationGroup._eval_is_alt_sym_naiveqs 6+- - KKqM    DL DL<  U7i  DLDL< rjc^UcmTRnUS:aSnOSnU[S5-[U5- n[[U5*U- 5nU4Sj[U55nTR US9$UHn[ U5(dM g g) aA test using monte-carlo algorithm. Parameters ========== eps : float, optional The criterion for the incorrect ``False`` return. perms : list[Permutation], optional If explicitly given, it tests over the given candidates for testing. If ``None``, it randomly computes ``N_eps`` and chooses ``N_eps`` sample of the permutation from the group. See Also ======== _check_cycles_alt_sym g(\?g= ףp=?rc3D># UHnTR5v M g7fr+)r)r.rFrgs r0r1@PermutationGroup._eval_is_alt_sym_monte_carlo..s<|!T^^%%| permsTF)r7rintr>_eval_is_alt_sym_monte_carlor)rgepsrrc_nd_nN_epsrs` r0r-PermutationGroup._eval_is_alt_sym_monte_carlos* = A2vs1v:s1v%CS # &E= 8. Explanation =========== More specifically, it is one-sided Monte Carlo with the answer True (i.e., G is symmetric/alternating) guaranteed to be correct, and the answer False being incorrect with probability eps. For degree < 8, the order of the group is checked so the test is deterministic. Notes ===== The algorithm itself uses some nontrivial results from group theory and number theory: 1) If a transitive group ``G`` of degree ``n`` contains an element with a cycle of length ``n/2 < p < n-2`` for ``p`` a prime, ``G`` is the symmetric or alternating group ([1], pp. 81-82) 2) The proportion of elements in the symmetric/alternating group having the property described in 1) is approximately `\log(2)/\log(n)` ([1], p.82; [2], pp. 226-227). The helper function ``_check_cycles_alt_sym`` is used to go over the cycles in a permutation and look for ones satisfying 1). Examples ======== >>> from sympy.combinatorics.named_groups import DihedralGroup >>> D = DihedralGroup(10) >>> D.is_alt_sym() False See Also ======== _check_cycles_alt_sym rc3.># UH nTUv M g7fr+r)r.rFrs r0r1.PermutationGroup.is_alt_sym..s:\LO\srTF)rFF)r>rrQrRr7r is_transitive)rgrrrrrs ` r0 is_alt_symPermutationGroup.is_alt_symsT  # )E:U5\:E4454A A <<4<< <<5 T\\U%: KK q5..0 0    ! !444= =%1" dlrjcD^URcUR5nU[U5S- nURnURn[ [ [U555m[U4SjU55(aSUl SUlgSUlgUR$)aTest if the group is nilpotent. Explanation =========== A group `G` is nilpotent if it has a central series of finite length. Alternatively, `G` is nilpotent if its lower central series terminates with the trivial group. Every nilpotent group is also solvable ([1], p.29, [12]). Examples ======== >>> from sympy.combinatorics.named_groups import (SymmetricGroup, ... CyclicGroup) >>> C = CyclicGroup(6) >>> C.is_nilpotent True >>> S = SymmetricGroup(5) >>> S.is_nilpotent False See Also ======== lower_central_series, is_solvable r9c3,># UH oT:Hv M g7fr+rr.rGrs r0r10PermutationGroup.is_nilpotent../$Q=$TF) rTlower_central_seriesr?r|r7r@r:r>rrU)rglcs terminatorrr7rs @r0 is_nilpotentPermutationGroup.is_nilpotents<    %++-CSX\*J((D[[FtE&M23H/$///$(!%)"%*"%% %rjc URXS9(dgURnURnUR(a X4:XdU(dgUR(agUR 5nU(dUX4:waPX4:a&[ UR [US- 5/-5nO%[ UR [US- 5/-5nUR Vs/sHofRPM nnUR Vs/sHofRPM nnUH;n UH2n [X[U 55nURUS5(aM1 g M= gs snfs snf)aTest if ``G=self`` is a normal subgroup of ``gr``. Explanation =========== G is normal in gr if for each g2 in G, g1 in gr, ``g = g1*g2*g1**-1`` belongs to G It is sufficient to check this for each g1 in gr.generators and g2 in G.generators. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([1, 2, 0]) >>> b = Permutation([1, 0, 2]) >>> G = PermutationGroup([a, b]) >>> G1 = PermutationGroup([a, Permutation([2, 0, 1])]) >>> G1.is_normal(G) True rFTr9) rr7rOrOr PermGroupr|rrr r ro) rggrrd_selfd_grnew_selfrrrg1g2s r0 is_normalPermutationGroup.is_normals.2yy ??f   99;&.}$X%8%8Kq>> from sympy.combinatorics.named_groups import DihedralGroup >>> D = DihedralGroup(10) >>> D.is_primitive() False See Also ======== minimal_block, random_stab Frc3*# UH oS:gv M g7frNrr.rs r0r10PermutationGroup.is_primitive..sI.H1f.HT) rSrrr>r?rrr& stabilizerrr<r; minimal_block) rgrrandom_stab_gensrrstabrorbrs r0 is_primitivePermutationGroup.is_primitiveGsP    )%% %    5 ( ! $$Q'A3t9% ''(8(8A(>?&#$45D??1%DC AAv#Id.@.@!Q.HIII%*"  "rjcSnUR5(dg/n/n/nU(a[/nURS5n[[U55H$nUR UR SU55 M& [ U5n OURS5n U R5n U GHn U R5n U S:wdMURSU /5n U"U 5up[UR5Vs1sHnUUS:XdMUiM nnSnS/[U5-n[U5Hounn[U5[U5:aURU5(aSUU'M;[U5[U5:dMUURU5(dMmSn O [U5VVs/sHunnUU(aMUPM nnn[U5VVs/sHunnUU(aMUPM nnn[U5VVs/sHunnUU(aMUPM nnnU(dGMX;dGMUR U 5 UR U5 UR U5 GM U$s snfs snnfs snnfs snnf)a For a transitive group, return the list of all minimal block systems. If a group is intransitive, return `False`. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> from sympy.combinatorics.named_groups import DihedralGroup >>> DihedralGroup(6).minimal_blocks() [[0, 1, 0, 1, 0, 1], [0, 1, 2, 0, 1, 2]] >>> G = PermutationGroup(Permutation(1,2,5)) >>> G.minimal_blocks() False See Also ======== minimal_block, is_transitive, is_primitive c[U5n0nSnS/U-n[U5H%nXU;aX2X'X4U'US- nMX UXE'M' [U5U4$)Nrr9)r?r>r)blocksrappearedrrrFs r0_number_blocks7PermutationGroup.minimal_blocks.._number_blockssr F AHAqA1X9H,*+VY'aDFA#1I.AD 8Q; rjFrT)rrr>r?rrr&rrr<r r7r issubset)rgrrr num_blocks rep_blocksr rrFr rr rblock num_blockrrZrminimalblocks_remove_maskrrrs r0minimal_blocksPermutationGroup.minimal_blockss6* $!!##  ! $$Q'A3t9% ''(8(8A(>?&#$45D??1%DC AAv**Aq62-e4 "' "4J"4Q ! 8Iq"4J&+Ws6{%:"%j1DAq1vC(S\\!__04*1-Q#c(*qzz#"'2)2&(9W(91ASTUAV!(9W,5j,A_,ADAqI[\]I^a,A _,5j,A_,ADAqI[\]I^a,A _7y:MM%(%%i0%%c*78 -KX__s05 I-I-+I2I2I8,I8I>I>cf^URcUR5S-S:wagUR5nU[U5S- nURnUR n[ [[U555m[U4SjU55(aSUlgSUlgUR$)a.Test if the group is solvable. ``G`` is solvable if its derived series terminates with the trivial group ([1], p.29). Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> S = SymmetricGroup(3) >>> S.is_solvable True See Also ======== is_nilpotent, derived_series rrTr9c3,># UH oT:Hv M g7fr+rrs r0r1/PermutationGroup.is_solvable..rrF) rUrrr?r|r7r@r:r>r)rgdsrrr7rs @r0 is_solvablePermutationGroup.is_solvables*    $zz|a1$$$&BCGaKJ((D[[FtE&M23H/$///$(!$)!$$ $rjc^^[T[5(aURTR:wagg[T[5(dgUT:XdURS[ 5:XagTR 5UR 5-S:wagURTR:Xd!URTR:aT(d URnOg[UU4SjU55$)aFReturn ``True`` if all elements of ``self`` belong to ``G``. If ``strict`` is ``False`` then if ``self``'s degree is smaller than ``G``'s, the elements will be resized to have the same degree. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> from sympy.combinatorics import SymmetricGroup, CyclicGroup Testing is strict by default: the degree of each group must be the same: >>> p = Permutation(0, 1, 2, 3, 4, 5) >>> G1 = PermutationGroup([Permutation(0, 1, 2), Permutation(0, 1)]) >>> G2 = PermutationGroup([Permutation(0, 2), Permutation(0, 1, 2)]) >>> G3 = PermutationGroup([p, p**2]) >>> assert G1.order() == G2.order() == G3.order() == 6 >>> G1.is_subgroup(G2) True >>> G1.is_subgroup(G3) False >>> G3.is_subgroup(PermutationGroup(G3[1])) False >>> G3.is_subgroup(PermutationGroup(G3[0])) True To ignore the size, set ``strict`` to ``False``: >>> S3 = SymmetricGroup(3) >>> S5 = SymmetricGroup(5) >>> S3.is_subgroup(S5, strict=False) True >>> C7 = CyclicGroup(7) >>> G = S5*C7 >>> S5.is_subgroup(G, False) True >>> C7.is_subgroup(G, 0) False FTrc3D># UHnTRUTS9v M g7f)rN)rs)r.rGrars r0r1/PermutationGroup.is_subgroup..9 s>A1::a:/r)r,SymmetricPermutationGroupr7r&r|rrr)rgrarrs `` r0rPermutationGroup.is_subgroupsV a2 3 3{{ahh&!-.. 19*KM9 779tzz| #q ( ;;!(( "qxx'??D>>>>rjcUR$)aReturn ``True`` if a group is polycyclic. A group is polycyclic if it has a subnormal series with cyclic factors. For finite groups, this is the same as if the group is solvable. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1, 3]) >>> b = Permutation([2, 0, 1, 3]) >>> G = PermutationGroup([a, b]) >>> G.is_polycyclic True )r"rws r0 is_polycyclicPermutationGroup.is_polycyclic; s"rjcHUR(a UR$U(aHURb UR$[URS55UR:HnX lU$SnUR 5Hn[U5S:dMU(a gSnM! U$)aTest if the group is transitive. Explanation =========== A group is transitive if it has a single orbit. If ``strict`` is ``False`` the group is transitive if it has a single orbit of length different from 1. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1, 3]) >>> b = Permutation([2, 0, 1, 3]) >>> G1 = PermutationGroup([a, b]) >>> G1.is_transitive() False >>> G1.is_transitive(strict=False) True >>> c = Permutation([2, 3, 0, 1]) >>> G2 = PermutationGroup([a, c]) >>> G2.is_transitive() True >>> d = Permutation([1, 0, 2, 3]) >>> e = Permutation([0, 1, 3, 2]) >>> G3 = PermutationGroup([d, e]) >>> G3.is_transitive() or G3.is_transitive(strict=False) False rFr9T)rPr?rXr7r)rgransgot_orbrs r0rPermutationGroup.is_transitiveN sB   && & "".***djjm$ 3C"% JA1vz   rjcURc)[U5S:H=(a USRUlUR$)a Test if the group is the trivial group. This is true if the group contains only the identity permutation. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> G = PermutationGroup([Permutation([0, 1, 2])]) >>> G.is_trivial True r9r)rVr? is_Identityrws r0rOPermutationGroup.is_trivial s;    #"4yA~E$q'2E2ED rjcU/nUnURX5nURU5(d<URU5 UnURX5nURU5(dM<U$)aReturn the lower central series for the group. The lower central series for a group `G` is the series `G = G_0 > G_1 > G_2 > \ldots` where `G_k = [G, G_{k-1}]`, i.e. every term after the first is equal to the commutator of `G` and the previous term in `G1` ([1], p.29). Returns ======= A list of permutation groups in the order `G = G_0, G_1, G_2, \ldots` Examples ======== >>> from sympy.combinatorics.named_groups import (AlternatingGroup, ... DihedralGroup) >>> A = AlternatingGroup(4) >>> len(A.lower_central_series()) 2 >>> A.lower_central_series()[1].is_subgroup(DihedralGroup(2)) True See Also ======== commutator, derived_series )rgrrrs r0r%PermutationGroup.lower_central_series sg<food,%%c** JJsOG//$0C%%c** rjcURb UR$URnUS:Xag[HnX-S:XdM X-nX0lUs $ g)aRMaximum proper divisor of the degree of a permutation group. Explanation =========== Obviously, this is the degree divided by its minimal proper divisor (larger than ``1``, if one exists). As it is guaranteed to be prime, the ``sieve`` from ``sympy.ntheory`` is used. This function is also used as an optimization tool for the functions ``minimal_block`` and ``_union_find_merge``. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> G = PermutationGroup([Permutation([0, 2, 1, 3])]) >>> G.max_div 2 See Also ======== minimal_block, _union_find_merge Nr9r)rXr7r)rgrrrs r0rPermutationGroup.max_div sO6 == $== KK 6AuzD !  rjcUR5(dgURnURn[[ U55nS/U-n/n[ U5nXpR :aS/U-$[ US- 5H&nUSXAUS-'URXS-5 M( XuUS'SnUS- n X:a\Xhn US- nUHFn URX5n URU "U 5U "U 5UXF5n U S:XaS/U-s $X- n MH X:aM\[ U5HnURX5 M 0n[U5VVs/sHupURX5PM snn$s snnf)aFor a transitive group, finds the block system generated by ``points``. Explanation =========== If a group ``G`` acts on a set ``S``, a nonempty subset ``B`` of ``S`` is called a block under the action of ``G`` if for all ``g`` in ``G`` we have ``gB = B`` (``g`` fixes ``B``) or ``gB`` and ``B`` have no common points (``g`` moves ``B`` entirely). ([1], p.23; [6]). The distinct translates ``gB`` of a block ``B`` for ``g`` in ``G`` partition the set ``S`` and this set of translates is known as a block system. Moreover, we obviously have that all blocks in the partition have the same size, hence the block size divides ``|S|`` ([1], p.23). A ``G``-congruence is an equivalence relation ``~`` on the set ``S`` such that ``a ~ b`` implies ``g(a) ~ g(b)`` for all ``g`` in ``G``. For a transitive group, the equivalence classes of a ``G``-congruence and the blocks of a block system are the same thing ([1], p.23). The algorithm below checks the group for transitivity, and then finds the ``G``-congruence generated by the pairs ``(p_0, p_1), (p_0, p_2), ..., (p_0,p_{k-1})`` which is the same as finding the maximal block system (i.e., the one with minimum block size) such that ``p_0, ..., p_{k-1}`` are in the same block ([1], p.83). It is an implementation of Atkinson's algorithm, as suggested in [1], and manipulates an equivalence relation on the set ``S`` using a union-find data structure. The running time is just above `O(|points||S|)`. ([1], pp. 83-87; [7]). Examples ======== >>> from sympy.combinatorics.named_groups import DihedralGroup >>> D = DihedralGroup(10) >>> D.minimal_block([0, 5]) [0, 1, 2, 3, 4, 0, 1, 2, 3, 4] >>> D.minimal_block([0, 1]) [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] See Also ======== _union_find_rep, _union_find_merge, is_transitive, is_primitive Fr9rr) rr7r|r:r>r?rrrrr  setdefault)rgpointsrrrrrrrF len_not_reprrdeltarnew_repsrs r0r PermutationGroup.minimal_block s`!!## KKuQx.A K || 3q5Lq1uA%+AYG1q5M " NN6a%= )fQi !e oJE FA,,U<--c%j#e*e.5@2:3q5L# oqA   , 6?6HI6Hda##A)6HIIIsE&cU1nUn[U5S:aj[5nUH6nURH#nXe-U)-nXr;dMURU5 M% M8 UR U5 Un[U5S:aMjU$)aReturn the conjugacy class of an element in the group. Explanation =========== The conjugacy class of an element ``g`` in a group ``G`` is the set of elements ``x`` in ``G`` that are conjugate with ``g``, i.e. for which ``g = xax^{-1}`` for some ``a`` in ``G``. Note that conjugacy is an equivalence relation, and therefore that conjugacy classes are partitions of ``G``. For a list of all the conjugacy classes of the group, use the conjugacy_classes() method. In a permutation group, each conjugacy class corresponds to a particular `cycle structure': for example, in ``S_3``, the conjugacy classes are: * the identity class, ``{()}`` * all transpositions, ``{(1 2), (1 3), (2 3)}`` * all 3-cycles, ``{(1 2 3), (1 3 2)}`` Examples ======== >>> from sympy.combinatorics import Permutation, SymmetricGroup >>> S3 = SymmetricGroup(3) >>> S3.conjugacy_class(Permutation(0, 1, 2)) {(0 1 2), (0 2 1)} Notes ===== This procedure computes the conjugacy class directly by finding the orbit of the element under conjugation in G. This algorithm is only feasible for permutation groups of relatively small order, but is like the orbit() function itself in that respect. r)r?r{r|rupdate)rgr new_classlast_iterationthis_iterationrrv conjugateds r0conjugacy_class PermutationGroup.conjugacy_class: sTC ".!A% UN#A!"1"J!2&**:6)$   ^ ,+N.!A%rjc[[[UR555nU1nUR 5/nUR 5H=nXB;dM UR U5nURU5 URU5 M? U$)aReturn the conjugacy classes of the group. Explanation =========== As described in the documentation for the .conjugacy_class() function, conjugacy is an equivalence relation on a group G which partitions the set of elements. This method returns a list of all these conjugacy classes of G. Examples ======== >>> from sympy.combinatorics import SymmetricGroup >>> SymmetricGroup(3).conjugacy_classes() [{(2)}, {(0 1 2), (0 2 1)}, {(0 2), (1 2), (2)(0 1)}] ) r@r:r>r7rrrDrr?)rgrknown_elementsclassesrr@s r0conjugacy_classes"PermutationGroup.conjugacy_classesv s{&4dkk 234"!&&()A& 003 y)%%i0 ! rjc^[US5(GaURn[[[ U555m[ U4SjUR 55(aU$[UR SS5nUR5upV[XV5n[XW5upURSSS9 Sn U (GaIURSSS9 [ U5Hn UR5n UR5n X- n[XX5nUST:wdUS [U5S -:wdMSUR nURU5 [U5nURU5 URXV5unnUUpe[XV5n[UU5upM S n UR HRn UR H6n X- n[XUU 5nUST:wdUS [U5S -:wdM4Sn O U (dMR O U (aGMIU$[US 5(aUR![U55$[US 5(aUR![U/55$g) aReturn the normal closure of a subgroup/set of permutations. Explanation =========== If ``S`` is a subset of a group ``G``, the normal closure of ``A`` in ``G`` is defined as the intersection of all normal subgroups of ``G`` that contain ``A`` ([1], p.14). Alternatively, it is the group generated by the conjugates ``x^{-1}yx`` for ``x`` a generator of ``G`` and ``y`` a generator of the subgroup ``\left\langle S\right\rangle`` generated by ``S`` (for some chosen generating set for ``\left\langle S\right\rangle``) ([1], p.73). Parameters ========== other a subgroup/list of permutations/single permutation k an implementation-specific parameter that determines the number of conjugates that are adjoined to ``other`` at once Examples ======== >>> from sympy.combinatorics.named_groups import (SymmetricGroup, ... CyclicGroup, AlternatingGroup) >>> S = SymmetricGroup(5) >>> C = CyclicGroup(5) >>> G = S.normal_closure(C) >>> G.order() 60 >>> G.is_subgroup(AlternatingGroup(5)) True See Also ======== commutator, derived_subgroup, random_pr Notes ===== The algorithm is described in [1], pp. 73-74; it makes use of the generation of random elements for permutation groups by the product replacement algorithm. r|c3,># UH oT:Hv M g7fr+rrs r0r12PermutationGroup.normal_closure.. s;*:Q=*:rN )rrTrr9FrnrM)rNr7r@r:r>rr|r&rQrrrrrr?rr`)rgr}rr7Zrrrrr_looprrGrconjrhr temp_basetemp_strong_gensrs @r0r`PermutationGroup.normal_closure sNb 5, ' '[[FtE&M23H;%*:*:;;;  !1!1!!45A ! ; ; = D 8 K .tG -L  2 ,E!!B"!-qA(A A3D \NC1v)SVs4y1}-D || D),T2#**4077J4 #3,57Gk4TG*;4 139 &8"$A\\ s$T%79q6X-Q3t9q=1H$(E! *u)+%>H UM * *&&'7'>? ? UL ) )&&'7'@A A*rjcD[URURX5$)aCompute the orbit of alpha `\{g(\alpha) | g \in G\}` as a set. Explanation =========== The time complexity of the algorithm used here is `O(|Orb|*r)` where `|Orb|` is the size of the orbit and ``r`` is the number of generators of the group. For a more detailed analysis, see [1], p.78, [2], pp. 19-21. Here alpha can be a single point, or a list of points. If alpha is a single point, the ordinary orbit is computed. if alpha is a list of points, there are three available options: 'union' - computes the union of the orbits of the points in the list 'tuples' - computes the orbit of the list interpreted as an ordered tuple under the group action ( i.e., g((1,2,3)) = (g(1), g(2), g(3)) ) 'sets' - computes the orbit of the list interpreted as a sets Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([1, 2, 0, 4, 5, 6, 3]) >>> G = PermutationGroup([a]) >>> G.orbit(0) {0, 1, 2} >>> G.orbit([0, 4], 'union') {0, 1, 2, 3, 4, 5, 6} See Also ======== orbit_transversal )rr7r|)rgr+actions r0rXPermutationGroup.orbit sHdkk4??EBBrjcUcURU5nX2cgX2nURVs/sHoURPM nn/nUS:wa2URXd5 XdR U5nX2nUS:waM2U(a[ [ U65$[ [[UR555$s snf)aReturn a group element which sends ``alpha`` to ``beta``. Explanation =========== If ``beta`` is not in the orbit of ``alpha``, the function returns ``False``. This implementation makes use of the schreier vector. For a proof of correctness, see [1], p.80 Examples ======== >>> from sympy.combinatorics.named_groups import AlternatingGroup >>> G = AlternatingGroup(5) >>> G.orbit_rep(0, 4) (0 4 1 2 3) See Also ======== schreier_vector Fr) rr|rrrr@r r:r>r])rgr+r,rrrrr/s r0 orbit_repPermutationGroup.orbit_rep s0  ""2259O  (  !'+7! 7 2g HHTW 7==&D%A2g 9a=) )4dll 345 58sB=cD[URURX5$)aComputes a transversal for the orbit of ``alpha`` as a set. Explanation =========== For a permutation group `G`, a transversal for the orbit `Orb = \{g(\alpha) | g \in G\}` is a set `\{g_\beta | g_\beta(\alpha) = \beta\}` for `\beta \in Orb`. Note that there may be more than one possible transversal. If ``pairs`` is set to ``True``, it returns the list of pairs `(\beta, g_\beta)`. For a proof of correctness, see [1], p.79 Examples ======== >>> from sympy.combinatorics.named_groups import DihedralGroup >>> G = DihedralGroup(6) >>> G.orbit_transversal(0) [(5), (0 1 2 3 4 5), (0 5)(1 4)(2 3), (0 2 4)(1 3 5), (5)(0 4)(1 3), (0 3)(1 4)(2 5)] See Also ======== orbit )_orbit_transversalr]r|)rgr+r:s r0rS"PermutationGroup.orbit_transversalH s6"$,,NNrjcB[URUR5$)aDReturn the orbits of ``self``, ordered according to lowest element in each orbit. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation(1, 5)(2, 3)(4, 0, 6) >>> b = Permutation(1, 5)(3, 4)(2, 6, 0) >>> G = PermutationGroup([a, b]) >>> G.orbits() [{0, 2, 3, 4, 6}, {1, 5}] )_orbitsr]rK)rgrs r0rPermutationGroup.orbitse st||T%5%566rjcURb UR$UR(a(URn[U5UlUR$UR(a+URn[U5S- UlUR$[ UR Vs/sHn[U5PM sn5nX0lU$s snf)atReturn the order of the group: the number of permutations that can be generated from elements of the group. The number of permutations comprising the group is given by ``len(group)``; the length of each permutation in the group is given by ``group.size``. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([1, 0, 2]) >>> G = PermutationGroup([a]) >>> G.degree 3 >>> len(G) 1 >>> G.order() 2 >>> list(G.generate()) [(2), (2)(0 1)] >>> a = Permutation([0, 2, 1]) >>> b = Permutation([1, 0, 2]) >>> G = PermutationGroup([a, b]) >>> G.order() 6 See Also ======== degree r)rLrQr]rrRrrr?)rgrrrs r0rPermutationGroup.orderu sH ;; ";;  << A#A,DK;;  << A#A,q.DK;;  $"9"9:"9Q#a&"9: ; ;s"CcrURU5(a!UR5UR5-$g)a Returns the index of a permutation group. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation(1,2,3) >>> b =Permutation(3) >>> G = PermutationGroup([a]) >>> H = PermutationGroup([b]) >>> G.index(H) 3 N)rr)rgrs r0rPermutationGroup.index s/ ==  ::<* * rjc~URnUbU$URnUS:aUR5(agUR5nU(aA[ SUR 55(aSuUlUlgSuUlUlgURSS9$SuUlUlgURSS9$) aReturn ``True`` if the group is symmetric. Examples ======== >>> from sympy.combinatorics import SymmetricGroup >>> g = SymmetricGroup(5) >>> g.is_symmetric True >>> from sympy.combinatorics import Permutation, PermutationGroup >>> g = PermutationGroup( ... Permutation(0, 1, 2, 3, 4), ... Permutation(2, 3)) >>> g.is_symmetric True Notes ===== This uses a naive test involving the computation of the full group order. If you need more quicker taxonomy for large groups, you can use :meth:`PermutationGroup.is_alt_sym`. However, :meth:`PermutationGroup.is_alt_sym` may not be accurate and is not able to distinguish between an alternating group and a symmetric group. See Also ======== is_alt_sym rc38# UHoRv M g7fr+)is_oddrs r0r10PermutationGroup.is_symmetric.. s=_88_r6TFTFTF)rr)rQr7rrr;r|rRr)rgrQr _is_alt_syms r0 is_symmetricPermutationGroup.is_symmetric sF,,  N KK 6!!##"??A =T__===5@2 dl#1<.DL$, 22D2AA)5 &DL$,**D*99rjc~URnUbU$URnUS:aUR5(agUR5nU(aA[ SUR 55(aSuUlUlgSuUlUlgURSS9$SuUlUlgURSS9$) aReturn ``True`` if the group is alternating. Examples ======== >>> from sympy.combinatorics import AlternatingGroup >>> g = AlternatingGroup(5) >>> g.is_alternating True >>> from sympy.combinatorics import Permutation, PermutationGroup >>> g = PermutationGroup( ... Permutation(0, 1, 2, 3, 4), ... Permutation(2, 3, 4)) >>> g.is_alternating True Notes ===== This uses a naive test involving the computation of the full group order. If you need more quicker taxonomy for large groups, you can use :meth:`PermutationGroup.is_alt_sym`. However, :meth:`PermutationGroup.is_alt_sym` may not be accurate and is not able to distinguish between an alternating group and a symmetric group. See Also ======== is_alt_sym rc38# UHoRv M g7fr+is_evenrs r0r12PermutationGroup.is_alternating.." s>o99or6rkTrjF)rr)rRr7rrrr|rQr)rgrRrrls r0is_alternatingPermutationGroup.is_alternating sF,,  N KK 6!!##"??A >doo>>>5@2 dl#1<.DL$, 22D2AA)5 &DL$,**D*99rjc[U5n[U5n[U5H)n[US-U5HnXX-S:XdM g M+ g)zCSubroutine to test if there is only one cyclic group for the order.r9NT)r r?r>)rCprimesrrFrZs r0_distinct_primes_lemma'PermutationGroup._distinct_primes_lemma0 sQ KqA1Q3]9vy(A-#rjc^^TRb TR$[TR5S:XaSTlSTlgTRSLaSTlgTR 5mTS:aSTlTS:waSTlg[ T5n[ SUR555(aYTR(aSTlg[UR55n[RU5SLaSTlSTlgTR(dSTlg[ UU4SjUR555TlTR$)a1 Return ``True`` if the group is Cyclic. Examples ======== >>> from sympy.combinatorics.named_groups import AbelianGroup >>> G = AbelianGroup(3, 4) >>> G.is_cyclic True >>> G = AbelianGroup(4, 4) >>> G.is_cyclic False Notes ===== If the order of a group $n$ can be factored into the distinct primes $p_1, p_2, \dots , p_s$ and if .. math:: \forall i, j \in \{1, 2, \dots, s \}: p_i \not \equiv 1 \pmod {p_j} holds true, there is only one group of the order $n$ which is a cyclic group [1]_. This is a generalization of the lemma that the group of order $15, 35, \dots$ are cyclic. And also, these additional lemmas can be used to test if a group is cyclic if the order of the group is already found. - If the group is abelian and the order of the group is square-free, the group is cyclic. - If the order of the group is less than $6$ and is not $4$, the group is cyclic. - If the order of the group is prime, the group is cyclic. References ========== .. [1] 1978: John S. Rose: A Course on Group Theory, Introduction to Finite Group Theory: 1.4 r9TFc3*# UH oS:Hv M g7f)r9Nr)r.rs r0r1-PermutationGroup.is_cyclic..~ s0/!Av/rc3|>^# UH0umoS:dM [UUU4SjTR55v M2 g7f)r9c3L># UHoTT--TR:gv M g7fr+)r)r.rGrrrgs r0r17PermutationGroup.is_cyclic... s H1E1H .s!$N)r;r|)r.rrrrgs @r0r1r~ s5 '1q5 ICHH H H's <(<)rZr?r|rOrrrr r:keysr&rxrr)rgrmrwrs` @r0 is_cyclicPermutationGroup.is_cyclic< s&Z ?? &?? " t 1 $"DO#D    u $#DO  19#D z"&E" 0w~~/0 0 0"&',,.)F66v>$F"&#' #DO    rjcURb UR$UR5nUS-S:XaSUlgUS:XaSUlgUS:Xa"UR(+UlUR$UR(aSUlgUS-nURn[ U5S:XafUupEUR5UR5pvXg:aXTXv4upEpgUSs=:XaU:Xa O OSUlgXb:XaUS:XaXT-U-U):XaSUlg//pUR HDn U R5n U S:XaURU 5 M,X:XdM3U RU 5 MF [ U5US-US-- :waSUlgU (dSUlgU SnUSnUS-S:XaXTUS--:XaUSnXT-U-U):HUlUR$)aQ Return ``True`` if the group is dihedral. Examples ======== >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> from sympy.combinatorics.permutations import Permutation >>> from sympy.combinatorics.named_groups import SymmetricGroup, CyclicGroup >>> G = PermutationGroup(Permutation(1, 6)(2, 5)(3, 4), Permutation(0, 1, 2, 3, 4, 5, 6)) >>> G.is_dihedral True >>> G = SymmetricGroup(3) >>> G.is_dihedral True >>> G = CyclicGroup(6) >>> G.is_dihedral False References ========== .. [Di1] https://math.stackexchange.com/questions/827230/given-a-cayley-table-is-there-an-algorithm-to-determine-if-it-is-a-dihedral-gro/827273#827273 .. [Di2] https://kconrad.math.uconn.edu/blurbs/grouptheory/dihedral.pdf .. [Di3] https://kconrad.math.uconn.edu/blurbs/grouptheory/dihedral2.pdf .. [Di4] https://en.wikipedia.org/wiki/Dihedral_group rr9FTr|r)r[rrrr|r?r r) rgrrrrrr/rorder_2order_nrrs r0 is_dihedralPermutationGroup.is_dihedral s:    ($$ $  19> %D  A: $D  A:$(NN 2D $$ $ ?? %D  QJ t9>DA779aggiqu1Z aA{{$(!v!q&QSUqb[$(!rA AAvq!q!  w<1q5AE? * %D  %D  AJ AJ q5A:!1a4y. ASUqb[   rjcU(aURUS9up4/nURnUH2nUVs/sH o"U5PM snU:XdM!URU5 M4 U(d[[ [ U555n[ U5$URn URnUHn [XiU 5n M [ U 5$s snf)aWReturn the pointwise stabilizer for a set of points. Explanation =========== For a permutation group `G` and a set of points `\{p_1, p_2,\ldots, p_k\}`, the pointwise stabilizer of `p_1, p_2, \ldots, p_k` is defined as `G_{p_1,\ldots, p_k} = \{g\in G | g(p_i) = p_i \forall i\in\{1, 2,\ldots,k\}\}` ([1],p20). It is a subgroup of `G`. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> S = SymmetricGroup(7) >>> Stab = S.pointwise_stabilizer([2, 3, 5]) >>> Stab.is_subgroup(S.stabilizer(2).stabilizer(3).stabilizer(5)) True See Also ======== stabilizer, schreier_sims_incremental Notes ===== When incremental == True, rather than the obvious implementation using successive calls to ``.stabilizer()``, this uses the incremental Schreier-Sims algorithm to obtain a base with starting segment - the given points. r) rQr7rr@r:r>r&rK _stabilizer) rgr9 incrementalrr stab_gensr7rrYrrs r0pointwise_stabilizer%PermutationGroup.pointwise_stabilizer sH  $ > >F > K DI[[F",23F5CJF3v=$$S)##Dv$78 #I. .##D[[F"63%%4sCcn[U5(aUb [S5e[U5Up!O [U5n[ U5n[ [[UR555n[U5n[U5HnX"U5n[XG5nM U$![a [S5ef=f)am Multiply ``n`` randomly selected permutations from pgroup together, starting with the identity permutation. If ``n`` is a list of integers, those integers will be used to select the permutations and they will be applied in L to R order: make_perm((A, B, C)) will give CBA(I) where I is the identity permutation. ``seed`` is used to set the seed for the random selection of permutations from pgroup. If this is a list of integers, the corresponding permutations from pgroup will be selected in the order give. This is mainly used for testing purposes. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a, b = [Permutation([1, 0, 3, 2]), Permutation([1, 3, 0, 2])] >>> G = PermutationGroup([a, b]) >>> G.make_perm(1, [0]) (0 1)(2 3) >>> G.make_perm(3, [0, 1, 0]) (0 2 3 1) >>> G.make_perm([0, 1, 0]) (0 2 3 1) See Also ======== random z'If n is a sequence, seed should be Nonez#n must be an integer or a sequence.) r#rr?rrqrrr:r>r7r)rgrseed randomrangeresultrrrs r0 make_permPermutationGroup.make_perm) s@ q>> !JKK!fat HF!& T% "456 IqA[^$A&_F  H !FGG Hs BB4cV[UR55nURX!5$)z&Return a random group element )rrr)rgrrzs r0randomPermutationGroup.random\ s%&  **rjcUR/:XaURX5 URn[U5S- nUc>[U5n[US- 5nXv:XaUS- n[ SS/5n[ SS/5n OUSnUSnXv:XaUS- nUSnUSn US:Xa/[ XF[ XGU 55XF'[ XEXF5XE'O.[ [ XGU 5XF5XF'[ XFXE5XE'[XE5$)aqReturn a random group element using product replacement. Explanation =========== For the details of the product replacement algorithm, see ``_random_pr_init`` In ``random_pr`` the actual 'product replacement' is performed. Notice that if the attribute ``_random_gens`` is empty, it needs to be initialized by ``_random_pr_init``. See Also ======== _random_pr_init r9rrrvrrr)rdrr?rrr r r@) rg gen_count iterationsrrrrvrrrs r0rPermutationGroup.random_prb s!"    "   7''  q   ! A!a% AvE1vAAwAS!AS!AvES!AS!A 6%kngkna6PQKN%knknEKN%gkna&@+.QKN%knknEKN{~&&rjcUcURU5nUcUR5nOUSnU"U5nURXU5n[U)U5$)zRandom element from the stabilizer of ``alpha``. The schreier vector for ``alpha`` is an optional argument used for speeding up repeated calls. The algorithm is described in [1], p.81 See Also ======== random_pr, orbit_rep rand)rrrZr)rgr+rrrr,rs r0rPermutationGroup.random_stab s]  ""2259O  >>#D'DE{ NN5 8QB~rjcHUR(agUR5 g)axSchreier-Sims algorithm. Explanation =========== It computes the generators of the chain of stabilizers `G > G_{b_1} > .. > G_{b1,..,b_r} > 1` in which `G_{b_1,..,b_i}` stabilizes `b_1,..,b_i`, and the corresponding ``s`` cosets. An element of the group can be written as the product `h_1*..*h_s`. We use the incremental Schreier-Sims algorithm. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1]) >>> b = Permutation([1, 0, 2]) >>> G = PermutationGroup([a, b]) >>> G.schreier_sims() >>> G.basic_transversals [{0: (2)(0 1), 1: (2), 2: (1 2)}, {0: (2), 2: (0 2)}] N)rbr rws r0rPermutationGroup.schreier_sims s6     rjc URUSS9nUSSupXlX0lUSUlU(d/Ul/Ulg[ X5n[UUSS9upVn[U5H9upXHn U H*n XV s/sHoRX5PM sn X'M, M; X`lUV s/sHn [U 5PM sn UlXpl gs sn fs sn f)NT)rslp_dictr)ru) rQr^r_r`rbrarrr rr rc)rgrschreierrrrrslpsrFrurrrvrs r0r PermutationGroup._schreier_sims s11td1K$RaL ' ( !#D !#D  4TG+I$!t,-( D oFA$'D>AfEf++DG4fE& *1=>AfQi> $ F?s <C/Cc 0 ^&Uc/nUcURSSnURn[[U55n[ U5S:Xa+USR (aU(a XUSUS/04$X4$USSUSSpvUVs/sHoR (aMUPM nnUHPm&[ U&4SjU55(dMUHn T&RU U :wdM O eURU 5 MR [Xg5n /n 0n 0n 0n[ U5n[U5HOn[XJUUUSSSS9uU U'UU'[U U5U U'[U UR55U U'MQ US- nUS:GaSn0n[U UR55GHunn[U U5GHunm&T&RUnU UUn[T&RU5nUUUVs/sHnUU4PM nnUU4/U-nUU:wGaOSnUUn[UU5nUUUSSnUR%5 UVs/sHnUU44PM nnUU-n['UXlU UUUS9unnnUU::aSnOKU(aDSnSn UU U :XaU S- n UU U :XaMURU 5 US- nU R/5 USLa[)U5nU RUU45 [US-U5Hcn!U U!RU5 [XJU!UU!SSSS9uU U!'UU!'[U U!5U U!'[U U!R55U U!'Me US- nSnUSLdGM O USLdGM O USLaGMUS-nUS:aGMUSSn"U(aU Hyun#nU"RU#5 [[ U55HJnUUn$[+U$S[,5(aU U$SU$SSS -UU'M9U U$SU$SUU'ML M{ [U 5n UH nU/U U'M UU"U 4$U"R/U V#V%s/sHun#n%U#PM sn%n#5 UU"4$s snfs snf![ a [#U5=nUU'GNqf=fs snfs sn%n#f) awExtend a sequence of points and generating set to a base and strong generating set. Parameters ========== base The sequence of points to be extended to a base. Optional parameter with default value ``[]``. gens The generating set to be extended to a strong generating set relative to the base obtained. Optional parameter with default value ``self.generators``. slp_dict If `True`, return a dictionary `{g: gens}` for each strong generator `g` where `gens` is a list of strong generators coming before `g` in `strong_gens`, such that the product of the elements of `gens` is equal to `g`. Returns ======= (base, strong_gens) ``base`` is the base obtained, and ``strong_gens`` is the strong generating set relative to it. The original parameters ``base``, ``gens`` remain unchanged. Examples ======== >>> from sympy.combinatorics.named_groups import AlternatingGroup >>> from sympy.combinatorics.testutil import _verify_bsgs >>> A = AlternatingGroup(7) >>> base = [2, 3] >>> seq = [2, 3] >>> base, strong_gens = A.schreier_sims_incremental(base=seq) >>> _verify_bsgs(A, base, strong_gens) True >>> base[:2] [2, 3] Notes ===== This version of the Schreier-Sims algorithm runs in polynomial time. There are certain assumptions in the implementation - if the trivial group is provided, ``base`` and ``gens`` are returned immediately, as any sequence of points is a base for the trivial group. If the identity is present in the generators ``gens``, it is removed as it is a redundant generator. The implementation is described in [1], pp. 90-93. See Also ======== schreier_sims, schreier_sims_random Nr9rc3F># UHoTRU:Hv M g7fr+r?r.rrs r0r1=PermutationGroup.schreier_sims_incremental..,s:Eq**Es!T)r:rruF)rurr)r|r7r:r>r?r1rrrrr]rRrrr r KeyErrorr reverserr@r,rr)'rgrrrr7id_afr^_gensrrrstrong_gens_slporbsrrrrF continue_idbr,u_betarZgbu1rrGruru1_inv schreier_gen u1_inv_slprmovedrrrrvrrs' @r0rQ*PermutationGroup.schreier_sims_incremental s4x <D <??1%DU6]# t9>d1g11DGd1gY#777: AwQu!7EqE7C:E::: Cs+s2! 4 S!5UB u:xA'9&TUBVa4(9 $LOT!W"<?3LO<?//12DG ! qL1fJB $\!_%:%:%< = f'(9!(<=FAs.B%a,B!#//6:B+/74=9=aAq6=C9q6(S.CRx!=%'VF(0'; %)!WR[^ "**,9C%DAq1$i %D(3.$-lEWX^ahl$m 1c= %A %A$%E"#E(e"3 % #$E(e"3!LL/$MH-44R8:!( A+22As8<%*1q5!_ 1! 4 ; ;A > 26Q;O$)!HDTt!M!9 Qa37|A2G Q*.|A/C/C/E*FQ &5!"AA)-J!T)a>b%g!>hT! FAy1f|Ah *3""1%s3xAAA!!A$..!21Q4!81a!A2!EA!21Q4!81!>A )*#?3O&'S";8 8/:/$!QA/:;k!![8J: (=.8n>> from sympy.combinatorics.testutil import _verify_bsgs >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> S = SymmetricGroup(5) >>> base, strong_gens = S.schreier_sims_random(consec_succ=5) >>> _verify_bsgs(S, base, strong_gens) #doctest: +SKIP True Notes ===== The algorithm is described in detail in [1], pp. 97-98. It extends the orbits ``orbs`` and the permutation groups ``stabs`` to basic orbits and basic stabilizers for the base and strong generating set produced in the end. The idea of the extension process is to "sift" random group elements through the stabilizer chain and amend the stabilizers/orbits along the way when a sift is not successful. The helper function ``_strip`` is used to attempt to decompose a random group element according to the current state of the stabilizer chain and report whether the element was fully decomposed (successful sift) or not (unsuccessful sift). In the latter case, the level at which the sift failed is reported and used to amend ``stabs``, ``base``, ``gens`` and ``orbs`` accordingly. The halting condition is for ``consec_succ`` consecutive successful sifts to pass. This makes sure that the current ``base`` and ``gens`` form a BSGS with probability at least `1 - 1/\text{consec\_succ}`. See Also ======== schreier_sims Nc3:># UHnT"U5U:Hv M g7fr+rrs r0r18PermutationGroup.schreier_sims_random..s-13q6Q;rrr9Tr9rGF)r|r?r7rrrrr>rRr]r:rrr<rr1)rgrr consec_succrrrrrrrrFrrGrrZrrrrrs @r0schreier_sims_random%PermutationGroup.schreier_sims_randomsbJ <D <??Dt9 KKC----ooc*c11HCooc*c1 C A  5T@ xA"#5a19Mt$%&LO>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([2, 4, 6, 3, 1, 5, 0]) >>> b = Permutation([0, 1, 3, 5, 4, 6, 2]) >>> G = PermutationGroup([a, b]) >>> G.schreier_vector(0) [-1, None, 0, 1, None, 1, 0] See Also ======== orbit NrFT)r7r|r?r>rr) rgr+rrr usedrrrrFrs r0r PermutationGroup.schreier_vectors@ KK F1Hgwqy  IA1Xw**1-:&JJt$!%DJdG rjcV[[URURU55$)aReturn the stabilizer subgroup of ``alpha``. Explanation =========== The stabilizer of `\alpha` is the group `G_\alpha = \{g \in G | g(\alpha) = \alpha\}`. For a proof of correctness, see [1], p.79. Examples ======== >>> from sympy.combinatorics.named_groups import DihedralGroup >>> G = DihedralGroup(6) >>> G.stabilizer(5) PermutationGroup([ (5)(0 4)(1 3)]) See Also ======== orbit )rrr]rK)rgr+s r0rPermutationGroup.stabilizerMs"2T\\43C3CUKLLrjcZUR/:XaUR5 UR$)aPReturn a strong generating set from the Schreier-Sims algorithm. Explanation =========== A generating set `S = \{g_1, g_2, \dots, g_t\}` for a permutation group `G` is a strong generating set relative to the sequence of points (referred to as a "base") `(b_1, b_2, \dots, b_k)` if, for `1 \leq i \leq k` we have that the intersection of the pointwise stabilizer `G^{(i+1)} := G_{b_1, b_2, \dots, b_i}` with `S` generates the pointwise stabilizer `G^{(i+1)}`. The concepts of a base and strong generating set and their applications are discussed in depth in [1], pp. 87-89 and [2], pp. 55-57. Examples ======== >>> from sympy.combinatorics.named_groups import DihedralGroup >>> D = DihedralGroup(4) >>> D.strong_gens [(0 1 2 3), (0 3)(1 2), (1 3)] >>> D.base [0, 1] See Also ======== base, basic_transversals, basic_orbits, basic_stabilizers )r_rrws r0rPermutationGroup.strong_genshs+@    "       rjch^[U4SjU55(d [S5e[U5nU$)zR Return the subgroup generated by `gens` which is a list of elements of the group c3,># UH oT;v M g7fr+r)r.rGrgs r0r1,PermutationGroup.subgroup..s+d9drz2The group does not contain the supplied generators)rrr&)rgrras` r0subgroupPermutationGroup.subgroups1 +d+++QR R T "rjc  ^&^'^(^)^*^+U&4SjnU&U'U(U)U*U+4SjnUcUR5up#[U5nURm([[ [ T(555n [ UT(5m&T&RT(5 T&RS5 [X#5n [UU 5um'n Uc [U /5nUc(Sn /n[ U5Hn URU 5 M UnUS- nUS- nUSSnURUS9unn[UU5nURn[ U5V s/sHn [T(UU UU 5PM sn m*S/U-n[T(UU5nU"U5UU'UURX/5 S/U-nU /U-nS/U-m+[ U5H$n T'U SST+U 'T+U RU&4S jS 9 M& S/U-nS/U-m)T(S-UU'U"U5 U /U-nUUS- :GaUU"UU5UU;GaT&UUT&UU"UU5s=:a T&T)U:GaO GOUU"U5(GaUU"UU5nUUU'[!T(UUU5nUUUS-'[T(U5nU"U5UUS-'US- nT'UVs/sHnUUS- "U5PM nnURU&4S jS 9 UT+U'T(S-n[ U5H.n UUT*U ;dMUU "X-5n T&U T&U:dM,U nM0 UUU'U"U5 SUU'T+UUUn!UUS- R"R%U!5n"U UU"UU'['UUS- UU5UU'UUS- :aSUU"UU5UU;a>T&UUT&UU"UU5s=:a T&T)U:aO OUU"U5(aGMUUn#U#"UU5n!UUS- :XaT&UUT&U!s=:a T&T)U:aO OU!UU;aUU"U5(azU"U#5(amURU#5 USSnURU#5 [UU5n[ U5V s/sHn [T(UU UU 5PM sn m*U"U5UU'UnUS:a=UU[T'U5S- :Xa%US- nUS:aUU[T'U5S- :XaM%US:Xa [U5$UU:aoUnSUU'[T(UU5n$U"U$5UU'T(S-UU'[T'U5S-[T*U5- n%U%[T+U5:a T&T(T)U'O T+UU%T)U'UU==S- ss'US:Xa T+UUUn"O*UUS- R"R%T+UUU5n"U UU"UU'US:Xa UUUU'O['UUS- UU5UU'GMs sn fs snfs sn f) a Find the subgroup of all elements satisfying the property ``prop``. Explanation =========== This is done by a depth-first search with respect to base images that uses several tests to prune the search tree. Parameters ========== prop The property to be used. Has to be callable on group elements and always return ``True`` or ``False``. It is assumed that all group elements satisfying ``prop`` indeed form a subgroup. base A base for the supergroup. strong_gens A strong generating set for the supergroup. tests A list of callables of length equal to the length of ``base``. These are used to rule out group elements by partial base images, so that ``tests[l](g)`` returns False if the element ``g`` is known not to satisfy prop base on where g sends the first ``l + 1`` base points. init_subgroup if a subgroup of the sought group is known in advance, it can be passed to the function as this parameter. Returns ======= res The subgroup of all elements satisfying ``prop``. The generating set for this group is guaranteed to be a strong generating set relative to the base ``base``. Examples ======== >>> from sympy.combinatorics.named_groups import (SymmetricGroup, ... AlternatingGroup) >>> from sympy.combinatorics.testutil import _verify_bsgs >>> S = SymmetricGroup(7) >>> prop_even = lambda x: x.is_even >>> base, strong_gens = S.schreier_sims_incremental() >>> G = S.subgroup_search(prop_even, base=base, strong_gens=strong_gens) >>> G.is_subgroup(AlternatingGroup(7)) True >>> _verify_bsgs(G, base, G.generators) True Notes ===== This function is extremely lengthy and complicated and will require some careful attention. The implementation is described in [1], pp. 114-117, and the comments for the code here follow the lines of the pseudocode in the book for clarity. The complexity is exponential in general, since the search process by itself visits all members of the supergroup. However, there are a lot of tests which are used to prune the search tree, and users can define their own tests via the ``tests`` parameter, so in practice, and for some computations, it's not terrible. A crucial part in the procedure is the frequent base change performed (this is line 11 in the pseudocode) in order to obtain a new basic stabilizer. The book mentiones that this can be done by using ``.baseswap(...)``, however the current implementation uses a more straightforward way to find the next basic stabilizer - calling the function ``.stabilizer(...)`` on the previous basic stabilizer. cL>UVs/sHn[UU4SjS9PM sn$s snf)Nc>TU$r+r)rrs r0rDPermutationGroup.subgroup_search..get_reps..s }Q/?rjr)r)rrXrs r0get_reps2PermutationGroup.subgroup_search..get_repss2"#!%%?@!# ##s!c>[TU5S-[TU5- nU[TU5:a TTTU'gTUUTU'g)Nr9r6)r temp_indexrrr7nures_basic_orbits_init_base sorted_orbitss r0 update_nu3PermutationGroup.subgroup_search..update_nus^\!_-17:;.r=rjr9rrc>TU$r+rrYrs r0rr's M%4Hrjrc>TU$r+rrs r0rrGs -2Frj)rQr?r7r@r:r>rrrrr&r|rr`rrPrrrr),rgrJrrrL init_subgrouprrrrrrr]rFrhrwrres_baseres_strong_gensres_strong_gens_distrres_generatorsrFrrrmur@ new_point new_stab_gensrY temp_orbitnew_mu candidate temp_pointrrG temp_orbitsrrrr7rrrs, @@@@@@r0rT PermutationGroup.subgroup_searchsV\ #  5 5 < $ > > @ Dt94f ./&tV4 V$R 4TG%CD%6&8" l  ,hZ8M =)LE8_ \*% qL qL7$'$A$A%B%!/ 8 /!1/ #!Q -a0(1+ >! # #VH_ !6q!9: ( 1  1 TW% CL Jx x xA+Aq1M!  !  ! !&H ! I!VH_VH_ 1! "H,hl"q!$q'*jm;be$nQ/Q89%be$%%!H^,,*1-d1g6 ' +F4I!4L!!# /<%a!e,!7$,V$4 1q5!Q ,Q1 /@EnQU3E: /1$FG#- a !qAAw" (3mF6KK%.F " 1! !*1-ad3 &q1u-99?? K#Au-!$(A)>!$Eq!Khl"q!$q'*jm;be$nQ/Q89%be$%!H^,,Dq!A47JHqL be$j)A,9"Q%,@Ajm+a((GG%%a(7&&q)(@:I)K% /+)Q 5a 8(1+F)++ !) 0 1 q&QqTSa%9A%==Eq&QqTSa%9A%==Bw'771u!%f.CA.FG ( 5 1  1 a1A521567 ]1%5!66)&1BqE)!,Z8BqE aDAIDAv&q)!A$/&q1u-99?? a@PQRSTQU@VW?5)AaDAv$%aDq!$(A)>!$Eq!E5 #\1J+s+WW 'W%cURceURnUn[U5H@nURU5n[ U5X- :wa X0lUs $UR U5nMB XlU$UR$)aCompute the degree of transitivity of the group. Explanation =========== A permutation group `G` acting on `\Omega = \{0, 1, \dots, n-1\}` is ``k``-fold transitive, if, for any `k` points `(a_1, a_2, \dots, a_k) \in \Omega` and any `k` points `(b_1, b_2, \dots, b_k) \in \Omega` there exists `g \in G` such that `g(a_1) = b_1, g(a_2) = b_2, \dots, g(a_k) = b_k` The degree of transitivity of `G` is the maximum ``k`` such that `G` is ``k``-fold transitive. ([8]) Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([1, 2, 0]) >>> b = Permutation([1, 0, 2]) >>> G = PermutationGroup([a, b]) >>> G.transitivity_degree 3 See Also ======== is_transitive, orbit )rWr7r>rXr?r)rgrrarFr s r0transitivity_degree$PermutationGroup.transitivity_degreesz>  $ $ , AA1Xggajs8qu$01-HLLO  )* %H,, ,rjcURSSn[USSS9nUVs/sHo3UR5U- -PM nn/n[[ U55GHnX&nUR5nXxU- -n US:a[ USU5n O[ UR 5n XxU- -U ;aURXxU- -5 MlU RU SS9nUH n X{S--nM X- nX& XF US- n U [ U5:aBX,R5U:a,U S- n U [ U5:aX,R5U:aM,USU U/-X,S-nUSU U/-XLS-nGM [ U5$s snf) zg For an abelian p-group, return the subgroup consisting of all elements of order p (and the identity) Nc"UR5$r+rr7s r0r4PermutationGroup._p_elements_group..s !'')rjT)rrrrrrr9) r|r rr>r?r&rrrt) rgrrrGgens_pgens_rrFrx_orderx_pPrvrZs r0_p_elements_group"PermutationGroup._p_elements_groups q!d 3TB,01Dqaggik"D1s4y!AAggiGai.C1u$VBQZ0$T]]319~Q& a!)n-''d';AR%A!)GIE#d)m 7(BFA#d)m 7(BBQx1#~R0qc)F2J63"4 ''92sE-c URn/n[US- 5nUS:H=(a [SUR55n/nUnUS:aUR Xq-5 Xq-nUS:aM[ U5S- n[ SUS-5Hn U S:Xa U(aM[[ X-5V s/sHoXS- --X--PM sn 5n UR XK-5 U(dMa[SS5U -[SS5-U -n UR U 5 M Sn US:aXhn [ U 5Hn[5nU S:a[ X-5Hn U"XU -5nM U(a9[SS5U-[SS5-U-n UR U 5 SUS- -n OUn [USU 5H/upU(a U S-S:XaMX-U-n UR U 5 M1 XU-- n M US- nUS:aMU$s sn f)a Return a p-Sylow subgroup of a symmetric or an alternating group. Explanation =========== The algorithm for this is hinted at in [1], Chapter 4, Exercise 4. For Sym(n) with n = p^i, the idea is as follows. Partition the interval [0..n-1] into p equal parts, each of length p^(i-1): [0..p^(i-1)-1], [p^(i-1)..2*p^(i-1)-1]...[(p-1)*p^(i-1)..p^i-1]. Find a p-Sylow subgroup of Sym(p^(i-1)) (treated as a subgroup of ``self``) acting on each of the parts. Call the subgroups P_1, P_2...P_p. The generators for the subgroups P_2...P_p can be obtained from those of P_1 by applying a "shifting" permutation to them, that is, a permutation mapping [0..p^(i-1)-1] to the second part (the other parts are obtained by using the shift multiple times). The union of this permutation and the generators of P_1 is a p-Sylow subgroup of ``self``. For n not equal to a power of p, partition [0..n-1] in accordance with how n would be written in base p. E.g. for p=2 and n=11, 11 = 2^3 + 2^2 + 1 so the partition is [[0..7], [8..9], {10}]. To generate a p-Sylow subgroup, take the union of the generators for each of the parts. For the above example, {(0 1), (0 2)(1 3), (0 4), (1 5)(2 7)} from the first part, {(8 9)} from the second part and nothing from the third. This gives 4 generators in total, and the subgroup they generate is p-Sylow. Alternating groups are treated the same except when p=2. In this case, (0 1)(s s+1) should be added for an appropriate s (the start of a part) for each part in the partitions. See Also ======== sylow_subgroup, is_alt_sym r9rc38# UHoRv M g7fr+rqrs r0r12PermutationGroup._sylow_alt_sym..s@1YYr6rN)r7rrr|rr?r>r )rgrrrraltcoeffsrpowerrFrZrrr/rshifts r0_sylow_alt_symPermutationGroup._sylow_alt_symsV KKqs#1f@@@@ !e MM!% A!eF A q%'"AAv#eADkJkA!H 4kJKC KK %s!!Q'+K1,==cA C #ai A1X# 19"18_ %a 3-)!Q/5k!Q6GGM C(uqyM!"+D!H"51q5A:$$io C( #6E!+,!GE7ai: OKs1H c^SSKJnJn [T5(d [ S5eU4SjnU4SjnUR 5nUT-S:wa[ UR/5$U"U5upxU(aU$UR5(a[ URT55$UR5n U V s/sH*n [U 5T-S:wdM[U 5S:wdM(U PM, n n U (a<UR[U S5R55n U RT5$UR!5(dI[#U [S9n U R5n U SR$"U 6nU"X 5nU"X5nU"UU5$UR'5n[U5S:a!U"UUS5nU"UUS5nU"UU5$[U5S:Xa[U5Sn[)SU55(afU"UU5nU"UR+55S(d?UR+5RT5nUR-U5RT5$UR/5nUR 5nUT-S:wdUS:Xa3UR/5nUR 5nUT-S:waM+US:XaM3UUT--nUTS --S:wa [ U5$UR1U5nUR 5TU--S:waURT5nUR 5nUR35nUR5T5nUR/5nUR1U5nUR 5T-U-S:wa=UR/5nUR1U5nUR 5T-U-S:waM=UnUR 5TU--S:waMURT5$s sn f) a! Return a p-Sylow subgroup of the group. The algorithm is described in [1], Chapter 4, Section 7 Examples ======== >>> from sympy.combinatorics.named_groups import DihedralGroup >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.named_groups import AlternatingGroup >>> D = DihedralGroup(6) >>> S = D.sylow_subgroup(2) >>> S.order() 4 >>> G = SymmetricGroup(6) >>> S = G.sylow_subgroup(5) >>> S.order() 5 >>> G1 = AlternatingGroup(3) >>> G2 = AlternatingGroup(5) >>> G3 = AlternatingGroup(9) >>> S1 = G1.sylow_subgroup(3) >>> S2 = G2.sylow_subgroup(3) >>> S3 = G3.sylow_subgroup(3) >>> len1 = len(S1.lower_central_series()) >>> len2 = len(S2.lower_central_series()) >>> len3 = len(S3.lower_central_series()) >>> len1 == len2 True >>> len1 < len3 True r)orbit_homomorphismblock_homomorphismzp must be a primec>UR5nSnUT-S:XaUT- nUS- nUS:XaSU4$UT-S:XaMSU4$)Nrr9TFr)rarrrs r0 is_p_group3PermutationGroup.sylow_subgroup..is_p_groupsZ AAa%1*aCQ67N a%1* !8Orjc>UR5RT5nURU5nURU5nUR5RT5nURU5$r+)imagesylow_subgroupinvert_subgroup restrict_to)rrQRrs r0 _sylow_reduce6PermutationGroup.sylow_subgroup.._sylow_reduces` ))!,A""1%A"B ))!,A%%a( (rjr9rc3*# UH oS:gv M g7frrrs r0r12PermutationGroup.sylow_subgroup..s)5a65rr)!sympy.combinatorics.homomorphismsrrr!rrr&rrrrr?rr:r<r rr unionrr;r r rr1r2r)rgrrrrrrp_grouprro non_p_orbitsraomega1omega2rrrrSrGg_orderCs_orderrPrrC_hs ` r0r PermutationGroup.sylow_subgroupXsN 8qzz01 1  )  19>#T]]O4 4%  K ??  #D$7$7$:; ; #)M6aSVaZ1_Q16 M \!_ 5 9 9 ; of ``K`` on a subset of ``gens_h`` is a finite presentation of ``H``. Explanation =========== ``H`` should be generated by the union of ``K.generators`` and ``z`` (a single generator), and ``H.stabilizer(alpha) == K``; ``phi`` is a canonical injection from a free group into a permutation group containing ``H``. The algorithm is described in [1], Chapter 6. Examples ======== >>> from sympy.combinatorics import free_group, Permutation, PermutationGroup >>> from sympy.combinatorics.homomorphisms import homomorphism >>> from sympy.combinatorics.fp_groups import FpGroup >>> H = PermutationGroup(Permutation(0, 2), Permutation (1, 5)) >>> K = PermutationGroup(Permutation(5)(0, 2)) >>> F = free_group("x_0 x_1")[0] >>> gens = F.generators >>> phi = homomorphism(F, H, F.generators, H.generators) >>> rels_k = [gens[0]**2] # relators for presentation of K >>> z= Permutation(1, 5) >>> check, rels_h = H._verify(K, phi, z, 1) >>> check True >>> rels = rels_k + rels_h >>> G = FpGroup(F, rels) # presentation of H >>> G.order() == H.order() True See also ======== strong_presentation, presentation, stabilizer rrTr9rrNF) rXrr:rrinvertrrSrr?r|rtr)rrphir-r+rXr,K_betagammasrrr rFrbetas transversalrvrGrrrrelsrk_gensrnew_relrrs r0_verifyPermutationGroup._verifys\e}d#u=u!uV\\!_-u=>(./!f /C  c"  jj4dJJq"uaA~ Q)4U);CJJqM)I A$%$7$7$7$FDAq 31/V"' $;&' #d{" #s/$M%M<M>M1M.-M.1NNcSSKJnJn SSKJn SSKJnJnJn URSSnURSSnURSSn [[U55V s/sHn SU -PM n n U"SRU 55Sn U"XU RU5n [!UR"5nU(Ga,U R%5nUnUR%5nURVs/sH nUU;dM UPM nnUR'5S:Xa?UR%5nU RS UR'5-/nU/n[!U5nU(GaUR%5nU/W-n[!U5nUR)U5nUR)U5nUU:XaUU;aU R+U5nUnOBUR-XU- 5nU R+U5U R+U5S --nUUS --nUR/US S 9HnUU R+U5S --nM U/nGO{[U5S:XaUR1UU UU5unnGOSUR3UU5unnU(Ga6U"UU5nUR4R6n UR6n![95n"[U 5Hn U"[9XU!-5-n"M UR:n#U#Vs0sHnUUU"-U#U-U"-_M n$nURS[UR5*HnUU$U'M [![=U$R?555n%U"UU%U$5n&[!URVs/sH nU&"U5PM sn5n'U%R1U'U&RAU 5U&"U5U!5unnWHn(U(W;dM URCU(5 M UnU(aGMU(aGM,U"U W5n)U"U)5$s sn fs snfs snfs snf) a Return a strong finite presentation of group. The generators of the returned group are in the same order as the strong generators of group. The algorithm is based on Sims' Verify algorithm described in [1], Chapter 6. Examples ======== >>> from sympy.combinatorics.named_groups import DihedralGroup >>> P = DihedralGroup(4) >>> G = P.strong_presentation() >>> P.order() == G.order() True See Also ======== presentation, _verify rFpGroupsimplify_presentation free_group)r homomorphismGroupHomomorphismNx_%d, r9rTrr)"sympy.combinatorics.fp_groupsr:r;sympy.combinatorics.free_groupsr=rrr>r?rrrr>r?joinr|r&rr<rrXr-rZrtr6r*codomainr7rimagesr:r composer)*rgr:r;r=rr>r?rstabsrrFgen_symsFr.rr+rrGnew_gensr-r3intermediate_gensK_srXorbit_krelrrnew_relssuccesscheckrrrrt_imgrFK_s_actrwK_actrgroups* r0strong_presentation$PermutationGroup.strong_presentations0 C> L L&&q) &&q)yy|).c+.>(?@(?1VAX(?@ tyy* +A .1ALL+> T]] +HHJEA A#$<<>wwyA~LLN R(!'')34%&C!$%67LLN%&C*;$;!&'89 %(''%.e#Av!jjm KKQw7!jjmCJJqM2,== Bw000E!#**Q-"33F #uH\Q&), AsAu(E%GX$'#4#4Q#>LE5 /sE:JJ--JJ (M!&qAQ!!44A"*!">C!CU!QqSq\!^"3U!C!%!1!12GC4G3G!HA()F1I"I"24 3H"I-dGVD 0 1M 1!A$ 1M N,3OOE199S>STUVSWYZ,[)!A} A"(e\4 $U++iA?x"D 2NsO5( O:6O:O?'Pcd^#SSKJm#Jn SSKJn SSKJn SSKJn UR(a UR$U#4SjnURn[U5nUS:Xa:USR5n U S:Xa U"/5S$U"S5upT#"XU -/5$UR5S :aURSUS-S -n O/n [U 5n U R5n[UR5nURU 5n[U5n[![U55Vs/sHnS U-PM nnU"S R#U55Sn [!U5Vs/sHnU RUPM nnU"XURUS S9nU"UR$5nT#"U U5nU"UUURU5nU"U/5n[!U5Vs/sH nS/S U--PM snUlS/U-nUR(US'[!S U-5HnSUR&SU'M Sn[+[!U5[!S U-55Hvunn UUU nUU:XdMURU S -SU S ---nUUU-UU'UUR&UU 'UUR&UU SU S ---'US- nUU:XdMv O [-[!U55UlS=nn UR15(GdUR&UU UUU :Xa7U S-S U--n U S:XaUS-U-nUR&UU UUU :XaM7URU S -SU S ---nUUU-UUUU S--nU"U5n UR(n!U R3U SS9Hn"U!UR5U"5S--n!M UU!-nU"UU/5nUR7SU5 UR9/SUUSS9nUR15(dGMU"U5Ul UR$s snfs snfs snf)zb Return an `FpGroup` presentation of the group. The algorithm is described in [1], Chapter 6.1. rr9) CosetTabler<)r>c>[UT5(a@URUR5 T"UR[ [ U555$T"X5$r+)r,rrelatorsr=r:r{)rar3r:s r0_factor_group_by_rels._factor_group_by_relssD!W%% AJJ'q||T#d)_==1# #rjr9rrOrr@rAF)rRNrTrrr.)strategydraft max_cosets incomplete)rBr:r;sympy.combinatorics.coset_tablerZrCr=rr>rer|r?rr& presentationr.r>rDr\r)rrr:r is_completertr- scan_and_fillcoset_enumeration)$rgeliminate_gensr;rZr=r>r]rlen_grrJr half_gensrH_plen_hrrrFrIrFrr3G_prC_pr2rr+r,rr5rrrvr:s$ @r0rdPermutationGroup.presentation sL C>>B  (( ( $ D  A:GMMOEz!"~a((c?DA1%xj) ) ::<" 57Q,7II Y 'nnCNN#   Q  F(-c$i(89(81VAX(89 tyy* +A .,1<8D))D/!$$ 2 ..A&"A7C!$'+K$ ,CR,GGGW:D,,C(((=!((1+r/)>ckG(gY7C   a )'']&)aD(JC'//##,!6c :$$$A:99s$P#P(P-c:SSKJn UR(d [S5eUR 5n/n/n/nUR US5 UR 5 [[U5S- 5HnX&nX&S-RHnX;dM [U/UR-5nURSU5 URSU5 USR5n USR5n URSX-5 M M U"XCUSS9$)a Return the PolycyclicGroup instance with below parameters: Explanation =========== * pc_sequence : Polycyclic sequence is formed by collecting all the missing generators between the adjacent groups in the derived series of given permutation group. * pc_series : Polycyclic series is formed by adding all the missing generators of ``der[i+1]`` in ``der[i]``, where ``der`` represents the derived series. * relative_order : A list, computed by the ratio of adjacent groups in pc_series. r)PolycyclicGroupzThe group must be solvablerr9N) collector) sympy.combinatorics.pc_groupsrqr*rrrrr>r?r|r&insertr) rgrqr pc_series pc_sequencerelative_orderrFrrGG1rs r0polycyclic_group!PermutationGroup.polycyclic_group{s & B!!9: :!!#  R! s3xz"AA1X((:(!q||);.!.!`""@HT=~6*X$Lu?n-^Yv'R-^0@11"/b-^3Oj8(tDL  <;|  &@HTP0.$L;z+&+&Z,\=~Qf#%#%J:?x  $1f  $%N##JWJr9x>cBJ$CL&6PO:7 1f+&7:7:t7:7:r  TTl^!^!@3&j1f+ ,'\,@%2w"rFH*.B!H/bM6!!!!F HL&*{Fz0-0-d$(LhTE#N;ztlx,tm%^*Wrjr&c l[US5(dU/nUVs/sHoDRPM nn[U5S:XdUS:XaUUnS/U-nUHnSXx'M UH/n UH&n Xn X{S:XdMURU 5 SX{'M( M1 [ U5$US:Xau[ U5nU/nU1nUHSn UHJn [ U Vs/sHoJUPM sn5n X;dM(URU 5 UR U 5 ML MU [ U5$US:Xa[U5nU/nU1nUHSn UHJn [U Vs/sHoJUPM sn5n X;dM(URU 5 UR U 5 ML MU UVs1sHn[ U5iM sn$gs snfs snfs snfs snf) atCompute the orbit of alpha `\{g(\alpha) | g \in G\}` as a set. Explanation =========== The time complexity of the algorithm used here is `O(|Orb|*r)` where `|Orb|` is the size of the orbit and ``r`` is the number of generators of the group. For a more detailed analysis, see [1], p.78, [2], pp. 19-21. Here alpha can be a single point, or a list of points. If alpha is a single point, the ordinary orbit is computed. if alpha is a list of points, there are three available options: 'union' - computes the union of the orbits of the points in the list 'tuples' - computes the orbit of the list interpreted as an ordered tuple under the group action ( i.e., g((1, 2, 3)) = (g(1), g(2), g(3)) ) 'sets' - computes the orbit of the list interpreted as a sets Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> from sympy.combinatorics.perm_groups import _orbit >>> a = Permutation([1, 2, 0, 4, 5, 6, 3]) >>> G = PermutationGroup([a]) >>> _orbit(G.degree, G.generators, 0) {0, 1, 2} >>> _orbit(G.degree, G.generators, [0, 4], 'union') {0, 1, 2, 3, 4, 5, 6} See Also ======== orbit, orbit_transversal rnr9rFTr|setsN)rNrr?rr{rr frozenset) r7r|r+rWrrr rrrrrs r0rrsJ 5- ( (#- .:aMM:D . 5zQ&G+wv~BDHAv:&JJt$!%DJ  3x 8 e gwAa0a!fa01#JJt$HHTN  3x 6 % gwA !!4!Qa&!!45#JJt$HHTN  #&&#Qa#&& 1 /&1"5'sF"F' ?F, F1c/n[[U55n[U5nU(aHUSn[XU5nUR U5 XF-nUVs/sH oUU;dM UPM nnU(aMHU$s snf)a_Compute the orbits of G. If ``rep=False`` it returns a list of sets else it returns a list of representatives of the orbits Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy.combinatorics.perm_groups import _orbits >>> a = Permutation([0, 2, 1]) >>> b = Permutation([1, 0, 2]) >>> _orbits(a.size, [a, b]) [{0, 1, 2}] r)r:r>r{rr)r7r|rsorted_IrlrFr s r0r`r`sv" DE&M"H H A QKV+ C '8x!C>> from sympy.combinatorics.named_groups import DihedralGroup >>> from sympy.combinatorics.perm_groups import _orbit_transversal >>> G = DihedralGroup(6) >>> _orbit_transversal(G.degree, G.generators, 0, False) [(5), (0 1 2 3 4 5), (0 5)(1 4)(2 3), (0 2 4)(1 3 5), (5)(0 4)(1 3), (0 3)(1 4)(2 5)] FT)r:r>rrrr r@)r7r|r+r:rrurnrrrrpxpx_slprrrrs r0r]r]sOB $uV}% & 'Br{H 76>DDK#- .:aMM:D .C6DzU""&**S/!2V!; 4#!234!  .01bda1gaj/bB1I|  BDAqaB I|!# $A'!*B $  <3 /2  %sD.1D3%D9D?cU/nU[[U550nU[[U550nS/U-nSXb'UVs/sHowRPM nn/n UHvn UHmn Xn XlSLa6[XU 5n UR U 5 XU '[ U 5X\'SXl'MD[ X\XU 5nX;dM\U R U5 Mo Mx U Vs/sHn[U5PM sn$s snfs snf)aReturn the stabilizer subgroup of ``alpha``. Explanation =========== The stabilizer of `\alpha` is the group `G_\alpha = \{g \in G | g(\alpha) = \alpha\}`. For a proof of correctness, see [1], p.79. degree : degree of G generators : generators of G Examples ======== >>> from sympy.combinatorics.perm_groups import _stabilizer >>> from sympy.combinatorics.named_groups import DihedralGroup >>> G = DihedralGroup(6) >>> _stabilizer(G.degree, G.generators, 5) [(5)(0 4)(1 3), (5)] See Also ======== orbit FT)r:r>rr rr r r@)r7r|r+r r) table_invrrrrrrrgen_temprs r0rrTs8 'C Dv' (EU6]+,I 76>DDK#- .:aMM:D .I C6DzU"#Cq2 4 &d ",X"6 ! (#QxH 0$$\2!* * 1GAJ ** / +s C/C4cP\rSrSrSrSrSrSrSr\ S5r \ S5r S r g ) r'izA The class defining the lazy form of SymmetricGroup. deg : int cH[U5n[R"X5nU$r+)rrrB)rCrobjs r0rB!SymmetricPermutationGroup.__new__ssmmmC% rjc:URSUlSUlgrJ)rD_degrLrfs r0rh"SymmetricPermutationGroup.__init__sIIaL  rjc[U[5(d[S[U5-5eURUR :H$)zReturn ``True`` if *i* is contained in SymmetricPermutationGroup. Examples ======== >>> from sympy.combinatorics import Permutation, SymmetricPermutationGroup >>> G = SymmetricPermutationGroup(4) >>> Permutation(1, 2, 3) in G True z[A SymmetricPermutationGroup contains only Permutations as elements, not elements of type %s)r,rrqrrr5r7rms r0rt&SymmetricPermutationGroup.__contains__sF![))@BFq'JK Kvv$$rjcURb UR$URn[U5UlUR$)z Return the order of the SymmetricPermutationGroup. Examples ======== >>> from sympy.combinatorics import SymmetricPermutationGroup >>> G = SymmetricPermutationGroup(4) >>> G.order() 24 )rLrr)rgrs r0rSymmetricPermutationGroup.orders6 ;; ";;  IIl {{rjcUR$)z Return the degree of the SymmetricPermutationGroup. Examples ======== >>> from sympy.combinatorics import SymmetricPermutationGroup >>> G = SymmetricPermutationGroup(4) >>> G.degree 4 )rrws r0r7 SymmetricPermutationGroup.degreesyyrjcP[[[UR555$)z Return the identity element of the SymmetricPermutationGroup. Examples ======== >>> from sympy.combinatorics import SymmetricPermutationGroup >>> G = SymmetricPermutationGroup(4) >>> G.identity() (3) )r@r:r>rrws r0r"SymmetricPermutationGroup.identitystE$)),-..rj)rrLN) rrrrrrBrhrtrrr7rrrrjr0r'r'sC  %"$   / /rjr'cN\rSrSrSrS SjrSr\S5r\S5r Sr S r g) riaA left coset of a permutation group with respect to an element. Parameters ========== g : Permutation H : PermutationGroup dir : "+" or "-", If not specified by default it will be "+" here ``dir`` specified the type of coset "+" represent the right coset and "-" represent the left coset. G : PermutationGroup, optional The group which contains *H* as its subgroup and *g* as its element. If not specified, it would automatically become a symmetric group ``SymmetricPermutationGroup(g.size)`` and ``SymmetricPermutationGroup(H.degree)`` if ``g.size`` and ``H.degree`` are matching.``SymmetricPermutationGroup`` is a lazy form of SymmetricGroup used for representation purpose. Nc8[U5n[U[5(d[e[U5n[U[5(d[eUb|[U5n[U[[ 45(d[eUR U5(d[SRX#55eX;a[SRX55eOLURnURnXV:wa[SRX55e[ UR5n[U[5(a [U5nO,[U[5(d[S[U5-5e[U5S;a[SU-5e[R "XX#U5nU$)Nz{} must be a subgroup of {}.z{} must be an element of {}.z]The size of the permutation {} and the degree of the permutation group {} should be matching z0dir must be of type basestring or Symbol, not %s)r-z$dir must be one of '+' or '-' not %s)rr,rrr&r'rrrr5r7strrrqrrrrB)rCrGrrarg_sizeh_degreers r0rB Coset.__new__se QK![))% % QK!-..% % = Aa"24M!NOO))==## !?!F!Fq!LMMz !?!F!Fq!LMMVVFxxH! CVA\##*!&&1A c3  +CC((%'+Cy12 2 s8: %CcIJ JmmCA#. rjc,URSUlg)N)rD_dirrfs r0rhCoset.__init__sIIaL rjc2[UR5S:H$)a Check if the coset is left coset that is ``gH``. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup, Coset >>> a = Permutation(1, 2) >>> b = Permutation(0, 1) >>> G = PermutationGroup([a, b]) >>> cst = Coset(a, G, dir="-") >>> cst.is_left_coset True rrrrws r0 is_left_cosetCoset.is_left_coset "499~$$rjc2[UR5S:H$)a! Check if the coset is right coset that is ``Hg``. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup, Coset >>> a = Permutation(1, 2) >>> b = Permutation(0, 1) >>> G = PermutationGroup([a, b]) >>> cst = Coset(a, G, dir="+") >>> cst.is_right_coset True rrrws r0is_right_cosetCoset.is_right_coset3rrjcURSnURSn/n[UR5S:Xa(URHnUR XA-5 M U$URHnUR X-5 M U$)z7 Return all the elements of coset in the form of list. rr9r)rDrrr r)rgrGrcstrs r0as_list Coset.as_listFsw IIaL IIaL tyy>S ZZ 13  ZZ 13  rj)r)Nr) rrrrrrBrhrrrrrrrjr0rrs?2#J!%%$%%$ rjrNr{r)<mathrrrr itertoolsrrsympy.combinatoricsr sympy.combinatorics.permutationsr r r r r rsympy.combinatorics.utilrrrrrrrr sympy.corersympy.core.randomrrrsympy.core.symbolrsympy.core.sympifyr(sympy.functions.combinatorial.factorials sympy.ntheoryrrsympy.ntheory.factor_rr sympy.ntheory.primetestr!sympy.utilities.iterablesr"r#r$ rmul_with_afrr@r&rr`r]rrr'rrrjr0rs33$,));;$'>-;+DD   KNWuKNW\\J'Z<>B0+f  Q/Q/huEurj