(Problem 1.) You are trying to determine a secret integer x between 1 and n inclusive, using only queries of the form “is x = a (mod b)?” for integers a and b of your choosing. How many queries are required to determine x in the worst case?

And more restrictively,

(Problem 2.) Same as above but you are only allowed to make queries where b is prime.

The comments section seems to reveal at least a partial solution, but these are fun problems, so at least give them a shot before reading the solution there (or here.) If you’d like the solution spoiled anyway, read on!

First let’s talk about a problem that has a more intuitive solution. Namely, the same problem of finding an integer between 1 and n, but where we are allowed to ask questions of the form “is x ≤ a?” for our choice of integers a.

Computer scientists in the audience should recognize the solution: first, find out about the midpoint. That is, whether x ≤ n/2. Whatever the answer is, we split the search space in half! That is, we originally knew that x must be one of n values. After the first query, we know that x must be one of n/2 values: either 1 ≤ x ≤ n/2 or n/2 < x ≤ n. Either way, we can simply repeat the process again! After the second query, we know it must be one of n/4 values. And so on. For example, for 1 ≤ x ≤ 8, the following sequence of questions would reveal that the answer is x = 3.

It should be easy to convince yourself of the fact that you can only make these divisions lg(n) (that’s log-base-2*) times before you determine x.

Furthermore, this is the best we can do: any algorithm that finds x using only true/false queries requires at least lg(n) queries in the worst case. Why? Essentially, because this is how many bits there are in the binary expansion of x. Take n = 8 for example. If you could determine any 1 ≤ x ≤ 8 using only two queries in the worst case, then any such x could be written uniquely using only 2 bits, which is impossible.

But let’s go back to Problem 1. Notice that the above argument applies for any algorithm that may only make queries about x whose answers are boolean. So we may immediately say that at least lg(n) queries are required by any algorithm that solves it.

However, is the answer again exactly lg(n)? Our binary search problem had the “nice” property that no matter what the answer to our previous query was, we could always construct another query that cut the search space in half again. Any boolean query may be thought of as a filter that eliminates a certain portion of the search space (which here is simply the set {1, 2, …, n}.) But not all queries may have this nice property. For example, if we were only allowed to ask questions of the form “is x = a?” then we would need to ask n – 1 questions in the worst case—because no matter in what order we guess numbers, our first n – 1 guesses could be wrong.

It turns out that the queries in Problem 1 do indeed have this nice property. The algorithm works like so:

1. Ask whether x = 0 (mod 2). Doing so cuts the search space in half.
2. If the answer above was Yes, then ask whether x = 0 (mod 4). Since the previous answer was Yes, it must be the case that either x = 0 (mod 4) or x = 2 (mod 4), and the answer to this query again cuts the search space in half.
3. If the answer above was No, then ask whether x = 1 (mod 4). From the same reasoning as above, we again cut the search space in half.
4. Repeat the process using mod 8, 16, 32, etc., crafting the appropriate query.

It shouldn’t be too hard to find the correct question to ask in each case. As an example,

This process can always be completed in lg(n) queries, which is the answer to Problem 1.

Note, however, that we always use a modulus of the form , so this solution doesn’t help us solve Problem 2, where the modulus must always be prime! Don’t panic; I will discuss a solution to this problem in my next blog post.

* Here I’m assuming that n is a power of 2 to make the formula simpler, but if it isn’t then the correct answer is simply the ceiling of lg(n). That is, round lg(n) up. In fact, whenever I write lg(n) you can assume this is what I mean.

I think, in a sense, we are the accelerators. As we smash ideas together sometimes we discover the further structure of our fundamental particles—our complexity classes.

Duuuuude.

The content of the theorem relates to what strength of pseudo-randomness is “good enough” to fool circuits of a significantly limited size and depth into thinking the pseudo-randomness is truly random. As an analogy, the D in HD video is becoming ever and ever more H (currently we’re up to a resolution of 7680×4320) but our brains have a finite capacity and our eyes aren’t perfect lenses. Increase the resolution high enough, and eventually we won’t be able to tell the difference between the HD video signal and a “true” view of the world. Similarly, we’d like to know whether certain limited models of computation can tell apart real randomness from approximate randomness.

The Linial-Nisan conjecture restricts us to logical circuits used to compute answers to decision problems/boolean functions F¹ made up of AND, OR and NOT gates², where the number of gates is allowed to be polynomial in size³  but the depth of the circuit must remain constant across all instances.

This class of circuits is called AC⁰, and these conditions are more restrictive than they first seem. You might point out that any boolean function whatsoever can be computed by a depth-2 circuit (for example, in disjunctive normal form.) And that’s true, but the number of gates then required might be superpolynomial in size. For example, even doing something as relatively simple as computing the parity of n bits cannot be done in AC⁰—you either need to increase the depth of the circuit as the problem grows in size, or have access to more complicated gates, or use more than a polynomial number of gates.

The question, then, is what kind of probability distributions over {0,1}ⁿ look identical to the uniform distribution to AC⁰ circuits. In particular, the Linial-Nisan conjecture asks about distributions that are uniform when you restrict them to any k < n bits, but are no longer uniform as a whole. For example, consider  chosen uniformly, and . The last variable is determined entirely by the others so the n bits as a whole aren’t uniformly random, but if you pick any k = n-1 bits at a time you do get a uniform distribution. Do such distributions look uniform to AC⁰ circuits? And if so, how small can k be? (Imagine a distribution half of whose bits are determined by the others. Can such a fundamentally non-random distribution be detected by an AC⁰ circuit?)

Mark Braverman proved that k can be very low indeed. It need only be polylogarithmic (for example, of order for depth-2 circuits, in m being the number of gates.) In general, the exponent is quadratic in the depth to which we restrict ourselves. Asymptotically, this is tiny! And many suspect this bound is still too high, as suffices for depth-2 circuits, leading to the suspicion that the tight bound is .

How does Braverman prove this result? He constructs low-degree polynomials that sufficiently approximate and “sandwich” the function F in question (think of the squeeze theorem from your Calculus 1 days), which was previously known to be sufficient to prove the result.

The first kind of approximating polynomials are due to Linial, Manser and Nisan way back in 1993. These LMN polynomials are created by taking the canonical, polynomial expansion of the function (for example, by interpolation) and simply chopping off the high-order terms. Such polynomials approximate F very well on average, but may not be equal to F at many, if any points. In other words, there is a small distance between them.

LMN approximation (red) to a boolean function F (black)

The second kind of approximation is due to Razborov and Smolensky. This time, the approximating polynomial agrees with the function F on most inputs, but it may behave wildly wherever it doesn’t.

Razborov-Smolensky approximation (blue) of the same function

(In fact, the jumpiness in the blue graph can be far more wild than the picture suggests, making it an awful approximation at these points.) At any rate, neither of these approximations behave quite the way we want them to. What we’d like is a low-degree approximation of F that agrees with it on most inputs (as in the blue approximation) and doesn’t stray too far away when it doesn’t (as in the red approximation.)

What Braverman discovered is that although the blue approximation can be very, very wrong at some points, this error can be checked in AC⁰! In particular, there’s a AC⁰ function ε that takes on the value 1 whenever the blue approximation disagrees with F (and possibly at some other points that give false positives, but not too many.) This function ε tells us when we need to correct the blue approximation. Then, Braverman applies the red, wavy approximation to ε and takes its negation, giving us a low-degree polynomial which (nearly) vanishes whenever the blue approximation is inaccurate.

Approximation of 1-ε (orange)

Then he just multiplies the blue and orange functions together to create a new approximation! Doing this kills the blue guy whenever he misbehaves, resulting in a polynomial that approximates F in the nice ways we wanted, and which is still of low-enough degree to be usable.

That’s pretty much all there is to it! All that’s left to do is to fill in the gaps with some algebraic magic, and the claim is proved. Not bad at all.

¹ For example, is x prime? Or, does the input graph have a vertex of degree 5?
² We allow the AND and OR gates to take any number of inputs, rather than only two.
³ For example, the circuit that computes the answer for inputs of size n could have n¹³ gates.