Weisfeiler Leman graph isomorphism test

In graph theory, the Weisfeiler Leman graph isomorphism test is a heuristic test for the existence of an isomorphism between two graphs G and H. It is a generalization of the color refinement algorithm and has been first described by Weisfeiler and Leman in 1968. The original formulation is based on graph canonization, a normal form for graphs, while there is also a combinatorial interpretation in the spirit of color refinement and a connection to logic.

There are several versions of the test (e.g. k-WL and k-FWL) referred to in the literature by various names, which easily leads to confusion. Additionally, Andrey Leman is spelled `Lehman' in several older articles.

Weisfeiler-Leman-based Graph Isomorphism heuristics

All variants of color refinement are one-sided heuristics that take as input two graphs Gand H and output a certificate that they are not different or 'I don't know'. This means that if the heuristic is able to tell G and H apart, then they are definitely different, but the other direction does not hold: for every variant of the WL-test (see below) there are non-isomorphic graphs where the difference is not detected. Those graphs are highly symmetric graphs such as regular graphs for 1-WL/color refinement.

1-dimensional Weisfeiler-Leman (1-WL)

The 1-dimensional graph isomorphism test is essentially the same as the color refinement algorithm (the difference has to do with non-edges and is irrelevant for all practical purposes as it is trivial to see that graphs with a different number of nodes are non-isomorphic). The algorithm proceeds as follows:

Initialization All nodes are initialized with the same color 0

Refinement Two nodes u,v get a different color if a) they had a different color before or b) there is a color c such that u and v have a different number of c-colored neighbors

Termination The algorithm ends if the partition induced by two successive refinement steps is the same.

In order to use this algorithm as a graph isomorphism test, one runs the algorithm on two input graphs G and H in parallel, i.e. using the colors when splitting such that some color c (after one iteration) might mean `a node with exactly 5 neighbors of color 0'. In practice this is achieved by running color refinement on the disjoint union graph of G and H. One can then look at the histogram of colors of both graphs (counting the number of nodes after color refinement stabilized) and if they differ, this is a certificate that both graphs are not isomorphic.

The algorithm terminates after at most $n-1$ rounds where $n$ is the number of nodes of the input graph as it has to split one partition in every refinement step and this can happen at most until every node has its own color. Note that there are graphs for which one needs this number of iterations, although in practice the number of rounds until terminating tends to be very low (<10).

The refinement of the partition in each step is by processing for each node its label and the labels of its nearest neighbors. Therefore WLtest can be viewed as a message passing algorithm which also connects it to graph neural networks.

Higher-order Weisfeiler-Leman

This is the place where the aforementioned two variants of the WL algorithm appear. Both the k-dimensional Weisfeiler-Leman (k-WL) and the k-dimensional folklore Weisfeiler-Leman algorithm (k-FWL) are extensions of 1-WL from above operating on k-tuples instead of individual nodes. While their difference looks innocent on the first glance, it can be shown that k-WL and (k-1)-FWL (for k>2) distinguish the same pairs of graphs.

k-WL

Input: a graph G = (V,E)
# initialize
$c^{0}({\bar {v}})=$ HASH(type$({\bar {v}})$) for all ${\bar {v}}\in V^{k}$
repeat
   $c_{i}^{\ell }({\bar {v}})=\{\!\{c^{\ell -1}({\bar {w}}):{\bar {w}}\in {\mathcal {N}}_{i}({\bar {v}})\}\!\}$ for all ${\bar {v}}\in V^{k},i\in [k]$
   $c^{\ell }({\bar {v}})={\text{Hash}}(c^{\ell -1}({\bar {v}}),c_{1}^{\ell }({\bar {v}}),\dots ,c_{k}^{\ell }({\bar {v}})$
until $c^{\ell }\equiv c^{\ell -1}$ (both colorings induce identical partitions of $V^{k}$)
return $c^{\ell }$

Here the neighborhood ${\mathcal {N}}_{i}({\bar {v}})$ of a k-tuple ${\bar {v}}$ is given by the set of all k-tuples reachable by exchanging the i-th position of ${\bar {v}}$: ${\mathcal {N}}_{i}({\bar {v}})=\{(v_{1},\dots ,v_{i-1},w,v_{i+1},\dots ,v_{k}):w\in V\}$

k-FWL (k>1)

Input: a graph G = (V,E)
# initialize
$c^{0}({\bar {v}})=$ HASH(type$({\bar {v}})$) for all ${\bar {v}}\in V^{k}$
repeat
  $c_{w}^{\ell }({\bar {v}})=(c^{\ell -1}({\bar {v}}[1]\leftarrow w,\dots ,c^{\ell -1}({\bar {v}}[k]\leftarrow w)$ for all ${\bar {v}}\in V^{k},w\in V$
  $c^{\ell }({\bar {v}})={\text{Hash}}(c^{\ell -1}({\bar {v}}),\{\!\{c_{w}^{\ell }({\bar {v}}):w\in V\}\!\}$
until $c^{\ell }\equiv c^{\ell -1}$ (both colorings induce identical partitions of $V^{k}$)
return $c^{\ell }$

Note that there is one major difference here: FWL checks what happens if a single node w is placed at any position of the k-tuple (and then computes the multiset of these k-tuples) while k-WL looks at the multisets that you get when changing the i-th component only of the original k-tuple. It then uses all those multisets in the hash that computes the new color.

It can be shown (although only through the connection to logic) that k-FWL and (k+1)-WL are equivalent (for $k\geq 2$). Since both algorithms scale exponentially in k (both iterate over all k-tuples), the use of k-FWL is much more efficient than using the equivalent (k+1)-WL.

Examples and Code for 1-WL

Code

# ALGORITHM WLpairs
# INPUT: two graphs G and H to be tested for isomorphism
# OUTPUT: Certificates for G and H and whether they agree
U = combineTwo(G, H)
glabels = initializeLabels(U)  # dictionary where every node gets the same label 0
labels = {}  # dictionary that will provide translation from a string of labels of a node and its neighbors to an integer
newLabel = 1
done = False
while not(done):
    glabelsNew = {}  # set up the dictionary of labels for the next step
    for node in U:
        label = str(glabels[node]) + str([glabels[x] for x in neighbors of node].sort())
        if not(label in labels):  # a combination of labels from the node and its neighbors is encountered for the first time
            labels[label] = newLabel  # assign the string of labels to a new number as an abbreviated label
            newLabel += 1  # increase the counter for assigning new abbreviated labels
        glabelsNew[node] = labels[label]
    if (number of different labels in glabels) == (number of different labels in glabelsNew):
        done = True
    else:
        glabels = glabelsNew.copy()
certificateG = certificate for G from the sorted labels of the G-part of U
certificateH = certificate for H from the sorted labels of the H-part of U
if certificateG == certificateH:
    test = True
else:
    test = False

Here is some actual Python code which includes the description of the first examples.

g5_00 = {0: {1, 2, 4}, 1: {0, 2}, 2: {0, 1, 3}, 3: {2, 4}, 4: {0, 3}}
g5_01 = {0: {3, 4}, 1: {2, 3, 4}, 2: {1, 3}, 3: {0, 1, 2}, 4: {0, 1}}
g5_02 = {0: {1, 2, 4}, 1: {0, 3}, 2: {0, 3}, 3: {1, 2, 4}, 4: {0, 3}}


def combineTwo(g1, g2):
    g = {}
    n = len(g1)
    for node in g1:
        s = set()
        for neighbor in g1[node]:
            s.add(neighbor)
        g[node] = s.copy()
    for node in g2:
        s = set()
        for neighbor in g2[node]:
            s.add(neighbor + n)
        g[node + n] = s.copy()
    return g


g = combineTwo(g5_00, g5_02)
labels = {}
glabels = {}
for i in range(len(g)):
    glabels[i] = 0
glabelsCount = 1
newlabel = 1

done = False
while not (done):
    glabelsNew = {}
    glabelsCountNew = 0
    for node in g:
        label = str(glabels[node])
        s2 = []
        for neighbor in g[node]:
            s2.append(glabels[neighbor])
        s2.sort()
        for i in range(len(s2)):
            label += "_" + str(s2[i])
        if not (label in labels):
            labels[label] = newlabel
            newlabel += 1
            glabelsCountNew += 1
        glabelsNew[node] = labels[label]
    if glabelsCount == glabelsCountNew:
        done = True
    else:
        glabelsCount = glabelsCountNew
        glabels = glabelsNew.copy()
print(glabels)

g0labels = []
for i in range(len(g0)):
    g0labels.append(glabels[i])
g0labels.sort()
certificate0 = ""
for i in range(len(g0)):
    certificate0 += str(g0labels[i]) + "_"
g1labels = []
for i in range(len(g1)):
    g1labels.append(glabels[i + len(g0)])
g1labels.sort()
certificate1 = ""
for i in range(len(g1)):
    certificate1 += str(g1labels[i]) + "_"

if certificate0 == certificate1:
    test = True
else:
    test = False
print("Certificate 0:", certificate0)
print("Certificate 1:", certificate1)
print("Test yields:", test)

Examples

The first three examples are for graphs of order 5.

Graph G0	Graph G1	Graph G2

WLpair takes 3 rounds on 'G0' and 'G1'. The test succeeds as the certificates agree.

WLpair takes 4 rounds on 'G0' and 'G2'. The test fails as the certificates disagree. Indeed 'G0' has a cycle of length 5, while 'G2' doesn't, thus 'G0' and 'G2' cannot be isomorphic.

WLpair takes 4 rounds on 'G1' and 'G2'. The test fails as the certificates disagree. From the previous two instances we already know $G_{1}\cong G_{0}\not \cong G_{2}$.

G0 vs. G1	G0 vs. G2	G1 vs. G2

Indeed G0 and G1 are isomorphic. Any isomorphism must respect the components and therefore the labels. This can be used for kernelization of the graph isomorphism problem. Note that not every map of vertices that respects the labels gives an isomorphism. Let $\varphi :G_{0}\rightarrow G_{1}$ and $\psi :G_{0}\rightarrow G_{1}$ be maps given by $\varphi (a)=D,\varphi (b)=C,\varphi (c)=B,\varphi (d)=E,\varphi (e)=A$ resp. $\psi (a)=B,\psi (b)=C,\psi (c)=D,\psi (d)=E,\psi (e)=A$. While $\varphi$ is not an isomorphism $\psi$ constitutes an isomorphism.

When applying WLpair to G0 and G2 we get for G0 the certificate 7_7_8_9_9. But the isomorphic G1 gets the certificate 7_7_8_8_9 when applying WLpair to G1 and G2. This illustrates the phenomenon about labels depending on the execution order of the WLtest on the nodes. Either one finds another relabeling method that keeps uniqueness of labels, which becomes rather technical, or one skips the relabeling altogether and keeps the label strings, which blows up the length of the certificate significantly, or one applies WLtest to the union of the two tested graphs, as we did in the variant WLpair. Note that although G1 and G2 can get distinct certificates when WLtest is executed on them separately, they do get the same certificate by WLpair.

The next example is about regular graphs. WLtest cannot distinguish regular graphs of equal order, but WLpair can distinguish regular graphs of distinct degree even if they have the same order. In fact WLtest terminates after a single round as seen in these examples of order 8, which are all 3-regular except the last one which is 5-regular.

All four graphs are pairwise non-isomorphic. G8_00 has two connected components, while the others do not. G8_03 is 5-regular, while the others are 3-regular. G8_01 has no 3-cycle while G8_02 does have 3-cycles.

WLtest applied to four regular graphs of order 8.	WLpair applied to G8_00 and G8_01 of same degree.	WLpair applied to G8_02 and G8_03 of distinct degree.

Another example example of two non-isomorphic graphs that WLpair cannot distinguish is given here.

Applications

The theory behind the Weisfeiler Leman test is applied in graph neural networks.

Weisfeiler Leman graph kernels

In machine learning of nonlinear data one uses kernels to represent the data in a high dimensional feature space after which linear techniques such as support vector machines can be applied. Data represented as graphs often behave nonlinear. Graph kernels are method to preprocess such graph based nonlinear data to simplify subsequent learning methods. Such graph kernels can be constructed by partially executing a Weisfeiler Leman test and processing the partition that has been constructed up to that point. These Weisfeiler Leman graph kernels have attracted considerable research in the decade after their publication. They are also implemented in dedicated libraries for graph kernels such as GraKeL.

Note that kernels for artificial neural network in the context of machine learning such as graph kernels are not to be confused with kernels applied in heuristic algorithms to reduce the computational cost for solving problems of high complexity such as instances of NP-hard problems in the field of complexity theory. As stated above the Weisfeiler Leman test can also be applied in the later context.

See also

• Graph isomorphism
• Graph neural network