Quantum walk inspired algorithm for graph similarity and isomorphism

TL;DR

This paper introduces a quantum walk inspired algorithm that efficiently measures graph similarity and distinguishes structural differences in large, unlabeled graphs with polynomial complexity, addressing scalability issues in network analysis.

Contribution

The paper presents a novel quantum walk inspired algorithm for graph similarity that operates without prior graph labeling and has polynomial complexity.

Findings

Capable of distinguishing minor structural differences in graphs

Operates efficiently on large graphs with polynomial complexity

Provides a scalable solution for graph comparison without prior labeling

Abstract

Large scale complex systems, such as social networks, electrical power grid, database structure, consumption pattern or brain connectivity, are often modeled using network graphs. Valuable insight can be gained by measuring the similarity between network graphs in order to make quantitative comparisons. Since these networks can be very large, scalability and efficiency of the algorithm are key concerns. More importantly, for graphs with unknown labeling, this graph similarity problem requires exponential time to solve using existing algorithms. In this paper, we propose a quantum walk inspired algorithm, which provides a solution to the graph similarity problem without prior knowledge on graph labeling. This algorithm is capable of distinguishing between minor structural differences, such as between strongly regular graphs with the same parameters. The algorithm has polynomial complexity, scaling with $O(n^9)$.

Figures

Tables

Table 1. Table 1: Similarity scores for comparisons between different SRGs using two reference nodes. The parameters of the SRGs are as follows: 6a: S ​ R ​ G 𝑆 𝑅 𝐺 SRG (6,3,0,3), 6b: S ​ R ​ G 𝑆 𝑅 𝐺 SRG (6,4,2,4), 16a and 16b: S ​ R ​ G 𝑆 𝑅 𝐺 SRG (16,6,2,2), 45a and 45b: S ​ R ​ G 𝑆 𝑅 𝐺 SRG (45,12,3,3), 64a and 64b: S ​ R ​ G 𝑆 𝑅 𝐺 SRG (64,18,2,6).

Graphs	$ϵ$ Threshold	Euclidean	Euclidean Square	Matusita
6a vs 6b	0.3255	0.3409	0.3522	0.3575
16a vs 16b	0.4828	0.8398	0.9604	0.8191
29a vs 29b	0.9939	0.9997	0.99995	0.9999
36a vs 36b	0.9357	0.9994	0.9987	0.9994
45a vs 45b	0.9722	0.9962	0.9965	0.9945
64a vs 64b	0.8800	0.9996	0.9986	0.9996

Equations

$$d(G_1,G_2)=1-\frac{\text{n}[\text{mcs}(G_1,G_2)]}{\text{max}(\text{n}[G_1],\text{n}[G_2])},$$

$$d(G_1,G_2)=1-\frac{4}{6}=\mathrm{0.33.}$$

$$J(P)$$

$$S$$

$$ϵ$$

$$d$$

$$sim(G_1,G_2)$$

$$A_{ij}$$

$$d_i=\sum _{j=1}^n{A}_{ji}.$$

$${\hat{C}}_{ij}$$

$$\hat{T}|x,d_{x,i}⟩⟼|y,d_{y,j}⟩,$$

$$|\psi ⟩$$

$$\hat{T}|x,e_{xy}⟩=|y,e_{yx}⟩.$$

$$|{\psi }_t⟩$$

$$P_t(x)$$

$$|{\psi }_0⟩$$

$$|i,c⟩$$

$$|j,c⟩$$

$$|k,c⟩$$

$$|l,c⟩$$

$$D_{ijkl}$$

$$D_{ijkl}=\frac{\Vert pro{b}_i-pro{b}_k\Vert +\Vert pro{b}_j-pro{b}_l\Vert }{nSteps}.$$

$$D_{ijkl}={\left(\frac{\Vert pro{b}_i-pro{b}_k\Vert }{nSteps}\right)}^2+{\left(\frac{\Vert pro{b}_j-pro{b}_l\Vert }{nSteps}\right)}^2.$$

$$D_{ijkl}=\frac{\sqrt{{\sum }_{m=1}^n{\left(\sqrt{pro{b}_i(m)}-\sqrt{pro{b}_k(m)}\right)}^2}+\sqrt{{\sum }_{m=1}^n{\left(\sqrt{pro{b}_j(m)}-\sqrt{pro{b}_l(m)}\right)}^2}}{nSteps}.$$

$$\mathcal{D}$$

$$sim(A,B)$$

Full text

I Introduction

Many man-made and natural phenomena are modelled using graphs (networks), which show the interconnections between different elements of the systems. These networks have become crucial components in systems which are used in every day life, e.g., Google’s web page ranking system or social media networks Ek et al. (2015). In many applications, it is essential to provide some degree of similarity between two graphs. A number of different applications of graph comparisons have arisen in a wide variety of scientific disciplines. Some examples include classification of objects for the purposes of machine learning Horváth et al. (2004), analysis of protein-protein interaction networks Luo et al. (2010), modelling differences in brain connectivity Mheich et al. (2017) and comparing large scale databases Zheng et al. (2015). Additionally, these networks may need to be continuously compared for similarities. Examples include identification of faces in images or ensuring computer networks remain secure Showbridge et al. (1999).

Algorithms for making inexact comparisons between graphs with known labelling typically have linear or polynomial complexity, such as the DeltaCon algorithm which has, at worst, complexity $O(n^{2})$ Koutra et al. (2013). However, in many applications we do not have the luxury of knowing how to match the nodes (i.e. nodes are not labelled in correspondance). This significantly increases the complexity of comparison algorithms. The unlabelled graph matching problem takes exponential time to compute; additionally the unlabelled sub-graph matching problem is NP-Complete Bunke (2000); Emmert-Streib et al. (2016). Due to this, the proposed solutions to the unlabelled graph similarity problem scale exponentially. These methods include the techniques developed to find the maximum common subgraph, such as detecting the maximum clique which has complexity $O((nm)^{n})$ Levi (1973); Bunke and Shearer (1998) and a decision tree based algorithm with $O(2^{n}n^{3})$ Bunke (2000).

This exponential complexity of algorithms for graphs with unknown labelling significantly restricts the size of graphs that can be compared. An improved efficient algorithm must be adopted in order to reliably make comparisons on graphs in today’s large data applications. In this paper we propose a technique, developed to utilise coined quantum walks, to make comparisons between undirected graphs. The algorithm is inspired by the work done by Douglas and Wang Douglas and Wang (2008); Douglas which determines whether two input graphs are isomorphic using coined quantum walks. Graph isomorphism can be considered as a binary example of graph similarity, where comparisons output a “1” if two graphs are isomorphic, and a “0” otherwise. In this paper we extend the graph isomorphism algorithm Douglas and Wang (2008); Douglas to provide a degree of similarity between graphs. Note that classical graph isomorphic based algorithms have been developed (such as comparing maximum common sub-graphs), however they scale exponentiallyEmmert-Streib et al. (2016).

The paper is organized as follows. In §II, we introduce graph comparison problems and discuss the properties required for a graph similarity measure. The proposed coin quantum walk algorithm for graph similarity measure computation is described in §III. In §IV, we present computational results on a variety of graphs to illustrate the proposed method. Concluding remarks are in §V.

II Graph Comprisons and Axioms of Similarity Measures

II.1 Graph Comparison

Graph similarity measures are based on comparisons made between the structure of graphs. Comparison metrics are used to define the distance between graphs or a graph similarity index. Let $G_{1}(V,E_{1})$, $G_{2}(V,E_{2})$ be two graphs defined by a set of vertices $V$ and edge sets $E_{i},i=1,2$. Define sim($G_{1}$,$G_{2}$) $\in[0,1]$ as the similarity between these graphs.

Although the concept of similarity between two graphs may be intuitive, differing similarity measures tend to produce different results due to differences in how the structures of the graphs are analyzed. In some applications, a binary answer to whether graphs match or not is insufficient, especially if the input graphs are incomplete or contain noise. For graphs which only match approximately, it is useful to be able to determine a measure of similarity. For example, classification techniques in machine learning match objects that are within a certain tolerance level. It is desired that a similarity algorithm returns a score which indicates a degree of how the structures of two networks differ, while also being able to detect slight changes between them.

II.2 Classical Graph Comparison Techniques

We first review a few existing classical graph comparison techniques.

II.2.1 Maximum Common Subgraph

Maximum common subgraph techniques involve finding the largest subgraph structure that is common (isomorphic) between the two graphs. If two graphs are isomorphic, their nodes can be relabelled in such a way that they are equivalent ($G_{1}\cong G_{2}$). Similarity metrics that utilise this technique define graphs with larger common subgraphs as being more similar. One such distance metric is defined by Bunke Bunke and Shearer (1998):

[TABLE]

where n[$G$] denotes the number of nodes in graph $G$, and mcs($G_{1},G_{2}$) is the maximum common subgraph of $G_{1}$ and $G_{2}$. Note that as this metric defines the distance between graphs a smaller value would denote a higher similarity.

Figure 1 gives an example maximum common subgraph of two graphs. In this example, the distance would be

[TABLE]

II.2.2 Graph Edit Distance

The graph edit distance between two graphs is defined as the number of changes that would be required to make two graphs the same. These changes include relabelling vertices and adding or removing vertices and edges Bunke (2000). Additionally, each action can be attributed a weighting to provide variation to the resulting similarity measure. For example, a minimum of four changes would be required to make graph (a) in Figure 1 equivalent to graph (b).

II.2.3 Graph Eigensystems

The eigensystems of graphs can also be utilised to define the distance between two graphs. For example, consider two undirected graphs $G_{1}$ and $G_{2}$ with adjacency matrices $A$ and $B$ respectively. Umemyama Umeyama (1988) defines the shortest distance between $G_{1}$ and $G_{2}$ by minimising:

[TABLE]

where $P$ is a permutation matrix which represents a map which relates the nodes in $G_{1}$ to those in $G_{2}$. This permutation is optimal for the shortest distance, which is found by using the eigen decompositions of $A$ and $B$.

II.2.4 DeltaCon

DeltaCon is a graph similarity algorithm developed by Koutra, Vogelstein and Faloutsos Koutra et al. (2013). The algorithm makes comparisons on the pairwise node affinities of graphs. Due to these pairwise comparisons, the graph must have known labelling. A matrix $S$ is constructed, using Equation (4), such that $S_{ij}$ indicates the influence of node $i$ on node $j$:

[TABLE]

where $I$ is the identity matrix, $D$ is the diagonal degree matrix ($d_{ii}$ is the degree of node $i$) and $A$ is the adjacency matrix. The distance and similarity between two graphs is then defined by

[TABLE]

where $d$ is the Matusita distance between the node affinities. This distance is used in order to boost the graph node affinities, which increases the sensitivity of the metric. The resulting similarity score is in the interval $[0,1]$.

II.3 Axioms

The given distance between a pair of graphs relies on the similarity method used. It is not necessarily the case that two metrics will return the same similarity score. The requirements of the similarity metric would also differ between applications. However, Koutra et al. have formalised a set of axioms that graph similarity measures should conform to Koutra et al. (2013):

• A1

Identity: sim($G_{1}$,$G_{2}$) = 1 $\Leftrightarrow G_{1}\cong G_{2}$.

• A2

Symmetric: sim($G_{1}$,$G_{2}$) = sim($G_{2}$,$G_{1}$).

• A3

Zero: For a complete graph $G_{1}$ and empty graph $G_{2}$, sim($G_{1}$,$G_{2}$) $\rightarrow 0$ as $n\rightarrow\infty$.

Another important requirement raised by Koutra et al. is that the algorithm used must be scalable Koutra et al. (2013). Many applications require lots of comparisons to be made on large graphs, thus the similarity algorithm must be able to compute comparisons efficiently on large sets.

II.4 Graph Representations

A graph, denoted by $G(V,E)$, consists of a set of vertices (or nodes) $V$, representing position states, and a set of edges $E$, denoting connections between vertices. A graph can be described via a $n\times n$ adjacency matrix $A$:

[TABLE]

Note that for undirected graphs, the adjacency matrix is symmetric ($A_{ij}=A_{ji}$). More generally, a real valued weight $A_{ij}$ can be assigned to the edge $\{i,j\}\in E$. The degree $d_{i}$ of the node $i$, in an undirected graph is,

[TABLE]

Since the unlabelled graph matching problem is NP-Complete Bunke (2000); Emmert-Streib et al. (2016), existing solutions to measure graph similarity would take exponential time to compute. Next we propose a coined quantum walk solution.

III Coined Quantum Walk Graph Similarity

III.1 Coined Quantum Walk

Classical random walks, which are stochastic processes, can describe the path of a random walker on a graph. The quantum analogue, quantum walks, describe the time evolution of the probability state of a walker on a graph. Both discrete and continuous time formulations of walks exist, however we will restrict the discussion to the former.

At each time step, a classical walker flips a “coin” to determine which direction to move in next. Similarly, every step in a quantum walk involves applying a coin operator $\hat{C}$, then translating the system according to the coin state via the translation operator $\hat{T}$ Manouchehri and Wang (2013).

Consider an arbitrary graph described by the adjacency matrix $A$. The coined quantum walk formalism is restricted to undirected graphs. For a graph with $n$ nodes, there are $n$ position states labelled $\left|v_{x}\right\rangle\equiv\left|x\right\rangle$. The degree of each position state $\left|x\right\rangle$ gives the number of coin states $\left|c\right\rangle$. This is equivalent to a walker having $d_{x}$ paths to choose at position $\left|x\right\rangle$. Each node has a local coin operator $\hat{C_{x}}$, represented by a $d_{x}\times d_{x}$ matrix.

As the algorithm must work for graphs with unknown labelling, the coin operator used must not have a bias with respect to the neighboring nodes. This means that the coin operator must be constructed such that it will produce the same result for all combinations of labelled nodes. This constrains each coin to be in the form Douglas and Wang (2008):

[TABLE]

where $a,b\in\mathbb{C}$. One such unitary operator which keeps the symmetry with respect to its neighboring nodes is the Grover coin:

[TABLE]

where $d$ is the degree of the corresponding node and $\delta_{ij}$ is the Kronecker delta function.

Considering an edge $e_{xy}$ connecting nodes $x$ and $y$, one formalism of the 1-D quantum walk to a 2-D graph defines the translation operator as the unique mapping from one state to another along an edge:

[TABLE]

where $d_{x,i}$ is the $i$th neighbour of $x$. To achieve this, Watrous proposed to label the coin states of each node via the edges connected to it Watrous (2001). This allows the system to be represented by the set of nodes $x$ and edges connecting pairs of nodes $e_{xy}$. The state of the system is then represented in general as

[TABLE]

where $\alpha_{xy}$ denotes the probability amplitude of the walker at node $x$ transitioning to $y$, which satisfies the normalization condition such that $\sum_{x,y}|\alpha_{xy}|^{2}=1$. The translation operator is then defined by shifting the walker along an edge:

[TABLE]

The quantum walk is then carried out via repeated application of the coin and then translation operator, such that after $t$ time steps the state of the system is given by:

[TABLE]

After observation, the probability the walker is at node $x$ is given by:

[TABLE]

Not knowing the node labelling also requires us to ensure that there is no bias between nodes. To do this, the initial state is constructed in equal superposition, as in equation (17). For simplicity, the coin states $\left|e_{xy}\right\rangle$ are denoted as $\left|e_{xj}\right\rangle$, where $j=1,\ldots,d_{x}$, and $\left|e_{xj}\right\rangle$ is the $j$th outgoing edge of vertex $x$. Thus

[TABLE]

III.2 Graph Comparison Score

The graph isomorphism algorithm developed by Douglas and Wang Douglas and Wang (2008) generates graph comparison scores, an integer value that can be used to make comparisons between graphs. These comparison scores are calculated by comparing the time evolution of quantum walks on the graphs. In some cases, such as strongly regular graphs with the same parameters, a simple quantum walk is not sufficient to distinguish between their structure. To alleviate this, a phase is added to a number of reference nodes in each graph, which produces a new level of interaction in the walk Douglas and Wang (2008). This interaction helps break symmetries in the graph.

We adopt a two-node phase addition scheme, chosen as it is the fewest number of reference nodes required to distinguish SRGs Douglas and Wang (2008). Consider two input graphs, $A$ and $B$. Let $i,j\in A$ and $k,l\in B$ be the chosen reference nodes, as in Figure 2. Denote two phases $\phi,\theta$. At each step of the walk these phases are applied to the reference nodes:

[TABLE]

[TABLE]

The phase values chosen must be in the range $(0,2\pi)$, with $\phi\neq\theta$. The phase values should also be sufficiently different to ensure that each reference node is distinguishable. The similarity measure result is also not entirely independent of the chosen phase values. However, for sensible values of phase the influence is minimal, generally resulting in a range of at worst $\pm 0.05$ in similarity score. Additionally, this is not an issue if the particular application only requires to know the relative similarity between sets of graphs, assuming the phase is kept consistent.

A graph comparison 4-D matrix is constructed by making comparisons between the probability amplitudes of each pair of reference nodes at every step of the walk. To ensure that the complete structure of the graph is explored by the walker, it must complete at least twice as many steps as the diameter of the graph, which is the maximum shortest path between all pairs of nodes in the graph. The graph comparison score is then defined as the sum of the elements in $D$, where

[TABLE]

and $d_{xy}$ is the distance between the probability amplitude sets of reference nodes $x\in A$ and $y\in B$. For testing purposes a number of different distance measures have been tried (see §III.3 for details).

As the labelling of each graph is not known, the probability amplitudes need to be compared for all unique combinations of $\{i,j,k,l\}$. If the two nodes match up, or are similar, they are given a low score. The full comparison matrix has $n^{4}$ elements, however this can be reduced due to the symmetry in the adjacency matrices. As we are applying the same phase to each pair of reference nodes, and the difference in the response is independent of the phase applied, testing combinations of $\{j,i\}$ will give the same results as $\{i,j\}$. Thus, the number of comparisons necessary can be reduced to $\dfrac{n^{3}(n-1)}{2}$.

III.3 Distance Metric

We compare the probability amplitudes at the reference nodes using a variety of distance measures. In the following, we denote the set of probability amplitudes of reference node $i$ as $prob_{i}$ with input graphs $G_{1}$ and $G_{2}$, where $\{i,j\}\in G_{1}$ and $\{k,l\}\in G_{2}$. The first measure is used by Douglas and Wang in their graph isomorphism algorithm Douglas and Wang (2008).

Euclidean distance with $\epsilon$ threshold:

[TABLE]

The thresholding method is useful in the graph isomorphism case, where we require a sensitive metric to determine whether two graphs are isomorphic. However, graph similarity is not a binary problem and we lose significant information regarding the differences between the two graphs when thresholding the results. Thus, removing thresholding from the graph isomorphism algorithm would likely improve the graph similarity performance (while possibly reducing its effectiveness at determining graph isomorphism for extreme cases such as SRGs). In addition to the Euclidean distance, two other metrics have been tried in an attempt to increase the sensitivity of the algorithm. The Euclidean distance squared metric boosts the distance between each pair of probability vectors by squaring the Euclidean distance between them. The Matusita distance metric boosts the probability vectors before the comparison is made. The precise definitions for these three metrics are given below.

Euclidean distance:

[TABLE] 2. 3.

Euclidean distance squared:

[TABLE] 3. 4.

Matusita distance:

[TABLE]

As the sum of the probabilities at each time step must equal one, the Euclidean difference between the probability amplitude of two nodes would be in the range $[0,1]$. A value of [math] would denote the probability of finding the walker at both reference nodes as being the same at all time steps. Thus, the distance between the two sets of probability vectors corresponding to a pair of reference nodes would be in the range $[0,nSteps]$. As we do not want the similarity metric to be dependent on the number of steps the walker takes, the distance is normalised with respect to $nSteps$. Since $D_{ijkl}$ is given by the sum of the distance between two pairs of reference nodes, it is in the range $[0,2]$.

III.4 Similarity Metric

Consider the comparison between two input graphs, $A$ and $B$, with a graph comparison score $D_{AB}$. This score will be finite and non-zero, regardless of the input graphs. In order to be consistent with the identity axiom (II.3), we need to compare $D_{AB}$ with the resulting comparison score assuming $A$ was isomorphic to $B$. This is determined by calculating the comparison score between $A$ and an isomorphic permutation of $A$ (denote this $A^{\prime}$, and the resulting comparison score $D_{AA^{\prime}}$). Similarly the comparison score $D_{BB^{\prime}}$ is calculated. If $D_{AB}$ is equivalent to both $D_{AA^{\prime}}$ and $D_{BB^{\prime}}$, the input graphs are said to be isomorphic Douglas and Wang (2008).

The distance between the input graphs ($A$ and $B$) is then defined to be the normalised difference between $D_{AB}$ and the corresponding isomorphic comparison scores, i.e.:

[TABLE]

while the similarity metric is given by:

[TABLE]

We summarize the proposed coin quantum walk graph similarity measure computation in Algorithm 1.

III.5 Algorithm Complexity

Consider an undirected graph with $n$ nodes and $k$ edges, where $k\leq n^{2}/2$ (allowing for self loops). Let $d_{i}$ denote the degree of node $i$. In the worst case, a complete graph, $d_{i}=n~{}\forall~{}i$. Each step of the walk involves a coin flip and translation operation. The coin operator, $\hat{C_{i}}$, is applied locally to each node. Each local coin is of size $(d_{i}\times d_{i})$ and is applied to the coin states of node $i$, which is a vector of length $d_{i}$. Note that there are $2k$ coin states, with $\sum_{i}d_{i}=2k$ (in the worst case, $2k=n^{2}$). The application of the local coin operator then scales with $O({d_{i}}^{3})\leq O(n^{3})$. As this operator is applied $n$ times, the total coin flip scales with $O(\sum_{i}^{n}{d_{i}}^{3})\leq O(n^{4})=O(k^{2})$.

The translation operator, $\hat{T}$, is applied by shifting states along edges using a temporary register, thus it only scales with $O(n^{2})$. Therefore, each step of the quantum walk is $O(n^{4}+n^{2})=O(n^{4})$. During each step, there is an additional calculation to map the probability amplitudes of each state to the probability of the walker being at each node in the graph. This however only scales with $O(n)$, which is dwarfed by the scaling for the quantum walk operations.

As the walker needs to complete at least as many steps as twice the diameter of the graph, the walker must make at most $2n$ steps. Thus the walk would scale $O(2\mathcal{D}n^{4})\leq O(n^{5})$, where $\mathcal{D}$ is the diameter of the graph. Since the diameter of a graph is given by the maximum shortest path between all pairs of nodes, this tends to have a large variation between different graph structures. For each combination of nodes $\{i,j,k,l\}$ tested, two walks are conducted and the distance between the probability vectors for the two pairs of nodes is calculated. This scales at worst with $O(2n^{5}+2n)=O(n^{5})$. To calculate each graph comparison score $\dfrac{n^{3}(n-1)}{2}$ combinations of reference nodes must be tested, thus the algorithm which calculates three comparison scores scales with $O\left(\dfrac{3n^{8}(n-1)}{2}\right)=O(n^{9})$. Thus, assuming that each operation has $O(1)$ complexity, this algorithm has polynomial time complexity.

IV Results

IV.1 Sample Random Graphs

A variety of different random graph models have been utilised to test the algorithm against the graph similarity axioms and properties. Additionally, this will determine whether the algorithm has a bias towards certain graph structures. All random graphs used for testing have been generated using Mathematica. Graphs referred to as “Random graphs” are generated using a uniform distribution (the probability density function of vertex degree is uniform). These graphs will be denoted as $R(n,e)$, where $n$ is the number of nodes and $e$ is the number of edges in the graph. Other sets of graphs used to test the graph similarity algorithms are detailed below.

IV.1.1 Erdős-Rènyi Graphs

Random graph theory was pioneered by P. Erdős and A. Rènyi in 1959. Erdős-Rènyi graphs are constructed by choosing whether or not to add an edge connecting every pair of nodes using probability $p$ Erdős  and Rènyi (1959, 1960). The choice for each edge is independent to all other connections. Erdős-Rènyi random graphs will be denoted using $ER(n,p)$ where $n$ is the number of nodes and $p$ is the probability that any two nodes are connected. These graphs have been used in practice to describe and analyse complex topological networks, such as modelling epidemics as a dynamical computational networks Ganesh et al. (2005).

IV.1.2 Scale-Free Graphs

Albert et al. first discovered the scale-free nature of networks which model the topology of the world-wide web (WWW) in 1999. These networks follow a power law degree distribution where the probability $P(k)$ of a node connecting with $k$ other nodes scales with $P(k)\sim k^{-\gamma}$ for some constant $\gamma$ Barabási and Albert (1999); Réka Albert and Barabási (1999). Such networks maintain this power law distribution regardless of the number of nodes. This scale-free property was subsequently found in other networks describing real world systems, such as cellular protein-protein interactions Albert (2005); Nafis et al. (2015), brain activity He (2014), and interaction in social networks López-Pintado (2008).

Scale-free networks are constructed by starting with a small graph and repeatedly adding nodes. Each new node added is connected to $m$ other nodes already in the network. This scheme provides preferential attachment, as nodes will be more likely connected to nodes with high connectivity Barabási et al. (2000). Scale-free graphs will be denoted $SF(n,m)$, where each new node added is connected to $m$ other nodes and the total number of nodes in the network is given by $n$.

IV.1.3 Strongly Regular Graphs

A $k$-regular graph with $n$ nodes is said to be strongly regular if all adjacent nodes have $\lambda$ common neighbours and all non-adjacent nodes have $\mu$ common neighbours Bose (1963). Due to this structure, it is difficult to distinguish between SRGs with the same parameters ($n,k,\lambda,\mu$). This provides a good benchmark to test for isomorphism to ensure a similarity measure correctly distinguishes between similar graph structures. Strongly regular graphs with parameters ($n,k,\lambda,\mu$) will be denoted $SRG(n,k,\lambda,\mu)$.

IV.2 Isomorphism and Identity Testing

The identity axiom (II.3) is a key property of the graph similarity metric. It is expected that the algorithm will output “1” when the two input graphs are the same. As mentioned above, SRGs with the same parameters ($n,k,\lambda,\mu$) are difficult to distinguish, which make them a good baseline for testing the algorithm. These tests are used to confirm the similarity measure can correctly distinguish whether a pair of graphs differ in any way.

Table 1 gives the resulting similarity score when comparing a number of different SRGs from the same family. These same graphs have also been compared to themselves, all returning a similarity of 1. Thus, the algorithm successfully reproduces the identity axiom for these SRGs. Note that it is also expected that as the number of nodes increases, the similarity score will increase.

IV.3 Graph Similarity Testing

To test the graph similarity metric, we make comparisons between an input graph and a modified copy of this graph. Changes are made by randomly removing edges from the original graph. The graph similarity score is expected to decrease as edges are removed. Figure 7 demonstrate this trend for a variety of input graphs. For each number of edges removed, a statistical ensemble of graphs were generated for comparison. The variation in each of these sets of comparison scores would be due to the variations in structure created by removing different edges. The comparison score for each set is averaged, given by the solid lines in the plots. As we are more interested in how the similarity metric responds to small changes in graph structure, for each data set, we use a smaller step size at the beginning when removing edges.

As each input graph is generated with respect to the original graph, we can match the nodes between the graphs. This allows us to compare our algorithm with a classical graph similarity technique, such as DeltaCon. Note that we did not conduct this comparison with DeltaCon for SRGs in the previous section, due to the exponential time required by DeltaCon to match the nodes between the comparison graphs.

V Discussion and Conclusion

It is clear from Figure 7 that thresholding the distances does not provide sufficient sensitivity in the comparison measure. The comparison score remains at approximately 0.9 until a sudden drop to 0. As such, this distance metric would likely only be suitable for distinguishing between significantly different graphs. The other distance measures all give a gradual decrease in similarity score, decreasing faster for the larger number of changes (denoted as $\mathcal{C}$). This is in contrast to the DeltaCon measure, which is more sensitive for small $\mathcal{C}$ and begins to plateau as $\mathcal{C}$ increases. These two profiles likely represent different approaches to the graph similarity concept. The coined quantum walk metric gives results which are possibly more intuitive, as the graph structure is not likely to change significantly for small $\mathcal{C}$ (at least not for Erdős-Rènyi graphs) so the similarity should gradually decrease until there are no more edges to be deleted. However, DeltaCon suggests that making a few changes has a greater influence on the graph structure with respect to the previous set than for large $\mathcal{C}$. Whether this model is better than our quantum walk inspired model would depend on how the similarity between graphs is defined and the application requirements.

There is also a clear divide between Matusita and Euclidean distance measures, with the Matusita distance giving the least sensitive response. This metric boosts the difference in probabilities, which would increase the comparison score between graphs. However, this does not translate to a greater sensitivity in the similarity comparison, likely due to the boosted score being counteracted by the normalisation process. The Euclidean measures give roughly the same response as the Matusita measure for small $\mathcal{C}$, but becomes more sensitive as $\mathcal{C}$ increases. The Euclidean square measure has greater sensitivity, but at the cost of having a greater variation. This suggests that this measure is either more sensitive to graph structure changes or less accurate. Due to the fact that DeltaCon is relatively consistent, it is more likely the latter. The square metric could be useful if the application requires sensitivity to small change in graph structure only, otherwise the Euclidean measure is likely more suitable.

Overall, the coined quantum walk algorithm does not provide very good sensitivity for small $\mathcal{C}$; however, this could be attributed to these changes resulting in little difference in overall graph structure leading to a very similar score. In some cases, such as Figure 7e, the similarity score is relatively constant for a large range of $\mathcal{C}$ (in this case, 10 to 50 changes). The algorithm however is able to distinguish very similar graphs from less similar graphs. This would be useful in applications which do not require a high sensitivity for small $\mathcal{C}$, such as in machine learning or pattern recognition tasks. It could also be used to aid other processes, such as a preprocessing step to filter out comparisons which are significantly different, while another algorithm (which may have a greater time complexity) is used for a finer sensitivity.

The coined quantum walk algorithm successfully satisfies the three axioms described by Koutra et al. The identity algorithm has been shown to work for all investigated distance measures using the two reference node scheme. The second axiom is also fulfilled due to the algorithm design, as the input graph order has no effect on the final result. For two graphs with decreasing similarity, the graph comparison score will increase as a reduced number of reference node combinations provide a similar response. As two graphs tend towards being completely different (i.e. a complete graph compared with an empty graph), the comparison score will tend towards $O(n^{4})$. As this comparison score is likely much greater than the normalisation between each individual graph, the similarity between the graphs would become negligible. This has been confirmed by comparing complete and empty graphs, which return similarity scores of order $O(10^{-18})$, which is within precision error. The axiom is also substantiated by the results in Figure 7, as the similarity score tends to zero as $\mathcal{C}$ increases. This can be compared to the classical DeltaCon algorithm, which plateaus at some similarity score.

In conclusion, this paper proposes a quantum walk inspired algorithm designed to compute graph similarity measures in polynomial time with complexity $O(n^{9})$. The algorithm is capable of determining minor changes to significantly similar graph structure, such as determining isomorphism in strongly regular graphs. The algorithm also satisfies the axioms outlined by Koutra et al. Koutra et al. (2013). It is worth noting though that the proposed quantum walk model only works for undirected graphs. Consequently, the proposed algorithm to compute graph similarity measure naturally has this restriction as well. Alternative quantum walk models would need to be explored to develop an algorithm that is compatible for directed graphs.

VI Acknowledgements

This work was supported by resources provided by The Pawsey Supercomputing Centre with funding from the Australian Government and the Government of Western Australia. YL acknowledges funding from the National Sciences and Engineering Research Council of Canada.