This section carries the running example of §1 — the prover knows with over — 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.
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.
Evaluate the way a machine would, naming every intermediate value:
Four elementary operations, two multiplications and two additions, and each becomes one row of a table. A row has three wires (two inputs and an output) and a bank of five selectors that switch on whichever gate the row performs. The universal gate equation, imposed at every row, is
| (1) |
where carries the negated public input on that row (here , for the target ). A multiplication gate is the choice , and the rest zero; an addition gate is , . 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 | gate performed | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
The table as printed does not yet encode the computation. Nothing forces the in row to equal the in rows and , nor the output of row to be the input of row . A cheating prover could put in row and in row 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):
where denotes the cell of column in row . 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.
The claim is now equivalent to a purely combinatorial assertion: there exist values for the advice cells such that (i) every row satisfies the gate equation (1) with the fixed selectors, and (ii) every copy constraint holds. Knowing 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.
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 is determined by its values at distinct points (Math Guide, §“Lagrange interpolation”), and the rest of the section relies on this.
The table has rows, and four distinct field elements must name them. The chosen four are the th roots of unity. A primitive -th root of unity is an element with and no smaller positive power equal to (Math Guide, §“Roots of unity”), and the evaluation domain it generates is , a multiplicative subgroup of of order (Math Guide, §“The evaluation domain and its vanishing polynomial”). In take : then and , so
and row lives at the point . Roots of unity are chosen because they form a cyclic group: the row after is , so reading a column at the next row is evaluating its polynomial at ; the polynomial vanishing on is ; and interpolation over 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.
Each column of the table is four numbers, one per row. Interpolate: for the advice column there is a unique polynomial of degree with
(Math Guide, §“Lagrange interpolation”), and likewise , , the publicly known selector polynomials and the public-input polynomial , each of degree . Computed over , the nine interpolants are
and each returns its column at the rows: takes the values on , the values , and the values . Interpolation is thus a bijection between columns of four values and polynomials of degree : the encoding loses no information.
Assemble the left-hand side of the gate equation (1) with the polynomials in place of the per-row numbers.
Let
| (2) |
Then , and for every row if and only if every gate of the trace is satisfied.
The term multiplies three polynomials of degree at most , and every other term has degree at most , so . Evaluate at the label of row : each column polynomial returns that row’s value there, so is exactly the left-hand side of (1) for row . It is zero precisely when gate holds, and the conjunction over gives the claim. □
For the honest trace,
of degree exactly , and it vanishes at all four points of by construction. “Every gate is satisfied” has become “ vanishes on ”; the copy constraints remain separate. Four separate checks are now one statement about one polynomial.
The condition “ vanishes on ” is still a statement about four points. This subsection replaces it by a polynomial identity that refers to no individual row.
The vanishing polynomial of is the monic polynomial (leading coefficient ) whose roots are exactly the points of ,
where the closed form holds for every evaluation domain of order (Math Guide, §“The evaluation domain and its vanishing polynomial”): each is a root of , there are distinct ones, and comparing leading coefficients finishes. The closed form lets both parties evaluate at any point with multiplications.
Every gate of the trace holds if and only if there is a polynomial with .
By Theorem 2.1, every gate holds if and only if vanishes on . The factor theorem (Math Guide, §“Roots and the factor theorem”) gives if and only if ; and because the four roots are distinct, vanishes at all of them if and only if the product of the four linear factors divides (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
| (3) |
and divisibility is the existence of the quotient . □
Satisfaction of the gate constraints is precisely the existence of ; correct wiring still requires the copy constraints. For the honest trace the division comes out even: has degree , has degree , and
is a polynomial of degree with remainder zero, as it must be.
Suppose the advice is wrong: some gate fails. Then does not vanish on all of , so by (3) does not divide , and no polynomial satisfies . The dividing line is exact: the quotient exists if and only if every gate is satisfied. Concretely, take a prover who claims and writes in row of Table 1 instead of . Row ’s gate now reads , so the tampered gate polynomial has while still vanishing at the other three rows:
Dividing by with remainder (Math Guide, §“Division with remainder”) gives the quotient and a nonzero remainder. This Euclidean quotient is an illustrative choice for , not a claim that it maximises the cheat’s chances. Whatever she offers as the quotient, the gap polynomial is nonzero, since does not divide . For the Euclidean quotient is the remainder,
| (4) |
of degree . The identity is false, is the difference of its two sides, and §2.4 shows how the verifier detects .
The prover wishes to convince the verifier that as polynomials, with 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.
The prover commits to her polynomials and to the quotient ; the selector and public-input polynomials the verifier already knows.
The verifier picks a point uniformly at random and sends it.
The prover opens her commitments at : she returns the field elements together with short proofs that these are the true evaluations of the committed polynomials.
The verifier forms from the openings and the self-evaluated public polynomials via (2), computes , and checks the single field equation
| (5) |
He accepts if and only if (5) holds.
If the prover is honest then holds as polynomials, hence at every point, hence at . With the honest trace and the draw ,
and the verifier accepts. He accepts every time, for every .
Soundness rests on the fact that a nonzero polynomial of low degree has few roots.
Suppose the trace is invalid, so that the prover’s gate polynomial does not vanish on all of , and let be any polynomial she commits to as the quotient. Set . Then is a nonzero polynomial, and if the prover’s polynomials (which determine ) and are fixed before is drawn and the verifier receives their true evaluations at ,
Were the zero polynomial, would be divisible by and so, by (3), vanish on all of , which it does not. Hence for every choice of . By hypothesis and , and with them and , are fixed before is drawn (the verifier never receives itself; from the evaluations at he reconstructs only the single number ). The check (5) passes at exactly when , that is, exactly when is a root of . A nonzero polynomial of degree at most has at most roots, so a uniformly random is one of them with probability at most (Math Guide, §“The Schwartz–Zippel lemma”). □
The bound is negligible when is exponential in the security parameter and is polynomial in it. The verifier does not recompute the trace; he tests one polynomial identity at one random point.
For the cheat of Example 2.3, has degree and so at most roots; in its roots are exactly , the three rows where the tampered gate still held (Figure 3). This particular quotient choice slips past only if the random lands in that three-element set:
At the actual draw the openings give but ; since , the verifier rejects.
The fraction is large only because the field is a toy, and it concerns one particular quotient; the next paragraph bounds every cheat by . What such a term means at the deployed field size is the scale caveat of §1.2.
The argument needs small relative to , otherwise “ 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 of unbounded degree. The bound follows the degree the commitment admits, not the honest degree. The wires are committed at degree below , so ; committed as the two pieces of degree below that the deployed rule below prescribes, has degree at most , so and . Every cheat is therefore accepted with probability at most , and some cheat attains it, where the illustrative quotient reaches : the of degree that agrees with at the eight points gives the eleven roots . This is why a circuit’s gates are kept to low degree, and why the quotient , of degree here and up to a few times in general, is split into degree-bounded pieces. In the deployed system the quotient is cut into pieces of degree below , each committed separately (the halo2 book’s Vanishing argument chapter); “The complete Halo 2 protocol” in §4 gives the count.
The toy has met every ingredient concretely: an evaluation domain , a generator , the vanishing polynomial , columns interpolated into polynomials of degree , and a gate expressed as a polynomial identity on . The general object can now be named.
Fix a prime field and an integer with , so that contains a primitive -th root of unity (Math Guide, §“Existence over finite fields: the condition ”), and let be the multiplicative subgroup of size that generates. Its vanishing polynomial is , zero exactly on , so a congruence means “ is zero at every row ”, that is, . A PLONKish circuit over consists of:
a finite set of columns, each of 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 , and the circuit assigns every cell of a fixed column its value;
a maximum constraint degree ;
a finite set of rotations containing ; a column expression is a polynomial over in the values for and , where the value of at rotation at row is the cell of in row taken modulo ;
a finite sequence of custom gates , each a column expression of degree at most ;
a set of active rows: all of in the toy, and in the deployed system the first rows , the trailing rows being reserved for a boundary row and blinding (Remark 2.17 fixes );
a subset of equality-constrained cells together with a permutation of (a bijection ) whose cycles, the orbits of the cells , are the classes of cells required to hold a common value;
a set of lookup arguments, each an input tuple of column expressions and a table tuple of columns.
An assignment gives every cell a value in , the fixed cells their circuit values; write for the value of cell . It is satisfying if every gate vanishes at every row of (in the deployed system the selectors are zero outside ), for every , and for every lookup and every active row the tuple equals for some active row . The relation of the circuit is the set of pairs (instance-column values, advice-column values) of the satisfying assignments.
The letter is reserved, from §3 on, for the length of a committed vector; the constraint degree is therefore written throughout this volume.
The original PLONK system of Gabizon, Williamson and Ciobotaru uses a single fixed five-selector universal gate,
with three wire polynomials , selector polynomials and the public-input polynomial , carrying the negated public inputs; the toy’s gate (1) is exactly this gate, with held in an instance column. PLONKish generalises it by permitting designer-chosen gates of higher arity and degree, each switched by its own selector , a fixed column that vanishes on the rows where the gate is inactive. In the toy the five selectors are fixed columns, are advice, is the instance column, the single gate has degree and reads rotation only, and the copy constraints of §2.1 are the equality set with cycling each class; there are no lookups until §2.7. Figure 4 shows the general shape.
With the Lagrange basis of , defined by and for (Math Guide, §“The Lagrange basis on ”), a column with cells is the polynomial of degree , 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 and .
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 are the same value , or that row ’s input is row ’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.
Group the cells into the classes that must share a value, , , , , and let be the permutation of the twelve cells that cycles each class in the order written and fixes and :
Give every cell a distinct label: the cell in row of the -, -, -column gets , , respectively, where place the three columns in disjoint cosets of 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 , and all lie outside ; in take , :
Write for a cell’s label and 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 is unchanged when each label is replaced by the label of the cell’s image under : a pair moves to , and the moved pair was already present exactly when the cell at carried the same value . 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 with verifier challenges , and compare
| (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.
A product over all cells is not a local fact, so the prover commits to a running product: a column with whose row equals row times the ratio of row ’s factors in (6), numerator over denominator. After the last row the product has run over every cell, and because the row-to-row rule at the last row forces the full product to equal again: the grand product is 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 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.
Strip the product down to a single wired pair, (both should be ), with labels and that swaps. Their factors satisfy
because the shared value 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, . The factor on the left is matched on the right only by , 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.
For the honest trace with , the ratio of the two products in (6) over all twelve cells is exactly . Tamper one wire, setting and so breaking the copy , and the same ratio at the same challenges becomes : the inconsistent dataflow is exposed without any value being revealed.
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.
Let be nonzero, of degree at most in each variable separately. For drawn independently and uniformly from , .
Write with coefficients of degree at most . Since , some , and with probability at most (Math Guide, §“The Schwartz–Zippel lemma”). When , the polynomial is nonzero of degree at most , so it vanishes at the independent uniform with probability at most . The union bound (Math Guide, §“The union bound and a birthday calculation”) adds the two. □
Let be the interpolants of the columns that participate in equality constraints, and let be the number of participating cells. Label the cell (column , row ) by , where are chosen so that the cosets are pairwise disjoint and all labels are distinct; the deployed choice is for an element whose multiplicative order is the odd part of (the halo2 book’s Permutation argument chapter). Preprocessing fixes the permuted-label polynomials with whenever ; 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 and proves the two identities, both modulo ,
| (7) | ||||
which together assert
| (8) |
The verifier opens at the random point and at , and checks the boundary and the cross-multiplied update.
The first identity fixes ; the second, holding at every row , gives whenever the denominator is nonzero, and at it returns to row , whence (8). The toy is the case with , which is not of the deployed form .
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 , where is the number of participating cells.
Index cells by , write and for value and label, and set
Each side is a product of monic linear polynomials in over the ring , with roots and ; 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 for all , so , and the second product is the first with its factors reindexed by the bijection : .
If some constraint fails, pick with . The pair occurs among the roots ; among the roots the label occurs exactly once, paired with , so the multisets of roots differ. Cancel every common factor from both products; a factor then remains on one side, say the first, and is not a root of the other side. Substitute , 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 and the second becomes a product of nonzero elements of , which is nonzero because is an integral domain (Math Guide, §“Degree”, Corollary “ is an integral domain”). Hence . Its degree in each variable is at most , and Lemma 2.9 bounds the probability that the random challenges hit a zero of by . □
The honest prover’s ratio is whenever the denominator is nonzero. The deployed boundary rule of Remark 2.17 admits the final value , and the error bound changes accordingly.
Let the columns be fixed before , drawn uniformly, and let the running products be constrained on the active rows only, with and the value at the next row permitted to be or (the deployed rule; Remark 2.17 fixes 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 , with the number of participating cells.
Suppose some running products satisfy the identities and no numerator factor vanishes. Then induction from keeps every running value nonzero, so the boundary value is , the updates telescope, and the two products over the active rows are equal; by Theorem 2.11 that happens with probability at most . For each at most values of make a numerator factor vanish, which adds , and the union bound gives . □
Excluding the final commitment check, the verifier’s work for the argument is : evaluating the two identities (7) at the random point needs the linear factors, and costs multiplications by the closed form of the Lagrange basis (Math Guide, §“The Lagrange basis on ”). The complete deployed verifier still carries one check linear in , 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 update identity in (7) has degree 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 columns. Columns beyond that are split into chunks of at most , each with its own running product, and a boundary identity copies the value at the boundary row , the first row after the active rows , 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 , and therefore uses three running products of , and columns, not one.
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, “” is , a gate of degree , and a table of arbitrary entries does no better. A decomposition into ten boolean-constrained bits keeps the degree at 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 exceeds , so the bound 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 in a table column is, like a copy constraint, a statement about multisets, but it is not a permutation: may repeat one table entry and omit others. The prover therefore commits to , a rearrangement of in which equal values occupy contiguous runs, and to , a rearrangement of in which the first row of each run of holds the matching table value. Two row-local conditions then give membership: each row of either begins a run, , so that its value occurs in , or continues one, . 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 against , certifies that each primed column is a rearrangement of its original. Induction on the row index then gives membership for every row.
Constrain cells to two-bit values with the table and the column . Grouped, ; align , a rearrangement of placing beside the first run and beside the second. Row starts a run (), rows and continue it ( above), row starts a run (): 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 both and equal . The forged column fails the row checks: its must start a run in any arrangement , and no rearrangement of a table without a can put a beside it. Over all arrangements of the forged column and all rearrangements of the table, the row checks pass for none.
The Action circuit uses lookups of both kinds: it range-constrains each ten-bit word of a decomposition by a lookup into the table (the halo2 book’s Decomposition chapter), and it evaluates Sinsemilla by a lookup into a fixed table whose rows hold an index and the two coordinates of the -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.
The objective is that every entry of the column on the active rows appears as some entry of the column (the halo2 book’s Lookup argument chapter). The prover supplies polynomials and where (i) is a permutation of with like values grouped into contiguous runs, and (ii) is a permutation of in which the first row of each run of like values in holds the matching value. The prover commits to and ; after receiving challenges she commits to a running-product column and proves the four identities, all modulo ,
| (9) | ||||
the second and fourth additionally masked by the active-row factor of Remark 2.17.
Let the active rows be (Remark 2.17), and write , likewise for , and . Suppose first that no numerator factor or with vanishes. The columns are fixed before the challenges, so each of the values equals with probability , and likewise for ; by the union bound the supposition fails with probability at most . Under it, the second identity at row reads , and induction from gives and for every . Hence , the boundary condition forces , and multiplying the identities over and cancelling the nonzero gives
Set , , , and . If is a permutation of and of then and , so . If instead, say, is not a permutation of , then the multisets of roots and differ, so 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 , both and being monic of the same degree, would force , so , of degree at most in each variable, and Lemma 2.9 bounds the probability that the challenges hide the difference by . The case of is symmetric. The two terms together are at most .
So, with that probability excepted, is a rearrangement of and of on the active rows. The third identity fixes row : , a table value. The fourth, at every later active row , says : either , a table value, or . (At row the reference wraps around to the last row and carries no information, which is why the third identity is needed there.) By induction on , every equals the entry of at some active row, hence that of at some active row; and since every entry of on the active rows occurs in there, the claim follows. □
A lookup of input expressions against table columns is reduced to a single column by a random linear combination with a challenge drawn after the input and table columns are committed:
| (10) |
and Construction 2.14 runs on and .
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 at that row equals at some active row with probability at most .
For each active table row the difference of the compressed values is a polynomial in of degree at most 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 (Math Guide, §“The Schwartz–Zippel lemma”). A union bound over the at most active rows gives . □
Variable tables, where is itself an advice column, and range checks, where enumerates the allowed range, are special cases of the same argument.
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, 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 . Rows are the active rows, row is the boundary row, and rows are the blinding rows. (The letter indexes a row here; in §3 it denotes a round challenge.) Let be the sum of the Lagrange basis polynomials of the blinding rows, and let 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 , which is on the active rows and 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 , which allows (the halo2 book’s Lookup argument and Permutation argument chapters). The value is permitted so that a vanishing numerator factor ( or ; in the permutation argument ) still leaves the honest prover a satisfying assignment: she sets the product to 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 reads times a nonzero numerator, and . This happens with probability at most for a lookup and for the permutation argument, so completeness is overwhelming, not perfect. A boundary value of 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.
The random-point argument of §2.4 rests on a hypothesis: Theorem 2.5 assumed the prover’s polynomials were fixed before she saw . If she could choose after learning , she would pick numbers making (5) hold and reveal nothing real. A polynomial commitment enforces that hypothesis.
A commitment to a polynomial is a short string with two properties, both developed in the Crypto Guide, §“Hiding and binding”:
Binding. Having published , the prover cannot later open it as two different polynomials; pins down . Committing first, then receiving , then opening, leaves her answering for the one polynomial she fixed in advance, the situation Theorem 2.5 assumed.
Hiding. The string reveals nothing about . 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 and a point , the prover can prove “” for the committed without exposing , 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 , 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 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.
Encode of degree by its coefficient vector ; the running example’s advice polynomial becomes . Let be a group of prime order (deployed: Vesta, of order ), and let be generators derived from a public hash, with ; here is a group element, not the evaluation domain. The commitment is the single group element
the Pedersen vector commitment of the coefficient vector with blinder (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 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 would exhibit a nontrivial discrete-logarithm relation among the and . Proving is proving a statement about an inner product, since
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 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.
For the argument of this section the commitment must bind, so that the prover answers for polynomials fixed before 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, field elements: sending it reveals , and it is no shorter than . The verifier needs established for a committed he never sees, in fewer than group elements. That is the inner-product argument of §3.