ިsgbdZdgZddlZddlmZmZddlmZmZdZ dZ dZ d Z Gd dZ y) a ISMAGS Algorithm ================ Provides a Python implementation of the ISMAGS algorithm. [1]_ It is capable of finding (subgraph) isomorphisms between two graphs, taking the symmetry of the subgraph into account. In most cases the VF2 algorithm is faster (at least on small graphs) than this implementation, but in some cases there is an exponential number of isomorphisms that are symmetrically equivalent. In that case, the ISMAGS algorithm will provide only one solution per symmetry group. >>> petersen = nx.petersen_graph() >>> ismags = nx.isomorphism.ISMAGS(petersen, petersen) >>> isomorphisms = list(ismags.isomorphisms_iter(symmetry=False)) >>> len(isomorphisms) 120 >>> isomorphisms = list(ismags.isomorphisms_iter(symmetry=True)) >>> answer = [{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}] >>> answer == isomorphisms True In addition, this implementation also provides an interface to find the largest common induced subgraph [2]_ between any two graphs, again taking symmetry into account. Given `graph` and `subgraph` the algorithm will remove nodes from the `subgraph` until `subgraph` is isomorphic to a subgraph of `graph`. Since only the symmetry of `subgraph` is taken into account it is worth thinking about how you provide your graphs: >>> graph1 = nx.path_graph(4) >>> graph2 = nx.star_graph(3) >>> ismags = nx.isomorphism.ISMAGS(graph1, graph2) >>> ismags.is_isomorphic() False >>> largest_common_subgraph = list(ismags.largest_common_subgraph()) >>> answer = [{1: 0, 0: 1, 2: 2}, {2: 0, 1: 1, 3: 2}] >>> answer == largest_common_subgraph True >>> ismags2 = nx.isomorphism.ISMAGS(graph2, graph1) >>> largest_common_subgraph = list(ismags2.largest_common_subgraph()) >>> answer = [ ... {1: 0, 0: 1, 2: 2}, ... {1: 0, 0: 1, 3: 2}, ... {2: 0, 0: 1, 1: 2}, ... {2: 0, 0: 1, 3: 2}, ... {3: 0, 0: 1, 1: 2}, ... {3: 0, 0: 1, 2: 2}, ... ] >>> answer == largest_common_subgraph True However, when not taking symmetry into account, it doesn't matter: >>> largest_common_subgraph = list(ismags.largest_common_subgraph(symmetry=False)) >>> answer = [ ... {1: 0, 0: 1, 2: 2}, ... {1: 0, 2: 1, 0: 2}, ... {2: 0, 1: 1, 3: 2}, ... {2: 0, 3: 1, 1: 2}, ... {1: 0, 0: 1, 2: 3}, ... {1: 0, 2: 1, 0: 3}, ... {2: 0, 1: 1, 3: 3}, ... {2: 0, 3: 1, 1: 3}, ... {1: 0, 0: 2, 2: 3}, ... {1: 0, 2: 2, 0: 3}, ... {2: 0, 1: 2, 3: 3}, ... {2: 0, 3: 2, 1: 3}, ... ] >>> answer == largest_common_subgraph True >>> largest_common_subgraph = list(ismags2.largest_common_subgraph(symmetry=False)) >>> answer = [ ... {1: 0, 0: 1, 2: 2}, ... {1: 0, 0: 1, 3: 2}, ... {2: 0, 0: 1, 1: 2}, ... {2: 0, 0: 1, 3: 2}, ... {3: 0, 0: 1, 1: 2}, ... {3: 0, 0: 1, 2: 2}, ... {1: 1, 0: 2, 2: 3}, ... {1: 1, 0: 2, 3: 3}, ... {2: 1, 0: 2, 1: 3}, ... {2: 1, 0: 2, 3: 3}, ... {3: 1, 0: 2, 1: 3}, ... {3: 1, 0: 2, 2: 3}, ... ] >>> answer == largest_common_subgraph True Notes ----- - The current implementation works for undirected graphs only. The algorithm in general should work for directed graphs as well though. - Node keys for both provided graphs need to be fully orderable as well as hashable. - Node and edge equality is assumed to be transitive: if A is equal to B, and B is equal to C, then A is equal to C. References ---------- .. [1] M. Houbraken, S. Demeyer, T. Michoel, P. Audenaert, D. Colle, M. Pickavet, "The Index-Based Subgraph Matching Algorithm with General Symmetries (ISMAGS): Exploiting Symmetry for Faster Subgraph Enumeration", PLoS One 9(5): e97896, 2014. https://doi.org/10.1371/journal.pone.0097896 .. [2] https://en.wikipedia.org/wiki/Maximum_common_induced_subgraph ISMAGSN)Counter defaultdict)reducewrapsc |j}t|dkDrd}t|dt |}t |dt fd|DS#t$rY6wxYw)af Returns ``True`` if and only if all elements in `iterable` are equal; and ``False`` otherwise. Parameters ---------- iterable: collections.abc.Iterable The container whose elements will be checked. Returns ------- bool ``True`` iff all elements in `iterable` compare equal, ``False`` otherwise. z7The function does not works on multidimensional arrays.Nc3(K|] }|k( ywN).0itemfirsts Y/var/www/html/venv/lib/python3.12/site-packages/networkx/algorithms/isomorphism/ismags.py z are_all_equal..s2tu}2)shapelenNotImplementedErrorAttributeErroriternextall)iterablermessageiteratorrs @r are_all_equalrtsj 9 u:>OG%g.D 8H~H 4 E 22 22    s A A"!A"cg}|D]K}|D]2}tt|}|||s!|j|9|j|hM|S)a Partitions items into sets based on the outcome of ``test(item1, item2)``. Pairs of items for which `test` returns `True` end up in the same set. Parameters ---------- items : collections.abc.Iterable[collections.abc.Hashable] Items to partition test : collections.abc.Callable[collections.abc.Hashable, collections.abc.Hashable] A function that will be called with 2 arguments, taken from items. Should return `True` if those 2 items need to end up in the same partition, and `False` otherwise. Returns ------- list[set] A list of sets, with each set containing part of the items in `items`, such that ``all(test(*pair) for pair in itertools.combinations(set, 2)) == True`` Notes ----- The function `test` is assumed to be transitive: if ``test(a, b)`` and ``test(b, c)`` return ``True``, then ``test(a, c)`` must also be ``True``. )rraddappend)itemstest partitionsr partitionp_items rmake_partitionsr&sh4J&# &I$y/*FD&! d#  &   tf %& cHi}t|D]\}}|D]}|||< |S)a/ Creates a dictionary that maps each item in each partition to the index of the partition to which it belongs. Parameters ---------- partitions: collections.abc.Sequence[collections.abc.Iterable] As returned by :func:`make_partitions`. Returns ------- dict ) enumerate)r#colorscolorkeyskeys rpartition_to_colorr.s@F , t CF3K   Mr'ct|}|j}ttj|t|}t ||S)ax Given an collection of sets, returns the intersection of those sets. Parameters ---------- collection_of_sets: collections.abc.Collection[set] A collection of sets. Returns ------- set An intersection of all sets in `collection_of_sets`. Will have the same type as the item initially taken from `collection_of_sets`. )listpoprset intersectiontype)collection_of_setsrouts r intersectr7sH01  " " $E !!#5s5z BC 4;s r'ceZdZdZd&dZedZedZedZedZ edZ ed Z ed Z ed Z ed Zed ZedZedZd'dZedZdZd'dZdZd(dZd(dZd'dZd'dZdZedZedZedZe d(dZ!dZ"d)dZ#d*d Z$ed!Z%ed"Z&ed#Z'd$Z( d)d%Z)y)+ra% Implements the ISMAGS subgraph matching algorithm. [1]_ ISMAGS stands for "Index-based Subgraph Matching Algorithm with General Symmetries". As the name implies, it is symmetry aware and will only generate non-symmetric isomorphisms. Notes ----- The implementation imposes additional conditions compared to the VF2 algorithm on the graphs provided and the comparison functions (:attr:`node_equality` and :attr:`edge_equality`): - Node keys in both graphs must be orderable as well as hashable. - Equality must be transitive: if A is equal to B, and B is equal to C, then A must be equal to C. Attributes ---------- graph: networkx.Graph subgraph: networkx.Graph node_equality: collections.abc.Callable The function called to see if two nodes should be considered equal. It's signature looks like this: ``f(graph1: networkx.Graph, node1, graph2: networkx.Graph, node2) -> bool``. `node1` is a node in `graph1`, and `node2` a node in `graph2`. Constructed from the argument `node_match`. edge_equality: collections.abc.Callable The function called to see if two edges should be considered equal. It's signature looks like this: ``f(graph1: networkx.Graph, edge1, graph2: networkx.Graph, edge2) -> bool``. `edge1` is an edge in `graph1`, and `edge2` an edge in `graph2`. Constructed from the argument `edge_match`. References ---------- .. [1] M. Houbraken, S. Demeyer, T. Michoel, P. Audenaert, D. Colle, M. Pickavet, "The Index-Based Subgraph Matching Algorithm with General Symmetries (ISMAGS): Exploiting Symmetry for Faster Subgraph Enumeration", PLoS One 9(5): e97896, 2014. https://doi.org/10.1371/journal.pone.0097896 Nc||_||_||_d|_d|_d|_d|_d|_d|_d|_ d|_ d|_ d|_ |k|jd|_t|jj g|_t|jj g|_ddi|_ n|j||_|k|j#d|_t|jj&g|_t|jj&g|_ddi|_ y|j#||_y)a Parameters ---------- graph: networkx.Graph subgraph: networkx.Graph node_match: collections.abc.Callable or None Function used to determine whether two nodes are equivalent. Its signature should look like ``f(n1: dict, n2: dict) -> bool``, with `n1` and `n2` node property dicts. See also :func:`~networkx.algorithms.isomorphism.categorical_node_match` and friends. If `None`, all nodes are considered equal. edge_match: collections.abc.Callable or None Function used to determine whether two edges are equivalent. Its signature should look like ``f(e1: dict, e2: dict) -> bool``, with `e1` and `e2` edge property dicts. See also :func:`~networkx.algorithms.isomorphism.categorical_edge_match` and friends. If `None`, all edges are considered equal. cache: collections.abc.Mapping A cache used for caching graph symmetries. NcyNTr )n1n2s rz!ISMAGS.__init__..@r'rcyr;r )e1e2s rr>z!ISMAGS.__init__..Gr?r')graphsubgraph_symmetry_cache_sgn_partitions__sge_partitions_ _sgn_colors_ _sge_colors__gn_partitions__ge_partitions_ _gn_colors_ _ge_colors_ _node_compat_ _edge_compat__node_match_maker node_equalityr2nodes_edge_match_maker edge_equalityedges)selfrCrD node_match edge_matchcaches r__init__zISMAGS.__init__ sF2   $!% $  ##!!  !%!7!78K!LD %()<)<%=$>D !$' (8(8$9#:D "#QD !%!7!7 !CD   !%!7!78K!LD %()<)<%=$>D !$' (8(8$9#:D "#QD !%!7!7 !CD r'cj*fd}tjj|_jS)NcTjj|j|Sr )rQrDnode1node2rVs r nodematchz)ISMAGS._sgn_partitions..nodematchR"))$-- uUUr')rFr&rDrRrVr`s` r_sgn_partitionszISMAGS._sgn_partitionsN<  ( V%4DMM4G4G$SD !$$$r'cj*fd}tjj|_jS)NcTjj|j|Sr )rTrDedge1edge2rVs r edgematchz)ISMAGS._sge_partitions..edgematch\rar')rGr&rDrUrVrjs` r_sge_partitionszISMAGS._sge_partitionsXrdr'cj*fd}tjj|_jS)NcTjj|j|Sr )rQrCr]s rr`z(ISMAGS._gn_partitions..nodematchf"))$**eTZZOOr')rJr&rCrRrbs` r_gn_partitionszISMAGS._gn_partitionsb<    ' P$34::3C3CY#OD ###r'cj*fd}tjj|_jS)NcTjj|j|Sr )rTrCrgs rrjz(ISMAGS._ge_partitions..edgematchpror')rKr&rCrUrks` r_ge_partitionszISMAGS._ge_partitionslrqr'cf|jt|j|_|jSr )rHr.rcrVs r _sgn_colorszISMAGS._sgn_colorsv-    $ 243G3G HD    r'cf|jt|j|_|jSr )rIr.rlrvs r _sge_colorszISMAGS._sge_colors|rxr'cf|jt|j|_|jSr )rLr.rprvs r _gn_colorszISMAGS._gn_colors-    #1$2E2EFD r'cf|jt|j|_|jSr )rMr.rtrvs r _ge_colorszISMAGS._ge_colorsr}r'c|j |jSi|_tjtt |j tt |j D]\}}tt|j |}tt|j |}|j|j||j|sq||j|<|jSr ) rN itertoolsproductrangerrcrprrrQrDrC)rVsgn_part_color gn_part_colorsgngns r_node_compatibilityzISMAGS._node_compatibility    )%% %-6->-> #d**+ ,eC8K8K4L.M.  C )NMtD00@ABCd4..}=>?B!!$--djj"E5B"">2  C!!!r'c|j |jSi|_tjtt |j tt |j D]\}}tt|j |}tt|j |}|j|j||j|sq||j|<|jSr ) rOrrrrrlrtrrrTrDrC)rVsge_part_color ge_part_colorsgeges r_edge_compatibilityzISMAGS._edge_compatibilityrr'c.tfd}|S)NcJ|j||j|Sr )rR)graph1r^graph2r_cmps rcomparerz*ISMAGS._node_match_maker..comparer"v||E*FLL,?@ @r'rrrs` rrPzISMAGS._node_match_maker" s A  Ar'c.tfd}|S)NcJ|j||j|Sr )rU)rrhrrirs rrz*ISMAGS._edge_match_maker..comparerrr'rrs` rrSzISMAGS._edge_match_makerrr'c# K|jsiy|jsyt|jt|jkry|rF|j|j|j|j \}}|j |}ng}|j |j}|jD]}||}|s |t|hz |<!t jr>t fd}t |f |<|j| |Ed{yy7w)aFind all subgraph isomorphisms between subgraph and graph Finds isomorphisms where :attr:`subgraph` <= :attr:`graph`. Parameters ---------- symmetry: bool Whether symmetry should be taken into account. If False, found isomorphisms may be symmetrically equivalent. Yields ------ dict The found isomorphism mappings of {graph_node: subgraph_node}. Nc,t|tSNr-minrn candidatess rr>z*ISMAGS.find_isomorphisms..sc*Q-S6Qr'r)rDrCranalyze_symmetryrcrz_make_constraints_find_nodecolor_candidates_get_lookahead_candidates frozensetanyvaluesrr7 _map_nodes) rVsymmetry_cosets constraints la_candidatesrextra_candidates start_sgnrs @rfind_isomorphismszISMAGS.find_isomorphismss3$}}H   _s4==1 1  -- t33T5E5EIAv008KK446 668 == RC,S1 ",S/Y?O5P4Q"Q 3 R z  " #J,QRI%.z)/D%E$GJy !y*kJ J J  KsC EA(E7D>8Ect}||}|D]+}||}||f|vr|||f}n|||f}|||fxxdz cc<-|S)z For `node` in `graph`, count the number of edges of a specific color it has to nodes of a specific color. r )r) rCnode node_color edge_colorcounts neighborsneighborn_colore_colors r_find_neighbor_color_countz!ISMAGS._find_neighbor_color_countsr $K ! *H *Gh:-$T8^4$Xt^4 7G# $ ) $  * r'cv i}|jD]7}|j|j||j|j||<9t t }|j D]}|j|j ||j|j}t |jD].\\}}} |j|} |j|} | | | f<0|jD]/\} t fd Ds||j|1|S#t$rYwxYw)z Returns a mapping of {subgraph node: collection of graph nodes} for which the graph nodes are feasible candidates for the subgraph node, as determined by looking ahead one edge. c34K|]}||kywr r )r xg_count new_sg_counts rrz3ISMAGS._get_lookahead_candidates..sK|A'!*4Ks)rCrr|rrr2rDrwrzrr!rrKeyErrorrr) rVg_countsrrrsg_count sge_color sgn_colorcountge_colorgn_colorrrs @@rrz ISMAGS._get_lookahead_candidatessE ** B:: BHRL !% == ,C66 sD$4$4d6F6FH#9L191A =-&I=#77 BH#77 BH8=L8!34 = (~~/ , GKlKKsO''+ , ,$ s?D,, D87D8c#hK|jsiy|jsy|rF|j|j|j|j\}}|j |}ng}|j }t|jr|j||Ed{yy7w)a Find the largest common induced subgraphs between :attr:`subgraph` and :attr:`graph`. Parameters ---------- symmetry: bool Whether symmetry should be taken into account. If False, found largest common subgraphs may be symmetrically equivalent. Yields ------ dict The found isomorphism mappings of {graph_node: subgraph_node}. N) rDrCrrcrzrrrr_largest_common_subgraph)rVrrrrrs rlargest_common_subgraphzISMAGS.largest_common_subgraphs$}}H   -- t33T5E5EIAv008KK446 z  " #44ZM M M  NsB'B2)B0*B2c |jtt|jt|jtt t|t|j f}||jvr|j|St|j|||}t|dk(sJ|d}|j||||\}}|j||f|j<||fS)a Find a minimal set of permutations and corresponding co-sets that describe the symmetry of `graph`, given the node and edge equalities given by `node_partitions` and `edge_colors`, respectively. Parameters ---------- graph : networkx.Graph The graph whose symmetry should be analyzed. node_partitions : list of sets A list of sets containing node keys. Node keys in the same set are considered equivalent. Every node key in `graph` should be in exactly one of the sets. If all nodes are equivalent, this should be ``[set(graph.nodes)]``. edge_colors : dict mapping edges to their colors A dict mapping every edge in `graph` to its corresponding color. Edges with the same color are considered equivalent. If all edges are equivalent, this should be ``{e: 0 for e in graph.edges}``. Returns ------- set[frozenset] The found permutations. This is a set of frozensets of pairs of node keys which can be exchanged without changing :attr:`subgraph`. dict[collections.abc.Hashable, set[collections.abc.Hashable]] The found co-sets. The co-sets is a dictionary of ``{node key: set of node keys}``. Every key-value pair describes which ``values`` can be interchanged without changing nodes less than ``key``. r r) rEhashtuplerRrUmapr!r0_refine_node_partitionsr _process_ordered_pair_partitions)rVrCnode_partitions edge_colorsr- permutationsrs rrzISMAGS.analyze_symmetryBs@    +%++&%++&#e_56+++-. Cd***++C00  ( ( M ?#q((()!,#DD ?O[  f    +(4f(3##Id.A.A(.K$LM3##IK0  1*% &,,. 1LC'0JsO 1r'czg}|jD]%\}}|D]}||k7s |j||f'|S)z/ Turn cosets into constraints. )r!r )rrnode_inode_tsnode_ts rrzISMAGS._make_constraintssT  %||~ 9OFG! 9V#&&'78 9 9 r'c2td}|jD]D\}}||f|vr|||f}n|||f}|||||fxxdz cc<|||||fxxdz cc<Fi}|jD]&}||t||j f||<(|S)z For every node in graph, come up with a color that combines 1) the color of the node, and 2) the number of edges of a color to each type of node. c ttSr )rintr r'rr>z.ISMAGS._find_node_edge_color..s [%5r'r )rrUrRr2r!) rC node_colorsrrr^r_ecolornode_edge_colorsrs r_find_node_edge_colorzISMAGS._find_node_edge_colors56!KK ;LE5u~,$UE\2$UE\2 5M&+e"44 5 : 5 5M&+e"44 5 : 5 ;KK RD%0%6F4L>> found = list(ISMAGS._get_permutations_by_length([[1], [2], [3, 4], [4, 5]])) >>> answer = [ ... (([1], [2]), ([3, 4], [4, 5])), ... (([1], [2]), ([4, 5], [3, 4])), ... (([2], [1]), ([3, 4], [4, 5])), ... (([2], [1]), ([4, 5], [3, 4])), ... ] >>> found == answer True c3NK|]}tj|ywr )rr)r lby_lens rrz5ISMAGS._get_permutations_by_length..s HAi$$VAY/ Hs"%N)rr0rr rrsorted)r!rrs @r_get_permutations_by_lengthz"ISMAGS._get_permutations_by_lengths_ T" +D 3t9  $ $T * +$$ H H   sAA&A$A&c #Kfd}t|}t|}|j|||tfd|Dr|yg}|g}|D]} t fd| Dst | |} |rt | dk7rt | D chc] } t | c} t | D cgc] } t | c} k7rD|j| } g} |D])}| D]"}| j|t|dz$+| }|D]"}|jt| t $|D]}|j| |D]}|j||||Ed{ ycc} wcc} w7w)z Given a partition of nodes in graph, make the partitions smaller such that all nodes in a partition have 1) the same color, and 2) the same number of edges to specific other partitions. c||k(Sr r )r^r_rs r equal_colorz3ISMAGS._refine_node_partitions..equal_colors#E*.>u.EE Er'c3FK|]}tfd|Dyw)c3(K|] }| ywr r r rrs rrz;ISMAGS._refine_node_partitions...sGT*40GrN)r)r r$rs rrz1ISMAGS._refine_node_partitions..s$  GYG G s!Nc3(K|] }| ywr r rs rrz1ISMAGS._refine_node_partitions..s ND!1$!7 Nrr rr) r0r.rrrr&rrr extendrr)clsrCrrbranchrrnew_partitionsoutputr$refinedrr new_outputn_p permutationrs @rrzISMAGS._refine_node_partitionss F/(9 44UKU  ,  " !  !( *I NI NN))[AG )W5SV56#w>W!s1v>W:XX$'#B#B7#KL!#J%J+7JK&--cDQ4H.HIJJ(F%= 6's#;<="*CJJy)*/ *2 TC225#{FS S S T'6>W( Ts+B FE4 F/E9 B+F,E>-Fc||f|jvr|j||f}n|j||f}||jvr |j|}|j|}|Sg}|S)z Returns all edges in :attr:`graph` that have the same colour as the edge between sgn1 and sgn2 in :attr:`subgraph`. )rzrrt)rVsgn1sgn2rrg_edgess r_edges_of_same_colorzISMAGS._edges_of_same_color#s $<4++ +((t4I((t4I 00 0// :H))(3GGr'c #K|i}n|j}|t|jj}t ||}t |g||<|D]}||j vs||vr|||<|t|jk(r'|jD cic]\}} | | c} }c|t|jz } |jt|j|} t|jjt|j|z } | D]} | | vr| }n/|j|| }|Dchc]}|D] }||vs| }}}| jt |g| <|| f|vr |jDchc] }||kDs | }}n'| |f|vr |jDchc] }||ks | }}n| jt |g| <t| fd}|j||||Ed{ycc} }wcc}}wcc}wcc}w7w)zF Find all subgraph isomorphisms honoring constraints. Nc,t|tSrr)rnew_candidatess rr>z#ISMAGS._map_nodes..usc.:KQT6Ur'r)mapping to_be_mapped)copyr2rDrRr7rrr,r!rCr unionrr)rVrrrrrsgn_candidatesrkv left_to_mapsgn_nbrs not_gn_nbrsr  gn2_optionsr ergn2next_sgnrs @rrzISMAGS._map_nodes4si ?GllnG  t}}223L #:c?3#^$45 3 8 BW^^%%L)@GCLs7<<>22(/ 81q!t88&W\\^)<z1ISMAGS._largest_common_subgraph..sC 1 34Or')rTr )rrDrRrrrrCrrr StopIterationr2 _remove_noderr) rVrrr current_size found_isorRr isomorphsrleft_to_be_mappedr new_nodess ` rrzISMAGS._largest_common_subgraphsW  %dmm&9&9:;L4\ 2B78  3tzz? * &9 %u*OP OOj+E, % ?DJ((( $I! %&  ) E! 1E 1!--c5+F !%%i0 1 100  2C1   3) %: sCBD) D# D),D-A#D)D'D) D$!D)#D$$D)cV |D]\}}||k(s ||vs|}nnt||hz S)a& Returns a new set where node has been removed from nodes, subject to symmetry constraints. We know, that for every constraint we have those subgraph nodes are equal. So whenever we would remove the lower part of a constraint, remove the higher instead. )r)rrRrlowhighs rr!zISMAGS._remove_nodesL(  T$;45=D   $((r'c (t}t||D]x\}}t|dk7st|dk7rtd|d|||k7s9|j t t t|t t|fz|S)z Return the pairs of top/bottom partitions where the partitions are different. Ensures that all partitions in both top and bottom partitions have size 1. r z/Not all nodes are coupled. This is impossible: z, )r2zipr IndexErrorrrrr)top_partitionsbottom_partitionsrtopbots r_find_permutationszISMAGS._find_permutationssu N,=> PHC3x1}CA  $$2#326G5HJcz  DcOT$s)_+M!NO Pr'c|D]Q}|\}}dx}}t|D]\}}||n||vr|}||vs|}||k7s8||j||||=Sy)z Update orbits based on permutations. Orbits is modified in place. For every pair of items in permutations their respective orbits are merged. N)r)update) orbitsrrrr_rsecondidxorbits r_update_orbitszISMAGS._update_orbitss( #K%KD%" !EF'/ ! U$);5=EE> F  !u $$VF^46N #r'c#K||}||} ||vr|| vsJ|D cgc]} | j} } |D cgc]} | j} } |h||hz f}|h| |hz f}| |=| |=|| |||| |||j|| |} |j|| |d} t| } t| dk(sJ| d} | D]} t| | fycc} wcc} ww)z Generate new partitions from top and bottom_partitions where t_node is coupled to b_node. pair_idx is the index of the partitions where t_ and b_node can be found. T)rr rN)rrr0r)rVr-r.pair_idxt_nodeb_noderCr t_partition b_partitionr/new_top_partitionsr0new_bottom_partitions new_t_groups new_b_groupss r _couple_nodeszISMAGS._couple_nodessF%X. '1 $;)>>>4BCSchhjCC7H I I Ixx!77 xx!77 x ( !( +0<8H-3?hx0!99 %{ !% < < (+d!=! ""45%&!+++/2( 0C)*C/ / 0'D IsCCCCB Cc ||jDcgc]}|h}}n|}|i}n|j}tdt||DsJtd|Dr/|j ||}|j |||r|g|fSg|fSg}t |D chc]\} } | D]}t| dkDr|| f } } } }t| \} || } t| D]~t| dk(rk7rtfd|Dr-|j||| ||}|D]6}|\}}|j||||||\}}||z }|j|8t||Dchc]!\}}|D]}t|dk(r||k(r|#}}}}|jDchc] }|ks | }}||kxr|v}|r|D]}|vs|j|<||fScc}wcc}} } wcc}}}wcc}w)z Processes ordered pair partitions as per the reference paper. Finds and returns all permutations and cosets that leave the graph unchanged. c3PK|]\}}t|t|k( ywr r)r t_pb_ps rrz:ISMAGS._process_ordered_pair_partitions..Bs& %-S#CHC  s$&c38K|]}t|dk(yw)r NrF)r r/s rrz:ISMAGS._process_ordered_pair_partitions..Gs7s3x1}7sr c32K|]}|vxr|vywr r )r r7rr_s rrz:ISMAGS._process_ordered_pair_partitions..^s&%5: 0%5.0%s)rRrrr+r1r8r)rrrrrCrr3)rVrCr-r.rr4rrrr6r=unmapped_nodesr:r>r#oppr?r@ new_perms new_cosetsr/bottomrmappedks find_cosetr7r_s ` @rrz'ISMAGS._process_ordered_pair_partitions)s >).5tf5F5 F >F[[]F 14^EV1W    77 722>CTUL    5$~v--6z! %.n$=   [# ;!#3K   ^,h'1 K(! *E;1$u}%>D%"++!J" *3DE  V 3x1}     1ADa 1 16\8d&&8  05=#(::r]s?jX *,#3<#L**i$i$r'