o FZhI@sddlZddlmZmZmZddlmZddlmZddl m Z ddl m Z ddl mZGdd d Zdd d ZddZddZddZdddZddZdS)N)FpGroup FpSubgroupsimplify_presentation) FreeGroup)PermutationGroup)igcd)totient)Sc@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 r rrP/var/www/auris/lib/python3.10/site-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 isinstancer rZ 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(rr rreducerr%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.kernelcCs|j}|}|tjurtdg}t|trt|j}nt||dd}| }|||krc| }|| ||d}||vr[| |t|trTt|}nt||dd}|||ks2|S)Nz9Kernel computation is not implemented for infinite groupsT)normalr) r orderr InfinityNotImplementedErrorrrrrrrandomr*append)rGZG_orderr Kr7rrrrrr8vs*        z!GroupHomomorphism._compute_kernelcCsP|jdur%tt|j}t|jtr|j||_|jSt |j||_|jS)z/ Compute the image of `self`. N) rrsetrvaluesrr rZsubgroupr)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.rrr/r0z,GroupHomomorphism._apply..z2The supplied element does not belong to the domainT)originalrr) r rrtuple ValueErrorrr rrrr4 array_formabs) relemrvaluer r!r7_prr.rrFs.    zGroupHomomorphism._applycCs ||Sr rE)rrLrrr__call__s zGroupHomomorphism.__call__cC|dkS)z9 Check if the homomorphism is injective )r9r;r.rrr is_injectivezGroupHomomorphism.is_injectivecCs6|}|j}|tjur|tjurdS||kS)z: Check if the homomorphism is surjective N)rr;r r r<)rZimZothrrr is_surjectives  zGroupHomomorphism.is_surjectivecCs|o|S)z5 Check if `self` is an isomorphism. )rSrUr.rrris_isomorphismrTz GroupHomomorphism.is_isomorphismcCrQ)zs Check is `self` is a trivial homomorphism, i.e. all elements are mapped to the identity. rR)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 rIrr r )rrZrrrYrcomposeszGroupHomomorphism.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|]}||qSrrrXr.rrr[r0z1GroupHomomorphism.restrict_to..)rrr]r rIrr 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]rrIrrrr*r?r9)rr_r PhZh_irrrrinvert_subgroups     z!GroupHomomorphism.invert_subgroupN)__name__ __module__ __qualname____doc__rr%r*r9r8rrFrPrSrUrVrWr^r`rcrrrrr s" #.     r rTcst|tttfs tdttttfstd|jtfddDs*tdtfdd|Ds9td|rGt|tkrGtdt t |}| j gtt| fd d Dt 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``, do not check whether the given images actually define a homomorphism. zThe domain must be a groupzThe codomain must be a groupc3|]}|vVqdSr rrX)rrr #zhomomorphism..zCThe supplied generators must be a subset of the domain's generatorsc3rhr rrX)r rrri%rjz+The images must be elements of the codomainz>The number of images must be equal to the number of generatorscsg|]}|vr|qSrrrX)r rrr//sz homomorphism..z-The given images do not define a homomorphism)rrrr TypeErrorrallrIr6rextendrdictzip_check_homomorphismr )r r r rcheckr)r rr r homomorphism s& rrc st|dr|n|}|j}|j}dd|D}tt||j|jfdd}|D]4}t|trW| ||} | durV| } | ||} | durV| sVt dn||j } | sadSq-d S) 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. relatorscSsg|]}|jdqS)r)Zext_reprXrrrr/Fr0z'_check_homomorphism..cs0}|jD]\}}|}|||9}q|Sr )rJ)rBr"symbolpowerr!rrZsymbols_to_domain_generatorsrrrJs z#_check_homomorphism.._imageNzCan'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) hasattrZ presentationrsrrnrorrrequalsZmake_confluent RuntimeErrorr) r r rZpresZrelsr symbolsrrBr$successrrvrrp6s*    rpcsddlmddlm}|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)index)r,o)r!omegarrr/rr\z1orbit_homomorphism...rr,r'rrr!rr[rs*z&orbit_homomorphism..)base) r1r' sympy.combinatorics.named_groupsr}r6rrrZ_schreier_simsr Zbasic_stabilizersrr)grouprr}r rr_rrrorbit_homomorphismgs     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&r|NrRcs(i|]fddDqS)csg|] }|AqSrr)r,r7)br!rOrrr/sz1block_homomorphism...rrr'rrrOrrr[s(z&block_homomorphism..) r1r'rr}r6r5r?rr ) rblocksr}nmr7r rr_rrrblock_homomorphism{s&       rc Cst|ttfs tdt|ttfstdt|trGt|trGt|}t|}|j|jkrG|j|jkrG|s>> 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 FpGroupTzs       )1 $ t