🔬 physics

Heuristic and exact modularity optimization with size-constrained communities

This paper addresses the problem of size-constrained community detection by proposing a heuristic for modularity optimization and validating it against an exact integer optimization baseline, demonstrating that these methods offer a principled alternative to resolution parameter tuning for obtaining communities within user-specified size ranges.

Original authors: Filipi N. Silva, Samin Aref, Vincent Traag, Santo Fortunato

Published 2026-05-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Filipi N. Silva, Samin Aref, Vincent Traag, Santo Fortunato

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a city planner trying to divide a massive, bustling city into neighborhoods. Your goal is to group people who know each other well and hang out together into distinct "communities." This is what computer scientists call community detection.

Usually, algorithms do this by looking at the map of connections and saying, "These people are super connected, so they must be in the same neighborhood." However, there's a problem: the algorithm doesn't care about the size of the neighborhood. It might end up creating one giant, overcrowded district with 10,000 people and a bunch of tiny, lonely hamlets with just two people each.

In the real world, experts often know what a "good" neighborhood size should be. A marketing team knows a customer segment needs at least 100 people to be useful. A brain scientist knows a functional brain region shouldn't be the size of the whole brain. But standard tools don't let you say, "Make sure every neighborhood has between 50 and 200 people."

This paper introduces a new way to solve that problem. Here is the breakdown in simple terms:

The Old Way: Guessing with a "Resolution Knob"

Previously, if experts wanted to control neighborhood sizes, they had to use a "resolution knob."

The Analogy: Imagine you are trying to tune a radio to find a specific station. You don't know the exact frequency, so you just twist the dial back and forth, listening to see if the sound gets clearer.
The Problem: In network science, turning this knob changes the average size of communities, but it's a blunt instrument. You might get the average right, but you could still end up with one giant neighborhood and a bunch of tiny ones. You have no control over the variation (the difference between the biggest and smallest groups). It's like trying to bake cookies of the exact same size by just turning the oven temperature up and down; you might get the average right, but some will be burnt and some will be dough.

The New Way: The "Size-Enforcing" Rule

The authors (Filipi Silva, Samin Aref, Vincent Traag, and Santo Fortunato) propose a new method that acts like a strict bouncer at a club.

The Analogy: Instead of guessing the temperature, you tell the algorithm: "No neighborhood can have fewer than 50 people, and none can have more than 200."
How it works: They created a Heuristic (a smart, fast shortcut) that tries to find the best possible grouping while strictly obeying these size rules.
- If a group gets too small, the algorithm pushes people out.
- If a group gets too big, it splits them up.
- It does this by adding a "penalty" to the math. If a group breaks the size rule, the algorithm gets a "frown" (a penalty score) and tries to fix it.

The "Gold Standard" Check

To prove their new "smart shortcut" actually works, they also built an Exact method.

The Analogy: Think of the Exact method as a super-slow, super-smart mathematician who checks every single possible way to divide the city to find the perfect answer. This takes a huge amount of time and computer power, so you can't use it for big cities.
The Result: They compared their fast "smart shortcut" against the slow "perfect mathematician." They found that the shortcut was incredibly reliable. It found solutions that were almost identical to the perfect ones, but it did it much faster, making it usable for huge networks.

Real-World Tests

The team tested this on two types of maps:

Fake Cities (Synthetic Benchmarks): They built computer-generated networks where they knew the "correct" neighborhoods beforehand.
- Result: The old "knob" method often failed to find the correct neighborhoods, especially when the connections were a bit messy. The new "size-enforcing" method found the correct groups almost every time, even when the old method was confused.
Real Cities (Real Networks):
- Market Segmentation: In business, they showed how this helps group customers into usable sizes, avoiding the problem of one giant group and many useless tiny ones.
- Brain Maps: They looked at a map of the human brain. Standard methods often just split the brain into two big halves (left and right), which isn't very helpful. By setting size limits based on what neuroscientists know about brain regions, their method found 6 distinct, meaningful functional clusters that aligned with expert knowledge.

The Takeaway

This paper gives scientists and experts a tool to say, "I know what a reasonable group size looks like in my field, and I want the computer to respect that."

Instead of blindly twisting a knob and hoping for the best, you can now set clear boundaries (e.g., "Groups must be between 43 and 187 people"). The new method respects these boundaries, finds high-quality groupings, and does it fast enough to be used on real, large-scale data. It turns community detection from a game of "guess and check" into a precise, principled process.

Technical Summary: Heuristic and Exact Modularity Optimization with Size-Constrained Communities

Problem Statement

Community detection is a fundamental task in network analysis, yet standard algorithms often fail to incorporate domain-specific prior knowledge regarding community sizes. In applications such as market segmentation, neuroscience (brain connectomes), and genomics (chromosomal interactions), experts often possess knowledge of reasonable ranges for community sizes. However, existing unconstrained methods frequently produce partitions with extreme size disparities (e.g., one massive community and many trivial ones) or fail to align with biological or functional realities.

While multi-resolution techniques allow users to indirectly influence the average community size by tuning a resolution parameter ( $\gamma$ ), this approach does not control the size of individual communities, nor does it guarantee that all communities fall within a specific user-defined range. This paper addresses the Size-Constrained Maximum Modularity (SMM) problem: finding a partition of a network that maximizes modularity while ensuring every community size $n_c$ satisfies $n_{min} \le n_c \le n_{max}$ .

Methodology

The authors propose a dual approach to solving the SMM problem: an exact optimization baseline and a scalable heuristic.

1. Exact Optimization Baseline (SMMk)

To establish a ground truth for reliability, the authors formulate the problem as an Integer Program (IP).

Formulation: They extend the standard Integer Programming formulation for the Maximum Modularity $k$ -partition (MMk) problem.
Constraints: The model includes linear constraints to enforce the size bounds. Specifically, they introduce constraints ensuring that for any non-empty community $c$ , the number of nodes $\sum x_{ic} \ge n_{min}$ , and for all potential communities, $\sum x_{ic} \le n_{max}$ .
Solver: The model is solved using the Gurobi optimizer to obtain globally optimal (or near-optimal) partitions for small to medium-sized graphs. This serves as the baseline for evaluating the heuristic.

2. Heuristic Optimization (Constrained Leiden - CL)

Directly enforcing size constraints within standard modularity heuristics (like the Leiden algorithm) is problematic because local node moves can easily violate size bounds (e.g., moving a node to a new singleton community violates $n_{min} > 1$ ).

Penalty Approach: Instead of a barrier method (which restricts the search space), the authors employ a penalty approach. They transform the constrained problem into an unconstrained one by optimizing a modified objective function:
$Q'(G, P) = Q(G, P) - \phi \Theta(P)$
Where $\Theta(P)$ is a penalty function for communities violating size constraints, and $\phi$ is a penalty weight.
Penalty Function: The penalty $\theta(n_c)$ for a community of size $n_c$ is defined as:
$\theta(n_c) = \begin{cases} \sqrt{n_{min} - n_c} & \text{if } n_c < n_{min} \\ \sqrt{n_c - n_{max}} & \text{if } n_c > n_{max} \end{cases}$
The square root function is chosen because it is sub-additive, preventing the algorithm from being trapped in local optima where splitting a large violating community into two smaller violating communities yields a lower total penalty.
Progressive Schedule: The algorithm starts with $\phi = 0$ (unconstrained). If the resulting partition violates constraints, $\phi$ is increased (starting at $10^{-4}$ and doubling) and the optimization is re-initialized from the previous solution. This continues until a feasible partition is found.

Key Results

The authors evaluated the proposed Constrained Leiden (CL) method against Unconstrained Leiden (UL) and the Constrained Integer Programming (CIP) baseline across synthetic and real-world networks.

Synthetic Benchmarks

Planted Partition Models: In networks with known ground-truth communities, CL and CIP significantly outperformed UL in retrieval rates (measured by Adjusted Mutual Information, AMI), particularly when the mixing parameter was low to medium. UL frequently failed to retrieve the planted communities because it produced partitions with sizes outside the expected range.
Ring of Cliques: In a graph of 50 cliques (size 5) connected sequentially, UL only retrieved the correct partition if the resolution parameter was manually tuned to a specific range ( $[5, 40]$ ). In contrast, CL accurately retrieved the planted partition at the default resolution ( $\gamma=1$ ) when given the correct size range $[2, 8]$ .
Reliability: The retrieval rates of the heuristic CL were consistently close to, and sometimes equal to, the exact CIP baseline, demonstrating that the heuristic does not sacrifice accuracy for speed in these contexts.

Real-World Networks

Brain Connectome: Applied to the Budapest brain connectome network, UL produced a trivial partition of four communities (corresponding to hemispheres), which lacks neuroscience utility.
Domain Alignment: By applying CL with a size range derived from expert knowledge (based on the Brainnetome and Schaefer atlases, $[43, 187]$ nodes), the method produced 6 communities. This result aligns much better with known functional brain clusters (e.g., the 7 clusters defined by Yeo et al.) than the unconstrained result.
Control of Variation: The authors demonstrated that changing the resolution parameter in UL controls the average community size but fails to control the variation (variance) of sizes. CL provides direct control over both the mean and the variation, ensuring all communities fall within the specified bounds.

Significance and Claims

The paper claims that the proposed method offers a principled way to incorporate domain expertise into community detection.

Direct Control: Unlike the "trial-and-error" practice of tuning resolution parameters, CL allows users to explicitly define the minimum and maximum size of communities, directly addressing the needs of domain experts.
Scalability: While the exact IP method (CIP) is limited by computational complexity to smaller graphs, the CL heuristic is scalable and can be applied to large networks, making it practical for real-world applications.
Implementation: The method is implemented within the Python Leiden algorithm package, making it accessible for immediate use.

The authors conclude that while modularity has known limitations (such as the resolution limit and lack of a clear statistical foundation), the ability to enforce size constraints via their heuristic allows for more informative and domain-aligned partitions. They suggest future work could explore incorporating size constraints into other frameworks, such as Stochastic Block Models (SBMs), to leverage these constraints within a statistical inference context.