Corpus ID: 235829874

The Element Extraction Problem and the Cost of Determinism and Limited Adaptivity in Linear Queries

@article{Chakrabarti2021TheEE,
  title={The Element Extraction Problem and the Cost of Determinism and Limited Adaptivity in Linear Queries},
  author={Amit Chakrabarti and Manuel Stoeckl},
  journal={ArXiv},
  year={2021},
  volume={abs/2107.05810}
}
Two widely-used computational paradigms for sublinear algorithms are using linear measurements to perform computations on a high dimensional input and using structured queries to access a massive input. Typically, algorithms in the former paradigm are non-adaptive whereas those in the latter are highly adaptive. This work studies the fundamental search problem of ELEMENT-EXTRACTION in a query model that combines both: linear measurements with bounded adaptivity. In the ELEMENT-EXTRACTION… Expand

References

SHOWING 1-10 OF 63 REFERENCES
The adaptive complexity of maximizing a submodular function
TLDR
The result implies that in the realizable case, where there is a true underlying function generating the data, Θ(log n) batches of adaptive samples are necessary and sufficient to approximately “learn to optimize” a monotone submodular function under a cardinality constraint. Expand
An optimal algorithm for the distinct elements problem
TLDR
The first optimal algorithm for estimating the number of distinct elements in a data stream is given, closing a long line of theoretical research on this problem, and has optimal O(1) update and reporting times. Expand
Near-optimal linear decision trees for k-SUM and related problems
TLDR
These constructions are based on the notion of “inference dimension”, recently introduced by the authors in the context of active classification with comparison queries, and can be viewed as another contribution to the fruitful link between machine learning and discrete geometry, which goes back to the discovery of the VC dimension. Expand
Turnstile streaming algorithms might as well be linear sketches
TLDR
This work shows that to prove space lower bounds for 1-pass streaming algorithms, it suffices to prove lower bounds in the simultaneous model of communication complexity, rather than the stronger 1-way model. Expand
Incidence Geometries and the Pass Complexity of Semi-Streaming Set Cover
TLDR
The tight bounds on the best approximation factor achievable in p passes turn out to be Θp(min{n1/(p+1), e--1/p}), which may be thought of as vast generalisations of affine planes. Expand
Randomized Approximate Nearest Neighbor Search with Limited Adaptivity
TLDR
An Ω( 1/k(log d)1/k) lower bound is proved for the total number of memory accesses required by any randomized algorithm solving the approximate nearest neighbor search within k ≤ (log log d)/(2 log log log d) rounds of parallelMemory accesses on any data structures of polynomial size. Expand
Learning with Limited Rounds of Adaptivity: Coin Tossing, Multi-Armed Bandits, and Ranking from Pairwise Comparisons
TLDR
This work derives essentially matching upper and lower bounds on the query complexity of r-round algorithms, and shows that Θ(log∗ n) rounds are both necessary and sufficient for achieving the optimal worst case query complexity for identifying the k most biased coins. Expand
The Complexity of Parallel Search
TLDR
Lower and upper bounds on the deterministic and randomized complexity of parallel search algorithms are derived to establish that randomized parallel algorithms are much more powerful than deterministic ones, and to show that even randomized algorithms cannot make effective use of extremely large numbers of processors. Expand
Lower bounds for predecessor searching in the cell probe model
TLDR
A strong round elimination lemma for communication complexity that enables a tight lower bound for the predecessor problem and also extends to quantum communication complexity. Expand
Separations in query complexity based on pointer functions
TLDR
This work shows that the largest separation between deterministic and zero-error randomized query complexity for a total boolean function is given by the function f on n=2k bits defined by a complete binary tree of NAND gates of depth k, which achieves R0(f) = O(D( f)0.7537…). Expand
...
1
2
3
4
5
...