The Zcash ArboretumThe Complete Arboretum PDF

2 Arithmetisation: from a computation to committed polynomials

This section carries the running example of §1 — the prover knows x=3 with x3+x+5=35 over 𝔽97 — from a computation to a handful of polynomials that a verifier can query at one point, toy first and general second. It ends with the property the argument has not yet provided: that the queried polynomials are fixed before the evaluation point is chosen.

2.1 From computation to a grid of constraints

The verifier cannot evaluate the computation without the witness. Arithmetisation dismantles the computation into local facts, each involving only a handful of values, arranged so that “every local fact holds and the values are consistently shared” is equivalent to “the whole computation ran correctly”. The dialect of arithmetisation Halo 2 uses is called PLONKish; §2.5 defines it once the toy has shown what it generalises.

Execution trace.

Evaluate x3+x+5 the way a machine would, naming every intermediate value:

x2=x⋅x,x3=x2⋅x,s=x3+x,s+5=35.

Four elementary operations, two multiplications and two additions, and each becomes one row of a table. A row has three wires a,b,c (two inputs and an output) and a bank of five selectors qM,qL,qR,qO,qC that switch on whichever gate the row performs. The universal gate equation, imposed at every row, is

qM⁢a⁢b+qL⁢a+qR⁢b+qO⁢c+qC+PI=0, (1)

where PI carries the negated public input on that row (here −35, for the target 35). A multiplication gate a⋅b=c is the choice qM=1, qO=−1 and the rest zero; an addition gate a+b=c is qL=qR=1, qO=−1. Filling in the four operations gives the execution trace of Table 1. Definition 2.7 generalises this fixed selector bank to arbitrary custom gates and lookup arguments (the halo2 book’s PLONKish Arithmetization chapter); §4 gives the form of the Action circuit’s gates, and one in full, under “From statement to circuit: arithmetisation in practice”.

row a b c qM qL qR qO qC PI gate performed
0 3 3 9 1 0 0 −1 0 0 x⋅x=x2
1 9 3 27 1 0 0 −1 0 0 x2⋅x=x3
2 27 3 30 0 1 1 −1 0 0 x3+x=s
3 30 0 0 0 1 0 0 5 −35 s+5=35
Table 1: The execution trace for x=3, all entries in 𝔽97 (so −1=96 and −35=62). Every row satisfies the gate equation (1): row 0 reads 1⋅3⋅3+(−1)⋅9=0 and row 3 reads 1⋅30+5+(−35)=0. The selector columns q∙ are fixed circuit data and PI is the negated public input, both known to the verifier; the wires a,b,c are the prover’s advice, her secret trace.

Copy constraints.

The table as printed does not yet encode the computation. Nothing forces the x in row 0 to equal the x in rows 1 and 2, nor the output x2=9 of row 0 to be the input of row 1. A cheating prover could put x=3 in row 0 and x=8 in row 2 and satisfy each gate in isolation without the rows forming one computation. The missing assertions are that certain cells are equal, the copy constraints (also called equality constraints):

a0=b0=b1=b2⏟all are ⁢x=3,c0=a1⏟x2=9,c1=a2⏟x3=27,c2=a3⏟s=30,

where aj denotes the cell of column a in row j. Figure 2 draws them as wires. They turn a list of unrelated gates into a single dataflow; enforcing them is an argument in its own right, the permutation argument of §2.6.

Refer to caption
Figure 2: The four-row trace of Table 1 with the copy constraints drawn as wires. Each wire colour is one class of cells that must hold a single value: the blue wire ties the four occurrences of x, and the three coloured wires carry each row’s output cj into the next row’s input aj+1. The gates check rows; the wires make the rows one computation.

Satisfiability of the grid.

The claim is now equivalent to a purely combinatorial assertion: there exist values for the advice cells a,b,c such that (i) every row satisfies the gate equation (1) with the fixed selectors, and (ii) every copy constraint holds. Knowing x is exactly knowing how to fill the advice columns. The verifier knows the fixed columns and the public input; the prover must convince him that satisfying advice exists while revealing none of it. Everything that follows is machinery for doing precisely that.

2.2 From the grid to polynomials

The grid has finitely many rows, and the aim is a statement about all rows at once that the verifier can check at one point. A polynomial of degree less than n is determined by its values at n distinct points (Math Guide, §“Lagrange interpolation”), and the rest of the section relies on this.

An index set for the rows.

The table has n=4 rows, and four distinct field elements must name them. The chosen four are the 4th roots of unity. A primitive n-th root of unity is an element ω with ωn=1 and no smaller positive power equal to 1 (Math Guide, §“Roots of unity”), and the evaluation domain it generates is H={ω0,…,ωn−1}, a multiplicative subgroup of 𝔽× of order n (Math Guide, §“The evaluation domain H and its vanishing polynomial”). In 𝔽97 take ω=22: then ω2=96=−1 and ω4=1, so

H={ω0,ω1,ω2,ω3}={1,22,96,75}={1,22,−1,−22},

and row i lives at the point ωi. Roots of unity are chosen because they form a cyclic group: the row after ωi is ω⋅ωi, so reading a column at the next row is evaluating its polynomial at ω⁢X; the polynomial vanishing on H is Xn−1; and interpolation over H is a fast Fourier transform (Math Guide, §“The fast Fourier transform”). The gate check of this subsection alone would hold over any four distinct points.

Columns become polynomials.

Each column of the table is four numbers, one per row. Interpolate: for the advice column a there is a unique polynomial a⁢(X) of degree <4 with

a⁢(ω0)=3,a⁢(ω1)=9,a⁢(ω2)=27,a⁢(ω3)=30

(Math Guide, §“Lagrange interpolation”), and likewise b⁢(X), c⁢(X), the publicly known selector polynomials qM,qL,qR,qO,qC and the public-input polynomial PI, each of degree <4. Computed over 𝔽97, the nine interpolants are

a⁢(X) =90+61⁢X+22⁢X2+24⁢X3, qM⁢(X) =49+19⁢X+30⁢X3,
b⁢(X) =75+32⁢X+25⁢X2+65⁢X3, qL⁢(X) =49+78⁢X+67⁢X3,
c⁢(X) =65+16⁢X+3⁢X2+22⁢X3, qR⁢(X) =73+24⁢X+73⁢X2+24⁢X3,
PI⁢(X) =64+50⁢X+33⁢X2+47⁢X3, qO⁢(X) =72+54⁢X+24⁢X2+43⁢X3,
qC⁢(X) =74+76⁢X+23⁢X2+21⁢X3,

and each returns its column at the rows: b takes the values (3,3,3,0) on H, qO the values (96,96,96,0), and PI the values (0,0,0,62). Interpolation is thus a bijection between columns of four values and polynomials of degree <4: the encoding loses no information.

The gate polynomial.

Assemble the left-hand side of the gate equation (1) with the polynomials in place of the per-row numbers.

Theorem 2.1 (The gate polynomial).

Let

G⁢(X):=qM⁢(X)⁢a⁢(X)⁢b⁢(X)+qL⁢(X)⁢a⁢(X)+qR⁢(X)⁢b⁢(X)+qO⁢(X)⁢c⁢(X)+qC⁢(X)+PI⁢(X). (2)

Then deg⁡G≤9, and G⁢(ωi)=0 for every row i if and only if every gate of the trace is satisfied.

Proof.

The term qM⁢a⁢b multiplies three polynomials of degree at most 3, and every other term has degree at most 6, so deg⁡G≤9. Evaluate G at the label ωi of row i: each column polynomial returns that row’s value there, so G⁢(ωi) is exactly the left-hand side of (1) for row i. It is zero precisely when gate i holds, and the conjunction over i gives the claim. □

For the honest trace,

G⁢(X)=36+27⁢X+54⁢X2+50⁢X3+77⁢X4+24⁢X5+43⁢X6+47⁢X7+81⁢X8+46⁢X9,

of degree exactly 9, and it vanishes at all four points of H by construction. “Every gate is satisfied” has become “G vanishes on H”; the copy constraints remain separate. Four separate checks are now one statement about one polynomial.

2.3 From vanishing to a single identity

The condition “G vanishes on H” is still a statement about four points. This subsection replaces it by a polynomial identity that refers to no individual row.

The vanishing polynomial.

The vanishing polynomial of H is the monic polynomial (leading coefficient 1) whose roots are exactly the points of H,

ZH⁢(X):=∏i=03(X−ωi)=X4−1,

where the closed form Xn−1 holds for every evaluation domain of order n (Math Guide, §“The evaluation domain H and its vanishing polynomial”): each ωi is a root of Xn−1, there are n distinct ones, and comparing leading coefficients finishes. The closed form lets both parties evaluate ZH at any point with O⁢(log⁡n) multiplications.

Theorem 2.2 (Gate satisfaction is a quotient).

Every gate of the trace holds if and only if there is a polynomial t⁢(X) with G⁢(X)=t⁢(X)⁢ZH⁢(X).

Proof.

By Theorem 2.1, every gate holds if and only if G vanishes on H. The factor theorem (Math Guide, §“Roots and the factor theorem”) gives G⁢(ωi)=0 if and only if (X−ωi)∣G; and because the four roots are distinct, G vanishes at all of them if and only if the product of the four linear factors divides G (Math Guide, §“Lagrange interpolation”, its remark on the vanishing polynomial: a polynomial vanishes on a set of distinct nodes if and only if the product of the corresponding linear factors divides it). Thus

G⁢ vanishes on ⁢H⇔(X−ωi)∣G⁢ for each ⁢i⇔ZH⁢(X)∣G⁢(X), (3)

and divisibility is the existence of the quotient t. □

Satisfaction of the gate constraints is precisely the existence of t; correct wiring still requires the copy constraints. For the honest trace the division comes out even: G has degree 9, ZH has degree 4, and

t⁢(X)=G⁢(X)X4−1=61+70⁢X+43⁢X2+47⁢X3+81⁢X4+46⁢X5

is a polynomial of degree 5 with remainder zero, as it must be.

Example 2.3 (Why a cheat cannot produce t).

Suppose the advice is wrong: some gate fails. Then G does not vanish on all of H, so by (3) ZH does not divide G, and no polynomial t satisfies G=t⁢ZH. The dividing line is exact: the quotient exists if and only if every gate is satisfied. Concretely, take a prover who claims x2=10 and writes c0=10 in row 0 of Table 1 instead of 9. Row 0’s gate now reads 3⋅3−10=−1≠0, so the tampered gate polynomial G∗ has G∗⁢(ω0)=−1=96 while still vanishing at the other three rows:

G∗⁢(X)=54+10⁢X+43⁢X2+74⁢X3+83⁢X4+65⁢X5+78⁢X6+47⁢X7+81⁢X8+46⁢X9.

Dividing G∗ by ZH with remainder (Math Guide, §“Division with remainder”) gives the quotient t∗⁢(X)=67+14⁢X+78⁢X2+47⁢X3+81⁢X4+46⁢X5 and a nonzero remainder. This Euclidean quotient is an illustrative choice for t∗, not a claim that it maximises the cheat’s chances. Whatever t∗ she offers as the quotient, the gap polynomial D⁢(X):=G∗⁢(X)−t∗⁢(X)⁢ZH⁢(X) is nonzero, since ZH does not divide G∗. For the Euclidean quotient D is the remainder,

D⁢(X)=24⁢(1+X+X2+X3), (4)

of degree 3. The identity G∗=t∗⁢ZH is false, D is the difference of its two sides, and §2.4 shows how the verifier detects D≠0.

2.4 Why checking one random point is a proof

The prover wishes to convince the verifier that G⁢(X)=t⁢(X)⁢ZH⁢(X) as polynomials, with G built from her secret advice. The verifier does not read the polynomials: they encode the witness, and reading them would cost time at least linear in the number of rows. Instead, the two run a four-step protocol. A commitment is, for now, a short string that fixes a value without revealing it (Crypto Guide, §“Commitment schemes”); §2.9 says what a commitment to a polynomial must do and which one Halo 2 uses.

Construction 2.4 (The random-point check).
  1. 1.

    The prover commits to her polynomials a,b,c and to the quotient t; the selector and public-input polynomials the verifier already knows.

  2. 2.

    The verifier picks a point z∈𝔽 uniformly at random and sends it.

  3. 3.

    The prover opens her commitments at z: she returns the field elements a⁢(z),b⁢(z),c⁢(z),t⁢(z) together with short proofs that these are the true evaluations of the committed polynomials.

  4. 4.

    The verifier forms G⁢(z) from the openings and the self-evaluated public polynomials via (2), computes ZH⁢(z)=z4−1, and checks the single field equation

    G⁢(z)⁢=?⁢t⁢(z)⁢ZH⁢(z). (5)

He accepts if and only if (5) holds.

The honest case (completeness).

If the prover is honest then G=t⁢ZH holds as polynomials, hence at every point, hence at z. With the honest trace and the draw z=20,

ZH⁢(20)=204−1=46,t⁢(20)=67,G⁢(20)=75=67⋅46=t⁢(20)⁢ZH⁢(20),

and the verifier accepts. He accepts every time, for every z.

The dishonest case (soundness).

Soundness rests on the fact that a nonzero polynomial of low degree has few roots.

Theorem 2.5 (Soundness of the random-point check).

Suppose the trace is invalid, so that the prover’s gate polynomial G∗ does not vanish on all of H, and let t∗ be any polynomial she commits to as the quotient. Set D⁢(X):=G∗⁢(X)−t∗⁢(X)⁢ZH⁢(X). Then D is a nonzero polynomial, and if the prover’s polynomials a,b,c (which determine G∗) and t∗ are fixed before z is drawn and the verifier receives their true evaluations at z,

Prz⁢[the verifier accepts]=Prz⁢[D⁢(z)=0]≤deg⁡D|𝔽|.
Proof.

Were D the zero polynomial, G∗=t∗⁢ZH would be divisible by ZH and so, by (3), vanish on all of H, which it does not. Hence D≠0 for every choice of t∗. By hypothesis a,b,c and t∗, and with them G∗ and D, are fixed before z is drawn (the verifier never receives G∗ itself; from the evaluations at z he reconstructs only the single number G∗⁢(z)). The check (5) passes at z exactly when G∗⁢(z)−t∗⁢(z)⁢ZH⁢(z)=D⁢(z)=0, that is, exactly when z is a root of D. A nonzero polynomial of degree at most deg⁡D has at most deg⁡D roots, so a uniformly random z is one of them with probability at most deg⁡D/|𝔽| (Math Guide, §“The Schwartz–Zippel lemma”). □

The bound deg⁡D/|𝔽| is negligible when |𝔽| is exponential in the security parameter and deg⁡D is polynomial in it. The verifier does not recompute the trace; he tests one polynomial identity at one random point.

Example 2.6 (The random-point check on the toy).

For the x2=10 cheat of Example 2.3, D⁢(X)=24⁢(1+X+X2+X3) has degree 3 and so at most 3 roots; in 𝔽97 its roots are exactly {22,96,75}, the three rows where the tampered gate still held (Figure 3). This particular quotient choice slips past only if the random z lands in that three-element set:

Pr⁢[cheat accepted]=397.

At the actual draw z=20∉{22,96,75} the openings give G∗⁢(20)=20 but t∗⁢(20)⁢ZH⁢(20)=64; since 20≠64, the verifier rejects.

Refer to caption
Figure 3: The gap polynomial D=24⁢(1+X+X2+X3) of the x2=10 cheat over 𝔽97: its three roots 22,75,96 marked in red, the point 1∈H (not a root) in grey, and the verifier’s draw z=20 landing elsewhere. The check (5) passes only at a root of D.

Scale.

The fraction 3/97 is large only because the field is a toy, and it concerns one particular quotient; the next paragraph bounds every cheat by 11/97. What such a term means at the deployed field size is the scale caveat of §1.2.

Bounding the degree.

The argument needs deg⁡D small relative to |𝔽|, otherwise “deg⁡D roots out of |𝔽|” is no constraint at all. The commitment scheme enforces a degree bound on every committed polynomial (Crypto Guide, §“Polynomial commitment schemes”), so the prover cannot commit to a t∗ of unbounded degree. The bound follows the degree the commitment admits, not the honest degree. The wires are committed at degree below n=4, so deg⁡G∗≤9; committed as the two pieces of degree below n that the deployed rule below prescribes, t∗ has degree at most 7, so deg⁡(t∗⁢ZH)≤11 and deg⁡D≤11. Every cheat is therefore accepted with probability at most 11/97, and some cheat attains it, where the illustrative quotient reaches 3/97: the t∗ of degree 7 that agrees with G∗/ZH at the eight points 2,…,9 gives D the eleven roots 2,…,9,22,75,96. This is why a circuit’s gates are kept to low degree, and why the quotient t, of degree 5 here and up to a few times n in general, is split into degree-bounded pieces. In the deployed system the quotient is cut into pieces of degree below n, each committed separately (the halo2 book’s Vanishing argument chapter); “The complete Halo 2 protocol” in §4 gives the count.

2.5 PLONKish arithmetisation

The toy has met every ingredient concretely: an evaluation domain H, a generator ω, the vanishing polynomial ZH, columns interpolated into polynomials of degree <n, and a gate expressed as a polynomial identity on H. The general object can now be named.

Definition 2.7 (PLONKish constraint system).

Fix a prime field 𝔽 and an integer k with 2k∣|𝔽|−1, so that 𝔽× contains a primitive 2k-th root of unity ω (Math Guide, §“Existence over finite fields: the condition n∣q−1”), and let H:={ω0,…,ωn−1}⊂𝔽× be the multiplicative subgroup of size n:=2k that ω generates. Its vanishing polynomial is ZH⁢(X):=Xn−1, zero exactly on H, so a congruence p⁢(X)≡0(modZH⁢(X)) means “p is zero at every row ωi”, that is, ZH∣p. A PLONKish circuit 𝒞 over H consists of:

  1. 1.

    a finite set Col of columns, each of n cells, one per row, partitioned into fixed columns (preprocessed circuit data, known to both parties), advice columns (the prover’s witness) and instance columns (public input); a cell is an element of H×Col, and the circuit assigns every cell of a fixed column its value;

  2. 2.

    a maximum constraint degree dmax;

  3. 3.

    a finite set R⊂ℤ of rotations containing 0; a column expression is a polynomial over 𝔽 in the values v⁢(ωr⁢X) for v∈Col and r∈R, where the value of v at rotation r at row i is the cell of v in row i+r taken modulo n;

  4. 4.

    a finite sequence of custom gates gj=0, each gj a column expression of degree at most dmax;

  5. 5.

    a set Hact⊆H of active rows: all of H in the toy, and in the deployed system the first u<n rows ω0,…,ωu−1, the trailing rows being reserved for a boundary row and blinding (Remark 2.17 fixes u);

  6. 6.

    a subset E⊆Hact×Col of equality-constrained cells together with a permutation σ of E (a bijection E→E) whose cycles, the orbits {κ,σ⁢(κ),σ2⁢(κ),…} of the cells κ∈E, are the classes of cells required to hold a common value;

  7. 7.

    a set of lookup arguments, each an input tuple (A0,…,Am−1) of column expressions and a table tuple (S0,…,Sm−1) of columns.

An assignment gives every cell a value in 𝔽, the fixed cells their circuit values; write vκ for the value of cell κ. It is satisfying if every gate vanishes at every row of H (in the deployed system the selectors are zero outside Hact), vκ=vσ⁢(κ) for every κ∈E, and for every lookup and every active row ωi the tuple (A0⁢(ωi),…,Am−1⁢(ωi)) equals (S0⁢(ωi′),…,Sm−1⁢(ωi′)) for some active row ωi′. The relation ℛ𝒞 of the circuit is the set of pairs (instance-column values, advice-column values) of the satisfying assignments.

The letter d is reserved, from §3 on, for the length of a committed vector; the constraint degree is therefore written dmax throughout this volume.

Vanilla PLONK as the special case.

The original PLONK system of Gabizon, Williamson and Ciobotaru uses a single fixed five-selector universal gate,

qM⁢(X)⁢a⁢(X)⁢b⁢(X)+qL⁢(X)⁢a⁢(X)+qR⁢(X)⁢b⁢(X)+qO⁢(X)⁢c⁢(X)+qC⁢(X)+PI⁢(X)≡0(modZH⁢(X)),

with three wire polynomials a,b,c, selector polynomials qM,qL,qR,qO,qC and the public-input polynomial PI, carrying the negated public inputs; the toy’s gate (1) is exactly this gate, with PI held in an instance column. PLONKish generalises it by permitting designer-chosen gates of higher arity and degree, each switched by its own selector qi⁢(X), a fixed column that vanishes on the rows where the gate is inactive. In the toy the five selectors are fixed columns, a,b,c are advice, PI is the instance column, the single gate has degree 3 and reads rotation 0 only, and the copy constraints of §2.1 are the equality set E with σ cycling each class; there are no lookups until §2.7. Figure 4 shows the general shape.

Refer to caption
Figure 4: The PLONKish grid of Definition 2.7: columns by kind (fixed q0,q1; advice A0,A1,A2; instance I; a fixed table column S), rows indexed by the domain H. The outlined gate at row ω1 reads its columns at rotations 0 and +1; the green double arrow is one cycle of the equality permutation σ joining two advice cells; the red arrow is a lookup asserting that an advice value appears in S.

Columns as committed polynomials.

With the Lagrange basis ℓj⁢(X) of H, defined by ℓj⁢(ωj)=1 and ℓj⁢(ωj′)=0 for j′≠j (Math Guide, §“The Lagrange basis on H”), a column with cells v0,…,vn−1 is the polynomial v⁢(X)=∑jvj⁢ℓj⁢(X) of degree <n, exactly as the toy’s columns were interpolated in §2.2. The prover commits to each advice polynomial, and the fixed polynomials are committed once for all proofs, with the inner-product polynomial commitment of §3. Every argument that follows — gates, permutation, lookup, vanishing — is a polynomial identity on these committed polynomials, verified by querying them at random points exactly as §2.4 queried G and t.

2.6 Enforcing the wiring: the permutation argument

The copy constraints of §2.1 remain to be enforced. The gate identity of §§2.2–2.4 checks each row separately; it does not assert that a0,b0,b1,b2 are the same value x, or that row 1’s input is row 0’s output, and a prover could satisfy every gate with rows that do not form one computation. The permutation argument reduces the equalities to the equality of two products, which is checked at random challenges.

Equalities as a permutation.

Group the cells into the classes that must share a value, {a0,b0,b1,b2}, {c0,a1}, {c1,a2}, {c2,a3}, and let σ be the permutation of the twelve cells that cycles each class in the order written and fixes b3 and c3:

a0→b0→b1→b2→a0,c0↔a1,c1↔a2,c2↔a3.

Give every cell a distinct label: the cell in row j of the a-, b-, c-column gets ωj, k1⁢ωj, k2⁢ωj respectively, where k1,k2 place the three columns in disjoint cosets of H so that no two labels collide. Two cosets of a subgroup are equal or disjoint (Math Guide, §“Cosets and Lagrange’s theorem”), so it suffices that k1, k2 and k2/k1 all lie outside H; in 𝔽97 take k1=2, k2=3:

H={1,22,96,75},2⁢H={2,44,95,53},3⁢H={3,66,94,31}.

Write λcell for a cell’s label and vcell for its value. Asserting “cells in a class are equal” is then equivalent to asserting that the multiset (a finite collection in which an element may occur more than once; two multisets are equal when every element occurs equally often in both) of pairs {(vcell,λcell)} is unchanged when each label is replaced by the label of the cell’s image under σ: a pair (v,λ) moves to (v,λσ), and the moved pair was already present exactly when the cell at λσ carried the same value v. Figure 5 draws the cycles with their labels. Because labels are distinct, comparing two multisets of pairs is a job for a product: compress each pair to the linear form v+β⁢λ+γ with verifier challenges β,γ, and compare

∏cells(vcell+β⁢λcell+γ)against∏cells(vcell+β⁢λσ⁢(cell)+γ). (6)

If the wiring is honest the two products run over the same multiset of factors and agree identically in β,γ. If a copy constraint is false the difference is a nonzero polynomial in β,γ, which can still vanish at one particular challenge pair, but only rarely; the converse is probabilistic, not an “if and only if” for fixed challenges. Theorem 2.11 below makes both halves precise.

Refer to caption
Figure 5: Left: the four copy classes of the toy as cycles of σ on the grid, every cell showing its value and its label λ (column a in H, column b in 2⁢H, column c in 3⁢H); the arrow closing the x-class cycle, from b2 back to a0, is omitted. Right: the x-class with b1 tampered to 4; the two arrows leaving and entering the tampered cell now join unequal values, so four factors of (6), two in each product, have no partner in the other product.

The running product.

A product over all cells is not a local fact, so the prover commits to a running product: a column Zperm with Zperm⁢(ω0)=1 whose row j+1 equals row j times the ratio of row j’s factors in (6), numerator over denominator. After the last row the product has run over every cell, and because ωn=ω0 the row-to-row rule at the last row forces the full product to equal Zperm⁢(ω0)=1 again: the grand product is 1 exactly when the running product closes its loop. The deployed circuit imposes the rule cross-multiplied, “next row times denominator equals this row times numerator”, not as a field division, so a zero factor never makes the constraint undefined; the prover commits to Zperm and the verifier checks the boundary value and the row-to-row update at the random point, exactly as he checked the gate identity (the halo2 book’s Permutation argument chapter). The identities are written out in Construction 2.10.

A single wired pair.

Strip the product down to a single wired pair, c0=a1 (both should be 9), with labels λc0=3 and λa1=22 that σ swaps. Their factors satisfy

(9+β⁢λc0+γ)⁢(9+β⁢λa1+γ)=(9+β⁢λa1+γ)⁢(9+β⁢λc0+γ),

because the shared value 9 makes the two left-hand factors a mere reordering of the two right-hand ones: the labels may permute under σ precisely because the values agree. Now let the prover cheat the copy, a1=8≠9. The factor 8+β⁢λa1+γ on the left is matched on the right only by 8+β⁢λc0+γ, which differs since the labels differ; the two products differ as polynomials in β,γ. A single unequal value thus leaves a factor without a partner, and the two products differ.

Example 2.8 (The permutation check on the toy).

For the honest trace with β=γ=2, the ratio of the two products in (6) over all twelve cells is exactly 1. Tamper one wire, setting b1=4 and so breaking the copy b1=x=3, and the same ratio at the same challenges becomes 61≠1: the inconsistent dataflow is exposed without any value being revealed.

The general argument.

Halo 2 states the argument for any number of columns, and the statement needs one lemma on two-variable polynomials. The Schwartz–Zippel lemma of the Math Guide (§“The Schwartz–Zippel lemma”) is univariate; that section’s remark on the multivariate generalisation states the several-variable bound without proof, as a consequence of the univariate lemma applied once per variable, and Lemma 2.9 carries out that derivation for two variables.

Lemma 2.9 (Two variables).

Let P∈𝔽⁢[β,γ] be nonzero, of degree at most N in each variable separately. For β,γ drawn independently and uniformly from 𝔽, Pr⁢[P⁢(β,γ)=0]≤2⁢N/|𝔽|.

Proof.

Write P=∑ece⁢(β)⁢γe with coefficients ce∈𝔽⁢[β] of degree at most N. Since P≠0, some ce0≠0, and ce0⁢(β)=0 with probability at most N/|𝔽| (Math Guide, §“The Schwartz–Zippel lemma”). When ce0⁢(β)≠0, the polynomial P⁢(β,⋅)∈𝔽⁢[γ] is nonzero of degree at most N, so it vanishes at the independent uniform γ with probability at most N/|𝔽|. The union bound (Math Guide, §“The union bound and a birthday calculation”) adds the two. □

Construction 2.10 (Permutation argument over m columns).

Let v0⁢(X),…,vm−1⁢(X) be the interpolants of the m columns that participate in equality constraints, and let N=m⁢n be the number of participating cells. Label the cell (i,j) (column i, row j) by δi⁢ωj, where δ0,…,δm−1∈𝔽× are chosen so that the cosets δi⁢H are pairwise disjoint and all N labels are distinct; the deployed choice is δi=δi for an element δ whose multiplicative order is the odd part of |𝔽×| (the halo2 book’s Permutation argument chapter). Preprocessing fixes the permuted-label polynomials si⁢(X) with si⁢(ωj)=δi′⁢ωj′ whenever σ⁢(i,j)=(i′,j′); they are preprocessed like the fixed columns but are not circuit columns, and the verifying key — the verifier’s preprocessed description of the circuit, holding commitments to every fixed column and every permuted-label polynomial — contains their commitments. After the columns are committed the verifier sends challenges β,γ∈𝔽, and the prover commits to a running-product polynomial Zperm⁢(X) and proves the two identities, both modulo ZH⁢(X),

ℓ0⁢(X)⁢(1−Zperm⁢(X)) ≡0, (7)
Zperm⁢(ω⁢X)⁢∏i=0m−1(vi⁢(X)+β⁢si⁢(X)+γ)−Zperm⁢(X)⁢∏i=0m−1(vi⁢(X)+β⁢δi⁢X+γ) ≡0,

which together assert

∏i,j(vi⁢(ωj)+β⁢δi⁢ωj+γ)=∏i,j(vi⁢(ωj)+β⁢si⁢(ωj)+γ). (8)

The verifier opens Zperm at the random point z and at ω⁢z, and checks the boundary and the cross-multiplied update.

The first identity fixes Zperm⁢(ω0)=1; the second, holding at every row j, gives Zperm⁢(ωj+1)=Zperm⁢(ωj)⋅∏i(vi+β⁢δi⁢ωj+γ)/∏i(vi+β⁢si⁢(ωj)+γ) whenever the denominator is nonzero, and at j=n−1 it returns to row ω0, whence (8). The toy is the case m=3 with (δ0,δ1,δ2)=(1,2,3), which is not of the deployed form δi.

Theorem 2.11 (Soundness of the permutation argument).

The assignment satisfies every equality constraint (cells related by σ carry equal values) if and only if the two sides of (8) are equal as polynomials in β and γ. Consequently the honest prover always satisfies (8), and if some constraint is violated the two sides agree at uniformly random β,γ with probability at most 2⁢N/|𝔽|, where N is the number of participating cells.

Proof.

Index cells by κ, write vκ and λκ for value and label, and set

P⁢(β,γ):=∏κ(γ+vκ+β⁢λκ)−∏κ(γ+vκ+β⁢λσ⁢(κ))∈𝔽⁢[β]⁢[γ].

Each side is a product of monic linear polynomials in γ over the ring 𝔽⁢[β], with roots rκ:=−(vκ+β⁢λκ) and rκ′:=−(vκ+β⁢λσ⁢(κ)); two such roots are equal in 𝔽⁢[β] exactly when their value–label pairs coincide, since a polynomial in β is determined by its coefficients.

If every constraint holds then vσ⁢(κ)=vκ for all κ, so rκ′=−(vσ⁢(κ)+β⁢λσ⁢(κ))=rσ⁢(κ), and the second product is the first with its factors reindexed by the bijection σ: P=0.

If some constraint fails, pick κ0 with vσ⁢(κ0)≠vκ0. The pair (vκ0,λσ⁢(κ0)) occurs among the roots r′; among the roots r the label λσ⁢(κ0) occurs exactly once, paired with vσ⁢(κ0)≠vκ0, so the multisets of roots differ. Cancel every common factor from both products; a factor (γ−r) then remains on one side, say the first, and r is not a root of the other side. Substitute γ:=r, a ring homomorphism 𝔽⁢[β]⁢[γ]→𝔽⁢[β] (Math Guide, §“Roots and the factor theorem”, evaluation is a ring homomorphism; its proof holds verbatim over the coefficient ring 𝔽⁢[β]): the first product becomes 0 and the second becomes a product of nonzero elements of 𝔽⁢[β], which is nonzero because 𝔽⁢[β] is an integral domain (Math Guide, §“Degree”, Corollary “F⁢[X] is an integral domain”). Hence P≠0. Its degree in each variable is at most N, and Lemma 2.9 bounds the probability that the random challenges hit a zero of P by 2⁢N/|𝔽|. □

The honest prover’s ratio is 1 whenever the denominator is nonzero. The deployed boundary rule of Remark 2.17 admits the final value 0, and the error bound changes accordingly.

Corollary 2.12 (Permutation argument under the deployed boundary rule).

Let the columns be fixed before β,γ, drawn uniformly, and let the running products be constrained on the active rows ω0,…,ωu−1 only, with Zperm⁢(ω0)=1 and the value at the next row ωu permitted to be 0 or 1 (the deployed rule; Remark 2.17 fixes u<n and gives the identities). If some copy constraint fails, the probability over β,γ that some running products satisfy the update and boundary identities on the active rows is at most 3⁢N/|𝔽|, with N the number of participating cells.

Proof.

Suppose some running products satisfy the identities and no numerator factor vκ+β⁢λκ+γ vanishes. Then induction from Zperm⁢(ω0)=1 keeps every running value nonzero, so the boundary value is 1, the updates telescope, and the two products over the active rows are equal; by Theorem 2.11 that happens with probability at most 2⁢N/|𝔽|. For each β at most N values of γ make a numerator factor vanish, which adds N/|𝔽|, and the union bound gives 2⁢N/|𝔽|+N/|𝔽|=3⁢N/|𝔽|. □

Cost.

Excluding the final commitment check, the verifier’s work for the argument is O⁢(m+log⁡n): evaluating the two identities (7) at the random point z needs the 2⁢m linear factors, and ℓ0⁢(z)=(zn−1)/(n⁢(z−1)) costs O⁢(log⁡n) multiplications by the closed form of the Lagrange basis (Math Guide, §“The Lagrange basis on H”). The complete deployed verifier still carries one check linear in n, the multi-scalar multiplication (MSM; Math Guide, §“The mixed inner product with group elements”) that closes every opening; §3 develops it under “The verifier’s work: structured scalars and the final generator”.

The deployed chunking.

The update identity in (7) has degree m+1 in the committed polynomials, and the active-row factor of Remark 2.17, which masks the rows reserved for blinding, adds one more; so a single product accommodates at most m≤dmax−2 columns. Columns beyond that are split into chunks of at most dmax−2, each with its own running product, and a boundary identity ℓ0⁢(X)⁢(Zperm,a⁢(X)−Zperm,a−1⁢(ωu⁢X))≡0 copies the value at the boundary row ωu, the first row after the active rows ω0,…,ωu−1, from one product to the start of the next (the halo2 book’s Permutation argument chapter). The column layout is implementation-specific: the protocol specification fixes the Action statement, not its circuit. The deployed Action circuit, whose implementation is orchard, has fifteen equality-enabled columns (ten advice, one instance, four fixed) and maximum constraint degree dmax=9, and therefore uses three running products of 7, 7 and 1 columns, not one.

2.7 Proving a value sits in a table: lookups

Some constraints admit no low-degree gate on the constrained cells alone. “This cell is a ten-bit number” or “this chunk indexes an entry of the Sinsemilla generator table” (Sinsemilla is the hash of the Crypto Guide, §“Sinsemilla: an algebraic hash-based commitment”) has no low-degree formula in the cell itself: written as one polynomial gate, “v∈{0,…,210−1}” is ∏i=0210−1(v−i)=0, a gate of degree 210, and a table of arbitrary entries does no better. A decomposition into ten boolean-constrained bits keeps the degree at 2 but spends ten further cells on every such value. The single gate would exceed the degree bound of §2.4: in the toy field its degree 210 exceeds |𝔽|=97, so the bound deg⁡D/|𝔽| is vacuous, and at any field size it multiplies the degree of the quotient the prover must split, commit and open (§2.3). The Action circuit uses range and table constraints throughout.

Membership of every entry of a column A in a table column S is, like a copy constraint, a statement about multisets, but it is not a permutation: A may repeat one table entry and omit others. The prover therefore commits to A′, a rearrangement of A in which equal values occupy contiguous runs, and to S′, a rearrangement of S in which the first row of each run of A′ holds the matching table value. Two row-local conditions then give membership: each row of A′ either begins a run, Ai′=Si′, so that its value occurs in S, or continues one, Ai′=Ai−1′. The rearrangements are certified by the running product of §2.6 without labels: labelled factors fix one wiring σ, whereas here the rearrangements are the prover’s choice, so a single running product with unlabelled factors, row by row (Ai′+β)⁢(Si′+γ) against (Ai+β)⁢(Si+γ), certifies that each primed column is a rearrangement of its original. Induction on the row index then gives membership for every row.

Example 2.13 (A two-bit range check on the toy grid).

Constrain cells to two-bit values with the table S=(0,1,2,3) and the column A=(2,3,2,2). Grouped, A′=(2,2,2,3); align S′=(2,0,1,3), a rearrangement of S placing 2 beside the first run and 3 beside the second. Row 0 starts a run (2=2), rows 1 and 2 continue it (2 above), row 3 starts a run (3=3): every check is row-local and every polynomial low-degree, however large the table (Figure 6). The unlabelled product certifies the rearrangements: at the challenges (β,γ)=(5,7) both ∏i(Ai′+β)⁢(Si′+γ) and ∏i(Ai+β)⁢(Si+γ) equal 82. The forged column A=(2,7,2,2) fails the row checks: its 7 must start a run in any arrangement A′, and no rearrangement of a table without a 7 can put a 7 beside it. Over all 4 arrangements of the forged column and all 24 rearrangements of the table, the row checks pass for none.

Refer to caption
Figure 6: The lookup of Example 2.13. Left: the grouped column A′ beside the aligned table S′; a run starts where Ai′=Si′ (green bar) and continues where Ai′=Ai−1′ (blue arrow to the row above). Right: the forged column with a 7; the 7 starts a run, but no entry of S′ equals 7 and the row above holds 2, so both row-local checks fail at row 3.

The Action circuit uses lookups of both kinds: it range-constrains each ten-bit word of a decomposition by a lookup into the table {0,…,210−1} (the halo2 book’s Decomposition chapter), and it evaluates Sinsemilla by a lookup into a fixed table whose 210 rows hold an index i and the two coordinates of the i-th Sinsemilla generator (the halo2 book’s Sinsemilla chapter; the Orchard book’s Circuit chapter records the deployed uses of both). A table fact costs a few committed columns and one more running product, and the gates stay low-degree. The form of the Action circuit’s gates, one gate in full, and its three lookups are given in §4 under “From statement to circuit: arithmetisation in practice”; the exact identities, the boundary row, and multi-column tables come next.

2.8 The lookup argument

Construction 2.14 (Lookup argument).

The objective is that every entry of the column A⁢(X) on the active rows appears as some entry of the column S⁢(X) (the halo2 book’s Lookup argument chapter). The prover supplies polynomials A′⁢(X) and S′⁢(X) where (i) A′ is a permutation of A with like values grouped into contiguous runs, and (ii) S′ is a permutation of S in which the first row of each run of like values in A′ holds the matching value. The prover commits to A′ and S′; after receiving challenges β,γ she commits to a running-product column Zlookup⁢(X) and proves the four identities, all modulo ZH⁢(X),

ℓ0⁢(X)⁢(1−Zlookup⁢(X)) ≡0, (9)
Zlookup⁢(ω⁢X)⁢(A′⁢(X)+β)⁢(S′⁢(X)+γ)−Zlookup⁢(X)⁢(A⁢(X)+β)⁢(S⁢(X)+γ) ≡0,
ℓ0⁢(X)⁢(A′⁢(X)−S′⁢(X)) ≡0,
(A′⁢(X)−S′⁢(X))⁢(A′⁢(X)−A′⁢(ω−1⁢X)) ≡0,

the second and fourth additionally masked by the active-row factor of Remark 2.17.

Theorem 2.15 (Soundness of the lookup argument).

Let the columns A,S,A′,S′ be fixed before β,γ are drawn. If the four identities (9) hold on the active rows, with the boundary conditions of Remark 2.17, then except with probability at most 4⁢n/|𝔽| over the challenges β,γ, every value of A on the active rows equals the value of S at some active row.

Proof.

Let the active rows be 0,…,u−1 (Remark 2.17), and write Ai:=A⁢(ωi), likewise for S,A′,S′, and Zi:=Zlookup⁢(ωi). Suppose first that no numerator factor Ai+β or Si+γ with i<u vanishes. The columns are fixed before the challenges, so each of the u values −Ai equals β with probability 1/|𝔽|, and likewise for γ; by the union bound the supposition fails with probability at most 2⁢u/|𝔽|. Under it, the second identity at row i<u reads Zi+1⁢(Ai′+β)⁢(Si′+γ)=Zi⁢(Ai+β)⁢(Si+γ), and induction from Z0=1 gives Zi+1≠0 and (Ai′+β)⁢(Si′+γ)≠0 for every i<u. Hence Zu≠0, the boundary condition forces Zu=1, and multiplying the identities over i<u and cancelling the nonzero Zi gives

∏i<u(Ai′+β)⁢(Si′+γ)=∏i<u(Ai+β)⁢(Si+γ).

Set f⁢(β):=∏i(Ai′+β), g⁢(β):=∏i(Ai+β), f′⁢(γ):=∏i(Si′+γ), g′⁢(γ):=∏i(Si+γ) and P:=f⁢f′−g⁢g′∈𝔽⁢[β,γ]. If A′ is a permutation of A and S′ of S then f=g and f′=g′, so P=0. If instead, say, A′ is not a permutation of A, then the multisets of roots {−Ai′} and {−Ai} differ, so f≠g by the cancel-and-evaluate argument in the proof of Theorem 2.11 (now over the field 𝔽 itself); comparing the coefficients of the top power of γ in f⁢f′=g⁢g′, both f′ and g′ being monic of the same degree, would force f=g, so P≠0, of degree at most u in each variable, and Lemma 2.9 bounds the probability that the challenges hide the difference by 2⁢u/|𝔽|. The case of S′ is symmetric. The two terms together are at most 2⁢u/|𝔽|+2⁢u/|𝔽|≤4⁢n/|𝔽|.

So, with that probability excepted, A′ is a rearrangement of A and S′ of S on the active rows. The third identity fixes row 0: A0′=S0′, a table value. The fourth, at every later active row i, says (Ai′−Si′)⁢(Ai′−Ai−1′)=0: either Ai′=Si′, a table value, or Ai′=Ai−1′. (At row 0 the reference A′⁢(ω−1⁢X) wraps around to the last row and carries no information, which is why the third identity is needed there.) By induction on i, every Ai′ equals the entry of S′ at some active row, hence that of S at some active row; and since every entry of A on the active rows occurs in A′ there, the claim follows. □

Multi-column tables.

A lookup of m input expressions A0,…,Am−1 against m table columns S0,…,Sm−1 is reduced to a single column by a random linear combination with a challenge θ drawn after the input and table columns are committed:

Ac⁢(X):=∑j=0m−1θm−1−j⁢Aj⁢(X),Sc⁢(X):=∑j=0m−1θm−1−j⁢Sj⁢(X), (10)

and Construction 2.14 runs on Ac and Sc.

Proposition 2.16 (Compression of a multi-column lookup).

Let θ be drawn uniformly after all input and table columns are fixed. If the input tuple at some active row equals the table tuple at no active row, then the compressed input Ac at that row equals Sc at some active row with probability at most n⁢(m−1)/|𝔽|.

Proof.

For each active table row the difference of the compressed values is a polynomial in θ of degree at most m−1 whose coefficients are the differences of the tuple entries, not all zero; it is therefore nonzero, and the random θ zeroes it with probability at most (m−1)/|𝔽| (Math Guide, §“The Schwartz–Zippel lemma”). A union bound over the at most n active rows gives n⁢(m−1)/|𝔽|. □

Variable tables, where S is itself an advice column, and range checks, where S enumerates the allowed range, are special cases of the same argument.

Remark 2.17 (Active rows and blinding).

The lookup identities, like the permutation identities of §2.6, hold on the active rows only. The deployed system withholds the trailing rows of every column from them: a boundary row and, after it, nblind blinding rows, which in every witness column (advice, and the permuted and running-product columns of the arguments) hold uniform random values, for the reason “Zero knowledge: hiding the witness in Halo 2” in §4 gives; fixed and instance columns carry no random values. Let u:=n−nblind−1. Rows 0,…,u−1 are the active rows, row u is the boundary row, and rows u+1,…,n−1 are the blinding rows. (The letter u indexes a row here; in §3 it denotes a round challenge.) Let ℓblind⁢(X) be the sum of the Lagrange basis polynomials of the nblind blinding rows, and let ℓlast⁢(X):=ℓu⁢(X) select the boundary row. Both are computed directly from the domain by both parties; they are not committed circuit columns. Each product-update identity, and the run identity of (9), is multiplied by the factor (1−(ℓlast⁢(X)+ℓblind⁢(X))), which is 1 on the active rows and 0 elsewhere, so the random rows do not violate the active-row constraints. The wrap-around that closed the loop in Construction 2.10 is gone, so the running product is pinned at the boundary row instead, by ℓlast⁢(X)⁢(Z⁢(X)2−Z⁢(X))≡0, which allows Z⁢(ωu)∈{0,1} (the halo2 book’s Lookup argument and Permutation argument chapters). The value 0 is permitted so that a vanishing numerator factor (Ai+β or Si+γ; in the permutation argument vκ+β⁢λκ+γ) still leaves the honest prover a satisfying assignment: she sets the product to 0 from the next row on. The prover cannot force this event, because β,γ are drawn after her columns are committed. A denominator factor that vanishes at an earlier row than every vanishing numerator factor admits no satisfying running product: the update at that row j reads 0=Z⁢(ωj) times a nonzero numerator, and Z⁢(ωj)≠0. This happens with probability at most 2⁢u/|𝔽| for a lookup and N/|𝔽| for the permutation argument, so completeness is overwhelming, not perfect. A boundary value of 0 is not a certificate of multiset equality, so soundness also excludes the challenges at which a numerator factor vanishes: the bound of Theorem 2.15 includes that term, and Corollary 2.12 adds it for the permutation argument.

2.9 Why the prover cannot wriggle: binding commitments

The random-point argument of §2.4 rests on a hypothesis: Theorem 2.5 assumed the prover’s polynomials were fixed before she saw z. If she could choose a,b,c,t after learning z, she would pick numbers making (5) hold and reveal nothing real. A polynomial commitment enforces that hypothesis.

What a commitment must do.

A commitment to a polynomial f is a short string C=𝖢𝗈𝗆𝗆𝗂𝗍⁢(f) with two properties, both developed in the Crypto Guide, §“Hiding and binding”:

  • •

    Binding. Having published C, the prover cannot later open it as two different polynomials; C pins down f. Committing first, then receiving z, then opening, leaves her answering for the one polynomial she fixed in advance, the situation Theorem 2.5 assumed.

  • •

    Hiding. The string C reveals nothing about f. This is what will let the proof be zero-knowledge, under “Zero knowledge: hiding the witness in Halo 2” in §4.

A polynomial commitment adds an evaluation proof: given C and a point z, the prover can prove “f⁢(z)=v” for the committed f without exposing f, and no prover can produce accepting proofs of two different values at the same point (evaluation binding, Crypto Guide, §“Polynomial commitment schemes”). Theorem 2.5 concerns the idealised protocol, in which the verifier receives the true evaluations of polynomials fixed in advance. Compiled with a polynomial commitment scheme that is evaluation-binding and extractable, the four-step protocol of §2.4 becomes, under compatible composition hypotheses, an argument of knowledge (Crypto Guide, §“SNARKs: succinct non-interactive arguments of knowledge”, Theorem “The compilation recipe, informal”): by its layered extraction, a prover who passes either answers with the true evaluations of polynomials fixed before z, where Theorem 2.5 applies, or breaks the scheme’s evaluation binding or extractability. This volume asserts no bound on the compiled error as a sum of deg⁡D/|𝔽| and a commitment term (Remark 4.11, §5). For Halo 2 the extractability of the openings is Theorem 3.5 and, for the deployed opening, Corollary 3.13, under the discrete-logarithm assumption on Vesta, with the generator hash modelled as a random oracle.

How Halo 2 commits.

Encode f of degree <n by its coefficient vector 𝐟=(f0,…,fn−1); the running example’s advice polynomial becomes 𝐚=(90,61,22,24). Let 𝔾 be a group of prime order |𝔽| (deployed: Vesta, of order p𝖯𝖺𝗅𝗅𝖺𝗌), and let G0,…,Gn−1,H∈𝔾 be generators derived from a public hash, with 𝐆:=(G0,…,Gn−1); here H is a group element, not the evaluation domain. The commitment is the single group element

C=⟨𝐟,𝐆⟩+[r]⁢H=∑i[fi]⁢Gi+[r]⁢H,

the Pedersen vector commitment of the coefficient vector with blinder r∈𝔽 (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 commitment is perfectly hiding for uniform r and computationally binding under the discrete-logarithm assumption in 𝔾, with the hash modelled as a random oracle into 𝔾 (Crypto Guide, §“Pedersen vector commitments”, Theorem “Properties of the vector commitment”): two openings of one C would exhibit a nontrivial discrete-logarithm relation among the Gi and H. Proving f⁢(z)=v is proving a statement about an inner product, since

f⁢(z)=∑ifi⁢zi=⟨𝐟,(1,z,z2,…,zn−1)⟩,

and the inner-product argument does this in a logarithmic number of rounds, each halving the vectors, until the claim is trivial: the evaluation proof is O⁢(log⁡n) group elements, and it needs no trusted setup, because the generators come from a public hash rather than from anyone’s secret (Crypto Guide, §“Polynomial commitment schemes”, the inner-product alternative). Halo 2 uses exactly this one polynomial commitment scheme and no other: the inner-product argument over a group with no pairing (the halo2 book, which the protocol specification names as the definition of the system, § 5.4.10.3, “Halo 2”; its Inner product argument chapter), on the Vesta curve, where the protocol specification places the Action statement’s proofs (protocol specification, § 5.4.9.6, “Pallas and Vesta”). The parameters, the generators and the deployed byte layout are given at the end of §3.

Opening a vector commitment.

For the argument of this section the commitment must bind, so that the prover answers for polynomials fixed before z is drawn. A vector commitment alone does not provide step 3 of the random-point check. The only opening the Pedersen construction offers is the whole vector together with its blinder, n+1 field elements: sending it reveals f, and it is no shorter than f. The verifier needs ⟨𝐟,(1,z,…,zn−1)⟩=v established for a committed 𝐟 he never sees, in fewer than n group elements. That is the inner-product argument of §3.