Faster Approximation Algorithms for Parameterized Graph Clustering and Edge Labeling

Given an undirected graph $G=(V,E)$ the high-level goal of a graph clustering algorithm is to partition the node set $V$ into disjoint clusters in such a way that many edges are contained inside clusters, and few edges cross between clusters. These two goals are often in competition with each other, and there have been many different approaches for defining and forming clusters, all of which implicitly strike a different type of tradeoff between these goals. The LambdaCC clustering objective (Veldt et al., 2018) provides one approach for implicitly controlling this tradeoff using a resolution parameter $\lambda\in(0,1)$. Formally, given $G=(V,E)$ and parameter $\lambda\in(0,1)$, LambdaCC seeks a clustering that minimizes the following objective

where $\delta_{ij}$ is a binary cluster indicator for every node-pair, i.e., $\delta_{ij}=1$ if $i$ and $j$ are clustered together and $0$ otherwise. The number of clusters to form is not specified. Rather, the optimal number of clusters is controlled implicitly by tuning $\lambda$. Observe that the two pieces of the LambdaCC objective directly correspond to the two goals of graph clustering: the term $(1-\lambda)(1-\delta_{ij})$ for $(i,j)\in E$ is a penalty incurred if $i$ and $j$ are separated, and the term $\lambda\delta_{ij}$ for $(i,j)\notin E$ places a penalty on putting $i$ and $j$ together if they do not share an edge. The relative importance of the two competing goals of graph clustering (form clusters that are internally dense and externally sparse) is then controlled by tuning $\lambda$. Smaller values of $\lambda$ tend to produce a smaller number of (larger) clusters, and choosing large $\lambda$ leads to a larger number of (smaller) clusters.

One of the benefits of the LambdaCC framework is that it generalizes and unifies a number of previously studied objectives for graph clustering, including the sparsest cut objective (Arora et al., 2009), cluster editing (Shamir et al., 2004; Bansal et al., 2004), and cluster deletion (Shamir et al., 2004). It also is equivalent to the popular modularity clustering objective (Newman and Girvan, 2004) under certain conditions. The definition of modularity depends on underlying null distributions for graphs. When the Erdős-Rényi null model is used, modularity is equivalent to Objective (1) for an appropriate choice of $\lambda$. When the Chung-Lu null model is used, modularity can be viewed as a special case of a degree-weighted version of LambdaCC (Veldt et al., 2018), though we focus on Objective (1) in this paper. Finally, for an appropriate choice of $\lambda$, the LambdaCC objective is equivalent to graph clustering based on maximum likelihood inference for the popular stochastic block model (Abbe, 2018), which can be seen from LambdaCC’s relationship to modularity (Newman, 2016).

The CC in LambdaCC stands for correlation clustering (Bansal et al., 2004), a framework for clustering based on pairwise similarity and dissimilarity scores. In the most general setting, an instance of weighted correlation clustering is given by a set of vertices $V$, along with two non-negative weights $(w_{ij}^{+},w_{ij}^{-})$ for each pair of distinct vertices $i,j\in V$. If nodes $i$ and $j$ are placed in the same cluster, this incurs a disagreement penalty of $w_{ij}^{-}$ whereas if they are separated, a disagreement penalty of $w_{ij}^{+}$ is imposed. In correlation clustering, disagreements are also called mistakes. This terminology is especially natural when only one of the weights $(w_{ij}^{+},w_{ij}^{-})$ is positive and the other is zero (which is true for the most widely-studied special cases). In this case, each node pair $(i,j)$ is either “similar” ($w_{ij}^{+}>0$) and wants to be clustered together, or “dissimilar” ($w_{ij}^{-}>0$) and wants to be clustered apart. A mistake or disagreement happens precisely when nodes are clustered in a way that does not match this “preference.” Formally, the disagreements minimization objective for correlation clustering can be represented as the following integer linear program (ILP):

where $x_{ij}$ is a binary distance variable between nodes $i,j$, i.e., $x_{ij}=0$ means nodes $i$ and $j$ are clustered together, and $x_{ij}=1$ means they are separated. The most well-studied special case is when $(w_{ij}^{+},w_{ij}^{-})\in\{(1,0),(0,1)\}$. This is known as complete unweighted correlation clustering, as it is often viewed as a clustering objective on a complete signed graph where each pair of nodes either defines a positive edge or a negative edge. This is equivalent to the cluster editing problem (Shamir et al., 2004), which seeks to add or delete the minimum number of edges in an unsigned graph $G=(V,E)$ to partition it into a disjoint set of cliques. This is in turn related to cluster deletion, where one can only delete edges in $G$ in order to partition it into cliques. Cluster deletion is the same as solving Objective (2) when $(w_{ij}^{+},w_{ij}^{-})\in\{(1,0),(0,\infty)\}$ for every pair of nodes $(i,j)$.

Approximation algorithms. Correlation clustering is NP-hard even for special cases of cluster editing and cluster deletion, but many approximation algorithms have been designed (Ailon et al., 2008; Charikar et al., 2005; Chawla et al., 2015). Most of these algorithms rely on solving and rounding a linear programming (LP) relaxation of ILP (2), obtained by replacing $x_{ij}\in\{0,1\}$ with the constraint $x_{ij}\in[0,1]$. For the general weighted case, the best approximation guarantee is $O(\log n)$, which matches the integrality gap of the linear program (Charikar et al., 2005; Demaine et al., 2006). However, constant factor approximations are possible for certain weighted cases (Ailon et al., 2008; Veldt et al., 2020; Ailon et al., 2012). Ailon et al. (Ailon et al., 2008) designed a fast randomized combinatorial algorithm called Pivot for the complete unweighted case. This algorithm repeatedly selects a uniform random pivot node in each iteration and clusters it together with its unclustered neighboring nodes that share a positive edge. This algorithm comes with an expected 3-approximation guarantee. However, for general weighted correlation clustering, it can produce poor results.

Deterministic pivot. A derandomized version of the standard Pivot algorithm was developed by van Zuylen and Williamson (van Zuylen and Williamson, 2009), which can be applied to a broader class of weighted correlation clustering problems. Instead of randomly choosing pivot nodes, this technique relies on solving the LP relaxation of correlation clustering, constructing a derived graph $\hat{G}$ based on the solution to this LP, and then running a pivoting procedure in $\hat{G}$ that deterministically selects pivot nodes based on the LP output. They showed that this can produce a deterministic 3-approximation algorithm for the complete unweighted case, and can also be applied to other weighted cases including the case of probability constraints (where $w_{ij}^{+}+w_{ij}^{-}=1$ for every pair $\{i,j\}$). In proving these results, van Zuylen and Williamson presented a useful theorem (Theorem 3.1 in (van Zuylen and Williamson, 2009)) that can be used as a general strategy for developing approximation algorithms for other special weighted variants. We state a version of this theorem below, as it will be a useful step for some of our results. The original theorem includes details for choosing pivot nodes deterministically. The approximation holds in expectation when choosing pivot nodes uniformly at random.

Approximations for LambdaCC. The LambdaCC objective on a graph $G=(V,E)$ corresponds to a special case of Objective (2) where $(w_{ij}^{+},w_{ij}^{-})=(1-\lambda,0)$ if $(i,j)\in E$ and $(w_{ij}^{+},w_{ij}^{-})=(0,\lambda)$ if $(i,j)\notin E$. Veldt et al. (Veldt et al., 2018) previously showed a 3-approximation algorithm for the case where $\lambda\geq 1/2$, based on rounding the standard correlation clustering LP relaxation. However, because this LP has $O(n^{3})$ constraints for an $n$-node graph, in practice it is challenging to solve it for graphs with even a thousand nodes. Later, Gleich et al. (Gleich et al., 2018) proved that the LP integrality gap can be $O(\log n)$ for small values of $\lambda$. They also developed approximation guarantees for smaller values $\lambda$, but these get increasingly worse as $\lambda\rightarrow 0$. Faster heuristics algorithms for LambdaCC have also been developed (Veldt et al., 2018; Shi et al., 2021), but these come with no approximation guarantees. Thus, a limitation of this previous work is that existing LambdaCC algorithms either depend on an extremely expensive linear programming relaxation or come with no guarantees. The focus of our paper is to bridge this gap.

In social network analysis, the principle of strong triadic closure (Easley and Kleinberg, 2010; Granovetter, 1973) posits that two individuals in a social network will share at least a weak connection if they both share strong connections to a common friend. This has been used to define certain types of edge labeling problems where the goal is to label edges in a graph $G=(V,E)$ in such a way that this principle holds (Sintos and Tsaparas, 2014; Oettershagen et al., 2023; Grüttemeier and Komusiewicz, 2020; Grüttemeier and Morawietz, 2020; Adriaens et al., 2020).

Given a graph $G=(V,E)$ (which could represent an observed set of social interactions), a triplet of vertices $(i,j,k)$ is an open wedge centered at $j$ if the vertex pairs $(i,j)$ and $(j,k)$ are edges (i.e., in $E$) while $(i,k)$ is not. The strong triadic closure principle suggests that if such an open wedge exists, then either $(i,j)$ or $(j,k)$ is a weak edge, or else $(i,k)$ is a missing connection that should appear as an edge in $G$ but was not observed when $G$ was constructed. With this principle in mind, Sintos and Tsaparas (Sintos and Tsaparas, 2014) defined the strong triadic closure labeling problem (minSTC), where the goal is to label edges as weak and strong so that every open wedge contains as least one weak edge, and in such a way that the number of edges labeled weak is as small as possible. They showed that the problem is NP-hard but has a 2-approximation algorithm based on reduction to the Vertex Cover problem. They also considered a variation of the problem that allows for edge additions (minSTC+).

In our paper, we use $\mathcal{W}_{j}$ to denote the set of open wedges centered at $j$ in $G$, and let $\mathcal{W}=\cup_{j\in V}\mathcal{W}_{j}$. We use the term STC-labeling to indicate labeling of node pairs $(i,j)\in{V\choose 2}$ that satisfies the strong triadic closure in the following sense: for every open wedge $(i,j,k)$ centered at $j$, at least one of the edges $\{(i,j),(j,k)\}$ is labeled weak, or the non-edge $(i,j)\notin E$ is labeled as a missing edge. Such labeling is encoded by a collection of weak edges denoted as $E_{\mathit{weak}}\subseteq E$, as well as a set of missing edges denoted as $E_{\mathit{miss}}\subseteq({V\choose 2}-E)$. The minSTC+ problem seeks an STC-labeling $(E_{\mathit{weak}},E_{\mathit{miss}})$ that minimizes $|E_{\mathit{weak}}|+|E_{\mathit{miss}}|$. This can be formally cast as the following ILP:

If $z_{ij}=1$, this represents the presence of either a weak edge (if $(i,j)\in E$) or a missing edge (if $(i,j)\notin E$). This problem is also NP-hard but can be reduced to Vertex Cover in a 3-uniform hypergraph in order to obtain a 3-approximation algorithm.

While the strong triadic closure principle and the resulting edge labeling problems are of their own independent interest, we are particularly interested in these problems given their relationships with certain clustering objectives. The solution for minSTC is known to lower bound the cluster deletion objective, and minSTC+ similarly lower bounds cluster editing (Grüttemeier and Komusiewicz, 2020; Grüttemeier and Morawietz, 2020; Konstantinidis et al., 2018; Veldt, 2022). The LP relaxations for these problems, therefore, provide lower bounds for cluster deletion and clustering editing that are cheaper and easier to compute than the standard linear programming relaxations. Veldt (Veldt, 2022) recently showed how to round these LP relaxations—and how to round approximation solutions for minSTC+ and minSTC—to develop faster approximation algorithms for cluster editing and cluster deletion. We generalize these techniques in order to develop faster approximation algorithms for the full parameter regime of LambdaCC.

We present the first combinatorial algorithm for LambdaCC, called CoverFlipPivot (CFP), which provides a 6 approximation for every $\lambda\geq 1/2$. As outlined in Algorithm 2, CFP comprises three steps:

1. (1)

   Cover: Generate a feasible LambdaSTC labeling of $G$ by running the 3-approximate CoverLabel algorithm.

2. (2)

   Flip: Flip the edges in the original graph $G=(V,E)$ to create a derived graph $\hat{G}=(V,\hat{E})$, by deleting ‘weak’ edges $E_{\mathit{weak}}$ and adding ‘missing’ edges $E_{\mathit{miss}}$.

3. (3)

   Pivot: Run Pivot on the derived graph $\hat{G}$.

Before proving any approximation guarantees for CFP, we begin with a more general result that sheds light on the relationship between LambdaSTC and LambdaCC. This generalizes previous results showing that the optimal cluster deletion and minSTC objectives (and similarly, the cluster editing and minSTC+ objectives) differ by at most a factor of 2 (Veldt, 2022).

Algorithm 2 can be easily derandomized using the deterministic strategy for choosing pivot nodes for Theorem 2.1 (see (van Zuylen and Williamson, 2009)).

Algorithm 3 is an approximation algorithm for LambdaCC based on rounding the LambdaSTC LP relaxation. This LP has $|\mathcal{W}|$ constraints, whereas the canonical LP has $O(n^{3})$. In the worst case, it is possible for $|\mathcal{W}|=O(n^{3})$, but our experimental results demonstrate that $|\mathcal{W}|$ is far smaller for all of the real-world graphs we consider. Even more significantly, the LambdaSTC LP is a covering LP, which makes it possible to use fast existing techniques for approximating covering LPs. This leads to much faster algorithms, at the expense of only a slightly worse approximation factor since the LP is only solved approximately. The next section provides a more detailed runtime analysis.

Our approach for rounding the LambdaSTC LP follows a similar strategy as CFP, which involves building a new graph $\hat{G}$ and then running Pivot. The construction of $\hat{G}$ depends on the LP variables $\{x_{ij}\}$, the edge structure in $G$, and the value of $\lambda$. When $\lambda\geq 1/2$, we always ensure that a non-edge in $G$ maps to a non-edge in $\hat{G}$. For $\lambda<1/2$, we always ensure that an edge in $G$ maps to an edge in $\hat{G}$. We first prove that the algorithm has an approximation factor that ranges from $3$ to $5$ as $\lambda$ goes from $1/2$ to $1$.

Gleich et al. (Gleich et al., 2018) showed that for small enough $\lambda$, the canonical LambdaCC LP relaxation has an $O(\log n)$ integrality gap, but showed how to round that LP to obtain a $\frac{1}{\lambda}$-approximation, which is better than $O(\log n)$ for all $\lambda=\omega(1/\log n)$. These previous results rule out the possibility of obtaining an approximation better than $O(\log n)$ for arbitrarily small $\lambda$ by rounding the (looser) LambdaSTC LP relaxation. However, we can show that Algorithm 3 will still provide a $1+1/\lambda$ approximation, which is very close to the approximation factor obtained by Gleich et al. (Gleich et al., 2018) for rounding a much more expensive LP.