U -eI@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 rrb/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/sympy/combinatorics/homomorphisms.py__init__s zGroupHomomorphism.__init__c Cs|}i}t|jD]$}|j|}||ks|js|||<qt|jtrT|j}n|j }|D]~}||ks^|jrrq^|j j }t|jtr|j |ddd}n|}|D].} | |kr||| }q||| dd}q|||<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_invss0     zGroupHomomorphism._invsc sddlm}ddlm}t|||frtjtr>j|}jdkrR _ }j j }tjt r||ddd}n|}tt|D]D}||}|jrq|jkr|j|}q|j|dd}q|St|trfdd|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)FreeGroupElementNrcsg|]}|qSr)invert.0errr ksz,GroupHomomorphism.invert..)sympy.combinatoricsr'sympy.combinatorics.free_groupsr(rr rreducerr%rr rrgenerator_productrangelenrr) rr!r'r(rr"r ir$rr-rr)?s,         zGroupHomomorphism.invertcCs|jdkr||_|jS)z0 Compute the kernel of `self`. N)r_compute_kernelr-rrrkernelms  zGroupHomomorphism.kernelcCs|j}|}|tjkr tdg}t|tr:t|j}nt||dd}| }|||kr| }|| ||d}||krT| |t|trt|}qTt||dd}qT|S)Nz9Kernel computation is not implemented for infinite groupsT)normalr) r orderr InfinityNotImplementedErrorrrrrrrandomr)append)rGZG_orderr Kr5rrrrrr6vs(       z!GroupHomomorphism._compute_kernelcCsL|jdkrFtt|j}t|jtr8|j||_nt |j||_|jS)z/ Compute the image of `self`. N) rrsetrvaluesrr rZsubgroupr)rrBrrrrs   zGroupHomomorphism.imagec s|jkr2t|ttfr*fdd|DStd|jr@jjSj}jj}tjt rjj |dd}|D]0}|jkr|||}qn||dd|}qnnNd}|j D]B\}}|dkr||d}n||}||||}|t |7}q|S)z* Apply `self` to `elem`. csg|]}|qSr_applyr*r-rrr.sz,GroupHomomorphism._apply..z2The supplied element does not belong to the domainT)originalrr) r rrtuple ValueErrorrr rrrr2 array_formabs) relemrvaluer r!r5_prr-rrDs,   zGroupHomomorphism._applycCs ||Sr rC)rrJrrr__call__szGroupHomomorphism.__call__cCs|dkS)z9 Check if the homomorphism is injective )r7r9r-rrr is_injectiveszGroupHomomorphism.is_injectivecCs:|}|j}|tjkr.|tjkr.dS||kSdS)z: Check if the homomorphism is surjective N)rr9r r r:)rZimZothrrr is_surjectives   zGroupHomomorphism.is_surjectivecCs|o|S)z5 Check if `self` is an isomorphism. )rPrQr-rrris_isomorphismsz GroupHomomorphism.is_isomorphismcCs|dkS)zs Check is `self` is a trivial homomorphism, i.e. all elements are mapped to the identity. rO)rr9r-rrr is_trivialszGroupHomomorphism.is_trivialcs>jstdfddjD}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 sz-GroupHomomorphism.compose..)r is_subgroupr rGrr r )rrVrrrUrcomposeszGroupHomomorphism.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|]}||qSrrrTr-rrrWsz1GroupHomomorphism.restrict_to..)rrrXr rGrr r )rHr rrr-r restrict_tos zGroupHomomorphism.restrict_tocCs||stdg}t|j}|jD]Z}||}||krV||t|}|jD]&}|||kr`|||t|}q`q.|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) rXrrGrrrr)r=r7)rrZr PhZh_irrrrinvert_subgroups     z!GroupHomomorphism.invert_subgroupN)__name__ __module__ __qualname____doc__rr%r)r7r6rrDrNrPrQrRrSrYr[r^rrrrr s  #.      r rTcst|tttfstdttttfs0td|jtfddDsTtdtfdd|Dsrtd|rt|tkrtdt t |}| j gtt| fd d Dt t |}|rt||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 groupc3s|]}|kVqdSr rrT)rrr #szhomomorphism..zCThe supplied generators must be a subset of the domain's generatorsc3s|]}|kVqdSr rrT)r rrrc%sz+The images must be elements of the codomainz>The number of images must be equal to the number of generatorscsg|]}|kr|qSrrrT)r rrr./sz homomorphism..z-The given images do not define a homomorphism)rrrr TypeErrorrallrGr4rextendrdictzip_check_homomorphismr )r r r rcheckr)r rr r homomorphism s&rkc st|dr|n|}|j}|j}dd|D}tt||j|jfdd}|D]h}t|tr| ||} | dkr| } | ||} | dkr| st dn ||j } | sZdSqZd 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_reprTrrrr.Fsz'_check_homomorphism..cs0}|jD] \}}|}|||9}q |Sr )rH)r@r"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 presentationrlrrgrhrrrequalsZmake_confluent RuntimeErrorr) r r rZpresZrelsr symbolsrr@r$successrrorri6s&     ricsddlmddlm}|t}|jtfdd|jD}|jdt |||}t|j tkr|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&SymmetricGroupcs*i|]"fddDqS)csg|]}|AqSr)index)r+o)r!omegarrr.rsz1orbit_homomorphism...rr+r'rryr!rrWrsz&orbit_homomorphism..)base) r/r' sympy.combinatorics.named_groupsrvr4rrrZ_schreier_simsr Zbasic_stabilizersrr)groupryrvr rrZrr{rorbit_homomorphismgs     rc sddlmddlm}t|}d}gdg|t|D]*}|||kr:|||<|d7}q:t|D]}|||<qn||}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&ruNrOcs(i|] fddDqS)csg|]}|AqSrr)r+r5)br!rMrrr.sz1block_homomorphism...rrzr'rrrMr|rrWsz&block_homomorphism..) r/r'r~rvr4r3r=rr ) rblocksrvnmr5r rrZrrrblock_homomorphism{s$         rc Cst|ttfstdt|ttfs,tdt|trt|trt|}t|}|j|jkr|j|jkr|sxdSdt|||j|jfS|}| }| }|t j krt dt|tr|t j krt d| \}}||ks|j|jkr|sdSdS|s|}t|t|dkrdSt|j}t|t|D]} t| } | |jgt|jt| tt|| } t||| r8t|tr|| } t|||j| dd} | r8|sdSd| fSq8|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 FpGroupTzrZ isomorphismZ_HZg_orderZh_orderZ h_isomorphismrr ZsubsetrZ_imagesTrrrgroup_isomorphismsX8          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>rZrrr is_isomorphicsr)rT)T)rZsympy.combinatorics.fp_groupsrrrr0rZsympy.combinatorics.perm_groupsrZsympy.core.numbersrZsympy.ntheory.factor_rZsympy.core.singletonr r rkrirrrrrrrrs      )1$ t