This section defines the Halo 2 proof system as deployed for the Orchard Action statement: the Action circuit, the instance column, the transcript, the multipoint opening, the protocol, and its zero knowledge. It combines the arithmetisation of §2, which reduces a circuit to committed polynomials and identities among them (the gates, the permutation argument for the wiring, the lookup argument for table membership), with the polynomial commitment of §3, which opens a committed polynomial at a point in logarithmically many group elements and is binding under the discrete logarithm on Vesta. The abstractions the Crypto Guide owns, the non-interactive argument and the SNARK, the polynomial interactive oracle proof, the Fiat–Shamir transform and the polynomial-commitment interface, are recalled at the point of use. Halo 2 is a transparent PLONKish argument: the parameters of its commitment scheme are derived by hashing to the curve and carry no trapdoor (§3.8), and for the Orchard Action circuit its polynomial commitment works over Vesta. The protocol specification defines Action proofs as proofs of the Halo 2 proving system described in the halo2 book (protocol specification, § 5.4.10.3, “Halo 2”); this section cites the book, by chapter, as the specification of the protocol, and names an implementation only for a behaviour that neither document fixes.
The subsections treat, in order, the Action circuit as a PLONKish circuit (its gates, one gate in full, its lookup arguments and its column polynomials); the instance column; the Fiat–Shamir transform and the deployed transcript; the multipoint opening argument; the complete protocol in seven phases; its zero knowledge; and the compiled-polynomial-IOP pattern the protocol instantiates. Recursion is not deployed by Orchard and is treated in §7.
The constraint degree is , as Definition 2.7 fixed
it; the letter is the committed vector length of §3, which
equals the row count throughout this section. The letter carries
three meanings; two come from the sections this one joins:
§2 writes for the evaluation domain and §3
for the blinding generator of the Pedersen commitment. Here the domain
appears only through its vanishing polynomial
Definition 2.7 says what a PLONKish circuit is; the deployed
instance is the Orchard Action circuit. The protocol specification fixes the
statement it proves, the Action statement (protocol specification,
§ 4.18.4,
“Action Statement (Orchard)”), and requires every Action proof to verify under
the verifying key identified by the current Orchard circuit version (protocol
specification,
§ 4.6, “Action
Descriptions”, consensus rules). No specification or ZIP fixes
the parameters of the circuit behind that key; they are those of its
implementation, orchard. As a PLONKish circuit in the sense of
Definition 2.7 it has the field ,
The verifying key is a deterministic function of the commitment parameters and the circuit description: the values of the fixed columns, the gates, the lookup arguments and the permutation of Definition 2.7. For the Action circuit it is a fixed consensus parameter, the key the consensus rule above identifies. The prover’s witness is the content of the advice columns. A copy constraint places two cells in one cycle of (Construction 2.10), and the public inputs are bound to advice cells in this way (§4.2).
Every custom gate of the deployed circuit, a gate in the sense of Definition 2.7, has the form
where
The incomplete-addition gate of the Action circuit constrains
| (31) | ||||
| (32) |
(the halo2 book’s Incomplete and complete addition chapter).
Let
(i)(ii). Since
(ii)(iii). The -equations are the same equation rearranged. For
the -equations, the chord formula uses the slope of the line through
and , which is whichever endpoint is subtracted from
which, and the identity
On the -point toy curve of §3.7,
The bracket of (31) has degree three in the cells
and that of (32) degree two; with a selector column
taking values in the constraints have degrees four and three.
The deployed key combines selectors into shared fixed columns (the halo2
book’s Selector combining chapter), which can raise both degrees,
keeping them within the deployed bound
The selector is on row , which holds and
, each coordinate copy-constrained to the cell it came from; row
| row | |||||
|---|---|---|---|---|---|
| – | – | – |
If
A gate asserts only polynomial identities. “This value has ten bits” and
“this point is the -th Sinsemilla generator” are set memberships, and
§2.7 showed why no low-degree gate on the cell alone states
them; the circuit states them as lookup arguments. Each is one instance of
Construction 2.14, the input expressions playing
The Action circuit has three lookup arguments, one range check and two
Sinsemilla generator lookups, and all three use one table. It holds, for
in three table columns , where is the -bit little-endian encoding of the integer , the generator table is defined by the protocol specification (§ 5.4.1.9, “Sinsemilla Hash Function”), and the hash that derives it is the Crypto Guide’s (§“Sinsemilla: an algebraic hash-based commitment”; the hash-to-curve pipeline is §“Hashing to a curve point”). The first two rows are:
| row | coordinates of , hexadecimal |
|---|---|
On every active row
The range-check lookup is
| (33) |
with and the running-sum advice column at the current and
next rotations. With
The Sinsemilla lookup is the three-column instance
| (34) |
where
Lookup inputs may be arbitrary expressions over queried cells, not merely
cells. The Sinsemilla lookup asserts that the generator added is
with no advice cell holding that generator’s -coordinate.
The
Every column, advice, fixed and instance, is a vector of
Each gate polynomial is evaluated with the committed column polynomials
substituted for the queried cells, a query at rotation reading
, and the resulting polynomials, together with the
permutation identities (7) and the lookup
identities (9), are folded with powers of a
challenge and divided by
The running example of §2.2 stands at the same point:
it interpolated a four-row trace into
For the Action circuit
Definition 2.7 lists instance columns beside fixed and advice columns, and the arguments of §2 treat them like any other column. This subsection states how the instance column binds a proof to its public statement.
In the running example the target is public, so it is not advice but
instance data: it sits in the public-input polynomial
of (2), which the verifier builds
himself from the column ; its interpolant
An instance column is a public-input column: its entries
with
The deployed circuit binds the public values through the permutation
argument of §2.6, not through a gate. The instance
column is equality-enabled, so it participates in the permutation
; it is one of the fifteen columns counted under “The deployed
chunking” there, beside the ten advice and four fixed ones. Each
designated instance cell is copy-constrained to an advice cell that the
circuit’s constraints read (the halo2 book’s Permutation argument
chapter for the mechanism), so a satisfying assignment exists only when
those advice cells hold the public values the verifier supplied
(Figure 11). The alternative, a dedicated gate
The verifier does not take from the prover. Both parties compute the commitment to each instance polynomial from the instance values (the halo2 book’s Circuit commitments chapter), with the public blinding factor in place of a random one so that the two computations agree, and absorb it into the transcript before the first challenge is drawn, in phase 1 of §4.5; every Fiat–Shamir challenge thereby depends on the public input. The book fixes the factor for the fixed columns only; for the instance columns it is the choice of the implementation, halo2_proofs. Thereafter the instance column is treated like any other: its claimed evaluation appears among the phase-5 evaluations, enters the permutation identities as one of the of Construction 2.10, and the multipoint opening of phase 6 binds it to the instance commitment. Because the verifier computed that commitment himself, from the instance values he verifies against, the prover has no freedom over : an evaluation inconsistent with the verifier’s own values fails the opening argument, by the evaluation binding recalled in §2.9.
The Action statement’s public input is the tuple
(protocol specification,
§ 4.18.4,
“Action Statement (Orchard)”): the anchor , the root of the
note-commitment tree the spent note is proved against (the Crypto
Guide, §“Append-only and incrementally updatable trees”); the net
value commitment ; the nullifier ; the
randomised verification key ; the extracted commitment
each integer read as an element of
The verifier computes the instance commitment from the public values itself, and the copy constraints tie the designated cells to the advice cells the constraints read; so a witness extracted from an accepting proof satisfies the relation at , not at other public values the prover may target. The probabilistic conclusion, that a prover who knows no witness for , whatever witnesses she holds for other instances, convinces the verifier with at most negligible probability, holds under the knowledge soundness whose status §5 classifies: designed-but-unspecified for the deployed transcript, resting on the discrete logarithm on Vesta or on the algebraic group model, with the transcript hash modelled as a random oracle. Under that hypothesis an Action proof that verifies against an anchor, a nullifier and a value commitment certifies knowledge of a witness consistent with those values.
The protocols of §§2–3 are public-coin:
every verifier message is uniformly random and independent of the
prover’s messages, a field element (the point of the random-point
check, the pair
The Fiat–Shamir transform replaces the -th challenge by
the hash of the public statement and of the transcript
prefix, the prover’s messages
A prover against the compiled argument may vary the inputs of and inspect the resulting challenges. The bound on that freedom uses round-by-round soundness (Canetti, Chen, Holmgren, Lombardi, Rothblum, Rothblum and Wichs, Fiat–Shamir: From Practice to Theory), which Remark 4.12 recalls.
Let be a public-coin interactive protocol whose partial transcripts for a false statement carry a doomed labelling with error : the empty transcript is doomed, a doomed complete transcript is rejected, and from a doomed partial transcript, whatever the prover’s next message, the next challenge leaves it doomed except with probability at most . With modelled as a random oracle, a prover making at most distinct oracle queries, the verifier’s recomputations counted among them, makes the verifier of the Fiat–Shamir transform of accept with probability at most .
Each query is a transcript prefix followed by a prover message, and its answer is uniform and independent of everything before the query. The verifier accepts only a transcript that is not doomed, and the empty transcript is doomed, so acceptance requires some query on a doomed prefix whose answer leaves the doomed set; each query does so with probability at most , and the union bound over the at most queries gives . □
The proposition has the form of the halo2 book’s extraction theorem
(Protocol Description chapter, “Witness-extended Emulation”, its
term ) and of the state-restoration analysis of Ghoshal and
Tessaro that §5 cites, where its application to the
deployed transcript is classified.
For the toy’s identity check, a single challenge with error
(§2.4), ten queries exhaust the bound. This volume
establishes no round-by-round error for Halo 2, whose binding is computational.
At Orchard scale the identity check’s term is about (one
Schwartz–Zippel term, in the sense §1.2 fixed), and budgets
of , and queries multiply that term alone to
, and ; these agree with the
of the halo2 book’s algebraic-group-model bound
quoted in §5.2, proved for the abstract protocol, whose transfer
to the deployed transcript §5 classifies. The permutation argument’s
term over , with
The hash must take the whole transcript prefix as input: a statement or commitment left out can be chosen after the challenge is seen, the “weak Fiat–Shamir” failure the Crypto Guide records in §“The Fiat–Shamir transform: from interactive to non-interactive”. The bound holds with modelled as a random oracle, a heuristic. The Crypto Guide proves the one-round theorem, with its forking-lemma extractor and its programmed-oracle simulator, and states that a multi-round protocol such as this one needs a multi-round theorem whose hypotheses match the protocol at hand; §5 weighs that theorem against the deployed transcript.
The compiled argument is non-interactive: the proof is one static object, commitments, evaluations and the opening’s scalars, and verification recomputes the challenges by the same hash and runs the same checks. The protocol specification defines a Halo 2 proof as a byte sequence (protocol specification, § 5.4.10.3, “Halo 2”, and its “Encoding of Halo 2 Proofs”), so a full node verifies an Action proof from the transaction alone.
Neither the protocol specification nor the halo2 book fixes the
transcript that instantiates the transform; it is that of the
implementation, halo2_proofs, and is as follows. The state is
a BLAKE2b-512 hash state with the sixteen-byte personalisation
Halo2-Transcript (the Crypto Guide, §“Domain
separation and personalisation”). Absorbing a point
When the verifier has drawn his evaluation point , the prover has
committed to several dozen polynomials and claimed their values at
and at rotations of : a running product at and , a
permuted lookup input at and , an advice column at
every rotation its gates read. Opening each claim with the argument of
§3 would cost
Let
Fold each group (). The verifier sends
Divide out the points (). The verifier sends
samples a fresh blinder and sends
A fresh point (). The verifier sends
The value must take. The verifier computes
the value of if every is a polynomial and every is honest; he can, since and are his to evaluate, and he rejects if some is .
One polynomial (). The verifier sends
and run one opening of Construction 3.2 on the
statement , the prover’s witness being the
coefficient vector of and the blinder
Two remarks on the shape. Nothing is sent between and , so the deployed transcript squeezes them back to back; they are two challenges because they play two roles, one keeping the polynomials of a group linearly independent and one keeping the quotients of different groups independent. And the reduction is free for the verifier in group operations except for the combinations of commitments, which are a few scalar multiplications per committed polynomial; the one expensive step, the final multi-scalar multiplication, is paid once, inside the single opening. Figure 12 draws the data flow.
If every claimed value is true, then
In Construction 4.4, let the committed
polynomials and the claimed values be fixed before is drawn,
let be a polynomial of degree
The argument takes one Schwartz–Zippel term per challenge (the
Math Guide, §“The Schwartz–Zippel lemma”).
The fold. The difference
is fixed once is drawn and is sent, before . At the
term and every term with
the product over
The bound is one more Schwartz–Zippel allowance, of the order of . The opening’s own knowledge error, by Corollary 3.13, lies below it, and that corollary’s witness-or-relation form supplies the binding opening the lemma assumes.
In the Action circuit the point sets are five. Every fixed, instance and permuted-label polynomial, the random polynomial of phase 4 and the collapsed quotient are queried at ; the advice columns, five at and five at , according to the rotations their gates read; the permuted lookup input at and the permuted table at ; the lookup running products and the last permutation running product at ; and the first two permutation running products at , the last rotation reaching the boundary row of Remark 2.17 that chains one product into the next. The sets , , , and give the five values , the multipoint evaluations of Table 8, and the whole reduction adds one point and five scalars to the proof.
The pieces are now assembled into the Halo 2 protocol (the halo2 book’s
Protocol Description chapter, instantiated with the arguments of
its Proving system chapters), in seven phases. Throughout, is the
constraint field, for Orchard; is the commitment
group, the Vesta curve, whose order is
(§3.8); the rows are
The circuit fixes the columns, gates, lookup arguments and the equality permutation , as §4.1 described; its selectors and lookup tables are fixed columns. Key generation interpolates every fixed column and every permuted-label polynomial of Construction 2.10 and commits to them with the fixed blinding factor (for the fixed columns, the halo2 book’s Circuit commitments chapter); these commitments, with the circuit description, form the verifying key. The transparent parameters of the commitment scheme, the generators , the blinding generator and the inner-product generator hashed to the curve as §3.8 described, together with the domain data, are held separately. All of it is reproducible from public algorithms and the circuit; no secret setup trapdoor exists. Verification is a deterministic function of the parameters, the verifying key, the instance values and the proof.
Both parties first absorb the digest of the verifying key and the
instance commitments of §4.2 into the
transcript, so that every subsequent challenge depends on the circuit and
on the public input. The prover constructs the advice columns
The verifier sends and . The prover commits to the
permutation running products, one per chunk of
Before is drawn the prover commits to a uniformly random polynomial
of degree
the -weighted combination of the constraint polynomials of
the circuit: each constraint of each custom gate with its selector
factor, the permutation identities (7) and the
chunk-boundary identities, the lookup
identities (9), and the boundary identities of
Remark 2.17, each masked by its active-row factor where
that remark requires. If every constraint holds then every vanishes
on the rows, so does, and
Let
Let
Let every column polynomial and every permuted-label polynomial have
degree
A constraint of degree at most is a sum of products of at most
such factors, each of degree at most
For the deployed
retaining leading zero chunks when the actual degree is smaller, and
commits to each chunk separately with its own blinder; there are
chunks for Orchard. The count is right because has at most
Theorem 4.7 also sizes the domain on which the
prover computes . She evaluates the polynomials from which is built
on a set of points on which does not vanish, forms there, and
divides by point by point. Among polynomials of degree at most the
bound of the theorem, these values determine if and only if
The verifier sends . The prover evaluates every committed polynomial
the verifier’s identities query, except the quotient chunks, at
and at the rotated points the identities reference, for the
running products and for any gate reading the next row, for
the permuted lookup input and for gates reading the previous row, and
, the deployed boundary row, for all but the last
permutation product, and sends the claimed values as field elements. The
deployed proof also carries the evaluations at of the fixed columns
and of the permuted-label polynomials, which the same opening binds to
the verifying key’s commitments, and of the random polynomial, bound to
its phase-4 commitment. No evaluation of is sent: the verifier
computes the expected quotient value
The parties run Construction 4.4 on every
committed polynomial with a claimed evaluation: the advice columns, the
instance column, the fixed and permuted-label polynomials, the permuted
lookup columns, the running products, the random polynomial, and the
collapsed quotient with its expected value, the last two joining the
group. The prover sends the commitment after
The parties execute the deployed opening of §3.8, the
masked argument in the normalisation of
Remark 3.9, on . The prover
sends the mask commitment ; the verifier sends and ; then
for
In the recursive variant of Halo 2 the verifier is itself a circuit, and
that circuit defers the one expensive step of phase 7, the claim
The prover computes one multi-scalar multiplication of length per
commitment she sends before the opening,
| phase | prover sends | verifier squeezes | Orchard count |
|---|---|---|---|
| before | — (both absorb the key digest and the instance commitments) | — | bytes |
| advice commitments | — | points per Action | |
| after , the and commitments, per lookup | points per Action | ||
| after , , the permutation products and the lookup products | , | points per Action | |
| random polynomial commitment; then, after , the quotient chunks | points, shared | ||
| after , the claimed evaluations at and its rotations | scalars per Action; shared | ||
| after , , the commitment ; then, after , the values | , ; ; then | point, scalars, shared | |
| ; then, after , , the pairs for , each followed by ; then , | , ; after each pair | points, scalars, shared |
Knowledge soundness, classified in §5, concerns what a convincing prover knows; zero knowledge concerns what the proof reveals. Halo 2 is zero-knowledge through two devices, hiding commitments and blinded polynomials, assembled into a simulator. This subsection states what each device achieves on its own, and states the claim for the whole protocol as a cited proposition with its hypotheses.
The prover of the running example sends commitments and the evaluations
The commitment of Construction 3.2 is perfectly hiding. The prover commits a polynomial as
with the coefficient vector, the generator vector, and the blinding generator of §3, of no known discrete-logarithm relation to ; the term makes the commitment a uniform group element for every , since generates , so a commitment by itself leaks nothing about what was committed. This is the perfect hiding of the Pedersen commitment, proved in the Crypto Guide (§“The Pedersen commitment” and §“Hiding and binding”) and recalled in §2.9. Every commitment the prover sends in phases 1 to 6, the advice columns, the permuted lookup columns and , the permutation and lookup running products, the random polynomial, the quotient chunks and the multipoint polynomial , has this form with a fresh (the halo2 book’s Protocol Description chapter, which blinds every group element of the protocol, its note 4). The verifying key’s commitments and the instance commitments carry the fixed blinding factor instead: they commit public data both parties recompute (§4.5, §4.2), so there is nothing to hide, and a random blinder would prevent the two computations from agreeing.
The prover opens commitments, and an opening reveals evaluations. To
keep those evaluations from revealing the witness, the last
rows of
the table, the blinding rows, carry no circuit data: no gate
applies there, and each advice column holds uniformly random field
elements on them. By Lemma 4.9 below, a column
opened at distinct points outside the rows needs
Let
The map is
If
On the toy domain of §2.2, the rank
of the lemma’s map was computed for every choice of
It is a marginal statement about one column. The proof opens many related polynomials under shared challenges, and the joint distribution of all their evaluations, subject to the public relations among them, the gate equation, the running-product updates, the lookup identities, is not a consequence of the lemma applied column by column. The composition is addressed under “The simulator” below, and its status is stated there.
The quotient chunks admit no blinding-row treatment: determines them
entirely, and the rows of mean nothing. Their commitment blinders,
together with the blinding-row randomness they inherit through ,
protect them instead, and their single collapsed opening at is the
publicly computable value
In each phase the verifier sees only two kinds of object: hiding commitments, which are uniform group elements, and a bounded number of evaluations of the committed polynomials at the transcript’s challenge points. The blinding rows supply randomness which, by Lemma 4.9, makes the openings of each column uniform on its own; a full composition proof must show that this randomness masks the joint evaluations subject to the public relations, and must account for the correlations among advice, products, quotient and multipoint polynomials. The final inner-product opening uses the deployed mask of §3.8, the random polynomial vanishing at whose commitment opens phase 7, in addition to the commitment and round blinders, because Remark 3.7 showed that a final commitment blinder alone would not hide the folded coefficient; the opening of one polynomial was proved statistically honest-verifier zero knowledge there, and that proof is one ingredient of the composition, not the composition.
Zero knowledge requires a simulator for the complete joint transcript, given only the public input. The usual proof samples suitably blinded commitments and evaluations satisfying the verifier’s equations and then programs the random oracle so that the Fiat–Shamir challenges come out as required, in the manner of the Crypto Guide’s one-round simulator (§“The Fiat–Shamir transform: from interactive to non-interactive”). For the interactive protocol the halo2 book exhibits such a simulator and claims the following; this volume records the claim and does not reprove it.
The interactive Halo 2 protocol is perfect special honest-verifier zero
knowledge, the simulator being given the verifier’s challenges in
advance (the Crypto Guide, §“Sigma-protocols”), for challenge
tuples in which every challenge is nonzero and outside the rows and
every factor
Let every challenge be uniform in with no value excluded, as the
deployed transcript draws them. Then the transcripts of the interactive
protocol and of the simulator of Proposition 4.10, run on
the same challenges, are within statistical distance
Each challenge has at most
Perfect hiding of each commitment and Lemma 4.9 are ingredients of that argument, not by themselves a proof that the joint distribution matches a real execution. For the compiled argument, the Crypto Guide’s compilation recipe (Theorem “The compilation recipe, informal”, §“SNARKs: succinct non-interactive arguments of knowledge”) yields zero knowledge when the polynomial IOP is properly blinded and the corresponding simulation theorem applies; for a multi-round protocol that is a multi-round simulation theorem in the programmable random-oracle model, which this volume neither proves nor cites from a source that proves it for this protocol. Non-interactive zero knowledge of the deployed proof is therefore stated, not proved.
Subject to the hypotheses just named, Halo 2 targets three guarantees
for the relation of a PLONKish circuit
(Definition 2.7), the three that
§1.2 demanded of a proof. Overwhelming
completeness: an honest prover holding a satisfying witness convinces
the verifier except on negligible transcript degeneracies, a zero
inner-product challenge (§3.8, probability per
challenge), a point among the query points of the multipoint
reduction (“Completeness” in §4.4), an
evaluation point on a row, where the verifier’s division by
The protocol of §4.5 factors into two layers: a polynomial interactive oracle proof for the relation, and a polynomial commitment scheme, in the sense of the Crypto Guide (§“Polynomial commitment schemes”), that realises the proof’s oracles. Every phase of the protocol belongs to one of the two layers.
The Crypto Guide defines the object (§“SNARKs: succinct
non-interactive arguments of knowledge”, under “Polynomial interactive
oracle proofs”): a public-coin interactive protocol in which, in place of
ordinary messages, the prover in each round sends one or more
oracles for polynomials
The Crypto Guide’s compilation recipe (the same section) turns a polynomial IOP into a non-interactive argument with a polynomial commitment scheme and a random oracle . Setup runs the commitment scheme’s setup. The prover simulates the IOP, replacing each oracle message by its commitment , derives every verifier challenge from the transcript by the Fiat–Shamir transform of §4.3, and supplies, for each of the IOP’s queries, the claimed evaluation together with an evaluation proof (). The verifier parses the transcript, recomputes the challenges, checks each evaluation proof (), and runs the IOP’s accept-or-reject check on the opened evaluations (Figure 15).
The IOP that Halo 2 compiles is PLONK’s, in the PLONKish generality of
§2.5. Its oracles, sent by the prover, are one
polynomial per advice column; for each lookup, the two permuted columns
and ; the permutation running products, one per chunk, and one
lookup running product per lookup; and the quotient , split into
chunks below the degree bound. The fixed columns, the selectors among
them, and the permuted-label polynomials are preprocessed,
part of the verifying key rather than prover messages, which is why they
are absent from the list. The verifier’s challenges, in order, are
for the lookup compression, and for the
permutation and lookup products, for the combination of all
constraints into one gate equation, and for the evaluation point. The
final check is the gate equation
Phases 1 to 5 of §4.5 are this IOP compiled, with one
addition: the commitments to the advice, the permuted lookup columns, the
running products and the quotient chunks are the oracle messages replaced by
commitments, and the random polynomial of phase 4, committed and evaluated at
, is the compiler’s addition for zero knowledge (§4.6), not
an IOP message; the challenges are the IOP’s challenges squeezed from the
transcript, and the claimed evaluations of phase 5 answer the IOP’s oracle
queries. Phases 6 and 7 bind those answers to the commitments: the multipoint
reduction of §4.4, with its challenges
Soundness of the compiled argument is not the sum of two numbers, and the notions under which it is proved deserve their names. A polynomial IOP is round-by-round knowledge sound, informally, when its partial transcripts admit a “doomed” labelling that a prover message cannot escape except with bounded probability over the next verifier challenge; a related state-restoration notion lets a prover restore an earlier verifier state and redraw its challenge, which is precisely what a prover attacking a transcript hash can do. Precise equivalence or implication theorems between the two notions require additional conditions on the protocol and on the extractor, and this volume does not identify them. The Crypto Guide’s compilation recipe (Theorem “The compilation recipe, informal”, §“SNARKs: succinct non-interactive arguments of knowledge”) assumes a complete, knowledge-sound public-coin polynomial IOP; a correct, evaluation-binding and extractable commitment scheme; compatible composition hypotheses; and a suitable multi-round Fiat–Shamir theorem in the random-oracle model. For a multi-round protocol such as Halo 2 this volume reads those hypotheses as three: the IOP has a round-by-round or state-restoration knowledge-soundness theorem; the commitment scheme is extractable and evaluation-binding in a form compatible with it; and the transcript satisfies the hypotheses of an appropriate multi-round Fiat–Shamir theorem. The conclusion is that the compiled protocol is a non-interactive argument of knowledge in the random-oracle model, by layered extraction: the commitment scheme’s extractor recovers the committed polynomials, converting the argument’s prover into an IOP prover; the multi-round Fiat–Shamir theorem transfers the round-by-round or state-restoration guarantee to the non-interactive setting; and evaluation binding ensures that the opened evaluations are those of the extracted polynomials. What it does not say is that the knowledge error is determined by two scalars, the IOP’s knowledge error and the commitment scheme’s extraction error, added together: the exact error and the query loss depend on the definitions and on the extraction model, and §5 names the theorems that fix them for the analysed protocol and classifies their instantiation to the deployed transcript.
The subsection proves nothing afresh. The commitment interface with its hiding, binding and extraction properties is the Crypto Guide’s (§“Polynomial commitment schemes”); the Fiat–Shamir transform and its random-oracle security are the same volume’s (§“The Fiat–Shamir transform: from interactive to non-interactive”); the definitions of completeness, soundness and knowledge soundness for interactive arguments used above are its (§“Interactive proofs, zero knowledge, and SNARKs” and §“Knowledge soundness and extractors”); and the Schwartz–Zippel lemma and the vanishing polynomial of the rows are the Math Guide’s (§“The Schwartz–Zippel lemma” and §“The evaluation domain and its vanishing polynomial”). The volume adds the instantiation: which oracles, which challenges, which openings, and the one commitment scheme that realises them.