Batched Sumcheck explanation

Lagrange Polynomial basics

For

0i<2n, define it's bit representation as
(i0,,in1)
such that
i=k=0n1ik2nk1

Note that for
n<n
, if
i<2n
then its bit representation will look like
(0,,0,inn,,in1)
, with
nn
zeros in front.

The Lagrange polynomials over

{0,1}n are indexed by
0i<2n
, where
Li(X0,,Xn1)=eq(i0,,in1,X0,,Xn1)=eq(i0,,inn1,X0,,Xnn1)eq(inn,,in1,Xnn,,Xn1)

The Lagrange polynomials where

0i<2n can be factored as
Li(X0,,Xn1)=eq(i0,,inn1,X0,,Xnn1)eq(inn,,in1,Xnn,,Xn1)=eq(0,,0,X0,,Xnn1)eq(inn,,in1,Xnn,,Xn1)=(k=0nn1(1Xk))(k=nnn1((1ik)(1Xk)+ikXk))=L0(X0,,Xnn1)Li(Xnn,,Xn1)

Here, we use the convention that a Lagrange polynomial in
m
variables is indexed over all
0i<2m
.

The multi-linear extension of a polynomial over the

n-th boolean hypercube is
P(X0,,Xn1)=i=02n1PiLi(X0,,Xn1)

If the polynomial only only has non-zero values at the first
2n
evaluation points, then the factorization of the Lagrange polynomials still applies.
P(X0,,Xn1)=i=02n1PiLi(X0,,Xn1)=i=02n1PiLi(X0,,Xn1)=i=02n1PiL0(X0,,Xnn1)Li(Xnn,,Xn1)=L0(X0,,Xnn1)i=02n1PiLi(Xnn,,Xn1)

An important fact about Lagrange polynomials, is that they must sum to 1:

1=i=02m1Li(X0,,Xm1)

If we have a polynomial over

n<n variables
P(X0,,Xn1)=i=02n1PiLi(X0,,Xn1)

The canonical way to "lift" this polynomial to
n
variables, is to consider
P(X0,,Xn1)=P(Xnn1,,Xn1)=i=02n1PiLi(Xnn1,,Xn1)=i=02n1PiLi(X0,,Xn1)

Let's see how the list of evaluations
{Pi}i=02n1
relates to the initial ones
{Pi}i=02n1
.

For any

0i<2n and
0j<2nn
, we can write the index
0i<2n
as
i=i+j2n
, and it's bit decomposition is
(j0,,jnn1,i0,,in1)
.
The
i
-th evaluation of
P
is equal to the
i
-th evaluation of
P
:
Pi=Pi+j2n=P(j0,,jnn1,i0,,in1)=P(i0,,in1)=Pi

In other words, the list of evaluations of
P
is equal to
2nn
repetitions of the list of evaluations of
P
:
Pi=Pimod2n

Commitment

We have two a combination function

F:F×FF and two sets of two MLE polynomials
(P1,Q1)
(P2,Q2)
with
2n1
and
2n2
evaluations respectively. Let
n=max{n1,n2}
.

Given

Pb (respectively
Qb
) with
2nb
evaluations (
b=1,2
), we interpret it as a polynomial with
n
variables, such that when we list out its evaluations in the "canonical" order, the
2nb
non-zero evaluations are first. We can define it as:

Pb(X0,,Xn1)=L0(X0,,Xnnb1)Pb(Xnnb,,Xn1)

In order to open both pairs of polynomials using the same PCS opening argument, we need to commit to

Pb, obtained by computing the MSM with the first
2nb
group elements in the commitment key.

The interpretation of

Pb allows us to avoid allocating zeros at the end of the list of evaluations of
Pb
.

Sumcheck

In the context of Sumcheck, we use a different interpretation of

Pb to avoid padding.

We want to batch the claims

σb=x{0,1}nbF(Pb(x),Qb(x))

using a random linear combination challenge

γ.

In this context we run it on the polynomials

Pb(X0,,Xn1)=Pb(Xnnb,,Xn1)
This representation is equivalent to taking the list of evaluations of
Pb
, and repeating them
2nnb
times such that
Pb
is of length
2n
. Again, we want to avoid having to allocate that much space, especially for repeated values, so we need to "imagine" these repetitions instead.

Sumcheck works partially evaluating the claims in the challenge variables

r=(r0,,rn1).

If we instead apply the same Sumcheck combination on the repeated polynomials, we notice that the sum we get is the original one, scaled by

2nnb.

x{0,1}nF(Pb(x),Qb(x))=y{0,1}nnbx{0,1}nbF(Pb(x),Qb(x))=y{0,1}nnbσb=2nnbσb

In rounds

0i<nnb, the prover computes the univariate polynomial for this claim, given by:
Sb(i)(Xi)=x{0,1}ni1F(Pb(r0,,ri1,Xi,x),Qb(r0,,ri1,Xi,x))=y{0,1}ni1nbx{0,1}nbF(Pb(x),Qb(x))=2ni1nbσb

This polynomial is constant, and is equal to the initial claim scaled by
2ni1nb
.

When we bind the polynomial to

ri, it does not affect our list of evaluations, since
Pb(r0,,ri1,ri,Xi+1,,Xn1)=Pb(Xnnb,,Xn1)

For rounds

nnbi<n, the protocol will start evaluating the "active" variables of
Pb
, and the Sumcheck prover simply continues as previously, without having to do any scaling.

During the protocol, the prover will have sent the univariate polynomials

S(i)(Xi)=S1(i)(Xi)+γS2(i)(Xi) and at the end, sends the evaluations
pb=Pb(r0,,rn1)=Pb(rnnb,,rn1),qb=Qb(r0,,rn1)=Qb(rnnb,,rn1).

The verifier having processed this data through the transcript, does the following:

  • Set
    e(0)=2nn1σ1+γ2nn2σ2
  • For each
    i=0,1,,n1
    ,
    • Check
      e(i)=S(i)(0)+S(i)(1)
    • Set
      e(i+1)=S(i)(ri)
  • Check
    e(n)=F(p1,q1)+γF(p2,q2)

The parties now run a PCS argument to check the evaluations

pb,qb

PCS

The evaluations returned by the prover are for the polynomials

Pb,Qb. Note however that we have committed to the polynomials
P,Q
as described in the first section.

We can transform the evaluation

ub for
P
at
(r0,,rn1)
, into an evaluation
ub
for
P
at the same point, by setting
ub=P(r0,,rn1)=L0(r0,,rnnb1)P(rnnb,,rn1)=P(r0,,rn1)=L0(r0,,rnnb1)ub=ubi=0nnb1(1ri).

This simply involves rescaling the original Sumcheck evaluation by the first Lagrange polynomial, evaluated in the "missing" first variables of
P
.

We can then batch all polynomial evaluation instances into a single instance of size

n.