Related work

Grötschel and Wakabayashi formulated the CP problem as an integer linear program in 1989 [1]. In the past 30 years, a myriad of inexact algorithms has been proposed for the CP problem relying on heuristics and meta-heuristics such as simulated annealing [6], neighborhood search [7], iterated tabu search [8,9], and local search [10]. In 2021, Lu et al. [11] introduced a merge-divide memetic algorithm, which incorporates a merge-divide crossover operator along with simulated annealing-based local optimization and pool management. Their method uses a population-based approach to solve “challenging” CP instances, and is the first to have several complementary search components. According to their experiments, the algorithm has the ability to produce high-quality solutions, reporting improved best-known lower bounds for benchmark instances with 2000 nodes.

There are some applications of CP where optimization accuracy is not a concern because network instances are very large-scale. Named entity disambiguation is one such application from natural language processing which involves finding a cluster of candidates from a knowledge base which are likely to be the target of a name mentioned in a text [12]. In a recent study, Belalta et al. proposed a method for this task which heuristically solves a large-scale CP problem under the hood [12].

While heuristics and meta-heuristics are typically fast for small and mid-sized instances, their solutions have no guarantee of proximity to optimal solutions. Compared to them, there are fewer exact and approximation approaches proposed for solving the CP problem. In 2019, Simanchev et al. [13] introduced an exact branch-and-cut method tailored to two specific instances of the CP problem. They proposed a cutting-plane algorithm designed to explore facet inequalities, which was used to construct lower bounds, with special heuristics for searching for upper bounds. Their method is capable of finding optimal solutions for the two particular cases of the CP problem in a fair amount of time (within 3 hours) for networks up to 300 nodes. In 2023, Belyi et al. [14] estimated a tighter upper bound for the CP problem and combined it with a branch-and-bound algorithm to obtain exact solutions. Their method produced exact solutions faster than other existing methods at the time [14].

Some exact and approximation approaches rely on theoretical results from the polyhedral analysis of the IP formulations of the CP problem [15]. Letchford and Sørensen proposed a polynomial-time separation algorithm for finding the valid inequalities for CP [15]. In their more recent work, they proposed two families of new valid inequalities that can speed-up solving the IP models of CP [16]. Irmai et al. have recently generalized another family of valid inequalities for the CP problem [17]. For a detailed review of the literature on CP models and their performance, we refer the reader to [18]. A detailed dichotomy of clique-based partitioning problems is provided in [19].

Our contributions

In this study, we propose a method for approximating the optimal solutions of the CP problem. Our proposed approximation algorithm, named Troika, delivers solutions with guaranteed proximity to the optimal solution. Troika solves integer programs by node triple branching. This type of branching was proven useful [20] for dealing with constraints that involve triples. These constraints are called transitivity constraints and are a common challenge among Integer Programming (IP) models for clustering problems [5,14,21].

The main focus of this study is on developing an exact and approximation approach for solving the CP problem on small and mid-sized networks of practical relevance. Our proposed method pushes the practical limits on solving the CP problem on ordinary computers as demonstrated by comprehensive results on multiple benchmark datasets. While approximating an NP-hard optimization problem cannot possibly scale to large networks, the design of our method offers a key advantage over existing heuristics: it guarantees solution quality in the form of a user-specified optimality gap tolerance. In simpler terms, it allows the user to specify, in advance, their tolerance for the potential optimality gap of the partition. Compared to alternative exact methods, our method offers the advantage of having better time-quality speed-up: given the same time limit, it offers partitions closer to the optimal; and given the same optimality gap tolerance, it converges faster. We conduct extensive experiments to demonstrate the applicability of our proposed method on CP instances and two other use cases. As two side discussions, we analytically demonstrate the connections that convert a modularity maximization instance [22] and a correlation clustering instance [23] into a CP instance and show how Troika compares to eight modularity-based algorithms.

The technical background is outlined in Sect 2. The Troika algorithm is explained in Sect 3. Sect 4 provides comparative analysis results for Troika on five datasets demonstrating its practical advantages over the existing methods. Sect 5 discusses a use-case in community detection and demonstrates the advantages of Troika over eight modularity-based algorithms. Sect 6 deals with the applicability of Troika for portfolio analysis. The main results are discussed in Sect 7. Finally, materials and methods are provided in Sect 8.

2.1. Problem statement

The clique partitioning problem [1] for the graph is defined below. Given graph G and partition X, the weight (the sum of within-cluster edge weights) of the partition is computed according to Eq (1).

(1)

In the CP problem, we look for an optimal partition: a partition whose weight is maximum over all possible partitions: . Any partition of G that is not an optimal partition is a sub-optimal partition.

2.2. Integer programming formulations

The CP problem can be formulated as the IP model [1] in Eq (2).

(2)

In Eq (2), the optimal objective function value equals the optimal weight (maximum within-cluster weight) for the input graph G. An optimal partition is characterized by the optimal values of the x_ij variables. T indicates the set of all unique node triples for graph G. The 3 constraints defined for each triple in T are called transitivity constraints. They are a common challenge of network clustering problems formulated as integer programs [5,14,21].

The computational complexity of the classic formulation in Eq (2) becomes impracticable for large networks due to the voluminous number of constraints, scaling as which is [24]. The formulation in Eq (2) comprises numerous redundant constraints. The redundant constraints [24] are as follows:

The classic formulation of the problem [1] in Eq (2), can be strengthened by using negative edges for removing the redundant constraints [24]. The redundancy of these constraints is due to the pressure from the maximization objective function. After removing the redundant constraints [24] and applying other simplifications [21], we arrive at the model RP^*(G) as in Eq (3).

(3)

In the formulation which is proposed by [21], the set T is replaced by the subsets which are defined as follows:

(4)

The optimal solution from is required to go through a linear-time () post-processing step, called pp and described in [21], to ensure that an optimal solution has been obtained. This post-processing step ensures the solution found from solving the formulation does not violate the transitivity constraints in the classic formulation in Eq (2). Miyauchi et al. [21] demonstrated that the formulation combined with the pp post-processing step is a more efficient approach for solving the CP problem compared to solving the classic formulation [1] in Eq (2). In recent years, several attempts have been made for obtaining more efficient IP formulations for CP [4]. Koshimura et al. have proposed two new IP formulations with fewer constraints than . Like , both new models require a post-processing step to ensure that the optimal solution represents a feasible partition. Numerical results suggest that these two new formulations are only sometimes faster than RP^* [4]. Therefore, we use as the base IP foundation on which we build the Troika algorithm.

Despite the efficiency gain in using , this strengthened formulation does not fully take advantage of the structural characteristics of the input graph. We address this shortcoming in formulation by using the graph structure for developing pre-processing steps (discussed in Sect 8).

3.1. The branch and cut implementation

The feasible space of the formulation in Eq (3) is defined by constraints on node triples. Consider to be the union of the subsets defined in Eq (4). is the relevant set of node triples over which the transitivity constraints from [21] are defined. Given a node triple, , the three transitivity constraints are equivalent to the logical disjunction of Eqs (5) and (6).

(5)

(6)

Unlike Bayan, Troika starts by obtaining one lower bound and one upper bound before forming any IP models. The upper bound is obtained using the method proposed by Belyi et al. in [14]. The lower bound is obtained using the CP version of the Combo algorithm [25] (from the Python library PyCombo [26]). Combo is a heuristic network optimization algorithm that can be reconfigured to solve the CP problem. Solving the natural LP relaxation (resulted from dropping the integrality constraints) of the IP model [21] provides an additional upper bound. The minimum of the two upper bounds is used as the tight upper bound for starting the branch-and-cut scheme. Note that we have used the Gurobi LP solver [27] for solving all the LP models involved within the Troika algorithm.

At the root node, if the two bounds differ more than the optimality gap tolerance (as explained in Sect 3.2), the algorithm does not terminate. It selects a triple of nodes whose corresponding values (from the LP solution) violate both Eqs (5) and (6). Adding each of the violated constraints Eqs (5) and (6) forms a cut to the root node problem and divides the problem into left and right sub-problems. Recursively, for each of the two sub-problems, Gurobi LP and Combo are used to obtain an upper and a lower bound. This recursive process creates a search tree where node triples are used for branching.

Within Troika and after branching on the node triple (i,j,k), we use additional techniques to obtain the lower bound in the right and left branch respectively, to speed up the convergence. In the search for lower bound in the right branch, the pre-defined value δ is subtracted from the edge weights associated with nodes i, j, k. This adjustment can enhance the likelihood of identifying heuristic solutions that adhere to the constraint on the right branch. The δ value is set to be the absolute value of the median of all edge weights within the graph. This choice of value can ensure that the edge weights associated with nodes i, j, k get small enough to deter the Combo algorithm from grouping those triples together. This alteration does not ensure the compliance of the heuristic solution with the constraint in Eq (6); however, such compliance is not a prerequisite for Troika’s convergence to optimality.

Conversely, the constraint is added to the left sub-problem in the branching process. The associated nodes i, j, k are grouped together and represented by the supernode ijk. This supernode gets connected to all neighbours of i, j, k. The edges between the three nodes are conserved as a weighted self-loop on the supernode ijk. This ensures the Combo algorithm groups the node triple together in the returned partition, adhering to the constraint in the left sub-problem. The branching process is a key component among several other components of the Troika algorithm which are discussed in Sect 8 where a schematic representation of the Troika algorithm is also provided as a flowchart.

Exploration of search tree continues through branching on new triples whose LP solution violates both Eqs (5) and (6). After completing the computations of all Branch and Bound (B&B) nodes at a given level of the search tree, Troika determines the incumbent and the best bound. The incumbent is chosen as the higher value between the best heuristic solution and the best integer solution discovered during the search. The highest upper bound value from the level is recorded as the best bound. During the branching process, a B&B node is considered fathomed under three circumstances: when the LP solution turns integral; when the LP becomes infeasible; or when the LP objective function value falls below the current incumbent. Under these conditions, further branching from the B&B node is halted, and it is subsequently closed.

3.2. Search termination criteria

Troika is designed with two search termination criteria that grant users the flexibility to choose between computational efficiency and the precision of solutions. These criteria include optimality gap tolerance and solve time limit.

During the search process, Troika aims for the convergence of the best bound and incumbent to identify globally optimal solutions. This convergence is indicative of the exactness of the solution as per the branch-and-cut method, demonstrating the algorithm’s capability to deliver globally optimal results under a stringent criterion for the optimality gap tolerance.

Alternatively, one can use a larger optimality gap tolerance to obtain an approximate solution efficiently. The optimality gap, denoted by g, is the percentage difference between the current incumbent, i, and the best bound, b, according to the equation . The optimality gap tolerance is a user-specified threshold for the acceptably low optimality gap to terminate the search. Using an optimality gap tolerance of makes Troika an α-approximation algorithm for CP and terminates it once the solution gets within the proximity of the optimal value.

Furthermore, the criterion of solve time limit defines a maximum duration for the search process. This criterion is particularly suitable for scenarios where timely results are desirable. Additional technical details about the Troika algorithm are provided in Sect 8.

4.1. Comparisons on ABR benchmarks

Some early works on the CP problem were based on modeling and solving CP instances in the context of qualitative data analysis [1,3]. This context of the CP problem is known as “Aggregation of Binary Relations into an equivalence relation" (ABR). One instance of the problem is denoted through z “objects", each possessing q qualitative “attributes". These objects, along with their attribute values, can be organized into a matrix, with each element representing the value of attribute v for object i [29]. For every pair of objects and for each attribute v, the following binary constant is defined:

The similarities between objects i and j regarding the q attributes are then quantified through the edge weight − q [1]. In the case of missing values, some adjustments (using the approach from [30]) were made to create the weighted graphs as discussed in [29].

The 26 ABR test instances that we use from [29] consist of real-life use cases of the ABR from the literature [30–32]. They feature node counts n ranging between 30 and 797, with edge counts m ranging from 381 to 306,915. Most instances are deemed as “easy" and with four classified as “non-trivial" and one as “challenging" [29]. Next, we present the performance results for each of the three methods on the 26 ABR instances.

Fig 1 provides a comparison between the three methods based on EOS and solve time. Fig 1(a) shows that most ABR instances are solved to global optimality by these methods because EOS is zero for them. For the few instances where EOS is not zero, the difference in solution quality between Troika and Gurobi IP is substantial. Fig 1(b) indicates that Combo expectedly has the lowest median solve time on the ABR dataset followed by Troika and Gurobi IP respectively. Troika and Combo arrive at optimal solutions in 23 out of 26 ABR instances. Gurobi IP reached the globally optimal solutions in only 18 instances though.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. Two comparative performance measures for the three methods Troika, Combo, and Gurobi IP on the ABR benchmark dataset: (a) Extent of sub-optimality, (b) solve time.

https://doi.org/10.1371/journal.pcsy.0000062.g001

More detailed results on objective values and solve times are provided in S1 Table (in the supporting information). An important distinction is observed in the “lecturers” instance, where Gurobi IP reaches the time limit and returns a substantially inferior partition compared to Troika and Combo. Additional experiments showed that Gurobi IP fails to converge for the “lecturers” instance within a four-hour limit. As shown in Fig 1(a), the optimal partition of this instance is unattainable by Troika and Combo as well, while they produce partitions with orders-of-magnitude lower EOS compared to Gurobi IP. Besides Troika producing higher quality solutions, the time columns of S1 Table (in the supporting information) demonstrate that Troika is faster than Gurobi IP in 23 out of 26 ABR instances.

The quality of partitions produced by Combo and Troika is comparable for the ABR instances. Combo is particularly faster than Troika for the “hayes-roth”, “lecturers”, and “soup” instances because the extra computations of Troika (to ensure the optimality gap tolerance is met) take substantial time. Among these 26 instances, the mean solves times for Troika, Gurobi IP, and Combo are 22.53, 56.59, and 11.37 seconds, respectively, illustrating that Troika, on average, executes over 2.51 times faster than Gurobi IP and around 1.98 times slower than Combo, on average.

4.2. Comparisons on equicut benchmarks

Some benchmark instances of [29] are derived from the equicut problem. The “equicut” or “equipartition” problem is similar to the CP problem, but has the additional constraint that the partition must be a partition of two clusters of equal or almost equal size. Sørensen and Letchford used the instances from the equicut literature that had negative edges and defined CP instances based on them by removing the cluster count and cluster size restrictions [29].

We solve ten challenging and non-trivial equicut benchmark instances using the three methods. They have 50 nodes, except the last instance which has 60 nodes. Fig 2 shows EOS and solve time for each method on the ten equicut benchmark instances. Error bars in Fig 2(a) show one standard deviation for EOS values obtained over three runs for each algorithm. Fig 2(a) shows that the partitions of Combo for nine out of ten equicut instances get improved by the extra work that Troika does. On five instances, Troika has a better (lower) average EOS compared to Gurobi IP. Fig 2(b) shows that satisfying the optimality gap tolerance of 0.05 on these instances requires extra work from Troika or Gurobi IP that is substantially more time-consuming than obtaining a single heuristic solution from Combo.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. Two comparative performance measures for the three methods Troika, Combo, and Gurobi IP on the equicut benchmark dataset: (a) Extent of sub-optimality, (b) solve time.

https://doi.org/10.1371/journal.pcsy.0000062.g002

4.3. Comparisons on correlation benchmarks

A set of new benchmark instances proposed in [29] are called correlation benchmarks. These benchmarks are produced based on two steps: (1) creating a matrix with uniformly random entries from the unit interval, (2) defining the weighted edge (i,j) to be the correlation coefficient between columns i and j of the matrix.

We solve 20 challenging and non-trivial correlation instances using the three methods. The instance name denotes the number of nodes. Fig 3(a) shows that the partitions from Troika have much lower EOS compared to the two other methods on almost all these 20 instances. Fig 3(b) shows Troika median solve time to be higher than that of Gurobi IP on these instances; this is justifiable by the higher quality solutions that Troika produces compared to Gurobi IP parametrized with the same time limit and optimality gap tolerance.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 3. Two comparative performance measures for the three methods Troika, Combo, and Gurobi IP on the correlation benchmark dataset: (a) Extent of sub-optimality, (b) solve time.

https://doi.org/10.1371/journal.pcsy.0000062.g003

4.4. Comparisons on clusedit benchmarks

Another set of CP benchmarks from [29] are defined based on the “cluster editing" (clusedit) problem. This problem, also known as the “correlation clustering" problem [33], is defined on a signed graph . The edges in the set E⁻- all have the weight of -1 (are negative edges) and the edges in the set E⁺ all have weight of +1 (are positive edges). The correlation clustering problem is the task of finding a partition of nodes into any number of clusters to minimize the total count of intra-cluster negative edges and inter-cluster positive edges. To convert instances of this problem to CP instances, Sørensen and Letchford have defined the task of maximizing the sum of within-cluster edge weights for clusedit instances that have 20% to 60% negative edges.

We solve 12 challenging and non-trivial instances of these clusedit benchmarks using the three methods. The instance name denotes the number of nodes followed by the fraction of negative edges. Fig 4(a) demonstrates that Troika substantially improves the partitions from Combo, but rarely have better EOS compared to the partitions from Gurobi IP. Fig 4(b) shows Troika to have some relative advantages in terms of solve time compared to Gurobi IP on the clusedit benchmarks.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 4. Two comparative performance measures for the three methods Troika, Combo, and Gurobi IP on the clusedit benchmark dataset: (a) Extent of sub-optimality, (b) solve time.

https://doi.org/10.1371/journal.pcsy.0000062.g004

The results provided in Figs 2–4 show that for non-trivial and challenging instances across four benchmark datasets, Troika consistently returns partitions with objective function values that are closer to the globally optimal solutions compared to the Combo heuristic. This result is expected given the design of the Troika algorithm which relies on Combo for lower bounds and does some extra work for improving those partitions. Note that the descriptive comparisons provided in Figs 2–4 are not all statistically significant because some performance differences between these algorithms are marginal as shown in the error bars in Figs 2–4. While running Combo is considerably faster than Troika, the extra time that Troika spends leads to obtaining higher quality partitions as illustrated in Figs 2–4. While the results showed that generally Troika has some advantage in solution quality and/or time compared to Gurobi IP; there are some instances on which Gurobi IP outperforms Troika.

4.5. Comparisons on Barabási Albert graphs

Besides instances from four datasets of [29], we create random weighted graphs based on the Barabási-Albert (BA) graph generation process [34]. We use them for evaluating Troika on graphs that mirror real network structures. The Barabási Albert process grows the network through preferential attachment [34], which mirrors the heterogeneous connectivity inherent in some real-world networks, such as social, technological, and biological systems [35]. The BA graphs are reflective of certain real-world contexts where preferential attachment is a reasonably realistic model despite its simplicity.

We generate 20 BA graphs to test all the three methods under varying time restrictions. These graphs are generated with the number of nodes n sampled from the discrete uniform distribution of [100,150]. For the number of edges to attach between a new node and existing nodes, the discrete uniform distribution of [3,6] was used. Finally, each edge was assigned a random weight from the discrete uniform distribution of [–10,10]. The data for these 20 BA networks are available in a FigShare repository [36]. Before running our comparison between the three methods, we obtain the globally optimal partitions of these instances by solving the RP^* formulation using the Gurobi solver parametrized with an optimality gap tolerance of 1e–5. Then, we use the optimal values for calculating EOS for the three methods. Unlike Sects 4.1–4.4, we define three experiment settings for assessing the three methods on these BA instances. The three experiment settings correspond to the time limits of 1, 10, and 60 seconds consistently used for the methods.

In Fig 5, we observe that Troika consistently improves solutions from Combo on these 20 BA instances. We also see that this improvement increases as the time limit increases from 1 to 10 and then to 60 seconds. On a few instances, Troika’s partition is the same as Combo’s partition; this is because the optimality gap of Combo’s partition is below 0.05 and therefore Troika terminates without further attempting to improve the partition. Note that the top whiskers for the boxplots of Troika show that its solve time exceeds the time limit in some cases. This marginal breach of the time limit is due to the graceful termination of Troika which is only possible after each branching step is complete.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. Extent of sub-optimality and solve time for the three methods Troika, Combo, and Gurobi IP on the BA instances.

https://doi.org/10.1371/journal.pcsy.0000062.g005

Across the three time limit settings, Troika’s EOS is lower than Combo’s in around half of the BA instances. This indicates that even a split second of additional time gives Troika the potential to produce a better solution than Combo. Fig 5 shows that the median solve time of Troika is lower than that of Gurobi IP across the three time limit settings. Taken together with the consistently lower EOS values of Troika in Fig 5, we see that Troika outperforms Gurobi IP in both time and solution quality on almost all BA instances. Note that for very few BA instances, Gurobi IP terminates faster than Troika, but typically with a partition that has higher EOS.

The comprehensive results provided in Figs 1–5 show the practical advantages of Troika over two existing alternatives for obtaining approximate solutions for the CP problem. In Sect 5, we investigate the applicability of Troika for another use case: community detection.

5.1. The modularity maximization problem

Given the NP-hard nature [22] of the modularity maximization problem, most modularity-based community detection algorithms are heuristics. We discuss solving the CP problem by the Troika algorithm as an indirect method for community detection through approximating maximum modularity.

The modularity function is directly extendable to graphs that have nonnegative edge weights. Therefore, we define the Modularity Maximization (MM) problem [5,22] for the simple (unsigned but generally weighted) graph whose edge weights are nonnegative (). The modularity matrix of graph G is represented by whose entries are . The resolution parameter for the modularity function [41] is denoted by γ. Without loss of generality, we use .

Given partition X (defined earlier in Sect 2), for a pair of nodes (i,j), their cluster assignment is same (represented by x_ij = 0) or different (represented by x_ij = 1). Given weighted graph G and partition X, the modularity of the partition is computed according to Eq (7).

(7)

In the modularity maximization problem, we look for a partition whose modularity is maximum over all possible partitions:

5.2. Converting an MM instance into a CP instance

The feasibility space of MM and CP problems is the same: all possible partitions of the input graph nodes into non-overlapping clusters. In CP, only the edges () contribute to the objective function if they become internal edges (x_ij = 0). In MM, every pair of nodes (including pair of nodes without an edge) that have contributes to the objective function if they are assigned to the same cluster (x_ij = 0). Therefore, as long as the input graph is not a complete graph, an IP instance of MM on the graph has more decision variables compared to a CP instance of the same graph. MM requires a decision variable for node pairs with compared to CP which requires a variable for node pairs with . Therefore, it is expected that solving an instance of MM on the non-complete graph G will be harder compared to solving an instance of the CP problem on a non-complete graph with the same number of nodes.

Solving the MM problem on graph that has a modularity matrix B is equivalent to solving the CP problem for graph whose weight matrix equals B. Therefore, an instance of the MM problem on graph G can be converted into an instance of the CP problem for graph through using the weight matrix based on the formula . This implies that algorithms for solving the CP problem (including Troika) are also capable of solving the modularity maximization problem. Beside modularity maximization, the Troika algorithm also solves two other fundamental graph clustering problem as discussed in Sect 8.5.

5.3. Baselines, data, and measures

We compare Troika with eight modularity maximization algorithms (baselines). These eight algorithms are (1) Clauset-Newman-Moore (CNM) [42], (2) Louvain [43], (3) Belief [44], (4) Paris [45], (5) Leiden [46], (6) EdMot [47], (7) Combo for MM [25], and (8) graph neural network (GNN) [48]. For algorithms (1-6), we use their Python implementation from the Community Discovery library (CDlib) version 0.2.6 [49]. To access (7) Combo for MM, we use the Python library PyCombo [26]. For the GNN algorithm, we use its Python implementation (the GNN-100 variation) from its public GitHub repository referenced in [48].

For this comparison, we consider 100 networks comprising 53 real networks from a wide range of contexts, and 47 structurally diverse synthetic networks. The data for all these 100 networks are available in a FigShare repository [36]. The 47 synthetic networks are produced based on the graph generation models known as Lancichinetti-Fortunato-Radicchi (LFR) [50] and the Artificial Benchmark for Community Detection (ABCD) [51]. They include 20 LFR networks with small mixing parameter values and 27 ABCD networks with small mixing parameter values . The choice of using small mixing parameters ensures that these 47 synthetic networks have modular structures.

Our extent of sub-optimality measure, , is applicable in the context of modularity maximization as well. We use it to compare Troika to the eight MM algorithms based on solution quality. In cases where an algorithm returns a partition with a non-positive modularity value, we set EOS = 1 to facilitate easier interpretation of proximity to optimality based on non-negative EOS values.

5.4. Results on Troika for modularity maximization

Fig 6 shows the EOS for the partitions produced by nine algorithms including Troika, all of which aiming to maximize modularity. Among the nine algorithms, four algorithms have the best median performance indicated by a median EOS of zero: Troika, Combo (for MM), Leiden, and GNN. Among these algorithms, Troika has the lowest mean EOS. On these 100 networks, Troika returns globally optimal solutions for 88 networks. The median and mean of EOS for all algorithms are provided in S2 Table (in the supporting information). The results in Fig 6 demonstrates that Troika can be reliably used to partition unsigned networks by approximating maximum modularity. In Sect 6, we move on to demonstrating a different use case of Troika: portfolio analysis.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 6. The boxplot of each algorithm illustrates the extent of sub-optimality for their partitions on the 100 real and synthetic networks.

https://doi.org/10.1371/journal.pcsy.0000062.g006

6.1. Creating weighted networks from correlations of returns

For each year between 2000 and 2024, we create a weighted network from the correlation matrix of the constituents (individual stocks within the S&P 500). Almost all pairs of stocks have a non-zero correlation coefficient. Therefore, using all correlation coefficients as edge weights produces a complete graph without any particular structure. We create edges from correlations that are statistically significantly high (in absolute terms) using critical points of a normal distribution -2 and +2 (for the conventional significance threshold of 0.05). However, correlations data are often not normally distributed. Therefore, a transformation is required before using standard normal theory [52]. The Fisher transformation of correlation coefficients yields a variable that is approximately normally distributed [52]. The Fisher transformation takes the correlation coefficient r_ij corresponding to the stock i and j and returns . After the transformation, the distribution of transformed values z_ij for each year can be used to decide which pairs have strong positive or strong negative correlations. We create an edge (i,j) with the weight of r_ij for each transformed variable z_ij that differs from the mean z value by more than 2 standard deviations. The data for these 25 financial networks are available in a FigShare repository [36].

6.2. Troika’s results on portfolio networks

In these networks, individual stocks are represented as nodes, and strong positive or strong negative correlations between them as weighted edges. We run Troika on these networks and obtain their globally optimal partitions in seconds per network. Using the optimal partitions returned by Troika on each network, we evaluate the changes in the clusters inferred from correlations of returns within the S&P 500 index over 24 years.

The analysis of the optimal partitions produced by Troika on these networks reveals the dynamics in the structure of a major part of the US stock market over time. S3 Table (in the supporting information) provides detailed results on the cluster size and the number of clusters for the partitions of the S&P 500 networks obtained by the Troika algorithm. The optimal partition for each network is visualized in Fig 7 where clusters are shown using different node colours. The optimal partition for the year 2000 has 11 clusters (of positively correlated stocks) and an average cluster size of 13.54 nodes per cluster. In the three years leading to the 2008 financial crisis, we observe the number of clusters monotonically decreasing from 12 to 1 while the average cluster size monotonically increases from 16.3 to 294. In the network for year 2008, all edge weights are positive (from the consistently negative returns for most stocks). This causes the optimal partition to become the trivial solution in which all nodes belong to a single cluster. Such an unusual optimal partition structure is only observed for the year 2008 when the most severe economic crisis of the contemporary era impacted the US stock market. The results in Fig 7 show that Troika can handle these portfolio networks and provide optimal solutions that reveal patterns from financial correlation data modeled as networks.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 7. The respective partitions returned by Troika for the networks of S&P 500 market index from 2000 to 2024.

Red and blue edge colours represent negative and positive correlations respectively. Different node colours represent the major clusters. Magnify the high-resolution figure on screen for the details.

https://doi.org/10.1371/journal.pcsy.0000062.g007

Moving on to the more recent time, the optimal partitions also show a structural shift during the COVID-19 pandemic. In the year 2019 (and before the pandemic started), the network had 348 nodes and was predominantly characterized by one major cluster comprising 283 stocks and the rest scattered among 10 substantially small clusters. The optimal partition shows that the returns from the 283 stocks were overall positively correlated while there were 65 stocks in the network whose returns had different patterns and therefore created 10 separate clusters. The structure of the optimal partition goes through a major change in 2020, where a single dominant cluster emerges, consisting of over 97% of the stocks (298 out of the total 306 stocks), a change possibly attributable to the market’s reaction to the global pandemic conditions at the time. The year 2021 saw a reversion to a structure somewhat reminiscent of the 2019 structure, showcasing 13 clusters with one predominant cluster housing 292 constituents. By 2023, the optimal partition had changed into five clusters, with two primary clusters comprising 189 and 231 constituents, respectively. Except for the years 2008 and 2020, multiple major clusters exist in all optimal partitions distinguishing years of financial downturn (visible with distinct node colours in Fig 7).

In summary, the optimal partitions obtained by Troika allow us to infer clusters from correlations which in turn highlight the temporal changes of a portfolio or market index over the years. Compared to the network of a portfolio with one cluster encompassing all the network (the year 2008) or almost all the network (the year 2020), the observed presence of multiple sizable negatively correlated clusters is interpretable as a balanced portfolio with diverse sectors which offer opportunities for hedging against sector-specific risks.

8.1. Graph pre-processing

Troika leverages two graph pre-processing steps: pendant clique and node reduction, and component-wise processing for disconnected graphs.

8.1.2. Pendant cliques and node reduction.

Additionally, the Troika algorithm benefits from recognizing specific structural patterns, such as pendant nodes and cliques, to expedite feasible space exploration. In any optimal solution, each pendant node (i.e. node incident on precisely one edge) that has a positive degree, always belongs to the same cluster as its sole neighbour. We transform the original graph G into a reduced graph where each positive-degree (d_i>0) pendant node i is replaced with a self-loop at the neighboring node with a weight of d_i. The weight of the self-loop reflects the contribution of the reduced positively weighted edge to the optimal objective function value. If the edge weight is negative, a separate cluster is created for the pendant node to be later appended to the output partition. Pendant node reduction is illustrated in Fig 9.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 9. (a) Pendant node 4 is positively connected to its sole neighbor node 0.

(b) After reduction, node 4 and its edge are replaced with a self-loop at node 0 that has the same weight as the edge (0,4).

https://doi.org/10.1371/journal.pcsy.0000062.g009

Cliques are defined as complete sub-graphs with all internal edges bearing positive weights. Considering a node to be a 1-clique, the pendant node reduction idea can be generalized to reductions for pendant cliques of arbitrary size s. An s-clique is pendant if all its nodes are incident on s–1 edges, except one node that is incident on s edges. The exceptional node is called a connector. Pendant cliques can be replaced by a self-loop on the connector node whose weight accounts for the contribution of the clique to the optimal objective function value. So, each pendant clique (of any size) can be condensed into a self-loop on the corresponding connector node, ensuring the allocation of all nodes of the clique to the same cluster. Pendant clique reduction is shown in Fig 10. This pre-processing step may substantially reduce the number of variables and constraints in the optimization models within the Troika algorithm. An alternative and more general pre-processing approach for CP is discussed in [56].

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 10. (a) Input graph G with two distinct positive cliques: the first comprising nodes 0, 1, and 2, and the second consisting of nodes 3, 4, and 5.

(b) The post-reduction graph , where each of the two cliques is replaced with a self-loop at their corresponding two connector nodes 0 and 5. Weights of each self-loop equals the sum of positive weights of the clique that it has replaced.

https://doi.org/10.1371/journal.pcsy.0000062.g010

8.2. Variable fixing

Troika utilizes a variable fixing technique to solve the IP faster. Variable fixing can be used to determine the definitive value of certain variables at a point in the branch and cut process and for all subsequent LPs. Specifically, a binary variable x_ij can be fixed to either zero or one when its reduced cost surpasses a certain threshold in the current LP’s optimal solution. Suppose x_ij is set to zero with a reduced cost of c_ij, in an optimal LP solution, where the optimal objective function value is denoted as . It is observed that c_ij takes a negative value when x_ij is at its lower bound (i.e., zero). Let LB represent the objective value of the incumbent solution within the B&B search tree. It is deduced that any feasible solution with x_ij = 1 will have an objective value not exceeding . Consequently, x_ij is fixed to zero if . Conversely, c_ij will be positive if x_ij is at its upper bound (i.e., one), prompting us to fix x_ij to one if .

Upon applying these conditions to fix variables, Troika proceeds to determine the states of additional variables through logical deductions. For instance, if nodes i and j belong to the same cluster (x_ij fixed to zero) and nodes k and j do not share the same cluster (x_jk fixed to one), it logically follows that nodes i and k must be in different clusters, leading to x_ik being fixed to one. This logical implication is formalized as follows:

(8)

8.3. Implied branching and fixing

We further explore the synergies between branching and variable fixing to increase the convergence speed of the algorithm. By drawing logical conclusions from the states of fixed variables and the already established branching cuts, further variables can be fixed and additional cuts can be introduced to enhance the separation in both the right and left branches of the B&B tree [20].

Consider a scenario in the right branch where the constraint , pertaining to the triple (i,j,k), has been added to the LP formulation. Suppose there exists a fixed variable related to one of these nodes, for instance, x_ip = 0. This precondition enables the introduction of a novel cut into the LP model as follows:

(9)

Similarly, in the context of a left branch, consider the constraint has been added to the LP model. If a variable x_ip, associated with one of the nodes in the triple (i,j,k), is fixed, two more variables can be fixed as illustrated below:

(10)

(11)

The integration of logical inferences with variable states serves a dual purpose: it not only simplifies the process of fixing variables but also supports the creation of strategic cuts. This dual functionality considerably accelerates the Troika algorithm.

8.4. Triple selection for branching

Troika attempts to select the best triple for branching, facilitating an earlier detection of infeasibility, and enabling more variable fixing opportunities.

During each search iteration, the algorithm first identifies all triples that violate the two constraints in Eqs (5) and (6). Subsequently, it prioritizes certain triples for further evaluation based on their respective edge weights. Specifically, as defined in Sect 3.1, we introduced as the union of the subsets , , and , over which the transitivity constraints are defined. Moreover, can be partitioned to where

• T₃ denotes the triples that precisely have three strictly positive edge weights,
• T₂ denotes the triples that precisely have two strictly positive edge weights, and
• T₁ denotes the triples that precisely have one strictly positive edge weight.

The Troika algorithm adopts a structured approach for triple selection, starting with the triples in T₃. It only proceeds to select triples from T₂ after all triples in T₃ have been utilized. Similarly, selection from T₁ commences only after all triples in T₂ are exhausted. The selection of the best triple from the chosen subset is then guided by three key B&B-node-specific factors: (1) the greater overlap between its nodes with those in the triples already used for branching, (2) the count of its associated fixed variables, and (3) the absolute degree of its nodes. A binary indicator, , is assigned the value one if node i is included in any branching triples of the parent nodes. The quantity of fixed variables linked to node i is represented as f_i. For every node i, possessing a degree d_i, we compute a score s_i according to Eq (12), incorporating , f_i, and d_i to address the three outlined criteria.

(12)

The collective score for a triple (i,j,k) is calculated as the sum of s_i, s_j, and s_k. Selection of a triple for branching is then carried out using a roulette wheel selection mechanism based on the calculated scores of the candidate triples.

8.5. Troika also solves the correlation clustering problem

The Troika algorithm also solves another fundamental graph clustering problem that can be defined on weighted graphs: the Correlation Clustering (CC) problem [23]. In the MaxAgree version of the correlation clustering problem with the input , we look for a partition X that corresponds to the maximum value for the objective function: sum of within-cluster positive edge weights plus the sum of absolute values of between-cluster negative edge weights. This objective function simplifies to:

(13)

(14)

(15)

(16)

The rightmost term in Eq (16) is a constant function of G and does not depend on the partition X. The other term in Eq (16) is the objective function of the CP problem. Therefore, any optimal partition of CP for input is also an optimal partition for the MaxAgree CC problem [, Lemma 1]. This reduces the MaxAgree CC problem to a CP problem. Maximum agreement of G equals its maximum sum of within-cluster weights plus the constant .

Another version of the CC problem is the MinDisagee correlation clustering [23]. Its objective function is minimizing the sum of absolute values of within-cluster negative edge weights plus the sum of between-cluster positive edge weights. MaxAgree and MinDisagree CC are equivalent in the sense that one is a linear transformation of the other [57] and the two problems have the same optimal partitions. This can be explained by the observation that agreement and disagreement objective functions for any partition add up to a constant value (the sum of absolute values of weights). Given this equivalence, Troika also solves the MinDisagree correlation clustering problem.

Note that in some alternative definitions of the correlation clustering problem [58], every pair of nodes (i,j) has two nonnegative weights: a similarity weight and a dissimilarity weight . In such a case, the edge weights for the input graph can be obtained according to [57].

8.6. Accessing the Troika code and the network data

A Python implementation of the Troika algorithm is publicly available on GitHub https://github.com/saref/troika.

Each of the 53 real networks used in Sect 5 was loaded from the network repository Netzschleuder as simple unweighted and undirected graph G. Then, a CP problem was defined according to the weighted graph whose edge weights are the entries of the modularity matrix of G. The data for all these real networks (G) are available in a FigShare data repository [36]. The same FigShare repository contains data on all synthetic networks (LFR and ABCD networks) used in Sect 5 as well as all BA instances used in Sect 4.5 and all portfolio networks used in Sect 6. Other networks used in our study were from [29]. Sørensen and Letchford [29] have shared their CP instances and the optimal solutions that were available in a public GitHub repository https://github.com/MMSorensen/CP-Lib.