Try   HackMD

Final Plookup Protocol, Rolled Out

Terminology & Notation

We consider

F a finite field of prime order
p
, i.e.,
F=Zp
.
For a given integer
n
, we denote by
[n]
the set of integers
{1,...,n}
.
We explicitly define the multiplicative subgroup
HF
as the subgroup containing the
n
-th roots of unity in
F
, where
ω
is a primitive
n
-th root of unity and a generator of
H
. That is,
H={ω,,ωn1,ωn=1}.

We denote by

F<n[X] the set of univariate polynomials over
F
of degree strictly smaller than
n
.

For a polynomial

f(x)F<n[X] and
i[n]
, we sometimes denote
fi:=f(ωi)
. For a vector
\boldsymbolfFn
, we also denote by
f(x)
the polynomial in
F<n[X]
with
f(ωi)=fi
.

The Lagrange polynomial

Li(X)F<n[X] for
i[n]
has the form
Li(X)=ωi(Xn1)n(Xωi).

Thus, the zero polynomial

ZH(X)F<n+1[X] is defined as
ZH(X)=(Xω)(Xωn1)(Xωn)=Xn1.

Protocol

Common Preprocessed Input

n,([1]1,[x]1,,[xn+3]1).

Prover Algorithm

Prover Input: A vector

\boldsymbolf=(f1,f2,,fn) describing the query values and a vector
\boldsymbolt=(t1,t2,,tn)
describing the lookup values.

Round 1:

  1. Generate random blinding scalars

    b1,b2,,b12F.

  2. Compute the query polynomial

    f(X)F<n+2[X] and the lookup polynomial
    t(X)F<n+2[X]
    :
    f(X)=(b1X+b2)ZH(X)+i=1nfiLi(X),t(X)=(b3X+b4)ZH(X)+i=1ntiLi(X).

  3. Let

    \boldsymbolsF2n be the vector that is
    (\boldsymbolf,\boldsymbolt)
    sorted by
    \boldsymbolt
    . We represent
    \boldsymbols
    by the vectors
    \boldsymbolh1,\boldsymbolh2Fn
    as follows:
    \boldsymbolh1=(s1,s3,,s2n1),\boldsymbolh2=(s2,s4,,s2n).

  4. Compute the polynomials

    h1(X)F<n+3[X], and
    h2(X)F<n+2[X]
    :
    h1(X)=(b5X2+b6X+b7)ZH(X)+i=1ns2i1Li(X),h2(X)=(b8X+b9)ZH(X)+i=1ns2iLi(X).

  5. Compute

    [f(x)]1,
    [t(x)]1
    ,
    [h1(x)]1
    and
    [h2(x)]1
    .

The first output of the prover is

([f(x)]1,[t(x)]1,[h1(x)]1,[h2(x)]1).

Open question: can the proof size in Round 1 be improved?

Round 2:

  1. Compute the permutation challenges

    β,γFp:
    β=Hash(transcript,0),γ=Hash(transcript,1).

  2. Compute the permutation polynomial

    z(X)F<n+3[X]:
    z(X)= (b8X2+b9X+b10)ZH(X)+L1(X)+i=1n1(Li+1(X)j=1i(1+β)(γ+fj)(γ(1+β)+tj+βtj+1)(γ(1+β)+s2j1+βs2j)(γ(1+β)+s2j+βs2j+1)).

  3. Compute

    [z(x)]1.

The second output of the prover is

([z(x)]1).

Round 3:

  1. Compute the quotient challenge

    αFp
    α=Hash(transcript),

  2. Compute the quotient polynomial

    q(X)F<2n+7[X]:
    q(X)=1ZH(x)(z(X)(1+β)(γ+f(X))(γ(1+β)+t(X)+βt(Xω))z(Xω)(γ(1+β)+h1(X)+βh2(X))(γ(1+β)+h2(X)+βh1(Xω))+(z(X)1)L1(X)α

TODO: Add zero-knowledge to

q properly.

  1. Split

    q(X) into one polynomial
    qlow(X)
    of degree lower than
    n+3
    and another polynomial
    qhigh(X)
    of degree at most
    n+3
    such that:
    q(X)=qlow(X)+Xn+3qhigh(X).

  2. Compute

    [qlow(x)]1,[qhigh(x)]1.

The third output of the prover is

([qlow(x)]1,[qhigh(x)]1).

Round 4:

  1. Compute the evaluation challenge

    zFp:
    z=Hash(transcript),

  2. Compute the opening evaluations:

    f(z),t(z),h2(z),t(zω),z(zω),h1(zω).

The fourth output of the prover is

(f(z),t(z),h2(z),t(zω),z(zω),h1(zω)).

Round 5:

  1. Compute the opening challenge

    vFp:
    v=Hash(transcript),

  2. Compute the linearisation polynomial

    r(X)F<n+4[X]:
    r(X)= z(X)(1+β)(γ+f(z))(γ(1+β)+t(z)+βt(zω))z(zω)(γ(1+β)+h1(X)+βh2(z))(γ(1+β)+h2(z)+βh1(zω))+α(z(X)1)L1(z)ZH(z)(qlow(X)+zn+3qhigh(X)).

  3. Compute the opening proof polynomials

    Wz(X)F<n+3[X] and
    Wzω(X)F<n+2[X]
    :
    Wz(X)=1Xz[r(X)+v(f(X)f(z))+v2(t(X)t(z))+v3(h2(X)h2(z))]Wzω(X)=1Xzω[(t(X)t(zω))+v(z(X)z(zω))+v2(h1(X)h1(zω))]

  4. Compute

    [Wz(x)]1,[Wzω(x)]1.

The fifth output of the prover is

([Wz(x)]1,[Wzω(x)]1).

The complete proof is:

π=([f(x)]1,[t(x)]1,[h1(x)]1,[h2(x)]1,[z(x)]1,[qlow(x)]1,[qhigh(x)]1,[Wz(x)]1,[Wzω(x)]1f(z),t(z),h2(z),t(zω),z(zω),h1(zω)).

Compute multipoint evaluation challenge

uF:
u=Hash(transcript),

Verifier Algorithm

Verifier preprocessed input: The curve element

[x]2.

V((ti)i[n],π):

  1. Validate that

    [f(x)]1,
    [h1(x)]1
    ,
    [h2(x)]1
    ,
    [z(x)]1
    ,
    [qlow(x)]1
    ,
    [qhigh(x)]
    ,
    [Wz(x)]1
    ,
    [Wzω(x)]1G1
    .

  2. Validate that

    f(z),t(z),h2(z),t(zω),z(zω),h1(zω)F.

  3. Validate that

    (ti)i[n]Fn.

  4. Compute the challenges

    β,γ,α,z,v,uF as in prover description, from the common preprocessed inputs, public input, and elements of
    π
    .

  5. Compute the zero polynomial evaluation

    ZH(z)=zn1.

  6. Compute the Lagrange polynomial evaluation

    L1(z)=ω(zn1)n(zω).

  7. Compute the lookup commitment

    [t(x)]1.

The previous computation be avoided by forcing the prover to send it.

  1. To save a verifier scalar multiplication, we split

    r(X) into its constant and non-constant terms. Compute
    r(X)
    's constant term:
    r0:=z(zω)(γ(1+β)+βh2(z))(γ(1+β)+h2(z)+βh1(zω))+αL1(z),

    and let
    r(X):=r(X)r0
    .

  2. Compute the first part of the batched polynomial commitment

    [D]1:=[r(x)]+u(v[z(x)]1+v2[h1(x)]1):
    [D]1:=((1+β)(γ+f(z))(γ(1+β)+t(z)+βt(zω))+L1(z)α+uv)[z(x)]1+(z(zω)(γ(1+β)+h2(z)+βh1(zω))+uv2)[h1(x)]1ZH(z)([qlow(x)]1+zn+3[qhigh(x)]1).

  3. Compute the full batched polynomial commitment

    [F]1:
    [F]1:= [D]1+v[f(x)]1+v2[t(x)]1+v3[h2(x)]+u[t(x)]1.

  4. Compute the group-encoded batch evaluation

    [E]1:
    [E]1:=[r0+vf(z)+v2t(z)+v3h2(z)+u(t(z)+vz(z)+v2h1(z))]1

  5. Finally, batch validate all evaluations:

    e([Wz(x)]1+u[Wzω(x)]1,[x]2)=?e(z[Wz(x)]1+u(zω)[Wzω(x)]1+[F]1[E]1,[1]2).

tags: Plookup