Poly(s,1/ε)-Query Algorithms

• Poly(s,1/ε)-query algorithms are procedures that perform testing, learning, or approximation with query complexity bounded by a polynomial in the sparsity parameter s and the inverse error 1/ε.
• They leverage methods like random restrictions, cluster decompositions, and Fourier analysis to simplify structured data and reduce error effectively.
• These algorithms are pivotal in property testing, computational learning, derandomization, and efficient data structure design, offering near-optimal performance.

A poly$(s,1/\varepsilon)$-query algorithm is a randomized or deterministic procedure that, for a parameter $s$ (often denoting sparsity, term count, or model complexity) and error parameter $\varepsilon$, performs its core task—testing, learning, or approximation—with query complexity bounded by a polynomial in both $s$ and $1/\varepsilon$. These algorithms are of central importance for property testing, computational learning theory, deterministic derandomization, and query-efficient data structures, as they enable efficient handling of highly structured families and error-robust tasks in large or infinite domains.

1. Definition and Scope of Poly$(s,1/\varepsilon)$-Query Algorithms

A poly$(s,1/\varepsilon)$-query algorithm is an explicit construction or tester that, on input parameters $s$ and $\varepsilon > 0$, makes at most $\mathrm{poly}(s,1/\varepsilon)$ queries to an underlying function, data source, or oracle to decide membership in a property class, perform tolerant identity checks, or approximate an aggregate statistic. The polynomial dependence is crucial: it contrasts with exponential or even subexponential dependence on $1/\varepsilon$ frequently arising in classical regularity-lemma-based property testers.

Such algorithms arise in various settings:

• Property and identity testing: Decide if an unknown object (e.g., Boolean function, graph, polynomial) belongs to a sparse or combinatorially structured class (e.g., $s$-sparse GF(2) polynomials, $s$-term DNF, size-$s$ decision trees) or is $\varepsilon$-far from every such object.
• Efficient learning and tolerant testing: Obtain hypotheses or certificates with performance guarantees (relative to $\varepsilon$) using a polynomial (in $s,1/\varepsilon$) query budget.
• Derandomization and instance-optimality: Deterministic simulation of randomized/quantum query protocols, as well as construction of near-optimal deterministic analogues with query complexity polynomial in structural parameters and $1/\varepsilon$ (Blanc et al., 2019).
• Space/time-query tradeoffs in data structures: E.g., polytope membership, distance oracles in planar graphs, where error-dependence is polynomial in $1/\varepsilon$ (Arya et al., 2016, Le, 2022).

2. Key Algorithmic Paradigms and Meta-Frameworks

Poly$(s,1/\varepsilon)$-query complexity commonly arises via:

• Random restrictions/low-variation conditioning: Partition variables/edges/features into blocks, restrict low-influence subsets to fixed values, and reduce to a low-dimensional structured core, enabling simulation of proper learning or identity-testing oracles. The classical sparse polynomial tester uses this with careful influence decomposition and simulation of membership queries for the residual structure (0805.1765).
• Cluster-based or factorization decompositions: Reduce high-arity DNFs or unions of terms to a collection of local clusters/factored DNFs, each on at most $\mathrm{poly}(s,\log(1/\varepsilon))$ variables, thus confining the hard part to subspaces of manageable dimension (Chen et al., 22 Jan 2026).
• Fourier-analytic and small-bias generator constructions: Derandomize randomized query protocols for decision trees or Boolean formulas using pseudorandom generators that fool small-depth or size-$N$ trees, then aggregate via explicit sampled ensembles (PRGs with seeds of length $O(\log(N/\varepsilon))$ and pairwise independence suffice for average-case $L_2$ approximation) (Blanc et al., 2019).
• Spectral and partitioning methods in graphs: For testing minor-closed properties, spectral clustering and partition oracles provide poly$(d/\varepsilon)$-query partitions and enable efficient testers for a range of monotone and additive graph properties (Kumar et al., 2021).

3. Rigorous Instantiations: Boolean Function Classes

Sparse GF(2) Polynomials

Let $f:\{0,1\}^n\to\{-1,1\}$ and $s\geq 1$, $\varepsilon\in (0,\frac12)$. There exists a randomized test making $Q(s,1/\varepsilon)=\mathrm{poly}(s,1/\varepsilon)$ black-box queries and accepting iff $f$ is $s$-sparse and rejecting if $\varepsilon$-far from every such polynomial. The tester partitions variables, estimates variations, restricts low-variation variables, and simulates membership queries to a low-dimensional core using influence localization, then runs the Schapire–Sellie learning procedure (0805.1765). The bounds are explicit: $$Q(s,1/\varepsilon)=O(s^4/\varepsilon^2\log^2(s/\varepsilon))$$.

$s$-Term DNFs (Relative Error Model)

Let $f:\{0,1\}^n\to\{0,1\}$. In the relative-error model (using $f^{-1}(1)$-sampling), there is a tester making $\mathrm{poly}(s,1/\varepsilon)$ queries that distinguishes $s$-term DNFs from functions $\varepsilon$-far from any such DNF (measured relatively) (Chen et al., 22 Jan 2026). This uses a decomposition into $s'$ clusters: each comprises terms with a common "head" and a tail of $\mu=\Theta(s^2\log^2(s/\varepsilon))$ variables. The algorithm efficiently simulates membership-query and sampling oracles for each cluster, then runs factored identity tests and learning subroutines, all with total query complexity $\mathrm{poly}(s,1/\varepsilon)$.

Decision Trees and Reconstruction

Given black-box access to $f$ that is opt-close to a size-$s$ decision tree, there is an algorithm producing a tree $T$ of size $s^{O((\log s)^2/\varepsilon^3)}$ such that every evaluation $T(z)$ requires only $\mathrm{poly}((\log s)/\varepsilon)\cdot\log n$ queries to $f$ (Blanc et al., 2020). This provides exponentially more efficient tolerant testers for decision tree classes.

4. Derandomization of Query Algorithms

A central result is the constructive derandomization of randomized query algorithms, including decision trees:

Given a randomized $q$-query algorithm $R$ (bitlength $N$) and $\varepsilon > 0$, there is a deterministic $O(q/\varepsilon)$-query decision tree $D$ such that $\mathbb{E}_x[(D(x)-\mu_R(x))^2]\leq \varepsilon$ ($\mu_R(x)$ the acceptance probability). The construction employs:

• Small-bias pseudorandom generators for randomness reduction.
• Pairwise-independent sampling to average over PRG seeds and obtain concentration via Chebyshev-type arguments.
• Fourier-analytic error estimation to search for a deterministic ensemble achieving the $L_2$-error bound.

The running time is $\mathrm{poly}(N)\,2^{O(q/\varepsilon)}$, and the construction is instance-optimal—there exists a deterministic algorithm matching the minimum query depth required for $\varepsilon$-approximation (Blanc et al., 2019). For $q=\mathrm{poly}(s)$, the resulting deterministic algorithm has poly$(s,1/\varepsilon)$ query complexity.

Setting/Class	Query Complexity	Reference
$s$-sparse GF(2) poly. test	$\mathrm{poly}(s,1/\varepsilon)$	(0805.1765)
$s$-term DNFs, rel. error	$\mathrm{poly}(s,1/\varepsilon)$	(Chen et al., 22 Jan 2026)
$q$-query randomized trees	$O(q/\varepsilon)$	(Blanc et al., 2019)
Decision tree reconstruction	$\mathrm{poly}((\log s)/\varepsilon)$	(Blanc et al., 2020)

5. Applications in Data Structures and Graph Algorithms

Poly$(1/\varepsilon)$-query and -time algorithms are critical in geometric data structures and graph property testing:

• Approximate polytope membership: Data structures with space-time trade-offs achieving poly$(1/\varepsilon)$ query, matching lower bounds for fixed dimension, are achievable by quadtree-based subdivision and local approximation of facets (Arya et al., 2016).
• Planar graph distance oracles: Recent results attain subpolynomial-in-$1/\varepsilon$ query time and space for $(1+\varepsilon)$-approximate distances, breaking previous linear barriers in the error parameter (Le, 2022).
• Graph partition oracles: In minor-closed families, there are poly$(d/\varepsilon)$-query partition oracles providing hyperfinite decompositions, which underlie testing monotone/additive properties and approximation of robust parameters (Kumar et al., 2021).

6. Structural Reasons for Polynomial Query Bounds

Underlying the existence of poly$(s,1/\varepsilon)$-query algorithms are:

• Structural simplification under random restriction or low influence: Classes with bounded structural complexity (e.g., sparsity, bounded DNF width, decision tree size) become "juntas" on a prescribed number of variables under suitable random restrictions, enabling their identity to be tested in low-dimensional representations (0805.1765, Chen et al., 22 Jan 2026).
• Averaging and decomposition: In randomized/derandomized query algorithms, Yao-style averaging over coin-flip sequences combined with randomness-efficient samplers achieves the required expectation and variance reductions (Blanc et al., 2019).
• Cluster or factorization decompositions: DNFs and other union-of-terms classes can be partitioned into clusters amenable to efficient isolated verification (Chen et al., 22 Jan 2026).
• Spectral partitioning and local clustering: For graphs, spectral diffusion and clustering ensure that local neighborhoods reveal the essential global partition structure with only a polynomial number of localized queries (Kumar et al., 2021).

7. Limitations, Lower Bounds, and Outlook

While poly$(s,1/\varepsilon)$-query algorithms exist for many natural function and structure classes, explicit polynomial dependence sometimes fails for structural reasons—e.g., certain hereditary graph properties or more complex algebraic classes can require superpolynomial or even exponential-in-$1/\varepsilon$ query complexity. For all efficient testers of this type, nearly sharp lower bounds are obtained by constructions showing that distinguishing certain properties with less than a polynomial number of queries cannot detect property violation with high probability (Blanc et al., 2019, 0805.1765).

Recent work systematizes the scope and meta-frameworks guaranteeing poly$(1/\varepsilon)$-testability, with open problems regarding extensions to broader classes, tight bounds, and exact structural characterizations (Gishboliner et al., 23 Aug 2025). The principles underlying poly$(s,1/\varepsilon)$-query design—localization, structural simplification, random restriction, and pseudorandom aggregation—continue to drive advances in sublinear algorithms, learning theory, and derandomization.