hbSrS/rSSKrSSKJrJr SSKJrJr Sr Sr Sr S r "S S5r g) 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^URn[U5S:aSn[U5Se[ U5n[ US5m[ U4SjU55$![a N8f=f)a6 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,># UH oT:Hv M g7fN).0itemfirsts X/var/www/html/env/lib/python3.13/site-packages/networkx/algorithms/isomorphism/ismags.py are_all_equal..s2u}s)shapelenNotImplementedErrorAttributeErroriternextall)iterablermessageiteratorrs @r are_all_equalrtsq 9 u:>OG%g.D 8 H~H 4 E 22 22    s A A&%A&c/nUHSnUH8n[[U55nU"X55(dM&URU5 M? URU15 MU U$)ab 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&s_4J#I$y/*FD!! d# $   tf % cL0n[U5Hup#UHnX!U'M M U$)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.s2F , C3K- Mr'c[U5nUR5n[[RU[U55n[ U5"U5$)aL 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 intersectr7sF01  " " $E !!#5s5z BC ;s r'c\rSrSrSrS(Sjr\S5r\S5r\S5r \S5r \S 5r \S 5r \S 5r \S 5r\S 5r\S5r\S5r\S5rS)Sjr\S5rSrS)SjrSrS*SjrS*SjrS)SjrS)SjrSr\S5r\S5r\S5r \!S*Sj5r"Sr#S+S jr$S,S!jr%\S"5r&\S#5r'\S$5r(S%r)S+S&jr*S'r+g)-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 NcXlX lXPlSUlSUlSUlSUlSUlSUlSUl SUl SUl SUl UckURS5Ul[URR 5/Ul[URR 5/UlSS0Ul OURU5UlUckUR#S5Ul[URR&5/Ul[URR&5/UlSS0Ul gUR#U5Ulg)an 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. NcgNTr )n1n2s r!ISMAGS.__init__..@tr'rcgr<r )e1e2s rr?r@GrAr')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)selfrErF node_match edge_matchcaches r__init__ISMAGS.__init__ s@2  $!% $  ##!!  !%!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'c^TRc+U4Sjn[TRRU5TlTR$)NcT>TRTRUTRU5$r )rSrFnode1node2rXs r nodematch)ISMAGS._sgn_partitions..nodematchR"))$-- uUUr')rHr&rFrTrXrcs` r_sgn_partitionsISMAGS._sgn_partitionsN<  ( V%4DMM4G4G$SD !$$$r'c^TRc+U4Sjn[TRRU5TlTR$)NcT>TRTRUTRU5$r )rVrFedge1edge2rXs r edgematch)ISMAGS._sge_partitions..edgematch\rer')rIr&rFrWrXros` r_sge_partitionsISMAGS._sge_partitionsXrir'c^TRc+U4Sjn[TRRU5TlTR$)NcT>TRTRUTRU5$r )rSrEr`s rrc(ISMAGS._gn_partitions..nodematchf"))$**eTZZOOr')rLr&rErTrfs` r_gn_partitionsISMAGS._gn_partitionsb<    ' P$34::3C3CY#OD ###r'c^TRc+U4Sjn[TRRU5TlTR$)NcT>TRTRUTRU5$r )rVrErls rro(ISMAGS._ge_partitions..edgematchprwr')rMr&rErWrqs` r_ge_partitionsISMAGS._ge_partitionslrzr'chURc[UR5UlUR$r )rJr.rgrXs r _sgn_colorsISMAGS._sgn_colorsv-    $ 243G3G HD    r'chURc[UR5UlUR$r )rKr.rrrs r _sge_colorsISMAGS._sge_colors|rr'chURc[UR5UlUR$r )rNr.rxrs r _gn_colorsISMAGS._gn_colors-    #1$2E2EFD r'chURc[UR5UlUR$r )rOr.r~rs r _ge_colorsISMAGS._ge_colorsrr'cURb UR$0Ul[R"[[ UR 55[[ UR 555Hup[[UR U55n[[UR U55nURURX0RU5(dMuX RU'M UR$r ) rP itertoolsproductrangerrgrxrrrSrFrE)rXsgn_part_color gn_part_colorsgngns r_node_compatibilityISMAGS._node_compatibility    )%% %-6->-> #d**+ ,eC8K8K4L.M. )NtD00@ABCd4..}=>?B!!$--jj"EE5B"">2 . !!!r'cURb UR$0Ul[R"[[ UR 55[[ UR 555Hup[[UR U55n[[UR U55nURURX0RU5(dMuX RU'M UR$r ) rQrrrrrrr~rrrVrFrE)rXsge_part_color ge_part_colorsgeges r_edge_compatibilityISMAGS._edge_compatibilityrr'c0^[T5U4Sj5nU$)NcJ>T"URUURU5$r )rT)graph1ragraph2rbcmps rcomparer*ISMAGS._node_match_maker..comparer"v||E*FLL,?@ @r'rrrs` rrRISMAGS._node_match_maker" s A  Ar'c0^[T5U4Sj5nU$)NcJ>T"URUURU5$r )rW)rrmrrnrs rr*ISMAGS._edge_match_maker..comparerrr'rrs` rrUISMAGS._edge_match_makerrr'c#^ # UR(d0v gUR(dg[UR5[UR5:agU(aEURURURUR 5up#UR U5nO/nUR5m UR5nURH%nXVnU(dMT U[U51-T U'M' [T R55(a<[T U 4SjS9n[T U54T U'URUT U5ShvN ggN7f)aiFind 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&>[TU[S9$Nr-minrn candidatess rr?*ISMAGS.find_isomorphisms..sc*Q-S6Qr'r)rFrEranalyze_symmetryrgr_make_constraints_find_nodecolor_candidates_get_lookahead_candidates frozensetanyvaluesrr7 _map_nodes) rXsymmetry_cosets constraints la_candidatesrextra_candidates start_sgnrs @rfind_isomorphismsISMAGS.find_isomorphismss-$}}H   _s4==1 1  -- t33T5E5EIA008KK446 668 ==C,1 ",S/Y?O5P4Q"Q 3! z  " # #J,QRI%.z)/D%E$GJy !y*kJ J J  KsCE#A-EEEc[5nXnUH)nX&nX4U;aX1U4nOX6U4nXHU4==S- ss'M+ U$)zk For `node` in `graph`, count the number of edges of a specific color it has to nodes of a specific color. r )r) rEnode node_color edge_colorcounts neighborsneighborn_colore_colors r_find_neighbor_color_count!ISMAGS._find_neighbor_color_countsa K !H *G:-$8^4$t^4 G# $ ) $ " r'c^ ^ 0nURH6nURURX RUR5X'M8 [ [ 5nUR HnURUR X@RUR5n[5m UR5H-uupgnURUn URUn UT X4'M/ UR5H6unm [U U 4SjT 55(dM#X4RU5 M8 M U$![a Mf=f)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. c3:># UHnTUTU:*v M g7fr r )r xg_count new_sg_counts rr3ISMAGS._get_lookahead_candidates..sKl|A'!*4ls)rErrrrr2rFrrrr!rrKeyErrorrr) rXg_countsrrrsg_count sge_color sgn_colorcountge_colorgn_colorrrs @@rr ISMAGS._get_lookahead_candidatess) **B:: BHL!% ==C66 s$4$4d6F6FH#9L191A-&=#77 BH#77 BH8=L!342B (~~/ GKlKKKO''+ 0!$ s=D55 EEc## UR(d0v gUR(dgU(aEURURURUR5up#UR U5nO/nUR 5n[UR55(aURXT5ShvN ggN7f)aU 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) rFrErrgrrrrr_largest_common_subgraph)rXrrrrrs rlargest_common_subgraphISMAGS.largest_common_subgraphs$}}H   -- t33T5E5EIA008KK446 z  " # #44ZM M M  NsB9C;C<Cc URb[[UR5[UR5[[ [U55[UR 5545nX@R;aURU$[URXU55n[U5S:XdeUSnURXX#5upVURbXV4URW'XV4$)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) rGhashtuplerTrWmapr!r0_refine_node_partitionsr _process_ordered_pair_partitions)rXrEnode_partitions edge_colorsr- permutationsrs rrISMAGS.analyze_symmetryBs@    +%++&%++&#e_56+++-. C***++C00  ( ( M ?#q((()!,#DD O      +(4(##Id.A.A(.K$LM##IK0 '*% &,,.LC'0JO/r'c/nUR5H'up#UHnX$:wdM URX$45 M M) U$)z Turn cosets into constraints. )r!r )rrnode_inode_tsnode_ts rrISMAGS._make_constraintssD  %||~OF!#&&'78" . r'c([S5nURH?upEXE4U;aX$U4nOX%U4nX4XaU4==S- ss'X5XaU4==S- ss'MA 0nURH$nX[X8R 554Xx'M& U$)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 [[5$r )rintr r'rr?.ISMAGS._find_node_edge_color..s [%5r'r )rrWrTr2r!) rE node_colorsrrrarbecolornode_edge_colorsrs r_find_node_edge_colorISMAGS._find_node_edge_colors56!KKLE~,$E\2$E\2 M&e"44 5 : 5 M&e"44 5 : 5(KKD%0%6FL>> 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 c3V># UHn[R"TU5v M g7fr )rr)r lby_lens rr5ISMAGS._get_permutations_by_length..s# HAi$$VAY//s&)N)rr0rr rrsorted)r!rrs @r_get_permutations_by_length"ISMAGS._get_permutations_by_lengthsY T"D 3t9  $ $T *$$ H H   sAA*"A(#A*c #J^# U4Sjn[U5n[U5nURXU5m[U4SjU55(aUv g/nU/nUGHn [ U4SjU 55(d[ X5n U(a[ U 5S:wa[ U V s1sHn [ U 5iM sn 5[ U V s/sHn [ U 5PM sn 5:waIURU 5n /n UH,nU H#nU RU[US5-5 M% M. U nMUH nUR[U [ S95 M" MUHnURU 5 M GM UHnURXX45ShvN M gs sn fs sn fN7f)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>TUTU:H$r r )rarbrs r equal_color3ISMAGS._refine_node_partitions..equal_colors#E*.>u.EE Er'c3N># UHn[U4SjU55v M g7f)c3.># UH nTUv M g7fr r r rrs rr;ISMAGS._refine_node_partitions...sGYT*40YN)r)r r$rs rr1ISMAGS._refine_node_partitions..s& ,  GYG G G,s"%Nc3.># UH nTUv M g7fr r r#s rrr&s NID!1$!7Ir%r rr) r0r.rrrr&rrr extendrr)clsrErrbranchrrnew_partitionsoutputr$refinedrr new_outputn_p permutationrs @rrISMAGS._refine_node_partitionss F/(9 44UU  ,   " !  !(I NI NNN))AG )W5WSVW56#w>Ww!s1vw>W:XX$'#B#B7#KL!#J%+7K&--cDQ4H.HI,8 &(F% 6's#;< &"CJJy)"/)2C225{S S S'6>W( Ts+BF# F 5F#F B4F# F!F#cX4UR;aURX4nOURX!4nX0R;a URUnURUnU$/nU$)zu Returns all edges in :attr:`graph` that have the same colour as the edge between sgn1 and sgn2 in :attr:`subgraph`. )rrr~)rXsgn1sgn2rrg_edgess r_edges_of_same_colorISMAGS._edges_of_same_color#sw <4++ +((4I((4I 00 0// :H))(3GGr'c #^# Uc0nOUR5nUc[URR5n[ X!5n[ U/5X!'UGHnXtR 5;dX;aMXtU'U[UR55:Xa)UR5VV s0sHupX_M sn nv MhU[UR55- n UR5m[URU5n [URR5[URU5- n U Hn X;aU nO7URX5nUVVs1sHnUH nUU;dM UiM M nnnTU R[ U5/5TU 'X4U;a%URVs1sH nUU:dM UiM nnO.X4U;a%URVs1sH nUU:dM UiM nnOMTU R[ U5/5TU 'M [U U4SjS9nURUTUUUS9ShvN GM gs sn nfs snnfs snfs snfN 7f)z6 Find all subgraph isomorphisms honoring constraints. Nc&>[TU[S9$rr)rnew_candidatess rr?#ISMAGS._map_nodes..usc.:KQT6Ur'r)mapping to_be_mapped)copyr2rFrTr7rrr,r!rEr7unionrr)rXrrrr=r>sgn_candidatesrkv left_to_mapsgn_nbrs not_gn_nbrsr5 gn2_optionsr6ergn2next_sgnr;s @rrISMAGS._map_nodes4sO ?GllnG  t}}223L #:?3#^$45  B^^%%)@CLs7<<>22(/ 8qt88&W\\^)<9I(7 II I(# I!1I!7AI(I&!I(c#Z^# Uc [URR51n[[ [ U5/55nSnU[UR 5::aP[U[S9H>n[UU4SjS9nURUTX&S9n[ U5n U v UShvN SnM@ U(dUS:Xag[5n UH/nUH&n URXU5n U RU 5 M( M1 URTX*S9ShvN gNp![a Mf=fN7f)z9 Find all largest common subgraphs honoring constraints. NFrc&>[TU[S9$rrrs rr?1ISMAGS._largest_common_subgraph..sC 1 34Or')r>Tr )rrFrTrrrrErrr StopIterationr2 _remove_noderr) rXrrr> current_size found_isorTrJ isomorphsrleft_to_be_mappedr new_nodess ` rrISMAGS._largest_common_subgraphs@  %dmm&9&9:;L4\ 2B78  3tzz? * &9u*OP OOj+, % ?DJ((( $I!:&  ) E!E!--c+F !%%i0"00  1   3) %: sCB D+ D D+%D&A*D+D)D+ D&"D+%D&&D+c\UHup4X0:XdM XA;dMUn O OM[X1- 5$)z 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)rrTrlowhighs rrPISMAGS._remove_nodes?( ;4=D)  ((r'c .[5n[X5H{up4[U5S:wd[U5S:wa[SUSU35eX4:wdM;UR [ [ [U55[ [U55455 M} U$)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_permutationsISMAGS._find_permutationssu N>HC3x1}CA  $$2#326G5HJz  DcOT$s)_+M!NO?r'cUHTnUup4S=pV[U5HupxUbUb OX8;aUnXH;dMUnM XV:wdM=XRX5 X MV g)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) orbitsrr1rrbrsecondidxorbits r_update_orbitsISMAGS._update_orbitssp(K%KD" !E'/ $);=E> F 0 $$V^4N(r'c## XnX#n XH;aXY;deUV s/sHoR5PM n n UV s/sHoR5PM n n U1X1- 4nU1X1- 4nX X XX3&XX3&URXkU5n URXmUSS9n [U 5n [U 5S:XdeU Sn U Hn [U 5U 4v M gs sn fs sn f7f)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)r*r rN)r?rr0r)rXr^r_pair_idxt_nodeb_noderEr t_partition b_partitionr`new_top_partitionsranew_bottom_partitions new_t_groups new_b_groupss r _couple_nodesISMAGS._couple_nodess %. '1 $)>>>4BCNShhjNC7H I7H7H Ixx!77 xx!77  ( ! +0<8-3?h0!99 { !% < < +d!=! ""45%&!+++/2(C)*C/ /)'D IsCC CCBCc ^^UcURVs/sHow1PM nnOUnUc0nOUR5n[S[X#555(de[SU55(a2UR X#5nUR XX5 U(aU/U4$/U4$/n[ U5V V Vs1sH#upU Hn[U 5S:dMXy4iM M% n n n n[U 5umn X<n [U 5Hm[U 5S:XaMTT:wa[UU4SjU55(aM7URUUU TTUU5nUH7nUunnURUUUUUU5unnUU- nURU5 M9 M [X#5VVVs1sH+unnUHn[U5S:XdMUU:XdMUiM M- nnnnURVs1sH nUT:dM UiM nnUU:*=(a TU;nU(a$UHnTU;dM UR5UT'M X4$s snfs snn n fs snnnfs snf)z Processes ordered pair partitions as per the reference paper. Finds and returns all permutations and cosets that leave the graph unchanged. c3T# UHup[U5[U5:Hv M g7fr r)r t_pb_ps rr:ISMAGS._process_ordered_pair_partitions..Bs# 1WXSCHC 1Ws&(c3># UHn[U5S:Hv M g7f)r Nrz)r r`s rrr}Gs7s3x1}sr c3F># UHnTU;=(a TU;v M g7fr r )r rirrbs rrr}^s$%>DU 0%5.0fs!)rTr?rr\rbrjr)rrrrrvrre)rXrEr^r_rrfrrrrhrpunmapped_nodesrmrqr#opprrrs new_perms new_cosetsr`bottomrBmappedks find_cosetrirbs ` @rr'ISMAGS._process_ordered_pair_partitions)s >).5fF5F F >F[[]F 14^1W     77 7 722>UL    5$~v--6z! %.n$= $= #;!# TK# $=  ^,h'1 K(E;1$u}%>D%""++!J"E E V3x1} "%  E   1ADa 16\8d&&8 5=#(:: H> II I$ I 2I )rQrOrMrNrLrPrKrIrJrHrGrVrErSrF)NNN)T)F)NNr ),__name__ __module__ __qualname____firstlineno____doc__r\propertyrgrrrxr~rrrrrr staticmethodrRrUrrrrrrrrrrrrr classmethodrr7rrrPrbrjrvr__static_attributes__r r'rrrs(T?DB%%%%$$$$!! !!      " " " ".` @%N5$n    J0"    0  .0T0Td"HZA F)) &##,'0^b$r')r__all__r collectionsrr functoolsrrrr&r.r7rr r'rrs?jX *,#3<#L**i$i$r'