Constant Approximation of Arboricity in Near-Optimal Sublinear Time

2025-12-20

AI Summary

This paper studies the sublinear-time approximation of arboricity λ in undirected graphs. Prior algorithms achieved only an O(log²n) approximation ratio; we present the first constant-factor approximation algorithm, requiring only Õ(n/λ) adjacency-list queries—matching the information-theoretic lower bound up to polylogarithmic factors. Our method introduces a parallel recursive framework coupled with an adaptive dynamic scheduling mechanism, which effectively curbs error accumulation inherent in probabilistic sampling and overcomes the fundamental trade-off between constant approximation and low query complexity in sublinear-time algorithms. As a result, we achieve, for the first time, both a constant approximation ratio and Õ(n/λ) query complexity in sublinear time—resolving an open problem posed by Eden et al. (SODA’22). The algorithm is optimal up to logarithmic factors in both time and query complexity.

Technology Category

• Planning, Routing, and Scheduling: Scheduling under Uncertainty
• Search and Optimization: Combinatorial Optimization
• Constraint Satisfaction and Optimization: Distributed CSP/Optimization

Application Category

• Graph Algorithms and Modeling for the Web: Efficient manipulation of static and dynamic Web-related graphs
• Search and Retrieval-Augmented AI: Web learning to rank, online learning, and counterfactual learning for ranking
• Responsible Web: Human-perceived consequences of algorithmic deployment on the web

Abstract

We present a randomized algorithm that computes a constant approximation of a graph's arboricity, using $ ilde{O}(n/λ)$ queries to adjacency lists and in the same time bound. Here, $n$ and $λ$ denote the number of nodes and the graph's arboricity, respectively. The $ ilde{O}(n/λ)$ query complexity of our algorithm is nearly optimal. Our constant approximation settles a question of Eden, Mossel, and Ron [SODA'22], who achieved an $O(log^2 n)$ approximation with the same query and time complexity and asked whether a better approximation can be achieved using near-optimal query complexity. A key technical challenge in the problem is due to recursive algorithms based on probabilistic samplings, each with a non-negligible error probability. In our case, many of the recursions invoked could have bad probabilistic samples and result in high query complexities. The particular difficulty is that those bad recursions are not easy or cheap to detect and discard. Our approach runs multiple recursions in parallel, to attenuate the error probability, using a careful extit{scheduling mechanism} that manages the speed at which each of them progresses and makes our overall query complexity competitive with the single good recursion. We find this usage of parallelism and scheduling in a sublinear algorithm remarkable, and we are hopeful that similar ideas may find applications in a wider range of sublinear algorithms that rely on probabilistic recursions.

Problem

• Computes constant approximation of graph arboricity efficiently
• Achieves near-optimal sublinear query complexity with adjacency lists
• Improves prior logarithmic approximation using parallel recursion scheduling

Innovation

• Parallel recursion scheduling to reduce error probability
• Near-optimal sublinear query complexity for arboricity approximation
• Constant approximation improvement over previous logarithmic bounds