Recently Rubinfeld et al. (ICS 2011, pp. 223-238) proposed a new model of sublinear algorithms called local computation algorithms. In this model, a computation problem F may have more than one legal solution and each of them consists of many bits. The local computation algorithm for F should answer in an online fashion, for any index i, the i th bit of some legal solution of F . Further, all the answers given by the algorithm should be consistent with at least one solution of F . In this work, we continue the study of local computation algorithms. In particular, we develop a technique which under certain conditions can be applied to construct local computation algorithms that run not only in polylogarithmic time but also in polylogarithmic space. Moreover, these local computation algorithms are easily parallelizable and can answer all parallel queries consistently. Our main technical tools are pseudorandom numbers with bounded independence and the theory of branching processes.

Abstract. We propose a general method for converting online algorithms to local computation algorithms, 3 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 this improved 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.

We present a polylogarithmic local computation matching algorithm which guarantees a (1−ǫ)-approximation to the maximum matching in graphs of bounded degree.Related work. In the distributed setting, Itai and Israeli [10] showed a randomized algorithm which computes a maximal matching (which is a 1/2-approximation to the maximum matching) and runs in O(log n) time with high probability. This result has been improved several times since (e.g., [4,8]); of particular relevance is the approximation scheme of Lotker et al. [13], which, for every ǫ > 0, computes a (1 − ǫ)-approximation to the maximum matching in O(log n) time. Kuhn et al., [11] proved that any distributed algorithm, randomized or deterministic, requires (in expectation) Ω( log n/ log log n) time to compute a Θ(1)-approximation to the maximum matching, even if the message size is unbounded. ⋆

Given an input x, and a search problem F , local computation algorithms (LCAs) implement access to specified locations of y in a legal output y ∈ F (x), using polylogarithmic time and space. Mansour et al., (2012), had previously shown how to convert certain online algorithms to LCAs. In this work, we expand on that line of work and develop new techniques for designing LCAs and bounding their space and time complexity. Our contributions are fourfold: (1) We significantly improve the running times and space requirements of LCAs for previous results, (2) we expand and better define the family of online algorithms which can be converted to LCAs using our techniques, (3) we show that our results apply to a larger family of graphs than that of previous results, and (4) our proofs are simpler and more concise than the previous proof methods.For example, we show how to construct LCAs that require O(log n log log n) space and O(log 2 n) time (and expected time O(log log n)) for problems such as maximal matching on a large family of graphs, as opposed to the henceforth best results that required O(log 3 n) space and O(log 4 n) time, and applied to a smaller family of graphs.

In this paper we present an analysis of dynamic fair division of a divisible resource, with arrivals and departures of agents. Our key requirement is that we wish to disrupt the allocation of at most a small number of existing agents whenever a new agent arrives. We construct optimal recursive mechanisms to compute the allocations and provide tight analytic bounds. Our analysis relies on a linear programming formulation and a reduction of the feasible region of the LP into a class of "harmonic allocations", which play a key role in the trade-off between the fairness of current allocations and the fairness of potential future allocations. We show that there exist mechanisms that are optimal with respect to fairness and are also Pareto efficient, which is of fundamental importance in computing applications, as system designers loathe to waste resources. In addition, our mechanisms satisfy a number of other desirable game theoretic properties.