Testing Sparse Functions over the Reals
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) -linearity, (ii) -sparse, low-degree polynomials, and (iii) -juntas.
In this setting, given approximate query access to some , 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 -metric, under the assumption that we are drawing samples from the Standard Gaussian distribution. We present efficient testers and lower bounds for testing each of these three properties.
Keywords and phrases:
Property testing, sparsity, linearity, low-degree polynomials, juntas, computation over realsCategory:
Track A: Algorithms, Complexity and GamesFunding:
Vipul Arora: This work was done in part while the author was visiting the Simons Institute for the Theory of Computing.Copyright and License:
2012 ACM Subject Classification:
Theory of computation Streaming, sublinear and near linear time algorithmsEditors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele PuppisSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
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 over an underlying domain, which we can query at a small number of points in order to verify a property of the function in an approximate sense. For example, consider the problem of linearity testing of functions , where is a finite field. We are given access to a query oracle for ; i.e., on input , the oracle returns . The goal is to distinguish with high probability between two cases, viz. (i) is a linear function, or (ii) 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 is linear (or generally, a homomorphism of abelian groups) or -far from linearity, with the notion of -farness of from a function class defined as: , i.e., for any function that satisfies property , disagrees with on at least an -fraction of the inputs (uniformly drawn from ). In the context of linearity testing, is the class of linear functions/homomorphisms (the -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 ) 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 , and our goal is to distinguish whether (i) satisfies some property , or (ii) 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 , and we say is -far from if the following holds111The notion of -distance is more appropriate for real-valued functions, rather than the commonly used Hamming () distance, especially in the approximate query setting which we define later. For example, consider the case if for some , then , whereas . : .
Studying function testing over the reals often requires new techniques compared to testing on finite domains. A common reference distribution on is the standard -dimensional Gaussian distribution , which is approximately a uniform distribution on an -sphere of radius . And the notion of exact queries (oracle giving ) 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 -juntas [32] etc.
Interestingly, these works mostly focus on the setting when is Boolean valued, i.e., . The setting where the range of 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 -distances. In [16], functions over the hypercube, i.e., are studied for monotonicity. Recently, [39, 40] studied testing of monotonicity of Lipschitz functions .
[44] studied the problem of linearity testing for real-valued real-domain functions in full generality, i.e., for functions . 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 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 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 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 can give the exact value of 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 , outputs such that , for some small parameter , 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 . can also be thought of the noise reliability threshold of a channel communicating reals, i.e., if some information is transmitted on a channel with a reliability threshold of , then the received observable satisfies . When , this is the exact query model.
All our testers in this work are analyzed in the approximate query model for . 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 also hold for any -approximate query model for .
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 , and when is -far from . This is in contrast with one-sided error testers, which always decide correctly when , and can only err when 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: -linear, -sparse low-degree polynomials, and -juntas. Our testers for -linearity, and -sparse low-degree polynomials have two-sided error, whereas our -junta tester has one-sided error. Our testers for -linear functions and -juntas are adaptive, while our tester for -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 , and depends only on the sparsity parameter and the proximity parameter (as well as the total degree in the -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 ball (centered at the origin ) of suitable radius (typically ), i.e., for every , for some fixed constant (so in ) 222This boundedness notion corresponds to the bounds we get for low-degree polynomials over compact domains, e.g., if is a polynomial in , then for any , for all .. Note that testing only via bounded queries is impossible without such an assumption. For example, consider an arbitrary “good” function (-linear, -sparse polynomial, or a -junta), and choose a suitably small region at random (e.g. by choosing uniformly from and setting to be a small radius ball around ), where for any under the Gaussian measure on . Further, subdivide equally into and , and for some , define a function which is identical to outside ; while for , for . As can be arbitrarily large, can be moved arbitrarily far from the required property (in distance over the Gaussian measure). However, since is arbitrarily small, no algorithm using bounded queries can distinguish between and .
Choice of Reference Distribution.
In this work (for -linear, and -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 as representative of such a distribution, but we can also take for any continuous, log-concave distribution on . A probabilistic upper bound for the Hankel matrix eigenvalues, which we use in the analysis of the -sparsity tester, also assumes the isotropic Gaussian distribution (Theorem 2.12).
2 Our results
We focus on testing (i) -linearity, (ii) -sparse, low-degree polynomials, and (iii) -juntas, and assume that our reference distribution is , unless otherwise stated.
2.1 Testing -linear functions
Definition 2.1 (-linearity).
Let , and . is -linear if there exists a set , and there exist coefficients , such that, .
This problem has been extensively studied over finite domains with exact query access. [43] designed the first tester for -linearity with query complexity by studying the related problem of testing -juntas. Later, [18] improved the bound for testing -juntas to queries. Using the BLR test [24], along with this result gives a tester for -linearity with 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 non-adaptive, and adaptive queries are necessary for testing -linearity. These were first improved by [49], to non-adaptive, and adaptive query lower bounds. This was further improved by [19, 20] who proved adaptive query lower bound. Interestingly, the 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 be a function bounded on the ball , given via an -approximate query oracle. Let , and be parameters such that , where denotes the standard basis vector. There exists an -query tester (Algorithm 1) that distinguishes whether is -linear, or is -far from all -linear functions, with probability at least .
Remark 2.3.
Note the necessity of sufficiently good machine precision (small ) to successfully test -linearity. This is inevitable because if a linear function has “large” coefficients (), and a small coefficient (say ), we cannot distinguish (up to distance ) between and the -linear function using -approximate queries and Algorithm 1. The tester (specifically, Algorithm 2) uses the absolute difference between function values, which will be at most . Similar restrictions apply to testing -sparse polynomials, and -juntas.
In another sense, a qualitative dependence of on the function structure is inevitable. Otherwise, if given an -approximate oracle to , (which can be computed in time given , assuming a variable-length binary floating-point representation) would be an -approximate oracle to . But such a scaling would not help with our results, since the coefficients of , the non-zero influences, etc. would be similarly scaled-down.
2.2 Testing -sparse low degree polynomials
Definition 2.4 (-sparsity).
Let , and be a parameter. A monomial , for any , and has total degree . A polynomial , with and , , of total degree , is said to be a -sparse polynomial if .
Grigorescu et al. [52] solved this problem for polynomials on finite fields, i.e., , for large enough , using the machinery of Hankel matrices associated with polynomials:
Definition 2.5 (Hankel Matrix for polynomials [52, 11]).
Consider any , and define . For a function and , define the -dimensional Hankel matrix associated with at to be the following:
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 be an exactly -sparse polynomial over the reals, i.e., , where , and are the monomials of . Then for all ,
is a non-zero polynomial of degree , while , .
From Ben-Or and Tiwari [11]’s Observation 2.6, Grigorescu et al. [52] designed a tester with a query complexity of (independent of ), assuming to be an individual-degree- polynomial (note that all functions are polynomials of individual degree ).
Note that if we have exact query access to , the Hankel matrix can be computed using only queries to for any point . For the problem of testing a polynomial 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 , 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 , for polynomials over with total degree , which we will use in our work. Thus, we restrict our attention to polynomials of total degree at most .
Theorem 2.7 (Informal, see Theorem 6.1).
Let , be parameters such that , and be bounded in , given via an -approximate query access. Then there exists an -query tester (Algorithm 4), that distinguishes whether is a -sparse, degree- polynomial, or is -far from all such polynomials, with probability .
Remark 2.8.
We note that Test--Sparse (Algorithm 4) also works for testing -linear functions (by setting the degree ). However, we make the following remarks:
-
(i)
The query complexity of Test--Sparse (), invoked for -linearity testing, would be , which is worse than that of Test--Linear.
-
(ii)
The restriction on the approximation parameter is for Test--Sparse, as compared to for Test--Linear. Thus, for a wider range of parameters when is not too small, invoking Test--Linear is better, compared to Test--Sparse.
-
(iii)
Test--Linear is an adaptive tester, while Test--Sparse is non-adaptive.
2.3 Testing -juntas
Definition 2.9 (-junta).
Let , and be a parameter. A variable , , is influential with respect to , if for some , changing changes . is a -junta, if there are at most influential variables with respect to .
Testing whether a Boolean function is a -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 -query tester. Later, [33] extended it to the finite range setting. [17] then gave an -query non-adaptive tester for this problem, while for adaptive testers, [18] showed queries suffice. It is important to note that all these results use Fourier-analytic techniques. Notably, [22] designed a new algorithm for testing -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 -juntas. Recently [32] studied the linear -junta testing problem, where the function is defined as 333A function is said to be a linear k-junta if there are unit vectors and such that .. 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 queries for non-adaptive testers, which was improved to by [30]. For adaptive testers, [31] showed an lower bound, which was then improved to by [72].
Theorem 2.10 (Informal, see Theorem 7.1).
Let , and be such that , and be bounded in , given via -approximate queries. There exists a one-sided error, -query tester (Algorithm 6), that distinguishes if is a -junta, or is -far from all -juntas, with probability at least .
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 (-linearity, -sparse degree- polynomials, and -juntas), we prove lower bounds of queries. Additionally, for -sparse, degree- polynomials, we prove a lower bound of 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 , some and a distance parameter , queries are necessary for testing (i) -linear functions, (ii) -sparse degree- polynomials, and (iii) -juntas, with success probability at least .
The lower bound for testing -sparse degree- polynomials is improved to .
2.5 New Technical Contributions
-sparsity Tester.
A critical ingredient in proving the -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 ).
Let , be a -sparse, degree- polynomial, where ’s are its non-zero monomials, and denotes the largest singular value of the -dimensional Hankel matrix associated with at a point , . Then, for any , with ,
Proof Sketch.
For any vector , let denote the vector with the absolute values of the coordinates of . Then, for any , using the triangle inequality, and a Vandermonde-like decomposition of , (from Observation 2.6), where , we can upper-bound by , where , is the Vandermonde matrix , and . By the Courant-Fischer characterization, we have
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 have total degree , we can upper bound
Chebyshev’s inequality and a union bound over the 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 moments of the distribution.
-linearity Tester.
For -linearity, our tester is similar to the algorithm proposed in [26] for testing -linearity of functions , 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 -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 -linearity by splitting the variables into 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 ( 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 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) -linearity, (ii) -sparse, low-degree polynomials, and (iii) -juntas, summarized in Table 1, open several interesting questions:
| Problem | Upper Bound | Restriction |
|---|---|---|
| -linearity | ||
| -sparsity | ||
| -junta |
-
We note that our results have constraints on the approximate query parameter . The first open question is whether these can be improved.
-
Furthermore, our -sparse degree- polynomial tester performs queries, and our lower bound for this problem is . The second open question is whether the gaps in these bounds (w.r.t. , and ) 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 such that (pointwise -close) which is a stronger constraint compared to the expected -distance that we use between functions.
-
We have focused on optimizing the query complexity in terms of the sparsity parameter and degree (for low-degree polynomial testing). It is an interesting problem to optimize the dependence of in our arguments.
-
Only our -junta tester has a one-sided error profile, while our -linearity/sparsity testers have two-sided errors. Designing one-sided error testers for these problems is left open.
-
Finally, we use 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 -linearity tester, followed by our tester for -sparse low-degree polynomials in Section 6, and our -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- [6, Algorithm 8], ApproxLowDegreeTester [6, Algorithm 9], ApproxCharacterizationTest [6, Algorithm 10], ApproxQuery- [6, Algorithm 10] and ApproxQuery--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 is -linear, we construct a function such that if is -linear, then will also be -linear. Moreover, we simulate queries to using queries to , and test this newly constructed function .
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 on a set of points sampled from to construct the self-corrected function . To deal with the fact that different points from have different probability masses, the idea is to radially project the sampled points from into a small Euclidean ball of a small (constant) radius ( 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 :
so that . This definition of self-correction function was used in [44, 5, 7].
To test -linearity (Algorithm 1), we first test if is pointwise close to some additive (aka. linear) function using ApproximateAdditivityTester. If it rejects , we also reject . However, if ApproximateAdditivityTester does not reject, then the self-corrected function is pointwise close to some linear function. As we only have approximate oracle access to , we can’t simulate exactly. So, we use Approximate-, the approximate query oracle for . The work of [5, 7] proves: (i) and Approximate- are pointwise close in , and (ii) and Approximate- are also pointwise close. So, is pointwise close to Approximate-.
We partition the -variables into buckets uniformly at random. So if is -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 ) is more than .
3.2 Testing -sparsity
Our -sparse, degree- polynomial tester (Algorithm 4) adopts a similar approach. We first test if is a low-degree polynomial, using the ApproxLowDegreeTester from [5, 7]. If it rejects , we also reject . However, if ApproxLowDegreeTester does not reject , then is point-wise close to a low-degree polynomial.
As in -linearity testing, we use a self-corrected function from [5, 7]: For points , is the (weighted) median value of , weighted according to the probability of , i.e., Intuitively, is the value that should take if, when restricted to the line , would be a degree- univariate polynomial. Taking the weighted median over all directions , ensures that the self-correction proportionately respects the values of , in a local neighborhood of . For is defined via radial extrapolation from within along the radial line .
Given exact query access to , we can simulate query access to the self-corrected function . As we only have approximate query access to , we use ApproxQuery-g (the approximate oracle to the self-corrected function associated with ), which was proved to be pointwise close to . As a result, will be pointwise close to ApproxQuery-g as well.
Once we have that 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 (over finite fields) is -sparse, if and only if its associated Hankel matrix has a non-zero determinant. This can be efficiently tested with only queries to . 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 queries for deciding whether (i) is -sparse, or (ii) is not -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 , 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 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 is a -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 g which is -close to (on all the query points, whp), we can express (for ) of such a as the sum of 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 in all rounds.
To prove soundness, we need to show that in some round with probability , as long as is a non-zero polynomial. This follows (in Theorem 6.6) by invoking the probabilistic upper bound on , for .
3.3 Testing -juntas
Finally, we discuss our algorithm for testing -juntas (Algorithm 6). Our approach is to first randomly partition the -variables into buckets. If is a -junta, the influential variables will be separated into distinct buckets w.h.p (by birthday paradox).
Now we run 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 influential variables in , we reject it. Otherwise, we accept . Our analysis follows a combinatorial style similar to [22]. We would like to note that although we use for -linearity testing as well, the analysis here significantly deviates from that of -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 and normal face letters for variables. Specifically, denotes the standard unit vector. For , let denote the set . For a matrix , let , , and denote the supremum, operator, and Frobenious norms of , respectively. See [56] for the formal definitions. For concise expressions and readability, we use the asymptotic complexity notion of , where we hide poly-logarithmic dependencies of the parameters. For any , let denote the infimum(resp. supremum) value of over some . Let be the class of functions satisfying some particular first-order property and let .
Definition 4.1 (-distance).
Let is family of distributions with being a distribution on . For two arbitrary functions , the -distance between and is defined as: . We also define the -distance of to the class , and hence the class , by .
We have if and only if there exists a function which agrees with almost everywhere with respect to (in the measure-theoretic sense). We will only concern ourselves with since we are dealing with scalar-valued functions (aka functionals) and hence for all .
Our definitions hold for general reference distributions which are suitably concentrated. Later, we work with , which also has this desired concentration property.
Definition 4.2 (Concentrated distribution).
Let , and . A distribution supported on is -concentrated if most of its mass is contained in a ball of radius centered at some point , i.e., .
For brevity, we may write “ is -concentrated” to mean “ is -concentrated”.
Fact 4.3 ([23, Theorem 2.9]).
is -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 , where are both symmetric matrices. Let denote the eigenvalue of (symmetric matrix) , sorted in non-increasing order, and let denote its -operator (spectral) norm. Then,
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 -linearity tester.
Theorem 4.5 ([27, Theorem 8]).
Let be a polynomial of degree , such that . Then and , .
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 is a polynomial of degree , then there exists an absolute constant such that for any and ,
5 -linearity Testing
In this section, we present and analyze our algorithm Test--Linear (Algorithm 1).
Theorem 5.1 (Generalization of Theorem 2.2).
Let , is a function bounded in the ball , and be such that , where denotes the standard unit vector. Given -approximate query access to , there exists a tester Test--Linear (Algorithm 1) that, in queries, guarantees:
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 is additive, if for all , , where and denote the bitwise-xor operations in and , 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-. 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 , for , suppose is a function that is bounded in the ball and be an unknown -concentrated distribution. There exists a one-sided error, -query tester (ApproximateAdditivityTester) which with probability at least , distinguishes when is pointwise -close to some additive function and when, for every additive function , .
Lemma 5.5 ([5, Lemma D.3 and D.6]).
If TestAdditivity accepts with probability at least , then is a -additive function inside the small ball , and furthermore, for every it holds that
Lemma 5.6 ([5, Lemma D.4 and D.5]).
If TestAdditivity() accepts with probability at least , then for every with , it holds that
The following lemma gives us a way to scale the closeness for degree- polynomials.
Lemma 5.7 ([5, Lemma 4.19]).
Let be any real numbers. If is pointwise -close to a degree- polynomial in , then is pointwise -close to a degree- polynomial on all points in .
Using Lemma 5.5, Lemma 5.7 and the structure of Approximate- subroutine, they bound the distance between and Approximate-.
Claim 5.8.
If TestAdditivity accepts with probability at least , then Approximate- is pointwise -close to , in the ball w.h.p.; i.e.,
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 with probability at least , then following the description of ApproximateAdditivityTester, we have
We will invoke them with , implying (from Fact 4.3).
5.1 Analyses of Subroutines
The subroutine is presented in Algorithm 2.
To analyze it, we need:
Definition 5.10 (Influential bucket for linear functions).
For a function , a bucket is said to be an influential bucket if there exists at least one variable , which is influential with respect to (i.e., changes with a change in ). For a linear , with , is influential w.r.t if and only if , and hence is an influential bucket iff for some .
Claim 5.11 (Correctness of ).
Let , with be given via an -approximate query , where , be a partition of , and . Then (Algorithm 2) guarantees:
-
1.
If none of the buckets are influential, always returns and performs exactly queries to .
-
2.
Otherwise, with probability at least , returns for some which is an influential bucket, and performs queries to .
Next we describe and analyze the subroutine (Algorithm 3).
Claim 5.12 (Correctness of ).
Let , with , be given via the -approximate query oracle , where , and . Then (Algorithm 3), in at most queries, guarantees:
-
(i)
If is -linear function for some , then Algorithm 3 will return a set of influential buckets in with probability at least .
-
(ii)
If is -linear function for some , then Algorithm 3 will return the set of all influential buckets in with probability at least .
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 is a -linear function, following Theorem 5.4, we have: ApproximateAdditivityTester accepts , and hence by Lemma 5.6, is pointwise -close to linearity in . Combined with Lemma 5.7, we get is pointwise -close to linearity in . From Claim 5.8, we know that and Approximate- are pointwise -close in with probability at least . Using the triangle inequality, this implies that Approximate- is pointwise -close to some linear function with probability . Moreover, from Observation 5.9, we get: Approximate- is in fact pointwise -close to , with probability at least . With , following the guarantee of Claim 5.12, ensured by our assumption on :
we get that g will return at most -influential variables of with probability at least . Thus with probability at least , Test--Linear will Accept.
Soundness.
Let be -far from -linearity. We will prove the contrapositive. We will show that if Test--Linear does not reject with probability at least , then is pointwise close to some -linear function, with non-zero probability.
Note that if ApproximateAdditivityTester rejects with probability , 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 is pointwise -close to linearity in with probability at least , and from Claim 5.8, we have that and Approximate- are pointwise -close in with probability at least . This implies that Approximate- is pointwise -close to some linear function with probability at least . Again, from Observation 5.9, we get: Approximate- is pointwise -close to , with probability at least , implying now must be pointwise -close to linearity, with probability at least . Note, here , and .
With our assumption on again ensuring the conditions for Claim 5.12 are met, i.e.,
we get g will return at most -influential variables of with probability at least .
Since Test--Linear accepts with probability , this implies that the total number of influential variables returned by is at most , with probability . Combining the above, we conclude that is pointwise -close to a -linear function, with probability at least . This concludes the proof.
Query complexity.
From Theorem 5.4, we have: ApproximateAdditivityTester performs queries. From Claim 5.12, we have: performs queries. Combining them, we have: Test--Linear performs 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 . Given -approximate query access to that is bounded in , there exists a tester Test--Sparse (Algorithm 4) that performs queries and guarantees:
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- and ApproxQuery--InBall) from [5] and (its improvement in) [7]:
Theorem 6.2 ([7, Theorem 3.6]).
Let , for , be bounded in the ball , and for , let be an -concentrated distribution. For , given -approximate query access to , and sampling access to , there is an one-sided error, -query ApproxLowDegreeTester which, distinguishes between the case when is pointwise -close to some degree- polynomial and the case when, for every degree- polynomial , .
Lemma 6.3 ([5, Lemma 4.4]).
Let , , and . If ApproxCharacterizationTest fails with probability at most , then is pointwise -close to a degree- polynomial in . Furthermore, , ApproxQuery-() well approximates w.h.p., i.e.,
To invoke these results, we assume: (i) is bounded in , i.e., we set , and (ii) . Additionally, since we work over standard Gaussians, we set .
Testing sparsity of polynomials given exact query access.
As a preliminary, we design an algorithm for testing sparsity of polynomial functions , 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 is -sparse.
Lemma 6.4.
Let be a polynomial function (of any degree). Given exact query access to , there is an algorithm that makes queries to , and exactly tests whether (returns Accept), or (returns Reject) with error probability .
6.1 Testing sparsity of polynomials given approximate query access
Now, instead of exact query access, we have -approximate query to a polynomial , which guarantees for all points , giving us:
Observation 6.5.
Let and let be an -approximate query oracle to . Then for any and , we can express , where is a Hankel-structured noise matrix, s.t. , and .
We now present and analyze the correctness of Algorithm 5, using Theorem 2.12:
Theorem 6.6 (Sparsity testing with approximate queries).
Given -approximate query access to a polynomial of total degree , assuming , wherein , and is as in Theorem 4.6, Approx-Poly-Sparsity-Test (Algorithm 5), in queries, guarantees:
-
(i)
If has sparsity at most , the algorithm always Accepts, and
-
(ii)
If has sparsity , the algorithm Rejects with probability at least .
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 is a -sparse, degree- polynomial, from Theorem 6.2, we have: Approx-Low-Degree-Tester always accepts , and hence, from Lemma 6.3, we have that is pointwise -close to a degree- polynomial, say , in . Moreover,
| (1) |
By setting , the conditions of Theorem 6.6 are met, giving us that Approx-Poly-Sparsity-Test(ApproxQuery-) (Algorithm 5) will Accept with probability . So with probability at least , Test--Sparse (Algorithm 4) will accept .
Soundness.
Let be -far from all -sparse, degree- polynomials. We will show that if Algorithm 4 accepts with probability at least , then must be -close to some -sparse, degree- polynomial. From the premise, Approx-Low-Degree-Tester also accepts with probability at least . Then, as in completeness, from Lemma 6.3, we have: is pointwise -close to some degree- polynomial, say , i.e., for all , , and (1) still holds.
From the premise, Approx-Poly-Sparsity-Test(ApproxQuery-g) (Algorithm 5) does not reject with probability . In this case, as long as the closeness of ApproxQuery-g and satisfies the assumption in Theorem 6.6, will be -sparse. The assumption is:
| (2) |
where , , and may be bounded using Theorem 2.12 (with ), i.e.,
So, with probability at least , . Plugging these into (2), we observe, setting satisfies it, implying that is -close to some -sparse, degree- polynomial.
Query complexity.
The query complexity of Algorithm 4 consists of two parts:
-
query complexity of ApproxLowDegreeTester which is (from Theorem 6.2), and
-
the query complexity of Approx-Poly-Sparsity-Test (Algorithm 5) which is at most (from Theorem 6.6).
Combining the above, we have: Algorithm 4 performs queries in total.
7 -Junta Testing
In this section, we present and analyze our -junta tester.
Theorem 7.1 (Generalization of Theorem 2.10).
Let , . Given -approximate query access to an unknown function that is bounded in , there exists a one-sided error tester Test--Junta (Algorithm 6) that performs queries and guarantees:
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 be a function. For any set , the influence of over with respect to a distribution over is defined as follows:
We first prove a structural result. Let denote the set of all -juntas on variables.
Theorem 7.3.
If , then , with , .
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 , and any ,
Next we show, if is far from being a -junta, the influence of in Algorithm 6 (i.e. all buckets not yet identified as influential) is high, unless we identify more than parts.
Lemma 7.5.
Let and be a random partition of , for . If , with probability over the randomness of the partition, we have for any which is a union of at most parts of .
7.1 Proof of correctness of Test--Junta
As Algorithm 6 invokes Algorithm 2, we first prove its correctness for juntas.
Definition 7.6 (Influential variables and buckets).
Let , and . A variable is influential with respect to , if for some , only changing changes the value of . A bucket 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 , . By Fact 4.3, we have . Let
We use (Algorithm 2) for testing -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 be given via the -approximate query , where , be a partition of , and . With , we have:
-
1.
If none of the ’s are influential, always returns and performs exactly queries to .
-
2.
Otherwise, with probability at least , returns for some which is -influential and performs queries to .
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 is a -junta, at most of the buckets in the random partition will be influential. From Claim 7.7, we get that each execution of the loop increments 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, is incremented at most times, falsifying the check in line 6, making Accept.
Soundness.
Here our goal is to prove if is -far from all -juntas, then Algorithm 6 rejects it with probability . In particular, if is -far from being -junta, and is the union of at most -parts of , then Line 7 of Algorithm 6 will be satisfied w.h.p.
By Lemma 7.5, we have: if , ( in the execution of Algorithm 6). During the execution, when exactly influential buckets have been identified, , , and thus, by Lemma 7.4, there must exist a bucket such that . This bucket will then be output by . So, until influential buckets have been identified, each invocation of in an execution of its loop, returns an influential bucket with probability . Treating the outcome of each invocation as a geometric random variable, we conclude: to recover at least such buckets with probability ,
iterations of loop suffice. When , in line 6, algorithm rejects with same probability.
Query Complexity.
From Claim 7.7, we know: each invocation of performs queries to . With such invocations in total, and , the overall query complexity thus is .
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 -linearity.
queries for linearity.
For any , it is a folklore result that distinguishing if a function is linear, or -far from being linear in -distance, requires queries [42].
queries for degree- polynomial testing.
It is another folklore result that given a proximity parameter , queries are necessary to distinguish if an unknown function is a degree- polynomial, or a degree- (or ) polynomial (and hence, is -far from all degree- polynomials) with probability at least .
To prove the query lower bound for -linearity, we use a reduction from Set-Disjointness which is known to require communication complexity [54].
Connection between Communication and Query complexity.
Consider two functions and , a property , , and a communication problem : Alice and Bob receive and , respectively, and they want to decide if , or is -far from . [19] (Lemma 2.2) proved that , the randomized communication complexity of , the query complexity of deciding the property .
Construction of the hard instances.
Given , Alice constructs a polynomial . Similarly Bob, given , constructs a polynomial . Note that . Let . If , would be a linear function, whereas if , would be a -linear function.
Lemma 8.1.
Let be a -linear function, and be a -linear function with coefficients from . Under the standard Gaussian distribution , is -far from in -distance with probability at least .
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. L-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 Norm Inequalities for Polynomials over Convex Bodies in . 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 . 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. Testing1-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.
