\h xSSKJr SSKJr SSKJrJr SSKJr "SS\5r S Sjr S S jr S S jr g) ) free_group)DefaultPrinting)chainproduct) bisect_leftc\rSrSrSrSrSrSrS&Sjr\ S5r Sr S r \ r \ S 5rS rS'S jrS rSrSrS(SjrSrS)SjrS'SjrS)SjrSrSrSrSrSrSrSrSr Sr!Sr"Sr#S'S jr$S!r%S"r&S#r'S$r(S%r)g)* CosetTable aK Properties ========== [1] `0 \in \Omega` and `\tau(1) = \epsilon` [2] `\alpha^x = \beta \Leftrightarrow \beta^{x^{-1}} = \alpha` [3] If `\alpha^x = \beta`, then `H \tau(\alpha)x = H \tau(\beta)` [4] `\forall \alpha \in \Omega, 1^{\tau(\alpha)} = \alpha` References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of Computational Group Theory" .. [2] John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490. "Implementation and Analysis of the Todd-Coxeter Algorithm" i>Ndc U(d[RnXlX lX0lS/Ul[ [R"SURR555Ul S/[UR5-/Ul S/[UR5-/Ul URVs0sHoDURRU5_M snUl0UlURR#5HNupEUS-S:Xa!URUS-UR U'M/URUS- UR U'MP /UlURn['SR)[+[U55Vs/sHnSU-PM sn55SUlS/[UR5-/Ul 0Ulgs snfs snf)Nrc3.# UH nXS-4v M g7fN).0gens W/var/www/auris/envauris/lib/python3.13/site-packages/sympy/combinatorics/coset_table.py &CosetTable.__init__..@s*53C,/R.3sz, za_%d)r coset_table_max_limitfp_groupsubgroupcoset_table_limitplistr from_iterable generatorsAlenPtableindexA_dict A_dict_invitemsdeduction_stackrjoinrange_grpp_p)selffp_grpr max_cosetsxr$His r__init__CosetTable.__init__7s#99J  !+e))*5==33*556&TVV$%fS[() 3766:6a$&&,,q/)6:  ))+HAqyA~%)[[^a%7"%)[[^a%7" , " MMtzzuSV}*M}!6A:}*MNOPQR &TVV$%;+Ns =%GG$ c[[UR55Vs/sHoRUU:XdMUPM sn$s snf)zSet of live cosets. )r*r!r)r-cosets romegaCosetTable.omegaWs8$)TVV#5P#5%%9O#5PPPs AAcURURUR5nURVs/sHn[ U5PM snUl[ UR 5Ul[ UR 5UlU$s snf)z: Return a shallow copy of Coset Table instance ``self``. ) __class__rrr#rrr()r- self_copyperm_reps rcopyCosetTable.copy\sh NN4==$--@ :>**E*h4>*E 466l $()=)=$> !FsBc@SUR<SUR<S3$)NzCoset Table on z with z as subgroup generators)rrr-s r__str__CosetTable.__str__gs==$--1 1cVUR(dg[UR5S-$)zQThe number `n` represents the length of the sublist containing the live cosets. rr)r#maxr7r@s rn CosetTable.nms! zz4::""rCcL^[U4SjTR55(+$)z The coset table is called complete if it has no undefined entries on the live cosets; that is, `\alpha^x` is defined for all `\alpha \in \Omega` and `x \in A`. c3H># UHnSTRU;v M g7fN)r#)rr6r-s rr)CosetTable.is_complete..sIjUttzz%00j")anyr7r@s`r is_completeCosetTable.is_completexsIdjjIIIIrCcURnURn[U5nX`R:a[ SUR-5eUR S/[U5-5 UR R S/[UR5-5 UnURR U5 XuUURU'XUURU'U(aURRUR UURU'URRUR UURU'URRURU'gg)ak This routine is used in the relator-based strategy of Todd-Coxeter algorithm if some `\alpha^x` is undefined. We check whether there is space available for defining a new coset. If there is enough space then we remedy this by adjoining a new coset `\beta` to `\Omega` (i.e to set of live cosets) and put that equal to `\alpha^x`, then make an assignment satisfying Property[1]. If there is not enough space then we halt the Coset Table creation. The maximum amount of space that can be used by Coset Table can be manipulated using the class variable ``CosetTable.coset_table_max_limit``. See Also ======== define_c ethe coset enumeration has defined more than %s cosets. Try with a greater value max number of cosets N) r r#r!r ValueErrorappendr"rr%r&r+identityr,)r-alphar0modifiedr r# len_tablebetas rdefineCosetTable.defines)$ FF J .. .P,,-. .  dVCF]#  tfS[()  d'+e T[[^$*/d DOOA&' ,0II,>,>DFF5M$++a. )/3yy/A/ADFF4L+ ,!YY//DHHTN rCcURnURn[U5nXPR:a[ SUR-5eUR S/[U5-5 UnUR R U5 XdUURU'XUURU'URR X45 g)a A variation of ``define`` routine, described on Pg. 165 [1], used in the coset table-based strategy of Todd-Coxeter algorithm. It differs from ``define`` routine in that for each definition it also adds the tuple `(\alpha, x)` to the deduction stack. See Also ======== define rQN) r r#r!rrRrSrr%r&r()r-rUr0r r#rWrXs rdefine_cCosetTable.define_cs FF J .. .P,,-. .  dVCF]#  d'+e T[[^$*/d DOOA&' ##UJ/rCc4URnURnURnUnSn[U5nUn US- n Xz::a2XVX2Ub%XVX2UnUS- nXz::aXVX2UbM%Xz:aXi:waUR Xi5 gX:a2XYXBU b%XYXBU n U S-n X:aXYXBU bM%X:aUR Xi5 gX:Xa8XUX2U'XeU XBU'UR R XbU45 gg)z A variation of ``scan`` routine, described on pg. 165 of [1], which puts at tuple, whenever a deduction occurs, to deduction stack. See Also ======== scan, scan_check, scan_and_fill, scan_and_fill_c rrN)r%r&r#r! coincidence_cr(rS r-rUwordr%r&r#fr2rbjs rscan_cCosetTable.scan_csV__     I  Ef&a/2>Q)A FAf&a/2> 5v""1( f*!W"56BG,-A FAf*!W"56B 5   q $ V()!HVG_ %,-!HZQ( )  ' 'G 5 rCcVURnURnURn/nURXU5 [ U5S:aUR S5nUHnXWX8n U cMSXYXH'UR RXS-45 URU5n URU 5n XZX8bURXU X8U5 MX[XHbURXU XHU5 MXU X8'XU XH'M [ U5S:aMgg)a A variation of ``coincidence`` routine used in the coset-table based method of coset enumeration. The only difference being on addition of a new coset in coset table(i.e new coset introduction), then it is appended to ``deduction_stack``. See Also ======== coincidence rNr) r%r&r#merger!popr(rSrep) r-rUrXr%r&r#qgammar0deltamunus rr_CosetTable.coincidence_cs#__    5"!fqjEE!HE VY/$26EL/((//2?%B%By+7 2Ry';Q?:=1= 2Ry'?C/1b &),35b *-0!fqjrCctURnURnURnUn Sn [U5n Un U S- n UnU(aURR nSnU(dUS:XGaSnX::aSXXbU bFU(aWUR U XbU -nXXbU n U S- n X::aXXbU bMFX:a7X:wa1U(aURXWS-U-5 gURX5 gX:a\XXrU bOU(a#XR U URX--nXXrU n U S-n X:aXXrU bMOX:a2U(aURXWS-U-5 OURX5 OX:XanXU XbU 'XU XrU 'U(aNWS-U-UR U URX*'US-U-UR U URX*'gU(aURXU US9 U(aGMUS:XaGMgg)a ``scan`` performs a scanning process on the input ``word``. It first locates the largest prefix ``s`` of ``word`` for which `\alpha^s` is defined (i.e is not ``None``), ``s`` may be empty. Let ``word=sv``, let ``t`` be the longest suffix of ``v`` for which `\alpha^{t^{-1}}` is defined, and let ``v=ut``. Then three possibilities are there: 1. If ``t=v``, then we say that the scan completes, and if, in addition `\alpha^s = \alpha^{t^{-1}}`, then we say that the scan completes correctly. 2. It can also happen that scan does not complete, but `|u|=1`; that is, the word ``u`` consists of a single generator `x \in A`. In that case, if `\alpha^s = \beta` and `\alpha^{t^{-1}} = \gamma`, then we can set `\beta^x = \gamma` and `\gamma^{x^{-1}} = \beta`. These assignments are known as deductions and enable the scan to complete correctly. 3. See ``coicidence`` routine for explanation of third condition. Notes ===== The code for the procedure of scanning `\alpha \in \Omega` under `w \in A*` is defined on pg. 155 [1] See Also ======== scan_c, scan_check, scan_and_fill, scan_and_fill_c Scan and Fill ============= Performed when the default argument fill=True. Modified Scan ============= Performed when the default argument modified=True rrNrrV) r%r&r#r!r+rTr"modified_coincidence coincidencerY)r-rUrayfillrVr%r&r#rbr2rcrdreb_pf_pflags rscanCosetTable.scansY^__     I  E ))$$CdaiD&UXf!Wo6BdffQiAw88CHVG_-Q &UXf!Wo6B u611!R B((.&UXja&9:FffQi(@AACHZQ01Q &UXja&9:F u--aCGCK@$$Q*,-aQ)01aG,-692gckDFF1Idkk$'23:=r'#+DFF1Idoodg67 AAw :GddaiirCcURnURnURnUnSn[U5nUn US- n Xz::a2XVX2Ub%XVX2UnUS- nXz::aXVX2UbM%Xz:aXi:H$X:a2XYXBU b%XYXBU n U S-n X:aXYXBU bM%X:agX:XaXUX2U'XeU XBU'g)aj Another version of ``scan`` routine, described on, it checks whether `\alpha` scans correctly under `word`, it is a straightforward modification of ``scan``. ``scan_check`` returns ``False`` (rather than calling ``coincidence``) if the scan completes incorrectly; otherwise it returns ``True``. See Also ======== scan, scan_c, scan_and_fill, scan_and_fill_c rrFT)r%r&r#r!r`s r scan_checkCosetTable.scan_check}s $__     I  Ef&a/2>Q)A FAf&a/2> 56Mf*!W"56BG,-A FAf*!W"56B 5 V()!HVG_ %,-!HZQ( )rCcURnURnU"XS9nU"X%S9n X:wa[X5n [X5n XU 'U(amX:Xa3URUS-U-URU-URU'O5URUS-US--URU-URU 'UR U 5 gg)aF Merge two classes with representatives ``k`` and ``lamda``, described on Pg. 157 [1] (for pseudocode), start by putting ``p[k] = lamda``. It is more efficient to choose the new representative from the larger of the two classes being merged, i.e larger among ``k`` and ``lamda``. procedure ``merge`` performs the merging operation, adds the deleted class representative to the queue ``q``. Parameters ========== 'k', 'lamda' being the two class representatives to be merged. Notes ===== Pg. 86-87 [1] contains a description of this method. See Also ======== coincidence, rep rsrN)rrkminrEr,rS) r-klamdarlwrVrrkphipsirovs rriCosetTable.merges2 FFhh!'%+ :SBC AaD8$(HHQKOA$5dhhuo$EDHHSM$(HHUOR$72$=dhhqk$IDHHSM HHQK rCcVURnUnX4nU(aUSSnXT:waU(aUWU'UnX4nXT:waMU(aIWUnXQ:wa=UnXgnXCU'URUURU-URU'XQ:waM=U$UnX7nXT:waXCU'UnX7nXT:waMU$)a Parameters ========== `k \in [0 \ldots n-1]`, as for ``self`` only array ``p`` is used Returns ======= Representative of the class containing ``k``. Returns the representative of `\sim` class containing ``k``, it also makes some modification to array ``p`` of ``self`` to ease further computations, described on Pg. 157 [1]. The information on classes under `\sim` is stored in array `p` of ``self`` argument, which will always satisfy the property: `p[\alpha] \sim \alpha` and `p[\alpha]=\alpha \iff \alpha=rep(\alpha)` `\forall \in [0 \ldots n-1]`. So, for `\alpha \in [0 \ldots n-1]`, we find `rep(self, \alpha)` by continually replacing `\alpha` by `p[\alpha]` until it becomes constant (i.e satisfies `p[\alpha] = \alpha`):w To increase the efficiency of later ``rep`` calculations, whenever we find `rep(self, \alpha)=\beta`, we set `p[\gamma] = \beta \forall \gamma \in p-chain` from `\alpha` to `\beta` Notes ===== ``rep`` routine is also described on Pg. 85-87 [1] in Atkinson's algorithm, this results from the fact that ``coincidence`` routine introduces functionality similar to that introduced by the ``minimal_block`` routine on Pg. 85-87 [1]. See Also ======== coincidence, merge N)rr,)r-rrVrrrhosros rrkCosetTable.repsX FFh !Al#E(C l E(C(e# $ dhhrl : ( B%C,"e, rCcURnURnURn/nU(aURXX85 OUR XU5 [ U5S:GauUR S5n UGHJn XyXZn U cMSX{Xj'URXS9n URXS9n X|XZbU(aURU S-URU URU S--nXRU -URU URU -nURXU URU X5 MUR XU XZU5 MX}XjbU(aURU S-URU URU -nXRU -URU URU -nURXU URU X5 GMUR XU XjU5 GMXU XZ'XU Xj'U(dGMURU S-URU URU -URU -nXRU URU 'US-URU URU 'GMM [ U5S:aGMtgg)a) The third situation described in ``scan`` routine is handled by this routine, described on Pg. 156-161 [1]. The unfortunate situation when the scan completes but not correctly, then ``coincidence`` routine is run. i.e when for some `i` with `1 \le i \le r+1`, we have `w=st` with `s = x_1 x_2 \dots x_{i-1}`, `t = x_i x_{i+1} \dots x_r`, and `\beta = \alpha^s` and `\gamma = \alpha^{t-1}` are defined but unequal. This means that `\beta` and `\gamma` represent the same coset of `H` in `G`. Described on Pg. 156 [1]. ``rep`` See Also ======== scan rNrsr) r%r&r#modified_mergerir!rjrkr,r")r-rUrXrrVr%r&r#rlrmr0rnrorprs rruCosetTable.coincidences&__       Q 2 JJuA &!fqjEE!HE VY/$26EL/%;B%;By+7# $ 3DFF5M$++a.4QSU4U UA !((5/ 1$&&*T[[^2L LA //"Idkk!n4MqT JJr9VY+?C:=1=# $ 3DFF5M$++a.4Q QA !((5/ 1$&&*T__Q=O2P PA //"Idooa>P4QSTX JJr9Z]+CQG/1b &),35b *-0#8 $ 3DFF5M$++a.4Q QRVRZRZ[`Ra aA9:FF2Jt{{1~6=>UDFF2Jtq'9:5!fqjjrCc$URXSS9 g)a_ A modified version of ``scan`` routine used in the relator-based method of coset enumeration, described on pg. 162-163 [1], which follows the idea that whenever the procedure is called and the scan is incomplete then it makes new definitions to enable the scan to complete; i.e it fills in the gaps in the scan of the relator or subgroup generator. TrwNr{)r-rUras r scan_and_fillCosetTable.scan_and_fillTs %D )rCc`URnURnURn[U5nUnSnUn US- n X::a2XWX2Ub%XWX2UnUS- nX::aXWX2UbM%X:aXy:waUR Xy5 gX:a2XYXBU b%XYXBU n U S-n X:aXYXBU bM%X:aUR Xy5 OQX:Xa8XUX2U'XuU XBU'UR R XrU45 OURXrU5 M)a> A modified version of ``scan`` routine, described on Pg. 165 second para. [1], with modification similar to that of ``scan_anf_fill`` the only difference being it calls the coincidence procedure used in the coset-table based method i.e. the routine ``coincidence_c`` is used. See Also ======== scan, scan_and_fill rrN)r%r&r#r!r_r(rSr\) r-rUrar%r&r#rcrbr2rdres rscan_and_fill_cCosetTable.scan_and_fill_c`sg__   I    E&UXf!Wo6BHVG_-Q&UXf!Wo6Bu6&&q,&UXja&9:FHZQ01Q&UXja&9:Fu""1(,-aQ)01aG,-$$++QQL9 aa))rCcURRnURnURH(nUHnUR X45 X#U:dM M& M* g)a When combined with the HLT method this is known as HLT+Lookahead method of coset enumeration, described on pg. 164 [1]. Whenever ``define`` aborts due to lack of space available this procedure is executed. This routine helps in recovering space resulting from "coincidence" of cosets. N)rrelatorsrr7r{)r-RrrXrs r look_aheadCosetTable.look_aheadsN MM " " FFJJD $"7T>rCcDURnURn[UR5S:a[UR5[R :a!UR 5 URSS2 MaURR5upVX5U:Xa$UHnURXW5 X5U:dM O XEURUnUb,X8U:Xa$UHnURX5 X8U:dM O [UR5S:aMgg)z Processes the deductions that have been pushed onto ``deduction_stack``, described on Pg. 166 [1] and is used in coset-table based enumeration. See Also ======== deduction_stack rN) rr#r!r(r max_stack_sizerrjrfr%) r-R_c_x R_c_x_invrr#rUr0rrXs rprocess_deductionsCosetTable.process_deductionss FF $&&'!+4''(J,E,EE!((+//3358u$" E-8e+!#< A/DAGtO"AKK(w~#$&&'!+rCcd^^^TRn[TR5S:aTRR5umn[ UU4SjU55(dgUTTR UmTb[ UU4SjU55(dg[TR5S:aMg)z A variation of ``process_deductions``, this calls ``scan_check`` wherever ``process_deductions`` calls ``scan``, described on Pg. [1]. See Also ======== process_deductions rc3H># UHnTRTU5v M g7frJr~)rrrUr-s rr6CosetTable.process_deductions_check..s@%Qtua00%rLFc3H># UHnTRTU5v M g7frJr)rrrXr-s rrrsGY4??433YrLT)r#r!r(rjallr%)r-rrr#r0rUrXs` @@rprocess_deductions_check#CosetTable.process_deductions_checks $&&'!+++//1HE1@%@@@< A/DGYGGG $&&'!+rCcvURnURnURnUHnXRXFnXQXFXRXF'XuUXF'[[ UR 55HHnUR UU:XdMXXXFU:Xa X%UXF'M0XXXFU:XdM?XUXF'MJ M g)zSwitch the elements `\beta, \gamma \in \Omega` of ``self``, used by the ``standardize`` procedure, described on Pg. 167 [1]. See Also ======== standardize N)r r%r#r*r!r) r-rXrmr r%r#r0zrUs rswitchCosetTable.switchs FF A VY'A&+k&)&>> from sympy.combinatorics import free_group >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r >>> F, x, y = free_group("x, y") # Example 5.3 from [1] >>> f = FpGroup(F, [x**2*y**2, x**3*y**5]) >>> C = coset_enumeration_r(f, []) >>> C.compress() >>> C.table [[1, 3, 1, 3], [2, 0, 2, 0], [3, 1, 3, 1], [0, 2, 0, 2]] >>> C.standardize() >>> C.table [[1, 2, 1, 2], [3, 0, 3, 0], [0, 3, 0, 3], [2, 1, 2, 1]] rN)r r%rr*rFr#r)r-r r%rmrUr0rXs r standardizeCosetTable.standardizeswF FFdff q1HE::e$VY/D}<KK, FF?2rCc SnURnURnURnURn[ [ [ UR55Vs/sHo`RUU:wdMUPM sn5nURH6nUS- nX:wdMUH!n XXX9n XUX9'XZXIU:H M# M8 [[ US-55UlU[ UR5S2 UH@n [ [ UR55Hn X==[X{U 5-ss'M MB gs snf)zMRemoves the non-live cosets from the coset table, described on pg. 167 [1]. rrN) r r%r&r#tupler*r!rr7rr) r-rmr r%r&r#r2chirUr0rXrowres rcompressCosetTable.compresss  FF__  c$&&k 2E 21ffQi1nQ 2EFZZE QJE~A < 2D.2%L+K .%7  eEAI&' #dff+, C3tvv;'+cq622()Fs E2EcJ[[R"SU555n[5nUHnUR U5nM /nUR HAnUVs1sHowSU:XdM UiM nnUR U5 URU5 MC U$s snf)Nc3h# UH(nUR5US-R54v M* g7frcyclic_conjugatesrrels rr(CosetTable.conjugates..Bs5'=:;3),(=(=(?b++-(/:;02r)rrrsetunionr rSdifference_update) r-rR_cR_set conjugateR_c_listr0rarcs r conjugatesCosetTable.conjugatesAs5&&'=:;'==>IKK *EA"'8%$7a<%A8 OOA   # #A &9s B 0B cURH^nURUURUnUS:XaURRs $X1:dMGUR U5US--s $ g)a Compute the coset representative of a given coset. Examples ======== >>> from sympy.combinatorics import free_group >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r >>> F, x, y = free_group("x, y") >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y]) >>> C = coset_enumeration_r(f, [x]) >>> C.compress() >>> C.table [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1]] >>> C.coset_representative(0) >>> C.coset_representative(1) y >>> C.coset_representative(2) y**-1 rrN)r r#r%rrTcoset_representative)r-r6r0rms rrCosetTable.coset_representativeNsc.AJJu%dkk!n5Ez}}---}0072== rCc$URXSS9 g)z Define a function p_p from from [1..n] to A* as an additional component of the modified coset table. Parameters ========== \alpha \in \Omega x \in A* See Also ======== define TrsN)rY)r-rUr0s rmodified_defineCosetTable.modified_defineps" Et ,rCc&URXX4SS9 g)z Parameters ========== \alpha \in \Omega w \in A* y \in (YUY^-1) fill -- `modified_scan_and_fill` when set to True. See Also ======== scan T)rvrwrVNr)r-rUrrvrws r modified_scanCosetTable.modified_scans %aT :rCc&URXUSS9 g)NTr)r)r-rUrrvs rmodified_scan_and_fill!CosetTable.modified_scan_and_fills 5QT2rCc&URXXCSS9 g)z Parameters ========== 'k', 'lamda' -- the two class representatives to be merged. q -- queue of length l of elements to be deleted from `\Omega` *. w -- Word in (YUY^-1) See Also ======== merge TrrVN)ri)r-rrrrls rrCosetTable.modified_merges 1Qd 3rCc$URUSS9 g)zG Parameters ========== `k \in [0 \ldots n-1]` See Also ======== rep TrsN)rk)r-rs r modified_repCosetTable.modified_reps T"rCc&URXUSS9 g)z{ Parameters ========== A coincident pair `\alpha, \beta \in \Omega, w \in Y \cup Y^{-1}` See Also ======== coincidence TrN)ru)r-rUrXrs rrtCosetTable.modified_coincidences D9rC) r r%r&r"r+rr(rrr,rr#rJ)F)NFF)NF)*__name__ __module__ __qualname____firstlineno____doc__rrrr3propertyr7r=rA__repr__rFrNrYr\rfr_r{r~rirkrurrrrrrrrrrrrrrrrt__static_attributes__rrCrr r s.$N@QQ 1H ##J%0N0<*6^#6J^;D*X&PDP8Cv ***Z(@,70-` 3D >D-&; 34 # :rCr NcX[XUS9nU(aURnURnOURnURnU(a(UR SSUlUR SSUlURn URn UR n [[U55H:n U(a%U"SXURRU 5 M/U"SX5 M< Sn XR:aXU :XaqU H:nU(aU"XURR5 OU"X5 XU :dM: O XU :Xa(U H"nUR U XbMU"X5 M$ U S- n XR:aMU$![anU(aUsSnA$UeSnAff=f)a This is easier of the two implemented methods of coset enumeration. and is often called the HLT method, after Hazelgrove, Leech, Trotter The idea is that we make use of ``scan_and_fill`` makes new definitions whenever the scan is incomplete to enable the scan to complete; this way we fill in the gaps in the scan of the relator or subgroup generator, that's why the name relator-based method. An instance of `CosetTable` for `fp_grp` can be passed as the keyword argument `draft` in which case the coset enumeration will start with that instance and attempt to complete it. When `incomplete` is `True` and the function is unable to complete for some reason, the partially complete table will be returned. # TODO: complete the docstring See Also ======== scan_and_fill, Examples ======== >>> from sympy.combinatorics.free_groups import free_group >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r >>> F, x, y = free_group("x, y") # Example 5.1 from [1] >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y]) >>> C = coset_enumeration_r(f, [x]) >>> for i in range(len(C.p)): ... if C.p[i] == i: ... print(C.table[i]) [0, 0, 1, 2] [1, 1, 2, 0] [2, 2, 0, 1] >>> C.p [0, 1, 2, 1, 1] # Example from exercises Q2 [1] >>> f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3]) >>> C = coset_enumeration_r(f, []) >>> C.compress(); C.standardize() >>> C.table [[1, 2, 3, 4], [5, 0, 6, 7], [0, 5, 7, 6], [7, 6, 5, 0], [6, 7, 0, 5], [2, 1, 4, 3], [3, 4, 2, 1], [4, 3, 1, 2]] # Example 5.2 >>> f = FpGroup(F, [x**2, y**3, (x*y)**3]) >>> Y = [x*y] >>> C = coset_enumeration_r(f, Y) >>> for i in range(len(C.p)): ... if C.p[i] == i: ... print(C.table[i]) [1, 1, 2, 1] [0, 0, 0, 2] [3, 3, 1, 0] [2, 2, 3, 3] # Example 5.3 >>> f = FpGroup(F, [x**2*y**2, x**3*y**5]) >>> Y = [] >>> C = coset_enumeration_r(f, Y) >>> for i in range(len(C.p)): ... if C.p[i] == i: ... print(C.table[i]) [1, 3, 1, 3] [2, 0, 2, 0] [3, 1, 3, 1] [0, 2, 0, 2] # Example 5.4 >>> F, a, b, c, d, e = free_group("a, b, c, d, e") >>> f = FpGroup(F, [a*b*c**-1, b*c*d**-1, c*d*e**-1, d*e*a**-1, e*a*b**-1]) >>> Y = [a] >>> C = coset_enumeration_r(f, Y) >>> for i in range(len(C.p)): ... if C.p[i] == i: ... print(C.table[i]) [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] # example of "compress" method >>> C.compress() >>> C.table [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] # Exercises Pg. 161, Q2. >>> F, x, y = free_group("x, y") >>> f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3]) >>> Y = [] >>> C = coset_enumeration_r(f, Y) >>> C.compress() >>> C.standardize() >>> C.table [[1, 2, 3, 4], [5, 0, 6, 7], [0, 5, 7, 6], [7, 6, 5, 0], [6, 7, 0, 5], [2, 1, 4, 3], [3, 4, 2, 1], [4, 3, 1, 2]] # John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson # Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490 # from 1973chwd.pdf # Table 1. Ex. 1 >>> F, r, s, t = free_group("r, s, t") >>> E1 = FpGroup(F, [t**-1*r*t*r**-2, r**-1*s*r*s**-2, s**-1*t*s*t**-2]) >>> C = coset_enumeration_r(E1, [r]) >>> for i in range(len(C.p)): ... if C.p[i] == i: ... print(C.table[i]) [0, 0, 0, 0, 0, 0] Ex. 2 >>> F, a, b = free_group("a, b") >>> Cox = FpGroup(F, [a**6, b**6, (a*b)**2, (a**2*b**2)**2, (a**3*b**3)**5]) >>> C = coset_enumeration_r(Cox, [a]) >>> index = 0 >>> for i in range(len(C.p)): ... if C.p[i] == i: ... index += 1 >>> index 500 # Ex. 3 >>> F, a, b = free_group("a, b") >>> B_2_4 = FpGroup(F, [a**4, b**4, (a*b)**4, (a**-1*b)**4, (a**2*b)**4, (a*b**2)**4, (a**2*b**2)**4, (a**-1*b*a*b)**4, (a*b**-1*a*b)**4]) >>> C = coset_enumeration_r(B_2_4, [a]) >>> index = 0 >>> for i in range(len(C.p)): ... if C.p[i] == i: ... index += 1 >>> index 1024 References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of computational group theory" r/Nrr)r rrrrYr#rrr%r*r!r+rrFrTrR)r.Yr/draft incompleterVC_scan_and_fill_definerr%rr2rUrr0es rcoset_enumeration_rrsxx 64A11##(( ++a.ggajA XXF A 3q6]  1adAFF$5$5a$8 9 1ad #  E ##+ 8u  A&uA&u0x%'8u$#775>&)4<#E-$  ' ##+( H  H s08F >$F & F F)F$F)"F$$F)c [XX#USS9$)aC Introduce a new set of symbols y \in Y that correspond to the generators of the subgroup. Store the elements of Y as a word P[\alpha, x] and compute the coset table similar to that of the regular coset enumeration methods. Examples ======== >>> from sympy.combinatorics.free_groups import free_group >>> from sympy.combinatorics.fp_groups import FpGroup >>> from sympy.combinatorics.coset_table import modified_coset_enumeration_r >>> F, x, y = free_group("x, y") >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y]) >>> C = modified_coset_enumeration_r(f, [x]) >>> C.table [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1], [None, 1, None, None], [1, 3, None, None]] See Also ======== coset_enumertation_r References ========== .. [1] Holt, D., Eick, B., O'Brien, E., "Handbook of Computational Group Theory", Section 5.3.2 T)r/rrrV)r)r.rr/rrs rmodified_coset_enumeration_rrs@ vZ(2T CCrCcURnURn[XUS9nU(aURSSUlURSSUlUR Ul[ [[UR55U5HCupURUURU cM'UR RX45 ME URn UV s/sHoR5PM n n [[R"SU 555n [!5nU HnUR#U5nM /nURHBn UVs1sHnUSU :XdMUiM nnURU5 UR%U5 MD UHnUR'SU5 M U H5n UR)UURU UUR*U 5 M7 SnU[UR5:aURUU:XaURH}n URUU:wa OjURUURU bM:UR-X5 UR)UURU UUR*U 5 M US- nU[UR5:aMU$s sn fs snf![.anU(aUsSnA$UeSnAff=f)a6 >>> from sympy.combinatorics.free_groups import free_group >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_c >>> F, x, y = free_group("x, y") >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y]) >>> C = coset_enumeration_c(f, [x]) >>> C.table [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1]] rNc3h# UH(nUR5US-R54v M* g7frrrs rr&coset_enumeration_c..s2#" %($9$9$;c2g=X=X=Z#[ rrr)rrr r#rr(rr*r!r%rSr identity_cyclic_reductionrrrrrrrrr&r\rR)r.rr/rrXrrrUr0r r R_cyc_redrrrrrarcrrs rcoset_enumeration_crs AA64A ++a.ggaj!11c!''l 3Q7HEwwu~ahhqk*6!!((%48 A<=>AS..0AI> u""#" #"" #C EE  I&H SS# 4edtAw!|Te 4 " !Q  Xahhqk2HQ\\!_4MN E #agg,  33u:  Ass5zU*wwu~ahhqk2: 5,,,Xahhqk-BHQ\\Z[_D]^    #agg,  H?? 5" H sC"K K-K #KK&AK K9$K4,K92K44K9)NNFF)NNF) sympy.combinatorics.free_groupsrsympy.printing.defaultsr itertoolsrrbisectrr rrrrrCrrsM63$u:u:x;??DD LDH/4!CJ;?;@8 rC