Ë ¬¯wg7šãó—UddlmZddlmZddlmZddlmZmZ ddl mZddlm Z ddlmZddlmZmZdd lmZdd lmZed„«Zed„«Zed „«Zd„ZiZded<Gd„de «ZGd„dee e«Zd„Z d„Z!y)é)Úannotations)ÚS)ÚExpr)ÚSymbolÚsymbols)ÚCantSympify)ÚDefaultPrinting)Úpublic)ÚflattenÚis_sequence)Úpollute)Úas_intcóJ—t|«}|ft|j«zS)aàConstruct 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(_) )Ú FreeGroupÚtupleÚ generators©rÚ_free_groups úd/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/combinatorics/free_groups.pyÚ free_grouprs&€ô,˜GÓ$€KØˆ>œE +×"8Ñ"8Ó9Ñ9Ð9ócó4—t|«}||jfS)aýConstruct 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Ø˜×/Ñ/Ð0Ð0rcó–—t|«}t|jDcgc]}|j‘Œc}|j«|Scc}w)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 rÚnamer)rrÚsyms rÚvfree_groupr@s>€ô,˜GÓ$€KÜ ×!4Ñ!4Ö5˜#ˆSX‹XÒ5°{×7MÑ7MÔNØÐùò 6sŸAcó—|syt|t«r t|d¬«St|ttf«r|fSt|«r1t d„|D««rt|«St d„|D««r|Std«‚)N©T)Úseqc3ó<K—|]}t|t«–—Œyw©N)Ú isinstanceÚstr©Ú.0Úss rú z!_parse_symbols..csèø€Ò3 aŒz˜!œS×!Ñ3ùó‚c3ó<K—|]}t|t«–—Œywr")r#rr%s rr(z!_parse_symbols..esèø€Ò6¨”˜Aœt×$Ñ6ùr)zjThe type of `symbols` must be one of the following: a str, Symbol/Expr or a sequence of one of these types)r#r$Ú_symbolsrÚFreeGroupElementrÚallÚ ValueError©rs rÚ_parse_symbolsr0[s}€ÙØÜ'œ3ÔÜ˜ TÔ*Ð*Ü GœdÔ$4Ð5Ô 6ØˆzÐÜ WÔ ÜÑ3¨7Ô3Ô3Ü˜GÓ$Ð$Ü Ñ6¨gÔ6Ô 6ØˆNÜ ð*ó+ð+rzdict[int, FreeGroup]Ú_free_group_cachecóÄ—eZdZUdZdZdZdZdZgZde d<d„Z d„Zdd „Zd „Z d„Zd„Zd „ZeZd„Zd„Zd„Zd„Zed„«Zed„«Zed„«Zed„«Zd„Zd„Zy)ra‚ 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]ÚrelatorscóV—tt|««}t|«}t|j||f«}t j |«}|€Útj|«}||_ ||_ tdtfd|i«|_ ||_|j«|_t#|j «|_t'|j|j «D]<\}}t)|t*«sŒ|j,}t/||«sŒ0t1|||«Œ>|t |<|S)Nr,Úgroup)rr0ÚlenÚhashÚ__name__r1ÚgetÚobjectÚ__new__Ú_hashÚ_rankÚtyper,ÚdtyperÚ_generatorsrÚsetÚ _gens_setÚzipr#rrÚhasattrÚsetattr)ÚclsrÚrankr<ÚobjÚsymbolÚ generatorrs rr;zFreeGroup.__new__‹sý€Üœ wÓ/Ó0ˆÜ7‹|ˆÜc—l‘l G¨TÐ2Ó3ˆÜ×#Ñ# EÓ*ˆàˆ;Ü—.‘. Ó%ˆCØˆCŒIØˆCŒIäÐ/Ô2BÐ1DÀwÐPSÀnÓUˆCŒIØ!ˆCŒKØ Ÿ_™_Ó.ˆCŒNÜ §¡Ó/ˆCŒMÜ%(¨¯©°c·n±nÓ%Eò 6Ñ!˜ Ü˜f¤fÕ-Ø!Ÿ;™;DÜ˜s DÕ)Ü T¨9Õ5ð 6ð(+Ô˜eÑ$àˆ rcóˆ—g}|jD]'}|dff}|j|j|««Œ)t|«S)zçReturns 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) é)rÚappendr?r)r5ÚgensrÚelms rr@zFreeGroup._generators¤sH€ðˆØ—=‘=ò *ˆCØ˜8+ˆCØK‰K˜Ÿ™ CÓ(Õ)ð *ôT‹{ÐrNcó@—|j|xs|j«Sr")Ú __class__r)Úselfrs rÚclonezFreeGroup.clone¶s€Ø~‰~˜gÒ5¨¯©Ó6Ð6rcóF—t|t«sy|j}||k(S)z/Return True if ``i`` is contained in FreeGroup.F©r#r,r5)rRÚir5s rÚ__contains__zFreeGroup.__contains__¹s#€ä˜!Ô-Ô.ØØ—‘ˆØu‰}Ðrcó—|jSr")r<©rRs rÚ__hash__zFreeGroup.__hash__Às€Øz‰zÐrcó—|jSr"©rGrYs rÚ__len__zFreeGroup.__len__Ãs€Øy‰yÐrcó„—|jdkDrd|jz}|Sd}|j}|t|«dzz }|S)Nézz)rGrr$)rRÚstr_formrNs rÚ__str__zFreeGroup.__str__ÆsI€Ø9‰9rŠ>Ø8¸4¿9¹9ÑDˆHð ˆð8ˆHØ—?‘?ˆDØœ˜D› C™Ñ'ˆHØˆrcóD—|j|}|j|¬«S)Nr/)rrS)rRÚindexrs rÚ__getitem__zFreeGroup.__getitem__Ñs!€Ø—,‘,˜uÑ%ˆØz‰z 'ˆzÓ*Ð*rcó —||uS)z@No ``FreeGroup`` is equal to any "other" ``FreeGroup``. r©rRÚothers rÚ__eq__zFreeGroup.__eq__Õs€ðuˆ}Ðrcó†—t||j«r|jj|«St d|›d|›«‚)aReturn 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#r?rrdr.©rRÚgens rrdzFreeGroup.indexÚs9€ôc˜4Ÿ:™:Ô&Ø—?‘?×(Ñ(¨Ó-Ð-åÒPTÑVYÐZÓ[Ð[rcó`—|jdk(rtjStjS)aReturn 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)rGrÚOneÚInfinityrYs rÚorderzFreeGroup.orderís"€ð9‰9˜Š>Ü—5‘5ˆLä—:‘:ÐrcóP—|jdk(r |jhStd«‚)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)rGÚidentityr.rYs rÚelementszFreeGroup.elementss-€ð9‰9˜Š>à—M‘M?Ð"äð<ó=ð =rcó—|jS)a 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=rYs rrGzFreeGroup.ranks€ðz‰zÐrcó—|jdvS)zÙReturns 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 )rrLr\rYs rÚ is_abelianzFreeGroup.is_abelian"s€ðy‰y˜FÐ"Ð"rcó"—|j«S)z+Returns the identity element of free group.)r?rYs rrrzFreeGroup.identity1s€ðz‰z‹|ÐrcóF—t|t«sy||jk7ryy)aiTests 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 FTrU)rRÚgs rÚcontainszFreeGroup.contains6s#€ô˜!Ô-Ô.ØØ Q—W‘WŠ_Øàrcó—|jhS)z,Returns the center of the free group `self`.)rrrYs rÚcenterzFreeGroup.centerLs€à— ‘ ˆÐrr")r8Ú __module__Ú__qualname__Ú__doc__Úis_associativeÚis_groupÚis_FreeGroupÚis_PermutationGroupr3Ú__annotations__r;r@rSrWrZr]rbÚ__repr__rerirdrpÚpropertyrsrGrvrrrzr|rrrrrrsÁ…ñð$€NØ€HØ€LØÐØ€HˆjÓòò2ó$7òòòòð€Hò+òò \ò&ð(ñ=óð=ð(ñ óð ðñ#óð#ðñóðòó,rrcór—eZdZdZdZd„ZdZd„Zd„Ze d„«Z e d„«Ze d „«Zd „Z d„Ze d„«Ze d „«Zd„Zd„ZeZd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd3d„Zd4d„Zd„Zd„Zd„Z d„Z!d„Z"d„Z#d „Z$d!„Z%d5d"„Z&d6d#„Z'd$„Z(d%„Z)d&„Z*d'„Z+d(„Z,d)„Z-d*„Z.d+„Z/d,„Z0d-„Z1d.„Z2d/„Z3d0„Z4d7d1„Z5d2„Z6y)8r,z«Used 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. Tcó$—|j|«Sr")rQ)rRÚinits rÚnewzFreeGroupElement.new^s€Ø~‰~˜dÓ#Ð#rNcó‚—|j}|€0t|jtt |««f«x|_}|Sr")r<r7r5Ú frozensetr)rRr<s rrZzFreeGroupElement.__hash__cs8€Ø— ‘ ˆØˆ=Ü!% t§z¡z´9¼UÀ4»[Ó3IÐ&JÓ!KÐKˆDŒJ˜Øˆrcó$—|j|«Sr")rŠrYs rÚcopyzFreeGroupElement.copyis€Øx‰x˜‹~Ðrcó$—|jdk(ryy)NrTF©Ú array_formrYs rÚis_identityzFreeGroupElement.is_identityls€à?‰?˜bÒ Øàrcó—t|«S)aó 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 )rrYs rr‘zFreeGroupElement.array_formss€ô@T‹{Ðrc ó’—tt|jDcgc]\}}|dkDr|f|zn|f|z‘Œc}}««Scc}}w)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 r©rrr‘)rRrVÚjs rÚletter_formzFreeGroupElement.letter_form•sV€ô4”WØ $§¡÷1Ù˜˜1ð)*¨Aª˜q˜d 1šf°Q°B°5¸1¸"±:Ñ=ó1ó2ó3ð 3ùó1sšAcó¢—|j}|j|}|jr|j|dff«S|j|dff«S)NrLéÿÿÿÿ©r5r—Ú is_Symbolr?)rRrVr5Úrs rrezFreeGroupElement.__getitem__²sN€Ø— ‘ ˆØ×Ñ˜QÑˆØ;Š;Ø—;‘; A ˜yÓ)Ð)à—;‘; ! R ˜{Ó+Ð+rcó‚—t|«dk7r t«‚|jj|jd«S)NrLr)r6r.r—rdrks rrdzFreeGroupElement.indexºs5€Üˆs‹8qŠ=Ü“,ÐØ× Ñ ×'Ñ'¨¯©¸Ñ(:Ó;Ð;rcóÂ—|j}|j}|Dcgc]7}|jr|j|dff«n|j|dff«‘Œ9c}Scc}w)z rLr™rš)rRr5rœrOs rÚletter_form_elmz FreeGroupElement.letter_form_elm¿sf€ð— ‘ ˆØ×Ñˆà:;ö=Ø36ð,/¯=ª=—‘˜c !˜W˜JÔ'Ø—[‘[ C 4¨ ) Ó.ñ/ò=ð =ùò=s—tt|j««S)zKThis is called the External Representation of ``FreeGroupElement`` r•rYs rÚext_repzFreeGroupElement.ext_repÈs€ô”W˜TŸ_™_Ó-Ó.Ð.rcó|—|jddt|jDcgc]}|d‘Œ c}«vScc}w)Nr)r‘r)rRrlrœs rrWzFreeGroupElement.__contains__Îs6€Ø~‰~˜aÑ Ñ#¤u¸D¿O¹OÖ-L°q¨a°«dÒ-LÓ'MÐMÐMùÒ-Ls¥9 cóÂ—|jryd}|j}tt|««D]¬}|t|«dz k(rJ||ddk(r|t ||d«z }Œ4|t ||d«dzt ||d«zz }Œ^||ddk(r|t ||d«dzz }Œ|t ||d«dzt ||d«zdzz }Œ®|S)Nz ÚrLrz**Ú*)r’r‘Úranger6r$)rRrar‘rVs rrbzFreeGroupElement.__str__Ñs$€Ø×ÒØàˆØ—_‘_ˆ Ü”s˜:“Ó'ò GˆAØ”C˜ “O aÑ'Ò'Ø˜a‘= Ñ# qÒ(Ø¤ J¨q¡M°!Ñ$4Ó 5Ñ5‘Hà¤ J¨q¡M°!Ñ$4Ó 5Ø$(ñ!)Ü+.¨z¸!©}¸QÑ/?Ó+@ñ!AñA‘Hð˜a‘= Ñ# qÒ(Ø¤ J¨q¡M°!Ñ$4Ó 5¸Ñ ;Ñ;‘Hà¤ J¨q¡M°!Ñ$4Ó 5Ø$(ñ!)Ü+.¨z¸!©}¸QÑ/?Ó+@ñ!AØCFñ!GñG‘Hð Gðˆrcó¾—t|«}|jj}|dk(r|S|dkr|}|j«}n|} |dzr||z}|dz}|s |S||z}Œ)NrérL)rr5rrÚinverse)rRÚnÚresultÚxs rÚ__pow__zFreeGroupElement.__pow__ès{€Ü1‹IˆØ—‘×$Ñ$ˆØŠ6ØˆMØˆqŠ5ØˆAØ—‘“‰AàˆAØØ1ŠuØ˜!‘Ø !‰GˆAÙØàˆ ð ‰FˆAð rcóP—|j}t||j«std«‚|jr|S|jr|St|j|jz«}t|t|j«dz «|jt|««S)aUReturns 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 multipliedrL) r5r#r?Ú TypeErrorr’Úlistr‘Ú zero_mul_simpr6r)rRrhr5rœs rÚ__mul__zFreeGroupElement.__mul__ûs€ð — ‘ ˆÜ˜% §¡Ô-Üð$ó%ð %à×ÒØˆLØ×ÒØˆKÜ—‘ 5×#3Ñ#3Ñ3Ó4ˆÜaœ˜TŸ_™_Ó-°Ñ1Ô2Ø{‰{œ5 ›8Ó$Ð$rcó‚—|j}t||j«std«‚||j «zS©Nr¯©r5r#r?r°r©©rRrhr5s rÚ__truediv__zFreeGroupElement.__truediv__s<€Ø— ‘ ˆÜ˜% §¡Ô-Üð$ó%ð %àU—]‘]“_Ñ%Ð%rcó‚—|j}t||j«std«‚||j «zSrµr¶r·s rÚ__rtruediv__zFreeGroupElement.__rtruediv__s<€Ø— ‘ ˆÜ˜% §¡Ô-Üð$ó%ð %àd—l‘l“nÑ%Ð%rcó—tSr")ÚNotImplementedrgs rÚ__add__zFreeGroupElement.__add__%s€ÜÐrcóª—|j}t|jddd…Dcgc] \}}||f‘Œc}}«}|j|«Scc}}w)a& 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™)r5rr‘r?)rRr5rVr–rœs rr©zFreeGroupElement.inverse(sL€ð— ‘ ˆÜ t§¡±t¸°tÑ'<×=™t˜q !A˜r’7Ó=Ó>ˆØ{‰{˜1‹~Ðùó>s§A cóZ—|jrtjStjS)zéFind 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 )r’rrnrorYs rrpzFreeGroupElement.order;s €ð×ÒÜ—5‘5ˆLä—:‘:Ðrcóª—|j}t||j«std«‚|j «|j «z|z|zS)zO Return the commutator of `self` and `x`: ``~x*~self*x*self`` z@commutator of only FreeGroupElement of the same FreeGroup exists)r5r#r?r.r©r·s rÚ commutatorzFreeGroupElement.commutatorLsP€ð — ‘ ˆÜ˜% §¡Ô-Üð'ó(ð (ð—<‘<“> %§-¡-£/Ñ1°$Ñ6°uÑ<Ð>> 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 r™FrLrTrÃ)r5rrÚis_independentr6Ú subword_indexr.ÚsubwordrÆ) rRrlÚbyrÄr©ÚwordÚlrVÚks rrÆzFreeGroupElement.eliminate_wordrs)€ð:ˆ:Ø—‘×$Ñ$ˆBØ×Ñ˜sÔ# s¨b¢yØˆKØ$Š;ØˆIØ‰7bŠ=ØˆDØˆÜ‹Hˆð Ø×"Ñ" 3Ó'ˆAØˆAð|‰|˜A˜qÓ! " a¡%Ñ'¨¯©°Q°q±S¼#¸d»)Ó(D×(SÑ(SÐTWÐY[Ó(\Ñ\ˆáØ×&Ñ& s¨B°TÀ7Ð&ÓKÐKàˆKøôò ÙØ’ð Ø×&Ñ& s¨B¡wÓ/Ø‘øÜò Ø”ð úñð ús6ÁCÃ DÃC*Ã)DÃ*C:Ã5DÃ9C:Ã:DÃ?Dcó&—td„|D««S)a^ 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ó8K—|]\}}t|«–—Œywr"©Úabs)r&rVr–s rr(z+FreeGroupElement.__len__..¿sèø€Ò-™f˜q !”3q—6Ñ-ùs‚)ÚsumrYs rr]zFreeGroupElement.__len__s€ô$Ñ-¨Ô-Ó-Ð-rcót—|j}t||j«sytj ||«S)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)r5r#r?rrir·s rrizFreeGroupElement.__eq__Ás/€ð<— ‘ ˆÜ˜% §¡Ô-ØÜ|‰|˜D %Ó(Ð(rcóÒ—|j}t||j«std«‚t |«}t |«}||kry||kDryt|«D]Š}||jd}||jd}|jj|d«}|jj|d«} || kry|| kDry|d|dkry|d|dkDsŒŠyy)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 comparedTFrrL) r5r#r?r°r6r¦r‘rrd) rRrhr5rÒÚmrVÚaÚbÚpÚqs rÚ__lt__zFreeGroupElement.__lt__äsû€ð,— ‘ ˆÜ˜% §¡Ô-Üð+ó,ð ,ä‹IˆÜ‹JˆàˆqŠ5ØØ ŠUØÜq“ò ˆAØQ‘×"Ñ" 1Ñ%ˆAØa‘×#Ñ# AÑ&ˆAØ— ‘ ×#Ñ# A a¡DÓ)ˆAØ— ‘ ×#Ñ# A a¡DÓ)ˆAØ1ŠuÙØQ’ÙØ1‘˜˜!™’ÙØ1‘˜˜!™“Ùð ðrcó—||k(xs||kSr"rrgs rÚ__le__zFreeGroupElement.__le__s€Ø˜‘ Ò- ¨¡Ð.rcóh—|j}t||j«std«‚||kS)a 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Û)r5r#r?r°r·s rÚ__gt__zFreeGroupElement.__gt__s:€ð — ‘ ˆÜ˜% §¡Ô-Üð+ó,ð ,à˜5‘=Ð Ð rcó—||kSr"rrgs rÚ__ge__zFreeGroupElement.__ge__-s€Ø˜%‘<ÐÐrcóœ‡—t|«dk7rtd«‚|jdŠ‰dtˆfd„|jD««zS)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 rLz1gen must be a generator or inverse of a generatorrc3ó@•K—|]}|d‰dk(sŒ|d–—Œyw©rrLNr©r&rVr's €rr(z0FreeGroupElement.exponent_sum..Ns#øèø€ÒF ¸¸1¹ÀÀ1Á»˜˜!ÑFùsƒ” )r6r.r‘rØ©rRrlr's @rÚexponent_sumzFreeGroupElement.exponent_sum0sHø€ô6ˆs‹8qŠ=ÜÐPÓQÐQØN‰N˜1ÑˆØ‰t”CÓF d§o¡oÔFÓFÑFÐFrcóÆ‡—t|«dk7s|jdddkrtd«‚|jdŠ‰dtˆfd„|jD««zS)að 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 rLrzgen must be a generatorc3óR•K—|]}|d‰dk(sŒt|d«–—Œ ywrêrÖrës €rr(z3FreeGroupElement.generator_count..ks'øèø€ÒK a¸aÀ¹dÀaÈÁd»lœ˜A˜a™DŸ ÑKùsƒ'”')r6r‘r.rØrìs @rÚgenerator_countz FreeGroupElement.generator_countPs]ø€ô0ˆs‹8qŠ=˜CŸN™N¨1Ñ-¨aÑ0°1Ò4ÜÐ6Ó7Ð7ØN‰N˜1ÑˆØ‰t”CÓK¨4¯?©?ÔKÓKÑKÐKrcó—|j}|s!t|d«}tt|«|«}|dks|t|«kDrt d«‚||kr|j S|j||}t||«}|j|«S)aÃ 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) r5ÚmaxÚminr6r.rrr—Úletter_form_to_array_formr?)rRÚfrom_iÚto_jÚstrictr5r—r‘s rrÏzFreeGroupElement.subwordms€ð — ‘ ˆÙÜ˜ “^ˆFÜ”s˜4“y $Ó'ˆDØAŠ:˜¤ D£ Ò)Üð5ó6ð 6à6Š>Ø—>‘>Ð!à×*Ñ*¨6°4Ð8ˆKÜ2°;ÀÓFˆJØ—;‘;˜zÓ*Ð*rcóÈ—t|«}|j}|j}d}t|t|«|z dz«D]}||||z|k(sŒ|}n||Std«‚)a 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 NrLz'The given word is not a subword of self)r6r—r¦r.)rRrÑÚstartrÒÚself_lfÚword_lfrdrVs rrÎzFreeGroupElement.subword_index‹s~€ô ‹IˆØ×"Ñ"ˆØ×"Ñ"ˆØˆÜuœS ›\¨!™^¨AÑ-Ó.ò ˆAØq˜˜1™ˆ~ Ó(ØÙð ðÐØˆLäÐFÓGÐGrcó”— |j|«duS#t$rYnwxYw |j|dz«duS#t$rYywxYw)a³ 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 Nr™F)rÎr.©rRrÑs rÚis_dependentzFreeGroupElement.is_dependent¦s`€ð, Ø×%Ñ% dÓ+°4Ð7Ð7øÜò Ùð úð Ø×%Ñ% d¨B¡hÓ/°tÐ;Ð;øÜò Ùð ús‚• ! !¥;» AÁAcó&—|j|«S)zC See Also ======== is_dependent )rþrýs rrÍzFreeGroupElement.is_independentÅs€ð×$Ñ$ TÓ*Ð*Ð*rcó„—|j}|jDchc]}|j|ddff«’Œ}}|Scc}w)a 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} rrL)r5r‘r?)rRr5ÚsyllablerNs rÚcontains_generatorsz$FreeGroupElement.contains_generatorsÐsD€ð— ‘ ˆØAEÇÁÖQ°X—‘˜h q™k¨1Ð-Ð/Õ0ÐQˆÐQØˆùòRs›=có2—|j}t|«}|j}t||z«}||k\r|||zz}|||zz}||z }|||}t||z«dz } ||| z|d||z |z|| zz zz }t ||«}|j|«S)NrL)r5r6r—Úintrôr?) rRrõrör5rÒr—Úperiod1ÚdiffrÑÚperiod2s rÚcyclic_subwordzFreeGroupElement.cyclic_subwordás½€Ø— ‘ ˆÜ‹IˆØ×&Ñ&ˆÜf˜Q‘h“-ˆØQŠ;Øa˜‘iÑˆFØAg‘IÑˆDØf‰}ˆØ˜6 4Ð(ˆÜd˜1‘f“+ ‘/ˆØ˜GÑ# kÐ2J°4¸±6¸&±=ÀÀ7ÁÑ3JÐ&KÑKÑKˆÜ(¨¨uÓ5ˆØ{‰{˜4Ó Ð rc óˆ—tt|««Dchc] }|j||t|«z«’Œ"c}Scc}w)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 )r¦r6r©rRrVs rÚcyclic_conjugatesz"FreeGroupElement.cyclic_conjugatesðs7€ô*>CÄ3ÀtÃ9Ó=MÖN¸×#Ñ# A q¬¨T«¡{Õ3ÒNÐNùÒNs—%?cój—t|«}t|«}||k7ry|j«}|j«}|j}|j}djt t |««}djt t |««} t|«t| «k7ry|| dz| zvS)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ú )r6Úidentity_cyclic_reductionr—ÚjoinÚmapr$) rRÚwÚl1Úl2Úw1Úw2Úletter1Úletter2Ústr1Ústr2s rÚis_cyclic_conjugatez$FreeGroupElement.is_cyclic_conjugatesŸ€ô$‹YˆÜ ‹VˆØ Š8ØØ × +Ñ +Ó -ˆØ × (Ñ (Ó *ˆØ—.‘.ˆØ—.‘.ˆØx‰xœœC Ó)Ó*ˆØx‰xœœC Ó)Ó*ˆÜˆt‹9œ˜D› Ò!Øàt˜c‘z DÑ(Ð(Ð(rcó,—t|j«S)a5Returns 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 )r6r‘rYs rÚnumber_syllablesz!FreeGroupElement.number_syllables(s€ô4—?‘?Ó#Ð#rcó&—|j|dS)a< 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 rLrr s rÚexponent_syllablez"FreeGroupElement.exponent_syllable6ó€ð‰˜qÑ! !Ñ$Ð$rcó&—|j|dS)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 rrr s rÚgenerator_syllablez#FreeGroupElement.generator_syllableGrrcóä—t|t«rt|t«std«‚|j}||kr|jSt|j||«}|j|«S)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#rr.r5rrrr‘r?)rRrõrör5rœs rÚ sub_syllableszFreeGroupElement.sub_syllablesXs`€ô&˜&¤#Ô&¬j¸¼sÔ.CÜÐ@ÓAÐAØ— ‘ ˆØ6Š>Ø—>‘>Ð!äd—o‘o f¨dÐ3Ó4ˆAØ—;‘;˜q“>Ð!rcó—t|«}||k\s ||kDs||kDrtd«‚|dk(r||k(r|S|dk(r||j||«zS||k(r|jd|«|zS|jd|«|z|j||«zS)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)r6r.rÏ)rRrõrörÐÚlws rÚsubstituted_wordz!FreeGroupElement.substituted_wordts €ô ‹YˆØTŠ>˜V bš[¨D°2ªIÜÐ=Ó>Ð>ð QŠ;˜4 2š:ØˆIØ qŠ[Ød—l‘l 4¨Ó,Ñ,Ð,Ø RŠZØ—<‘< 6Ó*¨2Ñ-Ð-à—<‘< 6Ó*¨2Ñ-¨d¯l©l¸4ÀÓ.DÑDÐDrcó$—|sy|d|ddzk7S)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 Trr™rrYs rÚis_cyclically_reducedz&FreeGroupElement.is_cyclically_reduced”s!€ñ"ØØA‰w˜$˜r™( B™,Ñ&Ð&rcó¬—|j«}|j}|j«s§|jd«}|jd«}||z}|dk(r!|jd|j«dz }n8|j d«||zff|jd|j«dz z}|j|«}|j«sŒ§|S)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 rr™rL)rŽr5r(rr‘rr!r?)rRrÑr5Úexp1Úexp2rœÚreps rrz*FreeGroupElement.identity_cyclic_reduction©sÓ€ð&y‰y‹{ˆØ— ‘ ˆØ×,Ñ,Ô.Ø×)Ñ)¨!Ó,ˆDØ×)Ñ)¨"Ó-ˆDØt‘ˆAØAŠvØ—o‘o a¨×)>Ñ)>Ó)@À1Ñ)DÐE‘à×/Ñ/°Ó2°D¸4±KÐ@ÐBØŸ™¨¨4×+@Ñ+@Ó+BÀQÑ+FÐGñHà—;‘;˜sÓ#ˆDð×,Ñ,Õ.ðˆrcóŠ—|j«}|jj}|j«s†t |jd««}t |jd««}t ||«}|dt |«z}|dt |«z}|dz|z|dzz}||z}|j«sŒ†|r||fS|S)a/Return 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™)rŽr5rrr(r×rró) rRÚremovedrÑryr*r+ÚexprùÚends rÚcyclic_reductionz!FreeGroupElement.cyclic_reductionÊsÃ€ð0y‰y‹{ˆØJ‰J×ÑˆØ×,Ñ,Ô.Üt×-Ñ-¨aÓ0Ó1ˆDÜt×-Ñ-¨bÓ1Ó2ˆDÜd˜D“/ˆCØ˜‘GœS ›XÑ%ˆEØr‘(œC ›HÑ$ˆCØ˜"‘9˜T‘> # r¡'Ñ)ˆDØ%‘ˆAð×,Ñ,Õ.ñØ˜7ˆNØˆrcó—|jryt|«}|dk(r/|j«}||vxs|dz|v}t|«dk(xr|S|jd¬«\}}|js,|jd¬«\}}||k(r|j |«Syt|«|kst|«|zry|jd|«}||k(s|dz|k(r,|j|t|««} | j |«Sy)a; 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 TrLr™)r.Fr)r’r6rr1Úpower_ofrÏ) rRrhrÒrNr'ÚreducedÚr1Úr2ÚprefixÚrests rr3zFreeGroupElement.power_ofðs €ð×ÒØä‹JˆØŠ6à×+Ñ+Ó-ˆDØ˜ Ò2 ¨¡¨dÐ!2ˆAÜt“9 ‘>Ò' aÐ'ð ×+Ñ+°DÐ+Ó9‰ˆØ~Š~Ø×.Ñ.°tÐ.Ó<‰IˆE2ØRŠxØ×'Ñ'¨Ó.Ð.Øäˆt‹9qŠ=œC ›I¨šMØà—‘˜a Ó#ˆØUŠ?˜f b™j¨EÒ1Ø—<‘< ¤3 t£9Ó-ˆDØ—=‘= Ó'Ð'Ør)FT)NFT)T)r)F)7r8r}r~rÚ is_assoc_wordrŠr<rZrŽr†r’r‘r—rerdrŸr¡rWrbr…rr³r¸rºr½r©rprÁrËrÆr]rirárãrårçrírðrÏrÎrþrÍrrrrrrr!r#r&r(rr1r3rrrr,r,Vsa„ñð €Mò$ð €EòòðñóððñóððBñ3óð3ò8,ò<ð ñ=óð=ðñ/óð/ò Nòð*€Hòò&%ò8&ò&òòò&ò" =óó49òv.ò(!)òF.ò`/ò!ò, òGò@Ló:+ó<Hò6ò> +òò" !òOò.)òB$ò%ò"%ò""ò8Eò@'ò*óB$óL*rr,có@—t|dd«}g}d}|j}tt|««D]é}|t|«dz k(r‰||||dz k(r>|||vr|j |||f«|cS|j |||f«|cS|||vr|j ||df«|cS|j ||df«|cS||||dzk(r|dz }Œ±|||vr|j |||f«n|j |||f«d}Œëy)a` 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`. NrLr™)r±rr¦r6rM)r‘r5rÝÚ new_arrayrªrrVs rrôrôs]€ô ˆZ™ˆ]Ó€AØ€IØ €AØm‰m€GÜ ”3q“6‹]òˆØ”A“˜‘ Š?Ø‰tq˜˜Q™‘xÒØq‘TE˜gÑ%Ø×$Ñ$ q¨¡t e¨a¨R [Ô1ðÒð ×$Ñ$ a¨¡d¨A YÔ/ðÒð q‘TE˜gÑ%Ø×$Ñ$ q¨¡t e¨R [Ô1ðÒð×$Ñ$ a¨¡d¨A YÔ/ØÒØ ˆq‰TQq˜1‘u‘XÒ Ø ‰F‰Aà1‘˜'Ñ!Ø× Ñ 1 Q¡4 %¨!¨ Õ-à× Ñ ! A¡$¨ Ô+Ø‰Añ)rcó0—|dk\r‘|t|«dz kr||d||dzdk(rj||d||dzdz}||d}||f||<||dz=||ddk(r||=|dz}|dk\r(|t|«dz kr||d||dzdk(rŒgyyyyyy)z"Used to combine two reduced words.rrLN)r6)rÒrdr/Úbases rr²r²AsÖ€à !Š)˜¤ A£¨¡ Ò*¨q°©x¸©{¸aÀÈÁ ¹lÈ1¹oÒ/MØ‰hq‰k˜A˜e a™i™L¨™OÑ+ˆØ‰x˜‰{ˆØ˜#;ˆˆ%‰Ø ˆea‰iˆLØˆU‰8A‰;˜!ÒØ%ØQ‰JˆEð!Š)˜¤ A£¨¡ Ò*¨q°©x¸©{¸aÀÈÁ ¹lÈ1¹oÔ/MÐ*ˆ)Ð/MÐ*ˆ)rN)"Ú __future__rÚ sympy.corerÚsympy.core.exprrÚsympy.core.symbolrrr+Úsympy.core.sympifyrÚsympy.printing.defaultsr Úsympy.utilitiesr Úsympy.utilities.iterablesrrÚsympy.utilities.magicr Úsympy.utilities.miscrrrrr0r1r„rrr,rôr²rrrúrHsŸðÞ"åÝ ß9Ý*Ý3Ý"ß:Ý)Ý'ðñ:óð:ð0ñ1óð1ð0ñóðò4+ð*+-ÐÐ'Ó,ô\ô\ôHD{ O°UôDòN!óH r