41,698 research outputs found
Solving -SUM using few linear queries
The -SUM problem is given input real numbers to determine whether any
of them sum to zero. The problem is of tremendous importance in the
emerging field of complexity theory within , and it is in particular open
whether it admits an algorithm of complexity with . Inspired by an algorithm due to Meiser (1993), we show
that there exist linear decision trees and algebraic computation trees of depth
solving -SUM. Furthermore, we show that there exists a
randomized algorithm that runs in
time, and performs linear queries on the input. Thus, we show
that it is possible to have an algorithm with a runtime almost identical (up to
the ) to the best known algorithm but for the first time also with the
number of queries on the input a polynomial that is independent of . The
bound on the number of linear queries is also a tighter bound
than any known algorithm solving -SUM, even allowing unlimited total time
outside of the queries. By simultaneously achieving few queries to the input
without significantly sacrificing runtime vis-\`{a}-vis known algorithms, we
deepen the understanding of this canonical problem which is a cornerstone of
complexity-within-.
We also consider a range of tradeoffs between the number of terms involved in
the queries and the depth of the decision tree. In particular, we prove that
there exist -linear decision trees of depth
Solving k-SUM Using Few Linear Queries
The k-SUM problem is given n input real numbers to determine whether any k of them sum to zero. The problem is of tremendous importance in the emerging field of complexity theory within P, and it is in particular open whether it admits an algorithm of complexity O(n^c) with c<d where d is the ceiling of k/2. Inspired by an algorithm due to Meiser (1993), we show that there exist linear decision trees and algebraic computation trees of depth O(n^3 log^2 n) solving k-SUM. Furthermore, we show that there exists a randomized algorithm that runs in ~O(n^{d+8}) time, and performs O(n^3 log^2 n) linear queries on the input. Thus, we show that it is possible to have an algorithm with a runtime almost identical (up to the +8) to the best known algorithm but for the first time also with the number of queries on the input a polynomial that is independent of k. The O(n^3 log^2 n) bound on the number of linear queries is also a tighter bound than any known algorithm solving k-SUM, even allowing unlimited total time outside of the queries. By simultaneously achieving few queries to the input without significantly sacrificing runtime vis-a-vis known algorithms, we deepen the understanding of this canonical problem which is a cornerstone of complexity-within-P.
We also consider a range of tradeoffs between the number of terms involved in the queries and the depth of the decision tree. In particular, we prove that there exist o(n)-linear decision trees of depth ~O(n^3) for the
k-SUM problem
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
Optimal web-scale tiering as a flow problem
We present a fast online solver for large scale parametric max-flow problems as they occur in portfolio optimization, inventory management, computer vision, and logistics. Our algorithm solves an integer linear program in an online fashion. It exploits total unimodularity of the constraint matrix and a Lagrangian relaxation to solve the problem as a convex online game. The algorithm generates approximate solutions of max-flow problems by performing stochastic gradient descent on a set of flows. We apply the algorithm to optimize tier arrangement of over 84 million web pages on a layered set of caches to serve an incoming query stream optimally
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
Quantum SDP-Solvers: Better upper and lower bounds
Brand\~ao and Svore very recently gave quantum algorithms for approximately
solving semidefinite programs, which in some regimes are faster than the
best-possible classical algorithms in terms of the dimension of the problem
and the number of constraints, but worse in terms of various other
parameters. In this paper we improve their algorithms in several ways, getting
better dependence on those other parameters. To this end we develop new
techniques for quantum algorithms, for instance a general way to efficiently
implement smooth functions of sparse Hamiltonians, and a generalized
minimum-finding procedure.
We also show limits on this approach to quantum SDP-solvers, for instance for
combinatorial optimizations problems that have a lot of symmetry. Finally, we
prove some general lower bounds showing that in the worst case, the complexity
of every quantum LP-solver (and hence also SDP-solver) has to scale linearly
with when , which is the same as classical.Comment: v4: 69 pages, small corrections and clarifications. This version will
appear in Quantu
- …