Coo-game: Bridging Game Theory and Social Network Analysis for Overlapping Community Detection
An Algorithm Based on Game Theory for Detecting Overlapping Communities in Social Networks
The paper introduces Coo-game, a community detection algorithm that leverages game theory to identify overlapping community structures in social networks. By modeling individual nodes as "selfish agents" seeking a Nash local equilibrium through a gain-loss utility function, the authors achieve a fine-grained partition that outperforms classical models like GN and COPRA.
TL;DR
In social network science, communities aren't just groups; they are the result of individuals making choices. The research paper "An Algorithm based on Game Theory for Detecting Overlapping Communities" introduces Coo-game, a framework that treats nodes as rational players. By seeking a local Nash equilibrium and applying a connection-density optimization, the algorithm uncovers overlapping communities with higher precision and fewer "noisy" small clusters than traditional methods like COPRA.
Problem & Motivation
Most early community detection algorithms, such as the famous GN (Girvan-Newman) algorithm, treat the network as a static global entity to be sliced. They ignore the micro-incentives of the nodes that actually form these clusters.
The authors identify two fatal flaws in prior research:
- Coarse Resolution: Global methods often miss the "overlap" where a person belongs to multiple circles (e.g., family and work).
- Over-Partitioning: Modern micro-level methods often produce too many tiny, meaningless communities that don't satisfy the basic definition of a community: high internal density and sparse external links.
Methodology: The Core
The author's "Co-game" (and its optimized version, "Coo-game") operates on the intuition that community membership is a non-cooperative game.
1. The Utility Function
Every node (agent) is "selfish." It decides its strategy (Join, Leave, or Move) based on a utility function :
- Gain Function : Derived from the Modularity () metric, measuring how well the node fits into its current community set.
- Loss Function : Represents the "cost" of membership (e.g., membership fees or cognitive load), defined as .
2. Nash Local Equilibrium
Finding a global Nash Equilibrium is NP-hard. Instead, the algorithm seeks a local equilibrium where no node can improve its utility by changing its membership within a limited strategy space.

3. Structural Optimization
To fix the over-partitioning problem, the Coo-game variant checks each detected cluster. If a cluster's internal connection rate is lower than the network average, it is merged with its strongest neighbor.
Experiments & Results
The authors tested the algorithm using the LFR Benchmark (artificial graphs) and real-world datasets (Zachary’s Karate Club).
- Accuracy (NMI): On 5,000-node networks, Coo-game maintained an NMI above 0.7, significantly outperforming COPRA, which showed high volatility and lower accuracy as the mixing parameter () increased.
- Stability: Unlike label propagation methods (COPRA) which can be stochastic and unstable, the game-theoretic approach converged reliably to meaningful structures.
Fig: Normalized Mutual Information (NMI) demonstrates that Coo-game remains robust even as the overlapping node ratio increases.
Critical Analysis & Conclusion
Takeaway
The shift from "Global Partitioning" to "Individual Games" allows for natural overlapping detection. The Coo-game algorithm's strength lies in its ability to balance individual node "selfishness" with global "structural integrity" through its optimization pass.
Limitations
Despite its efficiency, the complexity of reaching local equilibrium is . While it handles 5,000 nodes well, the authors admit that very-large-scale networks (millions of nodes) would require a distributed computing approach or parallelized utility updates.
Future Work
The next frontier for this research is adapting the game-theoretic framework for directed and weighted graphs, which are common in modern web-scale data, and implementing it on Spark-based distributed architectures.
