Designing Local Computation Algorithms and Mechanisms

Local computation algorithms (LCAs) produce small parts of a single solution to a given search problem using time and space polylogarithmic in the size of the input. Consider, for example, a massive graph on which we would like to compute a maximal independent set (MIS). The graph is so big that computing the entire solution would simply take too long, and we do not have enough space to store the solution. Assume, though, that we never need the entire solution at any given time. Instead, we are occasionally queried about whether certain vertices are in the MIS. An LCA would allow us to reply to these queries consistently (i.e., if the LCA is queried on all of the vertices the replies would conform to a coherent solution), using polylogarithmic time and space. In this work we study several techniques for designing LCAs, and provide some useful tools for future research. We introduce a new graph family, d-light graphs, that includes graphs of constant bounded degree and several interesting randomly generated graphs, such as ErdősRényi graphs, and bipartite graphs where vertices on one side are linked to d vertices on the other, chosen uniformly at random. We show how to reduce LCAs for certain problems on this graph family to distributed and online algorithms. The reduction to distributed algorithms is due to Parnas and Ron [86]; its analysis on d-light graphs is new. We derive a reduction to online algorithms that is based on an idea by Onak and Nguyen [79]: generate a random order on the vertices and simulate the online algorithm on this order. We show a small seed of length O(log n) is sufficient to generate the randomness we need, and that with high probability, we do not require more than O(log n) time or space to reply to each query. These reductions allow us to obtain LCAs for problems such as MIS, maximal matching, load balancing and vertex coloring on d-light graphs. We also extend these techniques to obtain a (1 − )-approximation LCA to maximum matching on graphs of constant bounded degree. We further show that in some cases, we can design LCAs whose running time (and space) is independent of the size of the graph, and depends only on the maximal degree. Specifically, we give a (1 − )-approximation LCA to the maximal weighted base of a graphic matroid (i.e., maximal acyclic edge set); LCAs for approximating multicut and integer multicommodity flow on trees; and a local reduction of weighted matching to any unweighted matching LCA, such that the running time of the weighted matching LCA is independent of the edge weight function. The field of mechanism design involves designing algorithms for strategic environments ones in which input to the algorithm consists of (or includes) private information divulged by agents who have a stake in the outcome. We introduce local computation mechanism design designing mechanisms that are queried on a single agent, and are required to return the part of the solution that is relevant to her (the agent), while preserving the required global game theoretic properties. As an example, consider an auction of millions of items to millions of agents. When queried on an agent, we would like our mechanism to tell us which items she gets and how much she has to pay, and at the same time incentivize all agents to be truthful about their valuations for the items. Similarly to LCAs, local computation mechanisms reply to each query in polylogarithmic time and space, and the replies to different queries are consistent with the same global feasible solution. When the mechanism employs payments, the computation of the payments is also done in polylogarithmic time and space. We present local computation mechanisms for a variety of classical game-theoretical problems: (1) stable matching, (2) job scheduling, (3) combinatorial auctions for unitdemand and k-minded bidders, and (4) the housing allocation problem. For stable matching, some of our techniques have implications to the global (nonLCA) setting. Specifically, we show that when the men’s preference lists are bounded, we can achieve an arbitrarily good approximation to the stable matching within a fixed number of iterations of the Gale-Shapley algorithm.