Converting online algorithms to local computation algorithms

We propose a general method for converting online algorithms to local computation algorithms by selecting a random permutation of the input, and simulating running the online algorithm. We bound the number of steps of the algorithm using a query tree, which models the dependencies between queries. We improve previous analyses of query trees on graphs of bounded degree, and extend the analysis to the cases where the degrees are distributed binomially, and to a special case of bipartite graphs. Using this method, we give a local computation algorithm for maximal matching in graphs of bounded degree, which runs in time and space O(log^3 n). We also show how to convert a large family of load balancing algorithms (related to balls and bins problems) to local computation algorithms. This gives several local load balancing algorithms which achieve the same approximation ratios as the online algorithms, but run in O(log n) time and space. Finally, we modify existing local computation algorithms for hypergraph 2-coloring and k-CNF and use our improved analysis to obtain better time and space bounds, of O(log^4 n), removing the dependency on the maximal degree of the graph from the exponent.

💡 Research Summary

The paper introduces a unified framework for turning any online algorithm into a local computation algorithm (LCA). The central technique is to impose a random permutation on the input elements and then simulate the online algorithm in that order. Because an online algorithm’s decision for a given element depends only on previously processed elements, the set of required prior decisions for a query can be represented as a “query tree”. The root of the tree is the current query; its children are the earlier queries whose outcomes influence the current one, and so on recursively. By bounding the depth and size of this tree, the authors obtain explicit bounds on the time and space needed for each LCA query.

The authors first improve the analysis of query trees on bounded‑degree graphs. Using a refined collision probability argument and a careful martingale bound, they show that the expected depth is O(log n) with a much smaller constant factor than previous work. They then extend the analysis to graphs whose degrees follow a binomial distribution (i.e., random graphs with a fixed expected degree). Even when degrees vary, the expected tree depth remains logarithmic, which demonstrates robustness of the method for realistic, non‑regular networks. A special case of bipartite graphs is also treated: because dependencies are confined to one side of the bipartition, the tree can be pruned more aggressively, yielding an even tighter depth bound.

Armed with these probabilistic guarantees, the paper presents three concrete applications.

1. Maximum Matching in Bounded‑Degree Graphs – By running a greedy online matching algorithm on the random permutation and answering vertex‑membership queries via the query tree, the authors obtain an LCA that uses O(log³ n) time and space per query. This improves on prior LCAs that required O(log⁴ n) or higher.

2. Load Balancing (Balls‑into‑Bins) – The framework is applied to a broad family of online load‑balancing schemes, including the classic “two‑choice” and more general “multiple‑choice” algorithms. The resulting LCAs answer insertion and load‑query operations in O(log n) time and space while preserving the same approximation guarantees (e.g., maximum load of (1+o(1))·log log n).

3. Hypergraph 2‑Coloring and k‑CNF Satisfiability – Existing LCAs for these problems had running times that grew as a function of the maximum degree d (typically O(d·polylog n)). By applying the improved query‑tree analysis, the dependence on d is eliminated from the exponent, yielding O(log⁴ n) time and space regardless of the hypergraph’s degree. This makes the algorithms practical for high‑degree instances that were previously infeasible.

The paper concludes by emphasizing that the “random permutation + query tree” paradigm provides a systematic way to localize the decision process of any online algorithm, turning sequential global reasoning into a set of small, independent local computations. The authors suggest several directions for future work: extending the analysis to power‑law degree distributions, handling dynamic updates that modify the underlying permutation, and performing empirical studies on large‑scale distributed systems to validate the theoretical gains. Overall, the work bridges the gap between online algorithm design and local computation, delivering both theoretical insight and concrete, more efficient algorithms for classic combinatorial problems.