489 research outputs found
A Quasi-Polynomial Time Partition Oracle for Graphs with an Excluded Minor
Motivated by the problem of testing planarity and related properties, we
study the problem of designing efficient {\em partition oracles}. A {\em
partition oracle} is a procedure that, given access to the incidence lists
representation of a bounded-degree graph and a parameter \eps,
when queried on a vertex , returns the part (subset of vertices) which
belongs to in a partition of all graph vertices. The partition should be
such that all parts are small, each part is connected, and if the graph has
certain properties, the total number of edges between parts is at most \eps
|V|. In this work we give a partition oracle for graphs with excluded minors
whose query complexity is quasi-polynomial in 1/\eps, thus improving on the
result of Hassidim et al. ({\em Proceedings of FOCS 2009}) who gave a partition
oracle with query complexity exponential in 1/\eps. This improvement implies
corresponding improvements in the complexity of testing planarity and other
properties that are characterized by excluded minors as well as sublinear-time
approximation algorithms that work under the promise that the graph has an
excluded minor.Comment: 13 pages, 1 figur
A Local Algorithm for Constructing Spanners in Minor-Free Graphs
Constructing a spanning tree of a graph is one of the most basic tasks in
graph theory. We consider this problem in the setting of local algorithms: one
wants to quickly determine whether a given edge is in a specific spanning
tree, without computing the whole spanning tree, but rather by inspecting the
local neighborhood of . The challenge is to maintain consistency. That is,
to answer queries about different edges according to the same spanning tree.
Since it is known that this problem cannot be solved without essentially
viewing all the graph, we consider the relaxed version of finding a spanning
subgraph with edges (where is the number of vertices and
is a given sparsity parameter). It is known that this relaxed
problem requires inspecting edges in general graphs, which
motivates the study of natural restricted families of graphs. One such family
is the family of graphs with an excluded minor. For this family there is an
algorithm that achieves constant success probability, and inspects
edges (for each edge it is queried
on), where is the maximum degree in the graph and is the size of the
excluded minor. The distances between pairs of vertices in the spanning
subgraph are at most a factor of larger than in
.
In this work, we show that for an input graph that is -minor free for any
of size , this task can be performed by inspecting only edges. The distances between pairs of vertices in the spanning
subgraph are at most a factor of larger
than in . Furthermore, the error probability of the new algorithm is
significantly improved to . This algorithm can also be easily
adapted to yield an efficient algorithm for the distributed setting
Testing bounded arboricity
In this paper we consider the problem of testing whether a graph has bounded
arboricity. The family of graphs with bounded arboricity includes, among
others, bounded-degree graphs, all minor-closed graph classes (e.g. planar
graphs, graphs with bounded treewidth) and randomly generated preferential
attachment graphs. Graphs with bounded arboricity have been studied extensively
in the past, in particular since for many problems they allow for much more
efficient algorithms and/or better approximation ratios.
We present a tolerant tester in the sparse-graphs model. The sparse-graphs
model allows access to degree queries and neighbor queries, and the distance is
defined with respect to the actual number of edges. More specifically, our
algorithm distinguishes between graphs that are -close to having
arboricity and graphs that -far from having
arboricity , where is an absolute small constant. The query
complexity and running time of the algorithm are
where denotes
the number of vertices and denotes the number of edges. In terms of the
dependence on and this bound is optimal up to poly-logarithmic factors
since queries are necessary (and .
We leave it as an open question whether the dependence on can be
improved from quasi-polynomial to polynomial. Our techniques include an
efficient local simulation for approximating the outcome of a global (almost)
forest-decomposition algorithm as well as a tailored procedure of edge
sampling
Every property is testable on a natural class of scale-free multigraphs
In this paper, we introduce a natural class of multigraphs called
hierarchical-scale-free (HSF) multigraphs, and consider constant-time
testability on the class. We show that a very wide subclass, specifically, that
in which the power-law exponent is greater than two, of HSF is hyperfinite.
Based on this result, an algorithm for a deterministic partitioning oracle can
be constructed. We conclude by showing that every property is constant-time
testable on the above subclass of HSF. This algorithm utilizes findings by
Newman and Sohler of STOC'11. However, their algorithm is based on the
bounded-degree model, while it is known that actual scale-free networks usually
include hubs, which have a very large degree. HSF is based on scale-free
properties and includes such hubs. This is the first universal result of
constant-time testability on the general graph model, and it has the potential
to be applicable on a very wide range of scale-free networks.Comment: 13 pages, one figure. Difference from ver. 1: Definitions of HSF and
SF become more general. Typos were fixe
A Sublinear Tester for Outerplanarity (and Other Forbidden Minors) With One-Sided Error
We consider one-sided error property testing of -minor freeness
in bounded-degree graphs for any finite family of graphs that
contains a minor of , the -circus graph, or the -grid
for any . This includes, for instance, testing whether a graph
is outerplanar or a cactus graph. The query complexity of our algorithm in
terms of the number of vertices in the graph, , is . Czumaj et~al.\ showed that cycle-freeness and -minor
freeness can be tested with query complexity by using
random walks, and that testing -minor freeness for any that contains a
cycles requires queries. In contrast to these results, we
analyze the structure of the graph and show that either we can find a subgraph
of sublinear size that includes the forbidden minor , or we can find a pair
of disjoint subsets of vertices whose edge-cut is large, which induces an
-minor.Comment: extended to testing outerplanarity, full version of ICALP pape
Local Algorithms for Sparse Spanning Graphs
We initiate the study of the problem of designing sublinear-time (local) algorithms that, given an edge (u,v) in a connected graph G=(V,E), decide whether (u,v) belongs to a sparse spanning graph G\u27 = (V,E\u27) of G. Namely, G\u27 should be connected and |E\u27| should be upper bounded by (1+epsilon)|V| for a given parameter epsilon > 0. To this end the algorithms may query the incidence relation of the graph G, and we seek algorithms whose query complexity and running time (per given edge (u,v)) is as small as possible. Such an algorithm may be randomized but (for a fixed choice of its random coins) its decision on different edges in the graph should be consistent with the same spanning graph G\u27 and independent of the order of queries.
We first show that for general (bounded-degree) graphs, the query complexity of any such algorithm must be Omega(sqrt{|V|}). This lower bound holds for graphs that have high expansion. We then turn to design and analyze algorithms both for graphs with high expansion (obtaining a result that roughly matches the lower bound) and for graphs that are (strongly) non-expanding (obtaining results in which the complexity does not depend on |V|). The complexity of the problem for graphs that do not fall into these two categories is left as an open question
A Local Algorithm for the Sparse Spanning Graph Problem
Constructing a sparse spanning subgraph is a fundamental primitive in graph
theory. In this paper, we study this problem in the Centralized Local model,
where the goal is to decide whether an edge is part of the spanning subgraph by
examining only a small part of the input; yet, answers must be globally
consistent and independent of prior queries.
Unfortunately, maximally sparse spanning subgraphs, i.e., spanning trees,
cannot be constructed efficiently in this model. Therefore, we settle for a
spanning subgraph containing at most edges (where is the
number of vertices and is a given approximation/sparsity
parameter). We achieve query complexity of
, (-notation hides
polylogarithmic factors in ). where is the maximum degree of the
input graph. Our algorithm is the first to do so on arbitrary bounded degree
graphs. Moreover, we achieve the additional property that our algorithm outputs
a spanner, i.e., distances are approximately preserved. With high probability,
for each deleted edge there is a path of
hops in the output that connects its endpoints
Approximating the Spectrum of a Graph
The spectrum of a network or graph with adjacency matrix ,
consists of the eigenvalues of the normalized Laplacian . This set of eigenvalues encapsulates many aspects of the structure
of the graph, including the extent to which the graph posses community
structures at multiple scales. We study the problem of approximating the
spectrum , of in the regime where the graph is too
large to explicitly calculate the spectrum. We present a sublinear time
algorithm that, given the ability to query a random node in the graph and
select a random neighbor of a given node, computes a succinct representation of
an approximation , such that . Our algorithm has query complexity and running time ,
independent of the size of the graph, . We demonstrate the practical
viability of our algorithm on 15 different real-world graphs from the Stanford
Large Network Dataset Collection, including social networks, academic
collaboration graphs, and road networks. For the smallest of these graphs, we
are able to validate the accuracy of our algorithm by explicitly calculating
the true spectrum; for the larger graphs, such a calculation is computationally
prohibitive.
In addition we study the implications of our algorithm to property testing in
the bounded degree graph model
- …