Problem: Alice chooses a secret polynomial with nonnegative integer coefficients. Bob wants to discover this polynomial by querying Alice for the value of for some integer of Bob’s choice. What is the minimal number of queries Bob needs to determine exactly?
Solution: Two queries. The first is , and if we call , then the second query is .
To someone who is familiar with polynomials, this may seem shocking, and I’ll explain why it works in a second. After all, it’s very easy to prove that if Bob gives Alice all of his queries at the same time (if the queries are not adaptive), then it’s impossible to discover what is using fewer than queries. This is due to a fact called polynomial interpolation, which we’ve seen on this blog before in the context of secret sharing. Specifically, there is a unique single-variable degree polynomial passing through points (with distinct -values). So if you knew the degree of , you could determine it easily. But Bob doesn’t know the degree of the polynomial, and there’s no way he can figure it out without adaptive queries! Indeed, if Bob tries and gives a set of queries, Alice could have easily picked a polynomial of degree . So it’s literally impossible to solve this problem without adaptive queries.
The lovely fact is that once you allow adaptiveness, the number of queries you need doesn’t even depend on the degree of the secret polynomial!
Okay let’s get to the solution. It was crucial that our polynomial had nonnegative integer coefficients, because we’re going to do a tiny bit of number theory. Let . First, note that is exactly the sum of the coefficients , and in particular is larger than any single coefficient. So call this , and query . This gives us a number of the form
And because is so big, we can compute easily by computing . Now set , and this has the form . We can compute modulus again to get , and repeat until we have all the coefficients. We’ll stop once we get a that is zero.
As a small technical note, this is a polynomial-time algorithm in the number of bits needed to write down . So this demonstrates the power of adaptive queries: we get from something which is uncomputable with any number of queries to something which is efficiently computable with a constant number of queries.
The obvious follow-up question is: can you come up with an efficient algorithm if we allow the coefficients to be negative integers?