3,102 research outputs found
Efficient Batch Query Answering Under Differential Privacy
Differential privacy is a rigorous privacy condition achieved by randomizing
query answers. This paper develops efficient algorithms for answering multiple
queries under differential privacy with low error. We pursue this goal by
advancing a recent approach called the matrix mechanism, which generalizes
standard differentially private mechanisms. This new mechanism works by first
answering a different set of queries (a strategy) and then inferring the
answers to the desired workload of queries. Although a few strategies are known
to work well on specific workloads, finding the strategy which minimizes error
on an arbitrary workload is intractable. We prove a new lower bound on the
optimal error of this mechanism, and we propose an efficient algorithm that
approaches this bound for a wide range of workloads.Comment: 6 figues, 22 page
An Adaptive Mechanism for Accurate Query Answering under Differential Privacy
We propose a novel mechanism for answering sets of count- ing queries under
differential privacy. Given a workload of counting queries, the mechanism
automatically selects a different set of "strategy" queries to answer
privately, using those answers to derive answers to the workload. The main
algorithm proposed in this paper approximates the optimal strategy for any
workload of linear counting queries. With no cost to the privacy guarantee, the
mechanism improves significantly on prior approaches and achieves near-optimal
error for many workloads, when applied under (\epsilon, \delta)-differential
privacy. The result is an adaptive mechanism which can help users achieve good
utility without requiring that they reason carefully about the best formulation
of their task.Comment: VLDB2012. arXiv admin note: substantial text overlap with
arXiv:1103.136
Computing Local Sensitivities of Counting Queries with Joins
Local sensitivity of a query Q given a database instance D, i.e. how much the
output Q(D) changes when a tuple is added to D or deleted from D, has many
applications including query analysis, outlier detection, and in differential
privacy. However, it is NP-hard to find local sensitivity of a conjunctive
query in terms of the size of the query, even for the class of acyclic queries.
Although the complexity is polynomial when the query size is fixed, the naive
algorithms are not efficient for large databases and queries involving multiple
joins. In this paper, we present a novel approach to compute local sensitivity
of counting queries involving join operations by tracking and summarizing tuple
sensitivities -- the maximum change a tuple can cause in the query result when
it is added or removed. We give algorithms for the sensitivity problem for full
acyclic join queries using join trees, that run in polynomial time in both the
size of the database and query for an interesting sub-class of queries, which
we call 'doubly acyclic queries' that include path queries, and in polynomial
time in combined complexity when the maximum degree in the join tree is
bounded. Our algorithms can be extended to certain non-acyclic queries using
generalized hypertree decompositions. We evaluate our approach experimentally,
and show applications of our algorithms to obtain better results for
differential privacy by orders of magnitude.Comment: To be published in Proceedings of the 2020 ACM SIGMOD International
Conference on Management of Dat
- …