Abstract 1 Introduction 2 Technical overview 3 Preliminaries for relative-error testing over 𝑵(𝟎,𝟏)𝒏 4 Testing with known volume via Gaussian surface area:
XXx..Proof of Theorem 2
References

Sublinear-Query Relative-Error Testing of Halfspaces

Xi Chen ORCID Columbia University, New York, NY, USA    Anindya De ORCID University of Pennsylvania, Philadelphia, PA, USA    Yizhi Huang ORCID Columbia University, New York, NY, USA    Shivam Nadimpalli ORCID MIT, Cambridge, MA, USA    Rocco A. Servedio ORCID Columbia University, New York, NY, USA    Tianqi Yang ORCID Columbia University, New York, NY, USA
Abstract

The relative-error property testing model was introduced in [11] to facilitate the study of property testing for “sparse” Boolean-valued functions, i.e. ones for which only a small fraction of all input assignments satisfy the function. In this framework, the distance from the unknown target function f that is being tested to a function g is defined as Vol(fg)/Vol(f), where the numerator is the fraction of inputs on which f and g disagree and the denominator is the fraction of inputs that satisfy f.

Recent work [12] has shown that over the Boolean domain {0,1}n, any relative-error testing algorithm for the fundamental class of halfspaces (i.e. linear threshold functions) must make Ω(logn) oracle calls. In this paper we complement the [12] lower bound by showing that halfspaces can be relative-error tested over n under the standard N(0,In) Gaussian distribution using a sublinear number of oracle calls – in particular, substantially fewer than would be required for learning. Our results use a wide range of tools including Hermite analysis, Gaussian isoperimetric inequalities, and geometric results on noise sensitivity and surface area.

Keywords and phrases:
Property testing, relative-error testing, halfspaces, Gaussian space
Category:
Track A: Algorithms, Complexity and Games
Funding:
Xi Chen: NSF grants CCF-2106429 and CCF-2107187.
Anindya De: NSF grant CCF 2045128.
Yizhi Huang: NSF grants CCF-2211238, CCF-2312242, CCF-2106429, and CCF-2238221.
Rocco A. Servedio: NSF grants CCF-2211238 and CCF-2106429.
Tianqi Yang: NSF grants CCF-2211238, CCF-2106429, CCF-2312242, and AF-Medium 2212136.
Copyright and License:
[Uncaptioned image] © Xi Chen, Anindya De, Yizhi Huang, Shivam Naidmpalli, Rocco A. Servedio, and
Tianqi Yang; 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: https://arxiv.org/abs/2604.01557
Funding:
This work was awarded a grant by the AI Security Institute (AISI) via the Alignment Project (“Discovering rare harmful behaviors exhibited by high-dimensional AI systems”). This work is also funded by OpenAI. T.Y. and Y.H. are also supported by an Amazon Research Award and a Google CyberNYC award.
Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele Puppis

1 Introduction

Over the past three decades Boolean function property testing has become a well-established research topic in theoretical computer science, see e.g. the books and monographs [45, 29, 3]. In this paper we consider an extension of the standard model of property testing, known as relative-error testing, which was recently proposed in [11].

To describe the relative-error model, we first recall that in the standard model of Boolean function property testing the goal is to distinguish between the two cases that (i) f𝒞, where 𝒞 is the class of functions that have the property that is being tested, versus (ii) f is ε-far (under the uniform distribution) from every function in 𝒞, meaning that

𝖽𝗂𝗌𝗍(f,𝒞)ε, where 𝖽𝗂𝗌𝗍(f,𝒞):=ming𝒞𝖽𝗂𝗌𝗍(f,g) and 𝖽𝗂𝗌𝗍(f,g):=𝐏𝐫𝒙{0,1}n[f(𝒙)g(𝒙)].

A testing algorithm in the standard model can obtain information about the unknown function f:{0,1}n{0,1} that is being tested by making black-box oracle calls to f.

The impetus for the study of relative-error testing is that the standard model described above is poorly suited for testing sparse functions, i.e. functions which have few satisfying assignments. This is because any such function has very small uniform-distribution distance to the constant-0 function, and so the tester can simply ignore the input function f and answer according to the constant-0 function. Indeed, for sparse functions it is arguably more natural to ask whether f is “close” to having the property of interest (i.e. close to belonging to 𝒞) for a notion of closeness that is relative to the small size of f1(1) rather than to the “absolute” scale of all 2n possible inputs.

With this motivation, the relative-error property testing model which was defined in [11] changes the standard model in the following ways:

  • The distance between the target function f and a function g is now measured using relative distance, which is the uniform-distribution distance defined above scaled by the sparsity of f:

    𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(f,g):=𝐏𝐫𝒙{0,1}n[f(𝒙)g(𝒙)]𝐏𝐫𝒙{0,1}n[f(𝒙)=1],i.e.𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(f,g)=𝖽𝗂𝗌𝗍(f,g)𝐏𝐫𝒙{0,1}n[f(𝒙)=1].

    Relative distance thus captures the distance between f and g at the scale of f, and continues to be meaningful even if f is very sparse.111It is easy to verify, as observed in [11], that while 𝗋𝖾𝗅-𝖽𝗂𝗌𝗍 is not perfectly symmetric, if 𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(f,g)=ε1/2 then 𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(g,f) is also Θ(ε), so 𝗋𝖾𝗅-𝖽𝗂𝗌𝗍 is symmetric up to constant factors in the setting we are interested in.

  • In addition to the usual black-box oracle for f, a relative-error testing algorithm can also access a random sample oracle SAMP(f), which takes no input and returns a uniform random satisfying assignment 𝒙f1(1). (Note that without a SAMP(f) oracle, many black-box queries to f could be required even to find a single satisfying assignment of f.)

After the introduction of the relative-error testing model in [11], the relative-error testability of a number of well-studied properties (or classes of functions) was investigated in a number of papers [14, 15, 12, 9, 10]. Before turning to the specific results in those papers, we first give a quick overview of the general relationship between standard-model testability and relative-error testability.

Standard-model versus relative-error testability.

As shown already in [11], standard-model testing is never more difficult than relative-error testing: for any class 𝒞, if 𝒞 is relative-error testable to error ε using q oracle calls then 𝒞 is also standard-model testable to error ε using O(q/ε) oracle calls. (We remark that [14] gave a slight sharpening of this result under mild assumptions about the class 𝒞.) On the other hand, [11] showed, by considering a contrived class of functions, that relative-error testing can sometimes be much more difficult (require many more queries) than standard-model testing. This artificial class of functions leaves open the following natural question: for “natural” classes of functions that are commonly studied in computational learning theory and concrete complexity, how does the query complexity of testing in the standard model compare to the relative-error model?

Relative-error testability of well-studied properties.

The above question has been the subject of a significant amount of recent research [11, 14, 15, 12, 9, 10]. Most of these results suggest that – unlike the contrived example of [11] alluded to above – relative-error testing often turns out to be essentially no more (or at least not much more) difficult than standard-model testing for “natural” classes of functions 𝒞. In particular, the papers [11, 14, 15, 9, 10] show that for the classes of monotone Boolean functions; unate Boolean functions; conjunctions; decision lists; k-juntas; subclasses of k-juntas such as size-k decision trees and size-k branching programs; and s-term DNF formulas, the query complexity of relative-error testing is at most some fixed polynomial in the query complexity of standard-model testing.

However, an intriguing exception was discovered in the very recent work of [12] on testing halfspaces, also known as linear threshold functions or LTFs.222Recall that an n-variable halfspace is a function of the form sign(wxθ), with some wn and θ. Halfspaces are one of the most intensively studied classes in computational learning theory, dating from the introduction of the Perceptron algorithm more than sixty years ago [5, 43] down through to the present day [33, 17, 24, 23, 8]. They have also been studied intensively both in property testing, see e.g. [28, 37, 36, 20, 21, 32, 13], and in other fields including probability theory and Boolean function analysis, see e.g. [38, 41, 39, 7, 18, 25]. In [37] halfspaces were shown to be testable in the standard model with poly(1/ε) queries independent of the ambient dimension n; in contrast, [12] gave an Ω~(logn) lower bound on the number of queries that are required in the relative error model.

Given the [12] lower bound, a natural goal – which is the focus of the current paper – is to gain a better understanding of the query complexity of testing halfspaces in the relative-error model. In particular, the main question driving our research is the following: can n-dimensional halfspaces be relative-error tested with a number of queries that is sublinear in n? As motivation for this specific question, we remark that (as is well known) in many learning models the problem of learning an unknown halfspace is known to require Θ(n) samples or queries. Since the complexity of learning is an upper bound on the complexity of testing (see [30]), it is natural to aim for o(n)-query testing algorithms, since this would show that testing is easier than learning, which is one of the central motifs and motivations for property testing of Boolean functions. We further remark that the sample and query complexity of testing halfspaces in the distribution-free model is known to be Θ~(n) [4, 13], which lends additional impetus to the question of understanding whether it is possible to achieve sublinear complexity in the relative-error testing model.

1.1 Our contributions: Sublinear relative-error testing of halfspaces

Before describing our main results, we give some more context on halfspace testing in the standard model. Halfspace testing has primarily been studied under two distributions, which correspond to discrete and continuous domains. These are the usual uniform distribution over {0,1}n [37, 36] and the standard N(0,In) Gaussian distribution over n [37, 41, 20, 21]. For N(0,In), the “standard-model” distance between f,g:n{±1} is simply

𝖽𝗂𝗌𝗍(f,g):=𝐏𝐫𝒙N(0,1)n[f(𝒙)g(𝒙)].

In the standard model [37] showed that halfspaces can be tested using only poly(1/ε) queries under both the uniform distribution over {0,1}n and the Gaussian N(0,In) distribution over n. The [37] result for {0,1}n essentially uses their result over the Gaussian space as a subroutine.333We remark that a very different tester for the Gaussian space than the [37] tester was given by Mossel and Neeman in [41]; these results will be discussed in more detail later. Thus, developing relative-error halfspace testing algorithms for the Gaussian distribution is a natural first step towards obtaining improved results for the uniform distribution over {0,1}n.

Towards this end, as the main results of this paper we provide three sublinear-query testing algorithms for halfspaces, all over the Gaussian space, where the relative distance between f and another function g, where f,g:n{0,1}, is defined (analogous to the Boolean setting) as

𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(f,g):=𝐏𝐫𝒙N(0,In)[f(𝒙)g(𝒙)]𝐏𝐫𝒙N(0,In)[f(𝒙)=1],i.e.𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(f,g)=𝖽𝗂𝗌𝗍(f,g)𝐏𝐫𝒙N(0,In)[f(𝒙)=1],

and in this setting a call to the random sample oracle SAMP(f) returns a draw from the Gaussian distribution conditioned on f1(1). (See Section 3 for a more detailed definition of the model.)

 Remark 1.

Before detailing our algorithmic results, we remark that by combining the poly(1/ε)-query testing algorithms of [37, 41] for halfspaces under the Gaussian N(0,In) distribution in the standard model and Fact 9 of [11], we easily obtain relative-error testing algorithms with query complexity poly(1/(εp)) when we are promised that the “Gaussian volume” 𝐏𝐫N(0,In)[f(𝐱)=1] of the function f being tested is at least p. (Intuitively, this is because achieving relative error ε for a “p-volume” function is the same as achieving standard error εp.) However, this is a very poor bound in the (most interesting) case when p is very small; in the results below, we achieve an exponential improvement by giving algorithms whose dependence on n is sublinear and whose dependence on p is only inverse poly-logarithmic.

Our results.

For our first two results, the algorithm is assumed to be given (an accurate estimate of) the “Gaussian volume” p:=𝐏𝐫N(0,1)n[f(𝒙)=1] of the unknown target function f, which we sometimes refer to as the volume of f and denote by Vol(f). In the third result, the algorithm is only given a lower bound pmin on Vol(f) rather than an accurate estimate. We first give informal statements of our three algorithms’ guarantees and provide detailed theorem statements later.

  1. 1.

    The first algorithm (see Theorem 2) uses poly(log(1/p),1/ε) samples and queries to do ε-relative-error testing. At a high level, similar to [41], the algorithm relies on the robust extremal isoperimetric properties of halfspaces over the Gaussian space. See Section 2.1 for a more detailed description of the ideas underlying this algorithm.

  2. 2.

    The second algorithm (see Theorem 3) uses O~(n)poly(log(1/p),1/ε) samples to do ε-relative-error testing. In contrast with the first one, this algorithm does not use any black-box queries to f, only random samples drawn from SAMP(f). The high-level idea behind this tester is that for halfspaces over the Gaussian space, the level-1 Hermite weight depends only on the bias of the function, and this relationship is robust enough to serve as the basis for a testing algorithm (Section 2.2 gives a more complete overview). We note that similar ideas were used in the original work of [37] for testing under the Gaussian distribution, as well as a number of other related works including [32] and [22].

  3. 3.

    The third algorithm (see Theorem 4) addresses the problem when p is unknown; it only requires a lower bound pmin on the value of p rather than an accurate estimate. It uses O(n)poly(log(1/pmin),1/ε) samples and queries to do ε-relative-error testing. The high level idea is to use the estimator from the proof of Theorem 3 to obtain an upper bound on p, in conjunction with a variant of Theorem 2 which only errs if it is given an estimate of p which is too low. See Section 2.3 for a more detailed overview of the main ideas underlying this algorithm.

Here are detailed statements of our algorithmic results:

Theorem 2 (Gaussian halfspace testing for known p).

There is an algorithm GSA-Test with the following property: If GSA-Test is given sample access SAMP(f) and black-box access MQ(f) to a measurable function f:n{0,1}, a parameter ε, and an estimate p^ of p:=Vol(f) satisfying

p1+ζp^(1+ζ)p,whereζ=c1ε2log2(1/p)

for a suitably small absolute constant c1>0, then it makes O(ε14log13(1/p)) calls to the oracles to test whether f is a halfspace or ε-far from any halfspace in relative distance.

Theorem 3 (Sample-based Gaussian halfspace testing for known p).

There is a sample-based algorithm Hermite-Test with the following property: If it is given sample access SAMP(f) to a measurable function f:n{0,1}, a parameter ε, and an estimate p^ of p:=Vol(f) satisfying

p1+ηp^(1+η)p,whereη=c2ε2log(1/p)

for some suitably small absolute constant c2>0, then Hermite-Test makes

max{Θ(nε2+log2(1/p)ε4),Θ~(nε7)}

calls to SAMP(f) to test whether f is a halfspace or ε-far from any halfspace in relative distance.

We remark that the requirement in Theorem 3 that Hermite-Test is given an estimate of p is inherent to any sample-based algorithm rather than a limitation of our arguments. In the full version we observe that any algorithm which uses only samples from SAMP(f) and is not given an estimate of p must draw Ω(n) samples, even if we are given a promise that p is either 1/2 or 1.

Theorem 4 (Gaussian halfspace testing for unknown p).

There is an algorithm Combined-Test with the following property: If it is given sample access SAMP(f) and black-box access MQ(f) to an unknown measurable function f:n{0,1}, which is guaranteed to satisfy p:=Vol(f)pmin, and a parameter ε, then it makes

Θ(nlog(1/pmin)ε2+log6(1/pmin)ε12)

calls to the oracles to test whether f is a halfspace or ε-far from any halfspace in relative distance.

2 Technical overview

2.1 Our algorithm for halfspace testing using queries and samples:
Overview of Theorem 2

To explain the main idea of Theorem 2, we start by recalling two fundamental notions in Gaussian analysis. For any set An, its Gaussian volume, denoted by Vol(A), is 𝐏𝐫𝒙N(0,In)[𝒙A]. Furthermore, if A is sufficiently smooth, we can also define its Gaussian surface area, denoted 𝗌𝗎𝗋𝖿(A), as xAφn(x)𝑑σ(x), where φn() denotes the standard n-dimensional Gaussian density; in other words, we integrate the standard Gaussian density over the surface of A. Given these notions of volume and surface area over the Gaussian space, one is naturally led to the “isoperimetric problem:” for a given (Gaussian) volume, what set minimizes the (Gaussian) surface area?

This question was answered by Borell [6] and Sudakov-Tsirelson [46], who showed that for any 0<p<1, for any measurable set An with Vol(A)=p, it always holds that 𝗌𝗎𝗋𝖿(A)𝗌𝗎𝗋𝖿(Hp) where Hp is a halfspace with Vol(Hp)=p. In other words, in the Gaussian space, for any given volume p, the halfspace with volume p has minimal surface area. Subsequently, Ehrhard [26] showed that halfspaces are the unique minimizers of the Gaussian surface area. In other words, if a set An has Vol(A)=p and 𝗌𝗎𝗋𝖿(A)=𝗌𝗎𝗋𝖿(Hp), then the set A is a halfspace.

One is now naturally led to the robustness question: Suppose a set A has Vol(A)=p and 𝗌𝗎𝗋𝖿(A) is δ-close to 𝗌𝗎𝗋𝖿(Hp). Then is it the case that A is δ-close to a halfspace, where δ0 as δ0? Cianchi et al. [16] were the first to affirmatively answer this question. Soon thereafter, in a significant breakthrough, Mossel and Neeman [40] obtained a “dimension free robust isoperimetry result”, i.e. one in which the dependence between δ and δ is independent of the ambient dimension n.

This result was quantitatively improved by Eldan [27] and then by Barchiesi et al. [2] (the latter result is the underlying technical ingredient we use in Theorem 2). A natural question at this point is “what is the connection between robust isoperimetry and testing halfspaces?”

The connection arises from a 2014 result of Neeman [42], who gave an algorithm for testing surface area over Gaussian space. The precise technical guarantee is somewhat cumbersome to state, but roughly speaking, the algorithm makes poly(S,1/ε)-queries to an unknown set A and (i) accepts with high probability if 𝗌𝗎𝗋𝖿(A)S, but (ii) rejects with high probability if 𝗌𝗎𝗋𝖿(B)>(1+ε)S for every set B which is ε-close to A444This perturbation of A is necessary because one can increase the surface area of a set arbitrarily by modifying on a measure zero set.. Now, observe that if an unknown set A of some given volume p is a halfspace, then its surface area is exactly given by φ(Φ1(p)) where Φ is the cdf and φ is the pdf of the standard Gaussian. So to test whether A is a halfspace, we can use Neeman’s algorithm to test whether its surface area is essentially that of a halfspace of volume p, and accept if and only if that is the case. Correctness of this simple algorithm is established using the dimension-free robust isoperimetry result of Barchiesi et al. [2] that was mentioned above.

2.2 Our algorithm for sample-based halfspace testing: Overview of Theorem 3

Our starting point for Theorem 3 is the work of Matulef, O’Donnell, Rubinfeld, and Servedio [37] which gives an algorithm (the “MORS algorithm”) that tests halfspaces over n using Oε(1) queries. The MORS algorithm relies on two structural ingredients:

  • First, there is a function U:[0,1] (see the full version) which, given as input the volume Vol(f) of a function f:n{0,1}, tells us exactly what the level-1 Hermite weight

    𝐖=1[f]:=i=1n𝐄𝒙N(0,In)[f(𝒙)𝒙i]2

    would be if the function f were the indicator function of a halfspace.

  • Second, if U(Vol(f))𝐖=1[f], then the set f is close to some halfspace.

The above facts suggest a natural algorithm: estimate Vol(f) and 𝐖=1[f], and then compare U(Vol(f)) to 𝐖=1[f]. (We remark that the MORS algorithm uses queries to do this.)

The algorithm Hermite-Test (see the full version) that yields Theorem 3 can be viewed as a relative-error, sample-based variant of the MORS algorithm. Our main technical lemma (see the full version) shows that if U(Vol(f)) is sufficiently close to 𝐖=1[f] in a suitable sense, then f is close under relative distance to some halfspace. In this sense, this lemma can be viewed as a relative-error strengthening of the second structural ingredient of the MORS algorithm above. With this lemma in hand, we apply a test which is similar in spirit to the MORS algorithm: estimate 𝐖=1[f] and see if it is (sufficiently) close to U(Vol(f)).

This leads to a second technical challenge: in order to get a sample-based algorithm we must accurately estimate 𝐖=1[f] using access to samples from SAMP(f) alone. (Note that the MORS algorithm relies on query access to the function f, and there are sample-based testers [1, 32] that rely on labeled samples from f as opposed to just positive samples from SAMP(f).) To accomplish this, we employ a recent estimator used in a different context by [22, 19] (for the problem of detecting distribution truncation) which is as follows: given a draw of 2m i.i.d. samples 𝒙(1),,𝒙(m),𝒚(1),,𝒚(m)SAMP(f), we compute the statistic

𝑻:=1m2ij𝒙(i)𝒚(j).

It is readily verified that 𝐄[𝑻]=Vol(f)2𝐖=1[f]; since Vol(f) is known, we can estimate 𝐖=1[f] if we can estimate 𝐄[𝑻]. To estimate 𝐄[𝑻], we must establish a bound on the variance of 𝑻; to do this, we employ (consequences of) hypercontractivity of the Gaussian measure (see Chapters 9 and 11 of [44]), drawing inspiration from recent work [19].

2.3 Our algorithm for halfspace testing when the volume is unknown: Overview of Theorem 4

We obtain the algorithm of Theorem 4, which does not need to have (an estimate of) the value of p, by combining the ideas underlying Theorem 2 and Theorem 3, as well as bringing in new ideas. In particular, a crucial structural property of LTFs which we use for Theorem 4 is the following: not only does the level-1 Hermite weight of an LTF f depend only on the bias of the function 𝐄[f] as mentioned earlier, but under the Gaussian distribution LTFs are in fact robustly extremal, among all {0,1}-valued functions, in terms of how their level-1 Hermite weight depends on on the bias of the function. In more detail, writing hp to denote a halfspace with Gaussian volume p, it is the case that any function f:n{0,1} with Gaussian volume p must satisfy

𝐖=1[f]𝐖=1[hp]. (1)

(As alluded to in the last paragraph of Section 2.2, the LHS of the inequality above is precisely Vol(f)2𝐄𝒙,𝒚f1(1)[𝒙𝒚].) Moreover the inequality can only be an equality if f is a halfspace, and it can only be close to an equality if f is close to a halfspace. Versions of this structural property are established, in varying degrees of explicitness, in Theorem 7 of [34], Theorem 26 of [37], and Theorem 3.3.4 of [31]; our result (see the full version) gives a version of this which is – crucially, for our purposes – quantitatively stronger than those earlier results in the small-p regime.

With this perspective, we can reinterpret the testing algorithm of Theorem 3 in the following light: if the algorithm were not given p, it could compute an estimate τ of 𝐄𝒙,𝒚f1(1)[𝒙𝒚] using draws from SAMP(f) and solve the equation

τ=𝐖=1[hp2](p2)2

for the value p2. If f were an LTF and the value of τ were precisely the value of 𝐄𝒙,𝒚f1(1)[𝒙𝒚], then this would give us the exact correct value p2=p. On the other hand, because of the extremal property (1) mentioned above, if f is far from every LTF then (up to a small factor due to estimation error) the value of p2 will be significantly larger than the true value p=Vol(f).

Now let us return to Theorem 2; the key for our analysis is that this result relies on a robust extremal property of LTFs that goes in the other direction. Recall that the Theorem 2 algorithm essentially works by estimating

𝐏𝐫𝒙f1(1),𝒚Nλ(𝒙)[f(𝒙)f(𝒚)],i.e.𝐏𝐫𝒙f1(1),𝒚Nλ(𝒙)[f(𝒚)=0]

(where “𝒚Nλ(𝒙)” means that 𝒚 is a λ-correlated random perturbation of 𝒙; see Section 4.2 for a formal definition), and checking whether it takes the “right value” that it should take for an 0/1-valued LTF with expectation p, which is 12pSensλ(LTFp)=Cλln(1/p). In the Theorem 2 algorithm we use a value of λ which depends on p, but for a fixed value of λ, the function 12pSensλ(LTFp) is a decreasing function of p; as we will see, this will be crucial for us.

Now, known isoperimetric properties of halfspaces can be shown to imply that if f is any {0,1}-valued function f with Vol(f)=p, then f must (essentially) satisfy

𝐏𝐫𝒙f1(1),𝒚Nλ(𝒙)[f(𝒙)f(𝒚)]12pSensλ(hp);

i.e. that halfspaces are minimizers of the quantity 𝐏𝐫𝒙f1(1),𝒚Nλ(𝒙)[f(𝒙)f(𝒚)], which the algorithm of Theorem 2 estimates from samples and queries. This means that if we run the algorithm of Theorem 2 with the value p2 obtained from the modified algorithm of Theorem 3 as described earlier, there are two possibilities:

  • If f is a halfspace, then p2 will be (approximately) equal to the true value of p, and since we are running the algorithm of Theorem 2 with (essentially) the right value of p, it will accept.

  • On the other hand, if f is far from every halfspace, then as explained earlier p2 will be significantly larger than the true value of p. But since 12pSensλ(LTFp) is a decreasing function of p, the algorithm of Theorem 2 can only accept if it is run on a “guessed” value of Vol(f) which is either equal to or smaller than the true value of Vol(f). So in this case, the algorithm will reject.

This concludes the overview of the proof of Theorem 4. One point of technical interest is that the actual proof of Theorem 4 does not use Theorem 2 as a black-box. In fact, unlike Theorem 2 which crucially relies on the robust isoperimetry results of [2], Theorem 4 only relies on the classical result of Borell [7] which states that halfspaces are the minimizers of noise sensitivity. The result of Borell has many proofs by now, including some quite elementary (see [18] and references therein). So, arguably, the proof of Theorem 4 is significantly simpler than that of Theorem 2 (though conceptually, Theorem 4 is inspired by Theorem 2).

3 Preliminaries for relative-error testing over 𝑵(𝟎,𝟏)𝒏

We use boldfaced letters such as 𝒙,𝒇,𝑨, etc. to denote random variables (which may be real-valued, vector-valued, function-valued, or set-valued; the intended type of the random variable will be clear from the context). We write 𝒙𝒟 to indicate that the random variable 𝒙 is distributed according to probability distribution 𝒟.

We will write (ei)i=1n for the collection of standard basis vectors in n. Given two sets A and B, we use AB to denote their symmetric difference, i.e. AB=(AB)(BA). As in [44] we write for the set ={0,1,2,}.

The Gaussian distribution and Gaussian relative-error testing.

We will write N(0,In) to denote the n-dimensional standard Gaussian distribution, and denote its density function by φn, i.e., for xn,

φn(x)=1(2π)nex2/2.

We frequently write φφ1 to denote the one-dimensional standard Gaussian density. We write Vol(K) to denote the Gaussian measure of a (Lebesgue measurable) set Kn, that is

Vol(K):=𝐏𝐫𝒙N(0,In)[𝒙K].

Given a 0/1-valued function f:n{0,1}, we write Vol(f) to denote Vol(f1(1)).

Finally, we will write Φ:(0,1) for the c.d.f. of N(0,1), i.e.

Φ(r)=𝐏𝐫𝒈N(0,1)[𝒈r]=rφ(x)𝑑x.

We will frequently use the following standard tail bound on (univariate) Gaussian random variables:

Proposition 5 (Proposition 2.1.2 of [47] or Exercise 2.2 of [48]).

Suppose 𝐠N(0,1) is a one-dimensional Gaussian random variable. Then for all r>0, we have

(1r1r3)φ(r)Φ(r)=𝐏𝐫𝒈N(0,1)[𝒈r](1r1r3+3r5)φ(r).

From Proposition 5 we get the following estimate on Φ() that will be convenient:

Fact 6.

Let r be any positive value bounded away from 0 by an absolute constant, e.g. r0.01. Then we have 1Φ(r)=Φ(r)=Θ(er2/2/r).

Gaussian relative-error testing.

The model of relative-error testing under the Gaussian distribution is a natural variant of the model of relative-error testing over {0,1}n that was described earlier. Now a call to SAMP(f) returns a draw from N(0,1)n|f1(1), the standard Gaussian distribution conditioned on f1(1). Similar to before, a relative-error testing algorithm for 𝒞 must output “yes” with high probability (say at least 9/10; this success probability can be easily amplified) if f𝒞, and must output “no” with high probability (again, say at least 9/10) if 𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(f,𝒞)ε, where 𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(f,𝒞)=ming𝒞𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(f,g) and the relative distance between f and g is defined as

𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(f,g)=Vol(f1(1)g1(1))Vol(f).

Testing algorithms in the standard model.

For handling certain edge cases, we will rely on known testing algorithms in the standard (not relative-error) property testing model. One such result that we will use is the following theorem due to [37]:

Theorem 7 (Theorem 26 of [37]).

There is an algorithm MORS-Tester that, when given error parameter ε>0 and oracle access to f:n{0,1}, makes O(1/ε12) queries to f and has the following guarantee:

  1. 1.

    If f is a halfspace, the algorithm outputs accept with probability at least 0.99.

  2. 2.

    If Vol(f1(1)h1(1))ε for every halfspace h, then the algorithm outputs reject with probability at least 0.99.

For sample-based testing, we will use the following result due to Harms [32]:

Theorem 8 (Theorem 1.1 of [32]).

There is an algorithm Harms-Tester that, when given error parameter ε>0 and access to random labeled examples (𝐱,f(𝐱)) with each 𝐱N(0,In), uses O~(n/ε7) samples and has the following guarantee:

  1. 1.

    If f is a halfspace, the algorithm outputs accept with probability at least 0.99.

  2. 2.

    If Vol(f1(1)h1(1))ε for every halfspace h, then the algorithm outputs reject with probability at least 0.99.

4 Testing with known volume via Gaussian surface area:
XXx..Proof of Theorem 2

In this section we prove Theorem 2. Before we start, note that we can make a simplifying assumption, which is that p:=Vol(f) is at most 0.1. This is because if p>0.1, we can just run the testing algorithm from [37] (Theorem 7) with error parameter ε/10; as p>0.1, standard-model ε/10-testing implies ε-relative-error testing. So for the rest of this section, we assume that p0.1.

4.1 Gaussian surface area

We begin by recalling the notion of surface area in the Gaussian space.

Definition 9.

Let An. The surface area of A (under the standard Gaussian measure φn) is given by

𝗌𝗎𝗋𝖿(A):=limδ0+Vol(Aδ)Vol(A)δ,

where Aδ:={x:d(x,A)δ}. For sets A with a smooth boundary, 𝗌𝗎𝗋𝖿(A) is equivalent to

xAφn(x)𝑑σ(x),

where dσ(x) is the standard surface area element in n and A denotes the boundary of the set A.

There is a close connection between the notion of surface area and noise sensitivity, as shown by Ledoux [35]:

Theorem 10.

For any t0 and any set An with 𝒞1 boundary, we have

𝐍𝐒t(A)2tπ𝗌𝗎𝗋𝖿(A).

A near-converse of this result was shown by Neeman [42]: every set A as above is close to a set B whose surface area can be bounded in terms of the noise sensitivity of A.

Theorem 11 (Theorem 1.2, Theorem 2.1 of [42]).

Let An be a set with 𝒞1 boundary and let t,ξ>0. Then, there exists a set Bn such that

  1. 1.

    Vol(AB)𝐍𝐒t(A)ξ; and

  2. 2.

    𝗌𝗎𝗋𝖿(B)π2(1+O(ξlog(1/ξ)))1e2t1𝐍𝐒t(A).

We recall (see e.g. Chapter 5 of [44]) that the function

I(p):=φ(Φ1(p)) (2)

is sometimes known as the Gaussian isoperimetric function (cf. Fact 14 below). This function will be used in various ways throughout our arguments, including in the proof of the following simple fact:

Fact 12.

Let 0<qp1/2 and p/q(1+ε). Then,

φ(Φ1(p))φ(Φ1(q))1(1+ε)φ(Φ1(p)).

Proof.

The function I() is easily seen to be monotonically non-decreasing in the interval (0,1/2], which gives the first inequality. Moreover, it is known that the function I(p) is concave (see Exercise 5.24 [44]). This implies that

I(q)qpI(p)11+εI(p).

We will also need some basic facts about the function φ(Φ1(p))/p which we state here.

Claim 13.

The function R(p):=φ(Φ1(p))p is decreasing in the interval (0,1/2).

Proof.

Let s(,0) be chosen so that sφ(t)𝑑t=p. Then, note that

R(p)=φ(s)sφ(t)𝑑t.

We also need the following simple fact characterizing the surface area of any halfspace in the Gaussian space in terms of its volume; the proof of the final equality is a calculation using standard bounds on the Gaussian pdf and cdf, in particular Proposition 5.

Fact 14.

Let f:n{0,1} be a halfspace and let Vol(f1(1))=p. Then

𝗌𝗎𝗋𝖿(f1(1))=φ(Φ1(p))=Θ(pln(1/min{p,1p})).

4.2 Other basic algorithmic and structural ingredients

Gaussian noise sensitivity.

For any xn and any t0, we let Nt(x) denote the distribution over n defined by etx+1e2t𝒚 where 𝒚N(0,In). Further, for any function f:n and t0, we let Ptf(x)=𝐄𝒚Nt(x)[f(𝒚)].

Definition 15.

For any Boolean function f:n{0,1} and t0, we define 𝐍𝐒t(f) (read as the “noise sensitivity” of f) as

𝐍𝐒t(f)=𝐏𝐫𝒙N(0,In),𝒚Nt(𝒙)[f(𝒙)f(𝒚)].

For a set An, we define 𝐍𝐒t(A) to be 𝐍𝐒t(𝟏A) where 𝟏A() is the indicator function of A.

We observe that using calls to SAMP(f) and MQ(f), we can efficiently estimate the (normalized) noise sensitivity of f:

Lemma 16 (Estimating the normalized noise sensitivity).

For noise parameter t>0 and error parameter κ>0, there is an algorithm Est-Sense which for any f:n{0,1}, given query and sample access to f, outputs a ±κ accurate additive estimate to 𝐍𝐒t(f)/Vol[f] with confidence 0.99 using Θ(κ2) samples from SAMP(f) and the same number of queries to MQ(f).

Proof.

Sample 𝒙N(0,In) and 𝒚Nt(𝒙). Then, note that

𝐍𝐒t(f)=𝐏𝐫[f(𝒙)f(𝒚)]=𝐏𝐫[𝒙f1(1)𝒚f1(1)]+𝐏𝐫[𝒚f1(1)𝒙f1(1)].

As the distribution of (𝒙,𝒚) is exchangeable, it follows that

𝐍𝐒t(f)=2𝐏𝐫[𝒙f1(1)𝒚f1(1)]=2Vol(f)𝐏𝐫[f(𝒚)=0|f(𝒙)=1].

Standard sampling shows that the RHS probabilty can be estimated to error ±κ/2 with confidence 0.99 using Θ(κ2) calls to SAMP(f) and the same number of queries to f. The lemma follows.

Another key ingredient we require is the following deep result of Barchiesi et al. [2] which obtains a sharp stability version of the Gaussian isoperimetric inequality. In particular, they establish the following:

Theorem 17 (Main theorem of [2] and subsequent discussion: sharp stability version of Gaussian isoperimetric inequality).

Let E be a measurable subset of n and let s satisfy Vol(E)=Φ(s), i.e., the Gaussian volume of E is the same as that of the one-dimensional halfspace {x:xs}. Define the Gaussian isoperimetric deficit (namely, the gap between the two sides of the Gaussian isoperimetric inequality) to be

D(E):=𝗌𝗎𝗋𝖿(E)φ(Φ1(Vol(E))=𝗌𝗎𝗋𝖿(E)12πes2/2.

Then, there is a halfspace H={x:xωs} (for some unit vector ω) such that

Vol(EH)2C(1+s2)es2/2D(E),

where C>0 is a universal constant (which can be taken to be at most 3202π2).

 Remark 18.

The main theorem in [2] defines the isoperimetric deficit D(E)=𝗌𝗎𝗋𝖿(E)es2/2 – i.e. vis-a-vis their definition, we have an extra factor of 1/2π. The reason is just that while our definition of the surface area of a set A is xAφn(x)𝑑σ(x), the definition in [2] is equivalent to defining it as xA2πφn(x)𝑑σ(x).

An easy corollary of this is the following:

Corollary 19.

Let E be a measurable subset of n such that Vol(E)=p with p0.1. Suppose

D(E)β2plog3/2(1/p)

for some β. Then there is a halfspace H that satisfies Vol(H)=p and Vol(EH)Cβp for some absolute constant C>0. (Recalling φ(Φ1(p))=Θ(plog(1/p)), an equivalent statement is if

D(E)β2log2(1/p)φ(Φ1(p)),

then there is a halfspace H that satisfies Vol(H)=p and Vol(EH)Cβp.)

Proof.

Let H={x:x1s} be a one-dimensional halfspace such that Vol(H)=p. Note that

φ(Φ1(p))=12πes2/2

so es2/2=Θ(φ(Φ1(p))) and using φ(Φ1(p))=Θ(plog(1/p)), we have s2=Θ(log(1/p)).

Now, applying Theorem 17, we have that there is a halfspace H with Vol(H)=p and

Vol(EH)2 O(log(1/p)φ(Φ1(p))β2log2(1/p)φ(Φ1(p))).

This finishes the proof by plugging in φ(Φ1(p))=Θ(plog(1/p)).

4.3 Proof of Theorem 2

We now have all the necessary ingredients required to prove Theorem 2. The algorithm alluded to in Theorem 2, called GSA-Test, is given in Algorithm 1.

Algorithm 1 A relative-error LTF tester over Gaussian space using samples and queries.

Proof of Theorem 2.

The algorithm is given a value p^ such that p:=Vol(f) satisfies

p1+ζp^(1+ζ)p, (3)

where ζ=c1ε2/log2(1/p) for a suitable absolute constant c1>0.

The algorithm and its analysis use three main parameters, which are κ, t, and ξ. The precise values of t and ξ (in terms of p and ε) are set later (see (15)), but looking ahead, importantly, both ξ and t are set to be poly(log(1/p),1/ε). The parameter κ is defined as

κ:=ζtφ(Φ1(p𝗅𝖻))2πp𝗅𝖻ζtφ(Φ1(p))2πp. (4)

using Fact 12 and p𝗅𝖻p. We also define the parameter p𝗅𝖻 as

p𝗅𝖻:=p^/(1+ζ). (5)

Correctness analysis.

There are two parts of the analysis establishing correctness. We first start with the easy part, which is completeness.

Claim 20 (Completeness).

If f is a halfspace with Vol(f)=p and the input parameter p^ satisfies (3), then f passes the test with probability at least 0.99.

Proof.

As f is a halfspace, by Theorem 10 and Fact 14 we have

𝐍𝐒t(f)Vol(f)2tπφ(Φ1(p))p.

Note that p𝗅𝖻p and the function Λ(p):=φ(Φ1(p))/p is decreasing in the interval (0,1/2). Thus,

𝐍𝐒t(f)Vol(f)2tπφ(Φ1(p𝗅𝖻))p𝗅𝖻.

As 𝜶𝐍𝐒t(f)/Vol(f)+κ with probability 0.99 by Lemma 16, this finishes the proof.

The next claim analyzes the soundness of the test.

Claim 21 (Soundness).

Suppose f:n{0,1} has Vol(f)=p, and suppose that p and p^ satisfy (3). If 𝗋𝖾𝗅-𝖽𝗂𝗌𝗍(f,g)ε for every halfspace g, then f fails the test with probability at least 0.99.

Proof.

We prove the contrapositive. Suppose f passes the test with probability greater than 0.01. By Line 2 of the algorithm and Lemma 16, it must be the case that

𝐍𝐒t(f)Vol(f)2tπφ(Φ1(p𝗅𝖻))p𝗅𝖻+2κ.

Equivalently (recalling that Vol(f)=p), we get that

𝐍𝐒t(f)2tpπφ(Φ1(p𝗅𝖻))p𝗅𝖻+2κp.

Now, using Fact 12 and p𝗅𝖻p(1+ζ)p𝗅𝖻, we get that

𝐍𝐒t(f)2tpπφ(Φ1(p))p(1+ζ)+2κp=2(1+ζ)tφ(Φ1(p))π+2κp.

Plugging in the value of κ from (4) in the above estimate, we get

𝐍𝐒t(f)2tφ(Φ1(p))π+3ζtφ(Φ1(p))π3tφ(Φ1(p))π, (6)

where we use the fact that ζ1/3 when c1 is sufficiently small. For any parameter ξ>0, we can now apply Theorem 11 to get that there is another function f𝗌𝗆:n{0,1} satisfying the two bounds Equation 7 and Equation 10 given below: The first bound, using Equation 6, is

Vol(ff𝗌𝗆)𝐍𝐒t(f)ξ3tφ(Φ1(p))πξ. (7)

For the second bound, let us now define τ as

τ:=3tφ(Φ1(p))πξp=Θ(tlog(1/p)ξ), (8)

where we use Fact 14 in the last inequality. (Looking ahead to Equation 15, note that our choice of parameters will ensure that τ1/10.) By Equation 7, we have that

(1+τ)pp𝗌𝗆:=Vol(f𝗌𝗆)(1τ)p. (9)

The second bound given by Theorem 11 is

𝗌𝗎𝗋𝖿(f𝗌𝗆) π2(1+O(ξlog(1/ξ)))1e2t1𝐍𝐒t(f) (10)
π21e2t1(2tφ(Φ1(p))π+3ζtφ(Φ1(p))π)
+𝐍𝐒t(f)e2t1O(ξlog(1/ξ)),

where we used the first estimate of (6). Plugging in e2t12t and the second bound of (6),

𝗌𝗎𝗋𝖿(f𝗌𝗆)(1+3ζ)φ(Φ1(p))+O(ξ)φ(Φ1(p))log(1/ξ). (11)

Thus, defining the set E:=f𝗌𝗆1(1), the isoperimetric deficit D(E) for this set E satisfies

D(E) =𝗌𝗎𝗋𝖿(f𝗌𝗆)φ(Φ1(p𝗌𝗆))
(1+3ζ)φ(Φ1(p))+O(ξ)φ(Φ1(p))log(1/ξ)φ(Φ1(p𝗌𝗆)),

where we use (11) to get the inequality. Now, recall that by Equation 9 we have

p/p𝗌𝗆1/(1τ)1+2τ

using τ1/10. Combining this with Fact 12, it follows that φ(Φ1(p))(1+2τ)φ(Φ1(p𝗌𝗆) and

D(E)(2τ+3ζ(1+2τ)+O(ξlog(1/ξ)))φ(Φ1(p𝗌𝗆)). (12)

Now using Corollary 19 with this estimate (along with the fact Vol(E)=p𝗌𝗆 and τ1/10), there is a halfspace H such that

Vol(HE)=O(βp𝗌𝗆)=O(βp) (13)

where

β=log(1/p)O(τ+ζ+ξlog1/4(1/ξ)).

Using (8), it follows that

β=log(1/p)O((tlog(1/p))1/4ξ+ζ+ξlog1/4(1/ξ)). (14)

We can now use the fact that ζ=c1ε2/log2(1/p) for a sufficiently small c1>0 and finally set the parameters t and ξ as follows

t=c2ε10log10(1/p𝗅𝖻)andξ=c3ε2.1log2.1(1/p𝗅𝖻), (15)

for sufficiently small constants c2c31, to get from Equations 13 and 14 that

Vol(HE)ε2p. (16)

Combining Equation 7 with Equation 16, and observing that by Equation 15 we have that (7) is bounded from above by εp/2 as well (with room to spare), by the triangle inequality we get that Vol(f1(1)H)εp, i.e. f has relative distance at most ε from the halfspace H. This establishes the contrapositive and concludes the proof of Claim 21.

Complexity analysis.

We finally note that κ defined in (4) is Θ(ε7/log6.5(1/p)). As the sample complexity of Lemma 16 scales as O(κ2), our final sample complexity is O(ε14log13(1/p)). This concludes the proof of Theorem 2.

References

  • [1] Maria-Florina Balcan, Eric Blais, Avrim Blum, and Liu Yang. Active Property Testing. In 53rd Annual IEEE Symposium on Foundations of Computer Science, FOCS, pages 21–30, 2012. doi:10.1109/FOCS.2012.64.
  • [2] Marco Barchiesi, Alessio Brancolini, and Vesa Julin. Sharp dimension free quantitative estimates for the Gaussian isoperimetric inequality. The Annals of Probability, pages 668–697, 2017.
  • [3] Arnab Bhattacharyya and Yuichi Yoshida. Property Testing - Problems and Techniques. Springer, 2022. doi:10.1007/978-981-16-8622-1.
  • [4] Eric Blais, Renato Ferreira Pinto Jr, and Nathaniel Harms. VC dimension and distribution-free sample-based testing. In Proceedings of the 53rd Annual ACM SIGACT Symposium on Theory of Computing, pages 504–517, 2021. doi:10.1145/3406325.3451104.
  • [5] H. Block. The Perceptron: a model for brain functioning. Reviews of Modern Physics, 34:123–135, 1962.
  • [6] C. Borell. The Brunn-Minkowski inequality in Gauss space. Invent. Math., 30:207–216, 1975.
  • [7] C. Borell. Geometric bounds on the Ornstein-Uhlenbeck velocity process. Probability Theory and Related Fields, 70:1–13, 1985.
  • [8] Gautam Chandrasekaran, Adam Klivans, Vasilis Kontonis, Raghu Meka, and Konstantinos Stavropoulos. Smoothed Analysis for Learning Concepts with Low Intrinsic Dimension. In The Thirty Seventh Annual Conference on Learning Theory (COLT), pages 876–922, 2024. URL: https://proceedings.mlr.press/v247/chandrasekaran24a.html.
  • [9] X. Chen, D. Palit, K. Peshawaria, W. Pires, R. Servedio, and Y. Zhang. Relative-error unateness testing. Available at https://arxiv.org/abs/2510.21589, 2025. doi:10.48550/arXiv.2510.21589.
  • [10] X. Chen, W. Pires, T. Pitassi, and R. Servedio. DNF formulas are efficiently testable with relative error. Available at https://arxiv.org/pdf/2601.16076, 2026.
  • [11] Xi Chen, Anindya De, Yizhi Huang, Yuhao Li, Shivam Nadimpalli, Rocco A. Servedio, and Tianqi Yang. Relative-error monotonicity testing. Available at https://arxiv.org/abs/2410.09235, to appear in SODA 2025, 2024. doi:10.48550/arXiv.2410.09235.
  • [12] Xi Chen, Anindya De, Yizhi Huang, Shivam Nadimpalli, Rocco A. Servedio, and Tianqi Yang. Halfspaces are hard to test with relative error. SODA 2026, to appear, 2026.
  • [13] Xi Chen and Shyamal Patel. Distribution-free testing for halfspaces (almost) requires PAC learning. In Proceedings of the 2022 ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1715–1743. SIAM, 2022. doi:10.1137/1.9781611977073.70.
  • [14] Xi Chen, William Pires, Toniann Pitassi, and Rocco A. Servedio. Relative-error testing of conjunctions and decision lists. In 52nd International Colloquium on Automata, Languages, and Programming, ICALP 2025, volume 334 of LIPIcs, pages 52:1–52:18, 2025. doi:10.4230/LIPIcs.ICALP.2025.52.
  • [15] Xi Chen, William Pires, Toniann Pitassi, and Rocco A. Servedio. Testing juntas and junta subclasses with relative error. In 38th Annual Conference on Learning Theory (COLT), 2025.
  • [16] Andrea Cianchi, Nicola Fusco, Francesco Maggi, and Aldo Pratelli. On the isoperimetric deficit in Gauss space. American Journal of Mathematics, pages 131–186, 2011.
  • [17] A. Daniely. Complexity theoretic limitations on learning halfspaces. In Proceedings of the 48th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2016, pages 105–117, 2016.
  • [18] A. De, E. Mossel, and J. Neeman. Majority is stablest: discrete and SoS. In Proc. 45th Annual ACM Symposium on Theory of Computing (STOC), pages 477–486, 2013.
  • [19] Anindya De, Huan Li, Shivam Nadimpalli, and Rocco A Servedio. Detecting low-degree truncation. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, pages 1027–1038, 2024. doi:10.1145/3618260.3649633.
  • [20] 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.
  • [21] Anindya De, Elchanan Mossel, and Joe Neeman. Robust testing of low dimensional functions. In Proceedings of the 53rd Annual ACM SIGACT Symposium on Theory of Computing, pages 584–597, 2021. doi:10.1145/3406325.3451115.
  • [22] Anindya De, Shivam Nadimpalli, and Rocco A Servedio. Testing convex truncation. In Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 4050–4082. SIAM, 2023. doi:10.1137/1.9781611977554.CH155.
  • [23] Ilias Diakonikolas, Daniel Kane, Vasilis Kontonis, Sihan Liu, and Nikos Zarifis. Efficient testable learning of halfspaces with adversarial label noise. Advances in Neural Information Processing Systems, 36, 2024.
  • [24] Ilias Diakonikolas, Daniel M Kane, and Pasin Manurangsi. The complexity of adversarially robust proper learning of halfspaces with agnostic noise. Advances in Neural Information Processing Systems, 33:20449–20461, 2020.
  • [25] Irit Dinur, Ehud Friedgut, Guy Kindler, and Ryan O’Donnell. On the Fourier tails of bounded functions over the discrete cube. In Proc. 38th ACM Symp. on Theory of Computing, pages 437–446, 2006. doi:10.1145/1132516.1132580.
  • [26] Antoine Ehrhard. Éléments extrémaux pour les inégalités de Brunn-Minkowski Gaussiennes. In Annales de l’IHP Probabilités et statistiques, volume 22(2), pages 149–168, 1986.
  • [27] Ronen Eldan. A two-sided estimate for the Gaussian noise stability deficit. Inventiones Mathematicae, 201:561–624, 2015.
  • [28] Dana Glasner and Rocco A. Servedio. Distribution-free testing lower bound for basic boolean functions. Theory of Computing, 5(1):191–216, 2009. doi:10.4086/toc.2009.v005a010.
  • [29] Oded Goldreich. Introduction to Property Testing. Cambridge University Press, 2017. doi:10.1017/9781108135252.
  • [30] Oded Goldreich, Shafi Goldwasser, and Dana Ron. Property testing and its connection to learning and approximation. Journal of the ACM, 45:653–750, 1998. doi:10.1145/285055.285060.
  • [31] Nathaniel Harms. Halfway to halfspace testing. Master’s thesis, University of Waterloo, 2017.
  • [32] Nathaniel Harms. Testing Halfspaces over Rotation-Invariant Distributions. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2019, pages 694–713. SIAM, 2019. doi:10.1137/1.9781611975482.44.
  • [33] A. Kalai, A. Klivans, Y. Mansour, and R. Servedio. Agnostically learning halfspaces. SIAM Journal on Computing, 37(6):1777–1805, 2008. doi:10.1137/060649057.
  • [34] S. Khot, G. Kindler, E. Mossel, and R. O’Donnell. Optimal inapproximability results for Max-Cut and other 2-variable CSPs? SIAM Journal on Computing, 37(1):319–357, 2007. doi:10.1137/S0097539705447372.
  • [35] M. Ledoux. Semigroup proofs of the isoperimetric inequality in Euclidean and Gauss space. Bull. Sci. Math., 118:485–510, 1994.
  • [36] Kevin Matulef, Ryan O’Donnell, Ronitt Rubinfeld, and Rocco A. Servedio. Testing ±1-weight halfspace. In APPROX-RANDOM, pages 646–657, 2009. doi:10.1007/978-3-642-03685-9_48.
  • [37] 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.
  • [38] E. Mossel and R. O’Donnell. On the noise sensitivity of monotone functions. Random Structures and Algorithms, 23(3):333–350, 2003. doi:10.1002/RSA.10097.
  • [39] E. Mossel, R. O’Donnell, and K. Oleszkiewicz. Noise stability of functions with low influences: invariance and optimality. Annals of Mathematics, 171:295–341, 2010.
  • [40] Elchanan Mossel and Joe Neeman. Robust dimension free isoperimetry in Gaussian space. Annals of Probability, 43(3):971–991, 2015.
  • [41] Elchanan Mossel and Joe Neeman. Robust optimality of gaussian noise stability. Journal of the European Mathematical Society, 17:433–482, 2015.
  • [42] Joe Neeman. Testing surface area with arbitrary accuracy. In David B. Shmoys, editor, Symposium on Theory of Computing, STOC 2014, pages 393–397. ACM, 2014. doi:10.1145/2591796.2591807.
  • [43] A. Novikoff. On convergence proofs on perceptrons. In Proceedings of the Symposium on Mathematical Theory of Automata, volume XII, pages 615–622, 1962.
  • [44] R. O’Donnell. Analysis of Boolean Functions. Cambridge University Press, 2014.
  • [45] D. Ron. Algorithmic and analysis techniques in property testing. Foundations and Trends in Theoretical Computer Science, 5:73–205, 2010.
  • [46] V. Sudakov and B. Tsirel’son. Extremal properties of half-spaces for spherically invariant measures. J. Soviet Math., 9:9–18, 1978. Translated from Zap. Nauchn. Sem. Leningrad. Otdel. Math. Inst. Steklova. 41 (1974), 14–21.
  • [47] Roman Vershynin. High-Dimensional Probability: An Introduction with Applications in Data Science, volume 47. Cambridge University Press, 2018.
  • [48] M. Wainwright. High-Dimensional Statistics: A Non-Asymptotic Viewpoint. Cambridge University Press, 2019.