Network community detection via iterative edge removal in a flocking-like system

We present a network community-detection technique based on properties that emerge from a nature-inspired system of aligning particles. Initially, each vertex is assigned a random-direction unit vector. A nonlinear dynamic law is established so that neighboring vertices try to become aligned with each other. After some time, the system stops and edges that connect the least-aligned pairs of vertices are removed. Then the evolution starts over without the removed edges, and after enough number of removal rounds, each community becomes a connected component. The proposed approach is evaluated using widely-accepted benchmarks and real-world networks. Experimental results reveal that the method is robust and excels on a wide variety of networks. Moreover, for large sparse networks, the edge-removal process runs in quasilinear time, which enables application in large-scale networks.

💡 Research Summary

The paper introduces a novel community‑detection algorithm that draws inspiration from the flocking behavior observed in nature. Each vertex of an undirected graph is assigned a random unit vector in three‑dimensional space. A nonlinear update rule drives neighboring vertices to align their vectors:

 v_i(t+1) = (1‑α)·v_i(t) + α·(1/k_i) Σ_j γ_ij v_j(t)

where γ_ij indicates adjacency, k_i is the degree of vertex i, and α∈(0,½) is a learning rate. After each update the vector is normalized, guaranteeing that its norm stays within (0, 1]. This dynamic mimics self‑propelled particles that constantly adjust their heading to match their neighbors, leading to a collective alignment within each connected component.

To exploit the alignment process for community detection, the authors define a misalignment coefficient for every edge:

 H_ij(t) = ‖ v_i(t)/‖v_i(t)‖ – v_j(t)/‖v_j(t)‖ ‖₁

which is simply the L₁ (city‑block) distance between the two normalized vectors. Empirically, edges that cross community boundaries retain higher H values for longer, because vertices in different communities align more slowly. Consequently, the algorithm proceeds in iterative “cycles”:

1. Run the flocking dynamics for a fixed number of iterations (t).
2. Compute H_ij for all existing edges.
3. Remove a selected fraction of edges with the largest H values.

The process repeats until the graph fragments into disconnected components, each of which corresponds to a detected community. The authors explore variations such as multiple random initializations per cycle and different removal fractions, showing that the method is robust to these choices.

Theoretical contributions include a continuous‑time approximation of the update rule, an energy function

 E = ¼ Σ_ij γ_ij ‖x_i – x_j‖²

where x_i = v_i/‖v_i‖, and a Lyapunov‑based proof that the perfectly aligned state (x_i = x_j for all adjacent i, j) is stable. Lemmas guarantee that the vector norms never reach zero or exceed one, provided α is bounded as above. These results justify why alignment is expected within each community and why inter‑community edges remain relatively misaligned.

Experimental evaluation covers synthetic LFR benchmark graphs with varying mixing parameters and real‑world networks (social, biological, infrastructure). Using α = 0.1, t = 100, and removing the single most misaligned edge per round, the method achieves modularity scores higher than two widely used baselines: the greedy modularity optimizer (CFG) and the Louvain method. For a test graph with four planted communities (average degree ≈10, intra‑community edge probability 0.66), the algorithm reaches Q ≈ 0.38, surpassing CFG (Q ≈ 0.33) and Louvain (Q ≈ 0.31). Modularity improves steadily over successive rounds, confirming that edge removal progressively isolates true communities.

Regarding computational complexity, each cycle requires O(m) time to compute H values and O(k log n) time to select the top‑k edges (implemented with a min‑heap). Because the number of cycles is typically small and the removal fraction can be tuned, the overall runtime scales quasi‑linearly: O(m log n) in the worst case, and O(n log n) for sparse graphs where m≈n. This makes the approach suitable for large‑scale networks where spectral or optimization‑heavy methods become prohibitive.

The authors acknowledge limitations: the choice of α and the number of iterations t influences convergence speed; dense graphs may cause slower alignment, potentially leading to over‑removal of edges; and the current framework lacks an automatic stopping criterion for the number of cycles. Future work could incorporate adaptive parameter selection, multi‑scale alignment, and extensions to directed or weighted graphs.

In summary, the paper presents a compelling blend of physics‑inspired dynamics and graph‑theoretic edge pruning to uncover community structure. It offers solid theoretical guarantees, demonstrates superior modularity performance on benchmark and real data, and operates with near‑linear computational cost, positioning it as a valuable addition to the toolbox of network scientists and practitioners dealing with large, complex graphs.