Approximating the noise sensitivity of a monotone Boolean function
Ronitt Rubinfeld, Arsen Vasilyan
TL;DR
This paper presents a near-optimal randomized algorithm for approximating the noise sensitivity of monotone Boolean functions within a specified range of parameters, introducing new analytical tools and lower bound techniques.
Contribution
It introduces a novel descending-ascending view of noise sensitivity and develops new lower bound techniques based on combinatorial and probabilistic methods.
Findings
The algorithm achieves query complexity close to the theoretical lower bound.
A new descending-ascending framework for analyzing noise sensitivity is proposed.
Lower bounds are established for approximating noise sensitivity, influence, and bias.
Abstract
The noise sensitivity of a Boolean function is one of its fundamental properties. A function of a positive noise parameter , it is denoted as . Here we study the algorithmic problem of approximating it for monotone , such that for constant , and where satisfies . For such and , we give a randomized algorithm performing queries and approximating to within a multiplicative factor of . Given the same constraints on and , we also prove a lower bound of on the query complexity of any algorithm that…
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Approximating the noise sensitivity of a monotone Boolean function
Ronitt Rubinfeld
CSAIL at MIT, and the Blavatnik School of Computer Science at Tel Aviv University, [email protected]. Ronitt Rubinfeld’s research was supported by NSF grants CCF-1650733, CCF-1733808, IIS-1741137 and CCF-1740751.
Arsen Vasilyan CSAIL at MIT, [email protected]. Arsen Vasilyan’s research was supported by the EECS SuperUROP program, the MIT Summer UROP program and the DeFlorez Endowment Fund.
The noise sensitivity of a Boolean function is one of its fundamental properties. A function of a positive noise parameter , it is denoted as . Here we study the algorithmic problem of approximating it for monotone , such that for constant , and where satisfies . For such and , we give a randomized algorithm performing queries and approximating to within a multiplicative factor of . Given the same constraints on and , we also prove a lower bound of on the query complexity of any algorithm that approximates to within any constant factor, where can be any positive constant. Thus, our algorithm’s query complexity is close to optimal in terms of its dependence on .
We introduce a novel descending-ascending view of noise sensitivity, and use it as a central tool for the analysis of our algorithm. To prove lower bounds on query complexity, we develop a technique that reduces computational questions about query complexity to combinatorial questions about the existence of “thin” functions with certain properties. The existence of such “thin” functions is proved using the probabilistic method. These techniques also yield previously unknown lower bounds on the query complexity of approximating other fundamental properties of Boolean functions: the total influence and the bias.
1 Introduction
Noise sensitivity is a property of any Boolean function defined as follows: First, pick uniformly at random from , then pick by flipping each with probability . Here , the noise parameter, is a given positive constant no greater than (and at least in the interesting cases). The noise sensitivity of , denoted as , equals the probability that . This definition was first explicitly given by Benjamini, Kalai and Schramm in [3]. Noise sensitivity has been the focus of multiple papers: [3, 7, 8, 10, 11, 13, 18, 23]. It has been applied to learning theory [4, 7, 8, 9, 11, 12, 16], property testing [1, 2], hardness of approximation [14, 17], hardness amplification [20], theoretical economics and political science[10], combinatorics [3, 13], distributed computing [19] and differential privacy [7]. Multiple properties and applications of noise sensitivity are summarized in [21] and [22].
In this work, we study the algorithmic question of approximating the noise sensitivity of a function to which we are given oracle access. It can be shown that standard sampling techniques require queries to get a -multiplicative approximation for . In Appendix B, we show that this is optimal for a wide range of parameters of the problem. Specifically, it cannot be improved by more than a constant when is a sufficiently small constant, satisfies and satisfies . Therefore, we focus on estimating the noise sensitivity of monotone functions, which form an important subclass of Boolean functions.
Noise sensitivity is closely connected to the total influence (henceforth just influence) of a Boolean function [21, 22]. Influence, denoted by , is defined as times the probability that , where is chosen uniformly at random, as for noise sensitivity, and is formed from by flipping a random index (this latter probability is sometimes referred to as the average sensitivity). Despite their close connections, the noise sensitivity of a function can be quite different from its influence. For instance, for the parity function of all bits, the influence is , but the noise sensitivity is (such disparities also hold for monotone functions, see for example the discussion of influence and noise sensitivity of the majority function in [22]).
The approximation of parameters of monotone Boolean functions was previously studied by [25, 24], where they considered the question of how fast one can approximate the influence of a monotone function given oracle access to . It was shown that one can approximate the influence of a monotone function with only queries, which for constant beats the standard sampling algorithm by a factor of , ignoring logarithmic factors.
Noise sensitivity is also closely related to the notion of noise stability (see for instance [22]). The noise stability of a Boolean function depends on a parameter and is denoted by . A well known formula connects it with noise sensitivity . This implies that by obtaining an approximation for , one also achieves an approximation for the gap between and one.
1.1 Results
Our main algorithmic result is the following:
Theorem 1
Let be a parameter satisfying:
[TABLE]
Suppose, is a monotone function and for some constant .
Then, there is an algorithm that outputs an approximation to to within a multiplicative factor of , with success probability at least . In expectation, the algorithm makes queries to the function. Additionally, it runs in time polynomial in .
Note that computing noise-sensitivity using standard sampling111Standard sampling refers to the algorithm that picks pairs and as in the definition of noise sensitivity and computes the fraction of pairs for which . requires samples. Therefore, for a constant , we have the most dramatic improvement if , in which case, ignoring constant and logarithmic factors, our algorithm outperforms standard sampling by a factor of .
As in [25] 222In the following, we discuss how we build on [25]. We discuss the relation with [24] in Subsection 1.4. , our algorithm requires that the noise sensitivity of the input function is larger than a specific threshold . Our algorithm is not sensitive to the value of as long as it is a constant, and we think of as a rough initial lower bound known in advance.
We next give lower bounds for approximating three different quantities of monotone Boolean functions: the bias, the influence and the noise sensitivity. A priori, it is not clear what kind of lower bounds one could hope for. Indeed, determining whether a given function is the all-zeros function requires queries in the general function setting, but only query (of the all-ones input), if the function is promised to be monotone. Nevertheless, we show that such a dramatic improvement for approximating these quantities is not possible.
For monotone functions, we are not aware of previous lower bounds on approximating the bias or noise sensitivity. Our lower bound on approximating influence is not comparable to the lower bounds in [25], as we will elaborate shortly.
We now state our lower bound for approximating the noise sensitivity:
Theorem 2
Suppose is a sufficiently large integer, satisfies , and are constants satisfying . Then, given a monotone function , one needs at least queries to reliably distinguish333Here and everywhere else, to reliably distinguish means to distinguish with probability at least . between the following two cases: (i) has noise sensitivity between and and (ii) has noise sensitivity larger than .
Remark: For any positive constant , we have that .
Remark: The range of the parameter can be divided into two regions of interest. In the region , the algorithm from Theorem 1 can distinguish the two cases above with only queries. Therefore its query complexity is optimal up to a factor of . Similarly, in the region , the standard sampling algorithm can distinguish the two distributions above with only queries. Therefore in this region of interest, standard sampling is optimal up to a factor of .
We define the bias of a Boolean function as , where is chosen uniformly at random from . It is arguably the most basic property of a Boolean function, so we consider the question of how quickly it can be approximated for monotone functions. To approximate the bias using standard sampling, one needs queries. We obtain a lower bound for approximating it similar to the previous theorem:
Theorem 3
Suppose is a sufficiently large integer, and are constants satisfying . Then given a monotone function f$$:\{0,1\}^{n}\rightarrow\{0,1\}, one needs at least queries to reliably distinguish between the following two cases: (i) has bias of (ii) has bias larger than .
Finally we prove a lower bound for approximating influence:
Theorem 4
Suppose is a sufficiently large integer, and are constants satisfying . Then given a monotone function f$$:\{0,1\}^{n}\rightarrow\{0,1\}, one needs at least queries to reliably distinguish between the following two cases: (i) has influence between and (ii) has influence larger than .
This gives us a new sense in which the algorithm family in [25] is close to optimal, because for a function with influence this algorithm makes queries to estimate the influence up to any constant factor.
Our lower bound is incomparable to the lower bound in [25], which makes the stronger requirement that , but gives a bound that is only a polylogarithmic factor smaller than the runtime of the algorithm in [25]. There are many possibilities for algorithmic bounds that were compatible with the lower bound in [25], but are eliminated with our lower bound. For instance, prior to this work, it was conceivable that an algorithm making as little as queries could give a constant factor approximation to the influence of any monotone input function whatsoever. Our lower bound shows that not only is this impossible, no algorithm that makes queries for any constant can accomplish this either.
1.2 Algorithm overview
Here, we give the algorithm in Theorem 1 together with the subroutines it uses. Additionally, we give an informal overview of the proof of correctness and the analysis of run-time and query complexity, which are presented in Section 3.
First of all, with and described as above, using a standard pairing argument we argue that . In other words, we can focus only on the case when the value of the function flips from one to zero.
We introduce the descending-ascending view of noise sensitivity (described in Subsection 3.1), which, roughly speaking, views the noise process as decomposed into a first phase that operates only on the locations in that are , and a second phase that operates only on the locations in that are set to [math]. Formally, we define:
Process
•
Pick uniformly at random from . Let be the set of indexes for which , and conversely let be the rest of indexes.
•
Phase 1: go through all the indexes in in a random order, and flip each with probability . Form the descending path from all the intermediate results. Call the endpoint .
•
Phase 2: start at , and flip each index in with probability . As before, all the intermediate results form an ascending path , which ends in .
This process gives us a path from to that can be decomposed into two segments, such that the first part, , descends in the hypercube, and the second part ascends in the hypercube.
Since is monotone, for and to be the case, it is necessary, though not sufficient, that and , which happens whenever hits an influential edge. Therefore we break the task of estimating the probability of into computing the product of:
- •
The probability that hits an influential edge, specifically, the probability that and , which we refer to as .
- •
The probability that does not hit any influential edge, given that hits an influential edge: specifically, the probability that given and , it is the case that . We refer to this probability as .
The above informal definitions of and ignore some technical complications. Specifically, the impact of certain “bad events” is considered in our analysis. We redefine and precisely in Subsection 3.1.3.
To define those bad events, we use the following two values, which we reference in our algorithms: and . Informally, and have the following intuitive meaning. A typical vertex of the hypercube has Hamming weight between and . A typical Phase 1 path from process will have length at most . To achieve this, we assign and , where and are certain constants. We also define to be the set of edges , for which both and are between and and . Again, most of the edges in the hypercube are in .
The utility of this ascending-descending view is that given444Our analysis requires that only as in the statement of Theorem 1, however the analysis of the case involves technical subtleties that we ignore here. , it is the case that will be shorter than . Therefore, typically, the path is also shorter than . Similar short descending paths on the hypercube have been studied before: In [25], paths of such lengths were used to estimate the number of influential edges by analyzing the probability that a path would hit such an edge. One useful insight given by [25] is that the probability of hitting almost every single influential edge is roughly the same.
However, the results in [25] cannot be immediately applied to analyze , because (i) does not have a fixed length, but rather its lengths form a probability distribution, (ii) this probability distribution also depends on the starting point of . We build upon the techniques in [25] to overcome these difficulties, and prove that again, roughly speaking, for almost every single influential edge, the probability that hits it depends very little on the location of the edge, and our proof also computes this probability. This allows us to prove that . Then, using the algorithm in [25] to estimate , we estimate .
Regarding , we estimate it by approximately sampling paths and that would arise from process , conditioned on that hits an influential edge. To that end, we first sample an influential edge that hits. Since hits almost every single influential edge with roughly the same probability, we do it by sampling approximately uniformly from among influential edges. For the latter task, we build upon the result in [25] as follows: As we have already mentioned, the algorithm in [25] samples descending paths of a fixed length to estimate the influence. For those paths that start at an for which and end at a for which , we add a binary search step in order to locate the influential edge that was hit by the path. Thus, we have the following algorithm:
Algorithm (given oracle access to a monotone function and a parameter )
Assign
Pick uniformly at random from .
Perform a descending walk downwards in the hypercube starting at . Stop at a vertex either after steps, or if you hit the all-zeros vertex.
If output FAIL.
If perform a binary search on the path and find an influential edge .
If return . Otherwise output FAIL.
Finally, once we have obtained a roughly uniformly random influential edge , we sample a path from among those that hit it. Interestingly, we show that this can be accomplished by a simple exponential time algorithm that makes no queries to . However, the constraint on the run-time of our algorithm forces us to follow a different approach:
An obvious way to try to quickly sample such a path is to perform two random walks of lengths and in opposite directions from the endpoints of the edge, and then concatenate them into one path. However, to do this, one needs to somehow sample the lengths and . This problem is not trivial, since longer descending paths are more likely to hit an influential edge, which biases the distribution of the path lengths towards longer ones.
To generate and according to the proper distribution, we first sample a path hitting any edge at the same layer555We say that edges and are on the same layer if and only if their endpoints have the same Hamming weights. We denote the layer an edge belongs to as . as . We accomplish this by designing an algorithm that uses rejection sampling. The algorithm samples short descending paths from some conveniently chosen distribution, until it gets a path hitting the desired layer. Specifically, the algorithm is the following (recall that we use to denote the Hamming weight of which equals to the number of indices on which , and we use the symbol to denote the whole layer of edges that have the same endpoint levels as ):
Algorithm (given an edge so )
Pick an integer uniformly at random among the integers in . Pick a vertex randomly at level .
As in phase 1 of the noise sensitivity process, traverse in random order through the indices of and with probability , flip each index that equals to one to zero. The intermediate results form a path , and we call its endpoint .
If does not intersect go to step .
Otherwise, output and .
Recall that has a technical role and is defined to be equal , where is a certain constant. is chosen to be long enough that it is longer than most paths , but short enough to make the sampling in efficient. Since the algorithm involves short descending paths, we analyze this algorithm building upon the techniques we used to approximate .
After obtaining a random path going through the same layer as , we show how to transform it using the symmetries of the hypercube, into a a random path going through itself. Additionally, given the endpoint of , we sample the path just as in the process . Formally, we use the following algorithm:
Algorithm (given an influential edge )
Use to sample and .
Perform an ascending random walk of length starting at and call its endpoint . Similarly, perform a descending random walk starting at of length , call its endpoint .
Define as the descending path that results between and by concatenating the two paths from above, oriented appropriately, and edge .
Define just as in phase 2 of our process starting at . Consider in random order all the zero indices has in common with and flip each with probability .
Return ,, , and .
We then use sampling to estimate which fraction of the paths continuing these paths does not hit an influential edge. This allows us to estimate , which, combined with our estimate for , gives us an approximation for .
Formally, we put all the previously defined subroutines together as follows:
Algorithm for estimating noise sensitivity. (given oracle access to a monotone function f$$:\{0,1\}^{n}\rightarrow\{0,1\})
Using the algorithm from [25] as described in Theorem 5, compute an approximation to the influence of to within a multiplicative factor of (). This gives us .
Compute .
Initialize and . Repeat the following until .
•
Use algorithm from Lemma 3.4 repeatedly to successfully sample an edge .
•
From Lemma 3.8 use the algorithm , giving it as input, and sample , , , and .
•
If it is the case that and , then .
•
.
Set .
Return .
1.3 Lower bound techniques
We use the same technique to lower bound algorithms which approximate any of the following three quantities: the noise sensitivity, influence and bias.
For concreteness, let us first focus on approximating the bias. Recall that one can distinguish the case where the bias is [math] from the bias being using a single query. Nevertheless, we show that for the most part, no algorithm for estimating the bias can do much better than the random sampling approach.
We construct two probability distributions and that are relatively hard to distinguish but have drastically different biases. To create them, we use a special monotone function , which we will explain later how to obtain. We pick a function from by taking , randomly permuting the indices of its input, and finally “truncating” it by setting it to one on all values for on levels higher than , where is some fixed threshold.
We form even more simply. We take the all-zeros function and truncate it at the same threshold . The threshold is chosen in a way that this function in has a sufficiently small bias.
The purpose of truncation is to prevent a distinguisher from gaining information by accessing the values of the function on the high-level vertices of the hypercube. Indeed, if there was no truncation, one could tell whether they have access to the all-zeros function by simply querying it on the all-ones input. Since is monotone, if it equals to one on at least one input, then it has to equal one on the all-ones input.
The proof has two main lemmas: The first one is computational and says that if is “thin” then and are hard to reliably distinguish. We say that a function is “thin” if it equals to one on only a small fraction of the points on the level . To prove the first lemma, we show that one could transform any adaptive algorithm for distinguishing from into an algorithm that is just as effective, is non-adaptive and queries points only on the layer .
To show this, we observe that, because of truncation, distinguishing a function in from a function in is in a certain sense equivalent to finding a point with level at most on which the given function evaluates to one. We argue that for this setting, adaptivity does not help. Additionally, if and both of them have levels at most then, since is monotone, implies that (but not necessarily the other way around). Therefore, for finding a point on which the function evaluates to one, it is never more useful to query instead of .
Once we prove that no algorithm can do better than a non-adaptive algorithm that only queries points on the level , we use a simple union bound to show that any such algorithm cannot be very effective for distinguishing our distributions.
Finally, we need to show that there exist functions that are “thin” and simultaneously have a high bias. This is a purely combinatorial question and is proven in our second main lemma. We build upon Talagrand random functions that were first introduced in [26]. In [18] it was shown that they are very sensitive to noise, which was applied for property testing lower bounds [2]. A Talagrand random DNF consists of clauses of indices chosen randomly with replacement. We modify this construction by picking the indices without replacement and generalize it by picking clauses, where is a non-negative constant. We show that these functions are “thin”, so they are appropriate for our lower bound technique.
“Thinness” allows us to conclude that and are hard to distinguish from each other. We then prove that they have drastically different biases. We do the latter by employing the probabilistic method and showing that in expectation our random function has a large enough bias. We handle influence and noise sensitivity analogously, specifically by showing that that as we pick fewer clauses, the expected influence and noise sensitivity decrease proportionally. We prove this by dividing the points where one of these random functions equals to one into two regions: (i) the region where only one clause is true and (ii) a region where more one clause is true. Roughly speaking, we show that the contribution from the points in (i) is sufficient to obtain a good lower bound on the influence and noise sensitivity.
1.4 Possibilities of improvement?
In [24] (which is the journal version of [25]), it was shown that using the chain decomposition of the hypercube, one can improve the run-time of the algorithm to and also improve the required lower bound on to be for some constant and (it was for any constant in [25]). Additionally, the algorithm itself was considerably simplified.
A hope is that techniques based on the chain decomposition could help improve the algorithm in Theorem 1. However, it is not clear how to generalize our approach to use these techniques, since the ascending-descending view is a natural way to express noise sensitivity in terms of random walks, and it is not obvious whether one can replace these walks with chains of the hypercube.
2 Preliminaries
2.1 Definitions
2.1.1 Fundamental definitions and lemmas pertaining to the hypercube.
Definition 1
We refer to the poset over as the -dimensional hypercube, viewing the domain as vertices of a graph, in which two vertices are connected by an edge if and only if the corresponding elements of differ in precisely one index. For and in , we say that if and only if for all in it is the case that .
Definition 2
The level of a vertex on the hypercube is the hamming weight of , or in other words number of -s in . We denote it by .
We define the set of edges that are in the same “layer” of the hypercube as a given edge:
Definition 3
For an arbitrary edge suppose and . We denote to be the set of all edges , so that and .
The size of is . The concept of will be useful because we will deal with paths that are symmetric with respect to change of coordinates, and these have an equal probability of hitting any edge in .
Definition 4
*As we view the hypercube as a graph, we will often refer to paths on it. By referring to a path we will, depending on the context, refer to its set of vertices or edges. We call the path descending if for every pair of consecutive vertices and , it is the case that . Conversely, if the opposite holds and , we call the path ascending. We consider an empty path to be vacuously both ascending and descending. We define the length of a path to be the number of edges in it, and denote it by . We say we take a descending random walk of length starting at , if we pick a uniformly random descending path of length starting at . *
Descending random walks over the hyper-cube were used in an essential way in [25] and were central for the recent advances in monotonicity testing algorithms [5, 6, 15].
Lemma 2.1** (Hypercube Continuity Lemma)**
Suppose is a sufficiently large positive integer, is a constant and we are given and satisfying:
[TABLE]
If we denote , then for any satisfying , if it is the case that , then, for large enough , it is the case that
**Proof: ** See Appendix C, Subsection 8.1.
2.1.2 Fundamental definitions pertaining to Boolean functions
We define monotone functions over the -dimensional hypercube:
Definition 5
Let be a function . We say that is monotone if for any and in , implies that
Influential edges, and influence of a function are defined as follows:
Definition 6
An edge in the hypercube is called influential if . Additionally, we denote the set of all influential edges in the hypercube as .
Definition 7
The influence of function f$$:\{0,1\}^{n}\rightarrow\{0,1\}, denoted by is:
[TABLE]
Where is with its -th bit flipped.666 We use the symbol to denote, depending on the type of object the symbol is followed by: (i) Picking a random element from a probability distribution. (ii) Picking a uniformly random element from a set (iii) Running a randomized algorithm and taking the result. Equivalently, the influence is times the probability that a random edge is influential. Since there are edges, then .
Definition 8
Let be a parameter and let be selected uniformly at random from . Let be defined as follows:
[TABLE]
We denote this distribution of and by . Then we define the noise sensitivity of as:
[TABLE]
Observation 2.2
For every pair and , the probability that for a pair drawn from , it is the case that , is equal to the probability that . Therefore,
[TABLE]
Hence:
[TABLE]
2.1.3 Influence estimation.
To estimate the influence, standard sampling would require samples. However, from [25] we have:
Theorem 5
There is an algorithm that approximates to within a multiplicative factor of for a monotone f$$:\{0,1\}^{n}\rightarrow\{0,1\}. The algorithm requires that for a constant that is given to the algorithm. It outputs a good approximation with probability at least and in expectation requires queries. Additionally, it runs in time polynomial in .
2.1.4 Bounds for and
The following observation allows us to assume that without loss of generality is not too small. A similar technique was also used in [25].
Observation 2.3
In this work (recalling that ), we assume that , for any constant , which is without loss of generality for the following reason. The standard sampling algorithm can estimate the noise sensitivity in samples. For , this is and already accomplishes the desired query complexity. Additionally, throughout the paper whenever we need it, we will without loss of generality assume that is smaller than a sufficiently small positive constant.
We will also need a known lower bound on influence:
Observation 2.4
For any function f$$:\{0,1\}^{n}\rightarrow\{0,1\} and it is the case that:
[TABLE]
Therefore it is the case that .
A very similar statement is proved in [18] and for completeness we prove it in Appendix A.
3 An improved algorithm for small
In this section we give an improved algorithm for small , namely . We begin by describing the descending-ascending view on which the algorithm is based.
3.1 Descending-ascending framework
3.1.1 The descending-ascending process.
It will also be useful to view noise sensitivity in the context of the following process 777We will use the following notation for probabilities of various events: for an algorithm or a random process we will use the expression to refer to the random variables we defined in the context of this process or algorithm. It will often be the case that the same symbol, say , will refer to different random random variables in the context of different random processes, so might not be the same as ..
Process
•
Pick uniformly at random from . Let be the set of indexes for which , and conversely let be the rest of indexes.
•
Phase 1: go through all the indexes in in a random order, and flip each with probability . Form the descending path from all the intermediate results. Call the endpoint .
•
Phase 2: start at , and flip each index in with probability . As before, all the intermediate results form an ascending path , which ends in .
By inspection, and are distributed the identically in as in . Therefore from Observation 2.2:
[TABLE]
Observation 3.1
Since the function is monotone, if and , then it has to be that .
Now we define the probability that a Phase 1 path starting somewhere at level makes at least steps downwards:
Definition 9
For any and in we define as follows:
[TABLE]
This notation is useful when one wants to talk about the probability that a path starting on a particular vertex hits a specific level.
3.1.2 Defining bad events
In this section, we give the parameters that we use to determine the lengths of our walks, as well as the “middle” of the hypercube.
Define the following values:
[TABLE]
Here and are large enough constants. For constant , taking and is sufficient for our purposes.
Informally, and have the following intuitive meaning. A typical vertex of the hypercube has between and . A typical Phase 1 path from process will have length at most .
We define the “middle edges” as the following set of edges:
[TABLE]
Denote by the rest of the edges.
We define the following two bad events in context of . The first one happens roughly when (from to , as defined by Process D) is much longer than it should be in expectation, and the second one happens when crosses one of the edges that are too far from the middle of the hypercube, which could happen because is long or because of a starting point that is far from the middle.
- •
happens when both of the following hold (i) crosses an edge and (ii) denoting , so that , it is the case that .
- •
happens when contains an edge in .
While defining we wanted two things from it. First of all, we wanted its probability to be upper-bounded easily. Secondly, we wanted it not to complicate the sampling of paths in Lemma 3.6. There exists a tension between these two requirements, and as a result the definition of is somewhat contrived.
3.1.3 Defining
We define:
[TABLE]
Ignoring the bad events, is the probability that hits an influential edge, and is the probability that given that hits an influential edge does not hit an influential edge. From Observation (3.1), if and only if these two things happen, it is the case that and . From this fact and the laws of conditional probabilities we have:
[TABLE]
We can consider for every individual edge in the probabilities:
[TABLE]
[TABLE]
The last equality is true because already implies . Informally and ignoring the bad events again, is the probability that and because hits and not some other influential edge. Similarly, is the probability and given that hits specifically .
Since is monotone, can hit at most one influential edge. Therefore, the events of hitting different influential edges are disjoint. Using this, Equation (1) and the laws of conditional probabilities we can write:
[TABLE]
Furthermore, the events that hits a given influential edge and then does not hit any are also disjoint for different influential edges. Therefore, analogous to the previous equation we can write:
[TABLE]
3.1.4 Bad events can be “ignored”
In the following proof, we will need to consider probability distributions in which bad events do not happen. For the most part, conditioning on the fact that bad events do not happen changes little in the calculations. In this subsection, we prove lemmas that allow us to formalize these claims.
The following lemma suggests that almost all influential edges are in .
Observation 3.2
It is the case that:
[TABLE]
**Proof: ** This is the case, because:
[TABLE]
The second inequality is the Hoeffding bound, then we used Observations 2.4 and 2.3.
Lemma 3.3
We proceed to prove that ignoring these bad events does not distort our estimate for . It is the case that:
[TABLE]
**Proof: ** See Appendix C, Subsection 8.2.
3.2 Main lemmas
Here we prove the correctness and run-time of the main subroutines used in our algorithm for estimating noise sensitivity. For completeness, we will repeat all the algorithms.
3.3 Lemmas about descending paths hitting influential edges
Here we prove two lemmas that allow the estimation of the probability that a certain descending random walk hits an influential edge. As we mentioned in the introduction, except for the binary search step, the algorithm in Lemma 3.4 is similar to the algorithm in [25]. In principle, we could have carried out much of the analysis of the algorithm in Lemma 3.4 by referencing an equation in [25]. However, for subsequent lemmas, including Lemma 3.5, we build on the application of the Hypercube Continuity Lemma to the analysis of random walks on the hypercube. Thus, we give a full analysis of the algorithm in Lemma 3.4 here, in order to demonstrate how the Hypercube Continuity Lemma (Lemma 2.1) can be used to analyze random walks on the hypercube, before handling the more complicated subsequent lemmas, including Lemma 3.5.
Lemma 3.4
There exists an algorithm that samples edges from so that for every two edges and in :
[TABLE]
The probability that the algorithm succeeds is at least . If it succeeds, the algorithm makes queries, and if it fails, it makes only queries. In either case, it runs in time polynomial in .
Remark: Through the standard repetition technique, the probability of error can be decreased to an arbitrarily small constant, at the cost of queries. Then, the run-time still stays polynomial in , since .
Remark: The distribution outputs is point-wise close to the uniform distribution over . We will also obtain such approximations to other distributions in further lemmas. Note that this requirement is stronger than closeness in norm.
**Proof: ** The algorithm is as follows:
Algorithm (given oracle access to a monotone function and a parameter )
Assign
Pick uniformly at random from .
Perform a descending walk downwards in the hypercube starting at . Stop at a vertex either after steps, or if you hit the all-zeros vertex.
If output FAIL.
If perform a binary search on the path and find an influential edge .
If return . Otherwise output FAIL.
Note that is distributed symmetrically with respect to change of indices. Pick an arbitrary edge in and let , so . Recall that was the set of edges in the same “layer” of the hypercube and that equals .
For any in , and are different only up to a permutation of indexes. Therefore, the probability that passes through equals to the probability of it passing through . Additionally, since is descending it can cross at most one edge in , which implies that the events of crossing each of these edges are disjoint. Thus, we can write:
[TABLE]
But will intersect if and only if . This allows us to express the probability in the numerator as a sum over the layers of the hypercube right above .
[TABLE]
Observation 2.3 allows us to lower-bound and argue that for sufficiently large we have:
[TABLE]
Since , it is the case that . This allows us to use Lemma 2.1 and deduce that . This and Equation (5) allow us to approximate in Equation (4) the following way:
[TABLE]
The algorithm outputs an influential edge if and only if hits an influential edge in . At the same time, these events corresponding to different edges in are disjoint since can hit only at most one influential edge. This together with Bayes rule allows us to express the probability that the algorithm outputs , conditioned on it succeeding:
[TABLE]
Substituting Equation (7) into Equation (6) we get:
[TABLE]
Substituting two different edges and in in place of and then dividing the resulting inequalities gives us:
[TABLE]
From this, the correctness of the algorithm follows. In case of failure, it makes queries and in case of success, it makes queries, because of the additional binary search. In either case, the run-time is polynomial.
Now, regarding the probability of success, note that the events of crossing different edges in are disjoint since the function is monotone. Therefore, we can sum Equation (6) over all edges in and get that the probability of success is at least . Applying Lemma 3.2 and substituting , the inverse of the success probability is:
[TABLE]
The following lemma, roughly speaking, shows that just as in previous lemma, the probability that in hits an influential edge does not depend on where exactly is, as long as it is in . The techniques we use are similar to the ones in the previous lemma and it follows the same outline. However here we encounter additional difficulties for two reasons: first of all, the length of is not fixed, but it is drawn from a probability distribution. Secondly, this probability distribution depends on the starting point of .
Note that unlike what we have in the previous lemma, here comes from the ascending-descending view of noise sensitivity.
Lemma 3.5
For any edge it is the case that:
[TABLE]
**Proof: ** Let , so . We can use the same argument from symmetry as in the proof of Lemma 3.4. We get:
[TABLE]
Above we did the following: Recall that is the event that crosses an edge in . The first equality is true because and can cross at most one influential edge, which implies that cannot happen. For the second equality we substituted the definition of . For the third equality we used the symmetry of with respect to change of indexes just as in the proof of Lemma 3.4.
Recall that we defined:
[TABLE]
This allows us to rewrite:
[TABLE]
Above we just looked at each of the layers of the hypercube and summed the contributions from them.
To prove a bound on we will need a bound on . Observation 2.3 implies that for any we can assume that using which we deduce
[TABLE]
Furthermore, we will need a bound on the binomial coefficients in Equation (8). By picking to be a large enough constant, this allows us to use Lemma 2.1 to bound the ratios of the binomial coefficients. For any between and inclusive:
[TABLE]
Equation (5) is valid in this setting too. Substituting Equation (5) together with Equation (9) into Equation (8) we get:
[TABLE]
Observe that a vertex on the level has more ones than a vertex on level . So for a positive integer , the probability that at least of them will flip is larger. Therefore, . This allows us to bound:
[TABLE]
Then, using Observation 2.3:
[TABLE]
Now, we bound from the other side:
[TABLE]
We bound the first term just as in Equation (12), and we bound the second one using a Chernoff bound:
[TABLE]
[TABLE]
Substituting Equations (14) and (15) into Equation (13) and using Observation 2.3 we get:
[TABLE]
Substituting Equations (16) and (12) into Equation (11) we get:
[TABLE]
Combining this with Equation (10) we deduce that:
[TABLE]
3.4 Sampling descending and ascending paths going through a given influential edge.
While we will use Lemma 3.5 in order to estimate , we will use the machinery developed in this section to estimate in Section 3.5. To that end, we will need to sample from a distribution of descending and ascending paths going through a given edge. The requirement on the distribution is that it should be close to the conditional distribution of such paths that would arise from process , conditioned on going through and satisfying and . See a more formal explanation in the statements of the lemmas.
In terms of resource consumption, the algorithms in this section require no queries to but only run-time. Note that the following simple exponential time algorithm achieves the correctness guarantee of Lemma 3.8 and still does not need to make any new queries to the function: The algorithm repeatedly samples and from the process until it is the case that crosses the given edge and neither nor happen. When this condition is satisfied the algorithm outputs these paths and . The resulting distribution would exactly equal the distribution we are trying to approximate in Lemma 3.8, which is the ultimate goal of the section. The polynomial run-time constraint compels us to do something else. Furthermore, this is the only part of the algorithm for which the polynomial time constraint is non-trivial.
A first approach to sampling would be to take random walks in opposite directions from the endpoints of the edge and then concatenate them together. This is in fact what we do. However, difficulty comes from determining the appropriate lengths of the walks for the following reason. If is longer, it is more likely to hit the influential edge . This biases the distribution of the descending paths hitting towards the longer descending paths. In order to accommodate for this fact we used the following two-step approach:
Sample only the levels of the starting and ending points of the path . This is equivalent to sampling the length of the segment of before the edge and after it. This requires careful use of rejection sampling together with the techniques we used to prove Lemmas 3.4 and 3.5. Roughly speaking, we use the fact that is distributed symmetrically with respect to the change of indices in order to reduce a question about the edge to a question about the layer . Then, we use the Lemma 2.1 to answer questions about random walks hitting a given layer. This is handled in Lemma 3.6. 2. 2.
Sample a path that has the given starting and ending levels and passes through an influential edge . This part is relatively straightforward. We prove that all the paths satisfying these criteria are equally likely. We sample one of them randomly by performing two random walks in opposite directions starting at the endpoints of . This all is handled in Lemma 3.8.
Lemma 3.6
There is an algorithm that takes as input an edge in , so that , and samples two non-negative numbers and , so that for any two non-negative and :
[TABLE]
The algorithm requires no queries to and runs in time polynomial in .
Remark: the approximation guarantee here is similar to the one in Lemma 3.4. It guaranteed that the relative distance should be small point-wise. This guarantee is stronger than closeness in either and norms. We also employ an analogous approximation guarantee in Lemma 3.8.
**Proof: ** Here is the algorithm (recall that we used the symbol to denote the whole layer of edges that have the same endpoint levels as ):
Algorithm (given an edge so )
Pick an integer uniformly at random among the integers in . Pick a vertex randomly at level .
As in phase 1 of the noise sensitivity process, traverse in random order through the indices of and with probability , flip each index that equals to one to zero. The intermediate results form a path , and we call its endpoint .
If does not intersect go to step .
Otherwise, output and .
To prove the correctness of the algorithm, we begin by simplifying the expression above. If , then cannot contain any other influential edge, so cannot happen and we can drop it from notation. Additionally we can substitute the definition for so:
[TABLE]
Now we can use the fact that is symmetric with respect to the change of indices, so we can substitute with any in . Therefore:
[TABLE]
Observation 3.7
The algorithm never returns , which is appropriate since the distribution being approximated is conditioned on . In what follows we consider and . Additionally, recall that is non-negative.
Before we continue, we derive the following intermediate results. Because of how is chosen in , we can use the notation:
[TABLE]
The last equality is true because after picking both process and algorithm pick the path exactly the same way. Therefore, the path is distributed the same way for the both processes if we condition on them picking the same starting point .
We can express:
[TABLE]
Above: (i) The first equality uses the fact that in the level of is chosen uniformly between the levels, and therefore . (ii) The second inequality uses the fact that after picking , both and pick and consequently identically. (iii) The third inequality is an application of the law of conditional probabilities together with the definition of .
Building on the previous equality we have:
[TABLE]
Above: (i) At step (5) of the algorithm, we have and , but this happens only after the condition on step (4) is satisfied. This adds a conditioning at the first equality. (ii) The second equality comes from Observation 3.7 since and , hence starts above and ends below it. Thus, the first two clauses imply the last one, so we drop it. (iii) Regarding the third equality, in the numerator we substituted Equation (19) whereas in the denominator we computed by breaking it into contributions from the levels above . Finally, we canceled from both the numerator and the denominator.
Back to Equation (18). Analogous to how we derived Equation (19), we have:
[TABLE]
In addition to the steps analogous to the ones involved in getting Equation (18), above we used the fact that the layer has vertices out of the vertices overall.
Again, the same way we derived Equation (20) from Equation (19) using Bayes rule, we get:
[TABLE]
In the second equality we dropped the clauses and because by Observation 3.7 they are implied by the first two clauses.
Since by Observation 3.7 it is the case that and , the same way we proved Equation (9) we have:
[TABLE]
Combining Equations (21) and (22) we get:
[TABLE]
Substituting Equations (18) and (20) into Equation (23) proves the correctness of the algorithm.
Now, we consider the run-time. Since and , then . In expectation at least of these indices, which equal to one, should flip. We can use a Chernoff bound to bound the probability of less than of them flipping by . Therefore:
[TABLE]
If this happens, it is sufficient for to be less than for to intersect . The probability of this happening is at least . Therefore, we can conclude:
[TABLE]
Then, the number of time the algorithm goes through the loop is . Thus, the algorithm runs in polynomial time.
Lemma 3.8
There exists an algorithm with the following properties. It takes as input an edge in , so that and outputs paths and together with hypercube vertices and . It is the case that is the starting vertex of , is both the starting vertex of and the last vertex of , and is the last vertex of . Additionally, is descending and is ascending. Furthermore, for any pair of paths and we have:
[TABLE]
It requires no queries to the function and takes computation time polynomial in to draw one sample.
**Proof: ** Below we give the algorithm:
Algorithm (given an influential edge )
Use to sample and .
Perform an ascending random walk of length starting at and call its endpoint . Similarly, perform a descending random walk starting at of length , call its endpoint .
Define as the descending path that results between and by concatenating the two paths from above, oriented appropriately, and edge .
Define just as in phase 2 of our process starting at . Consider in random order all the zero indices has in common with and flip each with probability .
Return ,, , and .
Now, we analyze the algorithm. Without loss of generality we assume that is descending and starts at a vertex and ends at a vertex . , in turn, is ascending, starts at and ends at . For all the other paths all the probabilities in (24) equal to zero. We have that:
[TABLE]
Similarly, we can write:
[TABLE]
By Lemma 3.6 we know that:
[TABLE]
Considering Equations (25), (26) and (27) together, for the lemma to be true, it is enough that:
[TABLE]
Since is in , if then cannot happen. If or both sides are zero. Otherwise, cannot happen either and Equation (28) is equivalent to:
[TABLE]
We first argue that:
[TABLE]
This comes from the fact that in both and the distribution of is symmetric with respect to exchange of coordinates. Now we argue that:
[TABLE]
This is true because given , both and choose the same way. Combining Equation (31) with Equation (30) we get Equation (29) which completes the proof of correctness.
The claims about run-time follow from the run-time guarantee on .
3.5 The noise sensitivity estimation algorithm.
Our algorithm is:
Algorithm for estimating noise sensitivity. (given oracle access to a monotone function f$$:\{0,1\}^{n}\rightarrow\{0,1\})
Using the algorithm from [25] as described in Theorem 5, compute an approximation to the influence of to within a multiplicative factor of (). This gives us .
Compute .
Initialize and . Repeat the following until .
•
Use algorithm from Lemma 3.4 repeatedly to successfully sample an edge .
•
From Lemma 3.8 use the algorithm , giving it as input, and sample , , , and .
•
If it is the case that and , then .
•
.
Set .
Return .
We analyze the algorithm by combining all the lemmas from the previous section. First, we prove that:
Lemma 3.9
It is the case that:
[TABLE]
**Proof: ** Summing Lemma 3.5 over all the edges in we get that:
[TABLE]
Substituting Equation (2) we get:
[TABLE]
With Observation 3.2 this implies the lemma.
Now, we proceed to prove that and are good approximations for and respectively.
Corollary 3.10
With probability at least :
[TABLE]
**Proof: ** From the correctness of the influence estimation algorithm we have that with probability at least :
[TABLE]
Which together with our lemma implies that:
[TABLE]
Definition 10
We call an iteration of the main loop ** successful* if and . We also denote by the probability of any given iteration to be successful.*
In the following two lemmas, we show that is a good approximation to and that , in turn, is a good approximation to . This will allow us to conclude that is a good approximation to .
Lemma 3.11
With probability at least we have that:
[TABLE]
Additionally, the expected number of iterations of the main loop is .
**Proof: ** See Appendix C, Subsection 8.3.
Lemma 3.12
It is the case that:
[TABLE]
**Proof: **
See Appendix C, Subsection 8.4.
Corollary 3.10 with Lemmas 3.11 and 3.12 together imply that with probability at least :
[TABLE]
Combining this with Lemma 3.3 and Equation (3) we get that:
[TABLE]
This proves the correctness of the algorithm. Now consider the number of queries:
- •
Estimating the influence requires queries and polynomial time. Since by Observation 2.3 it is the case that , this is at most .
- •
By Lemma 3.4, successfully sampling an edge requires queries and polynomial time. By Lemma 3.8 for each edge we willl additionally spend a polynomial amount of extra time.
- •
By Lemmas 3.11 and 3.12 we will have iterations of the loop.
Therefore, the overall run-time is polynomial, and the overall number of queries made is:
[TABLE]
Now using Lemmas 3.9 and 3.3 together with Equation (3) it equals to:
[TABLE]
Which is the desired number of queries.
4 Lower bounding the sample complexity.
We begin our proof of Theorems 2, 3 and 4 by first defining the distributions , and to consist of a single function f_{0}$$:\{0,1\}^{n}\rightarrow\{0,1\}:
[TABLE]
And here is chosen so that is the smallest integer larger than for which .
For our lower bounds we will need to show that and ORs of with other functions have useful properties. For this we will need the following lemma. Informally, it says that , and are continuous functions of in the sense that changing a little bit does not change them drastically.
Lemma 4.1
For any monotone function F$$:\{0,1\}^{n}\rightarrow\{0,1\}, denote by the OR of and . Then:
- a)
[TABLE]
- b)
[TABLE]
- c)
For any :
[TABLE]
**Proof: ** See Appendix D, Subsection 9.1.
Lemma 4.2
It is the case that:
- a)
, and hence is also a constant.
- b)
**
- c)
**
- e)
For any , it is the case that .
**Proof: ** See Appendix C, Subsection 9.2.
We will use the two following main lemmas, that we will prove in two separate subsections. The first one is a computational lemma that says that any function family that is “thin” at the level can be transformed into two distributions that are hard to distinguish. By “thin” we mean that they have few positive points at the level right below the threshold of . The second lemma says that there exist function families that are both “thin” in the sense the first lemma requires and have a large amount of bias, influence and noise sensitivity.
Lemma 4.3
Suppose F$$:\{0,1\}^{n}\rightarrow\{0,1\} is a monotone Boolean function with the property that:
[TABLE]
Additionally, suppose is an algorithm that makes queries given access to the following random function:
- •
With probability it is drawn from that consists of only .
- •
With probability it is drawn from that consists of an OR of the following:
- –
The function .
- –
, where is a random permutation of indices.
Consequently, suppose that outputs a guess whether its input was from or . Then has to err with probability more than .
Lemma 4.4
There exist functions F^{B}$$:\{0,1\}^{n}\rightarrow\{0,1\}, F^{I}$$:\{0,1\}^{n}\rightarrow\{0,1\} and for every there exists F^{\delta}$$:\{0,1\}^{n}\rightarrow\{0,1\} such that:
- •
Any in has the property that:
[TABLE]
- •
.
- •
.
- •
For any , it is the case that:
[TABLE]
Recall that we defined , and to be composed of only the function . Now we also have functions that are thin and have large bias, influence and noise sensitivity. Therefore, we use them to define distributions we can use with Lemma 4.3:
- •
as the OR of and . Where, recall, is a random permutation of indices.
- •
as the OR of and .
- •
For each , we define as the OR of and .
Observation 4.5
Permuting the indices to an input of a function preserves its bias, influence and noise sensitivity. That, together with Lemma 4.1 and Lemma 4.4, implies that:
- a)
For any in , we have .
- b)
For any in , we have . The last equality is true because .
- c)
For all and for all in :
[TABLE]
Here, again, the last equality is true because
Now, we are ready to prove our main theorems. Let us first consider the case of estimating the bias. We will prove it by contradiction, showing that the negation of Theorem 3 implies we can reliably distinguish two distributions that Lemma 4.3 prevents us from distinguishing. Suppose is an algorithm, taking as input a monotone function and with probability at least distinguishing whether (i) has a bias of or (ii) has a bias of at least . For the sake of contradiction, assume that it makes queries.
By Lemma 4.2 every function in has a bias of and by Observation 4.5, the bias of every function in is at least . Therefore, can distinguish between them with probability at least making . But by Lemma 4.3, such an algorithm has to err with probability more than . We have a contradiction and Theorem 3 follows.
Theorems 4 and 2 follow analogously.
4.1 Proof of Lemma 4.3
Suppose is an adaptive algorithm that makes at most queries and distinguishes a random function in from . We denote the number of queries it makes as . Without loss of generality, we assume that it always makes precisely queries. The algorithm is adaptive and in the end it outputs or . Then, the probability that the algorithm correctly distinguishes equals:
[TABLE]
We call the difference above the distinguishing power of .
Observation 4.6
For any in it is the case that if , then . Therefore, without loss of generality we can assume that never queries any point in that region.
Observation 4.7
If is randomized, we can think of it as a probability distribution over deterministic algorithms. The distinguishing powers of then will be the weighted sum of the distinguishing power of the deterministic algorithms, weighted by their probabilities. Therefore, the distinguishing power of the best of these deterministic algorithms is at least that of . Thus, without loss of generality we can assume that is deterministic.
Now, since is deterministic and it makes queries, it can be represented as a decision tree of depth . At each node, queries a point and proceeds to the next node. In the end, after queries, the algorithm reaches a leaf and outputs the label of the leaf, namely or . We can divide this decision tree into two regions:
- •
A path that the algorithm takes if at every query it receives zero.
- •
The rest of the decision tree. We call this region .
By Observation 4.6 and the definition of , when the algorithm is given access to a member of , namely , all the points that it queries will have . Therefore, the algorithm will follow the path on the decision tree and end up on the single leaf there.
Suppose now the algorithm is given access to a function in . There are two cases:
- •
All the queries it makes, will have . Then, on the decision tree it will follow the path and end up at the single leaf on it.
- •
After making query for which , the algorithm ends up in the subset of the tree we call . We call the probability that this happens .
If the single leaf in is not labeled with , then the algorithm will always err, given access to . Similarly, the algorithm can reach a leaf in only if it was given access to . Thus, labeling all such leaves with can only increase the distinguishing power. Therefore, without loss of generality, we assume that this is the labeling used in . Then, the distinguishing power equals .
The following lemma shows that we can assume that the algorithm is non-adaptive and only makes queries on the level .
Lemma 4.8
There exists an algorithm that satisfies all of the following:
- •
It is deterministic and non-adaptive.
- •
Its distinguishing power between and is at least .
- •
Just as it makes queries. We call them .
- •
For each of these , it is the case that .
**Proof: ** Consider the queries that makes along the path . Call them . We define as an arbitrary point that satisfies (i) and (ii) . At least one such point has to exist since .
The algorithm queries each of these and returns if for at least one of them . Otherwise it returns .
Since and the functions are monotone, whenever , then . At least one of equals one with probability , and therefore at least one of equals one with probability at least .
Thus, has a distinguishing power of at least . This implies that the distinguishing power of is at least that of .
Now, we can bound the distinguishing power of , which we call . We have:
[TABLE]
Above we used (i) a union bound and the fact that by Lemma 4.8, the algorithm is non-adaptive (ii) The fact that by definition . Recall that is the random permutation was permuted with. (iii) For any constant , is uniformuly distributed among the vertices with the same level. (iv) Lemma 4.8 together with the condition on the function .
Therefore, we get that:
[TABLE]
Since , then has to be less than . Since is at most by Lemma 4.8, then also has to be less than . This proves the lemma.
4.2 Proof of Lemma 4.4
Consider the distribution888There are two differences between this distribution and Talagrand random functions: (i) Here we choose clauses, whereas Talagrand functions have just clauses. (ii) In Talagrand functions the indices in each clause are sampled with replacement, whereas here we sample them without replacement. of functions, which is OR of AND clauses of uniformly and independently chosen subsets of indices, chosen without replacement. We will prove that:
- a)
Any in has the property that:
[TABLE]
- b)
.
- c)
.
- d)
For any , it is the case that:
[TABLE]
Then, the corresponding claims of the lemma will follow by an application of the probabilistic method. We have divided into subsections the proofs of the claims above.
4.3 Proof of (a)
Here we treat the clauses as fixed and look at the probability over the randomness of choosing to satisfy any of them. For a given clause, the probability that will satisfy it equals:
[TABLE]
In the very end we used that by Lemma 4.2 it is the case that .
Now, that we know the probability for one clause, we can upper-bound the probability satisfies any of the using a union bound. This gives us an upper bound of .
4.4 Proof of b)
It is the case that:
[TABLE]
If we fix a value of for which , and randomly choose a single AND of indices, the probability that it evaluates to one on is:
[TABLE]
Then, since we have clauses and they are chosen independently:
[TABLE]
This implies that .
4.5 Proof of c)
We have that:
[TABLE]
The probability of an event is the expectation of its indicator random variable. Using this twice, gives us the second equality above.
From Hoeffding’s inequality, it follows that with probability at least it is the case that . From this and Equation (32) it follows:
[TABLE]
Now we will lower-bound for any , for which . Name the clauses in as . For any clause we have:
[TABLE]
And since :
[TABLE]
This implies that:
[TABLE]
For every , so that , consider the following sequence of events, which we call :
- •
satisfies . By Equation (34) the probability of this happening is .
- •
does not satisfy all the other clauses. Since they are are chosen independently, by Equation (34) we have that the probability of this is , which is at least .
- •
is one of the inputs that are relevant to . The probability of this is .
Since these three events are independent:
[TABLE]
If happens, then . Additionally for different values of , the are disjoint and the probability of is the same for all by symmetry. Thus we have:
[TABLE]
Combining Equations (33) and (35):
[TABLE]
4.6 Proof of d)
Recall that in the definition of noise sensitivity, is chosen uniformly and is chosen by flipping each bit of with probability . We have:
[TABLE]
Consider the following three “good” events, which are similar to the ones introduced in [18] to analyze the noise sensitivity of Talagrand random functions:
- •
is when . By Hoeffding’s inequality, its probability is at least .
- •
is when . Since is also distributed uniformly, its probability is also at least .
- •
Denote by the set of indices for which . By the definition of noise sensitivity, in expectation of them become zero in . The event happens when at least of them are zero in . By the Chernoff bound, the probability of this is at least .
By a union bound, with probability at least all the events , and happen. Therefore:
[TABLE]
Now, suppose we are given values of and that satisfy , we will lower bound . Using and , just as in the proof of equation (5), we have that for any clause :
[TABLE]
Now, analogous to how we lower bounded the expected influence while proving part c), consider the following sequence of events, which we call :
- •
satisfies . By Equation (38), the probability of this is at least .
- •
All the for are unsatisfied by both and . By Equation (38) and a union bound, for each individual clause the probability of being unsatisfied by both and is at least . By independence, the probability of the overall event is at least , which is at least .
- •
Given that satisfies , it happens that at least one of the coordinates relevant to is zero in . We call the probability of this happening .
The third event is conditioned on the first one, so the probability that both happen equals to the product of their probabilities. In addition, The first and third event depend only on the randomness in choosing , and the second event only on the randomness in choosing all the other clauses. Therefore the second event is independent from the first and third, and thus:
[TABLE]
We now lower-bound . Because of , at least of the indices in become zero in . Let be the set of indices relevant to . Since they were chosen uniformly at random then, conditioning on being satisfied, has equal probability of being any subset of of size . Therefore, the probability that at least one of them ends up among the indices in that become zero in :
[TABLE]
Combining this with Equation (39), we get:
[TABLE]
We now combine (i) Equation (37) (ii) The fact that if happens then (iii) The fact that the different are disjoint and the probability of is the same for all by symmetry (iv) Equation (40):
[TABLE]
5 Acknowledgments
We are grateful to the anonymous referees for helpful comments and suggestions.
6 Appendix A
In this section we use Fourier analysis of boolean functions. We will use the notation of [22].
The following lemma is very similar to a statement from [18]:
Lemma 6.1
For any function f$$:\{0,1\}^{n}\rightarrow\{0,1\} and a parameter it is the case that:
[TABLE]
**Proof: ** We will use the Fourier expressions for both of the above (see [22]):
[TABLE]
We can now use Bernoulli’s inequality . Therefore:
[TABLE]
This completes the proof.
Lemma 6.2
For a fixed function f$$:\{0,1\}^{n}\rightarrow\{0,1\} and for values of satisfying , is an increasing function of .
**Proof: ** This follows immediately from the Fourier formula for noise sensitivity.
7 Appendix B
Recall that standard sampling approach requires queries to estimate noise sensitivity. Here we will show that for sufficiently small constant , the standard sampling algorithm is optimal up to a constant for all values of .
For any we define to be the uniform distribution over all functions for which it is the case that .
Lemma 7.1
For any sufficiently large , any , satisfying and any , satisfying , it is the case that:
[TABLE]
**Proof: ** implies that , hence:
[TABLE]
Since , we have that:
[TABLE]
Additionally, we have:
[TABLE]
Combing equations (41), (41) and (43), we get:
[TABLE]
At the same time, for sufficiently large we have that:
[TABLE]
Now, we will bound the variance. We have:
[TABLE]
We have the following three facts:
For arbitrary , , and , we have
[TABLE] 2. 2.
Suppose we further given that no two of and are equal to each other. We call this event . If is the case then
[TABLE] 3. 3.
If and are picked independently from conditioned on and , then happens unless or or or . By independence and a union bound, the probability of any of these happening is at most .
Therefore:
[TABLE]
Combining this with (44) and (46) we get a bound for the variance:
[TABLE]
(48) implies that has standard deviation of at most . Since , this standard deviation of is at most . By Chebyshev’s inequality, is within of its expectation with probability . Together with equations (44) and (45) this implies the statement of the lemma.
Theorem 6
For any sufficiently large , any satisfying and any satisfying , let be an algorithm that given access to a function f$$:\{0,1\}^{n}\rightarrow\{0,1\} with probability at least outputs NO if it is given access to a function f$$:\{0,1\}^{n}\rightarrow\{0,1\}, satisfying
[TABLE]
and with probability at least outputs YES, given a function satisfying:
[TABLE]
Then, there is a function given which makes queries.
**Proof: ** Consider distributions and . One needs queries to distinguish between them with any constant probability. Both values and are within the scope of Lemma 7.1. Therefore, from Lemma 7.1 it is the case that:
[TABLE]
[TABLE]
Since is correct with probability at least , by a union bound it will distinguish between a random function from and with probability at least . But one needs at least queries to distinguish them. This implies the lower bound on the number of queries makes.
8 Appendix C
8.1 Proof of Lemma 2.1
We distinguish three cases:
2. 2.
3. 3.
.
We first prove the case 1. Since here , the left inequality is true. We proceed to prove the right inequality. So, for sufficiently large :
[TABLE]
This completes the proof for case 1. We note that this method of bounding the product above was inspired by the proof in [25]. There it was used to bound probabilities of random walks directly, whereas we are using it to proof this Continuity Lemma first and then apply it later for random walks.
Now, we derive case 3 from it. Suppose , then, which gives us the inequality on the right. To prove the left one, define and . and will satisfy all the requirements for case 1, thus we have:
[TABLE]
This implies:
[TABLE]
This completes the proof for case 3. For case 2, together cases 1 and 3 imply that the following are true:
[TABLE]
Multiplying these together, we show the lemma in case 2.
8.2 Proof of Lemma 3.3
Recall that and , which implies the left inequality. We now prove the right one. We have:
[TABLE]
By Chernoff bound we have:
[TABLE]
Now using the Hoeffding bound together with the fact that since we have :
[TABLE]
Thus, combining Equations (49) and (50) with Observation 2.3 we have:
[TABLE]
Combining Equations (49) and (52) we get:
[TABLE]
Since and , this implies the lemma.
8.3 Proof of Lemma 3.11
Recall that the probability of any given iteration to be successful is . We can upper-bound the probability that the inequality fails to hold by the sum of probabilities the two following bad events: (i) after iterations there are more than successes. (ii) after iterations there are less than successes.
By Chernoff bound:
[TABLE]
[TABLE]
This proves the correctness.
To bound the expected number of iterations, we first observe that from a similar Chernoff bound, after iterations with probability at lest we exit the main loop. Each further time we make the same number of iterations, the probability of exiting only increases. This implies that the expected number of iterations is .
8.4 Proof of Lemma 3.12
Recall that by Equation (3):
[TABLE]
By Lemma 3.5:
[TABLE]
Dividing this equation by the equation in Lemma 3.9 and substituting :
[TABLE]
Now applying Observation 3.2 :
[TABLE]
Define to be the set of pairs of paths for which the following hold:
- •
is a descending path and is an ascending path.
- •
The endpoint of is the starting point of .
- •
The value of at the starting point of is one, and it is zero at the endpoint of .
If and only if is in , we have that , therefore these are the only paths contributing to .
Using this definition, we have:
[TABLE]
[TABLE]
Combining Equation (55) and Lemma 3.8 we get:
[TABLE]
Now, if in Lemma 3.4 we fix an and sum over in we get that for all :
[TABLE]
Combining Equation (54) with Equation (56) and Equation (57) we get:
[TABLE]
Equations (53) and (58) together imply the lemma.
9 Appendix D
9.1 Proof of Lemma 4.1
If we make the function equal to one on inputs it possibly equaled zero, the bias of the function cannot decrease. Additionally, can be constructed from by changing less than fraction of its points. Such a transformation cannot increase the bias by more than . This proves (a).
Regarding (b) and (c), we start we the following observation: suppose only one point of an arbitrary function is changed. By union bound the probability for a randomly chosen that either or is at most . Therefore, the probability that cannot change by more than . This implies that the influence cannot change by more than .
Regarding noise sensitivity, the situation is analogous. For any , the probability that any of and equals , on which the value of the function is changed, is at most by a union bound. Therefore, cannot change by more than .
Using the observation and a triangle inequality we get:
[TABLE]
[TABLE]
This completes the proof of (b) and (c).
9.2 Proof of Lemma 4.2
Now, we proceed to proving (a). By our condition on , it has to be the case that:
[TABLE]
Then, by Hoeffding’s bound, it is the case that:
[TABLE]
And therefore, , which proves (a).
Since is an integer, then equals one if and only if . Therefore, we can rewrite Equation (59) as:
[TABLE]
Additionally, for sufficiently large we have:
[TABLE]
Above, we used the fact that is at most a constant. Combining Equations (60) and (61) we get that for sufficiently large :
[TABLE]
This together with the fact that , proves (b).
Consider (c) now. We have that:
[TABLE]
This implies that:
[TABLE]
At the same time, given that , if one flips an index for which , then it will result that . And since the number of such indices is at least half:
[TABLE]
This proves the left inequality in (c). The right inequality is also correct, because it follows from Lemma 4.1 by picking to be the all-zeros function. Thus, (c) is true.
Regarding noise sensitivity, a known lemma (stated in Appendix A as Lemma 6.2) implies that noise sensitivity is an increasing function of . Therefore, it is enough to consider . Then, for any , if we flip each index with probability , the probability that overall exactly one index will be flipped equals . Additionally, given that only one index is flipped, it is equally likely to be any of the indices. Therefore, we can lower-bound the noise sensitivity:
[TABLE]
Together with (c), this implies the left inequality in (d).
Regarding the right inequality, it follows from Lemma 4.1 by picking to be the all-zeros function. Thus, (d) is true.
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] Maria-Florina Balcan, Eric Blais, Avrim Blum, and Liu Yang. Active property testing. In Foundations of Computer Science (FOCS), 2012 IEEE 53rd Annual Symposium on , pages 21–30. IEEE, 2012.
- 2[2] Aleksandrs Belovs and Eric Blais. A polynomial lower bound for testing monotonicity. In Proceedings of the forty-eighth annual ACM symposium on Theory of Computing , pages 1021–1032. ACM, 2016.
- 3[3] Itai Benjamini, Gil Kalai, and Oded Schramm. Noise sensitivity of boolean functions and applications to percolation. Publications Mathématiques de l’Institut des Hautes Études Scientifiques , 90(1):5–43, 1999.
- 4[4] Eric Blais, Ryan O’Donnell, and Karl Wimmer. Polynomial regression under arbitrary product distributions. Machine learning , 80(2-3):273–294, 2010.
- 5[5] Deeparnab Chakrabarty and Comandur Seshadhri. An o(n) monotonicity tester for boolean functions over the hypercube. SIAM Journal on Computing , 45(2):461–472, 2016.
- 6[6] Xi Chen, Rocco A Servedio, and Li-Yang Tan. New algorithms and lower bounds for monotonicity testing. In Foundations of Computer Science (FOCS), 2014 IEEE 55th Annual Symposium on , pages 286–295. IEEE, 2014.
- 7[7] Mahdi Cheraghchi, Adam Klivans, Pravesh Kothari, and Homin K Lee. Submodular functions are noise stable. In Proceedings of the twenty-third annual ACM-SIAM symposium on Discrete Algorithms , pages 1586–1592. Society for Industrial and Applied Mathematics, 2012.
- 8[8] Ilias Diakonikolas, Prasad Raghavendra, Rocco A. Servedio, and Li-Yang Tan. Average sensitivity and noise sensitivity of polynomial threshold functions. SIAM J. Comput. , 43(1):231–253, 2014.