cs.DSAug 3, 2026

Randomized Algorithms for Learning Partitions with Near Optimal Query Complexity in Constant Rounds

Authors: Deeparnab Chakrabarty, Aditi Dudeja, David Saulpic

Organizations: Dartmouth College · The Chinese University of Hong Kong (Shenzhen) · CNRS and Universit´e Paris Cit´e

Abstract

We study the round complexity of learning a hidden partition P\mathcal{P} of an nn-element universe using PAIR queries: PAIR(x,yx,y) tells us whether xx and yy belong to the same part of the partition or not. While it is easy to learn using n∣P∣n|\mathcal{P}| queries using a basic algorithm and this query complexity is optimal, this basic algorithm is highly sequential. Black, Mazumdar, and Saha [COLT 2025] recently gave tight deterministic round/query tradeoffs when the number of parts of P\mathcal{P} is known. In particular they prove Θ(log⁡log⁡n)Θ(\log\log n) rounds are sufficient and necessary to limit the number of queries to n∣P∣n|\mathcal{P}|. They leave proving a randomized lower bound as an open direction. We show that randomization dramatically changes the picture. When the number of parts k=∣P∣k = |\mathcal{P}| is known, we give a simple 3-round randomized algorithm using O(nklog⁡n)O(nk\log n) queries with high probability, and prove that 2 rounds require Ω(n4/3k2/3)Ω(n^{4/3}k^{2/3}) queries -- the same as deterministic algorithms. We also study a more general setting where the number of parts is unknown. In this case, we give a 4-round randomized algorithm using O(n∣P∣log⁡2n)O(n|\mathcal P|\log^2 n) queries with high probability, and prove that 3-rounds cannot achieve near-optimal query complexity. Furthermore, we show an even bigger separation in this regime between randomized and deterministic algorithms: for the latter, Θ(log⁡n/log⁡log⁡n)Θ(\log n/\log\log n) rounds are necessary and sufficient to obtain near-optimal query complexity.

Explore similar work

Jul 10, 2026cs.DS

Learning Partition Trees for Nearest Neighbor Search

We study nearest neighbor search from the perspective of data-driven algorithm design: given a dataset P⊂RdP \subset \mathbb{R}^d of size nn and sample access to a query distribution over Rd\mathbb{R}^d, the goal is to learn a data structure optimized for queries drawn from that specific distribution. We focus on the class of balanced halfspace trees, which naturally abstracts space-partitioning frameworks like locality-sensitive hashing. Assuming Gaussian-like marginal conditions on the dataset and query distribution, we give an efficient algorithm that learns a tree achieving o(nd)o(nd) query time, provided that a perfect tree exists. At the core of our algorithmic approach is the balanced halfspace cut problem, where we are given a distribution over Rd×Rd\mathbb{R}^d \times \mathbb{R}^d and must find a balanced halfspace that minimizes the fraction of cut pairs. We prove that without distributional assumptions, finding the optimal balanced halfspace is NP-hard. To circumvent this computational barrier, we design an efficient improper learning algorithm: if the optimal halfspace cuts an αα fraction of pairs, our algorithm outputs a balanced polynomial threshold function of degree O~(1/ε2)\tilde{O}(1/\varepsilon^2) that cuts at most an O(α+ε)O(\sqrt{α+\varepsilon}) fraction.
Sanjeev Khanna, Ashwin Padaki, Erik Waingarten
Sep 17, 2024cs.DS

Clustering with Non-adaptive Subset Queries

Recovering the underlying kk-clustering of a set UU of nn points by asking pair-wise same-cluster queries has garnered significant interest in the past few years. Given a query S⊂US \subset U, ∣S∣=2|S|=2, the oracle returns "yes" if the points are in the same cluster and "no" otherwise. For adaptive algorithms, the query complexity is known to be Θ(nk)Θ(nk), while non-adaptive algorithms are extremely limited: even for k=3k=3, such algorithms require Ω(n2)Ω(n^2) queries, matching the trivial upper bound. However, non-adaptivity is highly desirable since it allows queries to be asked in parallel. To break the quadratic barrier for non-adaptive queries, we study a natural generalization of this problem to subset queries for ∣S∣>2|S|>2, where the oracle returns the number of clusters intersecting SS. Previous work obtained an O(n)O(n) query adaptive algorithm, but the realm of non-adaptive algorithms remained completely unknown. In this paper, we give the first non-adaptive algorithms for clustering with subset queries. Our main result is a non-adaptive algorithm making O(nlog⁡k⋅(log⁡k+log⁡log⁡n)2)O(n \log k \cdot (\log k + \log\log n)^2) queries, improving to O(nlog⁡log⁡n)O(n \log \log n) when kk is constant. In addition to non-adaptivity, we make other practical considerations, such as enforcing a bound, ss, on the query size. We show Ω(max⁡(n2/s2,n))Ω(\max(n^2/s^2,n)) queries are necessary and obtain algorithms making O~(n2k/s2)\smash{\widetilde{O}(n^2k/s^2)} queries for any s≤ns \leq \sqrt{n} and O~(n2/s)\smash{\widetilde{O}(n^2/s)} queries for any s≤ns \leq n. Finally, we obtain improved upper bounds when the clusters are roughly balanced, and when the algorithm is allowed two rounds of adaptivity.
Hadley Black, Euiwoong Lee, Arya Mazumdar +1
Apr 16, 2026cs.DS

Tight Bounds for Learning Polyhedra with a Margin

We give an algorithm for PAC learning intersections of kk halfspaces with a ρρ margin to within error ε\varepsilon that runs in time poly(k,ε−1,ρ−1)⋅exp⁡(O(nlog⁡(1/ρ)log⁡k))\textsf{poly}(k, \varepsilon^{-1}, ρ^{-1}) \cdot \exp \left(O(\sqrt{n \log(1/ρ) \log k})\right). Notably, this improves on prior work which had an exponential dependence on either kk or ρ−1ρ^{-1} and matches known cryptographic and Statistical Query lower bounds up to the logarithmic factors in kk and ρρ in the exponent. Our learning algorithm extends to the more general setting when we are only promised that most points have distance at least ρρ from the boundary of the polyhedron, making it applicable to continuous distributions as well.
Shyamal Patel, Santosh Vempala