Exponentiating Multilinears
In this page, we explain a generic mathematical technique that exponentiates a variable base by a variable exponent pointwise on the cube. That is, we explain how to algebraically relate the multilinear extension of this exponentiation to the multilinear extensions of the base and the exponent. This protocol is the technical core of our multiplication protocol. In the next page, we apply this protocol to our situation.
We fix an -variate multilinear with values in , and an -valued, oblong-multilinear exponent function . As a notational device, we write for each and each . For each , we define by combining 's bits on :
When is a constraint array and its oblong-multilinearization, this condition indeed holds.
We define the exponentiated multilinear by specifying its values on the cube. For each , we set:
In this page, our goal will be to efficiently reduce an evaluation claim on to evaluation claims on and . This problem is tricky, since doesn't depend algebraically on and (the exponentiation operation is not algebraic).
The Product Decomposition
We first express pointwise on the cube as a product of 64 individual multilinears. Indeed, for each ,
We thus define
for each , and let be its multilinear extension.
Our treatment from this point onwards has two phases. First, we reduce an evaluation claim on to evaluation claims on the individual multilinears . After that, we reduce claims on the to claims on and .
The GKR Step
To reduce a claim on to claims on the , the parties could directly multilinearize the expression for above and run a sumcheck. The resulting sumcheck would be of a multilinear of individual degree 64 (excluding the equality indicator), which is very large.
Instead, we use GKR. We array the 64 multilinears , for , into the leaves of a balanced binary tree of height 6. Each internal node is defined to be the product of its children, pointwise on the cube.
Notationally, we index the layers as . In the leaf layer , for each , we let
For each intermediate layer and each , we let
We claim that our original multilinear and the resulting root multilinear are identical, as multilinears. Indeed, it's enough to note that, for each , each , and each , , and use induction.
We fix an initial evaluation claim . To assess it, the parties can run the following GKR loop:
- for each tree layer do:
- for each do: verifier samples , and sends it to the prover.
- the parties run a batched sumcheck on the claim: which pertains to a composition of multilinears of degree just 2 (excluding the equality indicator).
- in this way, after rounds, reduce the claim above to the further claim: where is a further -dimensional challenge sampled during the sumcheck.
- for each do: the prover sends the claimed evaluation .
- using the prover's claims , the verifier explicitly checks the equation just above.
- output the reduced evaluation point and the reduced claims , for .
The security analysis of this protocol is just standard GKR and batched sumcheck. The invariant of the loop is that, as of the beginning of each iteration , we have reduced the initial evaluation claim to the list of individual evaluation claims , for . By the usual batched sumcheck, the validity of these claims, individually, is implied—up to soundness error —by the validity of the sum claim that the parties check. The sumcheck's soundness analysis reduces this claim in turn, with soundness error just , to the validity of the prover's claimed evaluations , for . This proves the security of the reduction.
The Frobenius Step
We now reduce the individual evaluation claims , for , to a single claim on both and . For notation, we rename .
By definition, we have
on each cube point . Since each is either or , each is either or , and we just need to select between those two. We thus get the equivalent expression:
for each . Taking the multilinear extension, we get in turn:
Our claims thus take the form
for .
We could again in theory run sumcheck here, since the right-hand expression above is fully algebraic in and . On the other hand, the relevant multivariate would be of enormous degree: on the order of . Instead, we use a trick, based on the Frobenius endomorphism .
Indeed, for each , applying to both sides of the above equality, we get the equivalent claim:
Indeed, first off, the Frobenius is invertible, so makes sense. Second, is a ring homomorphism, so we can distribute it over all sums and products. Since is defined over , . Finally, has no effect on or , since it fixes , and it exactly "undoes" the th power attached to , since .
We thus now have 64 evaluation claims about low-degree multivariates. We can now apply the usual batch sumcheck to these. The verifier samples and sends to the prover 64 random scalars , for ; the parties then sumcheck the claim:
In this way, they can further reduce all 64 claims to a further claim of the form
for some challenge sampled during the sumcheck. The verifier can evaluate each quantity himself. As a practical matter, we note that —since the order of as an operator is 128—so the verifier can always evaluate using a few squarings. As for the rest, the prover can nondeterministically send evaluation claims and for each , say. Pending the correctness of these, the verifier can close out the above sumcheck.
Oblong-Multilinearizing
We've reduced everything to claims on and on all 64 polynomials . On the other hand, our goal was to reduce everything to a single claim on the oblong-multilinear . To do this, the verifier samples a random scalar , and outputs the single reduced evaluation claim
I.e., it outputs the claim , where .
To see why this is correct, we note that the equality of degree-63, univariate polynomials
holds, since is oblong-multilinear. Specializing both sides to , we get the correctness of this step. Conversely, if holds for some , then the degree-63 univariate polynomials
and are unequal, as univariate polynomials, since they differ at . The chance, over the verifier's challenge , that is thus at most . If this doesn't happen, then we get
so the reduction is sound.