165 research outputs found
Labeling Schemes with Queries
We study the question of ``how robust are the known lower bounds of labeling
schemes when one increases the number of consulted labels''. Let be a
function on pairs of vertices. An -labeling scheme for a family of graphs
\cF labels the vertices of all graphs in \cF such that for every graph
G\in\cF and every two vertices , the value can be inferred
by merely inspecting the labels of and .
This paper introduces a natural generalization: the notion of -labeling
schemes with queries, in which the value can be inferred by inspecting
not only the labels of and but possibly the labels of some additional
vertices. We show that inspecting the label of a single additional vertex (one
{\em query}) enables us to reduce the label size of many labeling schemes
significantly
Optimal competitiveness for Symmetric Rectilinear Steiner Arborescence and related problems
We present optimal competitive algorithms for two interrelated known problems
involving Steiner Arborescence. One is the continuous problem of the Symmetric
Rectilinear Steiner Arborescence (SRSA), studied by Berman and Coulston.
A very related, but discrete problem (studied separately in the past) is the
online Multimedia Content Delivery (MCD) problem on line networks, presented
originally by Papadimitriu, Ramanathan, and Rangan. An efficient content
delivery was modeled as a low cost Steiner arborescence in a grid of
network*time they defined. We study here the version studied by Charikar,
Halperin, and Motwani (who used the same problem definitions, but removed some
constraints on the inputs).
The bounds on the competitive ratios introduced separately in the above
papers are similar for the two problems: O(log N) for the continuous problem
and O(log n) for the network problem, where N was the number of terminals to
serve, and n was the size of the network. The lower bounds were Omega(sqrt{log
N}) and Omega(sqrt{log n}) correspondingly. Berman and Coulston conjectured
that both the upper bound and the lower bound could be improved.
We disprove this conjecture and close these quadratic gaps for both problems.
We first present an O(sqrt{log n}) deterministic competitive algorithm for MCD
on the line, matching the lower bound. We then translate this algorithm to
become a competitive optimal algorithm O(sqrt{log N}) for SRSA. Finally, we
translate the latter back to solve MCD problem, this time competitive optimally
even in the case that the number of requests is small (that is, O(min{sqrt{log
n},sqrt{log N}})). We also present a Omega(sqrt[3]{log n}) lower bound on the
competitiveness of any randomized algorithm. Some of the techniques may be
useful in other contexts
Fast and compact self-stabilizing verification, computation, and fault detection of an MST
This paper demonstrates the usefulness of distributed local verification of
proofs, as a tool for the design of self-stabilizing algorithms.In particular,
it introduces a somewhat generalized notion of distributed local proofs, and
utilizes it for improving the time complexity significantly, while maintaining
space optimality. As a result, we show that optimizing the memory size carries
at most a small cost in terms of time, in the context of Minimum Spanning Tree
(MST). That is, we present algorithms that are both time and space efficient
for both constructing an MST and for verifying it.This involves several parts
that may be considered contributions in themselves.First, we generalize the
notion of local proofs, trading off the time complexity for memory efficiency.
This adds a dimension to the study of distributed local proofs, which has been
gaining attention recently. Specifically, we design a (self-stabilizing) proof
labeling scheme which is memory optimal (i.e., bits per node), and
whose time complexity is in synchronous networks, or time in asynchronous ones, where is the maximum degree of
nodes. This answers an open problem posed by Awerbuch and Varghese (FOCS 1991).
We also show that time is necessary, even in synchronous
networks. Another property is that if faults occurred, then, within the
requireddetection time above, they are detected by some node in the locality of each of the faults.Second, we show how to enhance a known
transformer that makes input/output algorithms self-stabilizing. It now takes
as input an efficient construction algorithm and an efficient self-stabilizing
proof labeling scheme, and produces an efficient self-stabilizing algorithm.
When used for MST, the transformer produces a memory optimal self-stabilizing
algorithm, whose time complexity, namely, , is significantly better even
than that of previous algorithms. (The time complexity of previous MST
algorithms that used memory bits per node was , and
the time for optimal space algorithms was .) Inherited from our proof
labelling scheme, our self-stabilising MST construction algorithm also has the
following two properties: (1) if faults occur after the construction ended,
then they are detected by some nodes within time in synchronous
networks, or within time in asynchronous ones, and (2) if
faults occurred, then, within the required detection time above, they are
detected within the locality of each of the faults. We also show
how to improve the above two properties, at the expense of some increase in the
memory
Message Reduction in the LOCAL Model Is a Free Lunch
A new spanner construction algorithm is presented, working under the LOCAL model with unique edge IDs. Given an n-node communication graph, a spanner with a constant stretch and O(n^{1 + epsilon}) edges (for an arbitrarily small constant epsilon > 0) is constructed in a constant number of rounds sending O(n^{1 + epsilon}) messages whp. Consequently, we conclude that every t-round LOCAL algorithm can be transformed into an O(t)-round LOCAL algorithm that sends O(t * n^{1 + epsilon}) messages whp. This improves upon all previous message-reduction schemes for LOCAL algorithms that incur a log^{Omega (1)} n blow-up of the round complexity
Controller and estimator for dynamic networks
International audienceAfek, Awerbuch, Plotkin, and Saks identified an important fundamental problem inherent to distributed networks, which they called the Resource Controller problem. Consider, first, the problem in which one node (called the 'root') is required to estimate the number of events that occurred all over the network. This counting problem can be viewed as a useful variant of the heavily studied and used task of topology update (that deals with collecting all remote information). The Resource Controller problem generalizes the counting problem: such remote events are considered as requests, and the counting node, i.e., the 'root', also issues permits for the requests. That way, the number of requests granted can be controlled (bounded). An efficient Resource Controller was constructed in the paper by Afek et al., and it can operate on a dynamic network assuming that the network is spanned by a tree that may only grow, and only by allowing leaves to join the tree. In contrast, the Resource Controller presented here can operate under a more general dynamic model, allowing the spanning tree of the network to undergo both insertions and deletions of both leaves and internal nodes. Despite the more dynamic network model we allow, the message complexity of our controller is never more than the message complexity of the more restricted controller. All the applications for the controller of Afek et al. can be used also with our controller. Moreover, with the same message complexity, our controller can handle these applications under the more general dynamic model mentioned above. In particular, the new controller can be transformed into an efficient size-estimation protocol, i.e., a protocol allowing all nodes to maintain a constant factor estimation of the number of nodes in the dynamically changing network. Informally, the resulting new size-estimation protocol uses View the MathML source amortized message complexity per topological change (assuming that the number of changes in the network size is "not too small"), where n is the current number of nodes in the network. An application of the size estimation of Afek et al. was to solve agreement in the case of initial faults (Fischer, Lynch, and Paterson) and leader election under initial faults (Bar-Yehuda and Kutten). Hence, the controllers in this paper can be useful for these applications too
Approximating Generalized Network Design under (Dis)economies of Scale with Applications to Energy Efficiency
In a generalized network design (GND) problem, a set of resources are
assigned to multiple communication requests. Each request contributes its
weight to the resources it uses and the total load on a resource is then
translated to the cost it incurs via a resource specific cost function. For
example, a request may be to establish a virtual circuit, thus contributing to
the load on each edge in the circuit. Motivated by energy efficiency
applications, recently, there is a growing interest in GND using cost functions
that exhibit (dis)economies of scale ((D)oS), namely, cost functions that
appear subadditive for small loads and superadditive for larger loads.
The current paper advances the existing literature on approximation
algorithms for GND problems with (D)oS cost functions in various aspects: (1)
we present a generic approximation framework that yields approximation results
for a much wider family of requests in both directed and undirected graphs; (2)
our framework allows for unrelated weights, thus providing the first
non-trivial approximation for the problem of scheduling unrelated parallel
machines with (D)oS cost functions; (3) our framework is fully combinatorial
and runs in strongly polynomial time; (4) the family of (D)oS cost functions
considered in the current paper is more general than the one considered in the
existing literature, providing a more accurate abstraction for practical energy
conservation scenarios; and (5) we obtain the first approximation ratio for GND
with (D)oS cost functions that depends only on the parameters of the resources'
technology and does not grow with the number of resources, the number of
requests, or their weights. The design of our framework relies heavily on
Roughgarden's smoothness toolbox (JACM 2015), thus demonstrating the possible
usefulness of this toolbox in the area of approximation algorithms.Comment: 39 pages, 1 figure. An extended abstract of this paper is to appear
in the 50th Annual ACM Symposium on the Theory of Computing (STOC 2018
A note on models for graph representations
AbstractThis paper is intended more to ask questions than give answers. Specifically, we consider models for labeling schemes, and discuss issues regarding the number of labels consulted vs. the sizes of the labels.Recently, quite a few papers studied methods for representing network properties by assigning informative labels to the vertices of a network. Consider a graph function f on pairs of vertices (for example, f can be the distance function). In an f-labeling scheme, the labels are constructed in such a way so that given the labels of any two vertices u and v, one can compute the function f(u,v) (e.g. the graph distance between u and v) just by looking at these two labels. Some very involved lower bounds for the sizes of the labels were proven. Also, some highly sophisticated labeling schemes were developed to ensure short labels.In this paper, we demonstrate that such lower bounds are very sensitive to the number of vertices consulted. That is, we show several constructions of such labeling schemes that beat the lower bounds by large margins. Moreover, as opposed to the strong technical skills that were needed to develop the traditional labeling schemes, most of our schemes are almost trivial. The catch is that in our model, one needs to consult the labels of three vertices instead of two. That is, a query about vertices u and v can access also the label of some third vertex w (w is determined by the labels of u and v). More generally, we address the model in which a query about vertices u and v can access also the labels of c other vertices. We term our generalized model labeling schemes with queries.The main importance of this model is theoretical. Specifically, this paper may serve as a first step towards investigating different tradeoffs between the amount of labels consulted and the amount of information stored at each vertex. As we show, if all vertices can be consulted then the problem almost reduces to the corresponding sequential problem. On the other hand, consulting just the labels of u and v (or even just the label of u) reduces the problem to a purely distributed one. Therefore, in a sense, our model spans a range of intermediate notions between the sequential and the distributed settings.In addition to the theoretical interest, we also show cases that schemes constructed for our model can be translated to the traditional model or to the sequential model, thus, simplifying the construction for those models as well. For implementing query labeling schemes in a distributed environment directly, we point at a potential usage for some new paradigms that became common recently, such as P2P and overlay networks
- …