9jSrS/rSSKrSSKJrJr SSKJrJr SSK r Sr S Sjr Sr S r"S S 5r"S S5rg)a) ISMAGS Algorithm ================ Provides a Python implementation of the ISMAGS algorithm. [1]_ ISMAGS does a symmetry analysis to find the constraints on isomorphisms if we preclude yielding isomorphisms that differ by a symmetry of the subgraph. For example, if the subgraph contains a 4-cycle, every isomorphism would have a symmetric version with the nodes rotated relative to the original isomorphism. By encoding these symmetries as constraints we reduce the search space for isomorphisms and we also simplify processing the resulting isomorphisms. ISMAGS finds (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 are an exponential number of isomorphisms that are symmetrically equivalent. In that case, the ISMAGS algorithm will provide only one isomorphism per symmetry group, speeding up finding isomorphisms and avoiding the task of post-processing many effectively identical isomorphisms. >>> 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 ----- - 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. - With a method that yields subgraph isomorphisms, we can construct functions like ``is_subgraph_isomorphic`` by checking for any yielded mapping. And functions like ``is_isomorphic`` by checking whether the subgraph has the same number of nodes as the graph and is also subgraph isomorphic. This subpackage also allows a ``symmetry`` bool keyword argument so you can find isomorphisms with or without the symmetry constraints. - For more information, see [2]_ and the documentation for :class:`ISMAGS` which includes a description of the algorithm. 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 w/root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/networkx/algorithms/isomorphism/ismags.py are_all_equal..s2u}s)shapelenNotImplementedErrorAttributeErroriternextall)iterablermessageiteratorrs @r are_all_equalrsq 9 u:>OG%g.D 8 H~H 4 E 22 22    s A A&%A&c^^/mUHSnTH8n[[U55nT"X55(dM&URU5 M? TRU15 MU U(ao[ U4SjT55(d[ R "STST<35e[ UU4SjT55(d[ R "STST<35eTVs/sHn[U5PM sn$s snf)aD 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 match/tests so need to end up in the same part of the partition, and `False` otherwise. check : bool optional (default: True) If ``True``, check that the resulting partition satisfies the match criteria. Every item should match every item in its part and none outside the part. Returns ------- list[set] A partition as a list of sets (the parts). Each set contains some of the items in `items`, such that all items are in exactly one part and every pair of items in each part matches. The following will be true: ``all(thing_matcher(*pair) for pair in itertools.combinations(items, 2))`` 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``. The function `test` is assumed to be commutative: if ``test(a, b)`` returns ``True`` then ``test(b, a)`` returns ``True``. c3># UH=n[R"US5Hup#T"X#5=(a T"X25v M M? g7f)N) itertools combinations)r partt1t2tests rr!make_partition..sD !#00q9 L )T"\ )9 *!sAAz Invalid partition created with z=. Some items in a part do not match. This leads to partition=c3># UHWnTHMnX:wdM [R"X5H(up4T"X45(+=(a T"XC5(+v M* MO MY g7fr )r!product)r p1p2r$r% partitionr&s rrr'sc x 2$++B3 R  1T"\!1 14 2 2s A"A A"z;. Some items match multiple parts. This leads to partition=)rraddappendrnx NetworkXErrorset)itemsr&checkrr#p_itemr,s ` @rmake_partitionr5s@ID$t*%FD!!    dV $  !   ""3D6:,       ""3D6:,   #, ,)$CI) ,, ,sC0ch[U5VVVs0sHupUHo3U_M M snnn$s snnnf)z Creates a dictionary that maps each item in each part to the index of the part to which it belongs. Parameters ---------- partition: collections.abc.Sequence[collections.abc.Iterable] As returned by :func:`make_partition`. Returns ------- dict ) enumerate)r,IDr#nodes rnode_to_part_ID_dictr:s/&/y%9 K%9dd"HdD%9 KK Ks-c 2^^^[T5[U5:a5UR5H!up4UT;dM STU'UH nSTX54'M M# UR5(dBUR5V^Vs0sH#umnTTT[UUU4SjU554_M% snn$UR5V^Vs0sHFumnTTT[UUU4SjU55[UUU4SjURT554_MH snn$s snnfs snnf)aReturns a dict by node to counts of edge and node color for that node. This returns a dict by node to a 2-tuple of node color and degree by (edge color and nbr color). E.g. ``{0: (1, {(0, 2): 5})}`` means that node ``0`` has node type 1 and has 5 edges of type 0 that go to nodes of type 2. Thus, this is a measure of degree (edge count) by color of edge and color of the node on the other side of that edge. For directed graphs the degree counts is a 2-tuple of (in, out) degree counts. Ideally, if edge_match is None, this could get simplified to just the node color on the other end of the edge. Similarly if node_match is None then only edge color is tracked. And if both are None, we simply count the number of edges. Nc3<># UHnTTU4TU4v M g7fr r r ve_colorsn_colorsus rr'color_degree_by_node..s"$QDqhq!tnhqk%BDc3<># UHnTTU4TU4v M g7fr r r=s rrrBs"@4aXad^Xa[14rCc3<># UHnTUT4TU4v M g7fr r r=s rrrBs"F:aXad^Xa[1:rC)r adjacency is_directedr_pred)Gr@r?nnbrsr>rAs `` `rcolor_degree_by_noderLs  8}s1v{{}GA " A%)HQTN% ==??;;= (4  W$QD$QQR R(  {{}   %GAt QK @4@ @ F1771:F F  %     s :*D > !>>$' '~~d4R4j))rUc6URR5$r )rQr2)rRs rr2EdgeLookup.items8s~~##%%rUrPN) __name__ __module__ __qualname____firstlineno____doc__rSrYr2__static_attributes__r rUrrNrNs"#* &rUrNc\rSrSrSrSSjrSrSSjrSrSSjr S r SS jr SS jr SS jr SS jrSr\S5rSSjrSSjr\S5r\S5rSr\S5rSrSrg)ri<a) 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. Attributes ---------- graph: networkx.Graph subgraph: networkx.Graph Notes ----- ISMAGS does a symmetry analysis to find the constraints on isomorphisms if we preclude yielding isomorphisms that differ by a symmetry of the subgraph. For example, if the subgraph is a 4-cycle, every isomorphism would have a symmetric version with the nodes rotated relative to the original isomorphism. By encoding these symmetries as constraints we reduce the search space for isomorphisms and we also simplify processing the resulting isomorphisms. **Symmetry Analysis** The constraints in ISMAGS are based off the handling in ``nauty`` and its many variants, in particular ``saucy``, as discussed in the ISMAGS paper [1]_. That paper cites [3]_ for details on symmetry handling. Figure 2 of [3]_ describes the DFS approach to symmetries used here and relying on a data structure called an Ordered Pair Partitions(OPP). This consists of a pair of partitions where each part represents nodes with the same degree-by-color over all colors. We refine these partitions simultaneously in a way to result in permutations of the nodes that preserve the graph structure. We thus find automorphisms for the subgraph of interest. From those we identify pairs of nodes which are structurally equivalent. We then constrain our problem by requiring the first of the pair to always be assigned first in the isomorphism -- thus constraining the isomorphisms reported to only one example from the set of all symmetrically equivalent isomorphisms. These constraints are computed once based on the subgraph symmetries and then used throughout the DFS search for isomorphisms. Finding the symmetries involves a DFS of the OPP wherein we "couple" a node to a node in its degree-by-color part of the partition. This "coupling" is done via assigning a new color in the top partition to the node being coupled, and the same new color in the bottom partition to the node being coupled to. This new color has only one node in each partition. The new color also requires that we "refine" both top and bottom partitions by splitting parts until each part represents a common degree-by-color value. Those refinements introduce new colors as the parts are split during refinement. Parts do not get combined during refinement. So the coupling/refining process always results in at least one new part with only one node in both the top and bottom partition. In practice we usually refine into many new one-node parts in both partitions. We continue in this way until each node has its own part/color in the top partition -- and the node in the bottom partition with that color is the symmetric node. That is, an OPP represents an automorphism, and thus a symmetry of the subgraph when each color has a single node in the top partition and a single node in the bottom partition. From those automorphisms we build up a set of nodes that can be obtained from each other by symmetry (they are mutually symmetric). That set of nodes is called an "orbit" of the subgraph under symmetry. After finding the orbits for one symmetry, we backtrack in the DFS by removing the latest coupling and replacing it with a coupling from the same top node to a new bottom node in its degree-by-color grouping. When all possible couplings for that node are considered we backtrack to the previously coupled node and recouple in a DFS manner. We can prune the DFS search tree in helpful ways. The paper [2]_ demonstrates 6 situations of interest in the DFS where pruning is possible: - An **Automorphism OPP** is an OPP where every part in both partitions contains a single node. The mapping/automorphism is found by mapping each top node to the bottom node in the same color part. For example, ``[({1}, {2}, {3}); ({2}, {3}, {1})]`` represents the mapping of each node to the next in a triangle. It rotates the nodes around the triangle. - The **Identity OPP** is the first automorphism found during the DFS. It appears on the left side of the DFS tree and is first due to our ordering of coupling nodes to be in an arbitrary but fixed ordering of the nodes. This automorphism does not show any symmetries, but it ensures the orbit for each node includes itself and it sets us up for handling the symmetries. Note that a subgraph with no symmetries will only have the identity automorphism. - A **Non-isomorphic OPP** occurs when refinement creates a different number of parts in the top partition than in the bottom partition. This means no symmetries will be found during further processing of that subtree of the DFS. We prune the subtree and continue. - A **Matching OPP** is such that each top part that has more than one node is in fact equal to the bottom part with the same color. The many-node-parts match exactly. The single-node parts then represent symmetries that do not permute any matching nodes. Matching OPPs arise while finding the Identity Mapping. But the single-node parts are identical in the two partitions, so no useful symmetries are found. But after the Identity Mapping is found, every Matching OPP encountered will have different nodes in at least two single-node parts of the same color. So these positions in the DFS provide us with symmetries without any need to find the whole automorphism. We can prune the subtree, update the orbits and backtrack. Any larger symmetries that combine these symmetries with symmetries of the many-node-parts do not need to be explored because the symmetry "generators" found in this way provide a basis for all symmetries. We will find the symmetry generators of the many-node-parts at another subtree of the DFS. - An **Orbit Pruning OPP** is an OPP where the node coupling to be considered next has both nodes already known to be in the same orbit. We have already identified those permutations when we discovered the orbit. So we can prune the resulting subtree. This is the primary pruning discussed in [1]_. - A **Coset Point** in the DFS is a point of the tree when a node is first back-tracked. That is, its couplings have all been analyzed once and we backtrack to its parent. So, said another way, when a node is backtracked to and is about to be mapped to a different node for the first time, its child in the DFS has been completely analysed. Thus the orbit for that child at this point in the DFS is the full orbit for symmetries involving only that child or larger nodes in the node order. All smaller nodes are mapped to themselves. This orbit is due to symmetries not involving smaller nodes. Such an orbit is called the "coset" of that node. The Coset Point does not lead to pruning or to more symmetries. It is the point in the process where we store the **coset** of the node being backtracked. We use the cosets to construct the symmetry constraints. Once the pruned DFS tree has been traversed, we have collected the cosets of some special nodes. Often most nodes are not coupled during the progression down the left side of the DFS. They are separated from other nodes during the partition refinement process after coupling. So they never get coupled directly. Thus the number of cosets we find is typically many fewer than the number of nodes. We turn those cosets into constraints on the nodes when building non-symmetric isomorphisms. The node whose coset is used is paired with each other node in the coset. These node-pairs form the constraints. During isomorphism construction we always select the first of the constraint before the other. This removes subtrees from the DFS traversal space used to build isomorphisms. The constraints we obtain via symmetry analysis of the subgraph are used for finding non-symmetric isomorphisms. We prune the isomorphism tree based on the constraints we obtain from the symmetry analysis. **Isomorphism Construction** Once we have symmetry constraints on the isomorphisms, ISMAGS constructs the allowed isomorphisms by mapping each node of the subgraph to all possible nodes (with the same degree-by-color) from the graph. We partition all nodes into degree-by-color parts and order the subgraph nodes we consider using smallest part size first. The idea is to try to map the most difficult subgraph nodes first (most difficult here means least number of graph candidates). By considering each potential subgraph node to graph candidate mapping image in turn, we perform a DFS traversal of partial mappings. If the mapping is rejected due to the graph neighbors not matching the degree-by-color of the subgraph neighbors, or rejected due to the constraints imposed from symmetry, we prune that subtree and consider a new graph candidate node for that subgraph node. When no more graph candidates remain we backtrack to the previous node in the mapping and consider a new graph candidate for that node. If we ever get to a depth where all subgraph nodes are mapped and no structural requirements or symmetry constraints are violated, we have found an isomorphism. We yield that mapping and backtrack to find other isomorphisms. As we visit more neighbors, the graph candidate nodes have to satisfy more structural restrictions. As described in the ISMAGS paper, [1]_, we store each set of structural restrictions separately as a set of possible candidate nodes rather than computing the intersection of that set with the known graph candidates for the subgraph node. We delay taking the intersection until that node is selected to be in the mapping. While choosing the node with fewest candidates, we avoid computing the intersection by using the size of the minimal set to be intersected rather than the size of the intersection. This may make the node ordering slightly worse via a savings of many intersections most of which are not ever needed. 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 .. [3] Hadi Katebi, Karem A. Sakallah and Igor L. Markov "Graph Symmetry Detection and Canonical Labeling: Differences and Synergies" in "Turing-100. The Alan Turing Centenary" Ed: A. Voronkov p. 181 -- 195, (2012). https://doi.org/10.29007/gzc1 https://arxiv.org/abs/1208.6271 NcjUR5UR5:wa [S5eXlX lXPlUR X0RR URR 5nUuUlUlUl [UR5Ul [UR5Ul UR X@RR5URR55nUuUlUlUlURR5(a5[UR5Ul[UR5Ulg['[UR55Ul['[UR55Ulg)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. z2Directed and undirected graphs cannot be compared.N)rG ValueErrorgraphsubgraph_symmetry_cachecreate_aligned_partitionsnodes_sgn_partition _gn_partition N_node_colorsr: _sgn_colors _gn_colorsedges_sge_partition _ge_partition N_edge_colors _sge_colors _ge_colorsrN)rRrfrg node_match edge_matchcache node_partsedge_partitionss rrSISMAGS.__init__sV.    ("6"6"8 8QR R  $33  ++TZZ-=-= GQCT/1C/0C0CD.t/A/AB88  ++-tzz/?/?/A GVCT/1C :: ! ! # #3D4G4GHD 243E3EFDO)*>t?R?R*STD ()=d>P>P)QRDOrUc^^^^Tc[T5/n[T5/nXES4$[T[RRR 5n[T[RRR 5nU(dUU4SjnOUU4SjnU(dUU4Sjn OUU4Sjn [ TU5n[ TU 5n0n 0n [U5[U5p[R"[U 5[U 55GHup[[XN55n[[X_55nU(dTUOTRUSUSnU(dTUOTRUSUSnT"UU5(dMX;a3[R"STSU<S US XNS X_S XZUS 3 5eX;a7[R"STSU<SU<S USX_SXNS XKUS 35eXU'XU'GM U R!5VVs/sH upXNX_4PM nnn[U5nU(a&[#U6Vs/sHn[%U5PM snunnO//nnUU :aW[U 5Vs/sHnUU ;dM UUPM nn[%U5U-n[%U5[5/[U5--nUU :aW[U 5Vs/sHnUU ;dM UUPM nn[%U5U-n[%U5[5/[U5--nUUU4$s snnfs snfs snfs snf)aPartitions of "things" (nodes or edges) from subgraph and graph based on function `thing_matcher`. Returns: sg_partition, g_partition, number_of_matched_parts The first `number_of_matched_parts` parts in each partition match in order, e.g. 2nd part matches other's 2nd part. Warning: nodes in parts after that have no matching nodes in the other graph. For morphisms those nodes can't appear in the mapping. r c">T"TUTU5$r r )thing1thing2 sg_things thing_matchers rsg_match2ISMAGS.create_aligned_partitions..sg_match5s$Yv%6 &8IJJrUcf>Xsup#upET"TRUUTRUU5$r )rgr~ru1v1u2v2rRrs rrr:s:%+"(2$T]]2%6r%:DMM"T"TUTU5$r r )r~rg_thingsrs rg_match1ISMAGS.create_aligned_partitions..g_match@s$Xf%5x7GHHrUcf>Xsup#upET"TRUUTRUU5$r )rfrs rrrEs8%+"(2$TZZ^B%7B9KLLrUrz Matching function z- seems faulty. Partition found: sg_partition=z So z in subgraph part z matches two graph parts z and  z! Matching function seems broken: z Partitions found: g_partition=z sg_partition=z in graph part z matches two subgraph parts )r1 isinstancer/classes reportviewsOutEdgeDataViewr5rr!r)rangerrrgrfr0r2ziplist)rRrrr sg_partition g_partition sg_multiedge g_multiedgerr sgc_to_gc gc_to_sgcsNNsgcgcsgtgtsgt_gt_ new_orderNcolorsxnew_sg_pnew_g_pcextras```` rri ISMAGS.create_aligned_partitionssr   N+Lx=/Ka/ /")RZZ-C-C-S-ST  2::+A+A+Q+QR  K  S I  M&i: $Xw7   L!3{#3A ((rE!H=GCtL-./Cd;?+,B)59S>4==Q;PQTUVQW;XD&1(2,tzz"Q%7HA7OCT3''#**.}o>:,8?;!U"4\5F4GH''2&7u&~67r ;?**<]OL:-8N/L?K T0AB**6*;)8AJ@Q @QWS\   0@Q  i. 25y/ B/Qa/ B Hg "BgH R<.3BiNi1I;M_\!_iENH~-H7msugE &::G Q;-21XLX)9K^[^XEL7me+GH~#e*(<[STU55$)Nc38# UHn[U5v M g7fr rr rs rr=ISMAGS.find_isomorphisms....s8VAQminrJ cand_setss r*ISMAGS.find_isomorphisms..sS8VST8V5VrUkey)rgrfrrkrmrqrsanalyze_subgraph_symmetryr2_get_node_color_candidate_sets_get_color_degree_candidatesr- frozensetanyvaluesr intersection _map_nodes) rRsymmetrycosetsrJcsco constraintslookahead_candidatessgnlookahead_cands start_sgnrs @rfind_isomorphismsISMAGS.find_isomorphisms~sl$}}H   _s4==1 1  $$ %(:(: :  $$ %(:(: :  335F06 Wuq2TVw7A77KWKK779 #@@B$8$>$>$@ C cN  y9 :%A y! " " I+VWI$-$:$:Ii# UH,upUR5Hup4UTUU:*v M M. g7fr )r2)r idxcountscolorsg_cntg_countss rr6ISMAGS._get_color_degree_candidates..s='? )/ hsmE22)73'?s47) rLrfrorurgrnrtr2rr7)rRg_degsg_degr_ needed_countsgnrs `rr#ISMAGS._get_color_degree_candidatess %TZZ$//R%dmmT5E5EtGWGWX-3LLN   -;((a */++-*7&BX'0'?*7 -;    s/ C ,C?C C C c## UR(d0v gUR(dgU(aIUR5nUR5VVVs/sHup4UH oSU:wdM X54PM M nnnnO/nUR 5n[ UR 55(aGURSURn[SU551n URXvU 5ShvN ggs snnnfN 7f)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}. Nc36# UHoHo"v M M g7fr r )r prJs rr1ISMAGS.largest_common_subgraph..s%KAAaas) rgrfrr2rrrrkrmr_largest_common_subgraph) rRrrrJrcnrcandidate_setsrelevant_parts to_be_mappeds rlargest_common_subgraphISMAGS.largest_common_subgraphs$}}H   335F06 Wuq2TVw7A77KWKK<<> ~$$& ' '!001E43E3EFN%%K%KKLL44\   X s%AC<C3+ C36A6C<,C:-C<c ZURURp!URb[[ UR R 5[ UR R5[ [[[55[ UR55UR R545nX0R;aURU$URUR X5nURUR XU5nURbX@RW'U$)a Find a minimal set of permutations and corresponding co-sets that describe the symmetry of ``self.subgraph``, given the node and edge equalities given by `node_partition` and `edge_colors`, respectively. Returns ------- 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``. )rkrtrhhashtuplergrjrpmapnode_partitionr2rG_refine_node_partition _process_ordered_pair_partitions)rRr, edge_colorsrrs rr ISMAGS.analyze_subgraph_symmetrys"&!4!4d6F6F;    +$----.$----.#e^45+++-.MM--/ C***++C00// yV 66 MM9     +(.  % rUc[UR5[UR5:H=(a URU5$)zl Returns True if :attr:`graph` is isomorphic to :attr:`subgraph` and False otherwise. Returns ------- bool )rrgrfsubgraph_is_isomorphicrRrs r is_isomorphicISMAGS.is_isomorphics74==!S_4 9T9T :  rUc<[URUS9S5nUSL$)zz Returns True if a subgraph of :attr:`graph` is isomorphic to :attr:`subgraph` and False otherwise. Returns ------- bool rN)rsubgraph_isomorphisms_iter)rRrisoms rrISMAGS.subgraph_is_isomorphic&s)D33X3FM4rUc## [UR5[UR5:XaURUS9ShvN ggN7f)zq Does the same as :meth:`find_isomorphisms` if :attr:`graph` and :attr:`subgraph` have the same number of nodes. rN)rrfrgrrs risomorphisms_iterISMAGS.isomorphisms_iter5s? tzz?c$--0 0666I I I 1 Is?A AA c$URU5$)z/Alternative name for :meth:`find_isomorphisms`.)rrs rr!ISMAGS.subgraph_isomorphisms_iter=s%%h//rUc [[5nURRHPnURUnX0R :aX M'XR [URU55 MR [U5$)a Per node in subgraph find all nodes in graph that have the same color. Stored as a dict-of-set-of-frozenset. The dict is keyed by node to a collection of frozensets of graph nodes. Each of these frozensets are a restriction. The node can be mapped only to nodes in the frozenset. Thus it must be mapped to nodes in the intersection of all these sets. We store the sets to delay taking the intersection of them. This helps for two reasons: Firstly any duplicate restriction sets can be ignored; Secondly, some nodes will not need the intersection to be constructed. Note: a dict-of-list-of-set would store duplicate sets in the list and we want to avoid that. But I wonder if checking hash/equality when `add`ing removes the benefit of avoiding computing intersections. ) rr1rgrjrnrmr-rrldict)rRrr sgn_colors rr%ISMAGS._get_node_color_candidate_setsAsr%S)==&&C((-I...##'' $2D2DY2O(PQ ' N##rUc ^U4Sjn[U5n[XU5m[U4SjU55(dUVVs/sH@n[U4SjU55(aU/O[ [ XdSS9[ S9HnUPM MB nnn[U5n[XU5m[U4SjU55(dMU$s snnf)Nc>TUTU:H$r r node1node2 color_degrees r equal_color2ISMAGS._refine_node_partition..equal_colorZ&,u*== =rUc3N># UHn[U4SjU55v M g7f)c3.># UH nTUv M g7fr r r rJr s rr:ISMAGS._refine_node_partition..._s#?QLOQNrr rr s rr0ISMAGS._refine_node_partition.._sSAm#?Q#???"%c3.># UH nTUv M g7fr r rs rrres$Cd\!_drFr3r)r:rLrrsortedr5r) clsrfr,rr  node_colorsr#rr s @rrISMAGS._refine_node_partitionXs >+95 +E L SSSS&%D%$Cd$CCCFt NTWXYY% /y9K/KPLSSSSsAB=c #8^!# URnURnURnURnURn URn UR 5n [ U5n [U5V Vs0sHupX_M nn n0n0nUcUR5n[R"X!6nU1X!'X[U54/nU(Ga,USupnUGHnUU;aM UU;aUUnUU UUU'UUU'[U5[U5:XaUR5v UU UU MVUUR5- nUR5m!U (dXanUR5UUR5- nUHOnUU;aUnO.XUU4nUVVs1sHnUU;dM UHoiM M nnnT!U[U51-T!U'MQ GONXaR5nURUR5nUR5UUR5- URUR5- nUHnUU;a3UU;aUnOXUU4nUVs1sHnUUS:XdMUSiM nnOUU;a*XUU4nUVs1sHnUUS:XdMUSiM nnOVXUU4nUVs1sHnUUS:XdMUSiM nnXUU4nUUVs1sHnUUS:XdMUSiM sn-nT!U[U51-T!U'M UHPnUU4U;a[XUS-S5nOUU4U;a[U SUU5nOM;T!U[U51-T!U'MR [!UU!4SjS9n[R"T!U6n U (dGMU 1T!U'UR#UT![U 545 O! UR%5 UU;a UUU UU U(aGM+ggs snn fs snnfs snfs snfs snfs snf7f)a Find all subgraph isomorphisms honoring constraints. The collection `candidate_sets` is stored as a dict-of-set-of-frozenset. The dict is keyed by node to a collection of candidate frozensets. Any viable candidate must belong to all the frozensets in the collection. So each frozenset added to the collection is a restriction on the candidates. According to the paper, we store the collection of sets rather than their intersection to delay computing many intersections with the hope of avoiding them completely. Having the middle collection be a set also means that duplicate restrictions on candidates are ignored, avoiding another intersection. NrWr rc.>[STU55$)Nc38# UHn[U5v M g7fr rrs rr6ISMAGS._map_nodes....s2P.ss2P9Q<2P/PrUr)rg_adjrfrrrtrGrr7keysrrrrcopyrHr1rr.pop)"rRrrrrrg subgraph_adjrf graph_adjself_ge_partitionself_sge_colorsrG gn_ID_to_nodeidrJ gn_node_to_IDmapping rev_mappingsgn_candidatesqueue sgn_cand_iterrold_gn left_to_mapsgn_nbrs not_gn_nbrssgn2 gn2_candsg_edgese sgn_predsnew_sgnnew_sgn_candidatesrs" @rrISMAGS._map_nodesms==}}  JJ  ..****, U ,5e,<=,<52,< =  ',,.L#//1DE-.tN';<=16r .C#$'>$S\F#F+! "% Bw<3|#44%**,, #B*W\\^; +//1 #+0H"+.."2Yr]5G5G5I"IK +x/(3I&7T 8R&SG4;(RGqrQwPQ1PQGI(R +4D/Yy=Q#GCL1 Ge)>t)S(-R-R-R-RsuA2P5O:DP P )P 8B0P( P9 PP P ) P 2P P PP, P = P C/P8"Pc#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.>[STU55$)Nc38# UHn[U5v M g7fr rrs rrDISMAGS._largest_common_subgraph....s7V 1A rr)rJ candidatess rr1ISMAGS._largest_common_subgraph..sC7V ST 7V4VrU)rTr )rrgrjrrrrfrrr StopIterationr1 _remove_noder-r) rRrArr current_size found_isorjnext_sgn isomorphsrleft_to_be_mappedr new_nodess ` rrISMAGS._largest_common_subgraphs@  %dmm&9&9:;L4\ 2B78  3tzz? * &9u*VW OOj+, % ?DJ((( $I!:&  ) E!E!--c+F !%%i0"00  1   3) %: sCB D+ D D+%D&A*D+D)D+ D&"D+%D&&D+cZUHup4X0:XdM XA;dMUn O [X1- 5$M+)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)r9rjrlowhighs rrDISMAGS._remove_node@s:( ;4=D) !00 rUc^[[5mUH nT[U5RU5 M" [[R "U4Sj[ T5565$)am Get all permutations of items, but only permute items with the same length. >>> 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 )r! permutations)r lby_lens rr5ISMAGS._get_permutations_by_length..fs#L^)((33^s&))rrrr.r!r)r)r2rrTs @r_get_permutations_by_length"ISMAGS._get_permutations_by_lengthPsY T"D 3t9  $ $T *   LVF^L   rUc #^# U4SjnURXU5nU/nU(GaUR5n[U5n[XU5m[ U4SjU55(a[ U5[ U5:XaX#4v Mh//nUGHn [ U 5S:Xd[ U4SjU 55(aUHn U RU 5 M MI[XSS9n [ U 5n U S:Xd)U [ U V s1sHn [ U 5iM sn 5:Xa(UH nUR[U [ S95 M" MURU 5n/nUH>nUH5n U VVs/sHnUHnUPM M nnnURUU-5 M7 M@ UnGM URUSSS25 U(aGMggs sn fs snnf7f) Nc>TUTU:H$r r rs rr 'ISMAGS._refine_opp..equal_colorkr rUc3N># UHn[U4SjU55v M g7f)c3.># UH nTUv M g7fr r rs rr/ISMAGS._refine_opp...us .usMf= # UH nTUv M g7fr r )r r9r s rrr^~s2WRV$<3ERVrFrrrW) rr$r:rLrrrr.r5extendrrV)rrftopbottomrr possible_bottomsr more_bottomsr# new_bottom refined_partRrn_prRnew_partitions new_partitiontupsflat_pr s @r _refine_oppISMAGS._refine_oppjs >(([A"8%))+F.v6K/KPLMfMMMs8s6{*+%4Lt9>]2WRV2W%W%W&2 "))$/'3$2$5#QLL)AAvc<*H# UHn[U5S:*v M g7fr Nrr ras rr:ISMAGS._process_ordered_pair_partitions..s6 s3x1} Tc>U 4Sj[U55n[U5upEnX&n[[UT S95nUR XXVU/5 g)Nc3l># UH)upUHn[U5S:dMTUX14v M M+ g7fryr)r rt_partr9 node_to_IDs rrZISMAGS._process_ordered_pair_partitions.._load_next_queue_entry..s>#;KC"Dv;?.D!4-".#;s44r)r7rrrr.) r/rrrsunmapped_nodesrr9part_ib_part node2_iterr sort_by_IDs r_load_next_queue_entryGISMAGS._process_ordered_pair_partitions.._load_next_queue_entrysS#,]#;N ".1OAV%-FfV<=J LL-4T UrUrWc3># UHn[U5S:*v M g7fryrrzs rrr{s?s3x1}r|rFc3X# UH up[U5S:*=(d X:Hv M" g7fryr)r tbs rrr{s$IytqSVq[2AF2ys(*c3*># UHoT4v M g7fr r )r rJorb1s rrr{ s/N:aD :s) rr7rYr#insertrnrruupdater1r`r$)%rRrfrrrsrfinding_identityorbit_ir9orbit_idorbitsrirJrr/topsbottomsrrr new_top_part new_bot_partranew_toprtnew_botoppsnew_qopprRn1n2orb2 orbit_set2rrrs% @@@rr'ISMAGS._process_ordered_pair_partitionss 6 6 6 6I 7@7GH7GmgDM7GH%*+UT&U+'0'78'7tqad'78 ++  Vu5EF6;Bi 3D'4#5=X^x%F!%v %w 156#388:6</v|4189#388:9</v|4''wMC (?A???/4,$@IsCyIII(,'>'>'D &2FB#+B#>#@FLyez kI+9@7:sI. I4 I9I?J) rsrmrurrrorlrtrqrnrkrhrfrg)NNNT)Fr )r]r^r_r`rarSrirrrrrrrrr classmethodrrr staticmethodrDrVrnrurrbr rUrrr<siV5Sn]*~5n ,(T"H    J0$.(N%`A F 1 1  208d4crUr)ra__all__r! collectionsrr functoolsrrnetworkxr/rr5r:rLrNrr rUrrsOxt *,#3