Vulnerability of Clustering under Node Failure in Complex Networks

TL;DR

This paper investigates how the failure of individual nodes affects the clustering coefficient in complex networks, proposing algorithms to identify critical nodes and demonstrating their effectiveness through experiments.

Contribution

It formulates the vulnerability of network clustering to node failures as an NP-complete problem and provides two algorithms to identify critical vertices affecting clustering.

Findings

Proven NP-completeness of the vulnerability problem.

Algorithms effectively identify critical nodes impacting clustering.

Experimental results outperform other strategies in real and synthetic networks.

Abstract

Robustness in response to unexpected events is always desirable for real-world networks. To improve the robustness of any networked system, it is important to analyze vulnerability to external perturbation such as random failures or adversarial attacks occurring to elements of the network. In this paper, we study an emerging problem in assessing the robustness of complex networks: the vulnerability of the clustering of the network to the failure of network elements. Specifically, we identify vertices whose failures will critically damage the network by degrading its clustering, evaluated through the average clustering coefficient. This problem is important because any significant change made to the clustering, resulting from element-wise failures, could degrade network performance such as the ability for information to propagate in a social network. We formulate this vulnerability analysis as an optimization problem, prove its NP-completeness and non-monotonicity, and we offer two algorithms to identify the vertices most important to clustering. Finally, we conduct comprehensive experiments in synthesized social networks generated by various well-known models as well as traces of real social networks. The empirical results over other competitive strategies show the efficacy of our proposed algorithms.

Tables

Table 1. TABLE I: List of Symbols

Notation	Meaning
$N$	Number of vertices/nodes ($N=\left|V\right|$)
$M$	Number of edges/links ($M=\left|E\right|$)
$d_u$	The degree of $u$
$N\left(u\right)$	The set of neighbors of $u$
$T\left(u\right)$	The number of triangles containing $u$
$C\left(u\right),C\left(G\right)$	Clustering coefficients of $u$ and $G$
${\tilde{C}}_v\left(u\right),{\tilde{C}}_v\left(G\right)$	Clustering coefficients of $u$ and $G$
	after removing node $v$ from $G$
$G\left[S\right]$	The subgraph induced by $S\subseteq V$ in $G$
$tr(u,v)$	The number of triangles containing both $u,v$

Equations

$$C(u)=\{\begin{array}{ll}\frac{2T(u)}{d_u(d_u-1)}& d_u>1\\ 0& \text{ otherwise }\end{array}$$

$$C(G)=\frac{1}{N}\sum _{u\in V}C(u).$$

$${\tilde{C}}_v(G)=C\left(G[V\backslash \{v\}]\right).$$

$$S^{\ast }=\underset{S\subseteq V,|S|\le k}{\mathrm{argmax}}\Delta C(S),$$

$$2T(u)=\sum _{i\in V}\sum _{j\in V}{e}_{ui}{e}_{uj}{e}_{ij}.$$

$$\min \sum _{u\in V:d(u)>1}\sum _{i\in V}\sum _{j\in V}\frac{e_{ui}{e}_{uj}{e}_{ij}{x}_i{x}_j{x}_u}{d_u(d_u-1)(N-k)}$$

$$\sum _{u\in V}{x}_u\le k,$$

$$x_u\in \{0,1\},u\in V.$$

$$2T(u)=\sum _{v\in N(u)}|N(u)\cap N(v)|.$$

$$\frac{1}{N-1}\sum _{v\in V\setminus \{u\}}{\tilde{C}}_v(u)\le C(u).$$

$$\frac{1}{N-1}\sum _{v\in V\setminus \{u\}}{\tilde{C}}_v(u)\le C(u)\text{ when du≤2}.$$

$$\frac{1}{N-1}\sum _{v\in V\setminus \{u\}}{\tilde{C}}_v(u)=C(u)\text{ when du>2}.$$

$$\sum _{v\in V\setminus \{u\}}{\tilde{C}}_v(u)$$

$$=\sum _{v\in N(u)}{\tilde{C}}_v(u)+(N-d_u-1)C(u).$$

$${\tilde{C}}_v(u)=\frac{2\left(T(u)-|N(u)\cap N(v)|\right)}{(d_u-1)(d_u-2)}.$$

$$\sum _{v\in N(u)}{\tilde{C}}_v(u)=\frac{{\sum }_{v\in N(u)}2\left(T(u)-|N(u)\cap N(v)|\right)}{(d_u-1)(d_u-2)}$$

$$=\frac{2(d_{u}T(u)-{\sum }_{v\in N(u)}|N(u)\cap N(v)|)}{(d_u-1)(d_u-2)}$$

$$\sum _{v\in N(u)}{\tilde{C}}_v(u)=\frac{2(d_u-2)T(u)}{(d_u-1)(d_u-2)}=d_{u}C(u)$$

$$\sum _{v\in V}{\tilde{C}}_v(G)$$

$$\sum _{u\in V}\left[\frac{1}{N-1}\sum _{v\in V\setminus \{u\}}{\tilde{C}}_v(u)\right]$$

$$\Delta {\tilde{C}}_u=\frac{2T(u)}{Nd(u)(d(u)-1)}+$$

$$+$$

$$c_v-{\hat{c}}_v=\frac{2T(u)}{Nd(u)(d(u)-1)}.$$

$$c_v=\frac{2T(v)}{Nd(v)(d(v)-1)},$$

$${\hat{c}}_v=\frac{2(T(v)-tr(u,v))}{(N-1)(d(v)-1)(d(v)-2)},$$

$$c_v-{\hat{c}}_v=\sum _{v\in N_{>2}(u)}\frac{4T(v)(1-N)+2tr(u,v)Nd(v)-2T(v)d(v)}{N(N-1)d(v)(d(v)-1)(d(v)-2)}.$$

$$Pr\left(\text{ t becomes activated }\right)\ge 1-(1/2)\cdot (3/4{)}^k.$$

$$Pr\left(\text{ t becomes activated }\right)$$

$$=1/2+1/2\cdot Pr\left(\bigcup _{n\in N(s)\cap N(t)}{A}_n\right).$$

$$Pr\left(\bigcup _{i=1}^k{A}_{n_k}\right)=\sum _{i=1}^k\left(\genfrac{}{}{0ex}{}{k}{i}\right)(1/4{)}^i(-1{)}^{i+1}=1-(3/4{)}^k.$$

Full text

I Introduction

Network resilience to attacks and failures has been a growing concern in recent times. Robustness is perhaps one of the most desirable properties for corporeal complex networks, such as the World Wide Web, transportation networks, communication networks, biological networks and social information networks. Roughly speaking, robustness of a network evaluates how much the network’s normal function is affected in case of external perturbation, i.e., it measures the resilience of the network in response to unexpected events such as adversarial attacks and random failures (Holme et al., 2002). Complex systems that can sustain their organizational structure, functionality and responsiveness under such unexpected perturbation are considered more robust than those that fail to do so. The concept of vulnerability has generally been used to realize and characterize the lack of robustness and resilience of complex systems (Criado and Romance, 2012). In order to improve the robustness of real-world systems, it is therefore important to obtain key insights into the structural vulnerabilities of the networks representing them. A major aspect of this is to analyze and understand the effect of failure (either intentionally or at random) of individual components on the degree of clustering in the network.

Clustering is a fundamental network property that has been shown to be relevant to a variety of topics. For example, consider the propagation of information through a social network, such as the spread of a rumor. A growing body of work has identified the importance of clustering to such propagation; the more clustered a network is, the easier it is for information to propagate (Centola, 2010; Barclay et al., 2013; Lü et al., 2011; Malik and Mucha, 2013; Centola, 2011). In addition, in Fig. 1, we show experimentally a strong relationship between the final spread of information and the level of clustering in the network, with higher clustering corresponding to higher levels of expected spread. The importance of clustering is not limited to social networks; in the context of air transportation networks, Ponton et al. (2013) argued that higher clustering of such a network is beneficial, as passengers for a cancelled flight can be rerouted more easily. In this work, we use average clustering coefficient (ALCC) as our definition and measure of clustering in a network. ALCC was proposed for this purpose by Watts and Strogatz (1998).

The identification of elements that crucially affect the clustering of the network, as a result, is of great impact. For example, as a matter of homeland security, the critical elements for clustering in homeland communication networks should receive greater resources for protection; in complement, the identification of critical elements in a social network of adversaries could potentially limit the spread of information in such a network. However, most studies of network vulnerability in the literature focus on how the network behaves when its elements (nodes and edges) are removed based on the pair-wise connectivity (Dinh et al., 2012b), natural connectivity (Chan et al., 2014), or using centrality measures, such as degrees, betweeness (Albert et al., 2000), the geodesic length (Holme et al., 2002), eigenvector (Allesina and Pascual, 2009), etc. To our knowledge, none of the existing work has examined the average clustering coefficient from the perspective of vulnerability - as evidenced by the examples above, the damage made to the average clustering, resulted from element-wise failures, can potentially have severe effects on the functionality of the network. This drives the need for an analysis of clustering vulnerabilities in complex networks.

Finding a solution for this emerging problem, nevertheless, is fundamentally yet technically challenging because (1) the behavior of ALCC is not monotonic with respect to node removal and thus can be unpredictable even in response to minor changes, and (2) given large sizes of real networks, the $NP$-completeness of the problem prohibits the tractable computation of an exact solution. In this paper, we tackle the problem and analyze the vulnerabilities of the network clustering. Particularly, we ask the question:

{addmargin}

[1em]1em “Given a complex network and its clustering coefficient, what are the most important vertices whose failure under attack, either intentionally or at random, will maximally degrade the network clustering?”

There are many advantages of ALCC over other structural measures (Watts and Strogatz, 1998): (1) it is one of the most popular metrics for evaluating network clustering - the higher the ALCC of a network the better clustering it exhibits, (2) it implies multiple network modular properties such as small-world scale-free phenomena, small diameter and modular structure (or community structure), and (3) it is meaningful on both connected and disconnected as well as dense and sparse graphs: Sparse networks are expected to have small clustering coefficient whereas extant complex networks are found to have high clustering coefficients.

Our contributions in this paper are: (1) We define the Clustering Vulnerability Assessment (CVA) on complex networks, and formulate it as an optimization problem with ALCC as the objective function. (2) We study CVA’s complexity (NP-completeness), provide rigorous proofs and vulnerability analysis on random failures and targeted attacks. To our knowledge, this is the first time the problem and the analysis are studied specifically for ALCC. (3) Given the intractability of the problem, we provide two efficient algorithms which scale to large networks to identify the worst-case scenarios of adversary attacks. Finally, (4) we conduct comprehensive experiments in both synthesized networks (generated by various well-known models) as well as real networks. The empirical results over other methods show the efficacy and scalability of our proposed algorithms.

The paper is organized as follows: Section II reviews studies that are related to our work. Section III describes the notations, measure functions and the problem definition. Section IV shows the proof of NP-completeness implying the intractability of the problem. Section V and VI present our analysis of clustering behaviors on random failures and targeted attacks, respectively. In Section VII, we provide further evidence for a correlation between the extent of influence propagation and ALCC. In Section VIII, we report empirical results of our approaches in comparison with other strategies. Finally, Section IX concludes the paper.

II Related work

Vulnerability assessment has attracted a large amount of attention from the network science community. Work in the literature can be divided into two categories: Measuring the robustness and manipulating the robustness of a network. In measuring the robustness, different measures and metrics have been proposed such as the graph connectivity (Dinh et al., 2012b), the diameter, relative size of largest components, and average size of the isolated cluster (Albert et al., 2000). Other work suggests using the minimum node/edge cut (Frank and Frisch, 1970) or the second smallest non-zero eigenvalue or the Laplacian matrix (Fiedler, 1973). In terms of manipulating the robustness, different strategies has been proposed such as Albert et al. (2000); Peixoto and Bornholdt (2012), or using graph percolation (Callaway et al., 2000). Other studies focus on excluding nodes by centrality measures, such as betweeness and the geodesic length (Holme et al., 2002), eigenvector (Allesina and Pascual, 2009), the shortest path between node pairs (Grubesic et al., 2008), or the total pair-wise connectivity (Dinh et al., 2012b). Veremyev et al. (2015, 2014) developed integer programming frameworks to determine the critical nodes that minimize a connectivity metric subject to a budgetary constraint. For more information on network vulnerability assessments, the reader is referred to the surveys (Chen, 2016) and (Gomes et al., 2016) and references therein.

The vulnerability of the average clustering of a complex network has been a relatively unexplored area. In a related work (Nguyen et al., 2013), the authors introduced the community structure vulnerability to analyze how the communities are affected when top $k$ vertices are excluded from the underlying graphs. They further provided different heuristic approaches to find out those critical components in modularity-based community structure. Alim et al. (2014b) suggested a method based on the generating edges of a community to find out the critical components. In a similar vein, Alim et al. (2014a) studied the problem of breaking all density-based communities in the network, proved its NP-hardness and suggested an approximation as well as heuristic solutions. These studies, while forming the basis of community-based vulnerability analysis, face a fundamental limitation due to the ambiguity of definitions of a community in a network. Our work overcomes this particular shortcoming as ALCC is a well-defined and commonly accepted concept for quantifying the clustering of a network. Ertem et al. (2016) studied the problem of how to detect groups of nodes in a social network with high clustering coefficient; however, their work does not consider the vulnerability of the average clustering coefficient of a network. The diffusion of information in a social network has been studied from many perspectives, including worm containment (Nguyen et al., 2010), viral marketing (Kempe et al., 2003; Dinh et al., 2012a, 2013; Kuhnle et al., 2017), and the detection of overlapping communities (Nguyen et al., 2011).

III Notations and Problem definition

III-A Notations

Let $G=(V,E)$ be an undirected graph representing a complex network where $V$ is the set of $N$ nodes and $E$ is the set of edges containing $M$ connections. For a node $u\in V$, denote by $d_{u}$ and $N(u)$ the degree of $u$ and the set of $u$’s neighbors, respectively. For a subset of nodes $S\subseteq V$, let $G[S]$ and $m_{S}$ in this order denote the subgraph induced by $S$ in $G$ and the number of edges in this subgraph. Hereafter, the terms “vertices” and “nodes” as well as “edges” and “links” are used interchangeably.

(Triangle-free graphs) A graph $G$ is said to be triangle-free if no three vertices of $G$ form a triangle of edges. Verifying whether a given graph $G$ is triangle-free or not is tractable by computing the trace of $A^{3}$ where $A$ is the adjacency matrix of $G$. The trace is zero if and only if the graph is triangle-free. This verification can be done in polynomial time $O(N^{\omega})$ for $\omega\leq 2.372$ with the latest matrix multiplying result (Gall, 2014). Alternatively, one can use the method of (Schank and Wagner, 2005) with time complexity $O(M^{3/2})$ to check if the graph is triangle-free.

III-B Clustering Measure Functions

III-B1 Local Clustering Coefficient (LCC)

Given a node $u\in V$, there are $d_{u}$ adjacent vertices of $u$ in $G$ and there are $d_{u}(d_{u}-1)/2$ possible edges among all $u$’s neighbors. The local clustering coefficient $C(u)$ is the probability that two random neighbors of $u$ are connected. Equivalently, it quantifies how close the induced subgraph of neighbors is to a clique.

The local clustering coefficient $C(u)$ is defined (Watts and Strogatz, 1998)

[TABLE]

where $T(u)$ is the number of triangles containing $u$. It is clear that $0\leq C(u)\leq 1$ for any $u\in V$. For any node $v\neq u$, let $\tilde{C}_{v}(u)$ denote the clustering coefficient of $u$ in $G[V\backslash\{v\}]$. Finally, define $tr(u,v)$ as the number of triangles containing both vertices $u$ and $v$.

III-B2 Average Clustering Coefficient (ALCC)

In graph theory, the average local clustering coefficient (ALCC) $C(G)$ of a graph $G$ is a measure indicating how much vertices of $G$ tend to cluster together (Watts and Strogatz, 1998). This measure is defined as the average of LCC over all vertices in the network. $C(G)$ is defined as:

[TABLE]

Because $0\leq C(u)\leq 1$ for every node $u\in V$, $C(G)$ is normalized and can only take values in the range $[0,1]$ inclusively. For instance, $C(G)=0$ when $G$ is a triangle-free graph and $C(G)=1$ when $G$ is a clique or a collection of cliques. The higher the clustering coefficient of $G$ the more closely the graph locally resembles a clique. Also, we define

[TABLE]

III-C Problem definition

We define the Clustering Structure Assessment problem (CSA) as follows

Definition 1** ($CSA(G,k)$).**

Given a network $G=(V,E)$ and a positive integer $k\leq N$, find a subset $S^{*}\subseteq V$ of cardinality at most $k$ that maximizes the reduction of the clustering coefficient, i.e.,

[TABLE]

where $\Delta C(S)=C(G)-C(G[V\backslash S]).$

CSA problem aims to identify the most critical vertices of the network with respect to the average clustering coefficient. The input parameter $k$ can be interpreted as the the maximum number of node failures that normal functionality of the network can withstand once adversarial attacks or random corruptions occur. Accordingly, the case $|S|=k$ identifies exactly $k$ critical vertices and examines the worst scenarios that can happen when these vertices are compromised.

III-D Formulation as cubic integer program

In this section, we formulate the CSA problem as an integer program. Let $(e_{ij})_{i,j\in V}$ be the adjacency matrix of $G$.

Lemma 1**.**

For $u\in V$, $T(u)$ can be calculated in the following way:

[TABLE]

Proof.

The summand $e_{ui}e_{uj}e_{ij}=1$ iff $i,j$ are neighbors of $u$, and if edge $(i,j)$ is in the graph; that is, vertices $u,i,j$ form a triangle. ∎

We formulate CSA as an integer program in the following way. Let $x_{i}=1$ if $i$ is included in the set $S$, and $x_{i}=0$ otherwise.

Integer Program 1**.**

[TABLE]

such that

[TABLE]

[TABLE]

Notice that the sum (2) computes the ALCC of the residual graph after removing $S$. As we show in Section V, Corollary 1, there always exists a node the removal of which will not increase the ALCC; thus, an optimal solution to the program is an optimal solution to CSA.

IV Complexity of CSA

In this section, we show the NP-completeness of $CSA(G,k)$. This intractability indicates that an optimal solution for CSA might not be computationally feasible in practice.

Definition 2** (Decision problem – $CSA(G,k,\alpha)$).**

Given a network $G=(V,E)$, a number $k\leq N$ and a value $0\leq\alpha\leq 1$, does there exist a set $S\subseteq V$ of size $k$ such that $\Delta C(G)\geq\alpha$?

Theorem 1**.**

$CSA(G,k,C(G))$* is NP-Complete.*

Proof.

We show that the following subproblem of $CSA(G,k,C(G))$ is NP-complete; the subproblem asks for a set $S\subseteq V$ of $k$ nodes whose removal completely degrades the clustering coefficient $C(G[V\backslash S])$ to 0, or equivalently, makes the residual graph $G[V\backslash S]$ triangle-free (Lemma 2). To show the NP-completeness, we first show that CSA is in NP, and then prove its NP-hardness by constructing a polynomial time reduction from 3-SAT to $CSA(G,k,C(G))$. Given a set $S\subseteq V$ of $k$ nodes, one can verify whether $G[V\backslash S]$ is triangle-free by computing the trace of $A^{3}$ where $A$ is the adjacency matrix of $G[V\backslash S]$. As we mentioned above, this can be done in $O((N-k)^{2.372})$. Therefore, $CSA(G,k,C(G))$ is in NP.

Now, given an instance boolean formula $\phi$ of 3-SAT with $m$ variables and $l$ clauses, we will construct an instance of $CSA(G,k,C(G))$, where $k=m+2l$, as follows:

For each clause $C=l_{1}\vee l_{2}\vee l_{3}$ of $\phi$, introduce a 3-clique in $G$ with 3 clause literals as vertices: add vertices $l_{1}^{C},l_{2}^{C},\l_{3}^{C}$, and edges $(l_{i}^{C},l_{j}^{C})$ for $1\leq i<j\leq 3$. Color these vertices blue. 2. 2.

For each variable $x_{i}$ of $\phi$, create two vertices representing literals $x$ and $\neg x$ in $G$ and connect them by an edge. That is, add vertices $v_{x_{i}},v_{\neg x_{i}}$ and edge $(v_{x_{i}},v_{\neg x_{i}}$). Color these vertices green. 3. 3.

For each blue vertex in a 3-clique created in step 1, connect it to the corresponding green literal created in step 2. That is, for each literal $l_{j}$ in each clause $C$, if $l_{j}=x_{i}$, then add edge $(l_{j}^{C},v_{x_{i}})$. If literal $l_{j}=\neg x_{i}$, then instead add edge $(l_{j}^{C},v_{\neg x_{i}})$. 4. 4.

Finally, for every edge in $G$, create a dummy vertex $d$ (color it red) and connect $d$ to the two endpoints of that edge.

Figure 2 illustrates the reduction of the toy boolean formula $(x_{1}\vee\neg x_{2}\vee x_{3})\wedge(\neg x_{1}\vee x_{2}\vee\neg x_{3})$. In this example, step 1 introduces two 3-cliques with blue vertices, step 2 creates three pairs of green vertices, and step 3 consequently connects blue vertices to their corresponding green vertices by the thick curly edges. Finally, step 4 assembles dummy nodes $d$’s (in red) and two dotted lines for every existing edges in $G$.

Let $G_{-d}$ denote the graph $G$ without dummy vertices $d$’s and their adjacent dotted edges. Assume that $\phi$ has a satisfied assignment, we construct $S$ by (i) include in $S$ all vertices corresponding to true literals, and (ii) for each clause, include in $S$ all vertices of the 3-clique but the one corresponding to its first true literal. Thus, $S$ includes $m$ green vertices and $2l$ blue vertices. It is verifiable that vertices in $S$ form the vertex cover of $G_{-d}$. As a result, the removal of all nodes in $S$ will make $G[V\backslash S]$ triangle-free (since it leaves no edges in $G_{-d}$).

Suppose there exists a set $S$ of $k$ nodes such that removing $k$ nodes in $S$ leaves $G[V\backslash S]$ triangle-free. We note that $S$ will not contain any dummy node $d$ because replacing $d$ by any of its adjacent literals (which are not already in $S$ yet) yields a better solution in term of triangle coverage. As a consequence, $S$ only contains blue and green vertices. Furthermore, nodes in $S$ have to be indeed the vertex cover of $G_{-d}$ in order for $G[V\backslash S]$ to be triangle-free. This cover must contain one green vertex for each variable and two blue vertices for each 3-clique (or clause), requiring exactly $k=m+2l$ vertices. Now, assign value true to the variables whose positive literals are in $S$. Because $k=m+2l$, for each clause at least one edge connecting its blue 3-clique to the green vertices is covered by a variable vertex. Hence, the clause is satisfied. ∎

V Vulnerability Analysis in Random Failure

V-A Monotonicity of ALCC

The value of ALCC is not monotonic in terms of the set of excluded nodes $S$. Counterexamples showing the non-monotonicity of ALCC are presented in Fig. 3(a). This implies that we do not always have either $C(G[V\backslash S_{1}])\geq C(G[V\backslash S_{2}])$ or $C(G[V\backslash S_{1}])\leq C(G[V\backslash S_{2}])$ for any subsets $S_{1}\subseteq S_{2}\subseteq V$. In fact, it is possible that ALCC could be at a local minimum with further node removal increasing the value of ALCC. Our analysis in Section V-B shows that is always possible to degrade the value of ALCC by removing a vertex. We show that in any network $G$ there exists a vertex $u$ such that $\tilde{C}_{u}(G)\leq C(G)$. This result is the basis of the algorithms we present in Section VI.

V-B Analysis of Random Failure

When random failures occur,
the ALCC value is unpredictable due to the nonmonotonicity of ALCC. That is, the removal of nodes can result in either higher or lower ALCC of the residual graph. We show that under uniform random failures the expected ALCC $E_{u}[\tilde{C}_{u}(G)]$ is at most the current ALCC value (Theorem 2). This result also indicates that, given a network $G$, there exists a sequence of subgraphs $G_{i}$ of $G$ whose ALCC values form a nonincreasing sequence (Corollary 1).

Lemma 2**.**

In a graph $G$, the following statements hold:

• (i)

$C(G)=0$* if and only if $G$ is a triangle-free network.*

• (ii)

$C(G)=1$* if and only if $G$ is a clique or contains only separated cliques.*

Proof.

• (i)

Suppose there exists a triangle $u,v,w$ in $G$. Then $C(u)>0$, so $C(G)>0$. For the converse, if $C(G)>0$, there exists $u\in V$ such that $C(u)>0$. By definition of $C(u)$, there exists a triangle $u,v,w$ containing $u$.

• (ii)

Suppose $C(G)=1$. Then, for each $u\in V$, the subgraph induced by $\{u\}\cup N(u)$ is a clique, from which $G$ is a clique or only separated cliques. The converse follows directly from the definition of $C(G)$.

∎

Lemma 3**.**

For any $u\in V$,

[TABLE]

Proof.

For each neighbor $v$ of $u$, the number of triangles that contain both $u$ and $v$ is $|N(u)\cap N(v)|$. Since each triangle containing $u$ contains exactly two neighbors of $u$, it follows that the summation $\sum_{v\in N(u)}|N(u)\cap N(v)|$ counts twice the number of triangles containing $u$. ∎

Lemma 4**.**

For any node $u\in V$:

[TABLE]

Proof.

To prove this Lemma, we will show the following statements regarding the degree of $u$:

[TABLE]

[TABLE]

Eq. (3) is equivalent to $\displaystyle\sum_{v\in V\setminus\{u\}}\tilde{C}_{v}(u)\leq(N-1)C(u).$

Expanding the left-hand-side (LHS) of this inequality yields

[TABLE]

To find $\sum_{v\in V\setminus(N(u)\cup\{u\})}\tilde{C}_{v}(u)$, we use the fact that removing a non-neighbor node of $u$ will not affect the local clustering coefficient $C(u)$, i.e., $\tilde{C}_{v}(u)=C(u)$ for $v\in V\setminus(N(u)\cup\{u\})$. There are $(N-d_{u}-1)$ non-neighbors vertices of $u$ in $G$. Thus the second term of (6) follows. To evaluate the first term of Eq. (6), we consider two cases:

Case (i): When $d_{u}\leq 2$ (i.e., $u$ has only one or two neighbors). In this case, the removal of any neighbor of $u$ will make $d_{u}\leq 1$, and thus, will drop $\tilde{C}_{v}(u)$ to 0 based on the definition of LCC. This implies $0=\displaystyle\sum_{v\in N(u)}\tilde{C}_{v}(u)\leq d_{u}\times C(u).$ Substituting this to the first term of Eq. (6) yields Eq. (4)

Case (ii): When $d_{u}>2$. For any $v\in N(u)$, removing $v$ degrades $d_{u}$ to $d_{u}-1$ and decreases the number of triangles on $u$ by an amount of $|N(u)\cap N(v)|$. As a result,

[TABLE]

Therefore,

[TABLE]

By Lemma 3, we can simplify Eq. (8) to

[TABLE]

Substituting this to Eq. (6) yields Eq. (5). The inequality in Lemma 3 occurs only if $u$ is of single degree, or $u$ has exactly two connected neighbors. ∎

Using Lemma 3, we can show the following main result of ALCC’s behavior on random failures:

Theorem 2**.**

In a graph $G$, $E_{u}[\tilde{C}_{u}(G)]\leq C(G)$.

Proof.

By definition of ALCC, we have

[TABLE]

Applying Eq. (3) in Lemma 3 gives

[TABLE]

Thus $E[\tilde{C}_{\cdot}(G)]=\displaystyle\frac{1}{N}\sum_{v\in V}\tilde{C}_{v}(G)\leq C(G).$ ∎

Corollary 1**.**

In a graph $G\equiv G_{0}$ of $N$ nodes, there exists a sequence of subgraphs $G_{0}\supseteq G_{1}\supseteq\cdots\supseteq G_{N}\equiv\emptyset$ such that $C(G_{i})\geq C(G_{i+1})$ and $G_{i+1}$ is constructed by removing one vertex from $G_{i}$ for $i=0,\ldots,N-1$.

VI Algorithms

In this section, we present two algorithms for CSA problem, namely simple_greedy (Alg. 1), and Fast Adaptive Greedy Algorithm (FAGA) (Alg. 2). Alg. 1 is a simpler greedy algorithm than FAGA, which employs more sophisticated strategies to more efficiently provide a solution of significantly higher quality than Alg. 1.

VI-A Simple Greedy Algorithm

Our first algorithm (Alg. 1) computes for each node $u$ the ALCC value after removing $u$, denoted by $\tilde{C}_{u}(G)$. The $k$ vertices associated with the lowest values of $\tilde{C}_{u}(G)$ are included in the solution. Notice that in this algorithm, the values of $\tilde{C}_{u}(G)$ are computed only once, and $k$ nodes are simultaneously included in the final solution. Since the local clustering coefficient of a node $u$ is dependent only on the subgraph of its neighbors, we chose this approach over iteratively recomputing $\tilde{C}_{u}(G\backslash\{s_{1},\ldots,s_{i}\})$ for all nodes after choosing $\{s_{1},\ldots,s_{i}\}$ into set $S$.

Time-complexity: The complexity of Alg. 1 depends on the $N$ calls to compute the ALCC of the network. There are two state-of-the-art methods in (Gall, 2014) and (Schank and Wagner, 2005) for this purpose. If ALCC is computed using the matrix multiplying technique in (Gall, 2014), the time-complexity is $O(N^{\omega})$ with $\omega\leq 2.372$. Alternatively, if ALCC is computed using the method in (Schank and Wagner, 2005), which has complexity of $O(M^{3/2})$, the overall complexity will be $O(NM^{3/2})$. In practice, neither of these two upper bounds fully dominates the other. In our experimental evaluation in Section VIII, we utilize (Schank and Wagner, 2005) for computing ALCC.

VI-B Fast Adaptive Greedy Algorithm

We next present the Fast Adaptive Greedy Algorithm (FAGA - Alg. 2) that significantly improves simple_greedy. For small values of $k$, this algorithm requires as much time as computing ALCC only once; it is $N$ times faster than its predecessor. Furthermore, it provides a significant quality improvement over simple_greedy in our empirical studies.

In principle, FAGA employs an adaptive strategy in computing the reduction of ALCC when nodes are removed iteratively. At each round, the node $v$ incurring the highest reduction in ALCC is selected into the solution. As shown in the proof of Theorem 3, a node $v$ does exist at any iteration. Node $v$ is removed from the graph and the procedure repeats itself for the remaining vertices; that is, FAGA recomputes for each vertex $u$, which is not yet in the solution, its ALCC reduction $\Delta\tilde{C}_{u}$ when $u$ is removed from the graph. This strategy provides better solution quality than the non-adaptive greedy algorithm. While it is more complicated than the previous approach, it can be done faster than simple_greedy as we show in the following discussion.

We structure FAGA into two phases. The first phase (lines 1–15) extends the algorithm in (Schank and Wagner, 2005) to compute both ALCC and the number of triangles that are incident with each edge and node in the graph. This algorithm was proved to be time-optimal in $\theta(M^{3/2})$ for triangle-listing, and has been shown to be very efficient in practice. The second phase (lines 16–33) repeats the vertex selection for $k$ rounds. In each round, we select the node $u_{max}$ which decreases the clustering coefficient the most into the solution, remove $u_{max}$ from the graph, and perform the necessary update for $\Delta\tilde{C}_{u}$ for the remaining nodes $u\in V$.

The key efficiency of FAGA algorithm is in its update procedure for $\Delta\tilde{C}_{u}$. The update $\Delta\tilde{C}_{u}$ for remaining nodes after removing $u_{max}$ can be done in linear time. This is made possible due to the information on the number of triangles involving each edge. The correctness of this update formulation (lines 18–26) is proved in the following lemma.

Lemma 5**.**

Let $N_{2}(u)=\{v\in N(u):d(v)=2\}$, $N_{>2}(u)=\{v\in N(u):d(v)>2\}$. For each $u\in V$, $\Delta\tilde{C}_{u}(G)$ can be computed in the following way:

[TABLE]

Proof.

Denote the contribution of $v\in G$ to the average clustering coefficient as $c_{v}$ before the removal of $u$ and $\hat{c}_{v}$ after. $\Delta\tilde{C}_{u}$ can be written as $\sum_{v\in G}c_{v}-\hat{c}_{v}.$ If $v\not\in N(u)\cup\{u\}$, then $c_{v}=\hat{c}_{v}$. If $v=u$, then

[TABLE]

Let $v\in N_{>2}(u)$. Then before removal of $u$, $v$ is in $T(v)$ triangles. After removal, $v$ is in $T(v)-tr(u,v)$ triangles. Hence

[TABLE]

and

[TABLE]

whence

[TABLE]

Let $v\in N_{2}(u)$. Before removal of $u$, $v$ is in $T(v)$ triangles. After removal, $v$ is in 0 triangles, hence the result follows. ∎

One important feature of FAGA is that the produced residual ALCC values will form a nonincreasing sequence. This feature is summarized in the following theorem.

Theorem 3**.**

The ALCC values of networks after each iteration (Alg. 2, lines 16 – 28) form a non-increasing sequence.

Proof.

We first show that in a graph $G$, there always exists a node $u$ such that $\tilde{C}_{u}(G)\leq C(G)$. Assume otherwise, that is $\tilde{C}_{v}(G)>C(G)$ for all node $v\in V$. This implies $\sum_{v\in V}\tilde{C}_{v}(G)>N\times C(G)$ which contradicts Theorem 2. Thus, the statement holds true. Finally, the theorem follows because at each step we select the nodes that maximally degrades ALCC of the whole network. ∎

Time-complexity: The first phase takes $O(M^{3/2})$ as in (Schank and Wagner, 2005). The second phase takes a linear time in each round and has a total time complexity $O(k(N+M))$. Thus, the overall complexity is $O(M^{3/2}+k(M+N))$. When $k<M^{1/2}$, the algorithm has an effective time-complexity $O(N^{3/2})$, which is $N$ times faster than simple_greedy.

VII Clustering and the spread of information

In this section, we provide additional evidence for the relationship between the propagation of information in a social network and the average network clustering. Since information cannot propagate from one connected component to another, we consider this relationship when the graph $G$ representing the social network is connected. Thus, we consider connected graphs with different values of ALCC. We define the relevant models of influence propagation in Section VII-A; then, we demonstrate an empirical relationship in Section VII-B; next, we provide theoretical evidence in support of this relationship in Section VII-C.

VII-A Models of influence

To observe the effect of ALCC on influence propagation, we adopted the following two standard models (Kempe et al., 2003); intuitively, the idea of a model of influence propagation in a network is a way by which nodes can be activated given a set of seed nodes. An instance of influence propagation on a graph $G$ follows the independent cascade (IC) model if a weight can be assigned to each edge such that the propagation probabilities can be computed as follows: once a node $u$ first becomes active, it is given a single chance to activate each currently inactive neighbor $v$ with probability proportional to the weight of the edge $(u,v)$. In the linear threshold (LT) model each network user $u$ has an associated threshold $\theta(u)$ chosen uniformly from $[0,1]$ which determines how much influence (the sum of the weights of incoming edges) is required to activate $u$. $u$ becomes active if the total influence from its active neighbors exceeds the threshold $\theta(u)$.

VII-B Experimental evidence

To test the relationship between influence propagation and clustering empirically, we used a variety of Watts-Strogatz graphs (Watts and Strogatz, 1998); a graph generated by this model starts as a ring lattice, defined as follows. First, $n$ circular rings are constructed: for each $j\in\{1,\ldots,n\}$, vertices $u_{1}^{j},\ldots,u_{n}^{j}$ and edges $(u_{i}^{j},u_{i+1}^{j})$, $i=1,\ldots,n-1$, and $(u_{n}^{j},u_{1}^{j})$. Next, add edges $(u_{i}^{j},u_{i}^{j+1})$, for $j=1,\ldots,n-1$, and $(u_{i}^{n},u_{i}^{1})$, for each $i$. Finally, all vertices within $k$ hops of each other are connected by an edge. For these experiments, we used $n=100$ and $k=3$. With probability $p$, each edge in the graph is rewired; that is, replaced with an edge between two uniformly randomly chosen vertices. By varying $p$, one can control the level of clustering in the network, as shown in Fig. 1. Each graph generated in this manner has the same number of edges.

The expected activation was computed using a single seed node and an IT or LT realization; this computation was averaged over 1000 trials. When we normalize by the initial value, Fig. 1 shows a remarkable similarity between the normalized ALCC value and the normalized activations, for both the IC and LT models. Therefore, these results provide evidence supporting a positive correlation between ALCC and the expected activation of both the IC and LT models of information propagation.

VII-C Theoretical evidence of relationship between ALCC and influence propagation

In this section, we provide further evidence supporting the relationship between clustering and influence propagation, in the form of the following proposition, which shows how the probability of activation increases when more neighbors are shared; with higher ALCC, we may expect a higher fraction of shared neighbors between adjacent nodes.

Proposition 1**.**

Suppose $s$ is activated; let $t$ be a neighbor of $s$, and suppose $s,t$ share $k$ neighbors. Consider the IC model with uniform probability $1/2$ on each edge. Then

[TABLE]

Proof.

Let $A$ be the event that edge $(s,t)$ exists, and let $B$ be the event that edge $(s,t)$ does not exist, but for a common neighbor $n$, the edges $(s,n),(n,t)$ exist. For each common neighbor $n$, let $A_{n}$ be the event that both edges $(s,n),(n,t)$ exist. Then

[TABLE]

Notice that $Pr(A_{n})=1/4$, and let $N(s)\cap N(t)=\{n_{1},\ldots,n_{k}\}$. By the inclusion-exclusion principle, we have that

[TABLE]

Therefore, $Pr(A)+Pr(B)=1-(1/2)\cdot(3/4)^{k}$.

∎

VIII Experimental evaluation

We present the empirical results of our proposed algorithms on synthesized and real networks.
In Section VIII-A, we describe our methodology; in Section VIII-B, VIII-C we analyze the efficacy of degrading ACC, LCC, respectively; in Section VIII-D, we analyze the running time of the algorithms.

VIII-A Methodology

Algorithms

We are unaware of any competitive method that specifically minimizes ALCC, so to evaluate our approaches we compare to the following strategies:

• •

random_fail: Remove nodes uniformly at random,

• •

lcc_greedy: Remove nodes in greedy fashion according to highest local clustering coefficient,

• •

max_degree: Remove nodes in greedy fashion according to highest degree,

• •

betweenness: Removes in greedy fashion according to the highest betweenness centrality.

• •

optimal: For a network with 35 nodes, we were able to compute the optimal solution to CVA by exhaustive enumeration.

Method legends are described in Fig. 4(h).

Datasets

We use Erdős-Rényi (ER) (Erdős and Rényi, 1960), Watts-Strogatz (WS) (Watts and Strogatz, 1998), and Barabasi-Albert (BA)(Albert and Barabási, 2002) models to generate synthesized testbeds. These are foundational models which have been widely used in the literature. We used the following parameter values: $N=10000,M=49772$, $p=0.001$ (ER model); $N=35$, $p=0.2$ (ER model); $N=15000,M=44994$ (BA model); and $N=10000,M=200000$, with $n=100$, $k=3$, and $p=0.3$, these parameters are defined in Section VII (WS model).

Real-world traces include Facebook (Viswanath et al., 2009), ArXiv ePrint citation (dataset, 2003), and NetHEPT networks (Chen et al., 2010). The trace of Facebook has 25,492 users and 464,237 friendship links, NetHEPT has 15,234 authors with 31,376 connections, and ArXiv has 26,197 nodes with 14,484 edges. The parameter $k$ is set to a fraction of the total number of nodes in each graph. Besides ALCC, we also evaluate how the removal of critical nodes affects the maximum Local Clustering Coefficient (LCC).

VIII-B Results on Average Clustering Coefficient

In this section, we present results on the efficacy of the various algorithms to lower the ALCC. We observe (1) the performance of our algorithms in view of other strategies, and more importantly (2) the critical behavior of clustering coefficient when crucial nodes are removed by different criteria. The empirical results on synthesized and real data are presented in Fig. 4.

As depicted in the subfigures, ALCC values produced by our algorithm fast_greedy are consistently the best (lowest) values in all test cases, except in the ER network with 35 nodes where optimal was able to run. A visualization of the optimal solution on this network for $k=7$ is shown in Fig. 5. In the ER network with 10000 nodes, fast_greedy, lcc_greedy and simple_greedy methods quickly destroy clustering as soon as 0.02 fraction of nodes (on fast_greedy and lcc_greedy) and 0.05 fraction of nodes (on simple_greedy) are excluded from the networks. Interestingly, max_degree and betweenness methods do not appear much better than the baseline random_failure method especially for betweenness. A possible explanation for this is the independence and equal probability of wiring edges in ER model. Moreover, because ER model neither generates triadic closures nor forms hubs, the network structure might be easily broken when a few random but important nodes are removed.

In WS model, we observe the same degrading behavior of ALCC value produced by all methods with fast_greedy outperforming lcc_greedy and simple_greedy methods. Also in this model, these three methods outperformed the rest by a large magnitude. In BA model, fast_greedy still performs best, closely followed by max_degree and betweenness methods. As BA model generates graphs with references given to the power-law distribution (i.e., forming hubs) the performance of max_degree and betweenness can be explained. lcc_greedy does not do well in this type of network as it takes a considerable fraction of total nodes in order to degrade the average clustering coefficient.

In conclusion, fast_greedy is the best approach that consistently discovers nodes that are most important to the network clustering. The experiments also suggest that max_degree and betweenness, despite their popularity, might not be ideal methods to analyze structural vulnerability of complex networks. In addition, these experiments also show that (1) ALCC isn’t very susceptible to random failures, and (2) network clusters generated by ER, WS and BA can potentially be vulnerable to targeted attacks as the respective ALCC can quickly be impaired when only a few vertices are removed from the graphs.

In real data, the superior nature of fast_greedy becomes more visible as it beats other strategies by a significant gap. In real traces, max_degree and betweenness perform similarly while lcc_greedy and simple_greedy methods fluctuate in between. random_failure, unsurprisingly, remains the worst. We observe that even in big real networks, fast_greedy performs very well by degrading the ALCC dramatically (nearly 90%, 33% and 55% of ALCC decrement on ArXiv, NetHEPT and Facebook) as more nodes are excluded from the data. This fact implies that those practical systems, despite their complex structure and functionality, commonly expose their clustering vulnerability to targeted or adversarial attacks. Our proposed approach fast_greedy effectively discovers the critical nodes with high impact to those network structures. The results also demonstrate that simple_greedy and lcc_greedy are also good options though they require long execution time as we show below.

VIII-C Maximum Local Clustering Coefficient

We next examine the maximum local clustering coefficient (max-LCC) of nodes remaining in the residual graphs. This local measure is meaningful in the sense that a small max-LCC of a network indicates a low level of clustering. Therefore, we observe how the methods reduce the max LCC of the graphs. The results are reported in Fig. 6. The subfigures indicate that fast_greedy is really effective in not only degrading ALCC but also the max-LCC of all tested networks. In ER and BA models, fast_greedy quickly destroys the clustering coefficients at just 0.02% total nodes removed, and only lags behind lcc_greedy (which was expected to be the leading method) in WS model and Facebook. Furthermore, fast_greedy appears to be more stable than the others as it does not fluctuate between high and low values. In Facebook data, fast_greedy quickly degrades max-LCC values from 1 to approximately 0.5. This fact indicates that the resulting Facebook clusters and structure might not be very robust. In ArXiv and NetHEPT data, all methods are unable to degrade the LCC which demonstrates that there are a lot of local clusters in these networks.

VIII-D Running Time

The running time of all methods is presented in Fig. 7. As the baseline methods, random_failure and max_degree do not require much time for their execution due to their simple nature whereas lcc_greedy, in contrast, requires a considerable amount of execution time. fast_greedy and betweenness algorithms on average require fairly similar amounts of time for their tasks on all networks. simple_greedy, as a pay off for its simple design and implementation, takes a significant amount of time to finish its tasks (at least 5 times more than that taken by lcc_greedy) and is excluded from the charts for more visibility.

IX Conclusion

Clustering vulnerability is an important aspect in assessing the robustness of complex networks, as the level of clustering has significance for a variety of applications, including a salient role in the propagation of information in a social network. We have shown the discovery of the most important nodes to clustering is $NP$-complete,
and we offer two polynomial-time heuristics for this identification. Empirical results in comparison with different strategies on synthesized and real networks show that the average clustering coefficient is robust to failure of random nodes and confirm that our suggested algorithm FAGA (fast_greedy) is effective in analyzing node vulnerability of clustering and is scalable to larger networks.