Granular-ball Graph Coarsening

Updated 5 July 2026

Granular-ball graph coarsening is a method that adaptively aggregates connected, feature-coherent regions into supernodes using recursive quality-based refinement.
The approach replaces fixed-ratio contraction with a coarse-to-fine granulation process, which enhances clustering, spectral construction, and scalable GNN training.
It employs diverse quality metrics such as structural connectivity, purity, and average degree to generate representative, coherent graph clusters.

Searching arXiv for recent and foundational papers on granular-ball graph coarsening. Granular-ball graph coarsening is a class of graph reduction methods that replaces fine-grained node-level processing with adaptive “granular-balls,” each of which acts as a supernode representing a connected or feature-coherent subregion of the original graph. In this framework, coarsening is not treated as a fixed-ratio contraction alone; it is a coarse-to-fine granulation process in which large candidate regions are recursively refined until a local quality criterion is satisfied, and the resulting granular-balls are used either as the nodes of a coarsened graph or as latent multiscale structure that regularizes a sample-level graph (Xia et al., 24 Jun 2025). Across the recent literature, this paradigm is motivated by granular computing and the “global-first” or “large-scale priority” view of computation, and it has been instantiated for clustering, spectral graph construction, scalable GNN training, and graph-regularized representation learning (Xia et al., 2023).

1. Conceptual basis and historical emergence

Granular-ball methods originate in granular-ball computing, where learning is reformulated from point-based computation $f(x,\vec{\alpha})$ to ball-based computation $g(GB,\vec{\beta})$ under objectives that jointly favor high coverage, a small number of balls, and ball quality constraints (Xia et al., 2023). In the generic granular-ball computing model, the optimization trades off $\frac{n}{\sum_j |GB_j|}$ , the number of balls $k$ , and an optional $loss(GB)$ , subject to $quality(GB_j)\ge T$ , thereby formalizing the balance between coarse representation and local fidelity (Xia et al., 2023).

Within graph-related work, the first explicit formulations of a granular-ball graph coarsening method appear in graph coarsening via granular-ball supernodes and in supervised granular-ball coarsening for scalable GNN training (Xia et al., 24 Jun 2025). These methods depart from spectrum-preserving graph coarseners that rely primarily on predefined contraction rules and Laplacian matching, arguing instead that graphs contain subregions at different granularities and that highly connected, structurally cohesive node groups should be aggregated adaptively rather than by a fixed global rule (Xia et al., 24 Jun 2025). A closely related line uses supervised purity-driven granular-ball splitting to build coarsened graphs for GNN training, emphasizing that the coarsening ratio need not be predefined because the final number of balls emerges from the splitting process itself (Xia et al., 2024).

This development was preceded by several adjacent granular-ball constructions. GBCT introduced a point-cloud clustering pipeline with granular-ball generation and ball-level merging, and explicitly noted that its two-phase structure maps almost directly to graph coarsening and multilevel clustering (Xia et al., 2024). GBMST treated granular-balls as supernodes for MST-based clustering, constructing a coarse graph on balls rather than on individual points (Xie et al., 2023). More recently, MDL-GBTRSC used a granular-ball tree not as the final graph domain but as a multiscale regularizer of a sample-level affinity graph, showing that granular-balls can function either as explicit coarse nodes or as latent coarsening structure (Xian et al., 21 May 2026).

2. Mathematical representation of granular-balls and coarse graphs

In Euclidean granular-ball computing, a granular-ball $GB$ is a set of points with a center and a radius. For GBCT, if $GB=\{P_i\}\subset\mathbb{R}^d$ , then the center and radius are

$c = \frac{1}{|GB|} \sum_{i=1}^{|GB|} P_i,\qquad r = \max_{P_i\in GB}\|P_i-c\|$

with density

$\rho_{GB}=\frac{|GB|}{r^d}.$

GBCT further defines an average radius $g(GB,\vec{\beta})$ 0, inner and outer density estimates $g(GB,\vec{\beta})$ 1 and $g(GB,\vec{\beta})$ 2, and a center-consistency score

$g(GB,\vec{\beta})$ 3

which quantifies whether the ball is internally homogeneous enough to be retained without further splitting (Xia et al., 2024).

Graph-native granular-ball coarsening replaces the Euclidean ball by a subgraph-level object. In GBGC, a granular-ball $g(GB,\vec{\beta})$ 4 is associated with a subgraph $g(GB,\vec{\beta})$ 5, where $g(GB,\vec{\beta})$ 6 and $g(GB,\vec{\beta})$ 7 contains the original edges with both endpoints in $g(GB,\vec{\beta})$ 8 (Xia et al., 24 Jun 2025). The original graph $g(GB,\vec{\beta})$ 9 is partitioned into non-overlapping subgraphs

$\frac{n}{\sum_j |GB_j|}$ 0

Each such subgraph becomes a supernode in the coarsened graph $\frac{n}{\sum_j |GB_j|}$ 1, with

$\frac{n}{\sum_j |GB_j|}$ 2

A coarse edge $\frac{n}{\sum_j |GB_j|}$ 3 exists if there is at least one original edge connecting a node in $\frac{n}{\sum_j |GB_j|}$ 4 to a node in $\frac{n}{\sum_j |GB_j|}$ 5 (Xia et al., 24 Jun 2025).

The mapping from original nodes to supernodes is encoded by a projection matrix $\frac{n}{\sum_j |GB_j|}$ 6, where $\frac{n}{\sum_j |GB_j|}$ 7 if original node $\frac{n}{\sum_j |GB_j|}$ 8 belongs to supernode $\frac{n}{\sum_j |GB_j|}$ 9, and $k$ 0 otherwise. The coarsened Laplacian is then

$k$ 1

which places granular-ball coarsening directly within the standard operator-theoretic formulation of graph reduction (Xia et al., 24 Jun 2025). This suggests that granular-ball graph coarsening is not a separate formalism so much as a particular way of constructing the partition matrix and coarse topology.

The defining algorithmic feature of the method is adaptive granular-ball refinement. In GBCT, the initialization step sets $k$ 2 and uses $k$ 3-means to generate initial granular-balls, after which any ball with $k$ 4 is split by 2-means until no further acceptable split is possible (Xia et al., 2024). This coarse-to-fine procedure is the prototype for later graph variants.

GBGC implements the same principle directly on graphs. It begins with a coarse-grained initialization that conceptually treats the entire graph as one ball, then generates $k$ 5 initial granular-balls by a degree-based BFS procedure (Xia et al., 24 Jun 2025). For each current granular-ball $k$ 6, local structural quality is computed from its induced subgraph. The quality function is

$k$ 7

combining average internal connectivity $k$ 8 with the global clustering coefficient of the ball (Xia et al., 24 Jun 2025). Splitting is binary: two center nodes are selected as the highest-degree nodes in the current ball, BFS is run from both, and nodes are assigned to the nearer center. The split is accepted if

$k$ 9

Refinement stops when no ball can be improved by such a split (Xia et al., 24 Jun 2025).

The supervised variant SGBGC uses a label-aware purity criterion instead of structural quality. Its coarse partitioning selects about $loss(GB)$ 0 high-degree nodes as initial centers, balanced across labels, assigns all original nodes to these centers, and then iteratively splits connected subgraphs until each granular-ball reaches a prescribed purity threshold. In the reported experiments, $loss(GB)$ 1, meaning that all nodes in a ball share the same label (Xia et al., 2024). This makes the coarsening adaptive rather than rate-driven: the number of supernodes is determined by how much splitting is required to satisfy the supervision criterion.

A later large-scale node-classification framework replaces the earlier global BFS initialization with METIS partitioning into $loss(GB)$ 2 coarse balls, followed by local fine-grained binary splitting using the average-degree quality

$loss(GB)$ 3

A split is retained if

$loss(GB)$ 4

so the refinement criterion becomes local average connectivity improvement rather than label purity or triangle density (Wang et al., 31 Mar 2026). This suggests that “granular-ball graph coarsening method” is better understood as a family of adaptive splitting schemes whose main degree of freedom is the quality functional.

4. Construction of the coarsened graph

Once the final granular-balls are fixed, the coarsened graph is constructed by standard supernode aggregation. In GBGC, each granular-ball becomes one node in $loss(GB)$ 5, and a superedge is created whenever there is any original cross-ball edge (Xia et al., 24 Jun 2025). In SGBGC, the same principle is used: each granular-ball becomes a super-vertex, edges between super-vertices are induced by original edges linking nodes in different balls, super-vertex features are obtained by averaging node features, and labels are assigned by majority vote (Xia et al., 2024).

For methods working in feature space rather than directly on the original graph, coarse-edge construction is often expressed through ball–ball distances or aggregated similarities. GBCT defines the raw boundary distance between two balls as

$loss(GB)$ 6

with a shifted nonnegative distance and similarity

$loss(GB)$ 7

Cluster formation then proceeds by single-link agglomeration over the ball graph (Xia et al., 2024). In graph-coarsening language, this is an implicit complete weighted graph on granular-balls, where edge weights are inverse boundary separations.

Another formulation appears in granular-ball-induced multi-kernel clustering, where the granular-ball kernel is defined as the average pairwise similarity between all points in two balls: $loss(GB)$ 8 This directly yields a coarse graph whose nodes are balls and whose edge weights are density-normalized aggregate affinities (Xia et al., 23 Jun 2025). Because the resulting kernel remains symmetric and positive semi-definite, it is directly usable for spectral methods on the coarsened graph (Xia et al., 23 Jun 2025).

A different construction is used in MDL-GBTRSC, where granular-balls are not the final graph nodes. Instead, a granular-ball tree is learned first, with stable leaf balls carrying radii and effective variances. These are summarized by coding scales

$loss(GB)$ 9

which are then used to regularize sample-level edge weights by penalizing neighbors whose enclosing balls have very different scales (Xian et al., 21 May 2026). This suggests a second interpretation of granular-ball graph coarsening: not necessarily replacing the original graph, but injecting coarse multiscale structure into its edge weights.

5. Relation to scalable graph learning

The most direct application of granular-ball graph coarsening has been scalable GNN training. SGBGC is explicitly designed as a preprocessing step: it constructs a smaller granular-ball graph, trains a standard GNN such as GCN, GAT, or APPNP on that coarsened graph, and then uses the learned parameters $quality(GB_j)\ge T$ 0 on the original graph (Xia et al., 2024). The method is supervised, training-independent during coarsening, and adaptive in that it avoids specifying a coarsening rate in advance (Xia et al., 2024).

The later large-scale framework combines granular-ball coarsening with minibatch GCN training. After coarsening, the original adjacency matrix is decomposed as a block-diagonal part $quality(GB_j)\ge T$ 1 plus off-block interactions $quality(GB_j)\ge T$ 2, where each diagonal block corresponds to one granular-ball subgraph (Wang et al., 31 Mar 2026). During training, only randomly sampled granular-ball subgraphs are used in each minibatch. This yields memory complexity

$quality(GB_j)\ge T$ 3

where $quality(GB_j)\ge T$ 4 is the batch size in nodes, $quality(GB_j)\ge T$ 5 the number of GCN layers, and $quality(GB_j)\ge T$ 6 the hidden dimension, instead of storing embeddings for all $quality(GB_j)\ge T$ 7 nodes (Wang et al., 31 Mar 2026). The method reports that both coarse-grained initialization and fine-grained binary splitting are necessary: removing either component degrades accuracy or scalability, and on several large graphs the ablated variants fail (Wang et al., 31 Mar 2026).

These graph-specific results align with the broader theory of coarsened GNN training. Coarsening-based GNN acceleration treats training on a coarse graph as training in a restricted subspace defined by a normalized partition matrix $quality(GB_j)\ge T$ 8, with coarse features $quality(GB_j)\ge T$ 9 and coarse adjacency $GB$ 0 (Huang et al., 2021). That framework shows that coarsening acts as a regularizer and can improve generalization, provided the partition preserves graph energies in relevant low-frequency subspaces (Huang et al., 2021). A plausible implication is that granular-ball coarsening benefits not only from node-count reduction but also from its bias toward dense, homogeneous subgraphs, which serves as an explicit structural regularizer.

A complementary line uses granular-balls to augment, rather than replace, graph structure. SCGNN builds granular-balls over node features, converts them into anchors, connects original nodes to anchor nodes, and adds inter-anchor edges to inject group-level semantic consistency into a GNN (Tian et al., 4 May 2026). This can be read as a two-level coarse graph with interpolation links, again showing that granular-ball coarsening naturally supports multiscale message passing.

6. Variants, efficiency, and open issues

The literature now contains several distinct variants of the granular-ball graph coarsening idea. The main differences concern the quality criterion, the initialization strategy, and whether the balls become explicit coarse nodes or latent regularizers.

Variant	Granular-ball quality / criterion	Primary use
GBGC	Internal connectivity + clustering coefficient	Structural graph coarsening (Xia et al., 24 Jun 2025)
SGBGC	Purity threshold $GB$ 1	Supervised GNN coarsening (Xia et al., 2024)
Large-scale GB-CGNN	Average degree $GB$ 2	Minibatch GCN training (Wang et al., 31 Mar 2026)

In computational terms, GBGC reports overall time complexity

$GB$ 3

arguing that only the initialization is global and that all subsequent refinement is local (Xia et al., 24 Jun 2025). SGBGC reports

$GB$ 4

where $GB$ 5 denotes graph size at the edge level, and emphasizes that the entire coarsening stage is preprocessing rather than a training loop (Xia et al., 2024). The newer large-scale node-classification framework argues that METIS-based initialization plus local BFS splitting yields $GB$ 6 coarsening complexity on sparse graphs, making it the first linear-time granular-ball graph coarsening approach in that setting (Wang et al., 31 Mar 2026). Across these papers, a stable theme is that granular-ball methods attempt to shift expensive operations from all-node or all-edge processing to local ball-level processing.

Several limitations are already clear in the literature. One is the dependence on the chosen quality functional. Label purity works well for node classification, but a purity-only quality can be slow and structurally misaligned for large graphs; average-degree quality performs better in that setting (Wang et al., 31 Mar 2026). Another is that some variants remain tied to Euclidean feature spaces or embeddings rather than purely graph-native distances, so the quality of the embedding can affect the quality of the balls (Xia et al., 2024). A further issue is that standard coarse-edge construction often still uses heuristic aggregation rules. Independent work on learned coarsening weights suggests that, once a partition matrix is fixed, coarse edge weights can be improved substantially by optimizing them against Laplacian-preservation objectives rather than using only sums of crossing edges (Cai et al., 2021). This suggests a natural future direction: combine granular-ball supernode formation with learned edge-weight assignment.

Recent work also points to a conceptual bifurcation in the field. One branch uses granular-balls as explicit supernodes, producing smaller graphs for clustering or GNN training (Xia et al., 24 Jun 2025). The other branch uses granular-ball hierarchies as multiscale priors that regularize a finer graph without fully replacing it (Xian et al., 21 May 2026). A plausible implication is that “granular-ball graph coarsening method” now denotes a broader methodological family: adaptive, quality-controlled graph reduction in which coarse regions are discovered first and are then used either as the graph itself or as a structural scaffold for graph learning.

7. Significance

The granular-ball graph coarsening method is significant because it introduces an explicitly adaptive, multi-granularity view of graph reduction. Rather than fixing the coarse graph size in advance or relying solely on spectral matching, it constructs supernodes by recursively testing whether a current region is sufficiently homogeneous, connected, or pure under a domain-specific criterion (Xia et al., 24 Jun 2025). In this sense, the method brings the central granular-computing principle—coarse first, refine only where necessary—into graph representation and learning (Xia et al., 2023).

Empirically, the graph-specific papers report that such coarsening can preserve or even improve downstream accuracy while substantially reducing graph size and training cost (Xia et al., 2024). This suggests that granular-ball coarsening is not merely a compression device. It is also a structural denoising mechanism: by preferring internally coherent groups and by isolating heterogeneous or weakly connected regions for further refinement, it can yield coarse graphs that are easier for downstream models to optimize (Xia et al., 24 Jun 2025). For scalable graph learning, this positions granular-ball coarsening as both a graph reduction strategy and a graph regularization strategy, with applications spanning clustering, spectral graph construction, and GNN training (Wang et al., 31 Mar 2026).