Abstract 1 Introduction 2 Our results 3 Technical Overview 4 Preliminaries 5 𝒌-linearity Testing 6 𝒌-Sparse Low Degree Testing 7 𝒌-Junta Testing 8 Lower Bounds References

Testing Sparse Functions over the Reals

Vipul Arora ORCID School of Computing, National University of Singapore, Singapore    Arnab Bhattacharyya ORCID University of Warwick, UK    Philips George John ORCID CQT & CNRS@CREATE, National University of Singapore, Singapore    Sayantan Sen ORCID Centre for Quantum Technologies, National University of Singapore, Singapore
Abstract

Over the last three decades, function testing has been extensively studied over Boolean, finite fields, and discrete settings. However, to encode the real-world applications more succinctly, function testing over the reals (where the domain and range, both are reals) is of prime importance. Recently, there have been some works in the direction of testing for algebraic representations of such functions: the work by Fleming and Yoshida (ITCS 20), Arora, Kelman, and Meir (SOSA 25) on linearity testing and the work of Arora, Bhattacharyya, Fleming, Kelman, and Yoshida (SODA 23) for testing low-degree polynomials. Our work follows the same avenue, wherein we study three well-studied sparse representations of functions, over the reals, namely (i) k-linearity, (ii) k-sparse, low-degree polynomials, and (iii) k-juntas.

In this setting, given approximate query access to some f:n, we want to decide if the function satisfies some property of interest, or if it is far from all functions that satisfy the property. Here, the distance is measured in the 1-metric, under the assumption that we are drawing samples from the Standard Gaussian distribution. We present efficient testers and Ω(k) lower bounds for testing each of these three properties.

Keywords and phrases:
Property testing, sparsity, linearity, low-degree polynomials, juntas, computation over reals
Category:
Track A: Algorithms, Complexity and Games
Funding:
Vipul Arora: This work was done in part while the author was visiting the Simons Institute for the Theory of Computing.
Arnab Bhattacharyya: Research supported by a start-up grant at the University of Warwick.
Philips George John: Research supported by the NRF, Prime Minister’s Office, Singapore under its Campus for Research Excellence and Technological Enterprise (CREATE) programme. This work was also done in part while supported by the CQT++ Core Research Funding Grant from Prof. Divesh Aggarwal.
Sayantan Sen: Research supported by the NRF Investigatorship award (NRF-NRFI10-2024-0006) and CQT Young Researcher Career Development Grant (25-YRCDG-SS).
Copyright and License:
[Uncaptioned image] © Vipul Arora, Arnab Bhattacharyya, Philips George John, and Sayantan Sen; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Streaming, sublinear and near linear time algorithms
Related Version:
Full version (with complete proofs): https://arxiv.org/abs/2603.28061 [6]
Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele Puppis

1 Introduction

Property testing [24, 71, 48] is a rigorous framework for studying the global properties of large datasets by accessing only a few entries of it. In particular, given query access to an unknown “huge object”, the goal of property testing is to verify some property of the object by only inspecting a small portion of it. Formally, we can define property testing of functions, or function testing, by considering the “huge object” as a function f over an underlying domain, which we can query at a small number of points in order to verify a property of the function f in an approximate sense. For example, consider the problem of linearity testing of functions f:𝔽n𝔽, where 𝔽 is a finite field. We are given access to a query oracle for f; i.e., on input 𝒙, the oracle returns f(𝒙). The goal is to distinguish with high probability between two cases, viz. (i) f is a linear function, or (ii) f is “far” from all linear functions, while performing as few queries to the oracle as possible.

The field of property testing was initiated in the seminal work of [24, 25], who studied the problem of self-testing of programs, where the goal was to understand the correctness of a program by verifying its outputs on a set of correlated input data. A fundamental problem they studied is that of testing whether f is linear (or generally, a homomorphism of abelian groups) or ε-far from linearity, with the notion of ε-farness of f:𝔽n𝔽 from a function class 𝒫 defined as: 𝖽𝗂𝗌𝗍𝖴𝗇𝗂𝖿(𝔽n),0(f,𝒫)=infg𝒫Pr𝒙𝖴𝗇𝗂𝖿(𝔽n)[f(𝒙)g(𝒙)]ε, i.e., for any function g that satisfies property 𝒫, f disagrees with g on at least an ε-fraction of the inputs 𝒙 (uniformly drawn from 𝔽n). In the context of linearity testing, 𝒫 is the class of linear functions/homomorphisms (the 0-distance definition given above can be easily generalized in terms of function domain and range, input distribution etc). They showed a constant query (independent of |𝔽| and n) linearity tester, known as the BLR tester.

Over the last three decades, property testing has been extensively studied in many settings, such as when the unknown object is a function, a graph, or a probability distribution, with many natural connections to real-world problems, e.g., in the context of probabilistically checkable proofs [3, 4, 67, 34], PAC learning [48], program checking [70, 71], approximation algorithms [48, 38] and many more.

In particular, starting from the very first work that initiated the field of property testing [24], over the last three decades, function property testing has been extensively studied in several settings, culminating in a wide array of tools and techniques. This includes settings where the function is defined over finite fields [1, 58, 57, 45, 14, 13, 51, 73], over hyper-grids [35, 21, 28, 9], etc. One may see the books [50, 15] and the surveys [41, 69, 68] for detailed references.

Our problem setting.

Suppose we are given query access to an unknown function f:n, and our goal is to distinguish whether (i) f satisfies some property 𝒫, or (ii) f is ε-far from all functions that satisfy 𝒫. We define the notion of ε-farness over the reals in the following way: we fix a reference distribution 𝒟 on n, and we say f is ε-far from 𝒫 if the following holds111The notion of 1-distance is more appropriate for real-valued functions, rather than the commonly used Hamming (0) distance, especially in the approximate query setting which we define later. For example, consider the case if g=f+ε for some ε>0, then 𝖽𝗂𝗌𝗍𝒟,1(f,g)=ε, whereas 𝖽𝗂𝗌𝗍𝒟,0(f,g)=1. : 𝖽𝗂𝗌𝗍𝒟,1(f,𝒫)infg𝒫{𝔼𝒙𝒟[|f(𝒙)g(𝒙)|]}ε.

Studying function testing over the reals often requires new techniques compared to testing on finite domains. A common reference distribution on n is the standard n-dimensional Gaussian distribution 𝒩(𝟎,In), which is approximately a uniform distribution on an 2-sphere of radius n. And the notion of exact queries (oracle giving f(𝒙)) is not realistic over the reals, since one may require infinitely many bits to represent the exact function value. Although the problem of function testing over the reals has several practical motivations, there have been comparatively few works in this setting till now (compared to testing over finite domains) such as testing surface areas [64, 59], testing halfspaces [61, 62, 63], linear separators [8], high-dimensional convexity [29], linear k-juntas [32] etc.

Interestingly, these works mostly focus on the setting when f is Boolean valued, i.e., f:n{±1}. The setting where the range of f is real has also been studied, e.g., in the work of [12], wherein they test properties of functions, defined over finite hyper-grids, with respect to Lp-distances. In [16], functions over the hypercube, i.e., f:{0,1}n are studied for monotonicity. Recently, [39, 40] studied Lp testing of monotonicity of Lipschitz functions f:[0,1]n.

[44] studied the problem of linearity testing for real-valued real-domain functions in full generality, i.e., for functions f:n. Later, [5] studied the problem of testing low-degree polynomials in this regime, followed by the work of [7], which improved these results by achieving query-optimality with respect to the proximity parameter ε. In this work, we expand the landscape of testing various fundamental notions of sparsity to the general f:n regime.

A recent work of [10] studies a problem similar to sparsity testing of low degree polynomials, in a sample-based access model. However, it assumes a promise that the unknown function f:n is a multi-linear polynomial to begin with, and needs a large gap for the sparsity parameter between the YES and NO cases.

When the function f to be tested is real valued, two different models can be considered with respect to the query accuracy. In the first model, known as the arbitrary precision arithmetic or the exact testing model, we assume that the oracle representing f can give the exact value of f at any point of query 𝒙. However, this model is unrealistic from an implementation, or even from a classical complexity-theoretic, viewpoint. So, we instead consider a finite precision arithmetic or approximate testing model:

Definition 1.1 (η-approximate query).

The oracle, when queried for f(𝐱), outputs f~(𝐱) such that |f~(𝐱)f(𝐱)|η, for some small parameter η(0,1), for every query point 𝐱.

It is clear that for any property 𝒫, any tester for 𝒫 in the approximate model will also work in the exact model. The notion of approximate testing was studied in earlier works [46, 2, 37]. In this context, η can be thought of as the resolution limit of the computational machine, i.e., if the machine offers some α bits of precision, then η=2α. η can also be thought of the noise reliability threshold of a channel communicating reals, i.e., if some information a is transmitted on a channel with a reliability threshold of η, then the received observable a~ satisfies |aa~|η. When η=0, this is the exact query model.

All our testers in this work are analyzed in the approximate query model for η>0. Our results also require appropriate upper bounds on η, which will be stated in each context. But we use the exact query model for proving the lower bounds, since lower bounds for η=0 also hold for any η-approximate query model for η>0.

Similar to the context of access to the unknown functions, there are some variations in terms of the error profile of the testing algorithms. A tester is said to have two-sided error if it can err in both the cases: when f𝒫, and when f is ε-far from 𝒫. This is in contrast with one-sided error testers, which always decide correctly when f𝒫, and can only err when f is ε-far from 𝒫. Likewise, a tester is said to be adaptive if it performs queries based on the answers it obtained for the previous queries. On the other hand, a non-adaptive tester performs all its queries together in a single round. A tester over a finite domain is said to be local if the number of queries performed by it is independent of the domain size.

In this work, we design testers in the approximate query model for three sparse function representations: k-linear, k-sparse low-degree polynomials, and k-juntas. Our testers for k-linearity, and k-sparse low-degree polynomials have two-sided error, whereas our k-junta tester has one-sided error. Our testers for k-linear functions and k-juntas are adaptive, while our tester for k-sparse low-degree polynomials is non-adaptive. Importantly, all our testers are local: the number of queries performed by our testers is independent of the domain dimension n, and depends only on the sparsity parameter k and the proximity parameter ε (as well as the total degree d in the k-sparse low-degree polynomial case).

These properties are well-studied in the Boolean and finite fields regime, and this work strives to do the same over continuous domains. We believe the new techniques we have developed to design these testers will be of independent interest.

Boundedness.

We assume that the unknown functions are bounded inside an 2 ball B (centered at the origin 𝟎) of suitable radius (typically O(n)), i.e., for every 𝒙B(𝟎,O(n)), |f(𝒙)|C𝒙2 for some fixed constant C (so |f(𝒙)|Cn in B(𝟎,2n)) 222This boundedness notion corresponds to the bounds we get for low-degree polynomials over compact domains, e.g., if f(x)=a1x++adxd is a polynomial in x, then |f(x)|i=1d|ai|Ri for any x[R,R], for all R0.. Note that testing only via bounded queries is impossible without such an assumption. For example, consider an arbitrary “good” function f:n (k-linear, k-sparse polynomial, or a k-junta), and choose a suitably small region R at random (e.g. by choosing 𝒚 uniformly from B(𝟎,n) and setting R to be a small radius ball around 𝒚), where 0<μn(R)1/nc for any c>0 under the 𝒩(𝟎,In) Gaussian measure on n. Further, subdivide R equally into R1 and R2, and for some A2ε/μn(R), define a function f:n which is identical to f outside R; while f(𝒙)=A for 𝒙R1, f(𝒙)=A for 𝒙R2. As A>0 can be arbitrarily large, f can be moved arbitrarily far from the required property (in 1 distance over the Gaussian measure). However, since μn(R) is arbitrarily small, no algorithm using bounded queries can distinguish between f and f.

Choice of Reference Distribution.

In this work (for k-linear, and k-sparse low-degree testers), we have used an anti-concentration result of Glazer and Mikulincer (Theorem 4.6) which uses the Carbery-Wright anti-concentration inequality (Theorem 4.5), but with a more usable expression for the variance (in terms of the polynomial coefficients). This form assumes that the distribution (on the variables) is log-concave, isotropic, and non-discrete. We have chosen 𝒩(𝟎,In) as representative of such a distribution, but we can also take Pn for any continuous, log-concave distribution P on . A probabilistic upper bound for the Hankel matrix eigenvalues, which we use in the analysis of the k-sparsity tester, also assumes the isotropic Gaussian distribution (Theorem 2.12).

2 Our results

We focus on testing (i) k-linearity, (ii) k-sparse, low-degree polynomials, and (iii) k-juntas, and assume that our reference distribution 𝒟 is 𝒩(𝟎,In), unless otherwise stated.

2.1 Testing 𝒌-linear functions

Definition 2.1 (k-linearity).

Let f:n, and k. f is k-linear if there exists a set S[n]:|S|k, and there exist coefficients {ci}iS, such that, fiScixi.

This problem has been extensively studied over finite domains with exact query access. [43] designed the first tester for k-linearity with query complexity O~(k2) by studying the related problem of testing k-juntas. Later, [18] improved the bound for testing k-juntas to O(klogk) queries. Using the BLR test [24], along with this result gives a tester for k-linearity with O(klogk) query complexity, as done by [26], who presented an optimal, two-sided error, non-adaptive algorithm for this problem over Boolean domains. The first lower bounds for this problem were presented by [43], proving Ω(k) non-adaptive, and Ω(logk) adaptive queries are necessary for testing k-linearity. These were first improved by [49], to Ω(k) non-adaptive, and Ω(k) adaptive query lower bounds. This was further improved by [19, 20] who proved Ω(k) adaptive query lower bound. Interestingly, the Ω(k) adaptive query lower bound by [19] was proved by showing a novel connection to communication complexity, which we will also use later to prove our lower bounds.

Theorem 2.2 (Informal, see Theorem 5.1).

Let f:n be a function bounded on the ball B(𝟎,2n), given via an η-approximate query oracle. Let k, and ε,η(0,2/3) be parameters such that η<min{ε,O(mini[n]:f(𝐞i)0|f(𝐞i)|(nk)2)}, where 𝐞i denotes the ith standard basis vector. There exists an O~(klogk+1/ε)-query tester (Algorithm 1) that distinguishes whether f is k-linear, or is ε-far from all k-linear functions, with probability at least 2/3.

 Remark 2.3.

Note the necessity of sufficiently good machine precision (small η) to successfully test k-linearity. This is inevitable because if a linear function f has k “large” coefficients a1,,ak (η), and a small coefficient ak+1 (say <η/n2), we cannot distinguish (up to 1 distance εη) between f and the k-linear function i=1kaixi using η-approximate queries and Algorithm 1. The tester (specifically, Algorithm 2) uses the absolute difference between function values, which will be at most |ak+1(xk+1)|2η. Similar restrictions apply to testing k-sparse polynomials, and k-juntas.

In another sense, a qualitative dependence of η on the function structure is inevitable. Otherwise, if given an η-approximate oracle f~ to f, f~f~/2n (which can be computed in O(n) time given f~, assuming a variable-length binary floating-point representation) would be an η/2n-approximate oracle to f. But such a scaling would not help with our results, since the coefficients of f, the non-zero influences, etc. would be similarly scaled-down.

2.2 Testing 𝒌-sparse low degree polynomials

Definition 2.4 (k-sparsity).

Let f:n, and k be a parameter. A monomial 𝐱𝛂i=1nxiαi, for any 𝐱(x1,,xn)n, and 𝛂(α1,,αn)n has total degree 𝛂1i=1nαi. A polynomial f(x1,,xn)=i=1ai𝐱𝐝i, with ai0 and 𝐝in, i[], of total degree maxi[]{𝐝i1}, is said to be a k-sparse polynomial if k.

Grigorescu et al. [52] solved this problem for polynomials on finite fields, i.e., f:𝔽qn𝔽q, for large enough q, using the machinery of Hankel matrices associated with polynomials:

Definition 2.5 (Hankel Matrix for polynomials [52, 11]).

Consider any 𝐮(u1,,un)n, and define 𝐮i(u1i,,uni)n,for every i. For a function f:n and t, define the t-dimensional Hankel matrix associated with f at 𝐮 to be the following:

Ht(f,𝒖)(f(𝒖0)f(𝒖1)f(𝒖t1)f(𝒖1)f(𝒖2)f(𝒖t)f(𝒖t1)f(𝒖t)f(𝒖2t2))t×t.

We note an observation about Hankel matrices. It follows essentially the same argument as in [11, 52], since the decomposition they use over finite domains also works over the reals.

Observation 2.6 (Generalization of [11, Section 4], and [52, Lemma 4]).

Let f:n be an exactly k-sparse polynomial over the reals, i.e., f(𝐱)=i=1kaiMi(𝐱), where a1,,ak{0}, and M1,,Mk are the monomials of f. Then for all +1k,

det(H+1(f,𝒙))=S[k]|S|=+1iSaii,jSi<j(Mj(𝒙)Mi(𝒙))2,

is a non-zero polynomial of degree 2(+12)deg(f), while +1>k, det(H+1(f,𝐱))0.

From Ben-Or and Tiwari [11]’s Observation 2.6, Grigorescu et al. [52] designed a tester with a query complexity of O(k) (independent of d), assuming f to be an individual-degree-d polynomial (note that all functions 𝔽qn𝔽q are polynomials of individual degree q).

Note that if we have exact query access to f, the Hankel matrix Ht(f,𝒖) can be computed using only 2t1 queries to f for any point 𝒖n. For the problem of testing a polynomial f:n for sparsity, given exact query access, the tester of [52] works as it is. In fact, it achieves perfect soundness and completeness (proved in Lemma 6.4). However, the assumption of an exact query oracle is not realistic. Moreover, for general functions f:n, the promise of polynomiality no longer holds, and therefore a preliminary step is needed to eliminate functions that are far from being low-degree polynomials. [5] designed a local, approximate query, low degree tester with a query complexity of O(d5), for polynomials over n with total degree d, which we will use in our work. Thus, we restrict our attention to polynomials of total degree at most d.

Theorem 2.7 (Informal, see Theorem 6.1).

Let k,d, ε,η(0,1) be parameters such that η<min{ε,1/22n}, and f:n be bounded in B(𝟎,2dn), given via an η-approximate query access. Then there exists an O~(d5+d2ε+dk3)-query tester (Algorithm 4), that distinguishes whether f is a k-sparse, degree-d polynomial, or is ε-far from all such polynomials, with probability 2/3.

 Remark 2.8.

We note that Test-k-Sparse (Algorithm 4) also works for testing k-linear functions (by setting the degree d=1). However, we make the following remarks:

  1. (i)

    The query complexity of Test-k-Sparse (O~(d5+d2ε+dk3)), invoked for k-linearity testing, would be O~(k3+1ε), which is worse than that of Test-k-Linear.

  2. (ii)

    The restriction on the approximation parameter η is 1/22n for Test-k-Sparse, as compared to 1/(nk)2 for Test-k-Linear. Thus, for a wider range of parameters when η is not too small, invoking Test-k-Linear is better, compared to Test-k-Sparse.

  3. (iii)

    Test-k-Linear is an adaptive tester, while Test-k-Sparse is non-adaptive.

2.3 Testing 𝒌-juntas

Definition 2.9 (k-junta).

Let f:n, and k be a parameter. A variable xi, i[n], is influential with respect to f, if for some 𝐱(x1,,xn)n, changing xi changes f(𝐱). f is a k-junta, if there are at most k influential variables with respect to f.

Testing whether a Boolean function is a k-junta has been extensively studied in the exact query model. The first result in this context was by [66], which was followed by the work of [43], who designed a O~(k2)-query tester. Later, [33] extended it to the finite range setting. [17] then gave an O~(k3/2)-query non-adaptive tester for this problem, while for adaptive testers, [18] showed O~(klogk+k/ε) queries suffice. It is important to note that all these results use Fourier-analytic techniques. Notably, [22] designed a new algorithm for testing k-juntas with similar optimal bounds in the context of testing partial isomorphism of functions. Interestingly, this work deviates from the common Fourier analytic approach and instead presents a combinatorial approach to this problem. This algorithm from [22] will be used in designing our tester for k-juntas. Recently [32] studied the linear k-junta testing problem, where the function f is defined as f:n{+1,1} 333A function f:n{1,1} is said to be a linear k-junta if there are k unit vectors u1,ukn and g:k{1,1} such that f(x)=g(u1,x,,uk,x).. This is different from our setting of real-valued functions. It is not clear to us if their techniques can be generalized to our setting. In terms of lower bounds, [43] showed a lower bound of Ω(k) queries for non-adaptive testers, which was improved to Ω~(k3/2/ε) by [30]. For adaptive testers, [31] showed an Ω(k) lower bound, which was then improved to Ω(klogk) by [72].

Theorem 2.10 (Informal, see Theorem 7.1).

Let k, and ε,η(0,1) be such that η<min{O(ε/k2),O(1k2log2k)}, and f:n be bounded in B(𝟎,2n), given via η-approximate queries. There exists a one-sided error, O~(klogkε)-query tester (Algorithm 6), that distinguishes if f is a k-junta, or is ε-far from all k-juntas, with probability at least 2/3.

2.4 Lower bounds

We briefly mention our lower bound results, which hold even for adaptive testers, and exact query access. For all three properties (k-linearity, k-sparse degree-d polynomials, and k-juntas), we prove lower bounds of Ω(max{k,1ε}) queries. Additionally, for k-sparse, degree-d polynomials, we prove a lower bound of Ω(max{k,d,1ε}) queries. All our lower bounds follow from the general reduction from communication complexity, introduced by [19], coupled with some folklore results. We use Set-Disjointness as the hard instance to prove our results.

Theorem 2.11.

Given exact query access to f:n, some k,d and a distance parameter ε(0,1), Ω(max{k,1ε}) queries are necessary for testing (i) k-linear functions, (ii) k-sparse degree-d polynomials, and (iii) k-juntas, with success probability at least 2/3.

The lower bound for testing k-sparse degree-d polynomials is improved to Ω(max{d,k,1ε}).

2.5 New Technical Contributions

𝒌-sparsity Tester.

A critical ingredient in proving the k-sparse low degree tester (Theorem 2.7) is a new probabilistic upper bound on the maximum singular value of Hankel matrices associated with sparse, low-degree polynomials. This may be of independent interest.

Theorem 2.12 (Probabilistic Upper Bound on σmax).

Let f:n, f(𝐱)=i=1kaiMi(𝐱) be a k-sparse, degree-d polynomial, where Mi’s are its non-zero monomials, and σmax(Ht(f,𝐮)) denotes the largest singular value of the t-dimensional Hankel matrix associated with f at a point un, Ht(f,𝐮). Then, for any γ(0,1), with 𝐚(a1,,ak)k,

Pr𝒖𝒩(𝟎,In)[σmax(Ht(f,𝒖))𝒂22(2d/2d/2!+kγ2d/2d!)2t]γ.

Proof Sketch.

For any vector 𝒗n, let |𝒗|0n denote the vector with the absolute values of the coordinates of 𝒗. Then, for any 𝒛,𝒖n, using the triangle inequality, and a Vandermonde-like decomposition of H𝒖Ht(|f|,|𝒖|), (from Observation 2.6), where |f|(𝒙)i[k]|ai|Mi(𝒙), we can upper-bound |𝒛H𝒖𝒛| by |𝒛|VDV|𝒛|=D12V|𝒛|22, where D=diag(|𝒂|), V is the Vandermonde matrix 𝖵t(|M1(𝒖)|,,|Mk(𝒖)|)k×t, and M(|𝒖|)=|M(𝒖)|. By the Courant-Fischer characterization, we have

σmax(H𝒖)max𝒛21D12V|𝒛|22max𝒛21D12Vop2𝒛22D12VF2.

Using some results from [36] for the moments of the folded normal distribution, along with the properties of the Gamma function and the fact that all the monomials Mi have total degree d, we can upper bound

𝔼𝒖𝒩(𝟎,In)[|Mi(𝒖)|]2d/2d/2!, and Var[|Mi(𝒖)|]2dd!.

Chebyshev’s inequality and a union bound over the k monomials completes the proof.

 Remark 2.13.

Theorem 2.12 seems to be extendable to more general mean-zero distributions of 𝐮 with appropriate concentration (e.g. subgaussian, subexponential) since the crux of the proof, in addition to the use of properties of the Hankel matrix (which do not depend on the distribution of 𝐮), is to bound all the degree d moments of the distribution.

𝒌-linearity Tester.

For k-linearity, our tester is similar to the algorithm proposed in [26] for testing k-linearity of functions f:𝔽2n𝔽2, with the BLR test replaced by the approximate-query linearity tester from [44, 5, 7]. The crucial difficulties in the analysis over the reals come from (i) the η-approximate query access, and (ii) the use of 1-distance for farness. We first reject all functions which are far from linearity by means of the linearity test, and, conditioned on the fact that the tester does not reject with high probability, proceed to testing the self-corrected function instead (with closeness to linearity guaranteed). But we now have only approximate query access to the function, which we test for k-linearity by splitting the variables into O(k2) random buckets as in [26] and identify the influential ones. However, there is no analogous result for real-valued functions. Hence, we present a new analysis in Claim 5.11 for the FindInfBucket (Algorithm 2) that performs a binary search over the buckets, but with a different test for influential buckets that accounts for η-approximate queries. The analysis with approximate queries involves the appropriate use of anti-concentration results (Theorem 4.5) for real linear polynomials.

𝒌-junta tester.

Our tester is inspired by the junta testers used in [18] and [22], but our definition of influence (Definition 7.2) is different (1 rather than Hamming), to work with approximate query oracle. Theorem 7.3, Lemma 7.4, and Lemma 7.5, in our analysis are similar to that of [22]. The significant difference in analysis for the 1 distance comes in our Claim 7.7, and the subsequent proof of Theorem 7.1.

2.6 Discussion

Our efficient algorithms for the problem of testing real-valued functions given via approximate queries, over continuous domains, for three properties: (i) k-linearity, (ii) k-sparse, low-degree polynomials, and (iii) k-juntas, summarized in Table 1, open several interesting questions:

Table 1: A comparison of the upper bounds, as well as the corresponding restrictions, for the three sparse representation testing problems. The upper bounds, and the restrictions in the three rows follow sequentially from Theorem 2.2, Theorem 2.7, and Theorem 2.10, respectively.
Problem Upper Bound Restriction
k-linearity O~(klogk+1ε) η<min{ε,O(mini[n]:f(𝒆i)0|f(𝒆i)|(nk)2)}
k-sparsity O~(d5+d2ε+dk3) η<min{ε,1/22n}
k-junta O~(klogkε) η<min{O(ε/k2),O(1k2log2k)}
  • We note that our results have constraints on the approximate query parameter η. The first open question is whether these can be improved.

  • Furthermore, our k-sparse degree-d polynomial tester performs O~(d5+d2ε+dk3) queries, and our lower bound for this problem is Ω(max{d,k,1ε}). The second open question is whether the gaps in these bounds (w.r.t. k, and d) can be improved, e.g., by assuming additional structure on the underlying function, like Lipschitzness, etc.

  • Another interesting direction is to design tolerant testers [65] for these properties. This is different from the approximate query testing notion, as in tolerant testing, the decision boundary is expanded to require that functions that are sufficiently close to the property are also accepted with high probability, whereas in the approximate query model, we accept functions f~ such that 𝖽𝗂𝗌𝗍𝒟,(f,f~)η (pointwise η-close) which is a stronger constraint compared to the expected 1-distance 𝖽𝗂𝗌𝗍𝒟,1(f,g) that we use between functions.

  • We have focused on optimizing the query complexity in terms of the sparsity parameter k and degree d (for low-degree polynomial testing). It is an interesting problem to optimize the dependence of η in our arguments.

  • Only our k-junta tester has a one-sided error profile, while our k-linearity/sparsity testers have two-sided errors. Designing one-sided error testers for these problems is left open.

  • Finally, we use 𝒩(𝟎,In) as the reference distribution. It would be interesting to see if our results can be extended to other concentrated distributions as well (see 2.13).

Organization of the paper

In Section 3, we present an overview of our results and techniques, followed by a discussion of the preliminaries in Section 4. In Section 5, we present our k-linearity tester, followed by our tester for k-sparse low-degree polynomials in Section 6, and our k-junta tester in Section 7.

Due to space constraints here, we omit all proofs of intermediate technical lemmata and claims, an elaborate discussion of lower bounds, and all subroutines from prior works (ApproximateAdditivityTester [6, Algorithm 7], TestAdditivity [6, Algorithm 8], Approximate-g [6, Algorithm 8], ApproxLowDegreeTester [6, Algorithm 9], ApproxCharacterizationTest [6, Algorithm 10], ApproxQuery-g [6, Algorithm 10] and ApproxQuery-g-InBall [6, Algorithm 10]). They are included in the full version [6].

3 Technical Overview

3.1 Testing 𝒌-linearity

We build upon the self-correct and test approach of [24, 53]. Instead of directly testing if f is k-linear, we construct a function gself-correct such that if f is k-linear, then gself-correct will also be k-linear. Moreover, we simulate queries to gself-correct using queries to f, and test this newly constructed function gself-correct.

We use the Gaussian distribution as the reference distribution, since there are no uniform distributions over continuous domains with infinite support. (This deviates from the self-correction approach of [24].) In particular, we evaluate f on a set of points sampled from 𝒩(𝟎,In) to construct the self-corrected function gself-correct. To deal with the fact that different points from 𝒩(𝟎,In) have different probability masses, the idea is to radially project the sampled points from 𝒩(𝟎,In) into a small Euclidean ball B(𝟎,r) of a small (constant) radius (r=1/50 suffices) such that the probability masses of all points sampled from that ball is roughly the same. Moreover, since we work with an approximate oracle, we use a median-based notion of the self-corrected function, with a contraction factor κ𝒑:n:

g(𝒑)κ𝒑𝗆𝖾𝖽𝒙𝒩(𝟎,In)[f(𝒑κ𝒑𝒙)+f(𝒙)], and κ𝒑{1, if 𝒑2r𝒑2/r, if 𝒑2>r,

so that 𝒑/κ𝒑B(𝟎,r). This definition of self-correction function was used in [44, 5, 7].

To test k-linearity (Algorithm 1), we first test if f is pointwise close to some additive (aka. linear) function using ApproximateAdditivityTester. If it rejects f, we also reject f. However, if ApproximateAdditivityTester does not reject, then the self-corrected function g is pointwise close to some linear function. As we only have approximate oracle access to f, we can’t simulate g exactly. So, we use Approximate-g, the approximate query oracle for g. The work of [5, 7] proves: (i) g and Approximate-g are pointwise close in B(𝟎,r), and (ii) f and Approximate-g are also pointwise close. So, f is pointwise close to Approximate-g.

We partition the n-variables [n] into k2 buckets uniformly at random. So if f is k-linear, the influential variables will be separated into different buckets w.h.p. We can then detect them via the subroutine 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍 (Algorithm 2), which recursively isolates the variables in a bucket and returns only the influential ones. We then reject if the number of buckets with influential variables (variables whose values determine the value of f) is more than k.

3.2 Testing 𝒌-sparsity

Our k-sparse, degree-d polynomial tester (Algorithm 4) adopts a similar approach. We first test if f is a low-degree polynomial, using the ApproxLowDegreeTester from [5, 7]. If it rejects f, we also reject f. However, if ApproxLowDegreeTester does not reject f, then f is point-wise close to a low-degree polynomial.

As in k-linearity testing, we use a self-corrected function g from [5, 7]: For points 𝒑B(𝟎,r), g(𝒑) is the (weighted) median value of g𝒒(𝒑)i=1d+1(1)i+1(d+1i)f(𝒑+i𝒒), weighted according to the probability of 𝒒𝒩(𝟎,In), i.e., g(𝒑)𝗆𝖾𝖽𝒒𝒩(𝟎,In)[g𝒒(𝒑)]. Intuitively, g𝒒(𝒑) is the value that f should take if, when restricted to the line L𝒑,𝒒{𝒑+t𝒒,t}, f would be a degree-d univariate polynomial. Taking the weighted median over all directions 𝒒𝒩(𝟎,In), ensures that the self-correction proportionately respects the values of f, in a local neighborhood of 𝒑. For 𝒑B(𝟎,r),g is defined via radial extrapolation from within B(𝟎,r) along the radial line L𝟎,𝒑.

Given exact query access to f, we can simulate query access to the self-corrected function g. As we only have approximate query access to f, we use ApproxQuery-g (the approximate oracle to the self-corrected function associated with f), which was proved to be pointwise close to g. As a result, f will be pointwise close to ApproxQuery-g as well.

Once we have that f is close to a low-degree polynomial, we use a Hankel matrix (Definition 2.5) based characterization for sparse polynomials. [52, 11] proved Observation 2.6: a polynomial f (over finite fields) is k-sparse, if and only if its associated Hankel matrix has a non-zero determinant. This can be efficiently tested with only 2k+1 queries to f. For polynomials over the reals with exact-queries, the idea from [52] can be extended to give a zero-error (perfect soundness and completeness), zero-gap (does not require ε-farness for ε > 0 in the No case) tester, making 2k+1 queries for deciding whether (i) f is k-sparse, or (ii) f is not k-sparse (proved in Lemma 6.4). This result is even stronger than what [52] gets for finite fields, since the zero set of any polynomial over the reals has zero Gaussian (or Lebesgue) measure, whereas the corresponding probability needs to be bounded in terms of the degree of the polynomials over finite fields (e.g. by the Schwartz-Zippel lemma). Unfortunately, since we only have approximate query access to f, this technique no longer works, as determinants of sums of matrices do not behave nicely. So we take a probabilistic approach, showing that the noisy Hankel matrix constructed from the approximate query to f is not too far from the exact Hankel matrix (proved in Observation 6.5). Finally, we show in Theorem 6.6 using Weyl’s inequality (Theorem 4.4), that if f is a k-sparse, low-degree polynomial, then the smallest eigenvalue of the noisy Hankel matrix associated with ApproxQuery-g is not too large. Combining them all, our main result is proved in Section 6.2.

Since, we only have access to the Hankel matrix of f~=ApproxQuery-g which is η-close to f (on all the query points, whp), we can express H~𝒖Ht(f~,𝒖) (for t=k+1) of such a f~ as the sum of H𝒖Ht(f,𝒖) and a Hankel-structured error matrix with bounded spectral/operator norm (Observation 6.5). From this, and Weyl’s inequality, we get completeness as long as we Accept when the smallest singular value σmin(H~𝒖)η(k+1) in all Θ(d(k+1)2) rounds.

To prove soundness, we need to show that σmin(H~𝒖)>η(k+1) in some round with probability 2/3, as long as Q(𝒖)det(H𝐮) is a non-zero polynomial. This follows (in Theorem 6.6) by invoking the probabilistic upper bound on σmax(H𝐮), for 𝒖𝒩(𝟎,In).

3.3 Testing 𝒌-juntas

Finally, we discuss our algorithm for testing k-juntas (Algorithm 6). Our approach is to first randomly partition the n-variables into k2 buckets. If f is a k-junta, the k influential variables will be separated into distinct buckets w.h.p (by birthday paradox).

Now we run O(k/ε) iterations to find if there exists any influential variable in any bucket, using the subroutine 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍 (Algorithm 2). After these iterations, if we find more than k influential variables in f, we reject it. Otherwise, we accept f. Our analysis follows a combinatorial style similar to [22]. We would like to note that although we use 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍 for k-linearity testing as well, the analysis here significantly deviates from that of k-linearity testing and is presented in Claim 7.7. The main result is formally proved in Section 7.1.

4 Preliminaries

Notations.

Throughout this work, we use boldface letters to represent vectors of length n and normal face letters for variables. Specifically, 𝒆i(0,,0,1i,0,,0) denotes the ith standard unit vector. For n, let [n] denote the set {1,,n}. For a matrix A, let A, Aop, and AF denote the supremum, operator, and Frobenious norms of A, respectively. See [56] for the formal definitions. For concise expressions and readability, we use the asymptotic complexity notion of O~(), where we hide poly-logarithmic dependencies of the parameters. For any f:n, let f(/),C denote the infimum(resp. supremum) value of f over some Cn. Let Πn be the class of functions n satisfying some particular first-order property and let Π=n1Πn.

Definition 4.1 (1-distance).

Let 𝒟={𝒟n}n1 is family of distributions with 𝒟n being a distribution on n. For two arbitrary functions f,g:n, the 1-distance between f and g is defined as: 𝖽𝗂𝗌𝗍𝒟,1(f,g)𝔼𝐱𝒟n[|f(𝐱)g(𝐱)|]. We also define the p-distance of f to the class Πn, and hence the class Π, by 𝖽𝗂𝗌𝗍𝒟,p(f,Π)𝖽𝗂𝗌𝗍𝒟,p(f,Πn)infgΠn𝖽𝗂𝗌𝗍𝒟,p(f,g).

We have 𝖽𝗂𝗌𝗍𝒟,p(f,Π)=0 if and only if there exists a function gΠn which agrees with f almost everywhere with respect to 𝒟n (in the measure-theoretic sense). We will only concern ourselves with p{0,1} since we are dealing with scalar-valued functions (aka functionals) and hence f(𝒙)g(𝒙)p=|f(𝒙)g(𝒙)| for all p>0.

Our definitions hold for general reference distributions 𝒟 which are suitably concentrated. Later, we work with 𝒩(𝟎,In), which also has this desired concentration property.

Definition 4.2 (Concentrated distribution).

Let ε(0,1),R0, and 𝐜n. A distribution 𝒟 supported on n is (ε,R,𝐜)-concentrated if most of its mass is contained in a ball of radius R centered at some point 𝐜n, i.e., Pr𝐩𝒟[𝐩B(𝐜,R)]1ε.

For brevity, we may write “𝒟 is (ε,R)-concentrated” to mean “𝒟 is (ε,R,𝟎)-concentrated”.

Fact 4.3 ([23, Theorem 2.9]).

𝒩(𝟎,In) is (0.01,2n,𝟎)-concentrated.

4.1 Results from Perturbation Theory, and Measure Theory

For analyzing our testers, we use the following result from perturbation theory.

Theorem 4.4 (Weyl’s Inequality [55]).

Let Σ^=Σ+E, where Σ,En×n are both symmetric matrices. Let λi(A) denote the ith eigenvalue of (symmetric matrix) A, sorted in non-increasing order, and let Aop denote its 2-operator (spectral) norm. Then,

maxi[n]{|λi(Σ^)λi(Σ)|}Eopmax{|λd(E)|,|λ1(E)|}.

The following celebrated inequality of Carbery and Wright [27] provides anti-concentration bounds for polynomials of i.i.d Gaussian random variables (more generally, log-concave), which will be used in our proofs, particularly in the analysis of our k-linearity tester.

Theorem 4.5 ([27, Theorem 8]).

Let f:n be a polynomial of degree d, such that 𝖵𝖺𝗋𝒩(𝟎,In)[f]=1. Then t and ε>0, Pr𝐱𝒩(𝟎,In)[|f(𝐱)t|ε]O(d)ε1/d.

A recent result of Glazer and Mikulincer [47] provided a more suitable form of Carbery-Wright for polynomials, with the variance lower-bounded in terms of the coefficients.

Theorem 4.6 ([47, Corollary 4]).

If f:n is a polynomial f(𝐱)=i=1kai𝐱𝐌i of degree d, then there exists an absolute constant C>0 such that for any t and ε>0,

Pr𝒙𝒩(𝟎,In)[|f(𝒙)t|ε]Cd(εcoeffd(f))1/d, where coeffd2(f)i[k]:𝑴i1=dai2.

5 𝒌-linearity Testing

In this section, we present and analyze our algorithm Test-k-Linear (Algorithm 1).

Theorem 5.1 (Generalization of Theorem 2.2).

Let k, f:n is a function bounded in the ball B(𝟎,2n), and ε,η(0,2/3) be such that η<min{ε,O(mini[n]:f(𝐞i)0|f(𝐞i)|(nk)2)}, where 𝐞i denotes the ith standard unit vector. Given η-approximate query access to f, there exists a tester Test-k-Linear (Algorithm 1) that, in O~(klogk+1ε) queries, guarantees:

  • Completeness: If f is a k-linear function, 1 Accepts with probability 2/3.

  • Soundness: If f is ε-far from all k-linear functions, 1 Rejects w.p. 2/3.

Algorithm 1 Test-k-Linear.

Algorithm 1 uses two subroutines 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍 (Algorithm 2) and 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍𝗌 (Algorithm 3). We will first present and analyze them in Section 5.1, and then analyze Algorithm 1 in Section 5.2.

A closely related (and efficiently testable) notion of additivity may be noted here.

Definition 5.2 (Additive function).

A function f:AB is additive, if for all x,yA, f(xAy)=f(x)Bf(y), where A and B denote the bitwise-xor operations in A and B, respectively.

Over finite domains, additivity implies linearity. But over continuous domains, this isn’t always the case. However, for continuous functions, testing additivity suffices:

Fact 5.3 ([60, Section 5.2]).

For continuous functions, additivity is equivalent to linearity.

Algorithm 1 uses a query oracle to the self-corrected function, Approximate-g. We now note the following results from [5, 7] about their approximate additivity tester.

Theorem 5.4 ([5, Theorem D.1], and [7, Theorem 3.3]).

Let α,ε>0, for L>0, suppose f:n is a function that is bounded in the ball B(0,L) and 𝒟 be an unknown (ε/4,R)-concentrated distribution. There exists a one-sided error, O(1ε)-query tester (ApproximateAdditivityTester) which with probability at least 99/100, distinguishes when f is pointwise α-close to some additive function and when, for every additive function h, Pr𝐩𝒟[|f(𝐩)h(𝐩)|>O(Rn1.5α)]>ε.

Lemma 5.5 ([5, Lemma D.3 and D.6]).

If TestAdditivity(f,3α) accepts with probability at least 1/3, then g is a 42α-additive function inside the small ball B(𝟎,r), and furthermore, for every 𝐩B(𝟎,r) it holds that

Pr𝒙𝒩(𝟎,In)[|g(𝒑)g𝒙(𝒑)|12α]<12/125.
Lemma 5.6 ([5, Lemma D.4 and D.5]).

If TestAdditivity(f,3α) accepts with probability at least 1/3, then for every 𝐩,𝐪B(𝟎,r) with 𝐩+𝐪2r, it holds that

|g(𝒑+𝒒)g(𝒑)g(𝒒)|42α.

The following lemma gives us a way to scale the closeness for degree-d polynomials.

Lemma 5.7 ([5, Lemma 4.19]).

Let R>r>0 be any real numbers. If g is pointwise η-close to a degree-d polynomial in B(𝟎,r), then g is pointwise (12R/r)dη-close to a degree-d polynomial on all points in B(𝟎,R).

Using Lemma 5.5, Lemma 5.7 and the structure of Approximate-g subroutine, they bound the distance between g and Approximate-g.

Claim 5.8.

If TestAdditivity(f,3α) accepts with probability at least 1/3, then Approximate-g is pointwise 6α-close to g, in the ball B(𝟎,r) w.h.p.; i.e.,

Pr𝒑𝒟[|g(𝒑)Approximate-g(𝒑)|6α(12R/r)𝒑B(𝟎,R)]1ε/4.

The following observation directly follows using the triangle inequality, along with the above claim and the notion of η-approximate queries.

Observation 5.9.

If ApproximateAdditivityTester does not reject f with probability at least 2/3, then following the description of ApproximateAdditivityTester, we have

Pr𝒑𝒟[|f(𝒑)Approximate-g(𝒑)|750Rn1.5α𝒑B(𝟎,R)]1ε4.

We will invoke them with 𝒟=𝒩(𝟎,In), implying R=2n (from Fact 4.3).

5.1 Analyses of Subroutines

The subroutine 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍 is presented in Algorithm 2.

Algorithm 2 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍(f,B,S).

To analyze it, we need:

Definition 5.10 (Influential bucket for linear functions).

For a function f:n, a bucket B[n] is said to be an influential bucket if there exists at least one variable xi,iB, which is influential with respect to f (i.e., f(𝐱) changes with a change in xi). For a linear f, with f(𝐱)i[n]aixi, xi is influential w.r.t f if and only if ai0, and hence B is an influential bucket iff ai0 for some iB.

Claim 5.11 (Correctness of 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍).

Let f:n, with f(𝒙)=i[n]aixi be given via an η-approximate query f~, where η1100k2mink[n]:ak0|ak|, B={B1,,Br} be a partition of [n], and S[r]. Then 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍(f,B,S) (Algorithm 2) guarantees:

  1. 1.

    If none of the buckets {Bi,iS} are influential, 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍(f,B,S) always returns and performs exactly 2 queries to f.

  2. 2.

    Otherwise, with probability at least 18log|S|2/10k2, 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍(f,B,S) returns Bj for some jS which is an influential bucket, and performs 8lg(|S|)2 queries to f.

Next we describe and analyze the subroutine 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍𝗌 (Algorithm 3).

Algorithm 3 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍𝗌(f~,B,X).
Claim 5.12 (Correctness of 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍𝗌).

Let f:n, with f(𝒙)=i[n]aixi, be given via the η-approximate query oracle f~, where η1100k2mink[n]:ak0|ak|, and X[n]. Then 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍𝗌(f,B,X) (Algorithm 3), in at most 64klog(|X|)2 queries, guarantees:

  1. (i)

    If f is -linear function for some >8k, then Algorithm 3 will return a set of 8k influential buckets in f with probability at least 164log|X|2/10k.

  2. (ii)

    If f is -linear function for some 8k, then Algorithm 3 will return the set of all influential buckets in f with probability at least 164log|X|2/10k.

5.2 Analysis of the 𝒌-linearity tester (Algorithm 1)

We are now ready to prove the main theorem of this section:

Proof of Theorem 5.1.

Completeness.

Since f is a k-linear function, following Theorem 5.4, we have: ApproximateAdditivityTester accepts f, and hence by Lemma 5.6, g is pointwise 42η-close to linearity in B(𝟎,r). Combined with Lemma 5.7, we get g is pointwise 42η(12R/r)-close to linearity in B(𝟎,R). From Claim 5.8, we know that g and Approximate-g are pointwise 6η(12R/r)-close in B(𝟎,R) with probability at least 1ε/4. Using the triangle inequality, this implies that Approximate-g is pointwise 48η(12R/r)-close to some linear function with probability 1ε/4. Moreover, from Observation 5.9, we get: Approximate-g is in fact pointwise 750Rn1.5η-close to f, with probability at least 1ε/2. With R=2n, following the guarantee of Claim 5.12, ensured by our assumption on η:

O(n2η)1100k2mink[n]:ak0|ak|, or equivalently ηO(mini[n]:f(𝒆i)0|f(𝒆i)|(nk)2),

we get that 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍𝗌(Approximate-g,B,[r]) will return at most k-influential variables of f with probability at least 1128logk2/5k. Thus with probability at least 1ε/2128logk2/5k, Test-k-Linear will Accept.

Soundness.

Let f be ε-far from k-linearity. We will prove the contrapositive. We will show that if Test-k-Linear does not reject f with probability at least 1δ(2/3), then f is pointwise close to some k-linear function, with non-zero probability.

Note that if ApproximateAdditivityTester rejects f with probability 1δ, we are done. So, let us consider the case when ApproximateAdditivityTester accepts with probability δ. As in the completeness proof, from Lemma 5.5, and Lemma 5.7, we know that g is pointwise 42η(12R/r)-close to linearity in B(𝟎,R) with probability at least 112/125, and from Claim 5.8, we have that g and Approximate-g are pointwise 6η(12R/r)-close in B(𝟎,R) with probability at least 1ε/4. This implies that Approximate-g is pointwise 48η(12R/r)-close to some linear function with probability at least 1ε/412/125. Again, from Observation 5.9, we get: Approximate-g is pointwise 750Rn1.5η-close to f, with probability at least 1ε/4, implying now f must be pointwise (48(12R/r)+750Rn1.5)η-close to linearity, with probability at least 1ε/212/125. Note, here R=2n, and r=1/50.

With our assumption on η again ensuring the conditions for Claim 5.12 are met, i.e.,

(48(12R/r)+750Rn1.5)η1100k2mink[n]:ak0|ak|,

we get 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍𝗌(Approximate-g,B,[r]) will return at most 8k-influential variables of f with probability at least 1128logk2/5k.

Since Test-k-Linear accepts f with probability δ, this implies that the total number of influential variables returned by 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍𝗌 is at most k, with probability δ. Combining the above, we conclude that f is pointwise (48(12R/r)+750Rn1.5)η-close to a k-linear function, with probability at least δ12/125ε/2128logk2/5k. This concludes the proof.

Query complexity.

From Theorem 5.4, we have: ApproximateAdditivityTester performs O(1ε) queries. From Claim 5.12, we have: 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍𝗌 performs O~(klogk) queries. Combining them, we have: Test-k-Linear performs O~(klogk+1ε) queries in total.

6 𝒌-Sparse Low Degree Testing

In this section, we present and analyze our sparse low degree tester (Algorithm 4).

Theorem 6.1 (Generalization of Theorem 2.7).

Let η<min{ε,1/22n}. Given η-approximate query access to f:n that is bounded in B(𝟎,2dn), there exists a tester Test-k-Sparse (Algorithm 4) that performs O~(d5+d2ε+dk3) queries and guarantees:

  • Completeness: If f is a k-sparse, degree-d polynomial, then 4 Accepts with probability at least 1ε/4.

  • Soundness: If f is ε-far from all k-sparse, degree-d polynomials, then 4 Rejects with probability at least 2/3.

Algorithm 4 Test-k-Sparse.

We will prove Theorem 6.1 in Section 6.2, after developing the necessary machinery. Algorithm 4 first invokes ApproxLowDegreeTester to reject functions that are far from any low-degree polynomial. We record some useful claims about ApproxLowDegreeTester, and its subroutines (ApproxCharacterizationTest, ApproxQuery-g and ApproxQuery-g-InBall) from [5] and (its improvement in) [7]:

Theorem 6.2 ([7, Theorem 3.6]).

Let d, for L>0, f:n be bounded in the ball B(𝟎,L), and for ε(0,1),R>0, let 𝒟 be an (ε/4,R)-concentrated distribution. For α>0,β2(2n)O(d)(R/L)dα, given α-approximate query access to f, and sampling access to 𝒟, there is an one-sided error, O(d5+d2ε)-query ApproxLowDegreeTester which, distinguishes between the case when f is pointwise α-close to some degree-d polynomial and the case when, for every degree-d polynomial h:n, Pr𝐩𝒟[|f(𝐩)h(𝐩)|>β]>ε.

Lemma 6.3 ([5, Lemma 4.4]).

Let r=(4d)6, δ=2d+1α, and R>r. If ApproxCharacterizationTest fails with probability at most 2/3, then g is pointwise 2(2n)45d(R/L)dδ-close to a degree-d polynomial in B(𝟎,2dRn/L). Furthermore, 𝐩B(𝟎,2dRn/L), ApproxQuery-g(𝐩) well approximates g(𝐩) w.h.p., i.e.,

Pr𝒑𝒟[|g(𝒑)ApproxQuery-g(𝒑)|(24dRnLr)d2d+4δ]1ε4.

To invoke these results, we assume: (i) f is bounded in B(𝟎,R), i.e., we set L=R, and (ii) α=η. Additionally, since we work over standard Gaussians, we set R=2dn.

Testing sparsity of polynomials given exact query access.

As a preliminary, we design an algorithm for testing sparsity of polynomial functions f:n, by extending the machinery of Hankel matrices developed in [52, 11] to the real numbers. Moreover, ˜2.6 can be used to exactly determine whether a polynomial f is (k)-sparse.

Lemma 6.4.

Let f:n be a polynomial function (of any degree). Given exact query access to f, there is an algorithm that makes 2k+1 queries to f, and exactly tests whether f0k (returns Accept), or f0>k (returns Reject) with error probability 0.

6.1 Testing sparsity of polynomials given approximate query access

Now, instead of exact query access, we have η-approximate query f~ to a polynomial f, which guarantees |f~(𝒛)f(𝒛)|η for all points 𝒛n, giving us:

Observation 6.5.

Let f:n and let f~ be an η-approximate query oracle to f. Then for any t1 and 𝐮n, we can express Ht(f~,𝐮)=Ht(f,𝐮)+Et(𝐮), where Et(𝐮) is a Hankel-structured noise matrix, s.t. Et(𝐮)η, and Et(𝐮)opηt.

We now present and analyze the correctness of Algorithm 5, using Theorem 2.12:

Algorithm 5 Approx-Poly-Sparsity-Test: Approx-query sparsity test for polynomials.
Theorem 6.6 (Sparsity testing with approximate queries).

Given η-approximate query access f~ to a polynomial f:n of total degree d, assuming η(coeffdQ(Q))12(2(k+1))2Θ(k3d)(σmax(H𝐮))k, wherein H𝐮=Hk+1(f,𝐮),Q𝐮=(det(H𝐮))2,dQ=deg(Q), and coeffdQ2(Q) is as in Theorem 4.6, Approx-Poly-Sparsity-Test (Algorithm 5), in O(dk3) queries, guarantees:

  1. (i)

    If f has sparsity at most k, the algorithm always Accepts, and

  2. (ii)

    If f has sparsity >k, the algorithm Rejects with probability at least 23.

6.2 Analysis of 𝒌-Sparsity Low Degree Tester

We are now ready to analyze our sparse low degree tester (Algorithm 4).

Proof of Theorem 6.1.

Let us start with completeness. Completeness: Since f is a k-sparse, degree-d polynomial, from Theorem 6.2, we have: Approx-Low-Degree-Tester always accepts f, and hence, from Lemma 6.3, we have that g is pointwise 2(2n)45dRd2d+1η-close to a degree-d polynomial, say h, in B(𝟎,R). Moreover,

Pr𝒑𝒟[|g(𝒑)ApproxQuery-g(𝒑)|(24dnr)d22d+5η𝒑B(𝟎,2dn)]1ε2.
Pr𝒑𝒟[|h(𝒑)ApproxQuery-g(𝒑)|((24dnr)d22d+5+2(2n)45dRd2d+1)η]1ε4. (1)

By setting η=1/22n, the conditions of Theorem 6.6 are met, giving us that Approx-Poly-Sparsity-Test(ApproxQuery-g) (Algorithm 5) will Accept with probability 1ε/4. So with probability at least 1ε/4, Test-k-Sparse (Algorithm 4) will accept f.

Soundness.

Let f be ε-far from all k-sparse, degree-d polynomials. We will show that if Algorithm 4 accepts with probability at least 1/3, then f must be ε-close to some k-sparse, degree-d polynomial. From the premise, Approx-Low-Degree-Tester also accepts f with probability at least 1/3. Then, as in completeness, from Lemma 6.3, we have: g is pointwise 2(2n)45dRd2d+1η-close to some degree-d polynomial, say h(𝒙)=𝑴i1dai𝑴i(𝒙), i.e., for all 𝒑B(𝟎,R), |g(𝒑)h(𝒑)|2(2n)45dRd2d+1η, and (1) still holds.

From the premise, Approx-Poly-Sparsity-Test(ApproxQuery-g) (Algorithm 5) does not reject with probability 1/3. In this case, as long as the closeness of ApproxQuery-g and h satisfies the assumption in Theorem 6.6, h will be k-sparse. The assumption is:

(32(2n)45d+1)η(coeffdQ(Q))12(2(k+1))2Θ(k3d)(σmax(H𝒖))k, (2)

where H𝒖=Hk+1(h,𝒖),Q(𝒖)=(det(H𝒖))2,dQ=deg(Q), coeffdQ2(Q)(𝒂22nd)(k+1)((k+1)!)2, and σmax(H𝒖) may be bounded using Theorem 2.12 (with γ=0.01,t=k+1), i.e.,

Pr𝒖𝒩(𝟎,In)[σmax(H𝒖)𝒂22(2d/2d/2!+k0.012d/2d!)2(k+1)]0.01.

So, with probability at least 0.99, σmax(H𝒖)𝒂22(2d/2d/2!+10k2d/2d!)2(k+1). Plugging these into (2), we observe, setting η1/22n satisfies it, implying that f is ε-close to some k-sparse, degree-d polynomial.

Query complexity.

The query complexity of Algorithm 4 consists of two parts:

  • query complexity of ApproxLowDegreeTester which is O(d5+d2/ε) (from Theorem 6.2), and

  • the query complexity of Approx-Poly-Sparsity-Test (Algorithm 5) which is at most O(dk3) (from Theorem 6.6).

Combining the above, we have: Algorithm 4 performs O(d5+d2/ε+dk3) queries in total.

7 𝒌-Junta Testing

In this section, we present and analyze our k-junta tester.

Theorem 7.1 (Generalization of Theorem 2.10).

Let ε(0,1), η<min{ε16k2,O(1k2log2k)}. Given η-approximate query access to an unknown function f:n that is bounded in B(𝟎,2n), there exists a one-sided error tester Test-k-Junta (Algorithm 6) that performs O~((klogk)/ε) queries and guarantees:

  • Completeness: If f is a k-junta, then 6 always Accepts.

  • Soundness: If f is ε-far from all k-juntas, then 6 Rejects w.p. 2/3.

Algorithm 6 Test-k-Junta.

In order to prove Theorem 7.1, we first build some machinery, and then analyze Algorithm 6 and its subroutine (Algorithm 2 for juntas). Let us start with the notion of influence.

Definition 7.2 (Influence).

Let f:n be a function. For any set S[n], the influence of f over S with respect to a distribution 𝒟 over n is defined as follows:

𝖨𝗇𝖿𝗅f(S)=𝔼𝒙,𝒚𝒟[|f(𝒚)f(𝒙S𝒚S¯)|].

We first prove a structural result. Let 𝒥k denote the set of all k-juntas on n variables.

Theorem 7.3.

If 𝖽𝗂𝗌𝗍(f,𝒥k)ε, then S[n]:|S|k, with S¯[n]S, 𝖨𝗇𝖿𝗅f(S¯)ε.

Next we prove a lemma that connects the influence of the union of two sets of variables with the influences of individual sets.

Lemma 7.4 (Sub-additivity of Influence).

For every f:n, and any S,T[n],

max{𝖨𝗇𝖿𝗅f(S),𝖨𝗇𝖿𝗅f(T)}𝖨𝗇𝖿𝗅f(ST)𝖨𝗇𝖿𝗅f(S)+𝖨𝗇𝖿𝗅f(T).

Next we show, if f is far from being a k-junta, the influence of S¯ in Algorithm 6 (i.e. all buckets not yet identified as influential) is high, unless we identify more than k parts.

Lemma 7.5.

Let f:n and ={B1,,Br} be a random partition of [n], for r=Θ(k2). If 𝖽𝗂𝗌𝗍(f,𝒥k)ε, with probability 99/100 over the randomness of the partition, we have 𝖨𝗇𝖿𝗅f(S¯)ε/4 for any S[n] which is a union of at most k parts of .

7.1 Proof of correctness of Test-k-Junta

As Algorithm 6 invokes Algorithm 2, we first prove its correctness for juntas.

Definition 7.6 (Influential variables and buckets).

Let f:n, and k. A variable xi,i[n] is influential with respect to f, if for some 𝐱(x1,,xn)n, only changing xi changes the value of f(𝐱). A bucket B[n] is said to be influential if it contains the index of at least one influential variable, and non-influential otherwise.

Let denote the event that for 𝒙,𝒚𝒩(𝟎,In), 𝒙,𝒚B(𝟎,2n). By Fact 4.3, we have Pr𝒙,𝒚𝒩(𝟎,In)[¯]=Pr𝒙,𝒚𝒩(𝟎,In)[𝒙,𝒚B(𝟎,2n)0.01. Let

κminV[n]V is influential{𝔼𝒙,𝒚𝒩(𝟎,In)[|f(𝒙V𝒚V¯)f(𝒚)|]}.

We use 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍 (Algorithm 2) for testing k-linearity as well. However, the proof of correctness of Algorithm 2 in Section 5, presented in Claim 5.11, holds only for linear functions, which may not be the case in general. So, we prove the same for juntas too:

Claim 7.7 (Correctness of Algorithm 2 for juntas).

Let f:n be given via the η-approximate query f~, where ηmin{κ/4,1/(1000k2log2k)}, B={B1,,Br} be a partition of [n], and S[r]. With κmax{2f,B(𝟎,2n),ε/(4k2)}, we have:

  1. 1.

    If none of the Bi’s are influential, 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍(f,B,S) always returns and performs exactly 2 queries to f.

  2. 2.

    Otherwise, with probability at least 116ηlog|S|2/κ, 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍(f,B,S) returns Bj for some jS which is κ-influential and performs 8lg(|S|)2 queries to f.

We are now ready to prove the main theorem of this section:

Proof of Theorem 7.1.

Let us start with the completeness proof.

Completeness.

The argument of completeness of Algorithm 6 holds easily, as when f is a k-junta, at most k of the buckets in the random partition will be influential. From Claim 7.7, we get that each execution of the 𝖥𝗈𝗋 loop increments I by: either the index of an influential bucket (if it finds one), or nothing, while also removing the bucket from future loop executions. Hence after all its executions, |I| is incremented at most k times, falsifying the check in line 6, making f Accept.

Soundness.

Here our goal is to prove if f is ε-far from all k-juntas, then Algorithm 6 rejects it with probability 2/3. In particular, if f is ε-far from being k-junta, and S is the union of at most k-parts of , then Line 7 of Algorithm 6 will be satisfied w.h.p.

By Lemma 7.5, we have: if |I|k, 𝖨𝗇𝖿𝗅f(S)ε/4 (S=[n]I in the execution of Algorithm 6). During the execution, when exactly k influential buckets have been identified, 𝖨𝗇𝖿𝗅f(S)ε/4, |S|=O(k2)k=O(k2), and thus, by Lemma 7.4, there must exist a bucket Bi,iS such that 𝖨𝗇𝖿𝗅f(Bi)ε/(4k2). This bucket will then be output by 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍(f,B,S). So, until k+1 influential buckets have been identified, each invocation of 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍(f,B,S) in an execution of its 𝖥𝗈𝗋 loop, returns an influential bucket with probability 164ηlogk2/κ. Treating the outcome of each invocation as a geometric random variable, we conclude: to recover at least k+1 such buckets with probability 2/3,

k/(164ηlogk2/κ)=k+ki=1(64ηlogk2/κ)i=O(k/ε)

iterations of 𝖥𝗈𝗋 loop suffice. When |I|>k, in line 6, algorithm rejects with same probability.

Query Complexity.

From Claim 7.7, we know: each invocation of 𝖥𝗂𝗇𝖽𝖨𝗇𝖿𝖡𝗎𝖼𝗄𝖾𝗍(f,B,S) performs 4log|S| queries to f. With O(k/ε) such invocations in total, and |S|=r=O(k2), the overall query complexity thus is O((klogk)/ε).

8 Lower Bounds

See 2.11 For proving the lower bounds in the exact query model (which covers approximate queries), we follow the approach of [19], i.e., we show the hardness of testing by reducing from Set-Disjointness problem, a canonical hard problem in the field of communication complexity. For brevity, we only present the lower bound argument for k-linearity.

𝛀(𝟏𝜺) queries for linearity.

For any ε(0,1), it is a folklore result that distinguishing if a function f is linear, or ε-far from being linear in 1-distance, requires Ω(1/ε) queries [42].

𝛀(𝒅) queries for degree-𝒅 polynomial testing.

It is another folklore result that given a proximity parameter ε(0,1), Ω(d) queries are necessary to distinguish if an unknown function f is a degree-d polynomial, or a degree-(d+1) (or (d1)) polynomial (and hence, is ε-far from all degree-d polynomials) with probability at least 2/3.

To prove the Ω(k) query lower bound for k-linearity, we use a reduction from Set-Disjointness which is known to require Ω(k) communication complexity [54].

Connection between Communication and Query complexity.

Consider two functions f and g, a property 𝒫, hfg, and a communication problem Ch,𝒫: Alice and Bob receive f and g, respectively, and they want to decide if h𝒫, or f is ε-far from 𝒫. [19] (Lemma 2.2) proved that (Ch,𝒫), the randomized communication complexity of Ch,𝒫2Q(𝒫), the query complexity of deciding the property 𝒫.

Construction of the hard instances.

Given A[n]:|A|=k, Alice constructs a polynomial f=iA𝒙i. Similarly Bob, given B[n],|B|=k, constructs a polynomial g=iB𝒙i. Note that f,g:n. Let hfg. If |AB|=1, h would be a (2k2) linear function, whereas if |AB|=0, h would be a 2k-linear function.

Lemma 8.1.

Let f1 be a (2k+2)-linear function, and f2 be a 2k-linear function with coefficients from {0,1}. Under the standard Gaussian distribution 𝒩(𝟎,In), f1 is Ω(1)-far from f2 in 1-distance with probability at least 2/3.

References

  • [1] Noga Alon, Tali Kaufman, Michael Krivelevich, Simon Litsyn, and Dana Ron. Testing reed-muller codes. IEEE Transactions on Information Theory, 51(11):4032–4039, 2005. doi:10.1109/TIT.2005.856958.
  • [2] Sigal Ar, Manuel Blum, Bruno Codenotti, and Peter Gemmell. Checking approximate computations over the reals. In Proceedings of the twenty-fifth annual ACM symposium on Theory of Computing, pages 786–795, 1993. doi:10.1145/167088.167288.
  • [3] Sanjeev Arora, Carsten Lund, Rajeev Motwani, Madhu Sudan, and Mario Szegedy. Proof verification and the hardness of approximation problems. J. ACM, 45(3):501–555, May 1998. doi:10.1145/278298.278306.
  • [4] Sanjeev Arora and Shmuel Safra. Probabilistic checking of proofs: A new characterization of NP. J. ACM, 45(1):70–122, January 1998. doi:10.1145/273865.273901.
  • [5] Vipul Arora, Arnab Bhattacharyya, Noah Fleming, Esty Kelman, and Yuichi Yoshida. Low degree testing over the reals. In Nikhil Bansal and Viswanath Nagarajan, editors, Proceedings of the 2023 ACM-SIAM Symposium on Discrete Algorithms, SODA 2023, Florence, Italy, January 22-25, 2023, pages 738–792. SIAM, 2023. doi:10.1137/1.9781611977554.ch31.
  • [6] Vipul Arora, Arnab Bhattacharyya, Philips George John, and Sayantan Sen. Testing sparse functions over the reals. CoRR, abs/2603.28061, 2026. doi:10.48550/arXiv.2603.28061.
  • [7] Vipul Arora, Esty Kelman, and Uri Meir. On optimal testing of linearity. In Proceedings of the 2025 Symposium on Simplicity in Algorithms (SOSA), pages 65–76. SIAM, 2025. doi:10.1137/1.9781611978315.5.
  • [8] Maria-Florina Balcan, Eric Blais, Avrim Blum, and Liu Yang. Active property testing. In 53rd Annual IEEE Symposium on Foundations of Computer Science, FOCS 2012, New Brunswick, NJ, USA, October 20-23, 2012, pages 21–30. IEEE, IEEE Computer Society, 2012. doi:10.1109/FOCS.2012.64.
  • [9] Roksana Baleshzar, Deeparnab Chakrabarty, Ramesh Krishnan S. Pallavoor, Sofya Raskhodnikova, and C. Seshadhri. Optimal unateness testers for real-valued functions: Adaptivity helps. CoRR, abs/1703.05199, 2017. doi:10.48550/arXiv.1703.05199.
  • [10] Yiqiao Bao, Anindya De, Shivam Nadimpalli, Rocco A. Servedio, and Nathan White. Testing noisy low-degree polynomials for sparsity, 2025. doi:10.48550/arXiv.2511.07835.
  • [11] Michael Ben-Or and Prasoon Tiwari. A deterministic algorithm for sparse multivariate polynominal interpolation (extended abstract). In Janos Simon, editor, Proceedings of the 20th Annual ACM Symposium on Theory of Computing, May 2-4, 1988, Chicago, Illinois, USA, STOC ’88, pages 301–309, New York, NY, USA, 1988. ACM. doi:10.1145/62212.62241.
  • [12] Piotr Berman, Sofya Raskhodnikova, and Grigory Yaroslavtsev. Lp-testing. In David B. Shmoys, editor, Symposium on Theory of Computing, STOC 2014, New York, NY, USA, May 31 - June 03, 2014, STOC ’14, pages 164–173, New York, NY, USA, 2014. ACM. doi:10.1145/2591796.2591887.
  • [13] Arnab Bhattacharyya, Eldar Fischer, Hamed Hatami, Pooya Hatami, and Shachar Lovett. Every locally characterized affine-invariant property is testable. In Proceedings of the forty-fifth annual ACM symposium on Theory of computing, pages 429–436, 2013. doi:10.1145/2488608.2488662.
  • [14] Arnab Bhattacharyya, Swastik Kopparty, Grant Schoenebeck, Madhu Sudan, and David Zuckerman. Optimal testing of reed-muller codes. In 2010 IEEE 51st Annual Symposium on Foundations of Computer Science, pages 488–497. IEEE, 2010. doi:10.1109/FOCS.2010.54.
  • [15] Arnab Bhattacharyya and Yuichi Yoshida. Property Testing - Problems and Techniques. Springer, 2022. doi:10.1007/978-981-16-8622-1.
  • [16] Hadley Black, Iden Kalemaj, and Sofya Raskhodnikova. Isoperimetric Inequalities for Real-Valued Functions with Applications to Monotonicity Testing. In Kousha Etessami, Uriel Feige, and Gabriele Puppis, editors, 50th International Colloquium on Automata, Languages, and Programming (ICALP 2023), volume 261 of Leibniz International Proceedings in Informatics (LIPIcs), pages 25:1–25:20, Dagstuhl, Germany, 2023. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ICALP.2023.25.
  • [17] Eric Blais. Improved bounds for testing juntas. In International Workshop on Approximation Algorithms for Combinatorial Optimization, pages 317–330. Springer, 2008. doi:10.1007/978-3-540-85363-3_26.
  • [18] Eric Blais. Testing juntas nearly optimally. In Proceedings of the forty-first annual ACM symposium on Theory of computing, pages 151–158, 2009. doi:10.1145/1536414.1536437.
  • [19] Eric Blais, Joshua Brody, and Kevin Matulef. Property testing lower bounds via communication complexity. computational complexity, 21:311–358, 2012. doi:10.1007/s00037-012-0040-x.
  • [20] Eric Blais and Daniel Kane. Tight bounds for testing k-linearity. In International Workshop on Approximation Algorithms for Combinatorial Optimization, pages 435–446. Springer, 2012. doi:10.1007/978-3-642-32512-0_37.
  • [21] Eric Blais, Sofya Raskhodnikova, and Grigory Yaroslavtsev. Lower bounds for testing properties of functions over hypergrid domains. In 2014 IEEE 29th Conference on Computational Complexity (CCC), pages 309–320. IEEE, 2014. doi:10.1109/CCC.2014.38.
  • [22] Eric Blais, Amit Weinstein, and Yuichi Yoshida. Partially symmetric functions are efficiently isomorphism testable. SIAM Journal on Computing, 44(2):411–432, 2015. doi:10.1137/140971877.
  • [23] Avrim Blum, John Hopcroft, and Ravindran Kannan. Foundations of Data Science. Cambridge University Press, 2020. doi:10.1017/9781108755528.
  • [24] Manuel Blum, Michael Luby, and Ronitt Rubinfeld. Self-testing/correcting with applications to numerical problems. In Harriet Ortiz, editor, Proceedings of the 22nd Annual ACM Symposium on Theory of Computing, May 13-17, 1990, Baltimore, Maryland, USA, pages 73–83. ACM, 1990. doi:10.1145/100216.100225.
  • [25] Manuel Blum, Michael Luby, and Ronitt Rubinfeld. Self-testing/correcting with applications to numerical problems. J. Comput. Syst. Sci., 47(3):549–595, 1993. doi:10.1016/0022-0000(93)90044-W.
  • [26] Nader H Bshouty. An optimal tester for k-linear. Theoretical Computer Science, 950:113759, 2023. doi:10.1016/j.tcs.2023.113759.
  • [27] Anthony Carbery and James Wright. Distributional and Lq Norm Inequalities for Polynomials over Convex Bodies in n. Mathematical Research Letters, 8:233–248, 2001.
  • [28] Deeparnab Chakrabarty and C. Seshadhri. Optimal bounds for monotonicity and lipschitz testing over hypercubes and hypergrids. In Dan Boneh, Tim Roughgarden, and Joan Feigenbaum, editors, Symposium on Theory of Computing Conference, STOC’13, Palo Alto, CA, USA, June 1-4, 2013, pages 419–428. ACM, 2013. doi:10.1145/2488608.2488661.
  • [29] Xi Chen, Adam Freilich, Rocco A. Servedio, and Timothy Sun. Sample-based high-dimensional convexity testing. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques (APPROX/RANDOM), pages 37:1–37:20, 2017. doi:10.4230/LIPIcs.APPROX-RANDOM.2017.37.
  • [30] Xi Chen, Rocco A. Servedio, Li-Yang Tan, Erik Waingarten, and Jinyu Xie. Settling the query complexity of non-adaptive junta testing. J. ACM, 65(6):40:1–40:18, 2018. doi:10.1145/3213772.
  • [31] Hana Chockler and Dan Gutfreund. A lower bound for testing juntas. Information Processing Letters, 90(6):301–305, 2004. doi:10.1016/j.ipl.2004.01.023.
  • [32] Anindya De, Elchanan Mossel, and Joe Neeman. Is your function low dimensional? In Conference on Learning Theory, pages 979–993. PMLR, 2019. URL: http://proceedings.mlr.press/v99/de19a.html.
  • [33] Ilias Diakonikolas, Homin K Lee, Kevin Matulef, Krzysztof Onak, Ronitt Rubinfeld, Rocco A Servedio, and Andrew Wan. Testing for concise representations. In 48th Annual IEEE Symposium on Foundations of Computer Science (FOCS’07), pages 549–558. IEEE, 2007. doi:10.1109/FOCS.2007.32.
  • [34] Irit Dinur. The PCP theorem by gap amplification. J. ACM, 54(3):12, June 2007. doi:10.1145/1236457.1236459.
  • [35] Yevgeniy Dodis, Oded Goldreich, Eric Lehman, Sofya Raskhodnikova, Dana Ron, and Alex Samorodnitsky. Improved testing algorithms for monotonicity. In International Workshop on Randomization and Approximation Techniques in Computer Science, pages 97–108. Springer, 1999. doi:10.1007/978-3-540-48413-4_10.
  • [36] Regina C. Elandt. The folded normal distribution: Two methods of estimating parameters from moments. Technometrics, 3(4):551–562, 1961. URL: http://www.jstor.org/stable/1266561.
  • [37] Funda Ergün, S Ravi Kumar, and Ronitt Rubinfeld. Checking approximate computations of polynomials and functional equations. SIAM Journal on Computing, 31(2):550–576, 2001. doi:10.1137/S0097539798337613.
  • [38] Uriel Feige, Shafi Goldwasser, László Lovász, Shmuel Safra, and Mario Szegedy. Approximating clique is almost np-complete (preliminary version). In 32nd Annual Symposium on Foundations of Computer Science, San Juan, Puerto Rico, October 1-4, 1991, pages 2–12. IEEE Computer Society, 1991. doi:10.1109/SFCS.1991.185341.
  • [39] Renato Ferreira Pinto Jr. Directed Poincaré Inequalities and L¹ Monotonicity Testing of Lipschitz Functions. In Nicole Megow and Adam Smith, editors, Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques (APPROX/RANDOM 2023), volume 275 of Leibniz International Proceedings in Informatics (LIPIcs), pages 61:1–61:18, Dagstuhl, Germany, 2023. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.APPROX/RANDOM.2023.61.
  • [40] Renato Ferreira Pinto Jr. Directed isoperimetry and monotonicity testing: A dynamical approach. In 2024 IEEE 65th Annual Symposium on Foundations of Computer Science (FOCS), pages 2295–2305. IEEE, 2024. doi:10.1109/FOCS61266.2024.00134.
  • [41] Eldar Fischer. The art of uninformed decisions. Bull. EATCS, 75:97, 2001.
  • [42] Eldar Fischer. A basic lower bound for property testing, 2024. doi:10.48550/arXiv.2403.04999.
  • [43] Eldar Fischer, Guy Kindler, Dana Ron, Shmuel Safra, and Alex Samorodnitsky. Testing juntas. Journal of Computer and System Sciences, 68(4):753–787, 2004. doi:10.1016/j.jcss.2003.11.004.
  • [44] Noah Fleming and Yuichi Yoshida. Distribution-free testing of linear functions on n. In Thomas Vidick, editor, 11th Innovations in Theoretical Computer Science Conference, ITCS 2020, Seattle, Washington, USA, January 12-14, 2020, volume 151 of LIPIcs, pages 22:1–22:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPIcs.ITCS.2020.22.
  • [45] Katalin Friedl and Madhu Sudan. Some improvements to total degree tests. In Proceedings Third Israel Symposium on the Theory of Computing and Systems, pages 190–198. IEEE, 1995. doi:10.1109/ISTCS.1995.377032.
  • [46] Peter Gemmell, Richard Lipton, Ronitt Rubinfeld, Madhu Sudan, and Avi Wigderson. Self-testing/correcting for polynomials and for approximate functions. In STOC, volume 91, pages 32–42. Citeseer, 1991. doi:10.1145/103418.103429.
  • [47] Itay Glazer and Dan Mikulincer. Anti-concentration of polynomials: Dimension-free covariance bounds and decay of fourier coefficients. Journal of Functional Analysis, 283(9):109639, 2022. doi:10.1016/j.jfa.2022.109639.
  • [48] O. Goldreich, S. Goldwasser, and D. Ron. Property testing and its connection to learning and approximation. In Proceedings of 37th Conference on Foundations of Computer Science, pages 339–348, 1996. doi:10.1109/SFCS.1996.548493.
  • [49] Oded Goldreich. On testing computability by small width obdds. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques: 13th International Workshop, APPROX 2010, and 14th International Workshop, RANDOM 2010, Barcelona, Spain, September 1-3, 2010. Proceedings, pages 574–587. Springer, 2010. doi:10.1007/978-3-642-15369-3_43.
  • [50] Oded Goldreich. Introduction to property testing. Cambridge University Press, 2017. doi:10.1017/9781108135252.
  • [51] Parikshit Gopalan, Ryan O’Donnell, Rocco A Servedio, Amir Shpilka, and Karl Wimmer. Testing fourier dimensionality and sparsity. SIAM Journal on Computing, 40(4):1075–1100, 2011. doi:10.1137/100785429.
  • [52] Elena Grigorescu, Kyomin Jung, and Ronitt Rubinfeld. A local decision test for sparse polynomials. Inf. Process. Lett., 110(20):898–901, 2010. doi:10.1016/j.ipl.2010.07.012.
  • [53] Shirley Halevy and Eyal Kushilevitz. Distribution-free property-testing. SIAM Journal on Computing, 37(4):1107–1138, 2007. doi:10.1137/050645804.
  • [54] Johan Håstad and Avi Wigderson. The randomized communication complexity of set disjointness. Theory of Computing, 3(1):211–219, 2007. doi:10.4086/toc.2007.v003a011.
  • [55] Roger A. Horn and Charles R. Johnson. Topics in matrix analysis. Cambridge University Press, 1991. doi:10.1017/CBO9780511840371.
  • [56] Roger A. Horn and Charles R. Johnson. Matrix Analysis, 2nd Ed. Cambridge University Press, 2012. doi:10.1017/CBO9781139020411.
  • [57] Charanjit S Jutla, Anindya C Patthak, Atri Rudra, and David Zuckerman. Testing low-degree polynomials over prime fields. Random Structures & Algorithms, 35(2):163–193, 2009. doi:10.1002/rsa.20262.
  • [58] Tali Kaufman and Dana Ron. Testing polynomials over general fields. SIAM Journal on Computing, 36(3):779–802, 2006. doi:10.1137/S0097539704445615.
  • [59] Pravesh Kothari, Amir Nayyeri, Ryan O’Donnell, and Chenggang Wu. Testing surface area. In Chandra Chekuri, editor, Proceedings of the Twenty-Fifth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2014, Portland, Oregon, USA, January 5-7, 2014, pages 1204–1214. SIAM, SIAM, 2014. doi:10.1137/1.9781611973402.89.
  • [60] Marek Kuczma. An Introduction to the Theory of Functional Equations and Inequalities. Birkhäuser Basel, 2009.
  • [61] Kevin Matulef, Ryan O’Donnell, Ronitt Rubinfeld, and Rocco A Servedio. Testing halfspaces. SIAM Journal on Computing, 39(5):2004–2047, 2010. doi:10.1137/070707890.
  • [62] Kevin Matulef, Ryan O’Donnell, Ronitt Rubinfeld, and Rocco Servedio. Testing (subclasses of) halfspaces. In Property testing: current research and surveys, pages 334–340. Springer, 2010. doi:10.1007/978-3-642-16367-8_27.
  • [63] Kevin Matulef, Ryan O’Donnell, Ronitt Rubinfeld, and Rocco A Servedio. Testing±1-weight halfspace. In International Workshop on Approximation Algorithms for Combinatorial Optimization, pages 646–657. Springer, 2009. doi:10.1007/978-3-642-03685-9_48.
  • [64] Joe Neeman. Testing surface area with arbitrary accuracy. In David B. Shmoys, editor, Symposium on Theory of Computing, STOC 2014, New York, NY, USA, May 31 - June 03, 2014, pages 393–397. ACM, 2014. doi:10.1145/2591796.2591807.
  • [65] Michal Parnas, Dana Ron, and Ronitt Rubinfeld. Tolerant property testing and distance approximation. Journal of Computer and System Sciences, 72(6):1012–1042, 2006. doi:10.1016/j.jcss.2006.03.002.
  • [66] Michal Parnas, Dana Ron, and Alex Samorodnitsky. Testing basic boolean formulae. SIAM Journal on Discrete Mathematics, 16(1):20–46, 2002. doi:10.1137/S0895480101407444.
  • [67] Ran Raz and Shmuel Safra. A sub-constant error-probability low-degree test, and a sub-constant error-probability pcp characterization of np. In Proceedings of the twenty-ninth annual ACM symposium on Theory of computing, pages 475–484, 1997. doi:10.1145/258533.258641.
  • [68] Dana Ron. Algorithmic and analysis techniques in property testing. Found. Trends Theor. Comput. Sci., 2009. doi:10.1561/0400000029.
  • [69] Dana Ron et al. Property testing: A learning theory perspective. Foundations and Trends® in Machine Learning, 1(3):307–402, 2008. doi:10.1561/2200000004.
  • [70] Ronitt Rubinfeld and Madhu Sudan. Self-Testing Polynomial Functions Efficiently and Over Rational Domains. In Proceedings of the 3rd Annual ACM/SIGACT-SIAM Symposium on Discrete Algorithms (SODA), pages 23–32, 1992. URL: http://dl.acm.org/citation.cfm?id=139404.139410.
  • [71] Ronitt Rubinfeld and Madhu Sudan. Robust Characterizations of Polynomials with Applications to Program Testing. SIAM Journal on Computing, 25(2):252–271, 1996. doi:10.1137/S0097539793255151.
  • [72] Mert Sağlam. Near Log-Convexity of Measured Heat in (Discrete) Time and Consequences. In Mikkel Thorup, editor, 59th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2018, Paris, France, October 7-9, 2018, pages 967–978. IEEE Computer Society, 2018. doi:10.1109/FOCS.2018.00095.
  • [73] Alex Samorodnitsky. Low-degree tests at large distances. In Proceedings of the thirty-ninth annual ACM symposium on Theory of computing, pages 506–515, 2007. doi:10.1145/1250790.1250864.