\h<%SSKJr SSKJr SSKJr SSKJrJr SSK J r SSK J r SSKJr SSKJrJr SS KJr SS KJr \S 5r\S 5r\S 5rSr0rS\S'"SS\ 5r"SS\ \ \5rSr Sr!g)) annotations)S)Expr)Symbolsymbols) CantSympify)DefaultPrinting)public)flatten is_sequence)pollute)as_intcJ[U5nU4[UR5-$)aConstruct a free group returning ``(FreeGroup, (f_0, f_1, ..., f_(n-1))``. Parameters ========== symbols : str, Symbol/Expr or sequence of str, Symbol/Expr (may be empty) Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y, z = free_group("x, y, z") >>> F >>> x**2*y**-1 x**2*y**-1 >>> type(_) ) FreeGrouptuple generatorsr _free_groups W/var/www/auris/envauris/lib/python3.13/site-packages/sympy/combinatorics/free_groups.py free_grouprs&,G$K >E+"8"89 99c2[U5nXR4$)aConstruct a free group returning ``(FreeGroup, (f_0, f_1, ..., f_(n-1)))``. Parameters ========== symbols : str, Symbol/Expr or sequence of str, Symbol/Expr (may be empty) Examples ======== >>> from sympy.combinatorics.free_groups import xfree_group >>> F, (x, y, z) = xfree_group("x, y, z") >>> F >>> y**2*x**-2*z**-1 y**2*x**-2*z**-1 >>> type(_) )rrrs r xfree_groupr's,G$K // 00rc[U5n[URVs/sHo"RPM snUR5 U$s snf)aConstruct a free group and inject ``f_0, f_1, ..., f_(n-1)`` as symbols into the global namespace. Parameters ========== symbols : str, Symbol/Expr or sequence of str, Symbol/Expr (may be empty) Examples ======== >>> from sympy.combinatorics.free_groups import vfree_group >>> vfree_group("x, y, z") >>> x**2*y**-2*z # noqa: F821 x**2*y**-2*z >>> type(_) )rr rnamer)rrsyms r vfree_groupr@sB,G$K !4!4 5!4#XX!4 5{7M7MN  6sAc8U(dg[U[5(a [USS9$[U[[45(aU4$[ U5(a;[ SU55(a [U5$[ SU55(aU$[S5e)NT)seqc3B# UHn[U[5v M g7fN) isinstancestr.0ss r !_parse_symbols..cs37az!S!!7c3B# UHn[U[5v M g7fr")r#rr%s rr(r)es6gAt$$gr*zjThe type of `symbols` must be one of the following: a str, Symbol/Expr or a sequence of one of these types)r#r$_symbolsrFreeGroupElementr all ValueErrorrs r_parse_symbolsr1[s '3T** Gd$45 6 6z W   373 3 3G$ $ 6g6 6 6N * ++rzdict[int, FreeGroup]_free_group_cachec\rSrSr%SrSrSrSrSr/r S\ S'Sr Sr S r S rSS jrS rSrSrSr\rSrSrSrSr\S5r\S5r\S5r\S5rSrSrSr g )rraV Free group with finite or infinite number of generators. Its input API is that of a str, Symbol/Expr or a sequence of one of these types (which may be empty) See Also ======== sympy.polys.rings.PolyRing References ========== .. [1] https://www.gap-system.org/Manuals/doc/ref/chap37.html .. [2] https://en.wikipedia.org/wiki/Free_group TFz list[Expr]relatorscf[[U55n[U5n[URX45n[ R U5nUc[RU5nX4l X$l [S[4SU05Ul XlUR5Ul[#UR 5Ul['URUR 5HFupV[)U[*5(dMUR,n[/XG5(dM:[1XGU5 MH U[ U'U$)Nr-group)rr1lenhash__name__r2getobject__new___hash_ranktyper-dtyper _generatorsrset _gens_setzipr#rrhasattrsetattr)clsrrankr>objsymbol generatorrs rr=FreeGroup.__new__sw/07|cllG23##E* ;..%CII/2B1DwPSnUCI!K __.CN/CM%(cnn%E!ff--!;;Ds))95 &F (+ e $ rcUR4$)zdReturn a tuple of arguments that must be passed to __new__ in order to support pickling this object.r0selfs r__getnewargs__FreeGroup.__getnewargs__s rcgr"rrOs r __getstate__FreeGroup.__getstate__src/nURH(nUS44nURURU55 M* [U5$)zReturns the generators of the FreeGroup. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y, z = free_group("x, y, z") >>> F.generators (x, y, z) )rappendrAr)r7gensrelms rrBFreeGroup._generatorssC==C8+C KK C( )!T{rNcJURU=(d UR5$r") __class__r)rPrs rcloneFreeGroup.clones~~g566rcN[U[5(dgURnX:H$)z/Return True if ``i`` is contained in FreeGroup.Fr#r-r7)rPir7s r __contains__FreeGroup.__contains__s$!-..}rcUR$r"r>rOs r__hash__FreeGroup.__hash__s zzrcUR$r"rIrOs r__len__FreeGroup.__len__s yyrcURS:aSUR-nU$SnURnU[U5S-- nU$)Nzz)rIrr$)rPstr_formrYs r__str__FreeGroup.__str__sI 99r>8499DH 8H??D D C 'Hrc>URUnURUS9$)Nr0)rr^)rPindexrs r __getitem__FreeGroup.__getitem__s!,,u%zz'z**rcXL$)z@No ``FreeGroup`` is equal to any "other" ``FreeGroup``. rrPothers r__eq__FreeGroup.__eq__s }rc[XR5(aURRU5$[ SU<SU<35e)zReturn the index of the generator `gen` from ``(f_0, ..., f_(n-1))``. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> F.index(y) 1 >>> F.index(x) 0 z#expected a generator of Free Group z, got )r#rArrtr/rPgens rrtFreeGroup.indexs: c:: & &??((- -PTVYZ[ [rcbURS:Xa[R$[R$)zReturn the order of the free group. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> F.order() oo >>> free_group("")[0].order() 1 r)rIrOneInfinityrOs rorderFreeGroup.orders" 99>55L:: rcRURS:Xa UR1$[S5e)z Return the elements of the free group. Examples ======== >>> from sympy.combinatorics import free_group >>> (z,) = free_group("") >>> z.elements {} rzDGroup contains infinitely many elements, hence cannot be represented)rIidentityr/rOs relementsFreeGroup.elements s- 99>MM? "<= =rcUR$)z In group theory, the `rank` of a group `G`, denoted `G.rank`, can refer to the smallest cardinality of a generating set for G, that is \operatorname{rank}(G)=\min\{ |X|: X\subseteq G, \left\langle X\right\rangle =G\}. )r?rOs rrIFreeGroup.rankszzrc URS;$)zReturns if the group is Abelian. Examples ======== >>> from sympy.combinatorics import free_group >>> f, x, y, z = free_group("x y z") >>> f.is_abelian False )rrWrjrOs r is_abelianFreeGroup.is_abelian*syyF""rc"UR5$)z+Returns the identity element of free group.)rArOs rrFreeGroup.identity9szz|rcP[U[5(dgXR:wagg)a!Tests if Free Group element ``g`` belong to self, ``G``. In mathematical terms any linear combination of generators of a Free Group is contained in it. Examples ======== >>> from sympy.combinatorics import free_group >>> f, x, y, z = free_group("x y z") >>> f.contains(x**3*y**2) True FTra)rPgs rcontainsFreeGroup.contains>s$!-.. WW_rcUR1$)z,Returns the center of the free group `self`.)rrOs rcenterFreeGroup.centerTs rrr")!r: __module__ __qualname____firstlineno____doc__is_associativeis_group is_FreeGroupis_PermutationGroupr5__annotations__r=rQrTrBr^rcrgrkrq__repr__rurzrtrpropertyrrIrrrr__static_attributes__rrrrrrs$NHLHj2$7H+ \&(==(   # #,rrc\rSrSrSrSrSrSrSrSr Sr \ S 5r \ S 5r \ S 5rS rS r\ S5r\ S5rSrSr\rSrSrSrSrSrSrSrSrS6SjrS7SjrSr Sr!Sr"Sr#S r$S!r%S"r&S#r'S8S$jr(S9S%jr)S&r*S'r+S(r,S)r-S*r.S+r/S,r0S-r1S.r2S/r3S0r4S1r5S2r6S:S3jr7S4r8S5r9g);r-i^zUsed to create elements of FreeGroup. It cannot be used directly to create a free group element. It is called by the `dtype` method of the `FreeGroup` class. rTc$URU5$r")r])rPinits rnewFreeGroupElement.newgs~~d##rNcURnUc0[UR[[ U5545=UlnU$r")r>r9r7 frozensetr)rPr>s rrgFreeGroupElement.__hash__ls8  =!%tzz9U4[3I&J!K KDJ rc$URU5$r")rrOs rcopyFreeGroupElement.copyrsxx~rc$UR(+$r" array_formrOs r is_identityFreeGroupElement.is_identityus??""rc[U5$)aC SymPy provides two different internal kinds of representation of associative words. The first one is called the `array_form` which is a tuple containing `tuples` as its elements, where the size of each tuple is two. At the first position the tuple contains the `symbol-generator`, while at the second position of tuple contains the exponent of that generator at the position. Since elements (i.e. words) do not commute, the indexing of tuple makes that property to stay. The structure in ``array_form`` of ``FreeGroupElement`` is of form: ``( ( symbol_of_gen, exponent ), ( , ), ... ( , ) )`` Examples ======== >>> from sympy.combinatorics import free_group >>> f, x, y, z = free_group("x y z") >>> (x*z).array_form ((x, 1), (z, 1)) >>> (x**2*z*y*x**2).array_form ((x, 2), (z, 1), (y, 1), (x, 2)) See Also ======== letter_repr )rrOs rrFreeGroupElement.array_formys@T{rc [[URVVs/sHupUS:aU4U-OU*4U*-PM snn55$s snnf)a The letter representation of a ``FreeGroupElement`` is a tuple of generator symbols, with each entry corresponding to a group generator. Inverses of the generators are represented by negative generator symbols. Examples ======== >>> from sympy.combinatorics import free_group >>> f, a, b, c, d = free_group("a b c d") >>> (a**3).letter_form (a, a, a) >>> (a**2*d**-2*a*b**-4).letter_form (a, a, -d, -d, a, -b, -b, -b, -b) >>> (a**-2*b**3*d).letter_form (-a, -a, b, b, b, d) See Also ======== array_form rrr r)rPrbjs r letter_formFreeGroupElement.letter_formsY4W $1 /)*Aqd1fQB51":= /123 31s AcURnURUnUR(aURUS445$URU*S445$)NrWr7r is_SymbolrA)rPrbr7rs rruFreeGroupElement.__getitem__sN    Q  ;;;;Ay) );;!R{+ +rc[U5S:wa [5eURRURS5$)NrWr)r8r/rrtr}s rrtFreeGroupElement.indexs5 s8q=,   ''(:;;rcURnURnUVs/sH=nUR(aURUS445OURU*S445PM? sn$s snf)z rWrr)rPr7rrZs rletter_form_elm FreeGroupElement.letter_form_elmsk    :;=:;3,/== c!WJ'[[C4)./:;= ==sAA$c>[[UR55$)zKThis is called the External Representation of ``FreeGroupElement`` rrOs rext_repFreeGroupElement.ext_repsWT__-..rcURSS[URVs/sHo"SPM sn5;$s snf)Nr)rr)rPr~rs rrcFreeGroupElement.__contains__s8~~a #uDOO-LOqdO-L'MMM-Ls< cUR(agSnURn[[U55HnU[U5S- :XaIX#SS:XaU[ X#S5- nM5U[ X#S5S-[ X#S5-- nM^X#SS:XaU[ X#S5S-- nMU[ X#S5S-[ X#S5-S-- nM U$)Nz rWrz***)rrranger8r$)rPrprrbs rrqFreeGroupElement.__str__s    __ s:'AC Oa''=#q(JM!$4 55HJM!$4 5$(!)+.z}Q/?+@!AAH=#q(JM!$4 5 ;;HJM!$4 5$(!)+.z}Q/?+@!ACF!GGH(rc[U5nURRnUS:XaU$US:aU*nUR5nOUnUS-(aX#-nUS-nU(dU$X3-nM#)NrrW)rr7rinverse)rPnresultxs r__pow__FreeGroupElement.__pow__sw 1I$$ 6M q5A AA1u  !GA  FA rclURn[XR5(d [S5eUR(aU$UR(aU$[ UR UR -5n[U[UR 5S- 5 UR[U55$)zReturns the product of elements belonging to the same ``FreeGroup``. Examples ======== >>> from sympy.combinatorics import free_group >>> f, x, y, z = free_group("x y z") >>> x*y**2*y**-4 x*y**-2 >>> z*y**-2 z*y**-2 >>> x**2*y*y**-1*x**-2 ;only FreeGroup elements of same FreeGroup can be multipliedrW) r7r#rA TypeErrorrlistr zero_mul_simpr8r)rPryr7rs r__mul__FreeGroupElement.__mul__s  %--$% %   L   K 5#3#33 4aT__-12{{58$$rcURn[XR5(d [S5eXR 5-$Nrr7r#rArrrPryr7s r __truediv__FreeGroupElement.__truediv__s; %--$% %]]_%%rcURn[XR5(d [S5eXR 5-$rrrs r __rtruediv__FreeGroupElement.__rtruediv__$s; %--$% %lln%%rc[$r")NotImplementedrxs r__add__FreeGroupElement.__add__+srcURn[URSSS2VVs/sH up#X#*4PM snn5nURU5$s snnf)z Returns the inverse of a ``FreeGroupElement`` element Examples ======== >>> from sympy.combinatorics import free_group >>> f, x, y, z = free_group("x y z") >>> x.inverse() x**-1 >>> (x*y).inverse() y**-1*x**-1 Nr)r7rrrA)rPr7rbrrs rrFreeGroupElement.inverse.sN  ttt'<='{{1~>sA cdUR(a[R$[R$)zFind the order of a ``FreeGroupElement``. Examples ======== >>> from sympy.combinatorics import free_group >>> f, x, y = free_group("x y") >>> (x**2*y*y**-1*x**-2).order() 1 )rrrrrOs rrFreeGroupElement.orderAs    55L:: rcURn[XR5(d [S5eUR 5UR 5-U-U-$)z? Return the commutator of `self` and `x`: ``~x*~self*x*self`` z@commutator of only FreeGroupElement of the same FreeGroup exists)r7r#rAr/rrs r commutatorFreeGroupElement.commutatorRsQ  %--'( (<<>%--/1$6u< >> from sympy.combinatorics import free_group >>> f, x, y = free_group("x y") >>> w = x**5*y*x**2*y**-4*x >>> w.eliminate_word( x, x**2 ) x**10*y*x**4*y**-4*x**2 >>> w.eliminate_word( x, y**-1 ) y**-11 >>> w.eliminate_word(x**5) y*x**2*y**-4*x >>> w.eliminate_word(x*y, y) x**4*y*x**2*y**-4*x See Also ======== substituted_word rFrWrTr)r7ris_independentr8 subword_indexr/subwordr) rPr~byrrwordlrbks rrFreeGroupElement.eliminate_wordxs: :$$B   s # #syK ;I 7b=D H ""3'AA||Aq!"%' QS#d)(D(S(STW(\\ &&sT7&K KK   &&sBw/     s*CD C66 DD DD c&[SU55$)z For an associative word `self`, returns the number of letters in it. Examples ======== >>> from sympy.combinatorics import free_group >>> f, a, b = free_group("a b") >>> w = a**5*b*a**2*b**-4*a >>> len(w) 13 >>> len(a**17) 17 >>> len(w**0) 0 c3<# UHup[U5v M g7fr"abs)r&rbrs rr(+FreeGroupElement.__len__..s-fq3q66s)sumrOs rrkFreeGroupElement.__len__s$----rczURn[XR5(dg[R X5$)a Two associative words are equal if they are words over the same alphabet and if they are sequences of the same letters. This is equivalent to saying that the external representations of the words are equal. There is no "universal" empty word, every alphabet has its own empty word. Examples ======== >>> from sympy.combinatorics import free_group >>> f, swapnil0, swapnil1 = free_group("swapnil0 swapnil1") >>> f >>> g, swap0, swap1 = free_group("swap0 swap1") >>> g >>> swapnil0 == swapnil1 False >>> swapnil0*swapnil1 == swapnil1/swapnil1*swapnil0*swapnil1 True >>> swapnil0*swapnil1 == swapnil1*swapnil0 False >>> swapnil1**0 == swap0**0 False F)r7r#rArrzrs rrzFreeGroupElement.__eq__s.< %--||D((rcURn[XR5(d [S5e[ U5n[ U5nX4:agX4:ag[ U5HnXR SnXR SnURRUS5nURRUS5n X:a gX:a gUSUS:a gUSUS:dM g g)a The ordering of associative words is defined by length and lexicography (this ordering is called short-lex ordering), that is, shorter words are smaller than longer words, and words of the same length are compared w.r.t. the lexicographical ordering induced by the ordering of generators. Generators are sorted according to the order in which they were created. If the generators are invertible then each generator `g` is larger than its inverse `g^{-1}`, and `g^{-1}` is larger than every generator that is smaller than `g`. Examples ======== >>> from sympy.combinatorics import free_group >>> f, a, b = free_group("a b") >>> b < a False >>> a < a.inverse() False 9only FreeGroup elements of same FreeGroup can be comparedTFrrW) r7r#rArr8rrrrt) rPryr7rmrbabpqs r__lt__FreeGroupElement.__lt__s, %--+, , I J 5 UqA""1%A##A&A ##AaD)A ##AaD)Au1!1!rc X:H=(d X:$r"rrxs r__le__FreeGroupElement.__le__s -.rcnURn[XR5(d [S5eX::+$)z Examples ======== >>> from sympy.combinatorics import free_group >>> f, x, y, z = free_group("x y z") >>> y**2 > x**2 True >>> y*z > z*y False >>> x > x.inverse() True r)r7r#rArrs r__gt__FreeGroupElement.__gt__s7  %--+, ,  rc X:+$r"rrxs r__ge__FreeGroupElement.__ge__3s rc^[U5S:wa [S5eURSmTS[U4SjUR55-$)a For an associative word `self` and a generator or inverse of generator `gen`, ``exponent_sum`` returns the number of times `gen` appears in `self` minus the number of times its inverse appears in `self`. If neither `gen` nor its inverse occur in `self` then 0 is returned. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> w = x**2*y**3 >>> w.exponent_sum(x) 2 >>> w.exponent_sum(x**-1) -2 >>> w = x**2*y**4*x**-3 >>> w.exponent_sum(x) -1 See Also ======== generator_count rWz1gen must be a generator or inverse of a generatorrc3H># UHoSTS:XdMUSv M g7frrWNrr&rbr's rr(0FreeGroupElement.exponent_sum..Ts#Fo11!os" ")r8r/rr rPr~r's @r exponent_sumFreeGroupElement.exponent_sum6sH6 s8q=PQ Q NN1 tCFdooFFFFrc^[U5S:wdURSSS:a [S5eURSmTS[U4SjUR55-$)ah For an associative word `self` and a generator `gen`, ``generator_count`` returns the multiplicity of generator `gen` in `self`. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> w = x**2*y**3 >>> w.generator_count(x) 2 >>> w = x**2*y**4*x**-3 >>> w.generator_count(x) 5 See Also ======== exponent_sum rWrzgen must be a generatorc3Z># UH oSTS:XdM[US5v M" g7fr#rr$s rr(3FreeGroupElement.generator_count..qs)K?adadl AaD ?s++)r8rr/r r&s @rgenerator_count FreeGroupElement.generator_countVs]0 s8q=CNN1-a01467 7 NN1 tCK4??KKKKrc URnU(d![US5n[[U5U5nUS:dU[U5:a [ S5eX!::a UR $UR Xn[XT5nURU5$)ak For an associative word `self` and two positive integers `from_i` and `to_j`, `subword` returns the subword of `self` that begins at position `from_i` and ends at `to_j - 1`, indexing is done with origin 0. Examples ======== >>> from sympy.combinatorics import free_group >>> f, a, b = free_group("a b") >>> w = a**5*b*a**2*b**-4*a >>> w.subword(2, 6) a**3*b rzT`from_i`, `to_j` must be positive and no greater than the length of associative word) r7maxminr8r/rrletter_form_to_array_formrA)rPfrom_ito_jstrictr7rrs rrFreeGroupElement.subwordss  ^Fs4y$'D A:D )56 6 >>> !**68K2;FJ;;z* *rc[U5nURnURnSn[U[U5U- S-5HnXGXs-U:XdMUn O UbU$[S5e)z Find the index of `word` in `self`. Examples ======== >>> from sympy.combinatorics import free_group >>> f, a, b = free_group("a b") >>> w = a**2*b*a*b**3 >>> w.subword_index(a*b*a*b) 1 NrWz'The given word is not a subword of self)r8rrr/)rPrstartrself_lfword_lfrtrbs rrFreeGroupElement.subword_indexsu I""""uS\!^A-.A~(/  LFG GrcURU5SL$![a Of=fURUS-5SL$![a gf=f)a3 Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> (x**4*y**-3).is_dependent(x**4*y**-2) True >>> (x**2*y**-1).is_dependent(x*y) False >>> (x*y**2*x*y**2).is_dependent(x*y**2) True >>> (x**12).is_dependent(x**-4) True See Also ======== is_independent NrF)rr/rPrs r is_dependentFreeGroupElement.is_dependents`, %%d+47 7    %%dBh/t; ;  s ""< A A c.URU5(+$)z# See Also ======== is_dependent )r=r<s rrFreeGroupElement.is_independents$$T***rcURnURVs1sHo!RUSS445iM nnU$s snf)z Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y, z = free_group("x, y, z") >>> (x**2*y**-1).contains_generators() {x, y} >>> (x**3*z).contains_generators() {x, z} rrW)r7rrA)rPr7syllablerYs rcontains_generators$FreeGroupElement.contains_generatorssC AEQX hqk1-/0Q Rs ?cURn[U5nURn[X- 5nX:aXU--nX$U--nX!- nXQUn[X$- 5S- n XU -USXt- U-XI-- -- n[ X5nUR U5$)NrW)r7r8rintr1rA) rPr2r3r7rrperiod1diffrperiod2s rcyclic_subwordFreeGroupElement.cyclic_subwords  I&& fh- ; i F gI D}4(df+/ G#k2J46&=3J&KKK(5{{4  rc [[U55Vs1sHoRX[U5-5iM! sn$s snf)aReturns a words which are cyclic to the word `self`. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> w = x*y*x*y*x >>> w.cyclic_conjugates() {x*y*x**2*y, x**2*y*x*y, y*x*y*x**2, y*x**2*y*x, x*y*x*y*x} >>> s = x*y*x**2*y*x >>> s.cyclic_conjugates() {x**2*y*x**2*y, y*x**2*y*x**2, x*y*x**2*y*x} References ========== .. [1] https://planetmath.org/cyclicpermutation )rr8rJrPrbs rcyclic_conjugates"FreeGroupElement.cyclic_conjugatess9*>C3t9=MN=M##AT{3=MNNNs&Acl[U5n[U5nX#:wagUR5nUR5nURnURnSR[ [ U55nSR[ [ U55n [U5[U 5:wagXS-U -;$)a* Checks whether words ``self``, ``w`` are cyclic conjugates. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> w1 = x**2*y**5 >>> w2 = x*y**5*x >>> w1.is_cyclic_conjugate(w2) True >>> w3 = x**-1*y**5*x**-1 >>> w3.is_cyclic_conjugate(w2) False F )r8identity_cyclic_reductionrjoinmapr$) rPwl1l2w1w2letter1letter2str1str2s ris_cyclic_conjugate$FreeGroupElement.is_cyclic_conjugate s$Y V 8  + + -  ( ( *....xxC)*xxC)* t9D !czD(((rc,[UR5$)zReturns the number of syllables of the associative word `self`. Examples ======== >>> from sympy.combinatorics import free_group >>> f, swapnil0, swapnil1 = free_group("swapnil0 swapnil1") >>> (swapnil1**3*swapnil0*swapnil1**-1).number_syllables() 3 )r8rrOs rnumber_syllables!FreeGroupElement.number_syllables.s4??##rc&URUS$)z Returns the exponent of the `i`-th syllable of the associative word `self`. Examples ======== >>> from sympy.combinatorics import free_group >>> f, a, b = free_group("a b") >>> w = a**5*b*a**2*b**-4*a >>> w.exponent_syllable( 2 ) 2 rWrrMs rexponent_syllable"FreeGroupElement.exponent_syllable<q!!$$rc&URUS$)a  Returns the symbol of the generator that is involved in the i-th syllable of the associative word `self`. Examples ======== >>> from sympy.combinatorics import free_group >>> f, a, b = free_group("a b") >>> w = a**5*b*a**2*b**-4*a >>> w.generator_syllable( 3 ) b rrrMs rgenerator_syllable#FreeGroupElement.generator_syllableMrfrc[U[5(a[U[5(d [S5eURnX!::a UR$[ UR X5nURU5$)a `sub_syllables` returns the subword of the associative word `self` that consists of syllables from positions `from_to` to `to_j`, where `from_to` and `to_j` must be positive integers and indexing is done with origin 0. Examples ======== >>> from sympy.combinatorics import free_group >>> f, a, b = free_group("a, b") >>> w = a**5*b*a**2*b**-4*a >>> w.sub_syllables(1, 2) b >>> w.sub_syllables(3, 3) z!both arguments should be integers)r#rFr/r7rrrrA)rPr2r3r7rs r sub_syllablesFreeGroupElement.sub_syllables^sb&&#&&js.C.C@A A  >>> !doof34A;;q> !rc[U5nX:d X:dX$:a [S5eUS:XaX$:XaU$US:XaX0RX$5-$X$:XaURSU5U-$URSU5U-URX$5-$)a Returns the associative word obtained by replacing the subword of `self` that begins at position `from_i` and ends at position `to_j - 1` by the associative word `by`. `from_i` and `to_j` must be positive integers, indexing is done with origin 0. In other words, `w.substituted_word(w, from_i, to_j, by)` is the product of the three words: `w.subword(0, from_i)`, `by`, and `w.subword(to_j len(w))`. See Also ======== eliminate_word zvalues should be within boundsr)r8r/r)rPr2r3rlws rsubstituted_word!FreeGroupElement.substituted_wordzs Y >V[DI=> > Q;4:I q[ll4,, , Z<<6*2- -<<6*2-dll4.DD Drc.U(dgUSUSS-:g$)aReturns whether the word is cyclically reduced or not. A word is cyclically reduced if by forming the cycle of the word, the word is not reduced, i.e a word w = `a_1 ... a_n` is called cyclically reduced if `a_1 \ne a_n^{-1}`. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> (x**2*y**-1*x**-1).is_cyclically_reduced() False >>> (y*x**2*y**2).is_cyclically_reduced() True TrrrrOs ris_cyclically_reduced&FreeGroupElement.is_cyclically_reduceds!"Aw$r(B,&&rcUR5nURnUR5(dURS5nURS5nX4-nUS:Xa!URSUR 5S- nO7UR S5X4-44URSUR 5S- -nURU5nUR5(dMU$)a\Return a unique cyclically reduced version of the word. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> (x**2*y**2*x**-1).identity_cyclic_reduction() x*y**2 >>> (x**-3*y**-1*x**5).identity_cyclic_reduction() x**2*y**-1 References ========== .. [1] https://planetmath.org/cyclicallyreduced rrrW)rr7rrrdrrarhrA)rPrr7exp1exp2rreps rrR*FreeGroupElement.identity_cyclic_reductions&yy{ ,,..))!,D))"-D AAvooa)>)>)@1)DE//2DK@B4+@+@+BQ+FGH;;s#D,,.. rcUR5nURRnUR5(d[ UR S55n[ UR S55n[ XE5nUS[ U5-nUS[ U5-nUS-U-US--nX7-nUR5(dMU(aX#4$U$)aReturn a cyclically reduced version of the word. Unlike `identity_cyclic_reduction`, this will not cyclically permute the reduced word - just remove the "unreduced" bits on either side of it. Compare the examples with those of `identity_cyclic_reduction`. When `removed` is `True`, return a tuple `(word, r)` where self `r` is such that before the reduction the word was either `r*word*r**-1`. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> (x**2*y**2*x**-1).cyclic_reduction() x*y**2 >>> (x**-3*y**-1*x**5).cyclic_reduction() y**-1*x**2 >>> (x**-3*y**-1*x**5).cyclic_reduction(removed=True) (y**-1*x**2, x**-3) rr)rr7rrrr rdr0) rPremovedrrrurvexpr7ends rcyclic_reduction!FreeGroupElement.cyclic_reductions0yy{ JJ  ,,..t--a01Dt--b12Dd/CGSX%Er(CH$C"9T>#r')DA,,.. 7N rc0UR(ag[U5nUS:Xa:UR5nX;=(d US-U;n[U5S:H=(a U$URSS9upVUR(d(URSS9upXg:XaUR U5$g[U5U:d[U5U-(agUR SU5nX:Xd US-U:Xa,UR U[U55n U R U5$g)z Check if `self == other**n` for some integer n. Examples ======== >>> from sympy.combinatorics import free_group >>> F, x, y = free_group("x, y") >>> ((x*y)**2).power_of(x*y) True >>> (x**-3*y**-2*x**3).power_of(x**-3*y*x**3) True TrWr)rzFr)rr8rCr}power_ofr) rPryrrYr'reducedr1r2prefixrests rrFreeGroupElement.power_ofs    J 6++-D 2d!2At9>'a ' ++D+9 ~~..t.rgrrrrrrurtrrrcrqrrrrrrrrrrrrkrzrrrrr'r,rrr=rrCrJrNr^rardrhrkrorrrRr}rrrrrr-r-^sf IM$ E ##B338,< ==// N*H&%8&&&" =49v.(!)F.`/!, G@L:+<H6> +" !O.)B $%"%""8E@'*B$L*rr-c@[USS5n/nSnURn[[U55HnU[U5S- :XaX&X&S- :Xa>X&*U;aUR X&*U*45 Us $UR X&U45 Us $X&*U;aUR X&*S45 Us $UR X&S45 Us $X&X&S-:XaUS- nMX&*U;aUR X&*U*45 OUR X&U45 SnM g)aH This method converts a list given with possible repetitions of elements in it. It returns a new list such that repetitions of consecutive elements is removed and replace with a tuple element of size two such that the first index contains `value` and the second index contains the number of consecutive repetitions of `value`. NrWr)rrrr8rX)rr7r new_arrayrrrbs rr1r1#s> Z]AI AmmG 3q6] A ?tqQxTEg%$$qteaR[1  $$adAY/   TEg%$$qteR[1 $$adAY/  TQ1uX  FA'!  14%!-  !$+A)rc(US:aU[U5S- :ayXSXS-S:XaeXSXS-S-nXSnX24X'XS- XSS:XaX US-nUS:a)U[U5S- :aXSXS-S:XaMbgggggg)z"Used to combine two reduced words.rrWN)r8)rrtr{bases rrrGs !)A *qx{a l1o/MhqkAaiLO+x{; aiL 8A;!  QJE !)A *qx{a l1o/M*)/M*)rN)" __future__r sympy.corersympy.core.exprrsympy.core.symbolrrr,sympy.core.sympifyrsympy.printing.defaultsr sympy.utilitiesr sympy.utilities.iterablesr r sympy.utilities.magicr sympy.utilities.miscrrrrr1r2rrrr-r1rrrrrs" 9*3":)'::01104+*+-',ddXB{OUBJ!H r