\hISSKrSSKJrJrJr SSKJr SSKJr SSK J r SSK J r SSK Jr "SS 5rSS jrS rS rS rSSjrSrg)N)FpGroup FpSubgroupsimplify_presentation) FreeGroup)PermutationGroup)igcd)totient)Scr\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrg)GroupHomomorphism z A class representing group homomorphisms. Instantiate using `homomorphism()`. References ========== .. [1] Holt, D., Eick, B. and O'Brien, E. (2005). Handbook of computational group theory. cRXlX lX0lSUlSUlSUlgN)domaincodomainimages _inverses_kernel_image)selfrrrs Y/var/www/auris/envauris/lib/python3.13/site-packages/sympy/combinatorics/homomorphisms.py__init__GroupHomomorphism.__init__s&     ctUR5n0n[URR55H0nURUnXB;aMUR(aM,X2U'M2 [ UR [5(a URnO URnUHnXb;dUR(aMURRn[ UR [5(aURUSSS2nOUnUHn X;a XrU -nMXrU S-S--nM XrU'M U$)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_invsGroupHomomorphism._invss dkk&&()A AAM}}} * dmm%5 6 6$$D##DA}  $$A$--)9::..q1$B$7=1+ A1b5/2--A  QKrcSSKJn SSKJn [ XU45(Ga([ UR [ 5(aUR RU5nURcUR5UlUR5nURRn[ UR [5(aURU5SSS2nOUn[[!U55HSnXgnUR"(aMXR;aXPRU-nM<XPRUS-S--nMU U$[ U[$5(a!UV s/sHoR'U 5PM sn $gs sn f)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)FreeGroupElementNr)sympy.combinatoricsr2sympy.combinatorics.free_groupsr3r!rrreducerr.rrr$rgenerator_productrangelenr rinvert) rr*r2r3rr+r)ir-es rr:GroupHomomorphism.invert?s3 4D a'78 9 9$--11MM((+~~%!%JJLE $$A$--)9::..q1$B$73t9%G==&..++A..B/33A&H 4 ,-.AqKKNA. .!.s!E?c^URcUR5UlUR$)z Compute the kernel of `self`. )r_compute_kernelrs rkernelGroupHomomorphism.kernelms( << //1DL||rc^URnUR5nU[RLa [ S5e/n[ U[ 5(a[ UR5nO [XSS9nUR5R5nUR5U-U:waUR5nX`RU"U55S--nXt;a<URU5 [ U[ 5(a [ U5nO [XSS9nUR5U-U:waMU$)Nz9Kernel computation is not implemented for infinite groupsT)normalr) rorderr InfinityNotImplementedErrorr!rr$rrrandomr:append)rGG_orderr)Kr;rr's rr?!GroupHomomorphism._compute_kernelvs KK'') ajj %KM M a) * * ,A140A JJL   ggikW$ A++d1g&**Az Aa!122(.A"148AggikW$rcXURc[[URR 555n[ UR [5(a,UR RU5UlUR$[UR U5UlUR$)z Compute the image of `self`. ) rrsetrvaluesr!rrsubgroupr)rrQs rrGroupHomomorphism.images| ;; #dkk00234F$--)9::"mm44V< {{)? {{rcXR;aG[U[[45(a!UVs/sHo R U5PM sn$[ S5eUR (aURR$URnURRn[UR[5(aJURRUSS9nUH(nX`R;a X6U-nMX6S-S-U-nM* U$SnURH/upU S:aXS-nOXnXCUU --nU[U 5- nM1 U$s snf)z Apply `self` to `elem`. z2The supplied element does not belong to the domainT)originalrr)rr!rtuple_apply ValueErrorr rr$rrr7 array_formabs) relemr<rvaluer)r*r;_ps rrWGroupHomomorphism._applys6 {{ "$u ..0451 A55QR R   ==)) )[[FMM**E$++'788{{44TD4IAKK' & % &"u r 1% 7   OODA1u GRK G!)Q,.EQKA , /6sE c$URU5$r)rW)rr[s r__call__GroupHomomorphism.__call__s{{4  rcDUR5R5S:H$)z) Check if the homomorphism is injective )rArEr@s r is_injectiveGroupHomomorphism.is_injectives {{}""$))rcUR5R5nURR5nU[RLaU[RLagX:H$)z* Check if the homomorphism is surjective N)rrErr rF)rimoths r is_surjectiveGroupHomomorphism.is_surjectivesL ZZ\   !mm!!#  qzz 19 rcPUR5=(a UR5$)z% Check if `self` is an isomorphism. )rerjr@s ris_isomorphism GroupHomomorphism.is_isomorphisms!   ";t'9'9';;rcDUR5R5S:H$)z[ Check is `self` is a trivial homomorphism, i.e. all elements are mapped to the identity. rd)rrEr@s r is_trivialGroupHomomorphism.is_trivials zz|!!#q((rc UR5RUR5(d [S5eURVs0sHo"U"U"U55_M nn[ URUR U5$s snf)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`)r is_subgrouprrXrr r)rotherr*rs rcomposeGroupHomomorphism.composesp{{}((55+, ,-2\\:\T%(^#\: t}}fEE;sBc[U[5(a URUR5(d [ S5eUnUR Vs0sH o3U"U5_M nn[ X RU5$s snf)zP Return the restriction of the homomorphism to the subgroup `H` of the domain. z'Given H is not a subgroup of the domain)r!rrsrrXr#r r)rHrr*rs r restrict_toGroupHomomorphism.restrict_tosi !-..ammDKK6P6PFG G&'ll3lT!W*l3 ??4sA;cURUR55(d [S5e/n[UR5R5nUR H~nUR U5nXS;aURU5 [U5nUR5R H+nXe-U;dM URXe-5 [U5nM- M U$)zn 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) rsrrXrr$r#r:rIrA)rrxr)Phh_ir's rinvert_subgroup!GroupHomomorphism.invert_subgroups }}TZZ\**EF F TZZ\22 3A++a.C| C $T*[[]--5>KK&(.A. r)rrrrrrN)__name__ __module__ __qualname____firstlineno____doc__rr.r:rAr?rrWrarerjrmrpruryr__static_attributes__rrr r sW!F,/\. @!* <) F @rr c,^^[U[[[45(d [ S5e[T[[[45(d [ S5eUR m[ U4SjU55(d [S5e[ U4SjU55(d [S5eU(a#[U5[U5:wa [S5e[U5n[U5nURTR/[T5[U5- -5 URTVs/sH oUU;dM UPM sn5 [[X#55nU(a[UTU5(d [S5e[UTU5$s snf) 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,># UH oT;v M g7frr).0r*r#s r homomorphism..#s-1JzCThe supplied generators must be a subset of the domain's generatorsc3,># UH oT;v M g7frr)rr*rs rrr%s-fH}frz+The images must be elements of the codomainz>The number of images must be equal to the number of generatorsz-The given images do not define a homomorphism)r!rrr TypeErrorr#allrXr9rextendr$dictzip_check_homomorphismr )rrr)rcheckr*r#s ` @r homomorphismr sC f/)D E E455 h!17I F G G677""J -- - -^__ -f- - -FGG #f+T*YZZ :D &\F MM8$$%s:s6{'BCDKKJ8Jq4-J89 #d" #F (6BBHII VXv 66 9s 2 F?FcN^^ ^ [US5(aUOUR5nURnURnUVs/sHofRSPM nn[ [ XpR55m URm U UU 4SjnUHn [U[5(aYURU"U 5T 5n U c=UR5n URU"U 5T 5n U cU (d [S5eOU"U 5Rn U (aM g gs snf)a9 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. relatorsrcV>TnURHup#TUnUTUU--nM U$r)rY)rMr+symbolpowerr*r$rsymbols_to_domain_generatorss rr#_check_homomorphism.._imageJs< \\MF,V4A E! !A*rzCan'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#ext_reprrr$r!requalsmake_confluent RuntimeErrorr )rrrpresrelsr)r*symbolsrrMr-successr$rs ` @@rrr6sVZ006f6I6I6KD ==D ??D%)*Tyy|TG*#'G5F5F(G#H   H h ( (q 84Ay#113OOF1Ix89W&(+,,q %%Aq'( ?+sD"cSSKJn SSKJn U"[ U55nUR n[ U5nURVVs0sH.ofXR"UVs/sHoqRXv- 5PM sn5-_M0 nnnURUS9 [XU5n [ UR5[ U5:aUR[ U5U l U $[UR /5U l U $s snfs snnf)z Return the homomorphism induced by the action of the permutation group ``group`` on the set ``omega`` that is closed under the action. rr1SymmetricGroup)base)r4r2 sympy.combinatorics.named_groupsrr9r$rr#index_schreier_simsr basic_stabilizersrr) groupomegar2rrr$r*orrxs rorbit_homomorphismrgs 0?c%j)H  H KERWRbRb cRbQ+&GA{{13'7&GHHHRbF c e$%62A 5 " "#c%j0++CJ7  H%enn%56 H'H cs C:C5, C:5C:c SSKJn SSKJn [ U5nSn/nS/U-n[ U5H'nXU:XdM UR U5 XWU'US- nM) [ U5H nXqUXx'M U"U5n [ U5n URV Vs0sH#oU"U Vs/sH oXhU - PM sn5_M% n n n[X U 5n U $s snfs snn f)aJ 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. rr1rNrd) r4r2rrr9r8rIr#r )rblocksr2rnmr^br;rr$r*rrxs rblock_homomorphismr{s0? F A A A qA 1X 9> HHQKaD FA  1X|a HQxHEJEUEU VEU:AQi:;;EUF V%62A H; Vs C!C4 CCc [U[[45(d [S5e[U[[45(d [S5e[U[5(a[U[5(a[ U5n[ U5nUR UR :XaaUR R5UR R5:Xa+U(dgS[XUR UR 54$UnUR5nUR5nU[RLa [S5e[U[5(a0U[RLa [S5eUR5up6XE:wdURUR:wa U(dggU(dUn[U[!U55S:Xag[#UR 5n[$R&"U[)U55Hn [#U 5n U R+UR,/[)UR 5[)U 5- -5 [/[1X55n [3XU 5(dMs[U[5(aWR5U 5n [XUR U SS9n U R75(dMU(d gSU 4s $ U(dgg)a 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 FpGroupTzrsMTT5<#9"BBH'7R/b (" Hrh6r