1,744 research outputs found
How to Make Your Approximation Algorithm Private: A Black-Box Differentially-Private Transformation for Tunable Approximation Algorithms of Functions with Low Sensitivity
We develop a framework for efficiently transforming certain approximation
algorithms into differentially-private variants, in a black-box manner. Our
results focus on algorithms A that output an approximation to a function f of
the form , where 0<=a <1 is a parameter
that can be``tuned" to small-enough values while incurring only a poly blowup
in the running time/space. We show that such algorithms can be made DP without
sacrificing accuracy, as long as the function f has small global sensitivity.
We achieve these results by applying the smooth sensitivity framework developed
by Nissim, Raskhodnikova, and Smith (STOC 2007).
Our framework naturally applies to transform non-private FPRAS (resp. FPTAS)
algorithms into -DP (resp. -DP) approximation
algorithms. We apply our framework in the context of sublinear-time and
sublinear-space algorithms, while preserving the nature of the algorithm in
meaningful ranges of the parameters. Our results include the first (to the best
of our knowledge) -edge DP sublinear-time algorithm for
estimating the number of triangles, the number of connected components, and the
weight of a MST of a graph, as well as a more efficient algorithm (while
sacrificing pure DP in contrast to previous results) for estimating the average
degree of a graph. In the area of streaming algorithms, our results include
-DP algorithms for estimating L_p-norms, distinct elements,
and weighted MST for both insertion-only and turnstile streams. Our
transformation also provides a private version of the smooth histogram
framework, which is commonly used for converting streaming algorithms into
sliding window variants, and achieves a multiplicative approximation to many
problems, such as estimating L_p-norms, distinct elements, and the length of
the longest increasing subsequence
Estimating the weight of metric minimum spanning trees in sublinear time
In this paper we present a sublinear-time -approximation randomized algorithm to estimate the weight of the minimum spanning tree of an -point metric space. The running time of the algorithm is . Since the full description of an -point metric space is of size , the complexity of our algorithm is sublinear with respect to the input size. Our algorithm is almost optimal as it is not possible to approximate in time the weight of the minimum spanning tree to within any factor. We also show that no deterministic algorithm can achieve a -approximation in time. Furthermore, it has been previously shown that no algorithm exists that returns a spanning tree whose weight is within a constant times the optimum
Dynamic Graph Stream Algorithms in Space
In this paper we study graph problems in dynamic streaming model, where the
input is defined by a sequence of edge insertions and deletions. As many
natural problems require space, where is the number of
vertices, existing works mainly focused on designing space
algorithms. Although sublinear in the number of edges for dense graphs, it
could still be too large for many applications (e.g. is huge or the graph
is sparse). In this work, we give single-pass algorithms beating this space
barrier for two classes of problems.
We present space algorithms for estimating the number of connected
components with additive error and
-approximating the weight of minimum spanning tree, for any
small constant . The latter improves previous
space algorithm given by Ahn et al. (SODA 2012) for connected graphs with
bounded edge weights.
We initiate the study of approximate graph property testing in the dynamic
streaming model, where we want to distinguish graphs satisfying the property
from graphs that are -far from having the property. We consider
the problem of testing -edge connectivity, -vertex connectivity,
cycle-freeness and bipartiteness (of planar graphs), for which, we provide
algorithms using roughly space, which is
for any constant .
To complement our algorithms, we present space
lower bounds for these problems, which show that such a dependence on
is necessary.Comment: ICALP 201
Implicit Decomposition for Write-Efficient Connectivity Algorithms
The future of main memory appears to lie in the direction of new technologies
that provide strong capacity-to-performance ratios, but have write operations
that are much more expensive than reads in terms of latency, bandwidth, and
energy. Motivated by this trend, we propose sequential and parallel algorithms
to solve graph connectivity problems using significantly fewer writes than
conventional algorithms. Our primary algorithmic tool is the construction of an
-sized "implicit decomposition" of a bounded-degree graph on
nodes, which combined with read-only access to enables fast answers to
connectivity and biconnectivity queries on . The construction breaks the
linear-write "barrier", resulting in costs that are asymptotically lower than
conventional algorithms while adding only a modest cost to querying time. For
general non-sparse graphs on edges, we also provide the first writes
and operations parallel algorithms for connectivity and biconnectivity.
These algorithms provide insight into how applications can efficiently process
computations on large graphs in systems with read-write asymmetry
Fast Local Computation Algorithms
For input , let denote the set of outputs that are the "legal"
answers for a computational problem . Suppose and members of are
so large that there is not time to read them in their entirety. We propose a
model of {\em local computation algorithms} which for a given input ,
support queries by a user to values of specified locations in a legal
output . When more than one legal output exists for a given
, the local computation algorithm should output in a way that is consistent
with at least one such . Local computation algorithms are intended to
distill the common features of several concepts that have appeared in various
algorithmic subfields, including local distributed computation, local
algorithms, locally decodable codes, and local reconstruction.
We develop a technique, based on known constructions of small sample spaces
of -wise independent random variables and Beck's analysis in his algorithmic
approach to the Lov{\'{a}}sz Local Lemma, which under certain conditions can be
applied to construct local computation algorithms that run in {\em
polylogarithmic} time and space. We apply this technique to maximal independent
set computations, scheduling radio network broadcasts, hypergraph coloring and
satisfying -SAT formulas.Comment: A preliminary version of this paper appeared in ICS 2011, pp. 223-23
Approximately Counting Triangles in Sublinear Time
We consider the problem of estimating the number of triangles in a graph.
This problem has been extensively studied in both theory and practice, but all
existing algorithms read the entire graph. In this work we design a {\em
sublinear-time\/} algorithm for approximating the number of triangles in a
graph, where the algorithm is given query access to the graph. The allowed
queries are degree queries, vertex-pair queries and neighbor queries.
We show that for any given approximation parameter , the
algorithm provides an estimate such that with high constant
probability, , where
is the number of triangles in the graph . The expected query complexity of
the algorithm is , where
is the number of vertices in the graph and is the number of edges, and
the expected running time is . We also prove
that queries are necessary, thus establishing that
the query complexity of this algorithm is optimal up to polylogarithmic factors
in (and the dependence on ).Comment: To appear in the 56th Annual IEEE Symposium on Foundations of
Computer Science (FOCS 2015
Streaming Verification of Graph Computations via Graph Structure
We give new algorithms in the annotated data streaming setting - also known as verifiable data stream computation - for certain graph problems. This setting is meant to model outsourced computation, where a space-bounded verifier limited to sequential data access seeks to overcome its computational limitations by engaging a powerful prover, without needing to trust the prover. As is well established, several problems that admit no sublinear-space algorithms under traditional streaming do allow protocols using a sublinear amount of prover/verifier communication and sublinear-space verification. We give algorithms for many well-studied graph problems including triangle counting, its generalization to subgraph counting, maximum matching, problems about the existence (or not) of short paths, finding the shortest path between two vertices, and testing for an independent set. While some of these problems have been studied before, our results achieve new tradeoffs between space and communication costs that were hitherto unknown. In particular, two of our results disprove explicit conjectures of Thaler (ICALP, 2016) by giving triangle counting and maximum matching algorithms for n-vertex graphs, using o(n) space and o(n^2) communication
- …