+ jRtR.t^RIt^RIt^RIHtHt^RItRt R Rlt Rt Rt Rt !R R 4t!R R4tR#) 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 defaultdictc aVPp\V4^8dRp\V4Rh\ V4p\ VR4o\ ;QJdV3RlV4F 'dK R# R#!V3RlV44# \dL^i;i)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,<"TF qS8HxK R#5iN).0itemfirsts& g/home/luca/screen-checking/.venv/lib/python3.14/site-packages/networkx/algorithms/isomorphism/ismags.py are_all_equal..s2u}sFT)shapelenNotImplementedErrorAttributeErroriternextall)iterablermessageiteratorr s& @r are_all_equalrs 9 u:>OG%g.D 8 H~H 4 E 32233232322 22    s A?? B  B caa.oVFTpSF9p\\V44pS!W54'gK'VPV4K@ SPV04KV V'd\;QJdV3RlS4F 'dK RM RM!V3RlS44'g\ P !RS RS: 24h\;QJd VV3RlS4F 'dK RM RM!VV3RlS44'g\ P !RS RS: 24hSUu.uFp\V4NK up#uupi)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<"TF=p\P!V^4Fwr#S!W#4;'d S!W24xK! K? R#5i)N) itertools combinations)r partt1t2tests& r r !make_partition..sG !#00q9 L ) )T"\ )9 *!s /AAFTz Invalid partition created with z=. Some items in a part do not match. This leads to partition=c3<"TFWpSFNpW8wgK \P!W4F)wr4S!W44'*;'dS!WC4'*xK+ KP KY R#5ir)rproduct)r p1p2r r! partitionr"s& r r r#sf x 2$++B3 R  1 1T"\!1 14 2 2s A".A"A"z;. Some items match multiple parts. This leads to partition=)rraddappendrnx NetworkXErrorset)itemsr"checkr rp_itemr(s&f& @r make_partitionr1s1@ID$t*%FD!!    dV $ s ! sss !   ""3D6:,   s  sss    ""3D6:,   #, ,)$CI) ,, ,s'D>cd\V4UUUu/uFwrVFq3VbK K uppp#uupppi)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(IDrnodes& r node_to_part_ID_dictr6s/&/y%9 K%9dd"HdD%9 KK Ks+c aaaVP4'gFVP4UaUu/uF'wopSSS,\VVV3RlV443bK) upp#VP4UaUu/uFNwopSSS,\VVV3RlV44\VVV3RlVPS,443bKP upp#uuppiuuppi)aReturns a dict keyed by node to counts of edge and nbr color combos. Similar to color_degree_by_node except that multiedges are not included in the color tuples. Not used for largest_common_subgraph. Only for _all_morphisms when considering problem_type == "MONO", or cases with no multigraphs present. MONO needs to allow lower numbers of multiedges in the subgraph, so we can't use that as a color (which are essentially treated using equality checks for isomorphisms. We handle multiedge checks for MONO during mapping update checks rather than candidate identifying part of the loop. Ignoring the multiedges gives the same code we can use when both graph and subgraph are not multigraphs. c3L<"TFpSSV3,SV,3xK R#5irrr ve_colorsn_colorsus& r r 0color_degree_by_node_no_multi..s"$QDqhq!tnhqk%BD!$c3L<"TFpSSV3,SV,3xK R#5irrr9s& r r r>s"@4aXad^Xa[14r?c3L<"TFpSVS3,SV,3xK R#5irrr9s& r r r>s"F:aXad^Xa[1:r?) is_directed adjacencyr_pred)Gr<r;r=nbrss&ff` r color_degree_by_node_no_multirGs ==??;;= (4  W$QD$QQR R(  {{}   %GAt QK @4@ @ F1771:F F  %     s -C 3ACc @aaaa\S4\S48d7SP4F"wr4VS9gKRSV&VF pRSW53&K K$ SP4'gSP4'dGSP4UaUu/uF(wopSSS,\ VVVV3RlV443bK* upp#SP4UaUu/uF'wopSSS,\ VVV3RlV443bK) upp#SP4'd|SP4UaUu/uF]wopSSS,\ VVVV3RlV44\ VVV3RlSP S,P 4443bK_ upp#SP4UaUu/uFNwopSSS,\ VVV3RlV44\ VVV3RlSP S,443bKP upp#uuppiuuppiuuppiuuppi)a*Returns a dict keyed by node to counts of edge/nbr color for that node. The inputs are G -- graph of interest; `n_colors` -- a dict keyed by node to the node color/label associated with that node; `e_colors` -- a dict keyed by edge to the edge color/label associated with that edge. The returned dict is keyed by node to a 2-tuple of node color and degree dict. The degree dict holds counts for each edge-key which is a 3-tuple: (edge color, number of multiedges, nbr color). For example, ``{0: (1, {(0, 1, 2): 5})}`` means that node ``0`` has node color 1 and has 5 edges of color 0 that have 1 multiedge to nodes of color 2. This dict is a measure of degree (edge count) by color of edge, number of multiedges and color of the node on the other side of that edge. For directed graphs the degree counts are a 2-tuple of 2 dicts indicating (in, out) degree counts respectively. When both graph and subgraph are not multigraphs, the multiedge indicator is not relevant. Use `color_degree_by_node_no_multi` to make the keys of the inner dict 2-tuples with edge color and nbr node color. TODO: 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|<"TF1pSSV3,\SS,V,4SV,3xK3 R#5irrr r:rEr;r<r=s& r r 'color_degree_by_node..=s2VQUAXad^S1a\8A;GQU9<c3N<"TFpSSV3,^SV,3xK R#5iNrr9s& r r rLBs$$Tt!hq!tna!%Et"%c3|<"TF1pSSV3,\SS,V,4SV,3xK3 R#5irrJrKs& r r rLJs0RT!Q$QqT!Wx{CTrMc3d<"TF%wrSVS3,\V4SV,3xK' R#5irrJ)r r:kdr;r<r=s& r r rLKs1!3ad^SWhqk:!3s-0c3N<"TFpSSV3,^SV,3xK R#5irOrr9s& r r rLUs$CdXad^Q 4drQc3N<"TFpSVS3,^SV,3xK R#5irOrr9s& r r rLVs$IjXad^Q 4jrQ)rrCrB is_multigraphrrDr.)rEr<r;nrFr:r=sfff `r color_degree_by_noderYs6 8}s1v{{}GA " A%)HQTN% ==?? ??   !{{}  -GAt QKVQUVV -  ;;= (4  W$Tt$TTU U(   ;;=  )4  RTRR!"!1!1!3 )  "{{}   %GAt QK CdC C IaggajI I  %  1   s.H-H5A#H0AHc6a]tRtRtoRtRtRtRtRtVt R#) EdgeLookupi\aClass to handle getitem for undirected edges. Note that ``items()`` iterates over one of the two representations of the edge (u, v) and (v, u). So this technically doesn't violate the Mapping invariant that (k,v) pairs reported by ``items()`` satisfy ``.__getitem__(k) == v``. But we are violating the spirit of the protocol by having keys available for lookup by ``__getitem__`` that are not reported by ``items()``. Note that if we used frozensets for undirected edges we would have the same behavior we see here. You could ``__getitem__`` either ``{u, v}`` or ``{v, u}`` and get the same value -- yet ``items()`` would only report one of the two. So from that perspective we *are* following the Mapping protocol. Our keys are undirected edges. We are using 2-tuples as an imperfect representation of these edges. We are not using 2-tuples as keys. Only as imperfect edges and we use the edges as keys. cWnR#r edge_dict)selfr^s&&r __init__EdgeLookup.__init__ns"cWP9dVPV,#VPVRRR1,,#)Nr])r_edges&&r __getitem__EdgeLookup.__getitem__qs2 >> !>>$' '~~d4R4j))rbc6VPP4#r)r^r.)r_s&r r.EdgeLookup.itemsvs~~##%%rbr]N) __name__ __module__ __qualname____firstlineno____doc__r`rfr.__static_attributes____classdictcell__ __classdict__s@r r[r[\s"#* &&rbr[ca]tRtRtoRtRRltRtRRltRtRt RR lt R t RR lt RR lt RR ltRRltRRltRRltRt]R4tRRltRRlt]R4t]R4tRt]R4tRtRtVtR#)riza) 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 Nc rVP4VP48wd \R4hWnW nWPnVP W0PP VPP 4pVwVnVnVn \VP4Vn \VP4Vn VP W@PP4VPP44pVwVnVnVnVPP4'd7\VP4Vn\VP4VnR#\'\VP44Vn\'\VP44VnR#)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)rB ValueErrorgraphsubgraph_symmetry_cachecreate_aligned_partitionsnodes_sgn_partition _gn_partition N_node_colorsr6 _sgn_colors _gn_colorsedges_sge_partition _ge_partition N_edge_colors _sge_colors _ge_colorsr[)r_rvrw node_match edge_matchcache node_partsedge_partitionss&&&&&& r r`ISMAGS.__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)QRDOrbc DaaaaSf\S4.p\S4.pWE^3#\S\PPP 4p\S\PPP 4pV'g VV3RlpMVV3RlpV'g VV3Rlp MVV3Rlp \ SV4p\ SV 4p/p /p \V4\V4r\P!\V 4\V 44EF[wr\\WN,44p\\W_,44pV'g SV,M'SPV^,,V^,,pV'g SV,M'SPV^,,V^,,pS!VV4'gKW9dD\P!RS RV: RV RWN, R W_, R WZV,, R 2 4hW9dH\P!R S R V: RV: RV RW_, RWN, R WKV,, R 24hWV&WV&EK^ V P!4UUu.uFwrWN,W_,3NK ppp\V4pV'd'\#V!Uu.uFp\%V4NK upwppM..ppVV 8dh\V 4Uu.uFpVV 9gK VV,NK pp\%V4V,p\%V4\4.\V4,,pVV 8d=\V 4Uu.uFpVV 9gK VV,NK pp\%V4V,pVVV3#uuppiuupiuupiuupi)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. c2<S!SV,SV,4#rr)thing1thing2 sg_things thing_matchers&&r sg_match2ISMAGS.create_aligned_partitions..sg_matchss$Yv%6 &8IJJrbc<Wuwr#wrES!SPV,V,SPV,V,4#r)rwrru1v1u2v2r_rs&& r rrxs:%+"(2$T]]2%6r%:DMM".g_match~s$Xf%5x7GHHrbc<Wuwr#wrES!SPV,V,SPV,V,4#r)rvrs&& r rrs8%+"(2$TZZ^B%7B9KLLrbz 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 )r- isinstancer+classes reportviewsOutEdgeDataViewr1rrr%rangerrrwrvr,r.ziplist)r_rrr sg_partition g_partition sg_multiedge g_multiedgerr sgc_to_gc gc_to_sgcsNNsgcgcsgtgtsgt_gt_ new_orderNcolorsxnew_sg_pnew_g_pcextrasffff r ry ISMAGS.create_aligned_partitions]s]   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+G'))# !COMs$<N 8N+ N9 N N' Nc# H"VPVRR7RjxL R#L5i)z?left for backward compatibility. Use subgraph_isomorphisms_iterSUB problem_typeN_all_morphismsr_symmetrys&&r find_isomorphismsISMAGS.find_isomorphismss'&&xe&DDD Es " "c# ja"VR8Xd\P;r4MQVR8Xd"\Pp\PpM)VR8Xd\P;r4M\RV: R24hVP'g/xR#VP 'gR#V!\ VP4\ VP 44'gR#V!\ VP4VP4'gR#V!\ VP4VP4'gR#VR8Xd]V!\ VP4VP4'gR#V!\ VP4VP4'gR#V'dIVP4pVP4UUUu.uFwrgVFqV8wgK Wh3NK K p pppM.p VPV4oVP!W44p V P4F&wrSV ,P#\%V 44K( \'SP)44'dL\+SV3RlR7p \$P,!SV ,!3SV &VP/V SW4RjxL R#uupppiL 5i) a Find all morphisms between :attr:`graph` and :attr:`subgraph` Yield isomorphisms or monomorphisms depending on `problem_type`. Parameters ---------- symmetry : bool Whether symmetry should be taken into account. If False, morphisms may be symmetrically equivalent. problem_type : string The problem type to be used: - "ISO" for graph isomorphism, - "SUB" for subgraph isomorphism, - "MONO" for monomorphism. Yields ------ dict The isomorphism mappings in form: {graph_node: subgraph_node}. ISOrMONOzInvalid problem_type=z . Must be "ISO", "SUB" or "MONO"Nc6<\RSV,44#)c38"TFp\V4xK R#5irrJr rs& r r :ISMAGS._all_morphisms....s8VAQminrX cand_setss&r 'ISMAGS._all_morphisms..sS8VST8V5Vrbkey)operatoreqlerurwrvrr{r}rrr|ranalyze_subgraph_symmetryr._get_node_color_candidate_sets_get_color_degree_candidatesr) frozensetanyvaluesr intersection _map_nodes)r_rrSG_fits MONO_fitscosetsrXcsco constraintslookahead_candidatessgnlookahead_cands start_sgnrs&&& @r rISMAGS._all_morphismss+* 5 "*++ -Gi U "kkG I V #"*++ -Gi5 6VWX X}}}H  T]]+S_== T00143E3EFF T00143E3EFF  5 3t112D4F4FGG3t112D4F4FGG 335F06 Wuq2TVw7A77KWKK77 B #@@T$8$>$>$@ C cN  y9 :%A y! " " I+VWI$-$:$:Ii.sB'? )/ FHSM%$899)7:'?s?AFT)rrrvrWrwrYrGrrr~rr.rr3) r_rrr color_countg_degsg_degr_ needed_countsgnrs &f& `r r#ISMAGS._get_color_degree_candidates s% HKK' JJ $ $ & &$--*E*E*G*GQU.K7KDJJIT]]D,<,N>NO-3LLN   -;((a */++-*7&BX3'0'?333'0'?*7 -;    s*E. 1E'E''%E'E' E. 'E. c# "VP'g/xR#VP'gR#V'dIVP4pVP4UUUu.uFwr4VFqSV8wgK W53NK K ppppM.pVP \ P R7p\;QJd*RVP44F 'gK RM RM!RVP444'dIVPRVPp\RV440p VPWvV 4RjxL R#R#uupppiL5i)aV 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)rc38"TFp\V4xK R#5ir)r)r constraints& r r 1ISMAGS.largest_common_subgraph..HsI1H:s:1HrTFc34"TFqFq"xK K R#5irr)r prXs& r r rJs%KAAaas) rwrvrr.rrrrrr{r}r_largest_common_subgraph) r_rrrXrcnrcandidate_setsrelevant_parts to_be_mappeds && r largest_common_subgraphISMAGS.largest_common_subgraph&s$}}}H   335F06 Wuq2TVw7A77KWKK<>> matcher = ISMAGS(nx.cycle_graph(3), nx.path_graph(3)) >>> matcher.subgraph_is_isomorphic() False >>> len(list(matcher.monomorphisms_iter(symmetry=False))) 6 >>> len(list(matcher.monomorphisms_iter())) 3 rrrrs&&r rISMAGS.monomorphisms_itersH""8&"AArbc aaaVPUu/uFq"VPPW"4bK upo/pVPPF}pVPV,pWPP 8d\ 40W4&K5VPPWD4oVVV3RlVPV,4p\ V40W4&K V#uupi)aB For each node in subgraph store all nodes in graph with same color and self-loop count. These sets should not change so we cache them. 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. c3X<"TFpS!SSV,4'gKVxK! R#5irr)r rXLrloopss& r r 8ISMAGS._get_node_color_candidate_sets..s#T9qYq%PQ(=S9s* *)rvnumber_of_edgesrwrzr~r}rr|) r_rrXrr sgn_colorrr*r+s &f @@r r%ISMAGS._get_node_color_candidate_setss?CjjIjDJJ..q44jI==&&C((-I...'0{m# --c7ATD..y9TA#,Q<.N 'Js$Cc aV3Rlp\V4p\WV4o\;QJdV3RlV4F 'dK RM RM!V3RlV44'gnVUUu.uFFp\V3RlV44'dV.M\ \ WdRR7\ R7FpVNK KH ppp\V4p\WV4oKV#uuppi)c*<SV,SV,8H#rrnode1node2 color_degrees&&r equal_color2ISMAGS._refine_node_partition..equal_color&,u*== =rbc3N<"TFp\V3RlV44xK R#5i)c36<"TFpSV,xK R#5irrr rXr5s& r r :ISMAGS._refine_node_partition...s#?QLOOQNrr rr5s& r r 0ISMAGS._refine_node_partition..sSAm#?Q#???rQFTc36<"TFpSV,xK R#5irrr;s& r r r@$s$Cd\!__dr=r/r)r6rYrrsortedr1r) clsrvr(rr6 node_colorsrrr5s &&&& @r rISMAGS._refine_node_partitions >+95 +E L #SS###SSSS&%D%$Cd$CCCFt NTWXYY% /y9K/KPLs$A Cc # aaa a!a"a#"VPpVPpVPo!S!Po"VPpVP 4p \ S!4p \ S!4U U u/uFwrWbK p p p /o#/pVfVP4p\P!VS,!pV0VS&SV\V43.pV'EdVR,woppVEFMo V\P8Xd\;QJd)V V"V#V3RlVS,4F 'gK RM RM!V V"V#V3RlVS,44'dKoV 'dk\;QJd3V V!V#V3RlVPS,4F 'gK RM( RM$!V V!V#V3RlVPS,44'dKS V9dKSS#9d S#S,pVVS S#S&SVS &\S#4\V48XdVP!4xS#SVS EK;VS#P4, pVP!4oV 'Eg"VS,pV\P"8Xd6\S"P4S"S ,P4, 4pVFpVV9d.V\P"8XdSV,X0,SV&K5K7VP%SV4pVSV3,pS"S ,U u0uFBp VP&S V 3,V8XgKV!VS!P%S V 44'gK@V kKD pp SV,\V40,SV&K EMVS,pVPS,pV\P"8Xd\\S"P4S"S ,P4, S!PS ,P4, 4pVEFgpVV9dVV9d.V\P"8XdSV,X0,SV&K=K?VP%VS4pVVS3,pS!PS ,U u0uFBp VP&V S 3,V8XgKV!VS!P%V S 44'gK@V kKD pp SV,\V40,SV&KVV9dtVP%SV4pVSV3,pS"S ,U u0uFBp VP&S V 3,V8XgKV!VS!P%S V 44'gK@V kKD pp MVP%SV4pVP%VS4pVSV3,pS"S ,U u0uFBp VP&S V 3,V8XgKV!VS!P%S V 44'gK@V kKD pp VVS3,pTS!PS ,U u0uFBp VP&V S 3,V8XgKV!VS!P%V S 44'gK@V kKD up ,pSV,\V40,SV&EKj VFfpSV3V9d\)WS ,^,R4pM!VS3V9d\)V RV S ,4pMKISV,\V40,SV&Kh \+VV3RlR7p\P!SV,!pV'gEK)V0SV&VP-VS\V434EKh VP/4SS#9gEKVS#S,S#SEKR#uup p iuup iuup iuup iuup iuup i5i) 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. Nc3~<"TF2pSV8g;'d!VS9;'dSV,SS,9xK4 R#5irr)r sgn2r graph_adjmappingrs& r r $ISMAGS._map_nodes..]sP%6Dt ?? GO??#DM2>?%6s = ==TFc3<"TF<pSV8g;'d+VS9;'dSV,SPS,9xK> R#5ir)rD)r rIrrvrKrs& r r rLesY)< 4KEE $EE ' U[[_ DE)...s2P.ss2P9Q<2P/Prbrrd)rw_adjrvrrBrr3keysrrrrrrrDrcopyrr-rr-rr*pop)$r_rrrrrrw subgraph_adjself_sge_colorsrB gn_ID_to_nodeidrX gn_node_to_ID rev_mappingsgn_candidatesqueue sgn_cand_iterold_gn left_to_mapsgn_nbrs not_gn_nbrsrI sgn_e_cnt sge_color gn2_cands sgn_predssgn_insgn_outnew_sgnnew_sgn_candidatesrrrvrJrKs$&f&&&& @@@@@r rISMAGS._map_nodes,s% ==}}  JJ ****, U ,5e,<=,<52,< =  ',,.L#//1DE-.s~tN';<=e16r .C# +s%1$5 sss%1$5  !"3)1s(; 333)1s(;  %$'>$S\F#F+! "% Bw<3|#44%**,, #B*W\\^; +//1 #{+C0H HKK/&/ 0@9R=CUCUCW0W&X +x/(HKK72;D/[M2Q $ 8 )1(@(@d(KI(7T (BI*32))6A#'??2q5#9Y#F!"$-Y8M8MbRS8T#U!")6&)/8o9AU@V.VIdO#!,& ,C0H (s 3I HKK/&/%NN,'m0023#kk"o2245' !,x/#94#, #;6?o 6UIdO$<*2)A)A$)L,;D#I,F .3[[_-"-<'+q"u'='J%&(19N9NqRT9U'V%&A-<!*-"3#GCL1 u)>^)6-"-"-"."sA&];. ];A];2];];#']; ]; ]; (]; 1];=B ]; B4];=]"]"?]"D$];)]' ]'+]'1A];],"],], =];]1']1]1#];1]6 ]6 3]6 9D ]; 1];c # a"\PpVf!\VPP40p\ \ \V4.44pRpV\ VP48:d[\V\R7FEp\VV3RlR7pVPVSW$VR7p \ V 4p V xT RjxL RpKG V'gV^8XdR#\4p VF/pVF&p VPWV4p V PV 4K( K1 VP!SW+R7RjxL R#Lw \dKi;iL5i)z9 Find all largest common subgraphs honoring constraints. NFrc6<\RSV,44#)c38"TFp\V4xK R#5irrJrs& r r DISMAGS._largest_common_subgraph....s7V 1A rr)rX candidatess&r r1ISMAGS._largest_common_subgraph..sC7V ST 7V4Vrb)rT)rrrrwrzrrrrvrCrr StopIterationr- _remove_noder)r)r_rprrr current_size found_isorznext_sgn isomorphsr left_to_be_mappedr new_nodess&f&& r rISMAGS._largest_common_subgraphsKKK  %dmm&9&9:;L4\ 2B78  3tzz? * &9u*VW OOj+u, % ?DJ((( $I!:&  ) E!E!--c+F !%%i0"00  1   3) %: sIB)E- D;8 ED9EAE2E 3E; E E E  Ec dVFwr4W08XgK WA9gKTpK \W0, 4#)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)r5rzrlowhighs&&& r rsISMAGS._remove_node8s5( ;4=D) !00rbc a\\4oVF$pS\V4,PV4K& \\P !V3Rl\ S44!4#)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 c3^<"TF"p\P!SV,4xK$ R#5ir)r permutations)r lby_lens& r r 5ISMAGS._get_permutations_by_length..^s#L^)((33^s*-)rrrr*rr%rC)r.r rs& @r _get_permutations_by_length"ISMAGS._get_permutations_by_lengthHsY T"D 3t9  $ $T *   LVF^L   rbc #a"V3RlpVPWV4pV.pV'EdVP4p\V4p\WV4o\;QJdV3RlV4F 'dK RM RM!V3RlV44'd!\ V4\ V48XdW#3xK..pVEFp \ V 4^8Xg\ V3RlV 44'dVFp V PV 4K KK\WRR7p \ V 4p V ^8Xg*T \ V U u0uFp \ V 4kK up 48Xd,VF#pVP\V \ R74K% KVPV 4p.pVF@pVF7p V UUu.uFpVFpVNK K pppVPVV,4K9 KB TpEK VPVRRR1,4EKR#uup iuuppi5i) c*<SV,SV,8H#rrr2s&&r r6'ISMAGS._refine_opp..equal_colorcr8rbc3N<"TFp\V3RlV44xK R#5i)c36<"TFpSV,xK R#5irrr;s& r r /ISMAGS._refine_opp...ms r?s& r r %ISMAGS._refine_opp..msMf= (([A"8%))+F.v6K/KPLsMfMsssMfMMMs8s6{*+%4Lt9>]2WRV2W%W%W&2 "))$/'3$2$5#QLL)AAvc<*H"TFp\V4^8*xK R#5irOrJr rs& r r :ISMAGS._process_ordered_pair_partitions..s6 s3x1} FTc<V 3Rl\V44p\V4wrEpW&,p\\VS R74pVP WWVV.4R#)c3t<"TF-wrVF"p\V4^8gKSV,W13xK$ K/ R#5irOrJ)r rt_partr5 node_to_IDs& r r ZISMAGS._process_ordered_pair_partitions.._load_next_queue_entry..s>#;KC"Dv;?.D!4-".#;s88rN)r3rrrCr*) r]rrunmapped_nodesrr5part_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 Urbc3>"TFp\V4^8*xK R#5irOrJrs& r r rs?s3x1}rc3Z"TF!wr\V4^8*;'gW8HxK# R#5irOrJ)r tbs& r r rs'IytqSVq[22AF2ys+ +c3*<"TFqS3xK R#5irr)r rXorb1s& r r rs/N:aD :sNrd) rr3rfrTinsertrrrupdater-rrU)%r_rvrrrfinding_identityorbit_ir5orbit_idorbitsrirXrr]topsbottomsrrr4 new_top_part new_bot_partrnew_toprnew_botoppsnew_qopprn1n2orb2 orbit_set2rrrs%&&&&& @@@r r'ISMAGS._process_ordered_pair_partitionss 36 63336 6 6 6I 7@7GH7GmgDM7GH%*+UT&U+'0'78'7tqad'78 ++  Vu5EFe6;Bi 3D'4#5=X^x%F!%v %w 156#388:6</v|4189#388:9</v|4''wMC (3?A?333?A???/4,$@IsCyIIsCyIII(,'>'>'D &2FB#+B#>#@FL kI+9@7:s L&$ L, L15L7;L<) rr}rrrr|rrr~r{rxrvrw)NNNT)Fr)rjrkrlrmrnr`ryrrrrrrrr rrrr classmethodrrr staticmethodrsrrrrrorprqs@r rrzsiV5Sn]*~ HT 6*X"H   "$I,A,$BL:(F%PB H 1 1  208d4ccrbr)rn__all__rr collectionsrrnetworkxr+rr1r6rGrYr[rrrbr rsUxt *,3CL&&