VhrdZddlZddlZddgZGddZGddeZGddZGd d Zy) a ************* VF2 Algorithm ************* An implementation of VF2 algorithm for graph isomorphism testing. The simplest interface to use this module is to call the :func:`is_isomorphic ` function. Introduction ------------ The GraphMatcher and DiGraphMatcher are responsible for matching graphs or directed graphs in a predetermined manner. This usually means a check for an isomorphism, though other checks are also possible. For example, a subgraph of one graph can be checked for isomorphism to a second graph. Matching is done via syntactic feasibility. It is also possible to check for semantic feasibility. Feasibility, then, is defined as the logical AND of the two functions. To include a semantic check, the (Di)GraphMatcher class should be subclassed, and the :meth:`semantic_feasibility ` function should be redefined. By default, the semantic feasibility function always returns ``True``. The effect of this is that semantics are not considered in the matching of G1 and G2. Examples -------- Suppose G1 and G2 are isomorphic graphs. Verification is as follows: >>> from networkx.algorithms import isomorphism >>> G1 = nx.path_graph(4) >>> G2 = nx.path_graph(4) >>> GM = isomorphism.GraphMatcher(G1, G2) >>> GM.is_isomorphic() True GM.mapping stores the isomorphism mapping from G1 to G2. >>> GM.mapping {0: 0, 1: 1, 2: 2, 3: 3} Suppose G1 and G2 are isomorphic directed graphs. Verification is as follows: >>> G1 = nx.path_graph(4, create_using=nx.DiGraph) >>> G2 = nx.path_graph(4, create_using=nx.DiGraph) >>> DiGM = isomorphism.DiGraphMatcher(G1, G2) >>> DiGM.is_isomorphic() True DiGM.mapping stores the isomorphism mapping from G1 to G2. >>> DiGM.mapping {0: 0, 1: 1, 2: 2, 3: 3} Subgraph Isomorphism -------------------- Graph theory literature can be ambiguous about the meaning of the above statement, and we seek to clarify it now. In the VF2 literature, a mapping ``M`` is said to be a graph-subgraph isomorphism iff ``M`` is an isomorphism between ``G2`` and a subgraph of ``G1``. Thus, to say that ``G1`` and ``G2`` are graph-subgraph isomorphic is to say that a subgraph of ``G1`` is isomorphic to ``G2``. Other literature uses the phrase 'subgraph isomorphic' as in '``G1`` does not have a subgraph isomorphic to ``G2``'. Another use is as an in adverb for isomorphic. Thus, to say that ``G1`` and ``G2`` are subgraph isomorphic is to say that a subgraph of ``G1`` is isomorphic to ``G2``. Finally, the term 'subgraph' can have multiple meanings. In this context, 'subgraph' always means a 'node-induced subgraph'. Edge-induced subgraph isomorphisms are not directly supported, but one should be able to perform the check by making use of :func:`line_graph `. For subgraphs which are not induced, the term 'monomorphism' is preferred over 'isomorphism'. Let ``G = (N, E)`` be a graph with a set of nodes ``N`` and set of edges ``E``. If ``G' = (N', E')`` is a subgraph, then: ``N'`` is a subset of ``N`` and ``E'`` is a subset of ``E``. If ``G' = (N', E')`` is a node-induced subgraph, then: ``N'`` is a subset of ``N`` and ``E'`` is the subset of edges in ``E`` relating nodes in ``N'``. If ``G' = (N', E')`` is an edge-induced subgraph, then: ``N'`` is the subset of nodes in ``N`` related by edges in ``E'`` and ``E'`` is a subset of ``E``. If ``G' = (N', E')`` is a monomorphism, then: ``N'`` is a subset of ``N`` and ``E'`` is a subset of the set of edges in ``E`` relating nodes in ``N'``. Note that if ``G'`` is a node-induced subgraph of ``G``, then it is always a subgraph monomorphism of ``G``, but the opposite is not always true, as a monomorphism can have fewer edges. References ---------- [1] Luigi P. Cordella, Pasquale Foggia, Carlo Sansone, Mario Vento, "A (Sub)Graph Isomorphism Algorithm for Matching Large Graphs", IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 26, no. 10, pp. 1367-1372, Oct., 2004. http://ieeexplore.ieee.org/iel5/34/29305/01323804.pdf [2] L. P. Cordella, P. Foggia, C. Sansone, M. Vento, "An Improved Algorithm for Matching Large Graphs", 3rd IAPR-TC15 Workshop on Graph-based Representations in Pattern Recognition, Cuen, pp. 149-159, 2001. https://www.researchgate.net/publication/200034365_An_Improved_Algorithm_for_Matching_Large_Graphs See Also -------- :meth:`semantic_feasibility ` :meth:`syntactic_feasibility ` Notes ----- The implementation handles both directed and undirected graphs as well as multigraphs. In general, the subgraph isomorphism problem is NP-complete whereas the graph isomorphism problem is most likely not NP-complete (although no polynomial-time algorithm is known to exist). N GraphMatcherDiGraphMatchercdeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZy)rzvImplementation of VF2 algorithm for matching undirected graphs. Suitable for Graph and MultiGraph instances. cD|j|jk7rtjd|j}|s5|js|jrtjd|r5|jr|jstjd||_||_t |j|_t |j|_ t|Dcic]\}}|| c}}|_ tj|_t|j }|jd|zkr!tj t#d|zd|_|j'ycc}}w)aInitialize GraphMatcher. Parameters ---------- G1,G2: NetworkX Graph or MultiGraph instances. The two graphs to check for isomorphism or monomorphism. Examples -------- To create a GraphMatcher which checks for syntactic feasibility: >>> from networkx.algorithms import isomorphism >>> G1 = nx.path_graph(4) >>> G2 = nx.path_graph(4) >>> GM = isomorphism.GraphMatcher(G1, G2) z)G1 and G2 must have the same directednessz](Multi-)GraphMatcher() not defined for directed graphs. Use (Multi-)DiGraphMatcher() instead.z_(Multi-)DiGraphMatcher() not defined for undirected graphs. Use (Multi-)GraphMatcher() instead.g?graphN) is_directednx NetworkXError_is_directed_matcherG1G2setnodesG1_nodesG2_nodes enumerate G2_node_ordersysgetrecursionlimitold_recursion_limitlensetrecursionlimitinttest initialize)selfr r is_directed_matcherinexpected_max_recursion_levels [/home/dcms/DCMS/lib/python3.12/site-packages/networkx/algorithms/isomorphism/isomorphvf2.py__init__zGraphMatcher.__init__sP" >> r~~/ /""#NO O"779"(8BNNs Fcy)NFrs r!r z!GraphMatcher._is_directed_matcherscBtj|jy)zRestores the recursion limit.N)rrrr%s r!reset_recursion_limitz"GraphMatcher.reset_recursion_limits d667r&c#K|j}|j}|jj}|jDcgc]}||j vs|}}|j Dcgc]}||jvs|}}|r|rt||}|D]}||f y t|t|jz |} |jD]}||j vs|| fycc}wcc}wwz4Iterator over candidate pairs of nodes in G1 and G2.)keyN) rrr __getitem__inout_1core_1inout_2core_2minrr ) rrrmin_keynodeT1_inoutT2_inoutnode_2node_1 other_nodes r!candidate_pairs_iterz!GraphMatcher.candidate_pairs_iters ====$$00&*\\MTT5LDMM%)\\MTT5LDMM w/F" %fn$ % C ,z-GraphMatcher.is_isomorphic..03$!QA3c3&K|] \}}| ywrAr$rBs r!rEz-GraphMatcher.is_isomorphic..1rFrGT)r orderr sorteddegreenextisomorphisms_iter StopIteration)rd1d2xs r! is_isomorphiczGraphMatcher.is_isomorphic$s 77==?dggmmo -3$''.."23 3 3$''.."23 3 8 T++-.A  sB,, B87B8c#nKd|_|j|jEd{y7w)z.Generator over isomorphisms between G1 and G2.rNrrmatchr%s r!rMzGraphMatcher.isomorphisms_iter;s(  ::< +535c#Kt|jt|jk(r.|jj|_|jy|j D]p\}}|j ||s|j||s,|jj|||}|jEd{|jry7w)a%Extends the isomorphism mapping. This function is called recursively to determine if a complete isomorphism can be found between G1 and G2. It cleans up the class variables after each recursive call. If an isomorphism is found, we yield the mapping. N) rr.r r=r>r9syntactic_feasibilitysemantic_feasibilityr< __class__rUrestore)rG1_nodeG2_nodenewstates r!rUzGraphMatcher.matchBs t{{ s477| +;;++-DL,, $($=$=$? + --gw?00'B#'::#7#7gw#O#'::<//!((* + 0sBC"C"0C"C  C"cy)aReturns True if adding (G1_node, G2_node) is semantically feasible. The semantic feasibility function should return True if it is acceptable to add the candidate pair (G1_node, G2_node) to the current partial isomorphism mapping. The logic should focus on semantic information contained in the edge data or a formalized node class. By acceptable, we mean that the subsequent mapping can still become a complete isomorphism mapping. Thus, if adding the candidate pair definitely makes it so that the subsequent mapping cannot become a complete isomorphism mapping, then this function must return False. The default semantic feasibility function always returns True. The effect is that semantics are not considered in the matching of G1 and G2. The semantic checks might differ based on the what type of test is being performed. A keyword description of the test is stored in self.test. Here is a quick description of the currently implemented tests:: test='graph' Indicates that the graph matcher is looking for a graph-graph isomorphism. test='subgraph' Indicates that the graph matcher is looking for a subgraph-graph isomorphism such that a subgraph of G1 is isomorphic to G2. test='mono' Indicates that the graph matcher is looking for a subgraph-graph monomorphism such that a subgraph of G1 is monomorphic to G2. Any subclass which redefines semantic_feasibility() must maintain the above form to keep the match() method functional. Implementations should consider multigraphs. Tr$)rr\r]s r!rYz!GraphMatcher.semantic_feasibility[sLr&cV t|j}y#t$rYywxYw)aReturns `True` if a subgraph of ``G1`` is isomorphic to ``G2``. Examples -------- When creating the `GraphMatcher`, the order of the arguments is important >>> G = nx.Graph([("A", "B"), ("B", "C"), ("A", "C")]) >>> H = nx.Graph([(0, 1), (1, 2), (0, 2), (1, 3), (0, 4)]) Check whether a subgraph of G is isomorphic to H: >>> isomatcher = nx.isomorphism.GraphMatcher(G, H) >>> isomatcher.subgraph_is_isomorphic() False Check whether a subgraph of H is isomorphic to G: >>> isomatcher = nx.isomorphism.GraphMatcher(H, G) >>> isomatcher.subgraph_is_isomorphic() True TF)rLsubgraph_isomorphisms_iterrNrrQs r!subgraph_is_isomorphicz#GraphMatcher.subgraph_is_isomorphics/, T4467A    ((cV t|j}y#t$rYywxYw)aReturns `True` if a subgraph of ``G1`` is monomorphic to ``G2``. Examples -------- When creating the `GraphMatcher`, the order of the arguments is important. >>> G = nx.Graph([("A", "B"), ("B", "C")]) >>> H = nx.Graph([(0, 1), (1, 2), (0, 2)]) Check whether a subgraph of G is monomorphic to H: >>> isomatcher = nx.isomorphism.GraphMatcher(G, H) >>> isomatcher.subgraph_is_monomorphic() False Check whether a subgraph of H is monomorphic to G: >>> isomatcher = nx.isomorphism.GraphMatcher(H, G) >>> isomatcher.subgraph_is_monomorphic() True TF)rLsubgraph_monomorphisms_iterrNrbs r!subgraph_is_monomorphicz$GraphMatcher.subgraph_is_monomorphics/, T5578A  rdc#nKd|_|j|jEd{y7w)aGenerator over isomorphisms between a subgraph of ``G1`` and ``G2``. Examples -------- When creating the `GraphMatcher`, the order of the arguments is important >>> G = nx.Graph([("A", "B"), ("B", "C"), ("A", "C")]) >>> H = nx.Graph([(0, 1), (1, 2), (0, 2), (1, 3), (0, 4)]) Yield isomorphic mappings between ``H`` and subgraphs of ``G``: >>> isomatcher = nx.isomorphism.GraphMatcher(G, H) >>> list(isomatcher.subgraph_isomorphisms_iter()) [] Yield isomorphic mappings between ``G`` and subgraphs of ``H``: >>> isomatcher = nx.isomorphism.GraphMatcher(H, G) >>> next(isomatcher.subgraph_isomorphisms_iter()) {0: 'A', 1: 'B', 2: 'C'} subgraphNrTr%s r!raz'GraphMatcher.subgraph_isomorphisms_iters(0  ::<rVc#nKd|_|j|jEd{y7w)aGenerator over monomorphisms between a subgraph of ``G1`` and ``G2``. Examples -------- When creating the `GraphMatcher`, the order of the arguments is important. >>> G = nx.Graph([("A", "B"), ("B", "C")]) >>> H = nx.Graph([(0, 1), (1, 2), (0, 2)]) Yield monomorphic mappings between ``H`` and subgraphs of ``G``: >>> isomatcher = nx.isomorphism.GraphMatcher(G, H) >>> list(isomatcher.subgraph_monomorphisms_iter()) [] Yield monomorphic mappings between ``G`` and subgraphs of ``H``: >>> isomatcher = nx.isomorphism.GraphMatcher(H, G) >>> next(isomatcher.subgraph_monomorphisms_iter()) {0: 'A', 1: 'B', 2: 'C'} monoNrTr%s r!rfz(GraphMatcher.subgraph_monomorphisms_iters(.  ::<rVc|jdk(r:|jj|||jj||kr;y|jj|||jj||k7ry|jdk7r|j|D]y}||jvs|j||j|vry|jj|||jj|j||k7syy|j|D]}||j vs|j ||j|vry|jdk(rI|jj|j |||jj||ksy|jj|j |||jj||k7sy|jdk7rd}|j|D]%}||j vs||jvs!|dz }'d}|j|D]%}||jvs||j vs!|dz }'|jdk(r||k7ry||k\syd}|j|D]}||j vs|dz }d}|j|D]}||jvs|dz }|jdk(r||k7ryy||k\syya|Returns True if adding (G1_node, G2_node) is syntactically feasible. This function returns True if it is adding the candidate pair to the current partial isomorphism/monomorphism mapping is allowable. The addition is allowable if the inclusion of the candidate pair does not make it impossible for an isomorphism/monomorphism to be found. rkFrrT)rr number_of_edgesr r.r0r-r/)rr\r]neighbornum1num2s r!rXz"GraphMatcher.syntactic_feasibilitysH 99 ww&&w8477;R;R<ww&&w8DGG. +2&P88 8 6yr&cbeZdZdZfdZdZdZdZdZfdZ fdZ fd Z fd Z xZ S) rzxImplementation of VF2 algorithm for matching directed graphs. Suitable for DiGraph and MultiDiGraph instances. c&t|||y)aInitialize DiGraphMatcher. G1 and G2 should be nx.Graph or nx.MultiGraph instances. Examples -------- To create a GraphMatcher which checks for syntactic feasibility: >>> from networkx.algorithms import isomorphism >>> G1 = nx.DiGraph(nx.path_graph(4, create_using=nx.DiGraph())) >>> G2 = nx.DiGraph(nx.path_graph(4, create_using=nx.DiGraph())) >>> DiGM = isomorphism.DiGraphMatcher(G1, G2) N)superr")rr r rZs r!r"zDiGraphMatcher.__init__ts R r&cy)NTr$r%s r!r z#DiGraphMatcher._is_directed_matchersr&c#K|j}|j}|jj}|jDcgc]}||j vs|}}|j Dcgc]}||jvs|}}|r|rt||}|D]}||f y|jDcgc]}||j vs|} }|jDcgc]}||jvs|} }| r| rt| |}| D]}||f yt|t|jz |}|D]}||j vs||fycc}wcc}wcc}wcc}wwr*) rrrr,out_1r.out_2r0r1in_1in_2r) rrrr2r3T1_outT2_outr6r7T1_inT2_ins r!r9z#DiGraphMatcher.candidate_pairs_itersb ====$$00$(::I4T[[1H$II#'::I4T[[1H$II fW-F  %fn$ %'+iiKd4t{{3JTKEK&*iiKd4t{{3JTKEKU0#)F &.()XDKK(88gF&-FT[[0$fn,-?JILKsS=E#EEE#'E;E?/E#.EEE#E*E.AE#E#ci|_i|_i|_i|_i|_i|_t ||_|jj|_ y)zReinitializes the state of the algorithm. This method should be redefined if using something other than DiGMState. If only subclassing GraphMatcher, a redefinition is not necessary. N) r.r0r~rr|r} DiGMStater<r=r>r%s r!rzDiGraphMatcher.initializesQ      t_ {{'') r&c|jdk(r:|jj|||jj||kr;y|jj|||jj||k7ry|jdk7r|jj|D]}||j vs|j ||jj|vry|jj|||jj|j ||k7sy|jj|D]}||j vs|j ||jj|vry|jdk(rI|jj|j |||jj||ksy|jj|j |||jj||k7sy|jdk7r|j|D]y}||j vs|j ||j|vry|jj|||jj||j |k7syy|j|D]}||j vs|j ||j|vry|jdk(rI|jj||j ||jj||ksy|jj||j ||jj||k7sy|jdk7rd}|jj|D]%}||jvs||j vs!|dz }'d}|jj|D]%}||jvs||j vs!|dz }'|jdk(r||k7ry||k\syd}|j|D]%}||jvs||j vs!|dz }'d}|j|D]%}||jvs||j vs!|dz }'|jdk(r||k7ry||k\syd}|jj|D]%}||jvs||j vs!|dz }'d}|jj|D]%}||jvs||j vs!|dz }'|jdk(r||k7ry||k\syd}|j|D]%}||jvs||j vs!|dz }'d}|j|D]%}||jvs||j vs!|dz }'|jdk(r||k7ry||k\syd}|jj|D]%}||jvs||jvs!|dz }'d}|jj|D]%}||jvs||jvs!|dz }'|jdk(r||k7ry||k\syd}|j|D]%}||jvs||jvs!|dz }'d}|j|D]%}||jvs||jvs!|dz }'|jdk(r||k7ryy||k\syyrm) rr ror predr.r0r~rr|r})rr\r] predecessor successorrqrrs r!rXz$DiGraphMatcher.syntactic_feasibilitys1D 99 ww&&w8477;R;R<ww&&w8DGG>> G = nx.DiGraph([("A", "B"), ("B", "A"), ("B", "C"), ("C", "B")]) >>> H = nx.DiGraph(nx.path_graph(5)) Check whether a subgraph of G is isomorphic to H: >>> isomatcher = nx.isomorphism.DiGraphMatcher(G, H) >>> isomatcher.subgraph_is_isomorphic() False Check whether a subgraph of H is isomorphic to G: >>> isomatcher = nx.isomorphism.DiGraphMatcher(H, G) >>> isomatcher.subgraph_is_isomorphic() True )ryrcrrZs r!rcz%DiGraphMatcher.subgraph_is_isomorphics,w-//r&c t|S)aReturns `True` if a subgraph of ``G1`` is monomorphic to ``G2``. Examples -------- When creating the `DiGraphMatcher`, the order of the arguments is important. >>> G = nx.DiGraph([("A", "B"), ("C", "B"), ("D", "C")]) >>> H = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 2)]) Check whether a subgraph of G is monomorphic to H: >>> isomatcher = nx.isomorphism.DiGraphMatcher(G, H) >>> isomatcher.subgraph_is_monomorphic() False Check whether a subgraph of H is isomorphic to G: >>> isomatcher = nx.isomorphism.DiGraphMatcher(H, G) >>> isomatcher.subgraph_is_monomorphic() True )ryrgrs r!rgz&DiGraphMatcher.subgraph_is_monomorphics,w.00r&c t|S)aGenerator over isomorphisms between a subgraph of ``G1`` and ``G2``. Examples -------- When creating the `DiGraphMatcher`, the order of the arguments is important >>> G = nx.DiGraph([("B", "C"), ("C", "B"), ("C", "D"), ("D", "C")]) >>> H = nx.DiGraph(nx.path_graph(5)) Yield isomorphic mappings between ``H`` and subgraphs of ``G``: >>> isomatcher = nx.isomorphism.DiGraphMatcher(G, H) >>> list(isomatcher.subgraph_isomorphisms_iter()) [] Yield isomorphic mappings between ``G`` and subgraphs of ``H``: >>> isomatcher = nx.isomorphism.DiGraphMatcher(H, G) >>> next(isomatcher.subgraph_isomorphisms_iter()) {0: 'B', 1: 'C', 2: 'D'} )ryrars r!raz)DiGraphMatcher.subgraph_isomorphisms_iters,w133r&c t|S)aGenerator over monomorphisms between a subgraph of ``G1`` and ``G2``. Examples -------- When creating the `DiGraphMatcher`, the order of the arguments is important. >>> G = nx.DiGraph([("A", "B"), ("C", "B"), ("D", "C")]) >>> H = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 2)]) Yield monomorphic mappings between ``H`` and subgraphs of ``G``: >>> isomatcher = nx.isomorphism.DiGraphMatcher(G, H) >>> list(isomatcher.subgraph_monomorphisms_iter()) [] Yield monomorphic mappings between ``G`` and subgraphs of ``H``: >>> isomatcher = nx.isomorphism.DiGraphMatcher(H, G) >>> next(isomatcher.subgraph_monomorphisms_iter()) {3: 'A', 2: 'B', 1: 'C', 0: 'D'} )ryrfrs r!rfz*DiGraphMatcher.subgraph_monomorphisms_iters,w244r&)rsrtrurvr"r r9rrXrcrgrarf __classcell__)rZs@r!rrns> ! +-^ *D\|00104055r&ceZdZdZddZdZy)r;aGInternal representation of state for the GraphMatcher class. This class is used internally by the GraphMatcher class. It is used only to store state specific data. There will be at most G2.order() of these objects in memory at a time, due to the depth-first search strategy employed by the VF2 algorithm. Nc||_d|_d|_t|j|_||i|_i|_i|_i|_||||j|<||j |<||_||_t|j|_||jvr|j |j|<||jvr|j |j|<t}|jD]=}|j|j|Dcgc]}||jvs|c}?|D]*}||jvs|j |j|<,t}|j D]=}|j|j|Dcgc]}||j vs|c}?|D]*}||jvs|j |j|<,yyycc}wcc}w)zInitializes GMState object. Pass in the GraphMatcher to which this GMState belongs and the new node pair that will be added to the GraphMatcher's current isomorphism mapping. N) GMr\r]rr.depthr0r-r/rupdater r )rrr\r] new_nodesr3rps r!r"zGMState.__init__ s  ^ ?goBIBIBJBJ  7#6!(BIIg !(BIIg #DL"DLRYYDJbjj(&*jj 7#bjj(&*jj 7# I    .0eeDkW(XRYY=VXW " 2rzz)'+zzBJJt$ 2 I    .0eeDkW(XRYY=VXW " 2rzz)'+zzBJJt$ 2K$7 2XXsG7 3G7 $G< 8G< c|jN|jB|jj|j=|jj|j=|jj |jj fD]6}t|jD]}|||jk(s||=8y)zDeletes the DiGMState object and restores the class variables.N) r\r]rr.r0r~rr|r}rrrrs r!r[zDiGMState.restores << # (@t||,t||,ww||TWW\\477==$''--P %FV[[]+ %$<4::-t  % %r&rrr$r&r!rrose0N%r&r) rvrnetworkxr __all__rrr;rr$r&r!rsTKd  + ,QQhf5\f5R U%U%p%%r&