子图同构之VF2

1.子图同构问题描述

​ 首先描述一下子图同构是什么意思，一个图由一系列节点和一系列连接节点的边构成，节点和边都可以有标签，也就是可以给他们按属性分类。

​ 精确点：一个图$G=(V,E)$由集合$V$和集合$E$组成，$V$是节点(node)集合， $E$是边(edge)集合，且$E\subset V\times V$ ，用$L_v$表示节点上的标签集合，$L_e$表示边上的标签集合，那么每个节点对应的标签由函数（或者说映射）${\lambda }_v:V\to L_v$ 确定，每条边对应的标签由函数${\lambda }_e:E\to L_e$ 确定。

​ 现在给定两个图$G_1=(V_1,E_1)$, $G_2=(V_2,E_2)$ ,其中$G_1$是比较小的图(我们把它叫做pattern graph)，$G_2$是比较大的图(我们把它叫做target graph),用集合$M\subset V_1\times V_2$ 表示两个图中节点的对应关系。如果节点$u\in V_1$,则$\mu (u)\in V_2$表示与节点$u$对应的$G_2$中的节点；如果节点$v\in V_2$,则$\nu (v)\in V_1$表示与节点$v$对应的$G_1$中的节点。

​ 如果以下6个条件成立，则这两个图是子图同构的。

1. $$\forall u\in V_1\exists \mu (u)\in V_2:(u,\mu (u))\in M$$
2. $$\forall u,u^{{}^{\prime }}\in V_{1}u\ne u^{{}^{\prime }}\Rightarrow \mu (u)\ne \mu (u^{{}^{\prime }})$$
3. $$\forall (u,u^{{}^{\prime }})\in E_1\exists (\mu (u),\mu (u^{{}^{\prime }}))\in E_2)$$
4. $$\forall u,u^{{}^{\prime }}\in V_1(\mu (u),\mu (u^{{}^{\prime }}))\in E_2\Rightarrow (u,u^{{}^{\prime }})\in E_1$$
5. $$\forall u\in V_1{\lambda }_{V_1}(u)={\lambda }_{V_2}(\mu (u))$$
6. $$\forall (u,u^{{}^{\prime }})\in E_1{\lambda }_{e_1}(u,u^{{}^{\prime }})={\lambda }_{e_2}(\mu (u),\mu (u^{{}^{\prime }}))$$

用人话来解释一下：

1. 对于小图中每个节点，大图中都要有一个对应的节点与之对应，并且这样一对一对的节点构成了集合$M$；

2. 小图中任意两个不一样的节点，他们对应的大图中的节点不能是同一个；

3. 小图中每条边，大图中都有一条边与之对应，并且他们两端的节点一一对应；

4. 小图中任意两个节点，如果他们对应的大图中的节点之间有一条边，那么小图中这两个节点之间也得有条边;

5. 每对对应节点的label要相同，也就是这俩节点类型或属性相同；

6. 每对对应边的label要相同，也就是说这俩边的类型或属性相同。

​ 综上所述，子图同构简单来说就是，大图中有一个子结构，长得跟小图一模一样，而且这个子结构的节点之间不能多出小图中不存在的边来，如果要去掉最后这个而且，就把上面第4个条件去掉~

2.VF2算法

​ VF2算法的目标是，给定一个小图和一个大图，找出大图中所有与小图同构的子图，这是一个NP-hard问题。整体上，VF3算法是一个树搜索算法，并且想办法去尽可能剪枝。搜索树上的每个节点都是一个状态（state)，记为$s$，每个$s$中包含一系列节点的映射关系，可以想象成一系列key-value对，key都是小图中的节点，value都是大图中的节点。搜索最开始的时候（也就是树的根节点）$s$中什么都没有，随着搜索的进行（树高度的增加），$s$中的key-value对会一对对增加，假如这个状态中所有的节点对都满足第一节中的6条约束，我们称这个状态为一致状态(consistent state)；如果一个一致状态包含的小图中所有的节点，那意味着我们找到了一个大图的子结构与小图同构，称之为目标状态(goal state)；如果一个状态是不可能再派生出一致状态的，我们称之为死亡状态（dead state)。

​ 那么现在最大的问题就是两个：

1. 这棵搜索树怎么组织?
2. 怎么设计剪枝规则？

下面逐个展开~

A. 总体流程介绍

先来介绍一些符号：

$\tilde{M}(s)$表示状态$s$中的节点映射集合，则$\tilde{M}(s)\subseteq M$；

$\widetilde{M_1}(s)$表示$\tilde{M}(s)$中属于$G_1$的节点，也就是所有的key,严格点： M 1 ~ ( s ) = { u ∈ V 1 : ∃ ( u , v ) ∈ M ~ ( s ) , v ∈ V 2 } \tilde{M_1}(s)=\{u\in V_1:\exist (u,v)\in \tilde{M}(s),v\in V_2\} M1​~​(s)={u∈V1​:∃(u,v)∈M~(s),v∈V2​}；

$\widetilde{M_2}(s)$表示$\tilde{M}(s)$中属于$G_2$的节点，也就是所有的value,严格点： M 2 ~ ( s ) = { v ∈ V 2 : ∃ ( u , v ) ∈ M ~ ( s ) , u ∈ V 1 } \tilde{M_2}(s)=\{v\in V_2:\exist (u,v)\in \tilde{M}(s),u\in V_1\} M2​~​(s)={v∈V2​:∃(u,v)∈M~(s),u∈V1​}；

${\tilde{G}}_1(s)$表示仅包含节点在$\widetilde{M_1}(s)$中的$G_1$的子图，也就是比$\widetilde{M_1}(s)$加上了边；

${\tilde{G}}_2(s)$表示仅包含节点在$\widetilde{M_2}(s)$中的$G_2$的子图，也就是比$\widetilde{M_2}(s)$加上了边;

$\tilde{\mu }(s,u)$表示$\tilde{M}(s)$中与$u$对应的节点，其中$u\in V_1$,$\tilde{\mu }(s,u)\in V_2$；

${\tilde{\mu }}^{-1}(s,v)$表示$\tilde{M}(s)$中与$v$对应的节点，其中${\tilde{\mu }}^{-1}(s,v)\in V_1$,$v\in V_2$。

大致看一下整个流程，上伪代码~VF2总流程

1: $functionVF2(G_1,G_2)$

2: $Solutions=\varnothing$

3: $M(s_0)=\varnothing$

4: $Match(M(s_0),G_2,G_1,Solutions)$

5: $returnSolutions$

1: $functionMatch(M(s),G_2,G_1,Solutions)$

2: $ifM(s)coversallthenodesof{G}_{1}then$

3: $Append(M(s),Solutions)$

4: $else$

5: $P(s)=GetCantitates(M(s))$

6: $foreachpairinP(s)$

7: $ifIsFeasible(pair)$

8： $M(s^{{}^{\prime }})=ExtendMatch((M(s),pair)$

9: $Match(M(s^{{}^{\prime }}),G_2,G_1,Solutions)$

10: $BackTrack(M(s^{{}^{\prime }}),pair)$

​ 一开始，$\tilde{M}(s)$中什么都没有，调用$Match$函数开始后，先根据当前状态$s$和一些与$s$中节点的连接拓扑关系，获得节点对集合$P(s)$，这是接下来准备加入状态$s$候选节点对集合，每一节点对包含一个小图节点和一个大图节点。接下来对这个候选节点对集合遍历，每取出一对节点，先用$IsFeasible$函数判断其是否可行，如果可以有一些规则提前知道，这一对节点加入必然不可能最终得到一对子图同构，就可以不继续往下搜索；如果该节点对可行，就将这对节点加入状态$s$得到状态$s^{{}^{\prime }}$，并递归调用$Match$函数继续往下搜索。搜完每一分支进行回溯，整个过程就是一个深度优先搜索过程，状态$s$构成了树的每一个节点，$s$中的节点数相当于搜索树的深度。每找到一个子图同构（也就是深度达到小图节点数）就把结果加入$Solution$。因此该算法的关键在于如何设计可行规则，尽可能早地筛除不可能最终获得子图同构的节点对，也就是尽可能早、尽可能多地砍掉搜索树中的分支。

B 候选节点对

​ 首先我们将一个状态下不在$\tilde{M}(s)$里的节点分为${\tilde{P}}_1$,${\tilde{S}}_1$,${\tilde{V}}_1$${\tilde{P}}_2$,${\tilde{S}}_2$,${\tilde{V}}_2$ ,其中下标1代表是属于小图$G_1$的节点子集，下标2代表是属于大图$G_2$的节点子集，$P$是predecessor，意思是前驱节点，具体讲是至少有一条边连接到已经匹配的$\tilde{M}(s)$集合中节点的所有节点构成的集合，好拗口…重来：一个predecessor节点就是有边指向$\tilde{M}(s)$里面的节点；$S$与$P$相对，是successor,即后继节点，是从$\tilde{M}(s)$中出来被指向的节点构成的集合；最后$V$是这个图中既不在$M$中，又不在$P$和$S$中的节点构成的集合。综上，$M$是已经匹配的节点集合，$P$和$S$是直接和已经匹配的节点相连的节点集合，V是更外圈的节点集合，下面严格定义一下~

1. P ~ 1 ( s ) = { u ∈ V 1 − M ~ 1 ( s ) : ∃ u ′ ∈ M ~ 1 ( s ) : ( u , u ′ ) ∈ E 1 } \tilde P_1(s)=\{u\in V_1-\tilde M_1(s):\exist u^{'}\in \tilde M_1(s):(u,u^{'})\in E_1 \} P~1​(s)={u∈V1​−M~1​(s):∃u′∈M~1​(s):(u,u′)∈E1​}
2. S ~ 1 ( s ) = { u ∈ V 1 − M ~ 1 ( s ) : ∃ u ′ ∈ M ~ 1 ( s ) : ( u ′ , u ) ∈ E 1 } \tilde S_1(s)=\{u\in V_1-\tilde M_1(s):\exist u^{'}\in \tilde M_1(s):(u^{'},u)\in E_1 \} S~1​(s)={u∈V1​−M~1​(s):∃u′∈M~1​(s):(u′,u)∈E1​}
3. ${\tilde{V}}_1(s)=V_1-{\tilde{M}}_1(s)-{\tilde{P}}_1(s)-{\tilde{S}}_1(s)$
4. P ~ 2 ( s ) = { v ∈ V 2 − M ~ 2 ( s ) : ∃ v ′ ∈ M ~ 2 ( s ) : ( v , v ′ ) ∈ E 2 } \tilde P_2(s)=\{v\in V_2-\tilde M_2(s):\exist v^{'}\in \tilde M_2(s):(v,v^{'})\in E_2 \} P~2​(s)={v∈V2​−M~2​(s):∃v′∈M~2​(s):(v,v′)∈E2​}
5. S ~ 2 ( s ) = { v ∈ V 2 − M ~ 2 ( s ) : ∃ v ′ ∈ M ~ 2 ( s ) : ( v ′ , v ) ∈ E 2 } \tilde S_2(s)=\{v\in V_2-\tilde M_2(s):\exist v^{'}\in \tilde M_2(s):(v^{'},v)\in E_2 \} S~2​(s)={v∈V2​−M~2​(s):∃v′∈M~2​(s):(v′,v)∈E2​}
6. ${\tilde{V}}_2(s)=V_2-{\tilde{M}}_2(s)-{\tilde{P}}_2(s)-{\tilde{S}}_2(s)$

几个集合的关系如下图所示~~~

​ 那么当前状态$s$下，候选节点对集合$P(s)$由哪些节点对构成？任意选一个节点$u\in {\tilde{P}}_1(s)$，再任意选一个节点$v\in {\tilde{P}}_2(s)$，所有这样的节点构成的节点对$(u,v)$都得在$P(s)$里；任意选一个节点$u\in {\tilde{S}}_1(s)$，再任意选一个节点$v\in {\tilde{S}}_2(s)$，所有这样的节点构成的节点对$(u,v)$也得在$P(s)$里；如果能构成上面两种情况的节点对都不存在，任意选一个节点$u\in {\tilde{V}}_1(s)$，再任意选一个节点$v\in {\tilde{V}}_2(s)$，所有这样的节点构成的节点对$(u,v)$组成$P(s)$。

​ 接下来从候选节点对集合$P(s)$中挑选一对节点作为当前的候选节点，VF2算法从中任意拿出一对(其实这里有很多工作可以做，详见VF3)，然后进入下一步判断其是否可行。当然，这样可能会出现在整个搜索过程中多次到达同一个状态$s$的情况，只是每次到达这个状态$s$时，对应的$\tilde{M}(s)$中的节点对进入的顺序不一样，为了在搜索过程中不重复到达同一个状态$s$，我们在最开始就给小图中的节点一个优先级，这个优先级在VF2中是任意的(这个在VF3中也有很多讲究)，比如$u_1\prec u_2\prec ...u_n$，如果当前状态下$\tilde{M}(s)$中已经有小图节点$u_k$的优先序高于一对节点对中的小图节点$u_j$的优先序，那么$u_j$有关的节点对不会被考虑作为候选节点，这就保证了整棵搜索树中的状态不会重复。

C 可行规则

​ 在匹配过程中，每一步选取的节点对$(u_n,v_n)$加入到状态$s$不一定合适，要么加入后新的状态$s^{\prime }$不是一致状态(consistent state)，要么加入后未来几步不可能达到一致状态，因此这一搜索分支就可以被砍掉，不再往下搜索，并且回溯到上一状态$s$并选取下一节点对。我们要用一系列的可行规则来判断当前选出的候选节点对是否可以加入状态$s$达到$s^{\prime }$。

​ 我们用可行函数$IsFeasible(s_c,u_n,v_n)$来判断在当前状态$s_c$下，加入节点对$(u_n,v_n)$是否可行。判断规则主要分为两类，一类是基于节点和边的标签（label)，记作$F_s$，另一类基于图的拓扑结构，记作$F_t$。两类规则都得满足，因此有：

$IsFeasible(s_c,u_n,v_n)=F_s(s_c,u_n,v_n)\wedge F_t(s_c,u_n,v_n)$

​ $F_s$的规则很简单，就是要保证新加入节点对后，对应节点和边的label要全部相同：

1. $\forall u\in V_1{\lambda }_{V_1}(u)={\lambda }_{V_2}(\mu (u))$
2. $\forall (u,u^{{}^{\prime }})\in E_1{\lambda }_{e_1}(u,u^{{}^{\prime }})={\lambda }_{e_2}(\mu (u),\mu (u^{{}^{\prime }}))$

​ 而$F_t$的规则就复杂一些，当然这也是本算法剪枝的精髓所在~这部分规则又可以分为三个小部分，第一：将新节点对加入状态$s$后，检查新的状态$s^{\prime }$还是一致状态,记作$F_c$；第二，考虑1-lookahead，判断未来一步是否可能构成一致状态$s^{\prime \prime }$记作$F_{la1}$；第三，考虑2-lookahead,判断未来两步是否可能构成一致状态$s^{\prime \prime \prime }$,记作$F_{la2}$。

$F_t(s_c,u_n,v_n)=F_c(s_c,u_n,v_n)\wedge F_{la1}(s_c,u_n,v_n)\wedge F_{la2}(s_c,u_n,v_n)$

下面逐个展开~

第一类规则$F_c$：

当$s_c$已经是一个一致状态，判断要新加入的候选节点对$(u_n,v_n)$是否可行，需要满足$s_c\cup (u_n,v_n)$依然是一致状态。

$$\begin{gathered} F_c(S_c,u_n,v_n)= \\ \forall u^{\prime }\in S_1(u_n)\cap {\tilde{M}}_1(s_c)\exists v^{\prime }=\tilde{\mu }(s_c,u^{\prime })\in S_2(v_n) \\ \wedge \forall u^{\prime }\in P_1(u_n)\cap {\tilde{M}}_1(s_c)\exists v^{\prime }=\tilde{\mu }(s_c,u^{\prime })\in P_2(v_n) \\ \wedge \forall v^{\prime }\in S_2(v_n)\cap {\tilde{M}}_2(s_c)\exists u^{\prime }={\tilde{\mu }}^{-1}(s_c,v^{\prime })\in S_1(u_n) \\ \wedge \forall v^{\prime }\in P_2(v_n)\cap {\tilde{M}}_2(s_c)\exists u^{\prime }={\tilde{\mu }}^{-1}(s_c,v^{\prime })\in P_1(u_n) \end{gathered}$$

人话解释一下：

​ $S_1(u_n)$是$u_n$节点的所有后继节点构成的集合；$P_1(u_n)$是$u_n$节点的所有前驱节点构成的集合；

​ $S_2(v_n)$是$v_n$节点的所有后继节点构成的集合；$P_2(v_n)$是$v_n$节点的所有前驱节点构成的集合。

​ 4条规则就说了一件事：新的节点$u_n$与已经匹配上的${\tilde{M}}_1(s_c)$中节点的关系 和 新的节点$v_n$与已经匹配上的${\tilde{M}}_2(s_c)$中节点的关系 要一模一样！不能左边有右边没有或右边有左边没有，也不能乱了顺序和边的方向。

​ 补充：有的问题需求是，小图中有的边大图中必须有，而大图中有的边小图可以没有，也就是小于等于的关系，那么就把后两条规则删除，也就是最右边的两个图的情况可以被容许。

第二类规则$F_{la1}$：

$$\begin{gathered} F_{la1}(s_c,u_n,v_n)= \\ |P_1(u_n)\cap {\tilde{P}}_1(s_c)|\le |P_2(v_n)\cap {\tilde{P}}_2(s_c)| \\ \wedge |P_1(u_n)\cap {\tilde{S}}_1(s_c)|\le |P_2(v_n)\cap {\tilde{S}}_2(s_c)| \\ \wedge |S_1(u_n)\cap {\tilde{P}}_1(s_c)|\le |S_2(v_n)\cap {\tilde{P}}_2(s_c)| \\ \wedge |S_1(u_n)\cap {\tilde{S}}_1(s_c)|\le |S_2(v_n)\cap {\tilde{S}}_2(s_c)| \end{gathered}$$

​ 这一类约束主要考虑与当前状态$s_c$中的节点直接相连的节点($P,S$集合)与新的节点对$(u_n,v_n)$间的关系。现在考虑的是3部分节点，1是已经在$M(s_c)$中的节点，即已经匹配了的；2是新的候选节点；3是$P,S$集合中的节点。3的节点中，与1和2的关系可以分成四类，分别对应上述4条规则，每一类关系的节点数量都要满足：小图节点数量不大于大图节点数量，若小图某一类的节点数大于大图了，说明未来不可能形成一致状态，因为未来必然会有小图中边，在大图中找不到。

第三类规则$F_{la2}$：

$$\begin{gathered} F_{la2}(s_c,u_n,v_n)= \\ |P_1(u_n)\cap {\tilde{V}}_1(s_c)|\le |P_2(v_n)\cap {\tilde{V}}_2(s_c)| \\ \wedge |S_1(u_n)\cap {\tilde{V}}_1(s_c)|\le |S_2(v_n)\cap {\tilde{V}}_2(s_c)| \end{gathered}$$

​ 这一类约束主要考虑与当前状态$s_c$中的节点不直接相连的节点($V$集合)与新的节点对$(u_n,v_n)$间的关系。现在考虑的是3部分节点，1是已经在$M(s_c)$中的节点，即已经匹配了的；2是新的候选节点；3是$V$集合中的节点。3的节点中，与1和2的关系可以分成2类，分别对应上述2条规则，每一类关系的节点数量都要满足：小图节点数量不大于大图节点数量，若小图某一类的节点数大于大图了，说明未来不可能形成一致状态，因为未来必然会有小图中边，在大图中找不到。

​ 上述三类规则其实是把新节点对$(u_n,v_n)$的度分成三部分，第一部分是与$M(s)$中节点的连接；第二部分是与$P(s)、V(s)$中节点的连接，即1-lookahead；第三部分是与$V(s)$中节点的连接，即2-lookahead。这三类连接又可以分为入度和出度，与其连接的节点又可以按分组分开，其中第一部分$M(s)$中已经匹配上的节点分组一定相同，因此可以不考虑分组。这样分类后，每一类度的数量都要满足，小图不大于大图，否则将不可能同构，其中第一类比较特殊，必须完全相同才能同构，当然也有只需要小于等于的需求，这类需求严格意义上已经不是子图同构了。

3 总结

​ VF算法的搜索树其实跟Ullmann算法是一样的，只不过Ullmann用矩阵表示每一个状态$s$，VF2算法最核心的就是可行规则，提前筛除了很多不必要的分支，而后面的VF3算法在VF2的基础上加入了候选节点选择时的顺序，可以在更早的时候剪掉更多大分支，并且在可行规则中给节点分了类，进一步加大剪枝力度~