368 research outputs found
Sparse Fault-Tolerant BFS Trees
This paper addresses the problem of designing a sparse {\em fault-tolerant}
BFS tree, or {\em FT-BFS tree} for short, namely, a sparse subgraph of the
given network such that subsequent to the failure of a single edge or
vertex, the surviving part of still contains a BFS spanning tree for
(the surviving part of) . Our main results are as follows. We present an
algorithm that for every -vertex graph and source node constructs a
(single edge failure) FT-BFS tree rooted at with O(n \cdot
\min\{\Depth(s), \sqrt{n}\}) edges, where \Depth(s) is the depth of the BFS
tree rooted at . This result is complemented by a matching lower bound,
showing that there exist -vertex graphs with a source node for which any
edge (or vertex) FT-BFS tree rooted at has edges. We then
consider {\em fault-tolerant multi-source BFS trees}, or {\em FT-MBFS trees}
for short, aiming to provide (following a failure) a BFS tree rooted at each
source for some subset of sources . Again, tight bounds
are provided, showing that there exists a poly-time algorithm that for every
-vertex graph and source set of size constructs a
(single failure) FT-MBFS tree from each source , with
edges, and on the other hand there exist
-vertex graphs with source sets of cardinality , on
which any FT-MBFS tree from has edges.
Finally, we propose an approximation algorithm for constructing
FT-BFS and FT-MBFS structures. The latter is complemented by a hardness result
stating that there exists no approximation algorithm for these
problems under standard complexity assumptions
Optimal Vertex Fault Tolerant Spanners (for fixed stretch)
A -spanner of a graph is a sparse subgraph whose shortest path
distances match those of up to a multiplicative error . In this paper we
study spanners that are resistant to faults. A subgraph is an
vertex fault tolerant (VFT) -spanner if is a -spanner
of for any small set of vertices that might "fail." One
of the main questions in the area is: what is the minimum size of an fault
tolerant -spanner that holds for all node graphs (as a function of ,
and )? This question was first studied in the context of geometric
graphs [Levcopoulos et al. STOC '98, Czumaj and Zhao SoCG '03] and has more
recently been considered in general undirected graphs [Chechik et al. STOC '09,
Dinitz and Krauthgamer PODC '11].
In this paper, we settle the question of the optimal size of a VFT spanner,
in the setting where the stretch factor is fixed. Specifically, we prove
that every (undirected, possibly weighted) -node graph has a
-spanner resilient to vertex faults with edges, and this is fully optimal (unless the famous Erdos Girth
Conjecture is false). Our lower bound even generalizes to imply that no data
structure capable of approximating similarly can
beat the space usage of our spanner in the worst case. We also consider the
edge fault tolerant (EFT) model, defined analogously with edge failures rather
than vertex failures. We show that the same spanner upper bound applies in this
setting. Our data structure lower bound extends to the case (and hence we
close the EFT problem for -approximations), but it falls to for . We leave it as an open problem to
close this gap.Comment: To appear in SODA 201
Path-Fault-Tolerant Approximate Shortest-Path Trees
Let be an -nodes non-negatively real-weighted undirected graph.
In this paper we show how to enrich a {\em single-source shortest-path tree}
(SPT) of with a \emph{sparse} set of \emph{auxiliary} edges selected from
, in order to create a structure which tolerates effectively a \emph{path
failure} in the SPT. This consists of a simultaneous fault of a set of at
most adjacent edges along a shortest path emanating from the source, and it
is recognized as one of the most frequent disruption in an SPT. We show that,
for any integer parameter , it is possible to provide a very sparse
(i.e., of size ) auxiliary structure that carefully
approximates (i.e., within a stretch factor of ) the true
shortest paths from the source during the lifetime of the failure. Moreover, we
show that our construction can be further refined to get a stretch factor of
and a size of for the special case , and that it can be
converted into a very efficient \emph{approximate-distance sensitivity oracle},
that allows to quickly (even in optimal time, if ) reconstruct the
shortest paths (w.r.t. our structure) from the source after a path failure,
thus permitting to perform promptly the needed rerouting operations. Our
structure compares favorably with previous known solutions, as we discuss in
the paper, and moreover it is also very effective in practice, as we assess
through a large set of experiments.Comment: 21 pages, 3 figures, SIROCCO 201
Deep Distance Sensitivity Oracles
One of the most fundamental graph problems is finding a shortest path from a
source to a target node. While in its basic forms the problem has been studied
extensively and efficient algorithms are known, it becomes significantly harder
as soon as parts of the graph are susceptible to failure. Although one can
recompute a shortest replacement path after every outage, this is rather
inefficient both in time and/or storage. One way to overcome this problem is to
shift computational burden from the queries into a pre-processing step, where a
data structure is computed that allows for fast querying of replacement paths,
typically referred to as a Distance Sensitivity Oracle (DSO). While DSOs have
been extensively studied in the theoretical computer science community, to the
best of our knowledge this is the first work to construct DSOs using deep
learning techniques. We show how to use deep learning to utilize a
combinatorial structure of replacement paths. More specifically, we utilize the
combinatorial structure of replacement paths as a concatenation of shortest
paths and use deep learning to find the pivot nodes for stitching shortest
paths into replacement paths.Comment: arXiv admin note: text overlap with arXiv:2007.11495 by other author
Restorable Shortest Path Tiebreaking for Edge-Faulty Graphs
The restoration lemma by Afek, Bremler-Barr, Kaplan, Cohen, and Merritt
[Dist. Comp. '02] proves that, in an undirected unweighted graph, any
replacement shortest path avoiding a failing edge can be expressed as the
concatenation of two original shortest paths. However, the lemma is
tiebreaking-sensitive: if one selects a particular canonical shortest path for
each node pair, it is no longer guaranteed that one can build replacement paths
by concatenating two selected shortest paths. They left as an open problem
whether a method of shortest path tiebreaking with this desirable property is
generally possible.
We settle this question affirmatively with the first general construction of
restorable tiebreaking schemes. We then show applications to various problems
in fault-tolerant network design. These include a faster algorithm for subset
replacement paths, more efficient fault-tolerant (exact) distance labeling
schemes, fault-tolerant subset distance preservers and additive spanners
with improved sparsity, and fast distributed algorithms that construct these
objects. For example, an almost immediate corollary of our restorable
tiebreaking scheme is the first nontrivial distributed construction of sparse
fault-tolerant distance preservers resilient to three faults
Node Labels in Local Decision
The role of unique node identifiers in network computing is well understood
as far as symmetry breaking is concerned. However, the unique identifiers also
leak information about the computing environment - in particular, they provide
some nodes with information related to the size of the network. It was recently
proved that in the context of local decision, there are some decision problems
such that (1) they cannot be solved without unique identifiers, and (2) unique
node identifiers leak a sufficient amount of information such that the problem
becomes solvable (PODC 2013).
In this work we give study what is the minimal amount of information that we
need to leak from the environment to the nodes in order to solve local decision
problems. Our key results are related to scalar oracles that, for any given
, provide a multiset of labels; then the adversary assigns the
labels to the nodes in the network. This is a direct generalisation of the
usual assumption of unique node identifiers. We give a complete
characterisation of the weakest oracle that leaks at least as much information
as the unique identifiers.
Our main result is the following dichotomy: we classify scalar oracles as
large and small, depending on their asymptotic behaviour, and show that (1) any
large oracle is at least as powerful as the unique identifiers in the context
of local decision problems, while (2) for any small oracle there are local
decision problems that still benefit from unique identifiers.Comment: Conference version to appear in the proceedings of SIROCCO 201
- …