The Zcash ArboretumHalo 2 Guide PDF

3 The inner-product polynomial commitment

This section constructs the inner-product polynomial commitment that opens the commitments of §2.9 at the verifier’s point. It states the problem, performs one halving step, recurses it into the full argument with both parties’ tables, gives the verifier’s closing computation, proves knowledge soundness under the discrete-logarithm assumption, proves honest-verifier zero knowledge of the masked opening, runs the running example’s polynomial through every round on a curve of prime order 97, and in the last subsection gives the parameters, the normalisation, the opening, the bytes and the deferred check of the deployed Halo 2. Beyond the Math Guide, the section relies on these parts of the Crypto Guide: the Pedersen vector commitment (§“Pedersen vector commitments”), extractors and the tree extraction of Sigma-protocols (§“Knowledge soundness and extractors”, §“The Schnorr identification protocol”, §“Sigma-protocols”), the simulation paradigm (§“The simulation paradigm and zero knowledge”), hashing to a curve (§“Hashing to a curve point”) and the standing assumptions (§“Standing assumptions”). From this volume, the generic argument takes only the cue of §2.9; the toy reuses the running example’s advice polynomial and random point (§2.2, §2.4), restated where used; the last subsection takes the deployed circuit’s field from §1.2 and the advice, permutation, lookup and quotient objects from §2, and forward-references §4 for the row count and the remaining objects of the proof; the other references to §2 mark where the argument is used.

3.1 The problem: an inner product in fewer than d group elements

The prover holds a vector 𝐚=(a0,…,ad−1) of d field elements. She has published one group element,

P=⟨𝐚,𝐆⟩+[r]⁢H=∑i=0d−1[ai]⁢Gi+[r]⁢H,

the Pedersen vector commitment of 𝐚 with blinder r under the public generators 𝐆=(G0,…,Gd−1) and H (Crypto Guide, §“Pedersen vector commitments”; the mixed inner product ⟨𝐚,𝐆⟩ of a scalar vector with a vector of group elements is the Math Guide’s, §“The mixed inner product with group elements”). The verifier holds P, a public vector 𝐛=(b0,…,bd−1) of his own, and a number v the prover claims. He wants to be sure that

⟨𝐚,𝐛⟩=∑i=0d−1ai⁢bi=v.

There is a trivial protocol: the prover sends 𝐚 and r; the verifier recomputes P from them, which the binding of the commitment makes a meaningful check, and then computes ⟨𝐚,𝐛⟩ himself. It costs d+1 field elements and reveals 𝐚. Neither is acceptable here: the vector is the prover’s secret advice, and the verifier of §2.4 asks for evaluations rather than polynomials because a polynomial is long, so a proof as long as the vector gains nothing. The problem is therefore:

Convince the verifier that ⟨𝐚,𝐛⟩=v for the vector 𝐚 committed in P, using fewer than d group elements, and without revealing 𝐚.

Why this is polynomial evaluation.

Let p⁢(X)=a0+a1⁢X+⋯+ad−1⁢Xd−1 be the polynomial with coefficient vector 𝐚, and let x be a point. Then

p⁢(x)=∑i=0d−1ai⁢xi=⟨𝐚,(1,x,x2,…,xd−1)⟩.

Evaluating a committed polynomial is therefore exactly the problem above, with the public vector 𝐛⁢(x):=(1,x,x2,…,xd−1) of powers of the point. The running example makes it concrete. The advice polynomial of §2.2 is a⁢(X)=90+61⁢X+22⁢X2+24⁢X3 over 𝔽97, so 𝐚=(90,61,22,24) and d=4; the random point of §2.4 is z=20, so 𝐛⁢(20)=(1,20,202,203)=(1,20,12,46) in 𝔽97; and the value the verifier needs is a⁢(20)=⟨𝐚,𝐛⁢(20)⟩=59. Everything the random-point check of §2.4 asks of the prover, “open a, b, c and t at z”, is four instances of this one problem.

Where the difficulty sits.

The commitment is linear in the vector: adding two commitments commits to the sum of their vectors, and scaling one by λ commits to λ⁢𝐚 (Crypto Guide, §“Pedersen vector commitments”, the remark that linearity survives). The inner product is linear in 𝐚 too. But the two linear maps land in different places, one in the group and one in the field, and by the hiding of the commitment no public operation takes P to ⟨𝐚,𝐛⟩. A claim about a vector of length one is checked by sending the scalar and its blinder. The argument that follows reduces the length by halving. Each halving step turns a claim about vectors of length 2j into a claim of the same shape about vectors of length 2j−1, at a price of two group elements, and after k=log2⁡d steps the claim is about a single scalar. The argument uses exactly this linearity.

The relation.

Throughout, 𝔾 is a cyclic group of prime order p and 𝔽=𝔽p its scalar field, so that 𝔾 is a one-dimensional 𝔽-vector space (Math Guide, §“The mixed inner product with group elements”).

Definition 3.1 (The opening relation).

Fix public generators 𝐆=(G0,…,Gd−1) and H in 𝔾∖{𝒪}. To open the committed polynomial p at x∈𝔽 with claimed value v is to prove membership in

ℛIPA:={((P,x,v);(𝐚,r)):P=⟨𝐚,𝐆⟩+[r]⁢H,v=⟨𝐚,𝐛⁢(x)⟩,𝐚∈𝔽d},
𝐛⁢(x):=(1,x,…,xd−1),

where (P,x,v) is the public statement and (𝐚,r) the witness. The condition 𝐚∈𝔽d is the degree bound deg⁡p≤d−1: a commitment under d generators can only hold d coefficients.

Notation for the section.

The following conventions hold from here to the end of §3.

  • •

    The vector length is d=2k, and d is also the exclusive degree bound and the number of generators. The round count is k=log2⁡d. The letter n, the row count of Definition 2.7, is not used until the deployed parameters at the end of the section, where d=n; the constraint degree stays dmax as §2.5 fixed it. The Crypto Guide’s sketch of this argument indexes its generators from 0 to d and bounds the degree by d inclusively; nothing changes but the labels.

  • •

    Generators are indexed from 0, 𝐆=(G0,…,Gd−1), so that the coefficient ai of Xi multiplies Gi; the Crypto Guide’s “Pedersen vector commitments” indexes its generators G1,…,Gn instead, a shift of labels only.

  • •

    The letter H names the blinding generator H∈𝔾 of the Pedersen commitment; the evaluation domain H⊂𝔽 of §2 does not appear in this section. The letter p names the group order, and with an argument, p⁢(X), the committed polynomial.

  • •

    The letter z is the running example’s opening point, z=20, and x the generic one. The deployed protocol has a second challenge which its description also calls z; this volume writes it ζ.

  • •

    The structured scalars si∈𝔽 of §3.4 are scalars; the permuted-label polynomials si⁢(X) of Construction 2.10 are polynomials. Type and argument disambiguate. The mask s⁢(X) of §3.6 is one further polynomial, with coefficient vector 𝐦.

  • •

    In the byte count of §3.8, a is the number of Actions, an integer, not the vector 𝐚.

  • •

    A vector of length 2j splits into its low half, the first 2j−1 entries, and its high half, the last 2j−1: 𝐚=(𝐚lo,𝐚hi), and likewise for 𝐆 and 𝐛.

3.2 One fold, every step written out

One halving step is called a fold. This subsection performs one fold on a vector of length d.

Carry the claim inside the group element.

The commitment P says nothing about 𝐛 or v. Bring them in: after P is fixed, the verifier samples a further generator U uniformly from 𝔾∖{𝒪} and sends it. Both parties form

C:=P+[v]⁢U. (11)

If the prover is honest, C=⟨𝐚,𝐆⟩+[r]⁢H+[⟨𝐚,𝐛⟩]⁢U: a single group element carrying three kinds of information on three independent sets of generators, the vector on 𝐆, the blinder on H, and the inner product on U. The claim “P commits to 𝐚 and ⟨𝐚,𝐛⟩=v” has become the claim that C has this one shape, for some 𝐚 and r, with the U-coefficient tied to the 𝐆-coefficients by the inner product with the public 𝐛. The fold preserves exactly this shape while halving the vectors.

Split into halves.

Write 𝐚=(𝐚lo,𝐚hi), 𝐆=(𝐆lo,𝐆hi) and 𝐛=(𝐛lo,𝐛hi), each half of length d/2. An inner product splits along the halves:

⟨𝐚,𝐆⟩=⟨𝐚lo,𝐆lo⟩+⟨𝐚hi,𝐆hi⟩,⟨𝐚,𝐛⟩=⟨𝐚lo,𝐛lo⟩+⟨𝐚hi,𝐛hi⟩.

The fold.

Let u∈𝔽× be a nonzero challenge, and define the folded vectors of length d/2,

𝐚′:=u⁢𝐚lo+u−1⁢𝐚hi,𝐆′:=u−1⁢𝐆lo+u⁢𝐆hi,𝐛′:=u−1⁢𝐛lo+u⁢𝐛hi, (12)

entry by entry: ai′=u⁢ai+u−1⁢ai+d/2, Gi′=[u−1]⁢Gi+[u]⁢Gi+d/2 and bi′=u−1⁢bi+u⁢bi+d/2 for 0≤i<d/2. The coefficient vector is folded with the weights (u,u−1) and the generator and evaluation vectors with the inverse weights (u−1,u); this is the symmetric fold of the Halo paper and of Bulletproofs, and the reason for the inverse weights appears in the next computation.

The inner product of the folded vectors.

Expand ⟨𝐚′,𝐆′⟩ using bilinearity of the mixed inner product (Math Guide, §“The mixed inner product with group elements”), one term per pair of halves:

⟨𝐚′,𝐆′⟩ =⟨u⁢𝐚lo+u−1⁢𝐚hi,u−1⁢𝐆lo+u⁢𝐆hi⟩
=u⁢u−1⁢⟨𝐚lo,𝐆lo⟩+u⁢u⁢⟨𝐚lo,𝐆hi⟩+u−1⁢u−1⁢⟨𝐚hi,𝐆lo⟩+u−1⁢u⁢⟨𝐚hi,𝐆hi⟩
=⟨𝐚lo,𝐆lo⟩+⟨𝐚hi,𝐆hi⟩⏟=⟨𝐚,𝐆⟩+u2⁢⟨𝐚lo,𝐆hi⟩+u−2⁢⟨𝐚hi,𝐆lo⟩.

The two diagonal terms, low with low and high with high, have weight u⁢u−1=1 and reassemble the original ⟨𝐚,𝐆⟩: that is what the inverse weights were for. The two cross terms, low with high and high with low, survive with the weights u2 and u−2. The same expansion for the scalar inner product, with 𝐛′ folded by the same weights as 𝐆′, gives

⟨𝐚′,𝐛′⟩=⟨𝐚,𝐛⟩+u2⁢⟨𝐚lo,𝐛hi⟩+u−2⁢⟨𝐚hi,𝐛lo⟩.

The cross terms do not depend on the challenge.

The four cross inner products ⟨𝐚lo,𝐆hi⟩, ⟨𝐚hi,𝐆lo⟩, ⟨𝐚lo,𝐛hi⟩ and ⟨𝐚hi,𝐛lo⟩ involve only the halves, not u. The prover can therefore commit to them before the challenge is drawn. She samples two fresh blinders ℓ,ρ∈𝔽 and sends the two group elements

L:=⟨𝐚lo,𝐆hi⟩+[ℓ]⁢H+[⟨𝐚lo,𝐛hi⟩]⁢U,R:=⟨𝐚hi,𝐆lo⟩+[ρ]⁢H+[⟨𝐚hi,𝐛lo⟩]⁢U, (13)

each of the same three-part shape as C: a vector part on the generators, a blinder on H, and the matching scalar inner product on U. Only then does the verifier draw u.

The fold identity.

Now add the cross terms to C with the weights the expansion produced and regroup by generator set:

C+[u2]⁢L+[u−2]⁢R =⟨𝐚,𝐆⟩+[r]⁢H+[⟨𝐚,𝐛⟩]⁢U
+u2⁢(⟨𝐚lo,𝐆hi⟩+[ℓ]⁢H+[⟨𝐚lo,𝐛hi⟩]⁢U)
+u−2⁢(⟨𝐚hi,𝐆lo⟩+[ρ]⁢H+[⟨𝐚hi,𝐛lo⟩]⁢U)
=(⟨𝐚,𝐆⟩+u2⁢⟨𝐚lo,𝐆hi⟩+u−2⁢⟨𝐚hi,𝐆lo⟩)
+[r+u2⁢ℓ+u−2⁢ρ]⁢H+[⟨𝐚,𝐛⟩+u2⁢⟨𝐚lo,𝐛hi⟩+u−2⁢⟨𝐚hi,𝐛lo⟩]⁢U
=⟨𝐚′,𝐆′⟩+[r′]⁢H+[⟨𝐚′,𝐛′⟩]⁢U,

where r′:=r+u2⁢ℓ+u−2⁢ρ and the last line substitutes the two expansions. Written as one equation, the fold identity is

C′:=C+[u2]⁢L+[u−2]⁢R=⟨𝐚′,𝐆′⟩+[r′]⁢H+[⟨𝐚′,𝐛′⟩]⁢U. (14)

What has been achieved.

Compare the two sides of (14) with (11). The element C′ has the same shape as C, over vectors of half the length: its 𝐆′-part is the folded coefficient vector, its H-part a blinder, and its U-coefficient the inner product of the folded vectors. The verifier can compute C′, 𝐆′ and 𝐛′ entirely on his own from C, L, R, u and the public data. The prover computes 𝐚′ and r′. The claim about (𝐚,𝐛,𝐆) of length d has been replaced by a claim about (𝐚′,𝐛′,𝐆′) of length d/2, and the exchange cost exactly two group elements and one field element of challenge. Figure 7 shows the fold and identity (14). Only completeness is claimed here; that a prover who cannot open C cannot open C′ either is proved in §3.5.

The evaluation vector folds into a power vector.

When 𝐛=𝐛⁢(x), the high half is the low half scaled: 𝐛hi=xd/2⁢𝐛lo, since bi+d/2=xi+d/2=xd/2⁢xi. Hence

𝐛′=u−1⁢𝐛lo+u⁢xd/2⁢𝐛lo=(u−1+u⁢xd/2)⁢(1,x,…,xd/2−1):

the folded evaluation vector is again a vector of powers of x, scaled by the scalar u−1+u⁢xd/2. The verifier never needs to store 𝐛′; he needs one scalar per round. This is the seed of the closed form g of §3.4.

The fold at d=4, symbolically.

For the running example’s length, the halves are 𝐚lo=(a0,a1), 𝐚hi=(a2,a3), 𝐆lo=(G0,G1), 𝐆hi=(G2,G3), 𝐛lo=(1,x) and 𝐛hi=(x2,x3), so the cross terms of (13) read

L =[a0]⁢G2+[a1]⁢G3+[ℓ]⁢H+[a0⁢x2+a1⁢x3]⁢U,
R =[a2]⁢G0+[a3]⁢G1+[ρ]⁢H+[a2+a3⁢x]⁢U,

and the folded vectors are 𝐚′=(u⁢a0+u−1⁢a2,u⁢a1+u−1⁢a3), 𝐆′=([u−1]⁢G0+[u]⁢G2,[u−1]⁢G1+[u]⁢G3) and 𝐛′=(u−1+u⁢x2)⁢(1,x). Section 3.7 fills these in with numbers.

Refer to caption
Figure 7: One fold. The three vectors of length d (left; low halves in blue, high halves in amber) determine the two cross terms L and R (red): L from 𝐚lo, 𝐆hi and 𝐛hi, R from the complementary halves, both sent before the challenge u is drawn. The challenge then folds all three vectors to length d/2 (green). The identity beneath is equation (14): the folded commitment has the same three-part shape as the original, over the folded vectors, with the cross terms absorbed at weights u2 and u−2.

3.3 The recursion: k rounds to a single scalar

The folded claim of §3.2 has the shape of the original claim, so it can be folded again. After k=log2⁡d folds the vectors have length one, and a length-one claim is checked by sending the scalar and its blinder. That is the whole protocol; this subsection writes it out as a construction, numbers the rounds, and lays the two parties’ work side by side.

Construction 3.2 (IPA-based polynomial commitment).

Let 𝔾 be a cyclic group of prime order p in which the discrete logarithm problem is hard (Crypto Guide, §“Standing assumptions”), and let 𝔽=𝔽p. Choose d=2k and sample the generators 𝐆=(G0,…,Gd−1) and H independently and uniformly from 𝔾∖{𝒪}, as in the Crypto Guide’s Construction “Pedersen vector commitment” (§“Pedersen vector commitments”). Deployed generators are instead hash-to-curve outputs on public labels, uniform when hash-to-curve is modelled as a random oracle into 𝔾 (Crypto Guide, §“Hashing to a curve point”, Remark “Why NUMS generators are binding-safe”).

Commitment. For p⁢(X)=∑i=0d−1ai⁢Xi∈𝔽⁢[X] and a blinder r∈𝔽,

𝖢𝗈𝗆𝗆𝗂𝗍⁢(p;r):=⟨𝐚,𝐆⟩+[r]⁢H∈𝔾.

Opening. To prove ((P,x,v);(𝐚,r))∈ℛIPA, the two parties proceed as follows.

  1. 1.

    Setup. The verifier samples U uniformly from 𝔾∖{𝒪} and sends it. Both parties set C(k):=P+[v]⁢U, 𝐆(k):=𝐆 and 𝐛(k):=𝐛⁢(x); the prover sets 𝐚(k):=𝐚 and r(k):=r.

  2. 2.

    Rounds. For j=k,k−1,…,1, the vectors 𝐚(j),𝐆(j),𝐛(j) have length 2j and are split into halves as in §3.2.

    1. (a)

      The prover samples independent uniform ℓj,ρj∈𝔽 and sends

      Lj :=⟨𝐚lo(j),𝐆hi(j)⟩+[ℓj]⁢H+[⟨𝐚lo(j),𝐛hi(j)⟩]⁢U,
      Rj :=⟨𝐚hi(j),𝐆lo(j)⟩+[ρj]⁢H+[⟨𝐚hi(j),𝐛lo(j)⟩]⁢U.
    2. (b)

      The verifier sends a uniform uj∈𝔽×.

    3. (c)

      Both parties fold by (12):

      𝐆(j−1):=uj−1⁢𝐆lo(j)+uj⁢𝐆hi(j),𝐛(j−1):=uj−1⁢𝐛lo(j)+uj⁢𝐛hi(j),
      C(j−1):=C(j)+[uj2]⁢Lj+[uj−2]⁢Rj;

      the prover also folds 𝐚(j−1):=uj⁢𝐚lo(j)+uj−1⁢𝐚hi(j) and r(j−1):=r(j)+uj2⁢ℓj+uj−2⁢ρj.

  3. 3.

    Final message. After round 1 every vector has length one. Write a:=𝐚(0), G(0):=𝐆(0) and b(0):=𝐛(0) for the single entries. The prover sends the scalar a and the aggregated blinder

    r∗:=r(0)=r+∑j=1k(uj2⁢ℓj+uj−2⁢ρj).
  4. 4.

    Check. The verifier accepts if and only if

    P+[v]⁢U+∑j=1k([uj2]⁢Lj+[uj−2]⁢Rj)⁢=?⁢[a]⁢G(0)+[r∗]⁢H+[a⋅b(0)]⁢U, (15)

    where the left-hand side is C(0) and G(0), b(0) are computed as §3.4 describes.

The round index descends so that round j begins with vectors of length 2j; round k is the first round and round 1 the last. The scheme instantiates the polynomial-commitment interface of the Crypto Guide (§“Polynomial commitment schemes”, the inner-product alternative), and the opening protocol is the inner-product argument of Bootle, Cerulli, Chaidos, Groth and Petit as refined in Bulletproofs by Bünz, Bootle, Boneh, Poelstra, Wuille and Maxwell, in the symmetric normalisation those papers use.

Completeness.

The honest prover always passes. By induction on the rounds,

C(j)=⟨𝐚(j),𝐆(j)⟩+[r(j)]⁢H+[⟨𝐚(j),𝐛(j)⟩]⁢Ufor ⁢j=k,k−1,…,0: (16)

at j=k this is (11) with the honest P, and the step from j to j−1 is the fold identity (14) applied to the round’s vectors, challenge and blinders. At j=0 the vectors have one entry each, the inner products are products of scalars, and (16) reads C(0)=[a]⁢G(0)+[r∗]⁢H+[a⁢b(0)]⁢U, which is (15). The only way an honest run can fail is a challenge uj=0, which the verifier excludes.

Proof size.

The prover sends two group elements per round and two field elements at the end: 2⁢k group elements plus O⁢(1), against the d+1=2k+1 field elements of the trivial protocol. The verifier keeps only the challenges u1,…,uk and the received points; he need not fold 𝐆 round by round, as the next subsection shows. Figure 8 draws the k rounds, and Tables 2 and 3 list, one row per message, what each party holds, computes and sends, so that a reader can play either role; §3.7 refills the same rows with numbers.

Refer to caption
Figure 8: The k rounds of Construction 3.2. Each round halves the vector length: the prover sends two points (↓), the verifier answers with one challenge (↑) and keeps the three values. After k rounds one scalar and one aggregated blinder close the argument; the verifier’s closing work is the subject of §3.4.
step receives / holds computes and sends
setup holds 𝐚, r, x, v; receives U sets 𝐚(k):=𝐚, 𝐆(k):=𝐆, 𝐛(k):=𝐛⁢(x), r(k):=r
round j vectors of length 2j, split into halves samples ℓj,ρj; sends Lj, Rj as in Construction 3.2
receives uj folds 𝐚(j−1)=uj⁢𝐚lo(j)+uj−1⁢𝐚hi(j), 𝐆(j−1), 𝐛(j−1); r(j−1)=r(j)+uj2⁢ℓj+uj−2⁢ρj
final one entry each: a=𝐚(0), r∗=r(0) sends a, r∗
Table 2: The prover’s side of Construction 3.2, one row per message. The round row repeats for j=k,…,1.
step receives / holds computes and sends
setup holds P, x, v, 𝐆, H samples U and sends it; sets C(k):=P+[v]⁢U
round j receives Lj, Rj samples uj∈𝔽× and sends it; keeps (Lj,Rj,uj); optionally C(j−1):=C(j)+[uj2]⁢Lj+[uj−2]⁢Rj
final receives a, r∗ computes 𝐬 and G(0)=⟨𝐬,𝐆⟩ (one length-d multi-scalar multiplication), b(0)=g⁢(x;u1,…,uk) (O⁢(k) field operations), and checks (15)
Table 3: The verifier’s side of Construction 3.2, one row per message, with the closing computations of §3.4. The round row repeats for j=k,…,1; folding C round by round is optional because (15) sums the cross terms directly.

3.4 The verifier’s work: structured scalars and the final generator

The check (15) needs two quantities the verifier has not yet been told how to obtain cheaply: the final generator G(0) and the final evaluation scalar b(0). Folding 𝐆 round by round costs d+d/2+⋯+2=2⁢d−2 scalar multiplications (two per entry of each folded vector), and folding 𝐛 likewise many field operations. Both have closed forms in the challenges.

Theorem 3.3 (Structured scalars and the polynomial g).

For 0≤i<d write the binary expansion i=∑ℓ=0k−1βℓ⁢ 2ℓ with digits βℓ∈{0,1}, and define the structured scalars

si:=∏ℓ=1kuℓ(−1)1−βℓ−1(the factor is uℓ when ⁢βℓ−1=1⁢ and ⁢uℓ−1⁢ when ⁢βℓ−1=0⁢). (17)

Then, after the k folds of Construction 3.2,

G(0)=⟨𝐬,𝐆⟩=∑i=0d−1[si]⁢Gi,b(0)=⟨𝐬,𝐛⁢(x)⟩=g⁢(x;u1,…,uk), (18)

where

g⁢(X;u1,…,uk):=∏ℓ=1k(uℓ−1+uℓ⁢X2ℓ−1), (19)

a polynomial of degree d−1 in X.

Proof.

Follow one original generator Gm through the folds. Claim: after the rounds k,k−1,…,j+1 have been performed, Gm contributes to exactly one entry of 𝐆(j), the entry at position mmod2j, with coefficient ∏ℓ=j+1kuℓ(−1)1−βℓ−1, where βℓ−1 is the digit of m at position ℓ−1. At j=k nothing has happened and the claim says Gm sits at position m with coefficient 1. For the step from j to j−1: round j folds the length-2j vector by Gi(j−1)=[uj−1]⁢Gi(j)+[uj]⁢Gi+2j−1(j) for 0≤i<2j−1. The position mmod2j lies in the low half [0,2j−1) exactly when the digit βj−1 of m is 0, in which case it moves to position mmod2j−1 with the extra factor uj−1; and it lies in the high half exactly when βj−1=1, in which case it is the entry i+2j−1 with i=mmod2j−1 and moves to position i with the extra factor uj. Either way the new coefficient is the old one times uj(−1)1−βj−1, which is the claim for j−1. At j=0 every Gm sits in the single entry G(0) with coefficient sm, which is the first half of (18). The vector 𝐛 is folded with the same weights, so the same argument gives b(0)=∑msm⁢bm=⟨𝐬,𝐛⁢(x)⟩.

For the closed form, expand the product (19): choosing from the ℓ-th factor either uℓ−1 (when βℓ−1=0) or uℓ⁢X2ℓ−1 (when βℓ−1=1) produces, for each m, the monomial sm⁢X∑ℓ=1kβℓ−1⁢2ℓ−1=sm⁢Xm, and every m∈[0,d) arises from exactly one choice. Hence g⁢(X)=∑msm⁢Xm, whose value at x is ⟨𝐬,𝐛⁢(x)⟩, and whose degree is d−1 since the top monomial has coefficient sd−1=∏ℓuℓ≠0. □

At d=4 the scalars are s0=u1−1⁢u2−1, s1=u1⁢u2−1, s2=u1−1⁢u2 and s3=u1⁢u2, and g⁢(x;u1,u2)=(u1−1+u1⁢x)⁢(u2−1+u2⁢x2): the digit of weight 1 selects the exponent of u1, the round that folded pairs of neighbours, and the digit of weight 2 selects the exponent of u2, the round that folded the two halves of the whole vector.

The final equation, and why it checks.

The verifier’s closing work is now explicit. He evaluates b(0)=g⁢(x;𝐮) from the challenges; he computes G(0)=⟨𝐬,𝐆⟩, one multi-scalar multiplication of length d; he adds up the left-hand side of (15) from P, U, the 2⁢k received points and the challenges, 2⁢k+1 scalar multiplications; and he compares it with the right-hand side, three more scalar multiplications. For the honest prover the two sides agree by the invariant (16). That a dishonest prover cannot make them agree except by knowing an opening is §3.5.

The cost of the final check.

Evaluating g at x costs 3⁢k−2 field multiplications: k products uℓ⁢x2ℓ−1, k−1 squarings to produce the powers x,x2,x4,…, and k−1 multiplications of the factors together; at k=2 that is four multiplications, and at Orchard’s k=11 it is 31. But G(0) is a linear combination of all d generators, and computing it is a multi-scalar multiplication of length d, at Orchard’s d=211 some 2048 scalar multiplications: the one part of the verifier’s work that is linear in the size of the committed vector, and the check “linear in n” that §2.6 deferred to this subsection. Everything else the verifier does is logarithmic. The asymmetry has a name in the closed form: G(0)=⟨𝐬,𝐆⟩ is nothing but 𝖢𝗈𝗆𝗆𝗂𝗍⁢(g; 0), the unblinded commitment to the polynomial g whose value the verifier just computed in O⁢(k) operations. Checking a value of g is cheap; checking its commitment is not. This asymmetry is the seed of the accumulation scheme of §7, and of the deferral described at the end of this section.

3.5 Why it is binding: extraction from three transcripts

This subsection shows that any prover that makes the verifier of Construction 3.2 accept knows an opening (𝐚,r) of P with ⟨𝐚,𝐛⁢(x)⟩=v, in the operational sense of the Crypto Guide (§“Knowledge soundness and extractors”): an extractor that runs the prover as a subroutine, rewinds it to an earlier state and feeds it fresh challenges computes the pair from its answers. The mechanism is the one that makes Schnorr’s identification protocol a proof of knowledge (Crypto Guide, §“The Schnorr identification protocol”): a single transcript reveals nothing, but two accepting transcripts with the same first message and distinct challenges are two linear equations, and subtracting them cancels the unknown commitment and leaves the witness. Here each round has three unknown group elements instead of one, so three transcripts are needed per round, and the k rounds stack the three-way branching into a tree, the tree special soundness of the Crypto Guide (§“Sigma-protocols”). The single-round step is pure linear algebra and is proved in full; the tree is an induction on it; the discrete-logarithm assumption enters once, at the root.

Representations.

Fix a level j with generator vector 𝐆(j) of length 2j. A representation of an element Q∈𝔾 over (𝐆(j),H,U) is a triple (𝐱;y;w)∈𝔽2j×𝔽×𝔽 with

Q=⟨𝐱,𝐆(j)⟩+[y]⁢H+[w]⁢U.

Call the representation well formed at level j if its U-coordinate is the inner product of its 𝐆-coordinates with the round’s evaluation vector, w=⟨𝐱,𝐛(j)⟩. The invariant (16) says exactly that the honest prover holds a well-formed representation (𝐚(j);r(j);⟨𝐚(j),𝐛(j)⟩) of C(j) at every level. A representation over folded generators lifts to one over the generators of the level above: if Q=⟨𝐚′,𝐆′⟩+[y]⁢H+[w]⁢U with 𝐆′=u−1⁢𝐆lo+u⁢𝐆hi, then by bilinearity

Q=⟨(u−1⁢𝐚′,u⁢𝐚′),𝐆⟩+[y]⁢H+[w]⁢U, (20)

and the lift preserves well-formedness, since ⟨(u−1⁢𝐚′,u⁢𝐚′),𝐛⟩=⟨𝐚′,u−1⁢𝐛lo+u⁢𝐛hi⟩=⟨𝐚′,𝐛′⟩. Under the discrete-logarithm assumption a prover can know at most one representation of any Q: two of them differ by a nontrivial relation among 𝐆, H and U, which is the binding argument of the Crypto Guide (§“Pedersen vector commitments”). Nothing below uses this until the root is reached.

Lemma 3.4 (Single-round recovery).

Fix one round of Construction 3.2 at level j: the verifier’s element C:=C(j), the generators 𝐆:=𝐆(j) and evaluation vector 𝐛:=𝐛(j), and the prover’s cross terms L, R. Let u,u′,u′′ be three challenges for this round, and suppose that for each ν∈{u,u′,u′′} a representation (𝐱ν;yν;wν) of the folded element C+[ν2]⁢L+[ν−2]⁢R over (𝐆,H,U) is known. If the squares u2,u′⁣2,u′′⁣2 are pairwise distinct, then representations (𝐱L;yL;wL), (𝐱C;yC;wC) and (𝐱R;yR;wR) of L, C and R over (𝐆,H,U) are obtained by solving one 3×3 linear system with rows (ν2,1,ν−2), and they satisfy, for each ν,

𝐱ν=ν2⁢𝐱L+𝐱C+ν−2⁢𝐱R,yν=ν2⁢yL+yC+ν−2⁢yR,wν=ν2⁢wL+wC+ν−2⁢wR. (21)

If the three given representations are well formed at level j, so is the recovered representation of C.

Proof.

Write the three known representations as vectors 𝐘ν:=(𝐱ν,yν,wν)∈𝔽2j+2 and the three unknown ones as 𝐗L,𝐗C,𝐗R. The three group equations

[ν2]⁢L+C+[ν−2]⁢R=⟨𝐱ν,𝐆⟩+[yν]⁢H+[wν]⁢U,ν∈{u,u′,u′′},

suggest the linear system

M⁢(𝐗L𝐗C𝐗R)=(𝐘u𝐘u′𝐘u′′),M:=(u21u−2u′⁣21u′⁣−2u′′⁣21u′′⁣−2),

to be solved coordinate by coordinate. Multiplying the row of ν by the nonzero scalar ν2 turns it into (ν4,ν2,1), which does not change the kernel. If M⁢(c0,c1,c2)⊤=0, the polynomial c0⁢W2+c1⁢W+c2 of degree at most 2 vanishes at W=u2,u′⁣2,u′′⁣2; when these squares are pairwise distinct it is zero (Math Guide, §“Roots and the factor theorem”, Theorem “At most d roots”), so M is invertible. When two squares coincide, two rows of M coincide and M is singular. Define (𝐗L,𝐗C,𝐗R) as the unique solution. Because it solves the system exactly, 𝐘ν=ν2⁢𝐗L+𝐗C+ν−2⁢𝐗R for each ν, which is (21) read coordinate by coordinate. That the solutions are representations of L, C and R follows by taking the same linear combinations of the group equations: let (α,α′,α′′) be the middle row of M−1, so that α⁢(u2,1,u−2)+α′⁢(u′⁣2,1,u′⁣−2)+α′′⁢(u′′⁣2,1,u′′⁣−2)=(0,1,0) and 𝐗C=α⁢𝐘u+α′⁢𝐘u′+α′′⁢𝐘u′′. Adding α times the first group equation, α′ times the second and α′′ times the third gives, on the left, [0]⁢L+[1]⁢C+[0]⁢R=C, and on the right, by bilinearity, ⟨𝐱C,𝐆⟩+[yC]⁢H+[wC]⁢U. The first and third rows of M−1 do the same for L and R. For well-formedness, set δν:=wν−⟨𝐱ν,𝐛⟩ and δL:=wL−⟨𝐱L,𝐛⟩, δC:=wC−⟨𝐱C,𝐛⟩, δR:=wR−⟨𝐱R,𝐛⟩. Subtracting the inner product of the first identity of (21) with 𝐛 from the third gives δν=ν2⁢δL+δC+ν−2⁢δR for each ν, that is, M⁢(δL,δC,δR)⊤=(δu,δu′,δu′′)⊤. If the given representations are well formed the right-hand side is zero, and M invertible forces δL=δC=δR=0; in particular wC=⟨𝐱C,𝐛⟩. □

Theorem 3.5 (Knowledge soundness of the opening protocol).

Let 𝔾 be a group of prime order in which the discrete logarithm problem is hard, and let 𝐆 and H be uniform in 𝔾∖{𝒪} as in Construction 3.2 (for hashed generators: hash-to-curve modelled as a random oracle into 𝔾). The opening protocol of Construction 3.2 is knowledge sound for ℛIPA: there is an extractor which, given rewindable access to any prover that makes the verifier accept with non-negligible probability, runs in expected polynomial time and outputs either a witness (𝐚,r) with P=⟨𝐚,𝐆⟩+[r]⁢H and ⟨𝐚,𝐛⁢(x)⟩=v, or a nontrivial discrete-logarithm relation among 𝐆, H and the verifier’s generators U, U′. Its knowledge error is O⁢(log⁡d/|𝔽|).

Proof.

The proof is given at the level of this volume: the single-round step is Lemma 3.4, the tree is an induction on it, and the rewinding that supplies the sibling transcripts is the Crypto Guide’s (§“The Schnorr identification protocol”, the remark on extraction by rewinding, and §“Sigma-protocols”, the tree-extraction theorem cited there, which also gives the expected running time). The trees it assembles have children with pairwise distinct challenges (the Crypto Guide’s Definition “Tree special soundness”), while Lemma 3.4 needs pairwise distinct squares. A square has at most two square roots, so any five pairwise distinct challenges contain three with pairwise distinct squares: the rewinding assembles five children per node, and the extractor uses three of them. From a tree the extractor computes a witness or, at the root, a discrete-logarithm relation; that definition asks for a witness alone, and the difference is where the assumption enters.

Leaves. Rewind the prover to the moment after it sent (L1,R1) and obtain three accepting final messages (a,r∗) for three challenges u1 with pairwise distinct squares. An accepting final message is, by (15), a representation of C(0) over (G(0),H,U), namely (a;r∗;a⁢b(0)), and it is well formed at level 0: its U-coordinate is the inner product of a with the length-one vector b(0). Lift it to level 1 by (20): 𝐱=(u1−1⁢a,u1⁢a).

One node. The three lifted leaves are well-formed representations of the three folded elements C(1)+[u12]⁢L1+[u1−2]⁢R1 over (𝐆(1),H,U). Lemma 3.4 at the round-1 node returns a well-formed representation of C(1) (and representations of L1 and R1, which are not needed further).

Induction. Rewind to the moment after (L2,R2), obtain three challenges u2 with pairwise distinct squares, and under each of them repeat the two steps above. That yields, after lifting to level 2, three well-formed representations of the elements C(2)+[u22]⁢L2+[u2−2]⁢R2, and the lemma at the round-2 node returns a well-formed representation of C(2). Continuing upward, after k levels the extractor holds a well-formed representation (𝐱;y;w) of C(k)=P+[v]⁢U over (𝐆,H,U), with w=⟨𝐱,𝐛⁢(x)⟩. The tree of transcripts consumed has three children at every node and depth k, hence 3k=dlog2⁡3 leaves (Figure 9).

The root, where the assumption enters. The root representation says P=⟨𝐱,𝐆⟩+[y]⁢H+[w−v]⁢U. If w=v then (𝐱,y) is a witness: P=⟨𝐱,𝐆⟩+[y]⁢H and ⟨𝐱,𝐛⁢(x)⟩=w=v. If w≠v, the extractor rewinds once more, to the setup step at which the verifier sampled U, and repeats the whole extraction under an independent sample U′, obtaining P=⟨𝐱′,𝐆⟩+[y′]⁢H+[w′−v]⁢U′. If w′=v the witness is (𝐱′,y′). Otherwise subtracting the two expressions for P gives

[w−v]⁢U−[w′−v]⁢U′+⟨𝐱−𝐱′,𝐆⟩+[y−y′]⁢H=𝒪

with the nonzero coefficient w−v on U: a nontrivial relation among the independent uniform generators 𝐆, H, U, U′, which the every-generator embedding of the Crypto Guide (§“Pedersen vector commitments”, the proof of binding) turns into a discrete logarithm, the reduction embedding its challenge in the public generators and in the verifier’s samples alike. This is the only place the assumption is used.

The error. The figure does not come from a union bound over the tree. At each node the extractor needs three siblings whose challenges avoid O⁢(1) values: ±ν for each earlier sibling’s challenge ν, so that the squares stay pairwise distinct. Each of the k=log2⁡d rounds therefore contributes O⁢(1/|𝔽|), and the rounds together with the resampling of U give O⁢(log⁡d/|𝔽|), the theorem’s figure. Collisions among the challenges resampled inside the 3k-leaf tree cost the extractor a rewind and a fresh sample; they affect its expected running time, not the knowledge error. A naive union bound over the roughly 3k sibling draws would bound the tree-wide collision probability by O⁢(dlog2⁡3/|𝔽|), still negligible, but that is not the source of the figure. The weaker O⁢(d/|𝔽|) sometimes quoted for this argument is implied by the proved bound; a larger protocol whose own error is already linear in d loses nothing by quoting it. □

What the theorem does not say.

The theorem concerns the interactive protocol; the compiled argument is treated in §5. In the algebraic group model the extractor does not rewind for the representations at all: an algebraic prover hands them over with every group element it sends, and the tree collapses to a single transcript (§5, “The algebraic group model”). After the Fiat–Shamir transform has replaced the verifier’s challenges by hashes, the rewinding above must be re-proved against a prover who can query the hash adaptively and resume from any earlier transcript state (for one round, the Crypto Guide’s forking lemma, §“Security in the random oracle model and the forking lemma”; the multi-round case in §5), and its cost cannot be obtained by multiplying every node of the tree by an independent 1/ε factor. Nor does the theorem restate the binding of the commitment itself: that a single P cannot be opened as two vectors is the Crypto Guide’s theorem, cited in §2.9 and not reproved here.

The assumption, and what breaks it.

The extractor’s alternative output is a discrete-logarithm relation among 𝐆, H and the verifier’s U, U′, so the argument is binding as long as discrete logarithms are hard in 𝔾 and the generators are uniform; hashed generators are uniform when hash-to-curve is modelled as a random oracle into 𝔾 (Crypto Guide, §“Hashing to a curve point”, Remark “Why NUMS generators are binding-safe”), a hypothesis of Theorem 3.5. For the deployed instance the group is the Vesta curve (§3.8), and the assumption that carries the argument is the discrete logarithm on Vesta, the first of the Crypto Guide’s standing assumptions (§“Standing assumptions”), against which the generic attacks cost about 2126 operations (§“Instantiation on elliptic curves; the Pasta curves”); a quantum adversary running Shor’s algorithm lies outside those assumptions, which fix a classical adversary. Suppose the assumption fails: an algorithm computes discrete logarithms on Vesta. Then it computes the logarithms η0,…,ηd−1,ηH of the hashed generators to one base, and every commitment P=[π]⁢base opens to every vector: for any 𝐚~ whatsoever, the blinder r~:=(π−⟨𝐚~,𝜼⟩)/ηH satisfies ⟨𝐚~,𝐆⟩+[r~]⁢H=P, and the honest protocol run on (𝐚~,r~) convinces the verifier of ⟨𝐚~,𝐛⁢(x)⟩, a value the cheat chose. One commitment then opens to two vectors and to two values at one point; binding and evaluation binding fall together, and with them the premise of Theorem 2.5 that the polynomials were fixed before z was drawn.

Example 3.6 (The extractor run on the toy).

The extractor is run against an honest prover for the running example’s vector 𝐚=(90,61,22,24) opened at z=20 with v=59, on the prime-order-97 curve and generators of §3.7, with the blinder r=88, so P=(51,31) and C(2)=P+[59]⁢U=(43,6). It fixes (L2,R2), branches over three round-2 challenges u2∈{18,81,21}, and under each fixes (L1,R1) and branches over three round-1 challenges: {85,19,84}, {37,43,46} and {38,43,93}, nine leaves in all. At the node u2=18 the 3×3 system has determinant 67 and returns the representation 𝐚(1)=(80,0) with blinder 3 and U-coordinate 40=⟨𝐚(1),𝐛(1)⟩, well formed as the lemma promises; the other two nodes return (50,41) and (85,35) likewise. At the root the system in u2 has determinant 75 and returns 𝐚=(90,61,22,24), r=88 and U-coordinate 59=v: the extracted witness is the committed vector, its blinder, and the true value. Figure 9 draws the tree with the node u2=18 called out.

Refer to caption
Figure 9: The extractor’s tree of accepting transcripts for d=4 (Example 3.6): every node branches over three challenges, every root-to-leaf path is one accepting run of Construction 3.2, and each node’s 3×3 system of Lemma 3.4 turns its three children’s representations into its own. The red node’s system and the root’s are written out beneath.

3.6 Zero knowledge: what the blinders hide and what they do not

The transcript of one opening consists of group elements, challenges and two final scalars. The group elements are hidden by the blinders: the commitment blinder r makes P uniform in 𝔾 whatever 𝐚 is (perfect hiding, Crypto Guide, §“The Pedersen commitment” and §“Pedersen vector commitments”), and the round blinders ℓj,ρj make every Lj and Rj uniform and independent of everything else for the same reason, since each carries its own fresh [ℓj]⁢H or [ρj]⁢H. The aggregated blinder r∗ is uniform too, being r plus a combination of the fresh ℓj and ρj. The final scalar is not hidden by these blinders.

Remark 3.7 (Folding alone is not zero knowledge).

The final scalar a=𝐚(0) is a linear form in the committed coefficients whose coefficients the verifier knows. Follow one coefficient ai through the k folds exactly as the proof of Theorem 3.3 followed Gm: the coefficient side folds with the weights (uj,uj−1), the inverse of the generator side’s (uj−1,uj), so ai reaches the single final entry multiplied by ∏ℓuℓ(−1)βℓ−1, the factor uℓ when the digit βℓ−1 of i is 0 and uℓ−1 when it is 1. Writing 𝐭 for this vector, ti=si−1 entry by entry, and

𝐚(0)=⟨𝐚,𝐭⟩,ti:=∏ℓ=1kuℓ(−1)βℓ−1=si−1;at d=4:𝐭=(u1u2,u1−1u2,u1u2−1,u1−1u2−1). (22)

In the toy of §3.7, with u2=52 and u1=20, the vector is 𝐭=(70,22,75,79), the entrywise inverse of the structured scalars 𝐬=(79,75,22,70), and the final scalar 33 is ⟨(90,61,22,24),(70,22,75,79)⟩. One opening thus hands the verifier one linear equation in the four secret coefficients; every further opening of the same commitment under fresh challenges hands him another, and d of them determine 𝐚 outright. Four openings of the same vector, with challenge pairs (u2,u1)=(63,29), (79,7), (34,1) and (49,74), end in the scalars 88, 22, 40 and 14, and solving the 4×4 system recovers (90,61,22,24). Blinding the commitment and the round points hides those points, not this scalar. The masked opening below therefore does not fold 𝐚 itself: it first masks the polynomial by an independently random polynomial vanishing at the opening point, so that the linear form is taken of a vector the verifier cannot relate to 𝐚. The mask’s commitment S and the challenge that follows it are essential to the zero-knowledge argument below.

The masked opening.

The masked opening runs Construction 3.2 on a masked statement.

  1. 1.

    Mask. Before any folding, the prover samples a polynomial s⁢(X)=∑i=0d−1mi⁢Xi of degree below d with s⁢(x)=0: she draws the coefficient vector 𝐦 uniformly from 𝔽d and then replaces m0 by m0−s⁢(x), which makes 𝐦 uniform on the hyperplane {𝐦:⟨𝐦,𝐛⁢(x)⟩=0}. She samples a blinder rs and sends

    S:=𝖢𝗈𝗆𝗆𝗂𝗍⁢(s;rs)=⟨𝐦,𝐆⟩+[rs]⁢H.
  2. 2.

    Challenge. The verifier sends a uniform ξ∈𝔽.

  3. 3.

    Opening. By linearity of the commitment (Crypto Guide, §“Pedersen vector commitments”, the remark that linearity survives),

    P+[ξ]⁢S=𝖢𝗈𝗆𝗆𝗂𝗍⁢(p+ξ⁢s;r+ξ⁢rs), (23)

    a commitment to the coefficient vector 𝐚+ξ⁢𝐦 of the polynomial p+ξ⁢s, whose value at x is p⁢(x)+ξ⁢s⁢(x)=v. The parties run Construction 3.2 on the statement (P+[ξ]⁢S,x,v) with the witness (𝐚+ξ⁢𝐦,r+ξ⁢rs), the verifier sampling U in its setup step, after S and ξ.

  4. 4.

    Final message and check. The prover sends the final scalar c:=(𝐚+ξ⁢𝐦)(0) and the aggregated blinder f:=r+ξ⁢rs+∑j=1k(uj2⁢ℓj+uj−2⁢ρj). The verifier accepts if and only if

    P+[ξ]⁢S+[v]⁢U+∑j=1k([uj2]⁢Lj+[uj−2]⁢Rj)⁢=?⁢[c]⁢G(0)+[f]⁢H+[c⋅b(0)]⁢U, (24)

    which is (15) for the masked statement.

Completeness is that of Construction 3.2, since the witness satisfies ℛIPA for the masked statement; the mask leaves the opened value unchanged because s⁢(x)=0. The transcript of one opening is

(S;Lk,Rk,…,L1,R1;c,f)with the challenges(ξ,U,uk,…,u1).

The hiding argument.

The final scalar is the linear form (22), taken of the masked vector:

c=⟨𝐚+ξ⁢𝐦,𝐭⟩=⟨𝐚,𝐭⟩+ξ⁢⟨𝐦,𝐭⟩. (25)

In the toy, with 𝐦=(66,23,23,88), for which s⁢(20)=0, and ξ=29, the masked vector is (64,49,10,54), its inner product with 𝐛⁢(20) is 59, and under the challenges u2=52, u1=20 of the unmasked run the final scalar is c=1=⟨(64,49,10,54),𝐭⟩ with 𝐭=(70,22,75,79); a second mask 𝐦′=(32,68,64,88) under the same challenges ends in c′=75, and both runs are accepted (§3.7). The same form, on a different masked vector, gives an unrelated scalar.

Proposition 3.8 (Honest-verifier zero knowledge of the masked opening).

Let 𝔾 have prime order p, and let the verifier draw ξ uniformly from 𝔽, U uniformly from 𝔾∖{𝒪} and each uj uniformly from 𝔽×. There is a simulator which, given (P,x,v) but not (𝐚,r), outputs challenges and a transcript whose distribution lies within statistical distance 1/|𝔽|+(2/(|𝔽|−1))k (Math Guide, §“Statistical distance”) of the honest one. The masked opening is therefore statistical honest-verifier zero knowledge, not perfect, in the sense of the Crypto Guide (§“The simulation paradigm and zero knowledge”).

Proof.

Call a challenge tuple good if ξ≠0 and 𝐭 is not a multiple of 𝐛⁢(x). The vector 𝐦 is uniform on the hyperplane ⟨𝐦,𝐛⁢(x)⟩=0, a subspace of dimension d−1. The linear functional 𝐦↦⟨𝐦,𝐭⟩ (Math Guide, §“Bilinear forms and the inner product on Fn”) restricted to that subspace is nonzero unless 𝐭 is a scalar multiple of 𝐛⁢(x). If 𝐭=λ⁢𝐛⁢(x), the first entries force λ=t0=∏ℓuℓ, and the entry at i=2ℓ−1, whose only nonzero digit is βℓ−1, reads t0⁢uℓ−2=t0⁢x2ℓ−1, that is, uℓ−2=x2ℓ−1; each of these k equations has at most two solutions uℓ, so at most 2k challenge tuples among (|𝔽|−1)k are excluded. A nonzero linear functional on a vector space is onto 𝔽, and its fibres are the cosets of its kernel, all of equal size, so it carries the uniform distribution to the uniform distribution on 𝔽. For good challenges ξ⁢⟨𝐦,𝐭⟩ is therefore uniform, and by (25) so is c, independently of 𝐚.

In an honest run with good challenges, S and every Lj, Rj are uniform and independent (fresh blinders), c is uniform and independent of them (the mask), and f is the unique scalar that makes (24) hold once everything else is fixed, H generating 𝔾. The simulator produces the same distribution in the reverse order, the way the Schnorr simulator chooses its commitment after the challenge (Crypto Guide, §“Sigma-protocols”): it draws the challenges as the verifier does, draws S, all Lj and all Rj but R1 uniformly from 𝔾, draws c and f uniformly from 𝔽, and sets R1 to the one point that satisfies (24), namely R1:=[u12]⁢(right-hand side−every other term of the left). Both distributions are uniform on the solution set of the one equation: the honest run parametrises that set by the 2⁢k+1 points and c, with f determined; the simulator parametrises it by 2⁢k points and the two scalars, with R1 determined; and each parametrisation is a bijection onto that set, with p2⁢k+2 points on each side since 𝔾 and 𝔽 both have p elements, because the determined coordinate is unique in each case. For good challenges the simulated transcript is therefore distributed exactly as the real one. The challenges have the same distribution in both, and the tuples that are not good have probability at most 1/|𝔽|+2k/(|𝔽|−1)k; the statistical distance is at most that probability. □

The gap, stated.

This argues one opening in isolation. The proof system opens many committed polynomials at once, under shared challenges, and the mask is one of several blinding devices it uses; whether the joint transcript reveals nothing is a separate question, addressed under “Zero knowledge: hiding the witness in Halo 2” in §4, where the mask, in the deployed form of §3.8, reappears as the last of those devices.

3.7 A complete toy opening, carried by script

The toy opening commits the running example’s advice polynomial, a⁢(X)=90+61⁢X+22⁢X2+24⁢X3 of §2.2, and opens it at the random point z=20 of §2.4 with v=a⁢(20)=59: the opening the proof system needs, of a column polynomial at the verifier’s random point, never of the statement polynomial at the running example’s secret witness 3. Every value below is computed by script and can be recomputed by hand in 𝔽97 and on a curve with 97 points.

A genuine group of order 97.

The vector 𝐚 lives in 𝔽974, so the commitment group must have order 97: scalars of a prime-order group live in the field of its order (Math Guide, §“Base fields, scalar fields, and the Pasta cycle”), exactly as the deployed circuit’s field is the scalar field of the deployed commitment curve. The group (𝔽97,+) has order 97 but trivially computable discrete logarithms, a division, so the toy uses an elliptic curve. For a curve over a prime field 𝔽q to have exactly 97 points, the Hasse bound (Math Guide, §“The group structure of E⁢(𝔽p)”) confines the prime q to |q+1−97|≤2⁢q: q∈{79,83,89,97,101,103,107,109,113}. The case q=97 is excluded on purpose: a curve with as many points as its base field has elements is anomalous, and its discrete logarithm is easy (Math Guide, §“The elliptic-curve discrete logarithm problem”). The first short Weierstrass curve (Math Guide, §“Weierstrass equations”) in lexicographic order of (q,A,B) with exactly 97 points is

E:y2=x3+3over ⁢𝔽79,#⁢E⁢(𝔽79)=97,

counted point by point; 97 is prime, so the group is cyclic and every point but 𝒪 generates it, and its trace 79+1−97=−17 is not 1. It is the same kind of object as the Math Guide’s worked curve y2=x3+5 over 𝔽11 (§“A worked toy example”), one size up. With 97 points every discrete logarithm on it is a short search; the toy exhibits the algebra of the argument, never its hardness.

Generators from a hash.

The generators are derived from public labels by hashing to the curve, as the deployed ones are: the label and a counter are hashed to a candidate x-coordinate, and the counter is incremented until x3+3 is a square in 𝔽79. This is a variant of the try-and-increment loop of the Crypto Guide (§“Hashing to a curve point”), which increments x itself; its constant-time refinement is irrelevant to a toy. Indexed from 0 so that the coefficient ai multiplies Gi, the generators are

G0=(12,25),G1=(17,27),G2=(71,26),G3=(49,10),H=(78,9),U=(53,26).

The hashed point U stands in for the verifier’s uniform sample of Construction 3.2. No party chose any of them, so no relation among them is known in advance; a single discrete logarithm between two of them would give one, since H=[h]⁢G0 yields [h]⁢G0−H=𝒪. On this curve such a logarithm is a short search; on Vesta its infeasibility is the assumption of §3.5.

The instance.

The prover holds 𝐚=(90,61,22,24), which takes the values (3,9,27,30) on the domain of §2.2, and the blinder r=10; her commitment is

P=[90]⁢G0+[61]⁢G1+[22]⁢G2+[24]⁢G3+[10]⁢H=(39,25).

The verifier holds P, the point z=20, hence 𝐛⁢(20)=(1,20,202,203)=(1,20,12,46) in 𝔽97, and the claimed value v=59=⟨𝐚,𝐛⁢(20)⟩. With d=4 there are k=2 rounds, numbered 2 then 1.

The symmetric opening, both sides.

Tables 4 and 5 refill the rows of Tables 2 and 3 with numbers, listing each party’s inputs and computations; the verifier’s table never uses 𝐚.

step receives / holds computes and sends
setup holds 𝐚=(90,61,22,24), r=10, z=20, v=59; receives U=(53,26) 𝐚(2):=𝐚, 𝐆(2):=(G0,G1,G2,G3), 𝐛(2):=(1,20,12,46), r(2):=10
round 2 halves 𝐚lo=(90,61), 𝐚hi=(22,24); 𝐛lo=(1,20), 𝐛hi=(12,46) samples ℓ2=44, ρ2=16; ⟨𝐚lo,𝐛hi⟩=6, ⟨𝐚hi,𝐛lo⟩=17; sends L2=[90]⁢G2+[61]⁢G3+[44]⁢H+[6]⁢U=(74,6), R2=[22]⁢G0+[24]⁢G1+[16]⁢H+[17]⁢U=(38,72)
receives u2=52 (u2−1=28) 𝐚(1)=52⁢(90,61)+28⁢(22,24)=(58,61); 𝐛(1)=28⁢(1,20)+52⁢(12,46)=(70,42); 𝐆(1)=([28]⁢G0+[52]⁢G2,[28]⁢G1+[52]⁢G3)=((54,40),(30,71)); r(1)=10+522⋅44+282⋅16=95
round 1 halves alo=58, ahi=61; blo=70, bhi=42 samples ℓ1=12, ρ1=37; alo⁢bhi=11, ahi⁢blo=2; sends L1=[58]⁢G1(1)+[12]⁢H+[11]⁢U=(28,25), R1=[61]⁢G0(1)+[37]⁢H+[2]⁢U=(39,25)
receives u1=20 (u1−1=34) a(0)=20⋅58+34⋅61=33; b(0)=34⋅70+20⋅42=19; G(0)=[34]⁢G0(1)+[20]⁢G1(1)=(12,25); r(0)=95+202⋅12+342⋅37=40
final a=33, r∗=40 sends a=33, r∗=40
Table 4: The prover’s side of the toy opening (Table 2 with numbers): 𝐚=(90,61,22,24) opened at z=20 on the 97-point curve y2=x3+3 over 𝔽79, all scalars in 𝔽97. Points are given as (x,y) with coordinates in 𝔽79.
step receives / holds computes and sends
setup holds P=(39,25), z=20, v=59, 𝐆, H=(78,9) sends U=(53,26), a hashed point standing in for his sample; C(2):=P+[59]⁢U=(47,39)
round 2 receives L2=(74,6), R2=(38,72) samples u2=52 and sends it; keeps (L2,R2,52); C(1):=C(2)+[522]⁢L2+[282]⁢R2=(72,23)
round 1 receives L1=(28,25), R1=(39,25) samples u1=20 and sends it; keeps (L1,R1,20); C(0):=C(1)+[202]⁢L1+[342]⁢R1=(54,39)
final receives a=33, r∗=40 𝐬=(34⋅28, 20⋅28, 34⋅52, 20⋅52)=(79,75,22,70); G(0)=[79]⁢G0+[75]⁢G1+[22]⁢G2+[70]⁢G3=(12,25); b(0)=g⁢(20;20,52)=(34+20⋅20)⁢(28+52⋅12)=19; right-hand side [33]⁢G(0)+[40]⁢H+[33⋅19]⁢U=(54,39)=C(0): accept
Table 5: The verifier’s side of the same opening (Table 3 with numbers). He never sees 𝐚, r, ℓj or ρj; the structured scalars and g⁢(20) come from the two challenges alone, and G(0) is his one length-4 multi-scalar multiplication.

The verifier’s equation (15) closes: the left-hand side P+[59]⁢U+[522]⁢L2+[282]⁢R2+[202]⁢L1+[342]⁢R1 is (54,39), and so is the right-hand side [33]⁢G(0)+[40]⁢H+[33⋅19]⁢U. Each fold identity holds along the way: after round 2, (72,23)=⟨𝐚(1),𝐆(1)⟩+[95]⁢H+[⟨𝐚(1),𝐛(1)⟩]⁢U, and after round 1, (54,39)=[33]⁢(12,25)+[40]⁢H+[33⋅19]⁢U. The closed forms of Theorem 3.3 agree with the folds: ⟨𝐬,𝐆⟩=(12,25) is the G(0) the prover reached by folding, and g⁢(20;u1,u2)=(u1−1+u1⁢z)⁢(u2−1+u2⁢z2)=19 is her b(0). In a group of 97 elements collisions among the printed points are frequent, and nothing follows from any of them. Here G(0) happens to equal G0 and R1 happens to equal P; the masked run below and the runs of §3.8 show more.

A false value is rejected.

Let the prover claim v′=60 instead of 59. The prover’s messages are those of the honest run; only C(2)=P+[60]⁢U changes, by one more U. The left-hand side becomes (62,15) while the right-hand side stays (54,39), and the verifier rejects. By Theorem 3.5, a prover accepted on v′=60 would yield an opening of P with value 60 and hence, beside the honest opening, a discrete-logarithm relation among the generators; on a curve of 97 points such relations are a short search, and the theorem gives no security there.

The masked opening of the same polynomial.

The same P is then opened at the same z with the masked opening of §3.6. The prover samples 𝐦=(66,23,23,88), for which s⁢(20)=0, and rs=95, and sends S=⟨𝐦,𝐆⟩+[95]⁢H=(70,71); the verifier answers ξ=29. The masked vector 𝐚+29⁢𝐦=(64,49,10,54) has inner product 59 with 𝐛⁢(20), and the rounds run on it with the point U, the challenges u2=52, u1=20 and the round blinders of the unmasked run: the prover sends L2=(36,7), R2=(12,25), L1=(51,31) and R1=(72,23), and ends in c=1 and f=79. The final generator G(0)=(12,25) and the final evaluation scalar b(0)=19 are those of the unmasked run, since they depend on the challenges alone. The verifier’s equation (24) closes at (46,13) on both sides, and the false value v′=60 moves the left-hand side to (56,70): rejected. A second mask 𝐦′=(32,68,64,88) under the same challenges ends in c′=75 and is accepted as well.

3.8 Halo 2’s specifics: parameters, generators from a hash, the deferred multi-scalar multiplication, and the proof bytes

Everything above holds for any prime-order group and any d=2k. This subsection, and only this one, fixes the group, the size, the generators and the normalisation of the deployed Halo 2, states its opening, and counts the bytes an Orchard proof spends on the argument. Nothing earlier in the section depends on it.

The group and the size.

The Orchard Action circuit does its arithmetic in 𝔽p𝖯𝖺𝗅𝗅𝖺𝗌, the base field of the Pallas curve, because the statement manipulates Pallas points and their coordinates live there (§1.2; Math Guide, §“Base fields, scalar fields, and the Pasta cycle”). Its column polynomials therefore have coefficients in 𝔽p𝖯𝖺𝗅𝗅𝖺𝗌, and a Pedersen commitment to such a vector needs a group whose scalar field is 𝔽p𝖯𝖺𝗅𝗅𝖺𝗌: that group is the Vesta curve, whose order is p𝖯𝖺𝗅𝗅𝖺𝗌 (protocol specification, § 5.4.9.6, “Pallas and Vesta”). The specification uses Halo 2 with the Vesta curve to prove and verify the Action statement (§ 4.1.13, “Zero-Knowledge Proving System”), so every P, Lj, Rj, S and G(0) of this section is a Vesta point and every scalar a Pallas base-field element. The other half of the Pasta cycle, Pallas’s scalar field being Vesta’s base field, is needed only by the optional native recursion of §7; Orchard’s verifier never uses it. The committed polynomials have degree below the row count n=211=2048 of the Action circuit (Definition 2.7; the count is given under “From statement to circuit: arithmetisation in practice” in §4), so here d=n=211 and the argument runs k=11 rounds.

Generators from a hash.

The 2048 vector generators, the blinding generator H and the inner-product generator U are all outputs of hash-to-curve on one fixed domain-separation label, the vector generators indexed by their position and H and U by two further tags (Crypto Guide, §“Hashing to a curve point”, Construction “Nothing-up-my-sleeve generators”). With hash-to-curve modelled as a random oracle into 𝔾 they are independent and uniform, and a relation among them yields a discrete logarithm on Vesta (the same section, Remark “Why NUMS generators are binding-safe”). No secret is generated in producing them, unlike the trapdoor of KZG (Crypto Guide, §“Polynomial commitment schemes”, under “KZG: evaluation in the exponent”), the point the closing subsubsection returns to. Because U is a fixed parameter rather than a verifier’s sample drawn after each P, the deployed opening re-randomises it per opening with a challenge ζ (“The deployed opening in full” below).

Challenges from the transcript.

The interactive verifier of Construction 3.2 draws uj uniformly from 𝔽×, and the halo2 book’s Protocol Description excludes zero challenges. The deployed verifier is a hash (“Removing the verifier: the Fiat–Shamir transform” in §4), and the transcript of the halo2_proofs implementation squeezes every challenge, ξ, ζ and each uj, as a full field element with no rejection of zero. A zero uj would make the fold’s inversion fail, so the honest prover succeeds unless one of the k challenges is zero, an event of probability 1/|𝔽| per challenge, about 2−254: completeness of the deployed argument is overwhelming, not literally perfect, in the sense fixed in §1.2.

Remark 3.9 (The deployed IPA normalisation).

The deployed opening, stated in full below, is the masked opening of §3.6 with three changes. It folds with the weights (1,uj−1) on the coefficient vector and (1,uj) on 𝐛 and 𝐆, with cross terms Lj=⟨𝐚hi,𝐆lo⟩+⋯ and Rj=⟨𝐚lo,𝐆hi⟩+⋯, the halves swapped relative to (13), and the verifier’s accumulation [uj−1]⁢Lj+[uj]⁢Rj; it scales the cross terms’ U-coordinates by a further challenge ζ drawn after ξ; and it moves the claimed value into the commitment as −[v]⁢G0 in place of +[v]⁢U. Its final scalars are c and f, and its check is (29). The halo2 book, which the protocol specification (§ 5.4.10.3, “Halo 2”) cites for the proving system, states this opening in its chapter Protocol Description. Its blinding generator W is this volume’s H, its U is U, and its second challenge z is ζ, renamed because z=20 is the running example’s opening point; the book’s comparison with the scheme of Bünz, Chiesa, Mishra and Spooner (chapter Comparison to other work) writes H, U and z for the same three objects. The chapter numbers the round challenges from the first round, u0,…,uk−1, where this volume’s descending index gives uk,…,u1, and states the verifier’s evaluation polynomial (its κ) as

gdep⁢(X) =∏i=0k−1(1+uk−1−i⁢X2i) in its numbering, (26)
gdep⁢(X) =∏ℓ=1k(1+uℓ⁢X2ℓ−1) in this volume’s,

with structured scalars si=∏ℓ:βℓ−1=1uℓ, beside the symmetric g⁢(X)=∏ℓ=1k(uℓ−1+uℓ⁢X2ℓ−1) of (19) with si=∏ℓuℓ(−1)1−βℓ−1.

The change of variables. The two folds are one argument. Run both on the same vector, the same generators and the same evaluation vector, with the deployed challenge of every round the square of the symmetric one, udep:=usym2. In one round, writing u for usym,

𝐚sym′ =u⁢𝐚lo+u−1⁢𝐚hi=u⁢(𝐚lo+u−2⁢𝐚hi)=u⁢𝐚dep′,
𝐆sym′ =u−1⁢𝐆lo+u⁢𝐆hi=u−1⁢(𝐆lo+u2⁢𝐆hi)=u−1⁢𝐆dep′,
𝐛sym′ =u−1⁢𝐛lo+u⁢𝐛hi=u−1⁢(𝐛lo+u2⁢𝐛hi)=u−1⁢𝐛dep′,

so 𝐚dep′=u−1⁢𝐚sym′, 𝐆dep′=u⁢𝐆sym′ and 𝐛dep′=u⁢𝐛sym′, and the scalings cancel in every inner product: ⟨𝐚dep′,𝐆dep′⟩=⟨𝐚sym′,𝐆sym′⟩ and ⟨𝐚dep′,𝐛dep′⟩=⟨𝐚sym′,𝐛sym′⟩. The cross terms agree, up to their H-blinders, once the naming is unwound: the deployed L carries ⟨𝐚hi,𝐆lo⟩, which the symmetric presentation calls R, and its weight udep−1=u−2 is the symmetric weight on R; likewise for the other cross term. The single-round form holds for one round on identical inputs; over several rounds the change of variables is cumulative, because each round’s inputs already carry the previous rounds’ factors:

𝐚dep(j)=(∏ℓ>juℓ)−1⁢𝐚sym(j),𝐆dep(j)=(∏ℓ>juℓ)⁢𝐆sym(j),𝐛dep(j)=(∏ℓ>juℓ)⁢𝐛sym(j), (27)

with uℓ the symmetric challenges of the rounds already run. Each deployed factor of (26) is a symmetric factor scaled, 1+u2⁢Xm=u⁢(u−1+u⁢Xm), so after k rounds

gdep=(∏ℓ=1kuℓ)⁢gsym,𝐬dep=(∏ℓ=1kuℓ)⁢𝐬sym,adep(0)=(∏ℓ=1kuℓ)−1⁢asym(0),

while G(0) and b(0) carry the product itself, so that [a(0)]⁢G(0) and a(0)⁢b(0) agree in both normalisations, and the two verifier equations coincide once each run attaches ℓj and ρj to the same cross product. Table 6 prints both runs on the toy’s data and keeps the blinder names instead, so the deployed run attaches each blinder to the other cross product, and its equation differs from the symmetric one only in the H-term (r∗=33 against 40); with the blinders exchanged, the deployed run also closes at (54,39) with r∗=40. What the substitution does not do is identify the challenge distributions: a uniform deployed challenge is not the square of a uniform symmetric one (“Extraction in the deployed rows” below), so the deployed rows are analysed with their own lemma, and the deployed opening is knowledge sound by the argument of §3.5 with Lemma 3.10 at every node and two branchings, over ξ and ζ, in place of the resampled U at the root: Corollary 3.13.

symmetric fold deployed fold relation
round 2: challenge u2=52 u2=522=85
cross terms sent L2=(74,6), R2=(38,72) L2=(78,70), R2=(71,26) halves swapped
𝐚(1) (58,61) (72,59) 52−1⋅
𝐆(1) ((54,40),(30,71)) ((53,53),(41,6)) 52⋅
𝐛(1) (70,42) (51,50) 52⋅
round 1: challenge u1=20 u1=202=12
cross terms sent L1=(28,25), R1=(39,25) L1=(43,6), R1=(70,71) halves swapped
a(0) 33 85 (52⋅20)−1=70−1⋅
G(0) (12,25) (34,53) 70⋅
b(0) 19 69 70⋅
structured scalars 𝐬 (79,75,22,70) (1,12,85,50) 70⋅
g⁢(20) (u1−1+u1⁢z)⁢(u2−1+u2⁢z2)=19 (1+u1⁢z)⁢(1+u2⁢z2)=69 70⋅
aggregated blinder r∗ 40 33
verifier’s equation (54,39)=(54,39) (5,72)=(5,72) same [a(0)]⁢G(0), a(0)⁢b(0)
Table 6: The two folds on the same 𝐚=(90,61,22,24), the same generators and the same 𝐛⁢(20), with udep=usym2 in every round and the same round blinders. The last column is the cumulative factor of (27): after round 2 it is 52, after round 1 it is 52⋅20=70 in 𝔽97. The cross terms differ as points because the deployed naming attaches each blinder to the other cross product; every folded quantity differs by the stated factor only.

Extraction in the deployed rows.

The deployed fold changes the rows of the extractor’s linear system.

Lemma 3.10 (Single-round recovery in the deployed rows).

Fix one round at level j as in Lemma 3.4, but let the round fold the coefficient vector with the weights (1,u−1) and the generator and evaluation vectors with the weights (1,u),

𝐚′:=𝐚lo+u−1⁢𝐚hi,𝐆′:=𝐆lo+u⁢𝐆hi,𝐛′:=𝐛lo+u⁢𝐛hi,

with the cross terms named with the halves swapped relative to (13),

L:=⟨𝐚hi,𝐆lo⟩+[ℓ]⁢H+[⟨𝐚hi,𝐛lo⟩]⁢U,R:=⟨𝐚lo,𝐆hi⟩+[ρ]⁢H+[⟨𝐚lo,𝐛hi⟩]⁢U,

and the folded commitment C′:=C+[u−1]⁢L+[u]⁢R, so that the fold identity reads C′=⟨𝐚′,𝐆′⟩+[r+u−1⁢ℓ+u⁢ρ]⁢H+[⟨𝐚′,𝐛′⟩]⁢U by the same expansion as in §3.2. Then the conclusions of Lemma 3.4 hold with rows (ν−1,1,ν) and the identities 𝐱ν=ν−1⁢𝐱L+𝐱C+ν⁢𝐱R (likewise for y, w), provided only that u,u′,u′′ are pairwise distinct and nonzero. The deployed cross terms also scale their U-coordinates by a challenge ζ≠0 drawn before the rounds (“The deployed opening in full” below), which the lemma covers verbatim with U replaced by [ζ]⁢U.

Proof.

The fold identity is the expansion of §3.2 with the weights changed: the diagonal terms of ⟨𝐚lo+u−1⁢𝐚hi,𝐆lo+u⁢𝐆hi⟩ carry the weights 1⋅1 and u−1⁢u=1, and the cross terms ⟨𝐚hi,𝐆lo⟩ and ⟨𝐚lo,𝐆hi⟩ carry u−1 and u, which is why they are absorbed as [u−1]⁢L+[u]⁢R with L holding the high-with-low product. The lift (20) becomes 𝐱=(𝐚′,u⁢𝐚′), and preserves well-formedness since ⟨(𝐚′,u⁢𝐚′),𝐛⟩=⟨𝐚′,𝐛lo+u⁢𝐛hi⟩. The matrix now has rows (ν−1,1,ν); multiplying the row of ν by ν≠0 gives (1,ν,ν2), and the same root count, now for a polynomial of degree at most 2 in ν itself, shows that the matrix is invertible exactly when the challenges are pairwise distinct. Everything else is as in the proof of Lemma 3.4. □

The two row shapes impose different hypotheses: two challenges u′=−u have equal squares, so a triple containing them makes the symmetric matrix singular, while the deployed matrix remains invertible whenever the three challenges are distinct and nonzero. Over 𝔽97 the triple (3,94,5), in which 94=−3, has squares (9,9,25): the symmetric rows are (9,1,54), (9,1,54) and (25,1,66), two of them equal, with determinant 0; the deployed rows are (65,1,3), (32,1,94) and (39,1,5), with determinant 28≠0. Remark 3.9 shows that the deployed fold is the symmetric fold under the substitution udep=usym2, but that relabelling does not carry the hypotheses across: the squaring map 𝔽×→𝔽× is two-to-one onto the squares, so a uniform deployed challenge is not the square of a uniform symmetric one, and the condition “pairwise distinct squares” is a condition on three symmetric challenges that has no counterpart for three uniform deployed ones. Each shape is therefore analysed with its own rows. In the proof of Theorem 3.5 with Lemma 3.10 in place of Lemma 3.4, three pairwise distinct nonzero challenges suffice at each node, and each sibling avoids the earlier siblings’ challenges and 0.

Example 3.11 (The extractor in the deployed rows).

On the data of Example 3.6, the extractor with rows (u−1,1,u) and the fold of Lemma 3.10 branches over its own challenges: u2∈{78,83,56} at the root, and under them the round-1 triples {31,71,92}, {91,50,47} and {95,14,96}. The node systems have determinants 70, 41 and 33 and the root system 54, and the extractor recovers the same 𝐚=(90,61,22,24), r=88 and U-coordinate 59=v.

The deployed opening in full.

The deployed opening is the masked opening of §3.6 with the deployed fold, a further challenge ζ, and the claimed value moved into the commitment. Let 𝐞0:=(1,0,…,0), and write 𝐭 for the coefficient-side vector and 𝐬 for the structured scalars of the deployed fold throughout the rest of this subsection.

  1. 1.

    Mask. The prover samples s⁢(X) with s⁢(x)=0 and rs, and sends S:=𝖢𝗈𝗆𝗆𝗂𝗍⁢(s;rs)=⟨𝐦,𝐆⟩+[rs]⁢H, as in §3.6.

  2. 2.

    Two challenges. The verifier sends a uniform ξ, and then a uniform ζ.

  3. 3.

    The masked commitment. Both parties replace P by

    P′:=P+[ξ]⁢S−[v]⁢G0, (28)

    which, by linearity of the commitment (Crypto Guide, §“Pedersen vector commitments”, the remark that linearity survives), commits with blinder r+ξ⁢rs to the coefficient vector

    𝐚′:=𝐚+ξ⁢𝐦−v⁢𝐞0

    of the polynomial p+ξ⁢s−v, whose value at x is p⁢(x)+ξ⁢s⁢(x)−v=0. The claim “p⁢(x)=v” has become the claim “P′ commits to a vector whose inner product with 𝐛⁢(x) is 0”: the value is folded into the commitment, and the opening claims the value 0.

  4. 4.

    Rounds. The parties run the k rounds on (𝐚′,𝐆,𝐛⁢(x)) with the fold of Lemma 3.10, weights (1,uj−1) on the coefficients and (1,uj) on generators and evaluation vector, and with the U-coordinates of the cross terms scaled by ζ:

    Lj :=⟨𝐚hi′⁣(j),𝐆lo(j)⟩+[ℓj]⁢H+[ζ⁢⟨𝐚hi′⁣(j),𝐛lo(j)⟩]⁢U,
    Rj :=⟨𝐚lo′⁣(j),𝐆hi(j)⟩+[ρj]⁢H+[ζ⁢⟨𝐚lo′⁣(j),𝐛hi(j)⟩]⁢U;

    the verifier accumulates [uj−1]⁢Lj+[uj]⁢Rj, and the prover’s blinder accumulates f:=r+ξ⁢rs+∑j(uj−1⁢ℓj+uj⁢ρj).

  5. 5.

    Final message and check. The prover sends the final scalars c:=𝐚′⁣(0) and f. The verifier accepts if and only if

    P+[ξ]⁢S−[v]⁢G0+∑j=1k([uj−1]⁢Lj+[uj]⁢Rj)⁢=?⁢[c]⁢G(0)+[c⋅b(0)⋅ζ]⁢U+[f]⁢H, (29)

    where G(0)=⟨𝐬,𝐆⟩ and b(0)=⟨𝐬,𝐛⁢(x)⟩=gdep⁢(x) for the structured scalars si=∏ℓ:βℓ−1=1uℓ of (26).

Completeness is the invariant (16) again, with 𝐚′ in place of 𝐚, the value 0 in place of v, and every U-coordinate scaled by ζ; the final U-coordinate is ζ⁢⟨𝐚′⁣(0),𝐛(0)⟩=c⁢b(0)⁢ζ. Subtracting [v]⁢G0 moves the claimed value into the commitment, so that the argument opens to 0 and the check carries no term in v on U; the mask leaves the opened value unchanged in either form because s⁢(x)=0. The halo2 book gives the reason in its comparison with the scheme of Bünz, Chiesa, Mishra and Spooner, which adds the value on the inner-product generator instead (chapter Comparison to other work): G0 is a fixed base, so [v]⁢G0 is the cheaper multiplication inside a recursive verifier. The factor ζ has a reason of its own. The deployed U is a fixed public generator rather than a verifier’s sample drawn after P (“Generators from a hash” above): a prover who knew U in advance could plant a U-component in P or S, and drawing ζ after both re-randomises the generator that carries the inner product, so that a planted component would have to have anticipated ζ; Corollary 3.13 makes this precise.

Hiding in the deployed opening.

The final scalar is the linear form of (22) for this fold, taken of the masked vector:

c=⟨𝐚+ξ⁢𝐦−v⁢𝐞0,𝐭⟩=⟨𝐚−v⁢𝐞0,𝐭⟩+ξ⁢⟨𝐦,𝐭⟩,ti=∏ℓ:βℓ−1=1uℓ−1, (30)

the coefficient side folding with the inverse weights of the generator side as always. Unmasked, the deployed fold leaks this form as the symmetric one does (Remark 3.7): four deployed openings of (90,61,22,24) without the mask, with challenge pairs (u2,u1)=(16,85), (8,16), (69,95) and (11,41), end in the scalars 70, 24, 73 and 63, and solving the 4×4 system recovers the vector. Masked, with 𝐦=(66,23,23,88), ξ=29 and the challenges u2=85, u1=12, the masked vector is (5,49,10,54), its inner product with 𝐛⁢(20) is 0, and the final scalar is c=20=⟨(5,49,10,54),𝐭⟩ with 𝐭=(1,89,8,33); a second mask 𝐦′=(32,68,64,88) under the same challenges ends in c′=46, and both runs are accepted. The transcript of one opening is

(S;Lk,Rk,…,L1,R1;c,f)with the challenges(ξ,ζ,uk,…,u1).
Corollary 3.12 (Honest-verifier zero knowledge of the deployed opening).

Let 𝔾 have prime order p, and let the verifier draw ξ,ζ uniformly from 𝔽 and each uj uniformly from 𝔽×. There is a simulator which, given (P,x,v) but not (𝐚,r), outputs challenges and a transcript of the deployed opening whose distribution lies within statistical distance 1/|𝔽|+(|𝔽|−1)−k of the honest one.

Proof.

The proof of Proposition 3.8, with the deployed 𝐭 and with (29) in place of (24). Call a challenge tuple good if ξ≠0 and 𝐭 is not a multiple of 𝐛⁢(x); now 𝐭=λ⁢𝐛⁢(x) forces λ=t0=1 and then uℓ−1=x2ℓ−1 for every ℓ, at most one challenge tuple among (|𝔽|−1)k. For good challenges c is uniform and independent of 𝐚 by (30) and the argument of that proof. The simulator draws the challenges, S, every Lj and every Rj but R1, and c and f uniformly, and sets R1 to the one point that satisfies (29), namely R1:=[u1−1]⁢(right-hand side−every other term of the left); the counting of that proof shows that the two distributions agree for good challenges, and the tuples that are not good have probability at most 1/|𝔽|+(|𝔽|−1)−k. □

The deployed opening of the toy polynomial.

The toy’s P of §3.7 is opened at z=20 with the deployed opening, using the round challenges u2=85 and u1=12 of Table 6; Table 7 lists both sides with every intermediate value. The verifier’s equation (29) closes at (5,72) on both sides, with g⁢(20)=(1+12⋅20)⁢(1+85⋅202)=69 and 𝐬=(1,12,85,12⋅85)=(1,12,85,50) in the deployed shape, and the false value v′=60 moves the left-hand side to (67,31) against (5,72) on the right: rejected once more. The deployed run and the masked symmetric run of §3.7 open the same commitment to the same value with entirely different numbers; Remark 3.9 relates the two folds. The unmasked deployed run of Table 6 and this masked opening both close at (5,72), and that run’s R1=(70,71) equals the mask commitment S: further collisions of the kind noted in §3.7, accidents of a 97-element group, not consequences of the mask.

step prover verifier
mask samples 𝐦=(66,23,23,88), for which s⁢(20)=0, and rs=95; sends S=⟨𝐦,𝐆⟩+[95]⁢H=(70,71) receives S; sends ξ=29, then ζ=12
masked vector 𝐚′=𝐚+29⁢𝐦−59⁢𝐞0=(5,49,10,54); ⟨𝐚′,𝐛⁢(20)⟩=0; blinder f:=10+29⋅95 P′:=P+[29]⁢S−[59]⁢G0
round 2 halves 𝐚lo′=(5,49), 𝐚hi′=(10,54); ℓ2=44, ρ2=92; cross terms ⟨𝐚hi′,𝐆lo⟩=[10]⁢G0+[54]⁢G1=(34,53), ⟨𝐚hi′,𝐛lo⟩=23, ⟨𝐚lo′,𝐆hi⟩=[5]⁢G2+[49]⁢G3=(54,39), ⟨𝐚lo′,𝐛hi⟩=83; sends L2=(34,53)+[44]⁢H+[12⋅23]⁢U=(17,52), R2=(54,39)+[92]⁢H+[12⋅83]⁢U=(47,40) sends u2=85 (85−1=8); keeps (L2,R2,85); P′⁣(1):=P′+[8]⁢L2+[85]⁢R2=(64,5)
folds 𝐚′⁣(1)=(5,49)+8⁢(10,54)=(85,93), 𝐛(1)=(1,20)+85⁢(12,46)=(51,50), 𝐆(1)=(G0+[85]⁢G2,G1+[85]⁢G3) =((53,53),(41,6)); f=10+29⋅95+8⋅44+85⋅92=73
round 1 halves alo′=85, ahi′=93; ℓ1=95, ρ1=56; cross terms [93]⁢G0(1)=(58,8), 93⋅51=87, [85]⁢G1(1)=(24,9), 85⋅50=79; sends L1=(58,8)+[95]⁢H+[12⋅87]⁢U=(46,13), R1=(24,9)+[56]⁢H+[12⋅79]⁢U=(24,70) sends u1=12 (12−1=89); keeps (L1,R1,12); P′⁣(0):=P′⁣(1)+[89]⁢L1+[12]⁢R1=(5,72)
folds c=a′⁣(0)=85+89⋅93=20, b(0)=51+12⋅50=69, G(0)=G0(1)+[12]⁢G1(1)=(34,53); f=73+89⋅95+12⋅56=82
final sends c=𝐚′⁣(0)=20, f=82 g⁢(20)=(1+12⋅20)⁢(1+85⋅202)=69; 𝐬=(1,12,85,50), G(0)=⟨𝐬,𝐆⟩=(34,53); left: P′+[85−1]⁢L2+[85]⁢R2+[12−1]⁢L1+[12]⁢R1=(5,72); right: [20]⁢G(0)+[20⋅69⋅12]⁢U+[82]⁢H=(5,72): accept; with v′=60: left (67,31)≠(5,72): reject
Table 7: The deployed opening of the same P=(39,25) at z=20 with the deployed mask: the fold of Lemma 3.10, the cross terms named with the halves swapped, the U-coordinates scaled by ζ, the value 0 opened for P+[ξ]⁢S−[v]⁢G0, and the final scalars c and f. The round challenges are those of Table 6.
Corollary 3.13 (Knowledge soundness of the deployed opening).

Let 𝔾, 𝐆 and H be as in Theorem 3.5, and let U be a fixed generator, uniform in 𝔾∖{𝒪} like them. The deployed opening, with the check (29), is knowledge sound for ℛIPA: there is an extractor which, given rewindable access to any prover that makes the verifier accept with non-negligible probability, runs in expected polynomial time and outputs either a witness (𝐚,r) for (P,x,v) or a nontrivial discrete-logarithm relation among 𝐆, H and U. Its knowledge error is O⁢(log⁡d/|𝔽|).

Proof.

The extractor branches over two values ξ1≠ξ2 after S, under each over two nonzero values ζ1≠ζ2, and under each of those over the rounds as in the proof of Theorem 3.5, with three pairwise distinct nonzero challenges per node; the tree has 4⋅3k leaves, and the rewinding and running time are as in that proof.

Rounds. Fix ξ and ζ≠0, and write Uζ:=[ζ]⁢U. With Uζ in place of U the rounds are those of Lemma 3.10, so the induction in the proof of Theorem 3.5 returns a representation (𝐱;y;w) of P′=P+[ξ]⁢S−[v]⁢G0 over (𝐆,H,Uζ) with w=⟨𝐱,𝐛⁢(x)⟩, that is, the representation (𝐱;y;ζ⁢w) over (𝐆,H,U).

The challenge ζ. Under one ξ, the values ζ1 and ζ2 give representations (𝐱1;y1;ζ1⁢w1) and (𝐱2;y2;ζ2⁢w2) of the same P′ over (𝐆,H,U). If they differ, their difference is a nontrivial relation among 𝐆, H and U. Otherwise 𝐱1=𝐱2=:𝐱, so w1=w2=:w and (ζ1−ζ2)⁢w=0, whence w=0: P′=⟨𝐱,𝐆⟩+[y]⁢H with ⟨𝐱,𝐛⁢(x)⟩=0.

The challenge ξ. The values ξ1 and ξ2 follow the same S and give P+[ξi]⁢S−[v]⁢G0=⟨𝐱i,𝐆⟩+[yi]⁢H with ⟨𝐱i,𝐛⁢(x)⟩=0 for i=1,2. Subtracting, S=⟨𝐦,𝐆⟩+[rs]⁢H with 𝐦:=(𝐱1−𝐱2)/(ξ1−ξ2), rs:=(y1−y2)/(ξ1−ξ2) and ⟨𝐦,𝐛⁢(x)⟩=0. Substituting back, P=⟨𝐚,𝐆⟩+[r]⁢H with 𝐚:=𝐱1−ξ1⁢𝐦+v⁢𝐞0 and r:=y1−ξ1⁢rs, and ⟨𝐚,𝐛⁢(x)⟩=0−0+v⋅1=v, the first entry of 𝐛⁢(x) being 1. This is the witness.

The error. Beyond the O⁢(log⁡d/|𝔽|) of the rounds, the two branchings at the root and the exclusion of ζ=0 each cost O⁢(1/|𝔽|). A relation among 𝐆, H and U yields a discrete logarithm by the every-generator embedding, as at the root of Theorem 3.5. □

The bytes.

An Orchard proof is a byte string. The proofs of the a≥1 Action descriptions that one transaction carries in one pool, here called a bundle, are aggregated into a single proof (protocol specification, § 4.6, “Action Descriptions”); a transaction with Actions in both the Orchard and the Ironwood pool carries one such proof for each. Its length is 2720+2272⁢a bytes (ZIP 225, the sizeProofsOrchard field; ZIP 229, the fields sizeProofsOrchard and sizeProofsIronwood; the consensus rule is the protocol specification’s, § 7.5, “Action Description Encoding and Consensus”), 4992 bytes for a single Action. Every Vesta point and every field element in it occupies 32 bytes. Table 8 lists by kind, from the per-object counts of the Action circuit whose verifying key the consensus rules fix (protocol specification, § 4.6, “Action Descriptions”), every one of those bytes: a per-Action block of 22 points and 49 scalars, repeated for each Action, and a shared block of 33 points and 52 scalars. The inner-product argument’s share is the last three rows of the shared block: the blinding commitment S, the k=11 pairs (Lj,Rj), which are 22 points, and the two scalars c and f: 23 points, 736 bytes, or 800 bytes with the scalars, once per bundle, because the complete protocol collapses every opening of every polynomial into one opening (“The multipoint opening argument” in §4). This is the only part of the proof that grows with n, and it grows as 2⁢log2⁡n+1 points. Everything else grows with the circuit’s structure and not with n: one commitment per advice column, two permuted-column commitments and one running product per lookup, the permutation running products and quotient chunks, the multipoint commitment, and one field element per claimed evaluation.

kind count bytes what it is
Per-Action block, once per Action
point 10 320 advice column commitments, one per advice column
point 3 96 permuted lookup input commitments A′, one per lookup (Construction 2.14)
point 3 96 permuted lookup table commitments S′, one per lookup (Construction 2.14; unrelated to the mask commitment S)
point 3 96 permutation running-product commitments: the 15 equality-enabled columns in chunks of 7 (§2.6)
point 3 96 lookup running-product commitments, one per lookup
scalar 1 32 instance column evaluation at x
scalar 25 800 25=5⋅2+5⋅3 advice evaluations, one per queried rotation of each advice column (§4.4)
scalar 8 256 permutation product evaluations: 3 products at x and ω⁢x, the first 2 also at ω−6⁢x, the rotation to the boundary row n−nblind−1 of Remark 2.17, with nblind=5 blinding rows (§4.6)
scalar 15 480 lookup evaluations: product at x and ω⁢x; A′ at x and ω−1⁢x; S′ at x
total 2272 22 points and 49 scalars
Shared block, once per bundle
point 1 32 random polynomial commitment: a random polynomial added to blind the quotient (the complete protocol, §4)
point 8 256 quotient chunk commitments: constraint degree dmax=9, so dmax−1=8 chunks of degree below n (Theorem 4.7)
scalar 29 928 fixed column evaluations at x, one per fixed column
scalar 15 480 permuted-label polynomial evaluations at x, one per equality-enabled column (Construction 2.10)
scalar 1 32 random polynomial evaluation at x
point 1 32 multipoint polynomial commitment: the one polynomial into which every query collapses (Construction 4.4)
scalar 5 160 multipoint evaluations: the value of each query group’s combined polynomial at the reduction’s fresh challenge point, one per distinct set of query points; five sets (§4.4)
point 1 32 IPA: the blinding commitment S
point 22 704 IPA: the k=11 pairs (Lj,Rj)
scalar 2 64 IPA: the final scalars c and f
total 2720 33 points and 52 scalars
Table 8: The bytes of an Orchard proof, 2720+2272⁢a for a Actions (ZIP 225, ZIP 229), laid out as points and scalars of 32 bytes each. The three rows marked IPA are this section’s: 23 points and 2 scalars, 800 bytes, shared by the whole bundle. The advice, permutation, lookup and quotient rows are the objects of §2; the random polynomial is constructed under “The complete Halo 2 protocol” and the multipoint polynomial under “The multipoint opening argument”, both in §4.

3.8.1 The “Halo” in Halo 2: deferring the expensive check

The verifier of this section is logarithmic everywhere but in one place. He reads 2⁢k+1 points and two scalars, evaluates g in 3⁢k−2 field multiplications, and forms the left-hand side of (29) with 2⁢k+2 scalar multiplications ([ξ]⁢S, [v]⁢G0 and the 2⁢k round terms); then he needs G(0)=⟨𝐬,𝐆⟩, one combination of all 2048 generators, group arithmetic proportional to the size of the whole circuit (§3.4). Two ways of amortising that cost follow, batch verification and accumulation, the second not deployed by Orchard; between them, the paragraph “Transparency: no trusted setup” records why the linear cost is accepted.

Batch verification.

The consensus rules require each Action proof to be valid for the verifying key of the Orchard circuit (protocol specification, § 4.6, “Action Descriptions”); validity includes the check (29) with its multi-scalar multiplication of length d, and the specification composes no proofs, so the verifier pays that multiplication itself rather than passing it on. Several proofs can share it (Crypto Guide, §“Polynomial commitment schemes”, Remark “KZG versus IPA, and the Halo lineage”). Written as one multi-scalar multiplication that must evaluate to 𝒪, equation (29) has d+2⁢k+4 terms: the generators G0,…,Gd−1, U, H, P, S and the 2⁢k points Lj, Rj. The equations E1,…,Eb of b proofs are checked together by testing ∑i[μi]⁢Ei=𝒪 for fresh uniform μi∈𝔽 drawn by the verifier.

Lemma 3.14 (Randomised batch check).

Let 𝔾 have prime order, let E1,…,Eb∈𝔾, and let μ1,…,μb∈𝔽 be independent and uniform. If some Ei≠𝒪, then Pr⁢[∑j[μj]⁢Ej=𝒪]=1/|𝔽|.

Proof.

Fix i with Ei≠𝒪 and condition on every μj with j≠i. Since 𝔾 has prime order, Ei generates it, so μ↦[μ]⁢Ei is a bijection 𝔽→𝔾, and the sum equals 𝒪 for exactly one value of μi. □

Because 𝐆, U and H are shared, their terms merge, and b equations combine into one multi-scalar multiplication of d+2+b⁢(2⁢k+2) terms, against b⁢(d+2⁢k+4) when checked separately. In the complete protocol P is itself a combination of commitments (§4); those of the verifying key are shared as well, and each further proof adds its own points, the 22⁢a+33 of Table 8, and the instance commitments computed from its public inputs, one per Action (§4.2). The d=2048 generator terms are paid once per batch. A batch check is not accumulation: it emits nothing that a later proof could consume, and it verifies the batch and stops. Both take linear combinations of deferred equations; their interfaces and guarantees differ, and the accumulation scheme of Bünz, Chiesa, Mishra and Spooner, sketched below under “Accumulation (not deployed by Orchard)”, is not part of the specified protocol.

Transparency: no trusted setup.

The generators are outputs of a public hash-to-curve map on fixed inputs (this subsection, “Generators from a hash”); the scheme has no trapdoor and requires no trusted setup, unlike KZG, whose trapdoor permits forgeries (Crypto Guide, §“Polynomial commitment schemes”, under “KZG: evaluation in the exponent”). The price is the 2⁢k+1 points of Table 8, against the constant-size opening proof of KZG, and the linear verifier. ZIP 224’s motivation names the generation of the structured reference string of Zcash’s earlier proving system a point of risk within the protocol and asks for a proving system that does not require one (ZIP 224, Motivation).

Accumulation (not deployed by Orchard).

In a recursive verifier, a circuit that verifies a proof, the multi-scalar multiplication G(0)=⟨𝐬,𝐆⟩=𝖢𝗈𝗆𝗆𝗂𝗍⁢(g; 0) of §3.4 would cost d scalar multiplications inside the circuit. Instead the claim is combined with a running claim of the same shape, G′⁣(0)=𝖢𝗈𝗆𝗆𝗂𝗍⁢(g′; 0), by a random linear combination with a challenge ρ drawn after both (a verifier challenge, not a round blinder ρj of this section; §7 keeps the letter): G(0)+[ρ]⁢G′⁣(0)=𝖢𝗈𝗆𝗆𝗂𝗍⁢(g+ρ⁢g′; 0) holds for all ρ when both inputs hold and for at most one ρ otherwise. The combined claim, returned to a single tuple by a prover-assisted opening, is the accumulator carried along the chain of proofs, and a single multi-scalar multiplication outside any circuit at the end discharges all combined claims. The soundness of an accumulation scheme for a closely related inner-product commitment is cited in §7 from Bünz, Chiesa, Mishra and Spooner, under the extractability of its openings, which they conjecture from the binding of the Pedersen commitment; the cycle of curves that keeps the recursive arithmetic in the right fields is the other half of Pasta. Both are developed in §7, under “Accumulation and the Halo trick” and “A cycle of curves for efficient native recursion”, where recursion and accumulation over the cycle are classified designed-but-unspecified in the sense of §1.2: the protocol specification uses Halo 2 only to prove and verify Action statements and composes no proofs.