gIddlZddlmZmZmZddlmZddlmZddl m Z ddl m Z ddl mZGdd Zdd Zd ZdZdZddZdZdS)N)FpGroup FpSubgroupsimplify_presentation) FreeGroup)PermutationGroup)igcd)totient)ScleZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdS)GroupHomomorphismz A class representing group homomorphisms. Instantiate using `homomorphism()`. References ========== .. [1] Holt, D., Eick, B. and O'Brien, E. (2005). Handbook of computational group theory. cZ||_||_||_d|_d|_d|_dSN)domaincodomainimages _inverses_kernel_image)selfrrrs ]/var/www/html/ai-engine/env/lib/python3.11/site-packages/sympy/combinatorics/homomorphisms.py__init__zGroupHomomorphism.__init__s0      c|}i}t|jD]}|j|}||vs |js|||< t |jtr|j}n|j }|D]x}||vs|jr|j j }t |jtr|j |ddd}n|}|D]#} | |vr ||| z}||| dzdzz}$|||<y|S)z Return a dictionary with `{gen: inverse}` where `gen` is a rewriting generator of `codomain` (e.g. strong generator for permutation groups) and `inverse` is an element of its preimage N) imagelistrkeys is_identity isinstancerr strong_gens generatorsridentity_strong_gens_slp) rrinverseskvgensgwpartsss r_invszGroupHomomorphism._invss9 dk&&(())  A AAMM}" dm%5 6 6 $$DD#D  AH}} } $A$-)9:: .q1$$B$7 . .==(1+ AA(1b5/2--AAHQKKrcddlm}ddlm}t |||frt jt rj|}j _ }j j }t jtr||ddd}n|}tt!|D]B}||}|jr|jvr|j|z},|j|dzdzz}C|St |t$rfd|DSdS)a Return an element of the preimage of ``g`` or of each element of ``g`` if ``g`` is a list. Explanation =========== If the codomain is an FpGroup, the inverse for equal elements might not always be the same unless the FpGroup's rewriting system is confluent. However, making a system confluent can be time-consuming. If it's important, try `self.codomain.make_confluent()` first. r Permutation)FreeGroupElementNrc:g|]}|S)invert.0ers r z,GroupHomomorphism.invert..ks#...qDKKNN...r)sympy.combinatoricsr/sympy.combinatorics.free_groupsr0rrrreducerr,rrr"rgenerator_productrangelenrr) rr(r/r0rr)r'ir+s ` rr3zGroupHomomorphism.invert?s~ 433333DDDDDD a+'78 9 9 /$-11 ,M((++~%!%JJLLE $A$-)9:: ..q11$$B$73t99%% 4 4G=&&$.++AA$.B/33AAH 4  /....A... . / /rcP|j||_|jS)z0 Compute the kernel of `self`. )r_compute_kernelrs rkernelzGroupHomomorphism.kernelms' < //11DL|rc|j}|}|tjurt dg}t |t rt |j}nt||d}| }||z|kr| }|| ||dzz}||vrL| |t |t rt |}nt||d}||z|k|S)Nz9Kernel computation is not implemented for infinite groupsT)normalr) rorderr InfinityNotImplementedErrorrrr"rrrandomr3append)rGG_orderr'Kr>rr%s rr@z!GroupHomomorphism._compute_kernelvsF K'')) aj %KMM M a) * * 1 ,,AA1d4000A JJLL   ggiikW$$ A$++dd1gg&&**Azz Aa!1229(..AA"1d4888AggiikW$$rc,|jtt|j}t |jtr |j||_nt|j||_|jS)z/ Compute the image of `self`. ) rrsetrvaluesrrrsubgroupr)rrPs rrzGroupHomomorphism.imagesy ; #dk00223344F$-)9:: @"m44V<< (?? {rc.|jvr9t|ttfrfd|DSt d|jr jjSj}jj}tjtrHj |d}|D](}|jvr |||z}||dzdz|z})nId}|j D]?\}}|dkr ||dz}n||}||||zz}|t|z }@|S)z* Apply `self` to `elem`. c:g|]}|Sr2_applyr4s rr7z,GroupHomomorphism._apply..s#5551 A555rz2The supplied element does not belong to the domainT)originalrr) rrrtuple ValueErrorrrr"rrr; array_formabs) relemrvaluer'r(r>_ps ` rrUzGroupHomomorphism._applysU t{ " "$u .. 655555555QRR R   =) )[FM*E$+'788 {44TD4II88ADK'' &q % &q"u r 1% 7 8  O  DAq1uu GRK G!&)Q,.EQKAA rc,||SrrT)rr[s r__call__zGroupHomomorphism.__call__s{{4   rcV|dkS)z9 Check if the homomorphism is injective )rBrErAs r is_injectivezGroupHomomorphism.is_injectives# {{}}""$$))rc|}|j}|tjur|tjurdS||kS)z: Check if the homomorphism is surjective N)rrErr rF)rimoths r is_surjectivezGroupHomomorphism.is_surjectivesX ZZ\\   ! !m!!##   qz 1 149 rcR|o|S)z5 Check if `self` is an isomorphism. )rcrgrAs ris_isomorphismz GroupHomomorphism.is_isomorphisms'   "";t'9'9';';;rcV|dkS)zs Check is `self` is a trivial homomorphism, i.e. all elements are mapped to the identity. rb)rrErAs r is_trivialzGroupHomomorphism.is_trivials# zz||!!##q((rcjstdfdjD}t jj|S)z Return the composition of `self` and `other`, i.e. the homomorphism phi such that for all g in the domain of `other`, phi(g) = self(other(g)) z?The image of `other` must be a subgroup of the domain of `self`c:i|]}||Sr2r2)r5r(otherrs r z-GroupHomomorphism.compose..s+:::!TT%%((^^:::r)r is_subgrouprrXrr r)rrnrs`` rcomposezGroupHomomorphism.composesq{{}}((55 ,+,, ,:::::U\::: t}fEEErct|tr|jst d|}fd|jD}t |j|S)zh Return the restriction of the homomorphism to the subgroup `H` of the domain. z'Given H is not a subgroup of the domainc(i|]}||Sr2r2)r5r(rs rroz1GroupHomomorphism.restrict_to..s#333!TT!WW333r)rrrprrXr!r r)rHrrs` r restrict_tozGroupHomomorphism.restrict_tosr !-.. HammDK6P6P HFGG G3333al333 ???rc||stdg}t|j}|jD]}||}||vr$||t|}|jD]0}||z|vr'|||zt|}1|S)z Return the subgroup of the domain that is the inverse image of the subgroup ``H`` of the homomorphism image z&Given H is not a subgroup of the image) rprrXrr"r!r3rIrB)rrtr'Phh_ir%s rinvert_subgroupz!GroupHomomorphism.invert_subgroups }}TZZ\\** GEFF F TZZ\\2 3 3 / /A++a..C!|| C   $T**[[]]- / /S5>>KK#&&&(..A /rN)__name__ __module__ __qualname____doc__rr,r3rBr@rrUr`rcrgrirkrqrurzr2rrr r s!!!F,/,/,/\.   @!!!***   <<<))) F F F @ @ @rr r2Tcxt|tttfst dttttfst d|jt fdDstdt fd|Dstd|r/t|tkrtdtt|}| j gtt|z z fdDtt|}|r t||std t||S) a Create (if possible) a group homomorphism from the group ``domain`` to the group ``codomain`` defined by the images of the domain's generators ``gens``. ``gens`` and ``images`` can be either lists or tuples of equal sizes. If ``gens`` is a proper subset of the group's generators, the unspecified generators will be mapped to the identity. If the images are not specified, a trivial homomorphism will be created. If the given images of the generators do not define a homomorphism, an exception is raised. If ``check`` is ``False``, do not check whether the given images actually define a homomorphism. zThe domain must be a groupzThe codomain must be a groupc3 K|]}|vV dSrr2)r5r(r!s r zhomomorphism..#s'--1qJ------rzCThe supplied generators must be a subset of the domain's generatorsc3 K|]}|vV dSrr2)r5r(rs rrzhomomorphism..%s'--qH}------rz+The images must be elements of the codomainz>The number of images must be equal to the number of generatorscg|]}|v| Sr2r2)r5r(r's rr7z homomorphism../s888q!4-----rz-The given images do not define a homomorphism)rrrr TypeErrorr!allrXr=rextendr"dictzip_check_homomorphismr )rrr'rcheckr!s `` @r homomorphismr s f/)D E E64555 h!17I F G G86777"J ------- - -`^___ ----f--- - -HFGGG [#f++T**YZZZ ::D &\\F MM8$%s:s6{{'BCDDDKK8888J888999 #d6"" # #F J(6BBJHIII VXv 6 66rc t|dr|n|}|j}|j}d|D}t t ||j |j  fd}|D]}t|trh| || } | F| } | || } | | stdn||j } | sdSdS)a] Check that a given mapping of generators to images defines a homomorphism. Parameters ========== domain : PermutationGroup, FpGroup, FreeGroup codomain : PermutationGroup, FpGroup, FreeGroup images : dict The set of keys must be equal to domain.generators. The values must be elements of the codomain. relatorsc(g|]}|jdS)r)ext_rep)r5r(s rr7z'_check_homomorphism..Fs***qy|***rcR}|jD]\}}|}|||zz}|Sr)rY)rMr)symbolpowerr(r"rsymbols_to_domain_generatorss rrz#_check_homomorphism.._imageJsA \ " "MFE,V4A E! !AArNzCan't determine if the images define a homomorphism. Try increasing the maximum number of rewriting rules (group._rewriting_system.set_max(new_value); the current value is stored in group._rewriting_system.maxeqns)FT) hasattr presentationrr!rrr"rrequalsmake_confluent RuntimeErrorr) rrrpresrelsr'symbolsrrMr+successr"rs ` @@rrr6sOVZ00 K66f6I6I6K6KD =D ?D**T***G#'GV5F(G(G#H#H  H h ( ( &q 844Ay#1133OOFF1IIx889W9&(+,,,q %A 55  4rcddlmddlm}|t }|jt fd|jD}|t|||}t |j t kr |j t |_ nt|jg|_ |S)z Return the homomorphism induced by the action of the permutation group ``group`` on the set ``omega`` that is closed under the action. rr.SymmetricGroupcJi|]fdDzS)c@g|]}|z Sr2)index)r5or(omegas rr7z1orbit_homomorphism...rs)&G&G&GAu{{1Q3'7'7&G&G&Grr2)r5r(r/r"rs @rroz&orbit_homomorphism..rsC c c cQa++&G&G&G&G&G&G&G&GHHH c c cr)base) r8r/ sympy.combinatorics.named_groupsrr=r"rr!_schreier_simsr basic_stabilizersrr)grouprrrrrtr/r"s ` @@rorbit_homomorphismrgs 0/////??????~c%jj))H H KKE c c c c c cRWRb c c cF e$$$%622A 5 "##c%jj00+CJJ7 $en%566 Hrc ddlm ddlm}t |}d}g dg|z t |D]-}|||kr || |<|dz }.t |D]} || |<||}t | fd|jD}t|||}|S)ab Return the homomorphism induced by the action of the permutation group ``group`` on the block system ``blocks``. The latter should be of the same form as returned by the ``minimal_block`` method for permutation groups, namely a list of length ``group.degree`` where the i-th entry is a representative of the block i belongs to. rr.rNrbcFi|]fdDS)c2g|]}|z Sr2r2)r5r>br(r^s rr7z1block_homomorphism...s%:::Aa!Qi:::rr2)r5r(r/rr"r^s @rroz&block_homomorphism..sA V V Va:::::::::;; V V Vr) r8r/rrr=r<rIr!r ) rblocksrnmr>rrrtr/rr"r^s @@@@rblock_homomorphismr{s0/////?????? F A A A qA 1XX !9>> HHQKKKAaD FA 1XX|!~a  HQxxH V V V V V V VUEU V V VF%622A Hrct|ttfstdt|ttfstdt|trt|trt |}t |}|j|jkrV|j|jkr"|sdSdt|||j|jfS|}| }| }|tj urtdt|tr4|tj urtd| \}}||ks|j|jkr|sdSdS|s%|}t|t!|dkrdSt#|j}t%j|t)|D]} t#| } | |jgt)|jt)| z zt/t1|| } t3||| rbt|tr|| } t|||j| d} | r |sdSd| fcS|sdSdS)aE Compute an isomorphism between 2 given groups. Parameters ========== G : A finite ``FpGroup`` or a ``PermutationGroup``. First group. H : A finite ``FpGroup`` or a ``PermutationGroup`` Second group. isomorphism : bool This is used to avoid the computation of homomorphism when the user only wants to check if there exists an isomorphism between the groups. Returns ======= If isomorphism = False -- Returns a boolean. If isomorphism = True -- Returns a boolean and an isomorphism between `G` and `H`. Examples ======== >>> from sympy.combinatorics import free_group, Permutation >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> from sympy.combinatorics.fp_groups import FpGroup >>> from sympy.combinatorics.homomorphisms import group_isomorphism >>> from sympy.combinatorics.named_groups import DihedralGroup, AlternatingGroup >>> D = DihedralGroup(8) >>> p = Permutation(0, 1, 2, 3, 4, 5, 6, 7) >>> P = PermutationGroup(p) >>> group_isomorphism(D, P) (False, None) >>> F, a, b = free_group("a, b") >>> G = FpGroup(F, [a**3, b**3, (a*b)**2]) >>> H = AlternatingGroup(4) >>> (check, T) = group_isomorphism(G, H) >>> check True >>> T(b*a*b**-1*a**-1*b**-1) (0 2 3) Notes ===== Uses the approach suggested by Robert Tarjan to compute the isomorphism between two groups. First, the generators of ``G`` are mapped to the elements of ``H`` and we check if the mapping induces an isomorphism. z2The group must be a PermutationGroup or an FpGroupTzrs0TTTTTTTTTT555555<<<<<<######999999""""""BBBBBBBBH'7'7'7'7R///b   (" " " Hrrrrh66666r