Univariate Skip
Here, we begin in earnest our treatment of vanishing claims. As we've mentioned elsewhere, the main complication at hand is that the polynomials we want to verify the vanishing of are defined over small fields. In this page we sketch Binius's zerocheck variant, which is designed to exploit precisely this small-field situation. The theoretical ideas of this page largely come from Gruen [Gru24].
Algorithms for sumcheck and zerocheck are extremely complicated in general (especially in the small-field setting), and we can only hope to give a very rough survey in this page. As usual, here, we adopt the verifier's point of view, and sketch the security story. Of course, using a univariate zerocheck—as opposed to a standard one—serves to lighten rather the prover's load, and not the verifier's; so our motivation cannot be purely verifier-centric. For the full details, we opt to defer to the Binius codebase.
As we've repeatedly mentioned, the multivariate composition polynomials we're interested in zerochecking are, in general, defined over small fields. This fact makes the 0th round of the zerocheck special, in that much of the computation required by that round may be carried out over an appropriate small field. In the zerocheck's positive-indexed rounds, on the other hand, the polynomials at hand "saturate" to the maximal field size—and many of the small-field advantages disappear.
The univariate skip is designed to trade off 0th-round computation for positive-round computation. That is, the univariate skip serves to move as much work as possible into the 0th round; it vastly reduces, in the process, the amount of work which must be performed in the subsequent, positive-indexed rounds.
The Standard Zerocheck
As always, we are going to fix an -variate composite polynomial ; our goal is to check that for each . As usual, we will obtain itself from underlying -variate multilinears , by subjecting those multilinears to some -variate composition polynomial .
In the basic zerocheck, we wind up sumchecking the multivariate product . The 0th round is special: since the multilinears have small coefficients, their evaluations within the cube itself—as well as on nearby points of the form , say, where the trailing coordinates are boolean—will themselves be small. By consequence, evaluating the composition on these points (the main "workhorse" task of the zerocheck) will be very efficient.
On the other hand, after a single folding round goes by, this advantage will disappear. Indeed, the partially specialized multilinears will no longer have small coefficients; neither, therefore, will their evaluations at points of the form , where is small and the trailing coordinates are boolean. Thus, evaluating on tuples of these evaluations will stop being efficient. We thus see that we only get to reduce the problem size by 2 before the small-field efficiency advantage all-but disappears.
The Basic Idea
The basic idea is to "reshape" our fundamental domain into another domain, which has just as many points (that is, of them) but which is much "longer" in its 0th dimension. The goal will be to get more work out of the way in the 0th round (which we've already seen is special). That is, instead of reducing by just half our problem size during the course of the 0th round, we will rather want to reduce it by -fold, for some parameter generally bigger than 1.
Thus we fix a skipping parameter (in practice, will be around 7). We are going to pick a univariate domain in our huge field of size . (In practice, we will moreover want to be an -subspace of .) Our fundamental domain will be , now viewed as a subset of . Note that this thing's size is exactly .
We—that is, both the prover and the verifier—are now going to simply "pretend" that the initial multilinears , and so also the composite , were defined to begin with on , instead of on . This isn't a problem, conceptually: since our initial multilinears essentially amount to lists of elements, we can always decide to identify these lists with instead of with . Thus, instead of multilinears , we now have polynomials of degree less than in and linear their subsequent variables. The defining property of these rectangularizations is that for each ,
as -variate multilinears. Here, we write for a the natural injection which sends (here, is an -basis of ).
Just as -variate multilinears are exactly captured by their values on , so too are polynomials of this degree profile exactly captured by their values on . By applying the usual composition polynomial to the rectangularized underlying polynomials , we get a rectangularized composition polynomial . Since takes the same values on that does on , it's enough to check that vanishes identically on .
What is the point of moving the goalposts like this? It turns out that the standard zerocheck and sumcheck protocols have variants for rectangular domains, which are moreover more efficient than the standard procedures are in the small-field setting.
The Rectangular Zerocheck
We've already seen that a multivariate polynomial vanishes identically on the cube if and only if its multilinear extension vanishes everywhere. Here, we are going to use an analogous idea, adapted to the rectangular setting. We write for the bivariate equality indicator polynomial on the domain . That is, is the unique polynomial whose restriction to is the equality indicator function, and which moreover is of individual degree less than in both and .
We want to check whether the rectangularized composite polynomial vanishes identically on . To do this, we can rather consider its low-degree extension : that is, the unique polynomial which agrees with identically on , but which is moreover of degree less than in and multilinear in its other variables. Exactly as in the classical zerocheck, we note that vanishes identically on if and only if vanishes everywhere on . Thus, it's complete and sound for the verifier to sample a random point , and check whether .
We get an expression for in the following way:
Specializing this thing to , we see that it's enough to run a rectangular sumcheck on the product polynomial
That is, it's enough for the verifier to check whether the sum of this thing over the domain equals 0 or not.
The protocol for this exactly follows the script of the normal sumcheck. In particular, the prover will start by sending the 0th univariate round polynomial
The verifier will first check that holds. Then, the verifier will sample , and update its running sum claim to , and send to the prover. Finally, the prover will locally specialize the indeterminate of its underlying polynomials to , and fold everything. From that point onwards, things will look essentially like a normal zerocheck.
Efficiency Gains
The prover's round polynomial is univariate of degree at most , where is the total degree of the composition polynomial . The prover can send it to the verifier by specifying its evaluations on more than points.
In fact, will in fact vanish identically on , since vanishes on . The prover can thus just refrain from sending 's evaluations on at all. Similarly, the verifier can implicitly "backfill" to be 0 on , and skip its check .
As the prover computes for various points , the prover will need to repeatedly evaluate the composition on evaluations of the form . (Here, the suffix is boolean, while is a relatively small element—it lives in some extension of the domain , roughly -fold the size of .) And here, we get to the key efficiency point: if the s' coefficients are small, then so too will be the s' evaluations at points of the form . Thus the bulk of our work—namely, repeatedly evaluating —will take place over a small field. Moreover, we get to knock out "rounds' worth" of work in this way, instead of just one. By the time the univariate skip ends, the polynomials we're left with will be just th the size they were when we started, a huge efficiency gain.