o o hI@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 rru/var/www/html/construction_image-detection-poc/venv/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 r strong_gens generatorsr identity_strong_gens_slp) rrinverseskvgensgwpartssrrr_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'rr1rr-?s.         zGroupHomomorphism.invertcCs|jdur ||_|jS)z0 Compute the kernel of `self`. N)r_compute_kernelr1rrrkernelms  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)rGG_orderr#Kr:rr!rrrr;vs*        z!GroupHomomorphism._compute_kernelcCsP|jdur%tt|j}t|jtr|j||_|jSt |j||_|jS)z/ Compute the image of `self`. N) rrsetrvaluesrr rsubgroupr)rrHrrrrs  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.r1rrr2r3z,GroupHomomorphism._apply..z2The supplied element does not belong to the domainT)originalrr) r rrtuple ValueErrorrr rrrr7 array_formabs) relemrvaluer#r$r:_prr1rrKs.    zGroupHomomorphism._applycCs ||Sr rJ)rrQrrr__call__s zGroupHomomorphism.__call__cC|dkS)z9 Check if the homomorphism is injective )r<r>r1rrr is_injectivezGroupHomomorphism.is_injectivecCs6|}|j}|tjur|tjurdS||kS)z: Check if the homomorphism is surjective N)rr>r r r?)rimothrrr is_surjectives  zGroupHomomorphism.is_surjectivecCs|o|S)z5 Check if `self` is an isomorphism. )rXr\r1rrris_isomorphismrYz GroupHomomorphism.is_isomorphismcCrV)zs Check is `self` is a trivial homomorphism, i.e. all elements are mapped to the identity. rW)rr>r1rrr 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 rNrr r )rrarrr`rcomposeszGroupHomomorphism.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|]}||qSrrr_r1rrrbr3z1GroupHomomorphism.restrict_to..)rrrdr rNrr r )rHr rrr1r 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) rdrrNrrrr-rBr<)rrfr#Phh_ir!rrrinvert_subgroups     z!GroupHomomorphism.invert_subgroupN)__name__ __module__ __qualname____doc__rr(r-r<r;rrKrUrXr\r]r^rergrkrrrrr 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 rr_)rrr #zhomomorphism..zCThe supplied generators must be a subset of the domain's generatorsc3rpr rr_)r rrrq%rrz+The images must be elements of the codomainz>The number of images must be equal to the number of generatorscsg|]}|vr|qSrrr_)r#rrr2/sz homomorphism..z-The given images do not define a homomorphism)rrrr TypeErrorrallrNr9rextendrdictzip_check_homomorphismr )r r r#rcheckr)r rr#r homomorphism s& rzc 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)ext_repr_rrrr2Fr3z'_check_homomorphism..cs0}|jD]\}}|}|||9}q|Sr )rO)rFr%symbolpowerr$rrsymbols_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) hasattr presentationr{rrvrwrrrequalsmake_confluent RuntimeErrorr) r r rpresrelsr#symbolsrrFr'successrrrrx6s*    rxcsddlmddlm}|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$omegarrr2rrcz1orbit_homomorphism...rr/r*rrr$rrbrs*z&orbit_homomorphism..)base) r4r* sympy.combinatorics.named_groupsrr9rrr_schreier_simsr basic_stabilizersrr)grouprrr rrfrrrorbit_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)rNrWcs(i|]fddDqS)csg|] }|AqSrr)r/r:)br$rTrrr2sz1block_homomorphism...rrr*rrrTrrrbs(z&block_homomorphism..) r4r*rrr9r8rBrr ) rblocksrnmr:r rrfrrrblock_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 FpGroupTzr r?r@_to_perm_group is_abelianrrr itertools permutationsr9rurrvrwrxr-r]) rCrf isomorphism_Hg_orderh_order h_isomorphismrr#subsetr_imagesTrrrgroup_isomorphismsZ8           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)rCrfrrr is_isomorphicsr)rT)T)rsympy.combinatorics.fp_groupsrrrr5rsympy.combinatorics.perm_groupsrsympy.core.intfuncr%sympy.functions.combinatorial.numbersrsympy.core.singletonr r rzrxrrrrrrrrs       )1 $ t