IPA Multipoint

Introduction

This document explains how to open multiple polynomials at multiple different points. Ultimately, we use one IPA proof, 1 commitment and 1 scalar. This is the batched setting.

Statement

Given

m IPA commitments
C0=[f0(X)]...Cm1=[fm1(X)]
, prove evaluations:

f0(z0)=y0fm1(zm1)=ym1

where

zi{0,...,d1}

Proof

  1. Let
    rH(C0,...Cm1,z0,...,zm1,y0,...,ym1)

g(X)=r0f0(X)y0Xz0+r1f1(X)y1Xz1++rm1fm1(X)ym1Xzm1

The prover starts off by committing to

g(X), we denote this by
D
or
[g(X)]
.

The prover's job is to now convince the verifier that

D is a commitment to
g(X)
. We do this by evaluating
g(X)
at some random point
t

We split the evaluation into two parts

g1(t) and
g2(t)
,
g2(t)
can be computed by the verifier, while
g1(t)
cannot, because it involves random evaluations at the polynomials
fi(X)
.

  • The verifier is able to compute the
    g2(t)
    .
  • The prover will compute
    g1(t)
    and send a proof of it's correctness.

g1(t)=i=0m1rifi(t)tzi

g2(t)=i=0m1riyitzi

  1. Let
    tH(r,D)

We note that

g1(X)=i=0m1rifi(X)Xzi. However, we specify it as
i=0m1rifi(X)tzi
because the latter is also able to prove an opening for
g1(t)
and the verifier is able to compute the commitment for it.

Now we form two IPA proofs:

  • One for
    g1(X)
    at
    t
    . We call this
    π
  • One for
    g(X)
    at
    t
    . We call this
    ρ

The prover now computes

y=g1(t)

The proof consists of

D,(π,y),ρ

In this non-aggregated variation, the prover does not need to add

[g1(X)] to the transcript.

Verification

The Verifier ultimately wants to verify that

D is the commitment to the polynomial
g(x)
.

The verifier computes

r and
t
.

The verifier also computes

g2(t), we mentioned above that they can do this by themselves.

Computing
g(t)

The verifier now needs to compute

g(t):

g(t)=g1(t)g2(t)

  • We know that
    g1(t)
    was supplied in the proof as
    y
    .
  • g2(t)
    can be computed by the verifier.

Hence the verifier can compute

g(t).

Note however, that they cannot be sure that

g1(t) is the correct computation by the prover. They need to build
[g1(X)]
themselves and verify it against
g1(t)

Computing
[g1(X)]

This is

g1(X):

g1(X)=i=0m1rifi(X)tzi

Hence

[g1(X)] is:

[g1(X)]=i=0m1ritziCi

The verifier is able to compute this themselves, and so is able to verify that

g1(t) was computed correctly using IPA_VERIFY.

We can now call IPA_VERIFY using

  • [g1(X)]
  • g1(t)
  • π

Is
g(t)
correct?

Note now that since

g1(t) was verified to be correct and
g2(t)
was computed by the verifier, we can be sure that
g(t)
is correct.

Verify
g(x)
at
t

We now call IPA_VERIFY using:

  • D=[g(X)]
    *
  • g(t)
  • ρ

*In actuality, it's not

D but an augmented
D
, but this works at a higher level and does not ruin the explanation.

Complexity

The communication complexity of this protocol is two IPA proofs, 1 scalar and 1 commitment. We can get a better protocol by aggregating things together!

Aggregation

We now present a protocol to aggregate the two IPA proofs together, only requiring one IPA proof.

Prover

  1. Let
    qH(t,[g1(X)])

The prover no longer computes an IPA proof for

g1(X) and
g(X)
instead they combine them using
q
.

g3(X)=g1(X)+qg(X)

Now we form an IPA Proof for

g3(X) at
t
. Lets call this
σ
.

The prover still computes

y=g1(t)

The proof consists of

D,σ,y

Verifier

In the previous step, the verifier called

[g1(X)] ,
g1(t)
with
π
, we delay this verification and instead compute:

  • [g3(X)]=[g1(X)]+q[g(X)]
  • g3(t)=g1(t)+qg(t)

We now call IPA_VERIFY using:

  • [g3(X)]
  • g3(t)
  • σ

With overwhelming probability over

q this will only return true iff
[g1(X)]
and
[g(X)]
opened at
t
are
g1(t)
and
g(t)
respectively, from the equation.

Complexity

The communication complexity of the protocol is 1 IPA Proof, 1 commitment and 1 scalar.

Do we need to add
[g1(X)]
to the transcript?

In the KZG document, this is

h(X)

If we were able to avoid this, then we could save a lot on prover time, as they could evaluate each

fi at
t
, then do
rifi(t)tzi
instead of needing to first compute
rifi(X)tzi
. (In the non-batched version)

However, we do need to do this because the challenge

q is aggregating
[g1(X)]
and
[g(X)]
, we need to bind
[g1(X)]
to the challenge
q
.

There may be an argument to say that since

g1(X) uses
t
and simply using
q=H(t)
is enough to bind
g1(X)
to
q
. We can restate this problem as:

Given two polynomials :

f(X,Y) and
g(X)

I generate a completely random variable

t.

If I want to add together

f(X,t) and
g(x)

Is it enough to generate randomness based on

g(X) and
t
alone?

The answer is no because the prover has free reign over

X and can change it without affecting
q