Vertex-Based Connected Component Labeling

• Vertex-Based Connected Component Labeling is a suite of algorithms that assigns unique labels to connected vertices in graphs, images, and discrete domains for efficient segmentation.
• Key methods include tree-based union-find, label propagation, and BFS, all optimized for parallel architectures and high-performance GPU implementations.
• Recent advances focus on robustness and fault tolerance, incorporating strategies like f-VFT schemes to reduce label sizes and improve connectivity under failures.

Vertex-based connected component labeling encompasses a diverse collection of algorithms and paradigms for assigning unique labels to groups of mutually reachable vertices in a graph, image, or other discrete domain. It is foundational in graph theory, image segmentation, pattern recognition, physical simulation, and network analysis. The principal challenge lies in efficiently identifying maximal subsets (connected components) under various forms of connectivity, while accommodating both local and non-local data, irregular topologies, parallel and distributed architectures, and robustness or fault tolerance.

1. Algorithmic Foundations and Core Paradigms

Vertex-based labeling exploits graph-theoretic connectivity defined over the vertex set $V$ of a graph $G=(V,E)$. Two vertices $u,v$ are considered to belong to the same component if there exists a path in $G$ linking $u$ and $v$. The objective is to assign each vertex $v$ a label $\ell(v)$ such that $\ell(u)=\ell(v)$ if and only if $u$ and $v$ are connected.

Classical approaches include:

• Tree-based Union-Find: Maintains a set partition via root pointers, merging components dynamically. With path compression, find and union operations achieve nearly constant amortized cost (inverse Ackermann function $\alpha(n)$) (Weigel, 2011). This paradigm is broadly deployed in both CPU and GPU architectures.
• Label Propagation Methods: Each vertex maintains a label, repeatedly updated to the minimum of itself and its neighbors. Convergence under label propagation generally requires $O(\log n)$ steps for favorable graph classes, with the core update $\ell_i \gets \min(\ell_i, \ell_j)$ among neighbors (Weigel, 2011, Burkhardt, 2018, Liu et al., 2018).
• Breadth-First Search (BFS): Cluster expansion from seed vertices via layer-wise traversal, incurring $O(B^2)$ work per tile for block size $B$ in lattice-based problems but with limited parallelism potential due to dynamic queue management (Weigel, 2011).
• Coarse-to-fine local labeling: Initial local equivalence classes identified using row/column scans, followed by refinement (list unification and atomic merges) and selective boundary analysis (Chen et al., 2017, Chen et al., 2017). This strategy reduces memory accesses and the number of atomic operations.
• Run-based Segment Labeling: Processes contiguous runs/segments rather than pixels, recording label equivalences and features on-the-fly, and employing transitive closure for final label assignment and efficient hole processing (Lemaitre et al., 2020).

2. Parallelization Strategies and GPU Implementations

Parallelization is crucial for scaling vertex-based labeling to large graphs or high-resolution images. GPUs, with thousands of threads and fast shared memory, provide the architecture to exploit fine-grained parallelism:

• Tiling and Block Decomposition: Lattices (and in general, graphs with spatial locality) are partitioned into tiles/blocks (edge length $B$), enabling independent local labeling. Boundary conditions are managed either via iterative label relaxation or hierarchical sewing, which recursively merges boundaries (Weigel, 2011).
• Self-Labeling in Shared Memory: All sites/vertices in a block update their labels simultaneously (embarrassingly parallel). Sweeps are repeated until convergence, typically scaling as $n_B \sim B^{d_{\min}}$ for critical percolation clusters, where $d_{\min}$ is the fractal dimension of the shortest path (Weigel, 2011).
• Boundary Analysis: Subsequent passes restrict attention to block boundaries, drastically reducing atomic merge operations (Chen et al., 2017, Chen et al., 2017).
• Atomic Operations: Label reduction (e.g., atomicMin(label[label_1], label_2)) is utilized in generalized GPU frameworks for arbitrary graphs, ensuring minimal label propagation among connected vertices (Komura, 2016).
• Optimizations for Sparse Data: When operating directly on a stream of vertex/hit data (zero-suppression), auxiliary structures keep spatial caches and union-find operations achieve throughput of up to $300$ million hits per second on GPU, outpacing CPU methods by two orders of magnitude (Čelko et al., 16 Dec 2024).

3. Robustness, Fault Tolerance, and Connectivity under Failures

Vertex-based labeling generalizes beyond static connectivity, addressing queries and updates under vertex/edge failures. A major line of recent work establishes succinct vertex connectivity labeling schemes:

• Fault-Tolerant Labeling Schemes (f-VFT): Each vertex stores a $O(\text{poly}(f, \log n))$-bit label such that, given the labels of a query pair and up to $f$ failed vertices, connectivity in $G-F$ can be determined locally (Parter et al., 2022, Parter et al., 2023, Long et al., 24 Oct 2024). Novel decompositions (low-degree, expander hierarchies) and distributed encoding (e.g., Reed-Solomon codes, random sketching, heavy-light decomposition) underpin these constructions.
• Label Sizes and Complexity Bounds: Recent advances reduce the randomized vertex fault label sizes from $O(f^3\log^5 n)$ to $O(f^2\log^6 n)$ (Long et al., 24 Oct 2024). Deterministic schemes achieve $O(f^4\log^{7.5} n)$ bits via vertex-expander hierarchies and improved sparsification.
• Global vs Pairwise Lower Bounds: For global connectivity labeling under vertex faults, any scheme must use $\Omega(n^{1-1/f}/f)$ bits, even though pairwise connectivity labels can be polylogarithmic (Long et al., 24 Oct 2024).
• Applications: These schemes enable decentralized, distributed connectivity queries and robust routing (with table and header sizes in $O(\text{poly}(f, \log n))$ bits) in adversarial networks.

4. Generalizations for Cohesive Subgraph Identification

Vertex-based labeling extends to stricter subgraph notions:

• k-Vertex Connected Components (k-VCCs): Maximal subgraphs remaining connected after removal of any $k-1$ vertices. These avoid the “free-rider effect” and possess bounded diameter, high cohesiveness, limited overlap ($<k$ shared vertices per component), and bounded total number ($< |V|/2$ components) (Wen et al., 2017).
• Enumeration and Pruning: Efficient enumeration frameworks use recursive partition by vertex cuts and local connectivity checks via max-flow in auxiliary graphs. Optimization strategies (neighbor sweep, group sweep) prune up to $90\%$ of expensive local tests by leveraging side-vertex/group transitivity and deposit counting.
• Impact: k-VCCs underpin state-of-the-art algorithms for social network community detection, cohesive network summarization, and structurally robust analysis.

5. Adaptations to Implicit and Irregular Domains

Labeling algorithms have evolved for domains defined implicitly or with irregular structure:

• Implicitly-defined Domains: Connected component labeling for regions defined by constraints such as $\Omega := \mathcal{U} \setminus \{\phi=0\}$, where $\phi$ is a multivariate polynomial in Bernstein form. Recursive subdivision (quadtree/octree) is combined with convex hull properties: labels are assigned via sign evaluation and coefficient monotonicity tests per cell. In ambiguous cases, user-defined length scales and fuzzy tolerances control merging, which may “glue” nearly-touching components (Saye, 2022).
• Sparse/Zero-Suppressed Data: In applications where only nonzero (active) elements are recorded (e.g., detector hits), labeling operates directly on the stream, with union-find and path compression kept proportional to the hit count rather than matrix size, achieving real-time clustering (Čelko et al., 16 Dec 2024).

6. Performance, Scalability, and Practical Considerations

• Computational Scaling Laws: GPU run time for labeling clusters in a tile follows $$T^p_{\text{local}} = C_{\text{local}} \cdot (\ell^2/\min(\ell^2, n)) \cdot (B^2/\min(B^2/k, m)) \cdot B^{d_{min}}$$, where all terms and their scaling arise precisely in the relevant primary literature (Weigel, 2011).
• Speedups: Self-labeling plus hierarchical sewing gives $20\times$ to $30\times$ speedups over serial CPU implementations for large lattices (Weigel, 2011). Parallel CCL achieves up to $20.1\times$ speedup on $24$ cores for $465.2$MB images, with linear scaling in the number of processing elements (Gupta et al., 2016, Čelko et al., 16 Dec 2024).
• Memory and Data Layout: Shared memory and intelligent data partitioning (tile/block assignment, grouping spins per thread) are pivotal for maximizing throughput, minimizing atomic operations, and maintaining load balancing in the face of irregular graph structures (Weigel, 2011, Chen et al., 2017, Chen et al., 2017).

7. Mathematical Formulations and Key Results Table

Algorithm	Scaling Law / Formula	Citation
SW bond activation	$p=1-e^{-βJ}$	(Weigel, 2011)
Self-label local run time	$$T^p_\text{local}=C_\text{local} (\ell^2/\min(\ell^2, n))(B^2/\min(B^2/k, m)) B^{d_{\min}}$$	(Weigel, 2011)
Label relaxation iterations	$n_{relax}\sim \ell^{d_\text{min}}$	(Weigel, 2011)
Hierarchical sewing work per lvl	$T^s_k=C_{sew}(L^2/B)2^{1-k}$	(Weigel, 2011)
k-VCC diameter bound	$$diam(G_i)\leq \lfloor(|V(G_i)|-2)/\kappa(G_i)\rfloor+1$$	(Wen et al., 2017)
CV$_k$(P$_n$): $k$-diameter connectivity	$CV_k(P_n)=n/(k+1)$	(Buzzard et al., 2021)
Label reduction atomic op	$\text{atomicMin(label[label_1], label_2)}$	(Komura, 2016)
Parallel union-find per hit	$T_{\text{hit}}\approx O(\alpha(n))$	(Čelko et al., 16 Dec 2024)
f-VFT randomized vertex label size	$O(f^2\log^6 n)$	(Long et al., 24 Oct 2024)
Global connectivity under vertex faults lower bound	$\Omega(n^{1-1/f}/f)$	(Long et al., 24 Oct 2024)

The specific scaling and performance formulas, as well as the block and decomposition tradeoffs, are documented precisely in the cited works.

---

Vertex-based connected component labeling has evolved from classical sequential scan and pointer-based algorithms to highly parallel, robust schemes handling large-scale graphs, images, sparse data streams, and fault-tolerant distributed systems. The field combines deep combinatorial foundations, optimized local and global data organization, and algorithmic primitives—label-propagation, path compression, recursive subdivision—with principled performance guarantees and robust handling of complex topologies and failures. Each step, insight, and scaling law is explicitly validated in the primary literature, supporting both theoretical reliability and practical scalability.