o 8VaK@sddlZddlmZmZmZddlmZddlmZddl m Z ddl m Z ddl mZGdd d Zgd fd d Zd dZddZddZdddZddZdS)N)FpGroup FpSubgroupsimplify_presentation) FreeGroup)PermutationGroup)igcd)totientSc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd S)!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. cCs(||_||_||_d|_d|_d|_dSN)domaincodomainimages _inverses_kernel_image)selfr rrrC/usr/lib/python3/dist-packages/sympy/combinatorics/homomorphisms.py__init__s  zGroupHomomorphism.__init__c Cs|}i}t|jD]}|j|}||vs|js|||<q t|jtr*|j}n|j }|D]?}||vs8|jr9q/|j j }t|jtrN|j |ddd}n|}|D]} | |vr_||| }qR||| dd}qR|||<q/|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 isinstancerrZ strong_gens generatorsr identityZ_strong_gens_slp) rrZinverseskvgensgwpartssrrr_invss2    zGroupHomomorphism._invsc sddlm}ddlm}t|||frotjtrj|}jdur) _ }j j }tjt rB||ddd}n|}tt|D]"}||}|jrTqJ|jvra|j|}qJ|j|dd}qJ|St|tr}fdd|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)FreeGroupElementNrcg|]}|qSr)invert.0errr kz,GroupHomomorphism.invert..)sympy.combinatoricsr(sympy.combinatorics.free_groupsr)rrrreducerr&rr rrgenerator_productrangelenrr) rr"r(r)rr#r!ir%rr/rr+?s.         zGroupHomomorphism.invertcCs|jdur ||_|jS)z0 Compute the kernel of `self`. N)r_compute_kernelr/rrrkernelms  zGroupHomomorphism.kernelc Csddlm}|j}|}||jurtdg}t|tr#t|j}nt ||dd}| }|||kri| }|| ||d}||vra| |t|trZt|}nt ||dd}|||ks8|S)Nrr z9Kernel computation is not implemented for infinite groupsT)Znormalr)sympyr r orderInfinityNotImplementedErrorrrrrrZrandomr+append) rr GZG_orderr!Kr8rrrrrr9vs,         z!GroupHomomorphism._compute_kernelcCsP|jdur%tt|j}t|jtr|j||_|jSt |j||_|jS)z/ Compute the image of `self`. N) rrsetrvaluesrrrZsubgroupr)rrDrrrrs  zGroupHomomorphism.imagec s|jvrt|ttfrfdd|DStd|jr jjSj}jj}tjt rRjj |dd}|D]}|jvrE|||}q7||dd|}q7|Sd}|j D]!\}}|dkrf||d}n||}||||}|t |7}qW|S)z* Apply `self` to `elem`. cr*r_applyr,r/rrr0r1z,GroupHomomorphism._apply..z1The supplied element doesn't belong to the domainT)Zoriginalrr) r rrtuple ValueErrorrrrrrr5 array_formabs) relemrvaluer!r"r8_prr/rrFs.    zGroupHomomorphism._applycCs ||Sr rE)rrKrrr__call__s zGroupHomomorphism.__call__cC|dkS)z9 Check if the homomorphism is injective )r:r<r/rrr is_injectivezGroupHomomorphism.is_injectivecCsBddlm}|}|j}||jur||jurdS||kS)z: Check if the homomorphism is surjective rr N)r;r rr<rr=)rr ZimZothrrr is_surjectives   zGroupHomomorphism.is_surjectivecCs|o|S)z5 Check if `self` is an isomorphism. )rRrTr/rrris_isomorphismrSz GroupHomomorphism.is_isomorphismcCrP)zs Check is `self` is a trivial homomorphism, i.e. all elements are mapped to the identity. rQ)rr<r/rrr is_trivialszGroupHomomorphism.is_trivialcs>js tdfddjD}tjj|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`csi|] }||qSrrr-r"otherrrr z-GroupHomomorphism.compose..)r is_subgroupr rHrr r)rrYrrrXrcomposeszGroupHomomorphism.composecsDt|tr |jstd|}fdd|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 domaincsi|]}||qSrrrWr/rrrZr1z1GroupHomomorphism.restrict_to..)rrr\r rHrr r)rHr rrr/r restrict_tos zGroupHomomorphism.restrict_tocCs||s tdg}t|j}|jD]-}||}||vr+||t|}|jD]}|||vrC|||t|}q0q|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) r\rrHrrrr+r?r:)rr^r!PhZh_irrrrinvert_subgroups     z!GroupHomomorphism.invert_subgroupN)__name__ __module__ __qualname____doc__rr&r+r:r9rrFrOrRrTrUrVr]r_rbrrrrr s" #.     r Tcst|tttfs tdttttfstd|jtfddDr*tdtfdd|Dr9td|rGt|tkrGtdt t |}| j gtt| fd dDt t |}|r}t||s}td 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``, don't check whether the given images actually define a homomorphism. zThe domain must be a groupzThe codomain must be a groupcg|]}|vqSrrrW)rrrr0%z homomorphism..zCThe supplied generators must be a subset of the domain's generatorscrgrrrW)rrrr0'rhz+The images must be elements of the codomainz>The number of images must be equal to the number of generatorscsg|]}|vr|qSrrrW)r!rrr01sz-The given images do not define a homomorphism)rrrr TypeErrorranyrHr7rextendrdictzip_check_homomorphismr )r rr!rcheckr)rrr!r homomorphisms& rpcstdr j}n jj}|jfdd}|D]4}t|trK|||}|durJ|}|||}|durJ|sJt dn||j }|sUdSq!dS)Nrelatorscs|jrS}|j}d}d}|t|kra||d}ttr0||vr0j||}n||}|vrA|||}n|dvrQ||d|}|t|7}|d7}|t|ks|S)NrrQr)rrIr7rrrindexrJ)rBr#Zr_arrr8jZpowerr%r r!rrrrr@s&     z#_check_homomorphism.._imagezCan'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) hasattrrqZ presentationrrrrZequalsZmake_confluent RuntimeErrorr)r rrZrelsrrBr%Zsuccessrrtrrn8s(      rncsddlmddlm}|t}|jtfdd|jD}|jdt |||}t|j tkrD|j t|_ |St |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'SymmetricGroupcs*i|]fddDqS)csg|] }|AqSr)rr)r-o)r"omegarrr0r[z1orbit_homomorphism...rr-r(rrzr"rrZs*z&orbit_homomorphism..)base) r2r( sympy.combinatorics.named_groupsrxr7rrrZ_schreier_simsr Zbasic_stabilizersrr)grouprzrxrrr^rr|rorbit_homomorphismts     rc sddlmddlm}t|}d}gdg|t|D]}|||kr2|||<|d7}qt|D] }|||<q7||}t|fdd|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'rwNrQcs(i|]fddDqS)csg|] }|AqSrr)r-r8)br"rNrrr0sz1block_homomorphism...rr{r(rrrNr}rrZs(z&block_homomorphism..) r2r(rrxr7r6r?rr ) rZblocksrxnmr8rrr^rrrblock_homomorphisms&       rc Cst|ttfs tdt|ttfstdt|trGt|trGt|}t|}|j|jkrG|j|jkrG|s>> from sympy.combinatorics import Permutation >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> from sympy.combinatorics.free_groups import free_group >>> 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 FpGroupTzZ_to_perm_groupZ is_abelianrrr itertools permutationsr7rkrrlrmrnr+rU) r@r^ isomorphismZ_HZg_orderZh_orderZ h_isomorphismrr!ZsubsetrZ_imagesTrrrgroup_isomorphismsZ9           rcCst||ddS)a Check if the groups are isomorphic to each other Parameters ========== G : A finite ``FpGroup`` or a ``PermutationGroup`` First group. H : A finite ``FpGroup`` or a ``PermutationGroup`` Second group. Returns ======= boolean F)r)r)r@r^rrr is_isomorphic!sr)T)rZsympy.combinatorics.fp_groupsrrrr3rZsympy.combinatorics.perm_groupsrZsympy.core.numbersrZsympy.ntheory.factor_rr;r r rprnrrrrrrrrs      )< $ u