Ë ¼K i<›ãó—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 úe/mnt/ssd/data/python-lab/Trading/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„Zd„Zd „Z dd„Zd„Zd „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ó—|jfS)zdReturn a tuple of arguments that must be passed to __new__ in order to support pickling this object.r/©Úselfs rÚ__getnewargs__zFreeGroup.__getnewargs__¤s€à—‘ˆÐrcó—yr"rrLs rÚ__getstate__zFreeGroup.__getstate__¨s€à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)rMrs 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)rMÚir5s rÚ__contains__zFreeGroup.__contains__Ás#€ä˜!Ô-Ô.ØØ—‘ˆØu‰}Ðrcó—|jSr")r<rLs rÚ__hash__zFreeGroup.__hash__Ès€Øz‰zÐrcó—|jSr"©rGrLs rÚ__len__zFreeGroup.__len__Ës€Øy‰yÐrcó„—|jdkDrd|jz}|Sd}|j}|t|«dzz }|S)Nézz)rGrr$)rMÚstr_formrTs 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/)rrX)rMÚindexrs rÚ__getitem__zFreeGroup.__getitem__Ùs!€Ø—,‘,˜uÑ%ˆØz‰z 'ˆzÓ*Ð*rcó —||uS)z@No ``FreeGroup`` is equal to any "other" ``FreeGroup``. r©rMÚ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?rrhr.©rMÚgens rrhzFreeGroup.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ÚInfinityrLs 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.rLs rÚelementszFreeGroup.elements s-€ð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=rLs 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 )rrRr`rLs rÚ is_abelianzFreeGroup.is_abelian*s€ðy‰y˜FÐ"Ð"rcó"—|j«S)z+Returns the identity element of free group.)r?rLs rrvzFreeGroup.identity9s€ð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 FTrZ)rMÚgs rÚcontainszFreeGroup.contains>s#€ô˜!Ô-Ô.ØØ Q—W‘WŠ_Øàrcó—|jhS)z,Returns the center of the free group `self`.)rvrLs rÚcenterzFreeGroup.centerTs€à— ‘ ˆÐrr")r8Ú __module__Ú__qualname__Ú__doc__Úis_associativeÚis_groupÚis_FreeGroupÚis_PermutationGroupr3Ú__annotations__r;rNrPr@rXr\r^rarfÚ__repr__rirmrhrtÚpropertyrwrGrzrvr~r€rrrrrrsË…ñð$€NØ€HØ€LØÐØ€HˆjÓòò2òòó$7òòòòð€Hò+òò \ò&ð(ñ=óð=ð(ñ óð ðñ#óð#ðñóðòó,rrcóv—eZdZdZdZdZd„ZdZd„Zd„Z e d„«Ze d „«Ze d „«Z d„Zd„Ze d „«Ze d„«Zd„Zd„ZeZd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd4d„Zd5d„Zd„Zd„Z d„Z!d„Z"d„Z#d „Z$d!„Z%d"„Z&d6d#„Z'd7d$„Z(d%„Z)d&„Z*d'„Z+d(„Z,d)„Z-d*„Z.d+„Z/d,„Z0d-„Z1d.„Z2d/„Z3d0„Z4d1„Z5d8d2„Z6d3„Z7y)9r,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. rTcó$—|j|«Sr")rW)rMÚinits rÚnewzFreeGroupElement.newgs€Ø~‰~˜dÓ#Ð#rNcó‚—|j}|€0t|jtt |««f«x|_}|Sr")r<r7r5Ú frozensetr)rMr<s rr^zFreeGroupElement.__hash__ls8€Ø— ‘ ˆØˆ=Ü!% t§z¡z´9¼UÀ4»[Ó3IÐ&JÓ!KÐKˆDŒJ˜Øˆrcó$—|j|«Sr")rŽrLs rÚcopyzFreeGroupElement.copyrs€Øx‰x˜‹~Ðrcó—|jSr"©Ú array_formrLs rÚis_identityzFreeGroupElement.is_identityus€à—?‘?Ð"Ð"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 )rrLs rr•zFreeGroupElement.array_formys€ô@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•)rMr[Ú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)NrRéÿÿÿÿ©r5r›Ú is_Symbolr?)rMr[r5Úrs rrizFreeGroupElement.__getitem__¸sN€Ø— ‘ ˆØ×Ñ˜QÑˆØ;Š;Ø—;‘; A ˜yÓ)Ð)à—;‘; ! R ˜{Ó+Ð+rcó‚—t|«dk7r t«‚|jj|jd«S)NrRr)r6r.r›rhros rrhzFreeGroupElement.indexÀs5€Üˆs‹8qŠ=Ü“,ÐØ× Ñ ×'Ñ'¨¯©¸Ñ(:Ó;Ð;rcóÂ—|j}|j}|Dcgc]7}|jr|j|dff«n|j|dff«‘Œ9c}Scc}w)z rRrrž)rMr5r rUs 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™rLs rÚext_repzFreeGroupElement.ext_repÎs€ô”W˜TŸ_™_Ó-Ó.Ð.rcó|—|jddt|jDcgc]}|d‘Œ c}«vScc}w)Nr)r•r)rMrpr s rr\zFreeGroupElement.__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 ÚrRrz**Ú*)r–r•Úranger6r$)rMrer•r[s rrfzFreeGroupElement.__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érR)rr5rvÚinverse)rMÚ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 multipliedrR) r5r#r?Ú TypeErrorr–Úlistr•Ú zero_mul_simpr6r)rMrlr5r 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©rMrlr5s 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")ÚNotImplementedrks 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?)rMr5r[ršr s rrzFreeGroupElement.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–rrrrsrLs rrtzFreeGroupElement.orderAs €ð×ÒÜ—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.rr»s rÚ commutatorzFreeGroupElement.commutatorRsP€ð — ‘ ˆÜ˜% §¡Ô-Üð'ó(ð (ð—<‘<“> %§-¡-£/Ñ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 rFrRrTrÇ)r5rvÚis_independentr6Ú subword_indexr.ÚsubwordrÊ) rMrpÚbyrÈrÚwordÚlr[Úks rrÊzFreeGroupElement.eliminate_wordxs)€ð:ˆ:Ø—‘×$Ñ$ˆ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&r[ršs rr(z+FreeGroupElement.__len__..Åsèø€Ò-™f˜q !”3q—6Ñ-ùs‚)ÚsumrLs rrazFreeGroupElement.__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?rrmr»s rrmzFreeGroupElement.__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 comparedTFrrR) r5r#r?r´r6rªr•rrh) rMrlr5rÖÚmr[Ú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"rrks 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"rrks rÚ__ge__zFreeGroupElement.__ge__3s€Ø˜%‘<ÐÐ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 rRz1gen must be a generator or inverse of a generatorrc3ó@•K—|]}|d‰dk(sŒ|d–—Œyw©rrRNr©r&r[r's €rr(z0FreeGroupElement.exponent_sum..Ts#øèø€ÒF ¸¸1¹ÀÀ1Á»˜˜!ÑFùsƒ” )r6r.r•rÜ©rMrpr's @rÚexponent_sumzFreeGroupElement.exponent_sum6sHø€ô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 rRrzgen must be a generatorc3óR•K—|]}|d‰dk(sŒt|d«–—Œ ywrîrÚrïs €rr(z3FreeGroupElement.generator_count..qs'øèø€ÒK a¸aÀ¹dÀaÈÁd»lœ˜A˜a™DŸ ÑKùsƒ'”')r6r•r.rÜrðs @rÚgenerator_countz FreeGroupElement.generator_countVs]ø€ô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.rvr›Úletter_form_to_array_formr?)rMÚfrom_iÚto_jÚstrictr5r›r•s rrÓzFreeGroupElement.subwordss€ð — ‘ ˆÙÜ˜ “^ˆ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 NrRz'The given word is not a subword of self)r6r›rªr.)rMrÕÚstartrÖÚself_lfÚword_lfrhr[s 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 NrF)rÒr.©rMrÕ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 )rrs 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} rrR)r5r•r?)rMr5ÚsyllablerTs 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)NrR)r5r6r›Úintrør?) rMrù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©rMr[s 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$) rMÚwÚl1Úl2Úw1Úw2Úletter1Úletter2Ústr1Ústr2s rÚis_cyclic_conjugatez$FreeGroupElement.is_cyclic_conjugate sŸ€ô$‹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•rLs 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 rRr”rs rÚexponent_syllablez"FreeGroupElement.exponent_syllable<ó€ð‰˜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 rr”rs rÚgenerator_syllablez#FreeGroupElement.generator_syllableMr#rcóä—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.r5rvrr•r?)rMrùrúr5r s rÚ sub_syllableszFreeGroupElement.sub_syllables^s`€ô&˜&¤#Ô&¬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Ó)rMrùrúrÔÚlws rÚsubstituted_wordz!FreeGroupElement.substituted_wordzs €ô ‹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 TrrrrLs 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 rrrR)r’r5r,r"r•r r%r?)rMrÕ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’r5rvr,rÛr"r÷) rMÚremovedrÕr}r.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 TrRr)r2Fr)r–r6rr5Úpower_ofrÓ) rMrlrÖrTr'ÚreducedÚr1Úr2ÚprefixÚrests rr7zFreeGroupElement.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)8r8rr‚rƒÚ __slots__Ú is_assoc_wordrŽr<r^r’rŠr–r•r›rirhr£r¥r\rfr‰r±r·r¼r¾rÁrrtrÅrÏrÊrarmrårçrérërñrôrÓrÒrrÑrrrrr r"r%r'r*r,rr5r7rrrr,r,^sf„ñð €IØ€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`. NrRr)rµrrªr6rS)r•r5ráÚ new_arrayr®rr[s 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.rrRN)r6)rÖrhr3Úbases rr¶r¶GsÖ€à !Š)˜¤ 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úrMsŸðÞ"åÝ ß9Ý*Ý3Ý"ß:Ý)Ý'ðñ:óð:ð0ñ1óð1ð0ñóðò4+ð*+-ÐÐ'Ó,ôdôdôXB{ O°UôBòJ!óH r