Introduction
Incrementally verifiable computation (IVC) [21 ] allows a computation to maintain a short proof of the computation performed so far. After each step, the prover updates a succinct proof certifying the current configuration, without retaining or recomputing the preceding execution. IVC is particularly relevant to the way we use AI systems: we interact with them over time, providing new inputs and receiving responses as a conversation or task unfolds. Each new interaction prompts further computation that builds on the system’s current state. The computation thus proceeds incrementally, and we would like verification to proceed alongside it.
Several IVC schemes have been proposed in the literature, including schemes based on standard cryptographic assumptions such as LWE [19 , 9 , 20 ] . These results, however, do not directly address an important feature of many AI tasks: their dependence on external information and expertise. As emphasized by the UK AISI Alignment Team [13 ] , verification methods for AI safety should accommodate access to external information and human judgment. Oracle-aided computation provides a natural model for such computations: an AI system may query an external database, consult a specialized service, or ask for human judgment, with each consultation represented by an oracle query. Extending IVC to this setting requires certifying that the computation is consistent with the underlying oracle. Moreover, efficient verification requires the verifier to make substantially fewer oracle queries than made by the computations they verify. Combining these two goals leads to the question at the center of this work:
Can an oracle-aided computation maintain a short, efficiently updatable proof of its correctness that can be verified using few oracle queries?
Oracle access introduces a fundamental obstacle to constructing succinct proofs that can be verified using few oracle queries, even for a single computation. As was observed by Barbara, Chiesa, and Guan [3 ] , for an arbitrary computation, one incorrect answer can change the outcome while leaving all ordinary transitions valid. A verifier that makes substantially fewer oracle queries than the computation may fail to inspect precisely that answer. Barbara et al. prove that relativized succinct arguments, where the verifier makes a sublinear number of oracle calls, do not exist, even with interaction and computational soundness.
We study two approaches to overcoming this obstacle. In both settings, our constructions satisfy adaptive completeness and soundness : completeness holds even when the input and honest execution are chosen after seeing the public parameters, and soundness holds even when a cheating prover chooses its claim after seeing these parameters.
The first approach follows Chen, Kalai, and Xi [7 ] and restricts soundness to robust computations, in which an incorrect conclusion requires a substantial fraction of the oracle answers to be wrong. Chen et al. showed that this robustness condition enables doubly-efficient interactive verification. We construct non-interactive succinct arguments (SNARGs) and then extend them to IVC for robust oracle-aided bounded-space computations, including non-deterministic computations, under the sub-exponential hardness of LWE. Our schemes are privately verifiable . Namely, checking a proof requires a secret verification key generated during setup and withheld from the prover, who can construct and update proofs without access to this key. We complement this result with a lower bound: for general robust oracle-aided computations, a SNARG or IVC scheme with oracle-free setup and adaptive completeness and soundness cannot have both public parameters of length sublinear in the input length and a
deterministic public verifier making a number of oracle queries sublinear in the computation’s query count.
We would nevertheless like to obtain publicly verifiable SNARGs and IVC. For AI oversight, we want a proof to serve as a certificate that can be shared and independently checked by users, auditors, and other systems, without access to a private verification key. Our second approach makes this possible by requiring the oracle to authenticate its responses. Specifically, a signed oracle attaches a digital signature to each query-answer pair. This is a natural requirement when the oracle represents an external database or service: its provider can sign responses as they are issued, making their authenticity publicly checkable. We show that signed oracles enable publicly verifiable SNARGs and IVC under LWE assumptions. Signing the oracle’s responses also removes the robustness restriction altogether: our constructions apply to arbitrary computations with access to signed oracles, even when a single incorrect oracle answer can change the outcome. Moreover, verification requires no oracle queries.
Taken together, our results delineate two complementary possibilities for incrementally verifiable oracle-aided computation. Robustness enables succinct incremental verification of unauthenticated oracle computations using private verification and a small number of oracle queries; signed oracles enable public, oracle-free verification even for non-robust computations. The main technical innovations of this work lie in the robust setting, where we develop new techniques for proving soundness and preserving it under incremental proof updates. The signed-oracle constructions build on established techniques; their contribution is primarily conceptual, showing that authenticating oracle responses enables publicly verifiable SNARGs and IVC without any robustness requirement.
Our Results in More Detail
Throughout this work, we denote by λ \lambda λ the security parameter, n n n the input length, and T T T , S S S , and Q Q Q the time, space, and oracle-query bounds. The underlying oracle is fixed independently of setup, and setup makes no oracle queries. Our constructions have adaptive completeness and soundness: in particular, an adversary may choose its statement and proof after seeing the public parameters. All cryptographic assumptions are required to hold even given access to the underlying oracle.
Robust computations: from interaction to SNARGs and IVC. A purported execution follows the machine’s transition rules but may use incorrect oracle answers. We say that a computation is ε \varepsilon ε -robust on an input if the input is accepting, or every accepting purported execution uses incorrect answers on at least an ε \varepsilon ε -fraction of its oracle calls. Given a complete accepting purported execution on a false robust input, a verifier could detect an incorrect oracle answer by checking a small random sample of its oracle calls. Our first result obtains this guarantee using a SNARG and preserves it under incremental proof updates.
Theorem 1 (Robust oracle-aided computation, informal). Assuming sub-exponential hardness of LWE, there exist a privately verifiable SNARG and a privately verifiable IVC scheme for every time-T T T , space-S S S oracle-aided computation, including non-deterministic computations. Both schemes satisfy adaptive completeness and, for ε \varepsilon ε -robust claims, adaptive soundness , with the following guarantees:
The public parameters, private verification key, and proof have length poly ( λ , S , log T , 1 / ε ) \operatorname{poly}(\lambda, S, \log T, 1/\varepsilon) poly ( λ , S , log T , 1/ ε ) .
The verifier makes O ( λ / ε ) O(\lambda/\varepsilon) O ( λ / ε ) oracle queries.
Each IVC proof update and verification takes time poly ( n , λ , S , log T , 1 / ε ) \operatorname{poly}(n, \lambda, S, \log T, 1/\varepsilon) poly ( n , λ , S , log T , 1/ ε ) .
The prover updates its proof after each step without access to the private verification key or the preceding execution history.3
Here, adaptive completeness allows the input and honest execution to be chosen after seeing the public parameters. Adaptive soundness guarantees that no efficient adversary, given these parameters, can produce an accepting proof of a false ε \varepsilon ε -robust claim except with negligible probability. For IVC, robustness is imposed on the configuration being certified: every purported execution reaching an incorrect claimed configuration must contain an ε \varepsilon ε -fraction of incorrect oracle answers. Robustness of the final output alone does not imply this property for every intermediate configuration. It does imply the required condition for an accepting terminal configuration on a robust false input. The formal SNARG and IVC results appear in Theorem 20 (Section 5) and Theorem 49 (§ 7.5 ), respectively. § 3.2.1 and § 3.3.1 give the corresponding overviews.
A barrier to deterministic public verification. The private verification key conceals which oracle answers will be checked. The following theorem rules out deterministic public verification with short public parameters and few oracle queries.
Theorem 2 (Public-verification lower bound, informal). There does not exist a non-interactive argument for general robust oracle-aided computations with oracle-free setup, adaptive completeness and soundness, public parameters of length o ( n ) o(n) o ( n ) , and a deterministic public verifier making o ( Q ) o(Q) o ( Q ) oracle queries. This holds even for deterministic computations making nonadaptive oracle queries, and regardless of the proof length. The same impossibility applies to IVC with these guarantees.
The negative result already holds for the simple computation that, on input x x x , makes the Q Q Q oracle queries ( x , 1 ) , … , ( x , Q ) (x,1),\ldots,(x,Q) ( x , 1 ) , … , ( x , Q ) and outputs the majority of the resulting bits. For every candidate SNARG, our proof constructs an oracle, fixed independently of setup, and a cheating prover that produces an accepting proof of a false robust claim with non-negligible probability over the public parameters. Thus, under these requirements, robustness alone does not suffice for deterministic public verification. The IVC consequence follows by considering the proof at termination. See Theorem 24 (§ 6 ) and the overview in § 3.3 .
Public verification through signed oracles. For many applications, we would like a certificate that anyone can verify, without a private verification key or further access to the external sources. A result might be checked by several auditors, passed to another computation, or verified after the original oracle is no longer available. We also want to support computations that depend critically on individual oracle answers and therefore need not be robust.
Our second approach is to require the oracle to authenticate its answers. A signed oracle , on query u u u , returns the answer a = O ( u ) a = O(u) a = O ( u ) together with a digital signature on the pair ( u , a ) (u,a) ( u , a ) . The oracle holds the signing key, and its verification key is public and authenticated. An external database or service can therefore make its responses verifiable by signing them when they are supplied. For a versioned database, the version identifier can be included in the query. The answers themselves can be arbitrary; no randomness or algebraic structure is required. Signatures have previously been used in oracle-assisted proof systems, beginning with Chiesa and Tromer [8 ] . Here they authenticate the external information on which the application’s computation depends. Independently of our work, Chiesa, Guan, and Yıldız [5 ] also study signed application oracles in the context of zero-knowledge verification. Our signed-oracle results provide succinct non-interactive and incremental verification under LWE.
Theorem 3 (Signed oracle-aided computation, informal). Computations with access to signed oracles admit publicly verifiable SNARGs and IVC, with adaptive completeness and adaptive soundness, under the assumptions below. No robustness assumption is required, and neither setup nor verification makes oracle queries.
For time-T T T , space-S S S non-deterministic computations, sub-exponential hardness of LWE suffices. Public parameters and proofs have length poly ( λ , S , log T ) \operatorname{poly}(\lambda, S, \log T) poly ( λ , S , log T ) , and IVC proof updates and verification take time poly ( n , λ , S , log T ) \operatorname{poly}(n, \lambda, S, \log T) poly ( n , λ , S , log T ) .
For deterministic time-T T T computations with oracle queries and answers of length poly ( λ , log T ) \operatorname{poly}(\lambda, \log T) poly ( λ , log T ) , sub-exponential hardness of LWE suffices. Public parameters and proofs have length poly ( λ , log T ) \operatorname{poly}(\lambda, \log T) poly ( λ , log T ) , and verification and IVC proof updates take time n ⋅ poly ( λ , log T ) n \cdot\operatorname{poly}(\lambda, \log T) n ⋅ poly ( λ , log T ) . When T T T is polynomially bounded in λ \lambda λ , polynomial hardness of LWE suffices.
The hardness assumptions are understood to hold even given access to the underlying oracle. The honest prover obtains only the authenticated oracle responses used by the underlying execution.
The bounded-space results appear in Theorem 27 (Section 7) and Theorem 45 (§ 7.4 ). The fully succinct deterministic SNARG is Theorem 31 (§ 6.5 ), and the corresponding IVC refinement appears at the end of § 7.4 . For larger deterministic time bounds, the constructions require correspondingly stronger, poly ( T ) \operatorname{poly}(T) poly ( T ) -hard security; polynomial hardness alone is not sufficient for that extension. § 3.1 gives an overview of both constructions.
The contribution of this approach is primarily conceptual: authenticating external answers makes public succinct and incremental verification possible even when an individual answer can determine the outcome. The constructions adapt established hash-and-batch-argument and updatable-batch-argument techniques, with local checks for signatures. Their soundness uses local extraction to turn an incorrect authenticated answer into a signature forgery. In particular, the verifier checks a succinct proof of the authenticated execution; it need not receive and verify every signature separately.
Related Work
Oracle-aided verification and AI oversight. The study of oracle-aided verification is motivated in part by approaches to AI oversight in which a verifier has limited access to external information or judgment. Irving, Christiano, and Amodei [12 ] proposed AI safety via debate, and Brown-Cohen, Irving, and Piliouras [4 ] developed doubly-efficient debate protocols. These models use competing provers. Chen, Kalai, and Xi [7 ] study single-prover verification and obtain doubly-efficient interactive proofs and arguments for robust computations and for computations with low-degree oracles. In particular, their robust interactive argument uses O ( 1 / ε ) O(1/\varepsilon) O ( 1/ ε ) verifier oracle queries for constant soundness error. We study non-interactive arguments and incremental proof maintenance for bounded-space computations, and show a further limitation on deterministic public verification even under robustness.
Signed oracle models. Chiesa and Tromer [8 ] introduced a signed-input-and-randomness functionality and used it to construct short non-interactive arguments and proof-carrying data. The functionality supplies signed randomness to support extraction and recursive proof composition; their verifier already operates without access to it. They also discuss realizations using signature cards and trusted services. Maller, Mohnblatt, and Zapico [18 ] introduce the open-and-sign random-oracle model to obtain security guarantees for recursive proof systems, including IVC of polynomial depth. These works concern oracle functionalities used by the proof system itself. Our setting authenticates arbitrary answers supplied by the application’s external sources.
Independent work of Chiesa, Guan, and Yıldız [5 ] also considers this use of signed oracle answers. They study zero knowledge for oracle-aided computations, prove an impossibility result in the random-oracle model, and obtain zero-knowledge verification with efficient prover and verifier for signed oracles under collision-resistant hashing. Our work focuses on succinct non-interactive arguments and IVC under LWE, with the time–space bounds stated above, and also treats robust computations with unsigned oracles.
Succinct arguments from standard assumptions. Our constructions build on the development of batch arguments and SNARGs from standard cryptographic assumptions. Choudhuri, Jain, and Jin [6 ] construct SNARGs for deterministic polynomial-time computations from LWE. Kalai, Vaikuntanathan, and Zhang [15 ] obtain SNARGs for bounded-space non-deterministic computations under sub-exponential LWE. Our bounded-space signed-oracle result preserves the polynomial dependence on space and polylogarithmic dependence on time available for oracle-free NTISP(T T T , S S S ). The additional issue is establishing that locally extracted oracle responses agree with the underlying oracle, using either signature unforgeability or the quantitative guarantee supplied by robustness.
Incrementally verifiable computation. IVC originates in the work of Valiant [21 ] . Chiesa and Tromer [8 ] introduced proof-carrying data, and Bitansky, Canetti, Chiesa, and Tromer [2 ] developed recursive composition and bootstrapping for SNARKs and proof-carrying data. Paneth and Pass [19 ] and, independently, Devadas, Goyal, Kalai, and Vaikuntanathan [9 ] obtain IVC for deterministic computations from LWE using rate-1 batch arguments.
Our incremental constructions use the updatable batch arguments of Aldema Tshuva and Oshman [20 ] , who develop a general framework for lifting delegation schemes to IVC across several models of computation. Their primitive supports adding statements and witnesses as they become available. We use this framework to maintain local certificates of an oracle-aided execution. In the robust setting, the additional challenge is to preserve hidden sampling and quantitative soundness for a growing sequence of unauthenticated oracle responses.
Paper Organization
§ 3 gives a technical overview. § 4 reviews the cryptographic primitives, and § 5 defines robust oracle-aided computation and its verification. Section 5 constructs privately verifiable SNARGs for robust computations, and § 6 proves the lower bound for deterministic public verification. Section 7 develops publicly verifiable SNARGs for signed oracles, including the fully succinct deterministic construction. § 7 defines oracle-aided IVC and gives constructions in both settings.
Technical Overview
Technical Overview
The main difficulty in constructing SNARGs and IVC for oracle-aided computations is certifying the correctness of the oracle answers. Although numerous techniques are known for standard computations, both deterministic and non-deterministic, the oracle-aided setting presents a fundamental barrier. As observed in prior work [3 ] , a cheating prover can honestly execute a computation with respect to an oracle that differs from the true oracle on a single query. This single discrepancy may change the outcome, yet the verifier can detect it only by querying the oracle at that point. Thus, without further restrictions, the verifier may need to check every oracle answer, undermining our goal of making verification substantially more efficient than the computation itself.
We overcome this barrier in two settings. First, we consider signed oracles , whose answers come with signatures authenticating the query-answer pairs. We incorporate signature verification into the computation being proved and use local extraction to establish soundness. This yields publicly verifiable SNARGs and IVC for arbitrary oracle-aided computations, with a verifier that makes no oracle queries. We describe this approach in § 3.1 .
Second, we consider arbitrary oracles but require soundness only for robust computations : for any input x x x and any incorrect claimed output y y y , every purported execution4 on x x x that outputs y y y must contain a substantial fraction of incorrect oracle answers. With this relaxed soundness guarantee, we obtain SNARGs and IVC with relatively few verifier oracle queries. Our SNARGs and IVC in this setting are privately verifiable . We describe this approach in § 3.2 . In § 3.3 , we rule out deterministic publicly verifiable SNARGs and IVC with a sublinear number of oracle queries and public parameters of length o ( n ) o(n) o ( n ) .
We begin with the signed-oracle setting, whose analysis is simpler and serves as an introduction to our approach. Our main technical innovations arise in the robust setting. Our constructions follow the hash-and-BARG paradigm with local extraction, and we prove soundness under the LWE assumption. The key is to show that local guarantees suffice to establish the correctness of the oracle answers. For signed oracles, we adapt the local-extraction analysis to recover a signature forgery from a false proof. For arbitrary oracles, we show that the verifier’s hidden oracle checks reject an incorrect claim with high probability whenever every purported execution supporting that claim contains a substantial fraction of incorrect oracle answers. The space-dependent constructions assume sub-exponential hardness of LWE; for deterministic signed-oracle computations with T T T polynomially bounded in λ \lambda λ , polynomial hardness suffices.
Throughout this overview, T T T and S S S denote the time and space bounds, n n n is the input length, and λ \lambda λ is the security parameter. The oracle is fixed independently of setup, and our cryptographic assumptions are required to hold even for adversaries with access to it.
Signed Oracles
A signed oracle returns an answer a = O ( u ) a = \mathcal{O}(u) a = O ( u ) together with a signature on ( u , a ) (u,a) ( u , a ) . Its verification key vk is public and known to both the prover and the verifier, while its signing key is known only to the oracle. We first explain how to use these signatures to construct a SNARG, and then how to maintain the proof incrementally.
From signed answers to a SNARG
We begin with non-deterministic computations running in time T T T and space S S S . Our first construction has proof and public parameter lengths poly ( λ , S , log T ) \operatorname{poly}(\lambda, S, \log T) poly ( λ , S , log T ) and relies on sub-exponential hardness of LWE. This matches the best known dependence on the time and space bounds for oracle-free SNARGs for NTISP(T , S T, S T , S ) from LWE. We later show how to remove the dependence on the space bound for deterministic computations.
We follow the hash-and-BARG approach with local extraction, used in prior LWE-based SNARG constructions for NTISP [15 , 6 ] . The prover hashes the computation and uses a batch argument to certify its local transitions. We augment these transitions with signature verification and rely on the local-extraction guarantees. Here it is essential to recover the signature itself: a valid signature on an incorrect oracle answer may exist, so ordinary soundness for the augmented computation does not suffice. Local extraction allows us to turn a false proof into an explicit signature forgery.
Soundness. Our analysis follows the local-extraction approach of prior work. We track whether a configuration is reachable at the prescribed time using correct oracle answers. The initial configuration is reachable, whereas an accepting configuration on a false input is not. A transition from a reachable configuration to an unreachable one must therefore either violate the machine’s transition rules or use an incorrect oracle answer. The former violates the batch argument’s local-extraction guarantee. In the latter case, the extracted witness contains a valid signature on an incorrect query-answer pair, yielding a signature forgery.
To formalize this intuition, we use two independent batch-argument components to extract neighboring transitions. Collision resistance ensures that their shared configuration agrees, while index hiding allows us to move the extraction indices through the computation. Tracking reachability across these comparisons connects the prescribed initial configuration to the claimed endpoint. Consequently, a successful cheating prover allows us to break one of the underlying primitives or forge a signature.
Removing the space dependence. For deterministic computations, we can remove the dependence on the space bound using techniques from prior work. We compress configurations by replacing the work tape with its Merkle-tree hash. Authentication paths allow us to check the symbols read by each transition and the resulting change to the tape hash using a short witness. The local-extraction guarantee of the batch argument allows the soundness reduction to recover a signature on an incorrect oracle answer. Moreover, the soundness analysis can compare extracted configurations with the unique execution under the true oracle, avoiding the need to explore the bounded-space configuration graph. For IVC, we additionally use an updatable hash family to authenticate the growing sequence of transition records without rehashing the preceding records. For short oracle queries and answers, this yields proof and public parameter lengths poly ( λ , log T ) \operatorname{poly}(\lambda, \log T) poly ( λ , log T ) ; for T T T polynomially bounded in λ \lambda λ , polynomial hardness of LWE suffices.
Making the proof incremental
Our IVC construction follows the same approach, using the updatable batch arguments of Aldema Tshuva and Oshman [20 ] . These allow the prover to extend its proof after each computation step without revisiting the preceding execution. As above, we apply this machinery to a computation that also verifies signatures on its oracle query–answer pairs. The soundness analysis adapts the same local-extraction argument, with signature unforgeability ruling out incorrect oracle answers. This yields publicly verifiable IVC with proof and public parameter lengths poly ( λ , S , log T ) \operatorname{poly}(\lambda, S, \log T) poly ( λ , S , log T ) and a verifier that makes no oracle queries. For deterministic computations with short oracle queries and answers, the same configuration compression removes the dependence on S S S .
Robust Computations
We next consider arbitrary oracles, whose answers need not carry signatures. Here robustness provides another way to check correctness: on a false input, every accepting purported execution contains at least an ε \varepsilon ε fraction of incorrect oracle answers. If we could inspect such an execution, checking a few randomly chosen oracle answers would therefore suffice. Our goal is to obtain the same guarantee from a succinct proof.
A privately verifiable SNARG
We again use hash-and-BARG with local extraction, but now give the verifier private extraction trapdoors. These allow it to recover selected query-answer pairs and check them against the true oracle. We append a table listing all oracle calls to the computation transcript, and use the batch argument to certify that each table entry agrees with the corresponding call in the transcript. This allows the verifier to sample uniformly from the oracle calls.
Soundness. For signed oracles, extracting one incorrect answer together with its signature suffices to obtain a contradiction. For arbitrary oracles, we need a quantitative guarantee: the verifier’s hidden checks must detect incorrect answers with sufficient probability.
If the proof specified a complete purported execution, this would follow immediately from robustness. However, local extraction only gives witnesses for selected positions, and we cannot assume that these witnesses come from a single, globally consistent execution. Moreover, the prover chooses its input and proof after seeing the public parameters.
We address this using a potential Φ t x ( C ) \Phi_t^x(C) Φ t x ( C ) : the minimum number of incorrect oracle answers needed to reach configuration C C C at time t t t on input x x x , over all purported executions. We cap this quantity at Q Q Q , the number of oracle calls in every purported execution. The potential is used only in the analysis; the verifier does not compute it.
A correct transition cannot increase the potential, and an incorrect oracle answer can increase it by at most one. The potential starts at zero, while robustness guarantees that it is at least ε Q \varepsilon Q εQ at any accepting configuration on a false robust input. Along a single execution, these properties would imply at least ε Q \varepsilon Q εQ incorrect answers. Our argument obtains an analogous bound in expectation from local extractions that need not form a single execution.
More precisely, let p s p_s p s be the probability that the prover outputs a false robust instance, all public checks accept, and the first s s s private checks accept. We show that, for each check except the last,
p s ≤ ( 1 − ε ) p s − 1 + negl ( λ ) . p_s \le(1-\varepsilon)p_{s-1}+\operatorname{negl}(\lambda). p s ≤ ( 1 − ε ) p s − 1 + negl ( λ ) .
Although the hidden indices are sampled independently, the prover chooses its input and proof after seeing the public parameters, which are generated using these indices. Thus, this bound does not follow from independence alone.
To account for the preceding checks, let E E E be the event defining p s − 1 p_{s-1} p s − 1 . We multiply each potential by 1 E \mathbf{1}_E 1 E before taking expectations, so outcomes outside E E E contribute zero.5 We compare neighboring local extractions using the current component and the last component, whose trapdoor is unused by the preceding checks. Index hiding lets us change one component’s extraction index while evaluating the weighted potential with the other component’s trapdoor. When both components open the same transcript position, hash binding ensures that they recover the same configuration, except with negligible probability. We can therefore switch which component evaluates the potential and continue changing indices.
These comparisons allow the expected weighted potential differences to telescope. The initial-to-final potential gap then gives a lower bound on the contribution of incorrect oracle answers. Relating these answers to the oracle-call table and averaging over its entries yields
Pr [ E and the s th private check rejects ] ≥ ε p s − 1 − negl ( λ ) , \Pr[E \text{ and the }s\text{th private check rejects}] \ge\varepsilon p_{s-1} - \operatorname{negl}(\lambda), Pr [ E and the s th private check rejects ] ≥ ε p s − 1 − negl ( λ ) ,
which implies the desired recurrence. Iterating it over all but the last check gives negligible soundness error with O ( λ / ε ) O(\lambda/\varepsilon) O ( λ / ε ) oracle queries, without extracting a complete execution.
Impossibility of succinct deterministic public verification
We show that robustness alone does not suffice for deterministic public verification with a sublinear number of oracle queries and short public parameters. Specifically, there is no publicly verifiable SNARG for general robust oracle-aided computations with oracle-free setup, adaptive completeness and soundness, public parameters of length o ( n ) o(n) o ( n ) , and a deterministic verifier making o ( Q ) o(Q) o ( Q ) oracle queries. Here n n n is the input length and Q Q Q is the number of oracle calls made by the computation.
Our counterexample is a simple majority computation. Consider a Boolean oracle whose queries are pairs ( x , i ) (x,i) ( x , i ) , where x ∈ { 0 , 1 } n x \in\{0,1\}^n x ∈ { 0 , 1 } n and i ∈ [ Q ] i \in[Q] i ∈ [ Q ] . We view the oracle as a table: each input x x x indexes a row consisting of the Q Q Q bits O ( x , 1 ) , … , O ( x , Q ) \mathcal{O}(x,1),\ldots,\mathcal{O}(x,Q) O ( x , 1 ) , … , O ( x , Q ) . On input x x x , the computation reads this row and outputs its majority:
O ( x ) = Maj ( O ( x , 1 ) , … , O ( x , Q ) ) . \mathcal{O}(x)=\operatorname{Maj}(\mathcal{O}(x,1),\ldots,\mathcal{O}(x,Q)). O ( x ) = Maj ( O ( x , 1 ) , … , O ( x , Q )) .
For intuition, fix the public parameters and an accepting proof for some input under the all-one oracle. A deterministic verifier making only ℓ = o ( Q ) \ell=o(Q) ℓ = o ( Q ) oracle queries examines very few entries of the input’s row. Preserve those entries and change the remaining entries of that row to zero. Every answer seen by the verifier remains unchanged, so it still accepts. However, the row now contains at most ℓ \ell ℓ ones, making the claimed majority incorrect. Moreover, any accepting purported execution must use incorrect answers on a constant fraction of its oracle calls. Thus, the false claim satisfies the robustness requirement.
The difficulty is that the oracle must be fixed before the public parameters are generated. We use the shortness of the public parameters to encode every possible parameter string c r s \mathsf{crs} crs as a distinct input x c r s x_{\mathsf{crs}} x crs . For each such string, we simulate the honest prover and verifier under the all-one oracle and identify the entries of row x c r s x_{\mathsf{crs}} x crs queried by the verifier. This allows us to specify the corresponding row for every possible c r s \mathsf{crs} crs in advance. After setup, the cheating prover chooses the input x c r s x_{\mathsf{crs}} x crs and supplies the corresponding proof.
We cannot simply modify all these rows: the verifier may also query rows other than the one indexed by its input, and changing those rows could change its verification decision. Instead, we modify only a sparse set of rows, selected using a pairwise-independent hash function. With non-negligible probability, the row x c r s x_{\mathrm{crs}} x crs is modified while every other row visited by the verifier is left unchanged. On this event, the verifier sees exactly the same answers as under the all-one oracle and accepts a false robust claim. An averaging argument fixes the row selection and the prover’s randomness before setup, yielding a single oracle for which the attack succeeds with non-negligible probability over the public parameters.
The argument places no restriction on the proof length. Thus, the lower bound holds even for non-succinct non-interactive arguments with these parameter and query bounds. The same impossibility applies to IVC, since its proof at termination would give a SNARG for the completed computation. The formal result appears in § 6 .
Making the proof incremental
To obtain IVC, we must maintain this ability to sample oracle calls as the computation grows. We separate ordinary computation from oracle calls: an ordinary IVC certifies the computation between consecutive calls, while an outer updatable batch argument aggregates one record per oracle call. This lets the prover update its proof after every computation step while allowing the verifier to sample oracle calls directly.
A further issue is that the number of oracle calls in the claimed execution is not known at setup. Sampling from the full query bound could miss a much shorter execution. We therefore prepare hidden samples for query-count ranges whose sizes are powers of two. Verification uses a range within a factor of two of the claimed number of calls, preserving the sampling guarantee with only logarithmic overhead.
The same analysis extends to IVC by evaluating the potential at oracle-call boundaries. Soundness of the ordinary IVC ensures that the intervening computation cannot increase the potential, while the consistency guarantees of the updatable batch argument connect neighboring records. Thus, the quantitative argument continues to apply as the computation grows.
Under sub-exponential hardness of LWE, both constructions have proof and public parameter lengths poly ( λ , S , log T , 1 / ε ) \operatorname{poly}(\lambda, S, \log T, 1/\varepsilon) poly ( λ , S , log T , 1/ ε ) . Verification uses O ( λ / ε ) O(\lambda/\varepsilon) O ( λ / ε ) oracle queries, and IVC updates require no access to the private verification key.
Preliminaries
Notation. We let λ \lambda λ denote the security parameter throughout the paper. We use PPT to denote probabilistic polynomial-time, and denote the set of all positive integers up to n n n as [ n ] : = { 1 , … , n } [n] := \{1,\ldots,n\} [ n ] := { 1 , … , n } . For any x ∈ { 0 , 1 } n x \in\{0,1\}^{n} x ∈ { 0 , 1 } n and any subset J ⊆ [ n ] J \subseteq[n] J ⊆ [ n ] we denote by x J = ( x j ) j ∈ J x_J = (x_j)_{j \in J} x J = ( x j ) j ∈ J . For any finite set S S S , x ← S x \mathrel{\leftarrow} S x ← S denotes a uniformly random element x x x from the set S S S . Similarly, for any distribution D \mathcal{D} D , x ← D x \mathrel{\leftarrow} \mathcal{D} x ← D denotes an element x x x drawn from the distribution D \mathcal{D} D .
Hash Families with Local Opening and Updatability
In this section we recall the definition of a hash family with local opening [16 ] . These preliminaries are due to [BBK^{+}23].
Syntax. A hash family (HT) with succinct local opening consists of the following algorithms:
Gen ( 1 λ ) → h k \operatorname{Gen}(1^\lambda) \to\mathsf{hk} Gen ( 1 λ ) → hk . This is a PPT algorithm that takes as input the security parameter λ \lambda λ in unary and outputs a hash key h k \mathsf{hk} hk .
Hash ( h k , x ) → r t \operatorname{Hash}(\mathsf{hk},x) \to\mathsf{rt} Hash ( hk , x ) → rt . This is a deterministic poly-time algorithm that takes as input a hash key h k \mathsf{hk} hk and an input x ∈ { 0 , 1 } N x \in\{0,1\}^{N} x ∈ { 0 , 1 } N for N ≤ 2 λ N \le2^\lambda N ≤ 2 λ , and outputs a hash value r t \mathsf{rt} rt .
Open ( h k , x , j ) → ρ \operatorname{Open}(\mathsf{hk},x,j) \to\rho Open ( hk , x , j ) → ρ . This is a deterministic poly-time algorithm that takes as input a hash key h k \mathsf{hk} hk , an input x ∈ { 0 , 1 } N x \in\{0,1\}^{N} x ∈ { 0 , 1 } N for N ≤ 2 λ N \le2^\lambda N ≤ 2 λ , and an index j ∈ [ N ] j \in[N] j ∈ [ N ] , and outputs an opening ρ \rho ρ .
Verify ( h k , r t , j , b , ρ ) → 0 / 1 \operatorname{Verify}(\mathsf{hk},\mathsf{rt},j,b,\rho) \to0/1 Verify ( hk , rt , j , b , ρ ) → 0/1 . This is a deterministic poly-time algorithm that takes as input a hash key h k \mathsf{hk} hk , a hash value r t \mathsf{rt} rt , an index j ∈ [ N ] j \in[N] j ∈ [ N ] , a bit b ∈ { 0 , 1 } b \in\{0,1\} b ∈ { 0 , 1 } and an opening ρ \rho ρ . It outputs 1 (accept) or 0 (reject).
Definition 4. (Properties of HT ) A HT family ( Gen , Hash , Open , Verify ) (\operatorname{Gen},\operatorname{Hash},\operatorname{Open},\operatorname{Verify}) ( Gen , Hash , Open , Verify ) is required to satisfy the following properties.
Opening completeness. For any λ ∈ N \lambda\in\mathbb{N} λ ∈ N , any N ≤ 2 λ N \le2^\lambda N ≤ 2 λ , any x ∈ { 0 , 1 } N x \in\{0,1\}^{N} x ∈ { 0 , 1 } N , and any index j ∈ [ N ] j \in[N] j ∈ [ N ] ,
Pr [ Verify ( h k , r t , j , x j , ρ ) = 1 h k ← Gen ( 1 λ ) , r t = Hash ( h k , x ) , ρ = Open ( h k , x , j ) ] = 1. \Pr\left[
\begin{array}{c|c}
\operatorname{Verify}(\mathsf{hk},\mathsf{rt},j,x_j,\rho)=1 & \mathsf{hk} \leftarrow\operatorname{Gen}(1^\lambda),\\
& \mathsf{rt}=\operatorname{Hash}(\mathsf{hk},x),\\
& \rho=\operatorname{Open}(\mathsf{hk},x,j)
\end{array}
\right]=1. Pr Verify ( hk , rt , j , x j , ρ ) = 1 hk ← Gen ( 1 λ ) , rt = Hash ( hk , x ) , ρ = Open ( hk , x , j ) = 1. Succinctness. In the completeness experiment above, we have that ∣ h k ∣ + ∣ r t ∣ + ∣ ρ ∣ = poly ( λ ) |\mathsf{hk}|+|\mathsf{rt}|+|\rho|=\operatorname{poly}(\lambda) ∣ hk ∣ + ∣ rt ∣ + ∣ ρ ∣ = poly ( λ ) .
Collision resistance w.r.t. opening. For any poly-size adversary A \mathcal{A} A there exists a negligible function negl ( ⋅ ) \operatorname{negl}(\cdot) negl ( ⋅ ) such that for every λ ∈ N \lambda\in\mathbb{N} λ ∈ N ,
Pr [ Verify ( h k , r t , j , 0 , ρ 0 ) = 1 ∧ Verify ( h k , r t , j , 1 , ρ 1 ) = 1 h k ← Gen ( 1 λ ) , ( r t , j , ρ 0 , ρ 1 ) ← A ( h k ) ] = negl ( λ ) . \Pr\left[
\begin{array}{c|c}
\operatorname{Verify}(\mathsf{hk},\mathsf{rt},j,0,\rho_0)=1\\
\land\ \operatorname{Verify}(\mathsf{hk},\mathsf{rt},j,1,\rho_1)=1
&
\mathsf{hk}\leftarrow\operatorname{Gen}(1^\lambda),\\
&
(\mathsf{rt},j,\rho_0,\rho_1)\leftarrow\mathcal{A}(\mathsf{hk})
\end{array}
\right]=\operatorname{negl}(\lambda). Pr Verify ( hk , rt , j , 0 , ρ 0 ) = 1 ∧ Verify ( hk , rt , j , 1 , ρ 1 ) = 1 hk ← Gen ( 1 λ ) , ( rt , j , ρ 0 , ρ 1 ) ← A ( hk ) = negl ( λ ) .
Remark 5. We say that a hash family with local opening is T T T -secure, for T = T ( λ ) T=T(\lambda) T = T ( λ ) , if the collision resistance w.r.t. opening property holds against any poly ( T ) \operatorname{poly}(T) poly ( T ) -size adversary (as opposed to poly ( λ ) \operatorname{poly}(\lambda) poly ( λ ) -size) and the probability that the adversary finds a collision is negl ( T ) \operatorname{negl}(T) negl ( T ) (as opposed to negl ( λ ) \operatorname{negl}(\lambda) negl ( λ ) ). We refer to this property as T T T -collision-resistance w.r.t. opening.
Remark 6. One can naturally extend the definition of a hash family with local opening to allow the Open algorithm to take as input ( h k , x , J ) (\mathsf{hk},x,J) ( hk , x , J ) where J ⊆ [ N ] J \subseteq[N] J ⊆ [ N ] consists of a set of indices, as opposed to a single index. Open ( h k , x , J ) \operatorname{Open}(\mathsf{hk},x,J) Open ( hk , x , J ) will simply run Open ( h k , x , j ) \operatorname{Open}(\mathsf{hk},x,j) Open ( hk , x , j ) for every j ∈ J j \in J j ∈ J . Verify can be extended in a similar way to take as input ( h k , r t , J , b J , ρ J ) (\mathsf{hk},\mathsf{rt},J,b_J,\rho_J) ( hk , rt , J , b J , ρ J ) , and accept if and only if Verify ( h k , r t , j , b j , ρ j ) = 1 \operatorname{Verify}(\mathsf{hk},\mathsf{rt},j,b_j,\rho_j)=1 Verify ( hk , rt , j , b j , ρ j ) = 1 for every j ∈ J j \in J j ∈ J .
Theorem 7 ([16 ] ). Assuming the existence of a collision resistant hash family there exists a hash family with local opening (according to Theorem 4).
Updatable hash families. For our IVC constructions (§ 7 ), we use an updatable variant of a hash family with local openings, as in [20 ] . This variant is a generalization of Theorem 4, which allows to authenticate sequences of strings, rather than only sequences of bits. Specifically, we view a bit string x ∈ { 0 , 1 } N x \in\{0,1\}^{N} x ∈ { 0 , 1 } N as a sequence of N N N strings, each of length one. Under this identification, the following definition generalizes Theorem 4.
Succinct Non-Interactive Arguments
Definition 8 (Updatable hash family with local openings). Let z = ( z 1 , … , z k ) \mathbf{z}=(z_1,\ldots,z_k) z = ( z 1 , … , z k ) be a sequence of strings of arbitrary lengths . The algorithms HT.Hash, HT.Open, and HT.Verify are extended as follows:
HT.Hash(hk, z \mathbf{z} z ) → v \to v → v outputs a hash value authenticating the sequence z \mathbf{z} z .
HT.Open(hk, z \mathbf{z} z , j j j ) → ρ \to\rho → ρ outputs an opening of the j j j th string z j z_j z j .
HT.Verify(hk, v , j , z , ρ ) → { 0 , 1 } v,j,z,\rho) \to\{0,1\} v , j , z , ρ ) → { 0 , 1 } checks that z z z is the string at position j j j in the sequence authenticated by v v v .
We say that HT is updatable if it additionally provides the following two algorithms:
HT.Append(hk, v , z v,z v , z ) → v ′ \to v' → v ′ . The algorithm appends the string z z z to the sequence authenticated by v v v , without accessing the preceding strings.
HT.Size(v v v ) → k \to k → k . The algorithm returns the number of strings in the sequence authenticated by v v v . We set HT.Size(⊥ \perp ⊥ ) = 0 =0 = 0 .
We require the following properties.
Opening completeness. For every λ ∈ N \lambda\in\mathbb{N} λ ∈ N , every h k ∈ Supp ( H T . G e n ( 1 λ ) ) \mathrm{hk} \in\operatorname{Supp}(\mathrm{HT.Gen}(1^\lambda)) hk ∈ Supp ( HT.Gen ( 1 λ )) , every sequence z = ( z 1 , … , z k ) \mathbf{z}=(z_1,\ldots,z_k) z = ( z 1 , … , z k ) of admissible length, and every j ∈ [ k ] j \in[k] j ∈ [ k ] , letting
v = H T . H a s h ( h k , z ) , ρ = H T . O p e n ( h k , z , j ) , v=\mathrm{HT.Hash}(\mathrm{hk},\mathbf{z}),\qquad\rho=\mathrm{HT.Open}(\mathrm{hk},\mathbf{z},j), v = HT.Hash ( hk , z ) , ρ = HT.Open ( hk , z , j ) , we have
H T . V e r i f y ( h k , v , j , z j , ρ ) = 1. \mathrm{HT.Verify}(\mathrm{hk},v,j,z_j,\rho)=1. HT.Verify ( hk , v , j , z j , ρ ) = 1. Pr [ z ≠ z ~ , H T . V e r i f y ( h k , v , j , z , ρ ) = 1 , H T . V e r i f y ( h k , v , j , z ~ , ρ ~ ) = 1 ; h k ← H T . G e n ( 1 λ ) , ( v , j , z , ρ , z ~ , ρ ~ ) ← A ( h k ) ] ≤ μ ( λ ) . \Pr\left[
\begin{array}{c}
z\ne\widetilde{z},\\
\mathrm{HT.Verify}(\mathrm{hk},v,j,z,\rho)=1,\\
\mathrm{HT.Verify}(\mathrm{hk},v,j,\widetilde{z},\widetilde{\rho})=1
\end{array}
\ ;\
\begin{array}{c}
\mathrm{hk}\leftarrow\mathrm{HT.Gen}(1^\lambda),\\
(v,j,z,\rho,\widetilde{z},\widetilde{\rho})\leftarrow\mathcal{A}(\mathrm{hk})
\end{array}
\right]\le\mu(\lambda). Pr z = z , HT.Verify ( hk , v , j , z , ρ ) = 1 , HT.Verify ( hk , v , j , z , ρ ) = 1 ; hk ← HT.Gen ( 1 λ ) , ( v , j , z , ρ , z , ρ ) ← A ( hk ) ≤ μ ( λ ) . Append completeness. For every sequence z = ( z 1 , … , z k ) \mathbf{z}=(z_1,\ldots,z_k) z = ( z 1 , … , z k ) and every additional string z k + 1 z_{k+1} z k + 1 , satisfying
k + 1 ≤ 2 λ and ∑ i = 1 k + 1 ( ∣ z i ∣ + 1 ) ≤ 2 2 λ , k+1\le2^\lambda\qquad\text{and}\qquad\sum_{i=1}^{k+1}(|z_i|+1)\le2^{2\lambda}, k + 1 ≤ 2 λ and i = 1 ∑ k + 1 ( ∣ z i ∣ + 1 ) ≤ 2 2 λ , we have
H T . A p p e n d ( h k , H T . H a s h ( h k , z ) , z k + 1 ) = H T . H a s h ( h k , ( z 1 , … , z k + 1 ) ) . \mathrm{HT.Append}(\mathrm{hk},\mathrm{HT.Hash}(\mathrm{hk},\mathbf{z}),z_{k+1})
=\mathrm{HT.Hash}(\mathrm{hk},(z_1,\ldots,z_{k+1})). HT.Append ( hk , HT.Hash ( hk , z ) , z k + 1 ) = HT.Hash ( hk , ( z 1 , … , z k + 1 )) . Moreover,
H T . S i z e ( H T . H a s h ( h k , z ) ) = k . \mathrm{HT.Size}(\mathrm{HT.Hash}(\mathrm{hk},\mathbf{z}))=k. HT.Size ( HT.Hash ( hk , z )) = k . We set
H T . H a s h ( h k , ∅ ) = ⊥ and H T . S i z e ( ⊥ ) = 0. \mathrm{HT.Hash}(\mathrm{hk},\emptyset)=\perp
\qquad\text{and}\qquad
\mathrm{HT.Size}(\perp)=0. HT.Hash ( hk , ∅ ) =⊥ and HT.Size ( ⊥ ) = 0. Succinctness and efficiency. The lengths of hk, v v v , and ρ \rho ρ are bounded by poly ( λ ) \operatorname{poly}(\lambda) poly ( λ ) . The algorithms HT.Append and HT.Verify run in time poly ( λ , ∣ z ∣ ) \operatorname{poly}(\lambda,|z|) poly ( λ , ∣ z ∣ ) , independently of the lengths of the preceding strings. The algorithm HT.Size runs in time poly ( λ ) \operatorname{poly}(\lambda) poly ( λ ) .
The Merkle-forest construction of [20 ] provides such an updatable hash family from any collision-resistant hash functions.
Succinct Non-Interactive Arguments
We define succinct non-interactive argument systems (SNARG) [17 , 10 , 2 ] for the computation of a non-deterministic polynomial-time Turing machine M M M .
A SNARG system for M M M consists of polynomial-time algorithms (SNARG.Gen, SNARG.P \mathcal{P} P , SNARG.V \mathcal{V} V ) with the following syntax:
SNARG.Gen(1 λ 1^{\lambda} 1 λ , n n n ) ⟶ \longrightarrow ⟶ crs. The randomized setup algorithm outputs a common reference string crs.
SNARG.P \mathcal{P} P (crs, x x x , w w w ) ⟶ \longrightarrow ⟶ π \pi π . The prover is given the crs, an input x ∈ { 0 , 1 } n x \in\{0,1\}^{n} x ∈ { 0 , 1 } n , and non-deterministic choices w w w specifying an accepting execution of M M M on x x x . It outputs a proof π \pi π .
SNARG.V \mathcal{V} V (crs, x x x , π \pi π ) ⟶ \longrightarrow ⟶ 0/1. The verifier is given the crs, the input x x x , and the proof π \pi π . It outputs a bit indicating whether it accepts.
Definition 9. A triple of algorithms (SNARG.Gen, SNARG.P \mathcal{P} P , SNARG.V \mathcal{V} V ) is a SNARG system for a Turing machine M M M if the following hold:
Completeness. For every λ , n ∈ N \lambda, n \in\mathbb{N} λ , n ∈ N and every x ∈ { 0 , 1 } n x \in\{0,1\}^{n} x ∈ { 0 , 1 } n and w ∈ { 0 , 1 } m w \in\{0,1\}^{m} w ∈ { 0 , 1 } m such that M ( x , w ) = 1 M(x,w)=1 M ( x , w ) = 1 ,
Pr [ S N A R G . V ( c r s , x , π ) = 1 c r s ← S N A R G . G e n ( 1 λ , n ) , π ← S N A R G . P ( c r s , x , w ) ] = 1. \Pr\left[
\begin{array}{c|c}
\mathrm{SNARG}.\mathcal{V}(\mathrm{crs},x,\pi)=1 & \begin{array}{l}
\mathrm{crs} \leftarrow\mathrm{SNARG}.\mathrm{Gen}(1^{\lambda},n),\\
\pi\leftarrow\mathrm{SNARG}.\mathcal{P}(\mathrm{crs},x,w)
\end{array}
\end{array}
\right] = 1. Pr [ SNARG . V ( crs , x , π ) = 1 crs ← SNARG . Gen ( 1 λ , n ) , π ← SNARG . P ( crs , x , w ) ] = 1. Adaptive Soundness. For every poly-size adversary Adv, there is a negligible function μ \mu μ such that
Pr [ x ∈ { 0 , 1 } n ∖ L M ∧ S N A R G . V ( c r s , x , π ∗ ) = 1 c r s ← S N A R G . G e n ( 1 λ , n ) , ( x , π ∗ ) ← A d v ( c r s ) ] ≤ μ ( λ ) . \Pr\left[
\begin{array}{c|c}
x \in\{0,1\}^{n} \setminus L_M \land\mathrm{SNARG}.\mathcal{V}(\mathrm{crs},x,\pi^*)=1 & \begin{array}{l}
\mathrm{crs} \leftarrow\mathrm{SNARG}.\mathrm{Gen}(1^{\lambda},n),\\
(x,\pi^*) \leftarrow\mathrm{Adv}(\mathrm{crs})
\end{array}
\end{array}
\right] \leq\mu(\lambda). Pr [ x ∈ { 0 , 1 } n ∖ L M ∧ SNARG . V ( crs , x , π ∗ ) = 1 crs ← SNARG . Gen ( 1 λ , n ) , ( x , π ∗ ) ← Adv ( crs ) ] ≤ μ ( λ ) . Efficiency. The prover runs in time polynomial in the security parameter and the length of the execution. We explicitly specify the lengths of the crs and proof π \pi π , as well as the verifier’s running time. We say that a SNARG is fully succinct if the length of the crs and the proof π \pi π is poly ( λ , log T ) \operatorname{poly}(\lambda,\log T) poly ( λ , log T ) , and the runtime of the verifier is n ⋅ poly ( λ , log T ) n \cdot\operatorname{poly}(\lambda,\log T) n ⋅ poly ( λ , log T ) .
Somewhere Extractable Batch Arguments (seBARGs)
A batch argument system (BARG) for an NP language L L L allows proving that k k k NP statements are true with communication cost polylogarithmic in k k k . BARG and their applications to succinct non-interactive arguments have been studied in [6 , 15 , 14 ] . In this work, we use the somewhere-extractable variant of BARGs for “batch index Turing machine SAT” (BatchIndexTMSAT), defined below.
Definition 10. [1 ] The language BatchIndexTMSAT consists of instances of the form x = ( M , z , k , T ) x=(M,z,k,T) x = ( M , z , k , T ) , where:
M M M is the description of a deterministic Turing machine that takes as input ( z , i , w ) (z,i,w) ( z , i , w ) , where w w w is a witness.
z z z is an input string.
An instance x = ( M , z , k , T ) x=(M,z,k,T) x = ( M , z , k , T ) is in BatchIndexTMSAT if for every i ∈ [ k ] i\in[k] i ∈ [ k ] there exists a witness w i w_i w i such that M ( z , i , w i ) M(z,i,w_i) M ( z , i , w i ) accepts within T T T steps.
For an instance x = ( M , z , k , T ) x=(M,z,k,T) x = ( M , z , k , T ) , we write R ( x , i , w ) = 1 R(x,i,w)=1 R ( x , i , w ) = 1 if and only if i ∈ [ k ] i\in[k] i ∈ [ k ] and M ( z , i , w ) M(z,i,w) M ( z , i , w ) accepts within T T T steps.
Syntax. A (publicly verifiable and non-interactive) somewhere extractable batch argument system seBARG for BatchIndexTMSAT consists of the following polynomial time algorithms:
Gen ( 1 λ , n , 1 m , k , i ∗ ) → ( c r s , t d ) \operatorname{Gen}(1^\lambda,n,1^m,k,i^*)\to(\mathrm{crs},\mathrm{td}) Gen ( 1 λ , n , 1 m , k , i ∗ ) → ( crs , td ) . This is a probabilistic polynomial-time algorithm that takes as input a security parameter 1 λ 1^\lambda 1 λ , input length n n n , witness length 1 m 1^m 1 m , a parameter k k k , and an index i ∗ ∈ [ k ] i^*\in[k] i ∗ ∈ [ k ] . It outputs a common reference string c r s \mathrm{crs} crs along with a trapdoor t d \mathrm{td} td .
P ( c r s , M , z , 1 T , w 1 , … , w k ) → π \mathcal{P}(\mathrm{crs},M,z,1^T,w_1,\ldots,w_k)\to\pi P ( crs , M , z , 1 T , w 1 , … , w k ) → π . This deterministic polynomial-time algorithm takes as input a c r s \mathrm{crs} crs , Turing machine M M M , input z z z , runtime 1 T 1^T 1 T , and k k k witnesses w 1 , … , w k w_1,\ldots,w_k w 1 , … , w k . It outputs a proof π \pi π .
V ( c r s , x , π ) → 0 / 1 \mathcal{V}(\mathrm{crs},x,\pi)\to0/1 V ( crs , x , π ) → 0/1 . This deterministic polynomial-time algorithm takes as input a c r s \mathrm{crs} crs , instance x = ( M , z , k , T ) x=(M,z,k,T) x = ( M , z , k , T ) , and a proof π \pi π . It outputs a bit (1 to accept, 0 to reject).
Extract ( t d , π ) → w ∗ \operatorname{Extract}(\mathrm{td},\pi)\to w^* Extract ( td , π ) → w ∗ . This deterministic polynomial-time algorithm takes as input a trapdoor t d \mathrm{td} td and a proof π \pi π . It outputs a single witness w ∗ w^* w ∗ .
Definition 11 (seBARG). A somewhere-extractable batch argument system seBARG = ( Gen , P , V , Extract ) =(\operatorname{Gen},\mathcal{P},\mathcal{V},\operatorname{Extract}) = ( Gen , P , V , Extract ) for BatchIndexTMSAT is required to satisfy the following properties:
Completeness. For any λ ∈ N \lambda\in\mathbb{N} λ ∈ N , any k ( λ ) , n ( λ ) , m ( λ ) , T ( λ ) ≤ 2 λ k(\lambda),n(\lambda),m(\lambda),T(\lambda)\le2^\lambda k ( λ ) , n ( λ ) , m ( λ ) , T ( λ ) ≤ 2 λ , any instance x = ( M , z , k , T ) ∈ x=(M,z,k,T)\in x = ( M , z , k , T ) ∈ BatchIndexTMSAT with ∣ M ∣ + ∣ z ∣ = n |M|+|z|=n ∣ M ∣ + ∣ z ∣ = n , any corresponding witnesses w 1 , … , w k ∈ { 0 , 1 } m w_1,\ldots,w_k\in\{0,1\}^m w 1 , … , w k ∈ { 0 , 1 } m and any index i ∗ ∈ [ k ] i^*\in[k] i ∗ ∈ [ k ] ,
Pr [ V ( c r s , x , π ) = 1 : ( c r s , t d ) ← Gen ( 1 λ , n , 1 m , k , i ∗ ) , π ← P ( c r s , M , z , 1 T , w 1 , … , w k ) ] = 1. \Pr\left[
\begin{array}{c}
\mathcal{V}(\mathrm{crs},x,\pi)=1:\quad(\mathrm{crs},\mathrm{td})\leftarrow\operatorname{Gen}(1^\lambda,n,1^m,k,i^*),\\
\pi\leftarrow\mathcal{P}(\mathrm{crs},M,z,1^T,w_1,\ldots,w_k)
\end{array}
\right]=1. Pr [ V ( crs , x , π ) = 1 : ( crs , td ) ← Gen ( 1 λ , n , 1 m , k , i ∗ ) , π ← P ( crs , M , z , 1 T , w 1 , … , w k ) ] = 1. Efficiency. In the completeness experiment above,
∣ c r s ∣ + ∣ t d ∣ + ∣ π ∣ ≤ m ⋅ poly ( λ ) . |\mathrm{crs}|+|\mathrm{td}|+|\pi|\le m\cdot\operatorname{poly}(\lambda). ∣ crs ∣ + ∣ td ∣ + ∣ π ∣ ≤ m ⋅ poly ( λ ) . The running time of the verifier is at most
poly ( ∣ c r s ∣ + ∣ π ∣ ) + n ⋅ poly ( λ ) . \operatorname{poly}(|\mathrm{crs}|+|\pi|)+n\cdot\operatorname{poly}(\lambda). poly ( ∣ crs ∣ + ∣ π ∣ ) + n ⋅ poly ( λ ) . Extraction completeness. For every λ ∈ N \lambda\in\mathbb{N} λ ∈ N , every k , n , m , T ≤ 2 λ k,n,m,T\le2^\lambda k , n , m , T ≤ 2 λ , every instance x = ( M , z , k , T ) ∈ x=(M,z,k,T)\in x = ( M , z , k , T ) ∈ BatchIndexTMSAT with ∣ M ∣ + ∣ z ∣ = n |M|+|z|=n ∣ M ∣ + ∣ z ∣ = n , every corresponding witnesses w 1 , … , w k ∈ { 0 , 1 } m w_1,\ldots,w_k\in\{0,1\}^m w 1 , … , w k ∈ { 0 , 1 } m , and every index i ∗ ∈ [ k ] i^*\in[k] i ∗ ∈ [ k ] ,
Pr [ ( x , i ∗ , w ∗ ) ∈ R : ( c r s , t d ) ← Gen ( 1 λ , n , 1 m , k , i ∗ ) , π ← P ( c r s , M , z , 1 T , w 1 , … , w k ) , w ∗ ← Extract ( t d , π ) ] ≥ 1 − negl ( λ ) . \Pr\left[
\begin{array}{c}
(x,i^*,w^*)\in R:\quad(\mathrm{crs},\mathrm{td})\leftarrow\operatorname{Gen}(1^\lambda,n,1^m,k,i^*),\\
\pi\leftarrow\mathcal{P}(\mathrm{crs},M,z,1^T,w_1,\ldots,w_k),\\
w^*\leftarrow\operatorname{Extract}(\mathrm{td},\pi)
\end{array}
\right]\ge1-\operatorname{negl}(\lambda). Pr ( x , i ∗ , w ∗ ) ∈ R : ( crs , td ) ← Gen ( 1 λ , n , 1 m , k , i ∗ ) , π ← P ( crs , M , z , 1 T , w 1 , … , w k ) , w ∗ ← Extract ( td , π ) ≥ 1 − negl ( λ ) .
Index hiding. For any poly-size adversary A \mathcal{A} A and any polynomials k ( λ ) , n ( λ ) , m ( λ ) k(\lambda), n(\lambda), m(\lambda) k ( λ ) , n ( λ ) , m ( λ ) , there exists a negligible function negl ( ⋅ ) \operatorname{negl}(\cdot) negl ( ⋅ ) such that for every λ ∈ N \lambda\in\mathbb{N} λ ∈ N and every pair of indices i 0 , i 1 ∈ [ k ] i_0,i_1 \in[k] i 0 , i 1 ∈ [ k ] ,
Pr [ A ( c r s ) = b b ← { 0 , 1 } , ( c r s , t d ) ← Gen ( 1 λ , n , 1 m , k , i b ) ] ≤ 1 2 + negl ( λ ) . \Pr\left[
\begin{array}{c|c}
\mathcal{A}(\mathrm{crs})=b & b \gets\{0,1\},\\
&(\mathrm{crs},\mathrm{td}) \gets\operatorname{Gen}(1^\lambda,n,1^m,k,i_b)
\end{array}
\right]\leq\frac{1}{2}+\operatorname{negl}(\lambda). Pr [ A ( crs ) = b b ← { 0 , 1 } , ( crs , td ) ← Gen ( 1 λ , n , 1 m , k , i b ) ] ≤ 2 1 + negl ( λ ) .
Somewhere argument of knowledge. For any poly-size adversary A \mathcal{A} A and any polynomials k ( λ ) , n ( λ ) , m ( λ ) , T ( λ ) k(\lambda), n(\lambda), m(\lambda), T(\lambda) k ( λ ) , n ( λ ) , m ( λ ) , T ( λ ) there exists a negligible function negl ( ⋅ ) \operatorname{negl}(\cdot) negl ( ⋅ ) such that for any index i ∗ ∈ [ k ] i^* \in[k] i ∗ ∈ [ k ] and for every λ ∈ N \lambda\in\mathbb{N} λ ∈ N ,
Pr [ V ( c r s , x , π ) = 1 ( c r s , t d ) ← Gen ( 1 λ , n , 1 m , k , i ∗ ) ∧ ( x , i ∗ , w ∗ ) ∉ R ( M , z , π ) = A ( c r s ) ∧ ∣ M ∣ + ∣ z ∣ = n w ∗ ← Extract ( t d , π ) ] ≤ negl ( λ ) . \Pr\left[
\begin{array}{c|c}
\mathcal{V}(\mathrm{crs},x,\pi)=1 & (\mathrm{crs},\mathrm{td})\gets\operatorname{Gen}(1^\lambda,n,1^m,k,i^*)\\
\land\ (x,i^*,w^*)\notin R & (M,z,\pi)=\mathcal{A}(\mathrm{crs})\\
\land\ |M|+|z|=n & w^*\gets\operatorname{Extract}(\mathrm{td},\pi)
\end{array}
\right]\leq\operatorname{negl}(\lambda). Pr V ( crs , x , π ) = 1 ∧ ( x , i ∗ , w ∗ ) ∈ / R ∧ ∣ M ∣ + ∣ z ∣ = n ( crs , td ) ← Gen ( 1 λ , n , 1 m , k , i ∗ ) ( M , z , π ) = A ( crs ) w ∗ ← Extract ( td , π ) ≤ negl ( λ ) .
where above x = ( M , z , k , T ) x=(M,z,k,T) x = ( M , z , k , T ) .
Remark 12. We say that a seBARG scheme is T ∗ T^* T ∗ -secure, for T ∗ = T ∗ ( λ ) T^*=T^*(\lambda) T ∗ = T ∗ ( λ ) , if the index hiding property and the somewhere argument of knowledge property hold w.r.t. a poly ( T ∗ ) \operatorname{poly}(T^*) poly ( T ∗ ) -size adversary (as opposed to a poly ( λ ) \operatorname{poly}(\lambda) poly ( λ ) -size), and the advantage probability is negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) (as opposed to negl ( λ ) \operatorname{negl}(\lambda) negl ( λ ) ). In addition, the index hiding property and the somewhere argument of knowledge property are required to hold even if the parameters k ( λ ) , n ( λ ) , m ( λ ) , T ( λ ) k(\lambda), n(\lambda), m(\lambda), T(\lambda) k ( λ ) , n ( λ ) , m ( λ ) , T ( λ ) are polynomial in T ∗ ( λ ) T^*(\lambda) T ∗ ( λ ) . We refer to these properties as T ∗ T^* T ∗ -index-hiding and T ∗ T^* T ∗ -somewhere-argument-of-knowledge, respectively.
Throughout this paper, when we refer to a BARG or seBARG, we will implicitly mean a seBARG for BatchIndexTMSAT.
Remark 13. Given an seBARG, one can naturally extend the definition of the key generation algorithm Gen \operatorname{Gen} Gen to take as input a vector I = ( i 1 , … , i ℓ ) I=(i_1,\ldots,i_\ell) I = ( i 1 , … , i ℓ ) where each i j ∈ [ k ] i_j\in[k] i j ∈ [ k ] , as opposed to a single index. Gen ( 1 λ , n , 1 m , k , I ) \operatorname{Gen}(1^\lambda,n,1^m,k,I) Gen ( 1 λ , n , 1 m , k , I ) will simply run Gen ( 1 λ , n , 1 m , k , i j ) \operatorname{Gen}(1^\lambda,n,1^m,k,i_j) Gen ( 1 λ , n , 1 m , k , i j ) for every j ∈ [ ℓ ] j\in[\ell] j ∈ [ ℓ ] . The prover algorithm P \mathcal{P} P , given a crs that encodes the ∣ I ∣ |I| ∣ I ∣ indices, will simply generate ∣ I ∣ |I| ∣ I ∣ proofs (one for each crs), and the verifier will check these ∣ I ∣ |I| ∣ I ∣ proofs independently. In this situation, the seBARG trapdoor t d = ( t d 1 , … , t d ∣ I ∣ ) \mathrm{td}=(\mathrm{td}_1,\ldots,\mathrm{td}_{|I|}) td = ( td 1 , … , td ∣ I ∣ ) is written in ∣ I ∣ |I| ∣ I ∣ components, and the scheme inherits a strong form of index hiding: given seBARG.crs, the j j j th index i j i_j i j remains hidden even given all ∣ I ∣ − 1 |I|-1 ∣ I ∣ − 1 other trapdoors ( t d j ′ ) j ′ ∈ [ ℓ ] ∖ { j } (\mathrm{td}_{j'})_{j'\in[\ell]\setminus\{j\}} ( td j ′ ) j ′ ∈ [ ℓ ] ∖ { j } .
Theorem 14 ([6 , 22 , 11 , 14 ] ). There exists an seBARG for BatchIndexTMSAT assuming LWE or DLIN or (subexponential DDH and QR).
Oracle-Aided Turing Machines
An oracle-aided Turing machine M M M is a Turing machine equipped with an oracle query tape and an oracle answer tape. Upon entering a designated query state, the contents u u u of the query tape are sent to an oracle O \mathcal{O} O , and the contents of the answer tape are replaced by O ( u ) \mathcal{O}(u) O ( u ) . Queries may be adaptive. Namely, the query made at a particular step may depend on the answers to previous queries.
We allow M M M to be non-deterministic. We write M O ( x , w ) M^{\mathcal{O}}(x,w) M O ( x , w ) for the outcome of its execution on input x x x , where w w w specifies its non-deterministic choices, and define
L M O = { x : ∃ w such that M O ( x , w ) = 1 } . L_M^{\mathcal{O}}=\{x:\exists w\text{ such that }M^{\mathcal{O}}(x,w)=1\}. L M O = { x : ∃ w such that M O ( x , w ) = 1 } .
The deterministic setting is the special case in which there are no non-deterministic choices.
Definition of Privately-Verifiable SNARG s for Robust Oracle-Aided Computations
Complexity measures. We consider machines with time bound T = T ( n ) T = T(n) T = T ( n ) ,6 space bound S = S ( n ) S = S(n) S = S ( n ) , and oracle-query bound Q = Q ( n ) ≤ T ( n ) Q = Q(n) \le T(n) Q = Q ( n ) ≤ T ( n ) on inputs of length n n n . The space bound includes the work tapes and the oracle query and answer tapes, but not the read-only input tape. In particular, the lengths of queries and answers are at most S S S . An oracle call counts as one step; writing a query and subsequently processing its answer are charged in the usual way.
A configuration specifies the machine’s state, tape contents, and head positions. It does not include the input tape. The non-deterministic choices are made as the computation proceeds; we do not assume that a long, random-access witness is available outside the space bound.
Definition 16 (Purported execution). A purported execution of M O M^{O} M O on input x x x is a sequence of configurations
τ = ( C 0 , … , C T ) \tau= (C_0, \ldots, C_T) τ = ( C 0 , … , C T ) that starts in the prescribed initial configuration and respects all ordinary transition rules. At an oracle step, however, the execution may use any answer of the prescribed length. In particular, we do not require that two occurrences of the same query receive the same answer. The transcript records the answer used at each oracle step, through its configurations. We say that τ \tau τ is accepting if C T C_T C T is accepting.
Let q ( τ ) q(\tau) q ( τ ) be the number of oracle calls in τ \tau τ , and let ( u 1 , a 1 ) , … , ( u q ( τ ) , a q ( τ ) ) (u_1,a_1),\ldots,(u_{q(\tau)},a_{q(\tau)}) ( u 1 , a 1 ) , … , ( u q ( τ ) , a q ( τ ) ) be its query-answer pairs, in their order of occurrence. Define
err O ( τ ) = ∣ { j ∈ [ q ( τ ) ] : a j ≠ O ( u j ) } ∣ . \operatorname{err}_{O}(\tau) = \lvert\{j \in[q(\tau)] : a_j \ne O(u_j)\}\rvert. err O ( τ ) = ∣{ j ∈ [ q ( τ )] : a j = O ( u j )}∣ . Notice that queries are evaluated along the purported execution itself, not along an honest execution with a different sequence of answers.
Definition 17 (Robust oracle-aided computation). Let ε ∈ ( 0 , 1 ] \varepsilon\in(0,1] ε ∈ ( 0 , 1 ] . We say that M O M^{O} M O is ε \varepsilon ε -robust on input x x x if either x ∈ L M O x \in L_{M}^{O} x ∈ L M O , or every accepting purported execution τ \tau τ of M M M on x x x satisfies
err O ( τ ) ≥ ε q ( τ ) . \operatorname{err}_{O}(\tau) \ge\varepsilon q(\tau). err O ( τ ) ≥ εq ( τ ) . This is a one-sided notion: changing a rejecting instance into an accepting execution requires an ε \varepsilon ε -fraction of incorrect oracle answers. The quantification is over every accepting purported execution, including every sequence of non-deterministic choices. The fraction is measured among oracle calls, and not among all T T T computation steps. An accepting purported execution with no oracle calls is already a real accepting execution, and hence cannot exist for a no-instance.
Our soundness guarantees have an input-wise formulation: a verifier accepts a false statement only with negligible probability when the chosen input satisfies the robustness condition. They do not require the verifier to determine whether that condition holds.
Definition of Privately-Verifiable SNARGs for Robust Oracle-Aided Computations
We extend the definition of a SNARG to oracle-aided computations with private verification. Fix an oracle-aided machine M M M and parameters ( n , T , S , Q , ε ) (n,T,S,Q,\varepsilon) ( n , T , S , Q , ε ) as above. A SNARG for oracle-aided computations consists of algorithms SNARG.Gen, SNARG.P \mathcal{P} P , and SNARG.V \mathcal{V} V with the following syntax.
SNARG.Gen( 1 λ , n , ε ) ⟶ ( c r s , t d ) (1^{\lambda},n,\varepsilon) \longrightarrow(\mathrm{crs},\mathrm{td}) ( 1 λ , n , ε ) ⟶ ( crs , td ) . The randomized setup algorithm outputs a common reference string c r s \mathrm{crs} crs and a private verification key t d \mathrm{td} td . SNARG.Gen does not query the oracle.
SNARG.P O ( c r s , x , w ) ⟶ π \mathcal{P}^{O}(\mathrm{crs},x,w) \longrightarrow\pi P O ( crs , x , w ) ⟶ π . The prover is given the c r s \mathrm{crs} crs , an input x ∈ { 0 , 1 } n x \in\{0,1\}^{n} x ∈ { 0 , 1 } n , and non-deterministic choices w w w specifying an accepting execution of M O M^{O} M O on x x x . It has oracle access to O O O and outputs a proof π \pi π .
SNARG.V O ( c r s , t d , x , π ) ⟶ 0 / 1 \mathcal{V}^{O}(\mathrm{crs},\mathrm{td},x,\pi) \longrightarrow0/1 V O ( crs , td , x , π ) ⟶ 0/1 . The verifier is given the c r s \mathrm{crs} crs , the private verification key t d \mathrm{td} td , the input x x x , and the proof π \pi π . It has oracle access to O O O and outputs a bit indicating whether it accepts.
Definition 18 (Privately verifiable oracle-aided SNARG). A system as above is a privately verifiable SNARG for ε \varepsilon ε -robust oracle-aided computation M M M if the following properties hold for every oracle O O O fixed independently of setup.
Completeness. For every x ∈ { 0 , 1 } n x \in\{0,1\}^{n} x ∈ { 0 , 1 } n and every w w w such that M O ( x , w ) = 1 M^{O}(x,w)=1 M O ( x , w ) = 1 ,
Pr [ S N A R G . V O ( c r s , t d , x , π ) = 1 | ( c r s , t d ) ← S N A R G . G e n ( 1 λ , n , ε ) , π ← S N A R G . P O ( c r s , x , w ) ] ≥ 1 − negl ( λ ) . \Pr\left[
\mathrm{SNARG}.\mathcal{V}^{O}(\mathrm{crs},\mathrm{td},x,\pi)=1
\ \middle|\
\begin{aligned}
(\mathrm{crs},\mathrm{td}) &\leftarrow\mathrm{SNARG.Gen}(1^{\lambda},n,\varepsilon),\\
\pi&\leftarrow\mathrm{SNARG}.\mathcal{P}^{O}(\mathrm{crs},x,w)
\end{aligned}
\right]\ge1-\operatorname{negl}(\lambda). Pr [ SNARG . V O ( crs , td , x , π ) = 1 ( crs , td ) π ← SNARG.Gen ( 1 λ , n , ε ) , ← SNARG . P O ( crs , x , w ) ] ≥ 1 − negl ( λ ) . We also require adaptive completeness: the probability of rejecting an accepting execution remains negligible when ( x , w ) (x,w) ( x , w ) is chosen by a polynomial-size oracle algorithm after seeing c r s \mathrm{crs} crs .
Adaptive soundness. For every polynomial-size oracle adversary A d v \mathrm{Adv} Adv , there exists a negligible function μ \mu μ such that
Pr [ x ∈ { 0 , 1 } n ∖ L M O , M O is ε -robust on x , S N A R G . V O ( c r s , t d , x , π ∗ ) = 1 | ( c r s , t d ) ← S N A R G . G e n ( 1 λ , n , ε ) , ( x , π ∗ ) ← A d v O ( c r s ) ] ≤ μ ( λ ) . \Pr\left[
\begin{aligned}
x &\in\{0,1\}^{n}\setminus L_{M}^{O},\\
M^{O}\text{ is }\varepsilon\text{-robust on }x,\\
\mathrm{SNARG}.\mathcal{V}^{O}(\mathrm{crs},\mathrm{td},x,\pi^{*})&=1
\end{aligned}
\ \middle|\
\begin{aligned}
(\mathrm{crs},\mathrm{td}) &\leftarrow\mathrm{SNARG.Gen}(1^{\lambda},n,\varepsilon),\\
(x,\pi^{*}) &\leftarrow\mathrm{Adv}^{O}(\mathrm{crs})
\end{aligned}
\right]\le\mu(\lambda). Pr x M O is ε -robust on x , SNARG . V O ( crs , td , x , π ∗ ) ∈ { 0 , 1 } n ∖ L M O , = 1 ( crs , td ) ( x , π ∗ ) ← SNARG.Gen ( 1 λ , n , ε ) , ← Adv O ( crs ) ≤ μ ( λ ) . Efficiency. The prover runs in time poly ( λ , T , 1 / ε ) \operatorname{poly}(\lambda,T,1/\varepsilon) poly ( λ , T , 1/ ε ) . For the space-dependent SNARGs constructed in this paper, the lengths of c r s \mathrm{crs} crs , the private verification key t d \mathrm{td} td , and the proof π \pi π are bounded by poly ( λ , S , log T , 1 / ε ) \operatorname{poly}(\lambda,S,\log T,1/\varepsilon) poly ( λ , S , log T , 1/ ε ) . The verifier runs in time n ⋅ poly ( λ , S , log T , 1 / ε ) n\cdot\operatorname{poly}(\lambda,S,\log T,1/\varepsilon) n ⋅ poly ( λ , S , log T , 1/ ε ) and makes O ( λ / ε ) O(\lambda/\varepsilon) O ( λ / ε ) oracle calls. We say that a SNARG is fully succinct if it achieves these efficiency guarantees without the dependence on S S S .
Remark 19. Note that if we restrict t d = ⊥ \mathrm{td}=\bot td = ⊥ then Theorem 18 becomes a publicly verifiable SNARG for an oracle-aided computation.
In this section, we construct a privately-verifiable SNARG for robust oracle-aided computations. The idea is to hash the entire computation transcript, including the oracle answers, and use a seBARG to prove consistency of its local transitions. The verifier uses its trapdoor to extract a few query-answer pairs and checks them against the oracle.
Theorem 20. Let M M M be a non-deterministic oracle-aided machine with time bound T T T and space bound S S S . Assume that M M M always makes exactly Q ≤ T Q \le T Q ≤ T oracle queries. There exists a privately verifiable SNARG for ε \varepsilon ε -robust computations of M M M , with adaptive soundness assuming the LWE problem is sub-exponentially hard even given oracle access. Its public parameters, private verification key, and proof have length
poly ( λ , S , log T , 1 / ε ) . \operatorname{poly}(\lambda, S, \log T, 1/\varepsilon). poly ( λ , S , log T , 1/ ε ) . The verifier runs in time n ⋅ poly ( λ , S , log T , 1 / ε ) n \cdot\operatorname{poly}(\lambda, S, \log T, 1/\varepsilon) n ⋅ poly ( λ , S , log T , 1/ ε ) and makes O ( λ / ε ) O(\lambda/\varepsilon) O ( λ / ε ) oracle calls.
In what follows we fix an oracle O O O independently of the setup. Let M M M be an oracle-aided machine with time bound T T T and space bound S S S , such that every purported execution on an n n n -bit input makes exactly Q = Q ( n ) ≥ 1 Q = Q(n) \ge1 Q = Q ( n ) ≥ 1 oracle calls. We assume that LWE is sub-exponentially hard against non-uniform adversaries with access to O O O .
Our construction uses the hash family from § 4.1 and the seBARG from § 4.4 with succinct extraction, instantiated with T ∗ T^* T ∗ -security, where
T ∗ = 2 O ( S ) poly ( T , λ , 1 / ε ) . T^* = 2^{O(S)}\operatorname{poly}(T,\lambda,1/\varepsilon). T ∗ = 2 O ( S ) poly ( T , λ , 1/ ε ) .
Thus, the underlying security parameter of the hash family and the seBARG, which we denote by κ \kappa κ , can be chosen as a sufficiently large polynomial in λ \lambda λ , S S S , log ( T ) \log(T) log ( T ) , log ( 1 / ε ) \log(1/\varepsilon) log ( 1/ ε ) , by relying on the hardness of LWE against sub-exponential size adversaries with access to O O O .
The Construction
Let M M M be a non-deterministic Turing machine running in time T T T and space S S S . In what follows we construct a privately-verifiable SNARG for M O M^O M O , for an arbitrary oracle O O O . Our construction makes use of the following ingredients:
H T = ( H T . G e n , H T . H a s h , H T . O p e n , H T . V e r i f y ) . \mathrm{HT} = (\mathrm{HT.Gen},\mathrm{HT.Hash},\mathrm{HT.Open},\mathrm{HT.Verify}). HT = ( HT.Gen , HT.Hash , HT.Open , HT.Verify ) .
s e B A R G = ( s e B A R G . G e n , s e B A R G . P , s e B A R G . V , s e B A R G . E x t r a c t ) . \mathrm{seBARG} = (\mathrm{seBARG.Gen},\mathrm{seBARG.P},\mathrm{seBARG.V},\mathrm{seBARG.Extract}). seBARG = ( seBARG.Gen , seBARG.P , seBARG.V , seBARG.Extract ) .
We next describe our SNARG construction for the computation M O M^O M O .
SNARG.Gen: This algorithm takes as input ( 1 λ , n , ε ) (1^\lambda,n,\varepsilon) ( 1 λ , n , ε ) , and does the following:
Generate h k ← H T . G e n ( 1 κ ) \mathrm{hk} \leftarrow\mathrm{HT.Gen}(1^\kappa) hk ← HT.Gen ( 1 κ ) , where κ = poly ( λ , S , log T , log ⌈ 1 / ε ⌉ ) \kappa= \operatorname{poly}(\lambda,S,\log T,\log\lceil1/\varepsilon\rceil) κ = poly ( λ , S , log T , log ⌈ 1/ ε ⌉) .
Let r = ⌊ λ / ε ⌋ r = \lfloor\lambda/\varepsilon\rfloor r = ⌊ λ / ε ⌋ , and sample independently at random j 1 , … , j r ← [ Q ] j_1,\ldots,j_r \leftarrow[Q] j 1 , … , j r ← [ Q ] , and let J = ( j 1 , … , j r ) J = (j_1,\ldots,j_r) J = ( j 1 , … , j r ) .
Generate
( c r s s e B A R G , t d s e B A R G ) ← s e B A R G . G e n ( 1 κ , n l o c , 1 m , k , ( T + j ) j ∈ J ) , (\mathrm{crs}_{\mathrm{seBARG}},\mathrm{td}_{\mathrm{seBARG}}) \leftarrow\mathrm{seBARG}.\mathrm{Gen}(1^\kappa,n_{\mathrm{loc}},1^m,k,(T+j)_{j\in J}), ( crs seBARG , td seBARG ) ← seBARG . Gen ( 1 κ , n loc , 1 m , k , ( T + j ) j ∈ J ) ,
where k = T + Q k = T + Q k = T + Q and where n l o c n_{\mathrm{loc}} n loc and m m m are defined in Step 5 of S N A R G . P \mathrm{SNARG}.\mathcal{P} SNARG . P below.7
Let c r s = ( h k , c r s s e B A R G ) \mathrm{crs} = (\mathrm{hk},\mathrm{crs}_{\mathrm{seBARG}}) crs = ( hk , crs seBARG ) and t d = ( J , t d s e B A R G ) \mathrm{td} = (J,\mathrm{td}_{\mathrm{seBARG}}) td = ( J , td seBARG ) .
Output ( c r s , t d ) (\mathrm{crs},\mathrm{td}) ( crs , td ) .
SNARG.P \mathcal{P} P : This algorithm takes as input ( c r s , x , w ) (\mathrm{crs},x,w) ( crs , x , w ) , and does the following:
Run the accepting execution of M O ( x , w ) M^{\mathcal{O}}(x,w) M O ( x , w ) . Let C 0 , … , C T C_0,\ldots,C_T C 0 , … , C T be the configurations of this execution, and let t j t_j t j be the step at which its j j j th oracle call occurs. Define
D j = ( t j , u j , a j ) , j ∈ [ Q ] , D_j = (t_j,u_j,a_j), \qquad j\in[Q], D j = ( t j , u j , a j ) , j ∈ [ Q ] ,
where u j u_j u j is the query and a j a_j a j is the answer used at that step.
Let τ = ( C 0 , … , C T , D 1 , … , D Q ) \tau= (C_0,\ldots,C_T,D_1,\ldots,D_Q) τ = ( C 0 , … , C T , D 1 , … , D Q ) , and compute
r t = H T . H a s h ( h k , τ ) . \mathrm{rt} = \mathrm{HT.Hash}(\mathrm{hk},\tau). rt = HT.Hash ( hk , τ ) .
Remark 21. We use fixed-length encodings of configurations and oracle-table entries , so that their positions in the encoded transcript are publicly determined .
Define z = ( h k , x , r t ) z = (\mathrm{hk},x,\mathrm{rt}) z = ( hk , x , rt ) .
Define the oracle-free NP relation R l o c R_{\mathrm{loc}} R loc where ( z , i , w i ) ∈ R l o c (z,i,w_i)\in R_{\mathrm{loc}} ( z , i , w i ) ∈ R loc if and only if the following holds:
– If i ∈ [ T ] i\in[T] i ∈ [ T ] and the i i i th step is not an oracle step, then w i = ( C i − 1 , C i , ρ ) w_i = (C_{i-1},C_i,\rho) w i = ( C i − 1 , C i , ρ ) such that the following holds:
(a) V e r i f y ( h k , r t , I , ( C i − 1 , C i ) , ρ ) = 1 \mathrm{Verify}(\mathrm{hk},\mathrm{rt},I,(C_{i-1},C_i),\rho)=1 Verify ( hk , rt , I , ( C i − 1 , C i ) , ρ ) = 1 , where I I I are the coordinates in τ \tau τ corresponding to ( C i − 1 , C i ) (C_{i-1},C_i) ( C i − 1 , C i ) .
(b) ( C i − 1 , C i ) (C_{i-1},C_i) ( C i − 1 , C i ) is a valid machine transition and the configurations C i − 1 C_{i-1} C i − 1 and C i C_i C i have the same oracle counter; i.e., query ( C i − 1 ) = query ( C i ) \operatorname{query}(C_{i-1})=\operatorname{query}(C_i) query ( C i − 1 ) = query ( C i ) .
(c) If i = 1 i=1 i = 1 , C 0 C_0 C 0 is the initial configuration and query ( C 0 ) = 0 \operatorname{query}(C_0)=0 query ( C 0 ) = 0 , and if i = T i=T i = T then C T C_T C T is an accepting configuration.
– If i ∈ [ T ] i\in[T] i ∈ [ T ] and the i i i th step is an oracle step, say the j j j th oracle step, then w i = ( C i − 1 , C i , D j , ρ ) w_i = (C_{i-1},C_i,D_j,\rho) w i = ( C i − 1 , C i , D j , ρ ) such that the following holds:
(a) V e r i f y ( h k , r t , I , ( C i − 1 , C i , D j ) , ρ ) = 1 \mathrm{Verify}(\mathrm{hk},\mathrm{rt},I,(C_{i-1},C_i,D_j),\rho)=1 Verify ( hk , rt , I , ( C i − 1 , C i , D j ) , ρ ) = 1 , where I I I are the coordinates in τ \tau τ corresponding to ( C i − 1 , C i , D j ) (C_{i-1},C_i,D_j) ( C i − 1 , C i , D j ) .
(b) ( C i − 1 , C i ) (C_{i-1},C_i) ( C i − 1 , C i ) is a valid machine transition, and
j = query ( C i ) = query ( C i − 1 ) + 1 ∈ [ Q ] . j = \operatorname{query}(C_i) = \operatorname{query}(C_{i-1}) + 1 \in[Q]. j = query ( C i ) = query ( C i − 1 ) + 1 ∈ [ Q ] .
(c) D j = ( i , u j , a j ) D_j=(i,u_j,a_j) D j = ( i , u j , a j ) , where ( u j , a j ) (u_j,a_j) ( u j , a j ) are the query and answer in the configurations C i − 1 C_{i-1} C i − 1 and C i C_i C i , respectively.
(d) If i = 1 i=1 i = 1 , C 0 C_0 C 0 is the initial configuration and query ( C 0 ) = 0 \operatorname{query}(C_0)=0 query ( C 0 ) = 0 , and if i = T i=T i = T then C T C_T C T is an accepting configuration.
– If i = T + j i=T+j i = T + j for j ∈ [ Q ] j\in[Q] j ∈ [ Q ] then w i = ( C t j − 1 , C t j , D j , ρ ) w_i=(C_{t_j-1},C_{t_j},D_j,\rho) w i = ( C t j − 1 , C t j , D j , ρ ) such that the following holds:
(a) Verify ( h k , r t , I , ( C t j − 1 , C t j , D j ) , ρ ) = 1 \operatorname{Verify}(hk,rt,I,(C_{t_j-1},C_{t_j},D_j),\rho)=1 Verify ( hk , r t , I , ( C t j − 1 , C t j , D j ) , ρ ) = 1 , where I I I are the coordinates in τ \tau τ corresponding to ( C t j − 1 , C t j , D j ) (C_{t_j-1},C_{t_j},D_j) ( C t j − 1 , C t j , D j ) .
(b) D j = ( t j , u j , a j ) D_j=(t_j,u_j,a_j) D j = ( t j , u j , a j ) where t j ∈ [ T ] t_j\in[T] t j ∈ [ T ] .
(c) ( C t j − 1 , C t j ) (C_{t_j-1},C_{t_j}) ( C t j − 1 , C t j ) is a valid machine transition that increases the oracle call from j − 1 j-1 j − 1 to j j j , i.e., query ( C t j − 1 ) = j − 1 \operatorname{query}(C_{t_j-1})=j-1 query ( C t j − 1 ) = j − 1 and query ( C t j ) = j \operatorname{query}(C_{t_j})=j query ( C t j ) = j , and the configurations are associated with query u j u_j u j and answer a j a_j a j .
Remark 22. Note that the relation R l o c R_{\mathrm{loc}} R loc does not check a j = O ( u j ) a_j=O(u_j) a j = O ( u j ) . Thus it is an ordinary NP relation, not an oracle-aided one.
Construct the witnesses w 1 , … , w T + Q w_1,\ldots,w_{T+Q} w 1 , … , w T + Q for the NP relation R l o c R_{\mathrm{loc}} R loc . Compute
π s e B A R G = s e B A R G . P ( c r s s e B A R G , M l o c , z , 1 T l o c , w 1 , … , w T + Q ) . \pi_{\mathrm{seBARG}}=\mathrm{seBARG.P}(\mathrm{crs}_{\mathrm{seBARG}},M_{\mathrm{loc}},z,1^{T_{\mathrm{loc}}},w_1,\ldots,w_{T+Q}). π seBARG = seBARG.P ( crs seBARG , M loc , z , 1 T loc , w 1 , … , w T + Q ) .
where M l o c M_{\mathrm{loc}} M loc is the deterministic Turing machine that, on input ( z , i , w i ) (z,i,w_i) ( z , i , w i ) , accepts if and only if ( z , i , w i ) ∈ R l o c (z,i,w_i)\in R_{\mathrm{loc}} ( z , i , w i ) ∈ R loc , and T l o c T_{\mathrm{loc}} T loc is a bound on its runtime.
Let n l o c n_{\mathrm{loc}} n loc and m m m be fixed upper bounds on ∣ M l o c ∣ + ∣ z ∣ \lvert M_{\mathrm{loc}}\rvert+\lvert z\rvert ∣ M loc ∣ + ∣ z ∣ and the length of a local witness, respectively. We pad the common input and witnesses to these lengths.
Output π = ( r t , π s e B A R G ) \pi=(rt,\pi_{\mathrm{seBARG})} π = ( r t , π seBARG ) .
SNARG.V: This algorithm takes as input a tuple ( c r s , t d , x , π ) (\mathrm{crs},\mathrm{td},x,\pi) ( crs , td , x , π ) and does the following:
Parse c r s = ( h k , c r s s e B A R G ) \mathrm{crs}=(hk,\mathrm{crs}_{\mathrm{seBARG}}) crs = ( hk , crs seBARG ) , t d = ( J , t d s e B A R G ) \mathrm{td}=(J,\mathrm{td}_{\mathrm{seBARG}}) td = ( J , td seBARG ) and π = ( r t , π s e B A R G ) \pi=(rt,\pi_{\mathrm{seBARG}}) π = ( r t , π seBARG ) .
Let z = ( h k , x , r t ) z=(hk,x,rt) z = ( hk , x , r t ) .
Check that s e B A R G . V ( c r s s e B A R G , M l o c , z , T + Q , T l o c , π s e B A R G ) = 1 \mathrm{seBARG.V}(\mathrm{crs}_{\mathrm{seBARG}},M_{\mathrm{loc}},z,T+Q,T_{\mathrm{loc}},\pi_{\mathrm{seBARG}})=1 seBARG.V ( crs seBARG , M loc , z , T + Q , T loc , π seBARG ) = 1 . If this check fails, then reject.
Otherwise, compute
( w T + j ) j ∈ J = s e B A R G . E x t r a c t ( t d s e B A R G , π s e B A R G ) , (w_{T+j})_{j\in J}=\mathrm{seBARG.Extract}(\mathrm{td}_{\mathrm{seBARG}},\pi_{\mathrm{seBARG}}), ( w T + j ) j ∈ J = seBARG.Extract ( td seBARG , π seBARG ) ,
and check that for every j ∈ J j\in J j ∈ J it holds that R l o c ( z , T + j , w T + j ) = 1 R_{\mathrm{loc}}(z,T+j,w_{T+j})=1 R loc ( z , T + j , w T + j ) = 1 , and let ( u j , a j ) (u_j,a_j) ( u j , a j ) be the query-answer pair corresponding to w T + j w_{T+j} w T + j . Accept if and only if all these checks pass and
a j = O ( u j ) for every j ∈ J . a_j=O(u_j)\quad\text{for every }j\in J. a j = O ( u j ) for every j ∈ J .
Analysis
Completeness. Fix an accepting execution of M O ( x , w ) M^{O}(x,w) M O ( x , w ) , and let τ \tau τ be the transcript and oracle table constructed by the honest prover. By opening completeness, the witnesses constructed from τ \tau τ satisfy R l o c R_{\mathrm{loc}} R loc . By completeness of the seBARG, all the public verification checks accept.
It remains to consider the extracted witnesses. By the somewhere argument of knowledge property, all r r r extracted witnesses satisfy R l o c R_{\mathrm{loc}} R loc , except with negligible probability. Moreover, their opened configurations and table entries agree with τ \tau τ , except with negligible probability, as otherwise, an extracted opening and the corresponding honest opening give a collision with respect to opening. Every extracted pair ( u j , a j ) (u_j,a_j) ( u j , a j ) therefore satisfies a j = O ( u j ) a_j = \mathcal{O}(u_j) a j = O ( u j ) , and the verifier accepts. The same argument applies when ( x , w ) (x,w) ( x , w ) is chosen after seeing crs.
Adaptive soundness. Fix an oracle O \mathcal{O} O satisfying the oracle-security requirement, an oracle-aided machine M M M , and a robustness parameter ε \varepsilon ε whose representation has length ℓ ε ≤ poly ( T ) \ell_\varepsilon\leq\operatorname{poly}(T) ℓ ε ≤ poly ( T ) . Fix a polynomial-size oracle adversary A d v \mathsf{Adv} Adv . The adversary receives the crs and outputs an instance x x x and a proof π ∗ = ( r t , π s e B A R G ) \pi^* = (\mathsf{rt}, \pi_{\mathrm{seBARG}}) π ∗ = ( rt , π seBARG ) .
For every s ∈ { 0 , … , r } s \in\{0,\ldots,r\} s ∈ { 0 , … , r } , let E s E_s E s be the event that x ∉ L M O x \notin L_M^{\mathcal{O}} x ∈ / L M O , M O M^{\mathcal{O}} M O is ε \varepsilon ε -robust on x x x , all the public seBARG verification checks accept, and the private checks in components 1 , … , s 1,\ldots,s 1 , … , s accept. A private check includes both checking the extracted local witness and checking its oracle answer. Let
p s = Pr [ E s ] p_s = \Pr[E_s] p s = Pr [ E s ]
in the real experiment. Thus, p r p_r p r is the soundness error.
We prove that for every s ∈ [ r − 1 ] s \in[r-1] s ∈ [ r − 1 ] ,
p s ≤ ( 1 − ε ) p s − 1 + negl ( T ∗ ) . (1) p_s \leq(1-\varepsilon)p_{s-1}+\operatorname{negl}(T^*). \tag*{(1)} p s ≤ ( 1 − ε ) p s − 1 + negl ( T ∗ ) . (1)
Note that iterating Equation (1) , and using the fact that p 0 ≤ 1 p_0 \leq1 p 0 ≤ 1 and r = ⌊ λ / ε ⌋ r=\lfloor\lambda/\varepsilon\rfloor r = ⌊ λ / ε ⌋ , implies that
p r ≤ p r − 1 ≤ ( 1 − ε ) r − 1 ⋅ p 0 + ( r − 1 ) ⋅ negl ( T ∗ ) = ( 1 − ε ) ( ⌊ λ / ε ⌋ − 1 ) ⋅ p 0 + ( ⌊ λ / ε ⌋ − 1 ) ⋅ negl ( T ∗ ) = negl ( λ ) , p_r \leq p_{r-1} \leq(1-\varepsilon)^{r-1}\cdot p_0+(r-1)\cdot\operatorname{negl}(T^*)=(1-\varepsilon)^{(\lfloor\lambda/\varepsilon\rfloor-1)}\cdot p_0+(\lfloor\lambda/\varepsilon\rfloor-1)\cdot\operatorname{negl}(T^*)=\operatorname{negl}(\lambda), p r ≤ p r − 1 ≤ ( 1 − ε ) r − 1 ⋅ p 0 + ( r − 1 ) ⋅ negl ( T ∗ ) = ( 1 − ε ) (⌊ λ / ε ⌋ − 1 ) ⋅ p 0 + (⌊ λ / ε ⌋ − 1 ) ⋅ negl ( T ∗ ) = negl ( λ ) ,
as desired. To complete the adaptive soundness proof, it thus suffices to prove Equation (1) .
Proving Equation (1) using a potential function. For each input x x x , consider the configuration graph of all purported executions (Theorem 16) of M M M on x x x . We include an oracle-call counter in each configuration. An ordinary edge corresponds to a valid ordinary transition of M M M , including any permitted non-deterministic choice. At an oracle step with query u u u , we include an edge for every answer a a a of the prescribed length, regardless of whether a = O ( u ) a=\mathcal{O}(u) a = O ( u ) .
Assign each edge e e e the cost
c ( e ) = { 0 , if e is an ordinary transition , 1 [ a ≠ O ( u ) ] , if e uses answer a to query u . c(e)=
\begin{cases}
0, & \text{if } e \text{ is an ordinary transition},\\
\mathbf{1}[a\ne\mathcal{O}(u)], & \text{if } e \text{ uses answer } a \text{ to query } u.
\end{cases} c ( e ) = { 0 , 1 [ a = O ( u )] , if e is an ordinary transition , if e uses answer a to query u .
Thus, the cost of a path starting at the initial configuration equals the number of incorrect oracle answers in the corresponding purported execution.
For every t ∈ { 0 , … , T } t\in\{0,\ldots,T\} t ∈ { 0 , … , T } and configuration C C C , let d t x ( C ) d_t^x(C) d t x ( C ) be the minimum cost of a path of length t t t from the initial configuration to C C C , with the minimum of an empty set defined to be + ∞ +\infty + ∞ . These values can be computed by dynamic programming as follows:
d 0 x ( C ) = { 0 , C = C i n i t ( x ) , + ∞ , otherwise , d_0^x(C)=
\begin{cases}
0, & C=C_{\mathrm{init}}(x),\\
+\infty, & \text{otherwise},
\end{cases} d 0 x ( C ) = { 0 , + ∞ , C = C init ( x ) , otherwise ,
and, for each t < T t<T t < T ,
d t + 1 x ( C ′ ) = min e : C → C ′ ( d t x ( C ) + c ( e ) ) . d_{t+1}^x(C')=\min_{e:C\to C'}\bigl(d_t^x(C)+c(e)\bigr). d t + 1 x ( C ′ ) = e : C → C ′ min ( d t x ( C ) + c ( e ) ) .
Define the bounded potential
Φ t x ( C ) = min { d t x ( C ) , Q } , \Phi_t^x(C)=\min\{d_t^x(C),Q\}, Φ t x ( C ) = min { d t x ( C ) , Q } ,
where min { + ∞ , Q } = Q \min\{+\infty,Q\}=Q min { + ∞ , Q } = Q .
For every valid purported transition C ⟶ C ′ C\longrightarrow C' C ⟶ C ′ at step t t t , of cost c c c , we have
Φ t x ( C ′ ) ≤ Φ t − 1 x ( C ) + c . (2) \Phi_t^x(C')\leq\Phi_{t-1}^x(C)+c. \tag*{(2)} Φ t x ( C ′ ) ≤ Φ t − 1 x ( C ) + c . (2)
Also, Φ 0 x ( C i n i t ( x ) ) = 0 \Phi_0^x(C_{\mathrm{init}}(x))=0 Φ 0 x ( C init ( x )) = 0 . If x x x is an ε \varepsilon ε -robust no-instance, then every accepting configuration C C C satisfies
Φ T x ( C ) ≥ ε Q . (3) \Phi_T^x(C)\geq\varepsilon Q. \tag*{(3)} Φ T x ( C ) ≥ εQ . (3)
Indeed, every accepting purported execution has Q Q Q oracle calls and at least ε Q \varepsilon Q εQ incorrect answers. If C C C is unreachable, then d T x ( C ) = + ∞ d_T^x(C)=+\infty d T x ( C ) = + ∞ , and hence Φ T x ( C ) = Q ≥ ε Q \Phi_T^x(C)=Q\geq\varepsilon Q Φ T x ( C ) = Q ≥ εQ .
Claim 23. The entire table of potentials, as well as the predicate that x x x is an ε \varepsilon ε -robust no-instance, can be computed with oracle access to O \mathcal{O} O in time poly ( 2 S , n , T , ℓ ε ) ≤ poly ( T ∗ ) \operatorname{poly}(2^S,n,T,\ell_\varepsilon)\leq\operatorname{poly}(T^*) poly ( 2 S , n , T , ℓ ε ) ≤ poly ( T ∗ ) .
The proof of Theorem 23 follows by using a standard dynamic programming algorithm.
To prove Equation (1) , recall that p s p_s p s is the probability that E s − 1 E_{s-1} E s − 1 occurs and the s s s th private check accepts. Thus, it suffices to prove that
Pr [ E s − 1 ∧ the s th private check rejects ] ≥ ε p s − 1 − negl ( T ∗ ) . \Pr[E_{s-1}\mathbin{\wedge}\text{ the }s\text{th private check rejects}]\geq\varepsilon p_{s-1}-\operatorname{negl}(T^*). Pr [ E s − 1 ∧ the s th private check rejects ] ≥ ε p s − 1 − negl ( T ∗ ) .
We prove this using a sequence of hybrids, where we exploit index hiding to change the extraction indices of two seBARG components. We first show, using the potential function, that the expected total cost of the extracted transitions is at least ε Q p s − 1 \varepsilon Qp_{s-1} εQ p s − 1 , up to a negligible error. We then relate this cost to incorrect oracle answers in the table, implying that the s s s th private check rejects with probability at least ε p s − 1 \varepsilon p_{s-1} ε p s − 1 , up to a negligible error.
Proof of Equation (1) . Fix s ∈ [ r − 1 ] s\in[r-1] s ∈ [ r − 1 ] , and let E = E s − 1 E=E_{s-1} E = E s − 1 . We use the s s s th and r r r th seBARG components, whose trapdoors are not used in defining E E E . For a , b ∈ [ T + Q ] a,b\in[T+Q] a , b ∈ [ T + Q ] , let H a , b H_{a,b} H a , b denote the experiment in which these components have extraction indices a a a and b b b , respectively. Denote by ⋆ \star ⋆ a uniformly sampled index in { T + 1 , … , T + Q } \{T+1,\ldots,T+Q\} { T + 1 , … , T + Q } .
For every t ∈ [ T ] t\in[T] t ∈ [ T ] , consider H ⋆ , t H_{\star,t} H ⋆ , t , and let ( C t − 1 , C t ) (C_{t-1},C_t) ( C t − 1 , C t ) be the configurations extracted from component r r r . Let c t ∈ { 0 , 1 } c_t\in\{0,1\} c t ∈ { 0 , 1 } be the cost of this transition (as defined above). If the witness extracted from component r r r does not satisfy R l o c R_{\mathrm{loc}} R loc , we set the potential values and transition cost associated with this extraction to zero. Thus, all the random variables below are well-defined even when extraction fails. Set
F t − = E H ⋆ , t [ 1 E ⋅ Φ t − 1 x ( C t − 1 ) ] , F_t^-=\mathbb{E}_{H_{\star,t}}[1_E\cdot\Phi_{t-1}^x(C_{t-1})], F t − = E H ⋆ , t [ 1 E ⋅ Φ t − 1 x ( C t − 1 )] ,
F t + = E H ⋆ , t [ 1 E ⋅ Φ t x ( C t ) ] , F_t^+=\mathbb{E}_{H_{\star,t}}[1_E\cdot\Phi_t^x(C_t)], F t + = E H ⋆ , t [ 1 E ⋅ Φ t x ( C t )] ,
W t = E H ⋆ , t [ 1 E ⋅ c t ] . W_t=\mathbb{E}_{H_{\star,t}}[1_E\cdot c_t]. W t = E H ⋆ , t [ 1 E ⋅ c t ] .
By Equation (2) ,
F t + ≤ F t − + W t + negl ( T ∗ ) . F_t^+\leq F_t^-+W_t+\operatorname{negl}(T^*). F t + ≤ F t − + W t + negl ( T ∗ ) .
Moreover, the initial and terminal checks, together with Equation (3) , imply
F 1 − = 0 , F T + ≥ ε Q p s − 1 − negl ( T ∗ ) . F_1^-=0,\qquad F_T^+\geq\varepsilon Qp_{s-1}-\operatorname{negl}(T^*). F 1 − = 0 , F T + ≥ εQ p s − 1 − negl ( T ∗ ) .
For every j ∈ [ Q ] j \in[Q] j ∈ [ Q ] , consider H T + j , ⋆ H_{T+j,\star} H T + j , ⋆ , and let D j = ( t j , u j , a j ) D_j=(t_j,u_j,a_j) D j = ( t j , u j , a j ) be the oracle-table entry extracted from component s s s . Set
b j = 1 [ a j ≠ O ( u j ) ] , G j = E H T + j , ⋆ [ 1 E ⋅ b j ] . b_j = 1[a_j \ne O(u_j)], \qquad G_j = \mathbb{E}_{H_{T+j,\star}}[1_E \cdot b_j]. b j = 1 [ a j = O ( u j )] , G j = E H T + j , ⋆ [ 1 E ⋅ b j ] .
where b j = 0 b_j=0 b j = 0 if extraction is invalid.
We next argue that the following two equations hold:
F t + = F t + 1 − ± negl ( T ∗ ) , t ∈ [ T − 1 ] , F_t^+ = F_{t+1}^- \pm\operatorname{negl}(T^*), \qquad t \in[T-1], F t + = F t + 1 − ± negl ( T ∗ ) , t ∈ [ T − 1 ] ,
∑ t = 1 T W t = ∑ j = 1 Q G j ± negl ( T ∗ ) . \sum_{t=1}^{T} W_t = \sum_{j=1}^{Q} G_j \pm\operatorname{negl}(T^*). t = 1 ∑ T W t = j = 1 ∑ Q G j ± negl ( T ∗ ) .
This follows from T ∗ T^* T ∗ -index hiding, the somewhere argument-of-knowledge property, and collision resistance with respect to opening, as follows. By Theorem 23, the event E E E and the potential values used in these equations can be computed in time poly ( T ∗ ) \operatorname{poly}(T^*) poly ( T ∗ ) with oracle access to O O O . Thus, T ∗ T^* T ∗ -index hiding allows us to change an extraction index whenever the quantity being evaluated does not depend on the corresponding trapdoor. Moreover, whenever E E E occurs, the extracted witnesses are valid, and any two valid openings of the same position agree, except with probability negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) .
To prove the first equality, we consider the sequence of hybrids
H ⋆ , t , H t + 1 , t , H t + 1 , t + 1 , H ⋆ , t + 1 . H_{\star,t}, \quad H_{t+1,t}, \quad H_{t+1,t+1}, \quad H_{\star,t+1}. H ⋆ , t , H t + 1 , t , H t + 1 , t + 1 , H ⋆ , t + 1 .
We first change the extraction index of component s s s from ⋆ \star ⋆ to t + 1 t+1 t + 1 , while evaluating the potential using component r r r . In H t + 1 , t H_{t+1,t} H t + 1 , t , component r r r opens C t C_t C t as the configuration after step t t t , whereas component s s s opens C t C_t C t as the configuration before step t + 1 t+1 t + 1 . By collision resistance, these configurations agree except with negligible probability. We may therefore evaluate the potential using component s s s , change the extraction index of component r r r to t + 1 t+1 t + 1 , and then switch back to component r r r , since both components now open the configuration before step t + 1 t+1 t + 1 . Finally, we change the index of component s s s back to ⋆ \star ⋆ . Each change incurs an additive error of at most negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) , proving the first equality.
For the second equality, let A t , j A_{t,j} A t , j indicate that the transition extracted at time t t t is valid, is the j j j th oracle transition, and uses an incorrect oracle answer. We set A t , j = 0 A_{t,j}=0 A t , j = 0 if extraction is invalid. Consider the hybrid H T + j , t H_{T+j,t} H T + j , t , where component s s s opens the j j j th oracle-table entry and component r r r opens the transition at time t t t . By the local checks in R l o c R_{\mathrm{loc}} R loc , if either witness identifies this transition as the j j j th oracle call, then the two witnesses open the same configurations and oracle-table entry. By collision resistance, these openings agree except with negligible probability. Consequently,
A t , j = 1 [ t j = t ] ⋅ b j A_{t,j} = 1[t_j=t]\cdot b_j A t , j = 1 [ t j = t ] ⋅ b j
except with probability negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) on the event E E E . By index hiding, we can change the index of component s s s back to ⋆ \star ⋆ when evaluating A t , j A_{t,j} A t , j , and change the index of component r r r back to ⋆ \star ⋆ when evaluating 1 [ t j = t ] ⋅ b j 1[t_j=t]\cdot b_j 1 [ t j = t ] ⋅ b j . Thus,
E H ⋆ , t [ 1 E A t , j ] = E H T + j , ⋆ [ 1 E ⋅ 1 [ t j = t ] ⋅ b j ] ± negl ( T ∗ ) . \mathbb{E}_{H_{\star,t}}[1_E A_{t,j}] = \mathbb{E}_{H_{T+j,\star}}[1_E \cdot1[t_j=t]\cdot b_j] \pm\operatorname{negl}(T^*). E H ⋆ , t [ 1 E A t , j ] = E H T + j , ⋆ [ 1 E ⋅ 1 [ t j = t ] ⋅ b j ] ± negl ( T ∗ ) .
Summing over t t t and j j j gives the second equality, since each incorrect oracle transition contributes to exactly one A t , j A_{t,j} A t , j , and each oracle-table entry has exactly one time index t j t_j t j . The total error remains negligible, since T Q ≤ ( T ∗ ) 2 TQ \le(T^*)^2 T Q ≤ ( T ∗ ) 2 .
Combining these inequalities, we obtain
∑ j = 1 Q G j ≥ ∑ t = 1 T W t − negl ( T ∗ ) ≥ ∑ t = 1 T ( F t + − F t − ) − negl ( T ∗ ) ≥ F T + − F 1 − − negl ( T ∗ ) ≥ ε Q p s − 1 − negl ( T ∗ ) . \begin{aligned}
\sum_{j=1}^{Q} G_j &\ge\sum_{t=1}^{T} W_t-\operatorname{negl}(T^*)\\
&\ge\sum_{t=1}^{T}(F_t^+-F_t^-)-\operatorname{negl}(T^*)\\
&\ge F_T^+-F_1^--\operatorname{negl}(T^*)\\
&\ge\varepsilon Qp_{s-1}-\operatorname{negl}(T^*).
\end{aligned} j = 1 ∑ Q G j ≥ t = 1 ∑ T W t − negl ( T ∗ ) ≥ t = 1 ∑ T ( F t + − F t − ) − negl ( T ∗ ) ≥ F T + − F 1 − − negl ( T ∗ ) ≥ εQ p s − 1 − negl ( T ∗ ) .
Finally, in the real experiment the s s s th private check samples a uniformly random oracle-table index. Therefore,
Pr [ E ∧ the s th check rejects ] ≥ 1 Q ∑ j = 1 Q G j ≥ ε p s − 1 − negl ( T ∗ ) . \Pr[E \wedge\text{the }s\text{th check rejects}]\ge\frac{1}{Q}\sum_{j=1}^{Q}G_j\ge\varepsilon p_{s-1}-\operatorname{negl}(T^*). Pr [ E ∧ the s th check rejects ] ≥ Q 1 j = 1 ∑ Q G j ≥ ε p s − 1 − negl ( T ∗ ) .
It follows that
p s ≤ ( 1 − ε ) p s − 1 + negl ( T ∗ ) , p_s\le(1-\varepsilon)p_{s-1}+\operatorname{negl}(T^*), p s ≤ ( 1 − ε ) p s − 1 + negl ( T ∗ ) ,
which proves Equation (1) .
Efficiency. A local witness contains a constant number of configurations and table entries, together with their local openings. Thus its length is m = poly ( κ , S , log T ) m=\operatorname{poly}(\kappa,S,\log T) m = poly ( κ , S , log T ) . The common input has length n + poly ( κ , S , log T ) n+\operatorname{poly}(\kappa,S,\log T) n + poly ( κ , S , log T ) . Applying the succinctness and succinct extraction bounds of the underlying primitives to the r r r components, with the stated choice κ = poly ( λ , S , log ( n T ) , log ( 1 / ε ) ) \kappa=\operatorname{poly}(\lambda,S,\log(nT),\log(1/\varepsilon)) κ = poly ( λ , S , log ( n T ) , log ( 1/ ε )) , gives
∣ c r s ∣ + ∣ t d ∣ + ∣ π ∣ ≤ poly ( λ , S , log ( n T ) , 1 / ε ) . |\mathrm{crs}|+|\mathrm{td}|+|\pi|\le\operatorname{poly}(\lambda,S,\log(nT),1/\varepsilon). ∣ crs ∣ + ∣ td ∣ + ∣ π ∣ ≤ poly ( λ , S , log ( n T ) , 1/ ε ) .
The verifier checks the r r r public proofs, extracts r r r local witnesses, checks their local relations, and makes at most r = O ( λ / ε ) r=O(\lambda/\varepsilon) r = O ( λ / ε ) oracle calls. Its running time is
n ⋅ poly ( λ , S , log ( n T ) , 1 / ε ) . n\cdot\operatorname{poly}(\lambda,S,\log(nT),1/\varepsilon). n ⋅ poly ( λ , S , log ( n T ) , 1/ ε ) .
Under the convention T ≥ n T\ge n T ≥ n , these are the stated bounds with log T \log T log T in place of log ( n T ) \log(nT) log ( n T ) . The prover runs in time polynomial in the execution length, the security parameter, and 1 / ε 1/\varepsilon 1/ ε .
The argument above concerns the fixed-query-count construction. An extension to a varying number of oracle calls requires a corresponding construction and is not obtained by changing the denominator in the robustness condition to the upper bound Q Q Q .
Impossibility of Publicly-Verifiable SNARGs for Robust Oracle-Aided Computations
In this section, we prove a lower bound on the oracle-query complexity of a SNARG with deterministic public verification whose public parameters are shorter than the input length.
Theorem 24. There does not exist a SNARG with adaptive completeness and adaptive soundness for robust oracle-aided computations with deterministic public verification, with ∣ c r s ∣ = o ( n ) |\mathrm{crs}|=o(n) ∣ crs ∣ = o ( n ) , where n n n is the input length, and where the verifier makes o ( q ) o(q) o ( q ) queries, where q q q is the number of oracle gates.
More specifically, we show that a verifier that makes sufficiently fewer oracle queries than the computation cannot have negligible soundness error. Our argument does not use any bound on the proof length, and thus holds even for non-succinct non-interactive arguments, as long as the verifier makes o ( q ) o(q) o ( q ) oracle calls, where q q q is the number of oracle gates in the computation. It also holds for deterministic computations that make non-adaptive oracle queries.
Proof. Let n = n ( λ ) n=n(\lambda) n = n ( λ ) and N = N ( λ ) N=N(\lambda) N = N ( λ ) be polynomially bounded, and consider the oracle-aided computation
C O ( x ) = Maj ( O ( x , 1 ) , … , O ( x , N ) ) , x ∈ { 0 , 1 } n . C^{\mathcal{O}}(x)=\operatorname{Maj}(\mathcal{O}(x,1),\ldots,\mathcal{O}(x,N)),\qquad x\in\{0,1\}^{n}. C O ( x ) = Maj ( O ( x , 1 ) , … , O ( x , N )) , x ∈ { 0 , 1 } n .
We refer to ( O ( x , 1 ) , … , O ( x , N ) ) (\mathcal{O}(x,1),\ldots,\mathcal{O}(x,N)) ( O ( x , 1 ) , … , O ( x , N )) as the row indexed by x x x .
Suppose that there exists a SNARG Π = ( G e n , P , V ) \Pi=(\mathsf{Gen},\mathcal{P},\mathcal{V}) Π = ( Gen , P , V ) for the computation C O C^{\mathcal{O}} C O where V \mathcal{V} V makes ℓ ≤ N / 8 \ell\le N/8 ℓ ≤ N /8 queries to O \mathcal{O} O . To get a contradiction, the idea is to start with the oracle O 1 \mathcal{O}_{1} O 1 that answers 1 on every query, so that C O 1 ( x ) = 1 C^{\mathcal{O}_{1}}(x)=1 C O 1 ( x ) = 1 for every x ∈ { 0 , 1 } n x\in\{0,1\}^{n} x ∈ { 0 , 1 } n , and then change some rows ( O ( x , 1 ) , … , O ( x , N ) ) (\mathcal{O}(x,1),\ldots,\mathcal{O}(x,N)) ( O ( x , 1 ) , … , O ( x , N )) so that the majority is 0 without the verifier noticing, thus causing it to accept a false statement. Intuitively, this is done by changing the oracle on every ( x , i ) (x,i) ( x , i ) that the verifier does not query. The tricky part is doing this in a way that is independent of the crs, since the oracle O \mathcal{O} O should be fixed before crs was generated.
To this end, we define x x x to depend on crs in a way that x x x determines crs. For example, for every crs, let
x c r s = c r s ∥ 1 ∥ 0 n − ∣ c r s ∣ − 1 . x_{\mathrm{crs}}=\mathrm{crs}\mathbin\Vert1\mathbin\Vert0^{n-|\mathrm{crs}|-1}. x crs = crs ∥ 1 ∥ 0 n − ∣ crs ∣ − 1 .
Thus, c r s ↦ x c r s \mathrm{crs}\mapsto x_{\mathrm{crs}} crs ↦ x crs is an efficiently invertible encoding into the input space. Fix randomness r r r for the prover, and let
π c r s , r = P O 1 ( c r s , x c r s ; r ) . \pi_{\mathrm{crs},r}=\mathcal{P}^{\mathcal{O}_{1}}(\mathrm{crs},x_{\mathrm{crs}};r). π crs , r = P O 1 ( crs , x crs ; r ) .
Let Q c r s , r Q_{\mathrm{crs},r} Q crs , r be the set of queries made by V \mathcal{V} V in the execution
V O 1 ( c r s , x c r s , π c r s , r ) , \mathcal{V}^{\mathcal{O}_{1}}(\mathrm{crs},x_{\mathrm{crs}},\pi_{\mathrm{crs},r}), V O 1 ( crs , x crs , π crs , r ) ,
and let
I c r s , r = { i ∈ [ N ] : ( x c r s , i ) ∈ Q c r s , r } . I_{\mathrm{crs},r}=\{i\in[N]:(x_{\mathrm{crs}},i)\in Q_{\mathrm{crs},r}\}. I crs , r = { i ∈ [ N ] : ( x crs , i ) ∈ Q crs , r } .
Since C O 1 ( x ) = 1 C^{\mathcal{O}_{1}}(x)=1 C O 1 ( x ) = 1 for every x x x ,
Pr c r s ← G e n ( 1 λ ) , r [ V O 1 ( c r s , x c r s , π c r s , r ) = 1 ] ≥ 1 − negl ( λ ) . (4) \Pr_{\substack{\mathrm{crs}\leftarrow\mathsf{Gen}(1^\lambda),\,r}}\left[\mathcal{V}^{\mathcal{O}_{1}}(\mathrm{crs},x_{\mathrm{crs}},\pi_{\mathrm{crs},r})=1\right]\ge1-\operatorname{negl}(\lambda). \tag*{(4)} crs ← Gen ( 1 λ ) , r Pr [ V O 1 ( crs , x crs , π crs , r ) = 1 ] ≥ 1 − negl ( λ ) . (4)
where r r r is uniform.
Defining the oracle. We cannot modify every row x c r s x_{\mathrm{crs}} x crs , since the verifier may query the oracle on rows other than the one corresponding to its input. Instead, we modify only a small fraction of rows, selected using a pairwise-independent hash function. Specifically, let k = log 2 ( 2 ℓ ) k=\log_{2}(2\ell) k = log 2 ( 2 ℓ ) , and sample a pairwise-independent function
h : { 0 , 1 } n ⟶ { 0 , 1 } k . h:\{0,1\}^{n}\longrightarrow\{0,1\}^{k}. h : { 0 , 1 } n ⟶ { 0 , 1 } k .
We say that a row x x x is marked if h ( x ) = 0 k h(x)=0^k h ( x ) = 0 k . Let p = 2 − k = 1 2 ℓ p=2^{-k}=\frac{1}{2^\ell} p = 2 − k = 2 ℓ 1 . For every crs and every i ∈ [ N ] i\in[N] i ∈ [ N ] , define
O h , r ( x c r s , i ) = { 1 , if h ( x c r s ) ≠ 0 k or i ∈ I c r s , r , 0 , otherwise. (5) \mathcal{O}_{h,r}(x_{\mathrm{crs}},i)=
\begin{cases}
1, & \text{if }h(x_{\mathrm{crs}})\ne0^k\text{ or }i\in I_{\mathrm{crs},r},\\
0, & \text{otherwise.}
\end{cases} \tag*{(5)} O h , r ( x crs , i ) = { 1 , 0 , if h ( x crs ) = 0 k or i ∈ I crs , r , otherwise. (5)
All queries not covered by this definition are answered with 1. Thus, unmarked rows are all ones. A marked row of the form x c r s x_{\mathrm{crs}} x crs contains ones only at the positions in I c r s , r I_{\mathrm{crs},r} I crs , r . We emphasize that this defines an oracle before the crs is sampled.
Robustness. Note that the computation C O h , r C^{\mathcal{O}_{h,r}} C O h , r is 1 / 4 1/4 1/4 -robust on every input. This is the case since every row of O h , r \mathcal{O}_{h,r} O h , r is either all ones or contains at most ℓ ≤ N / 8 \ell\le N/8 ℓ ≤ N /8 ones. Thus, changing at most N / 4 N/4 N /4 oracle answers leaves a row of the first type with at least 3 N / 4 3N/4 3 N /4 ones, and a row of the second type with at most 3 N / 8 3N/8 3 N /8 ones, and hence does not change the outcome of the computation.
The cheating prover. Given crs, the adversary P r ∗ \mathcal{P}^*_r P r ∗ outputs
( x , π ) = ( x c r s , π c r s , r ) . (x,\pi)=(x_{\mathrm{crs}},\pi_{\mathrm{crs},r}). ( x , π ) = ( x crs , π crs , r ) .
That is, it simulates the honest prover on input x c r s x_{\mathrm{crs}} x crs , using random tape r r r and answering every simulated oracle query with 1. It does not query the actual oracle, and does not need to know h h h .
Analysis. Fix crs, r r r for which V O 1 ( c r s , x c r s , π c r s , r ) = 1 \mathcal{V}^{\mathcal{O}_1}(\mathrm{crs},x_{\mathrm{crs}},\pi_{\mathrm{crs},r})=1 V O 1 ( crs , x crs , π crs , r ) = 1 . Let B c r s , r B_{\mathrm{crs},r} B crs , r be the set of other rows visited in this execution. Namely,
B c r s , r = { u ∈ { 0 , 1 } n ∖ { x c r s } : ∃ i ∈ [ N ] such that ( u , i ) ∈ Q c r s , r } . B_{\mathrm{crs},r}=\{u\in\{0,1\}^n\setminus\{x_{\mathrm{crs}}\}:\exists i\in[N]\text{ such that }(u,i)\in Q_{\mathrm{crs},r}\}. B crs , r = { u ∈ { 0 , 1 } n ∖ { x crs } : ∃ i ∈ [ N ] such that ( u , i ) ∈ Q crs , r } .
We have ∣ B c r s , r ∣ ≤ ℓ |B_{\mathrm{crs},r}|\le\ell ∣ B crs , r ∣ ≤ ℓ . Consider the event
E c r s , r = { h ( x c r s ) = 0 k and h ( u ) ≠ 0 k for every u ∈ B c r s , r } . E_{\mathrm{crs},r}=\{h(x_{\mathrm{crs}})=0^k\text{ and }h(u)\ne0^k\text{ for every }u\in B_{\mathrm{crs},r}\}. E crs , r = { h ( x crs ) = 0 k and h ( u ) = 0 k for every u ∈ B crs , r } .
It is easy to see that on this event, the verifier accepts a false statement. Thus, it remains to argue that event E c r s , r E_{\mathrm{crs},r} E crs , r holds with non-negligible probability. To this end, note that the set B c r s , r B_{\mathrm{crs},r} B crs , r is defined using O 1 \mathcal{O}_1 O 1 , and is therefore independent of h h h . By pairwise independence and a union bound,
Pr h [ E c r s , r ] ≥ Pr h [ h ( x c r s ) = 0 k ] − ∑ u ∈ B c r s , r Pr h [ h ( x c r s ) = 0 k ∧ h ( u ) = 0 k ] = p − ∣ B c r s , r ∣ ⋅ p 2 ≥ p − ℓ p 2 = p − ℓ 4 ℓ 2 = 1 2 ℓ − 1 4 ℓ = 1 4 ℓ . \begin{aligned}
\Pr_h[E_{\mathrm{crs},r}]\ge\Pr_h[h(x_{\mathrm{crs}})=0^k]-\sum_{u\in B_{\mathrm{crs},r}}\Pr_h[h(x_{\mathrm{crs}})=0^k\land h(u)=0^k] \\
&=p-|B_{\mathrm{crs},r}|\cdot p^2 \\
&\ge p-\ell p^2 \\
&=p-\frac{\ell}{4\ell^2}=\frac{1}{2\ell}-\frac{1}{4\ell}=\frac{1}{4\ell}.
\end{aligned} h Pr [ E crs , r ] ≥ h Pr [ h ( x crs ) = 0 k ] − u ∈ B crs , r ∑ h Pr [ h ( x crs ) = 0 k ∧ h ( u ) = 0 k ] = p − ∣ B crs , r ∣ ⋅ p 2 ≥ p − ℓ p 2 = p − 4 ℓ 2 ℓ = 2 ℓ 1 − 4 ℓ 1 = 4 ℓ 1 .
Together with Equation (4) , this gives
Pr h , r , c r s ← Gen ( 1 λ ) [ C O h , r ( x c r s ) = 0 ∧ V O h , r ( c r s , x c r s , π c r s , r ) = 1 ] ≥ 1 − negl ( λ ) 4 ℓ . \Pr_{h,r,\mathrm{crs}\leftarrow\operatorname{Gen}(1^\lambda)}
\left[\mathcal{C}^{\mathcal{O}_{h,r}}(x_{\mathrm{crs}})=0\land
\mathcal{V}^{\mathcal{O}_{h,r}}(\mathrm{crs},x_{\mathrm{crs}},\pi_{\mathrm{crs},r})=1\right]
\ge\frac{1-\operatorname{negl}(\lambda)}{4\ell}. h , r , crs ← Gen ( 1 λ ) Pr [ C O h , r ( x crs ) = 0 ∧ V O h , r ( crs , x crs , π crs , r ) = 1 ] ≥ 4 ℓ 1 − negl ( λ ) .
Here h h h , r r r , crs are sampled independently. By averaging, there exist fixed choices h ∗ , r ∗ h^*,r^* h ∗ , r ∗ for which the same lower bound holds over crs alone. Setting O = O h ∗ , r ∗ \mathcal{O}=\mathcal{O}_{h^*,r^*} O = O h ∗ , r ∗ and P ∗ = P r ∗ ∗ \mathcal{P}^*=\mathcal{P}^*_{r^*} P ∗ = P r ∗ ∗ gives us the desired contradiction.
The Construction
Definition 25 (Signed oracle). Let O : { 0 , 1 } ∗ → { 0 , 1 } ∗ \mathcal{O} : \{0,1\}^{*} \to\{0,1\}^{*} O : { 0 , 1 } ∗ → { 0 , 1 } ∗ be an oracle, and let
S i g = ( S i g . G e n , S i g . S i g n , S i g . V e r i f y ) \mathrm{Sig} = (\mathrm{Sig.Gen}, \mathrm{Sig.Sign}, \mathrm{Sig.Verify}) Sig = ( Sig.Gen , Sig.Sign , Sig.Verify ) be a signature scheme. A signed oracle associated with O \mathcal{O} O is obtained by generating
( v k , s k ) ← S i g . G e n ( 1 κ s i g ) , (\mathrm{vk},\mathrm{sk}) \leftarrow\mathrm{Sig.Gen}(1^{\kappa_{\mathrm{sig}}}), ( vk , sk ) ← Sig.Gen ( 1 κ sig ) , where κ s i g \kappa_{\mathrm{sig}} κ sig is the signature security parameter, and defining
O s i g ( u ) = ( a , σ ) , a = O ( u ) , σ ← S i g . S i g n ( s k , ( u , a ) ) . \mathcal{O}^{\mathrm{sig}}(u) = (a,\sigma), \qquad a = \mathcal{O}(u), \qquad\sigma\leftarrow\mathrm{Sig.Sign}(\mathrm{sk},(u,a)). O sig ( u ) = ( a , σ ) , a = O ( u ) , σ ← Sig.Sign ( sk , ( u , a )) . The verification key v k \mathrm{vk} vk is public, whereas s k \mathrm{sk} sk is held only by the oracle and is unknown to the prover or the verifier. We require the signature scheme to have perfect completeness and to be existentially unforgeable against adaptive chosen-message attacks, even given access to O \mathcal{O} O .
Notice that the signature authenticates both the query and the answer. Also, the signature need not be unique: different calls on the same query may return different signatures, but they return the same answer.
Theorem 27. Let M M M be a non-deterministic oracle-aided machine with time bound T T T , space bound S S S , and oracle-query bound Q ≤ T Q \le T Q ≤ T . Let O s i g \mathcal{O}_{\mathrm{sig}} O sig be a signed oracle as in Theorem 25, with the security parameter κ s i g = poly ( λ , log T ) \kappa_{\mathrm{sig}} = \operatorname{poly}(\lambda,\log T) κ sig = poly ( λ , log T ) . Assume that LWE is sub-exponentially hard even given access to O \mathcal{O} O . There exists a (publicly verifiable) SNARG for M O M^{\mathcal{O}} M O , with adaptive soundness, whose public parameters and proof have length
poly ( λ , S , log T ) . \operatorname{poly}(\lambda,S,\log T). poly ( λ , S , log T ) . The verifier runs in time n ⋅ poly ( λ , S , log T ) n \cdot\operatorname{poly}(\lambda,S,\log T) n ⋅ poly ( λ , S , log T ) and makes no oracle calls. Setup also makes no oracle calls. The prover makes at most Q Q Q calls to O s i g \mathcal{O}_{\mathrm{sig}} O sig and runs in time polynomial in the security parameter and the length of the signed execution.14
As in the polynomial-time setting of § 4.3 , we first take n n n , T T T , S S S to be polynomially bounded in λ \lambda λ , and take T ≥ n T \ge n T ≥ n . We discuss the security requirements for larger time bounds at the end of the section. In § 6.5 , we give a fully succinct variant for deterministic computations.
The Construction
As in the construction in Section 5, our construction uses the following ingredients:
H T = ( H T . G e n , H T . H a s h , H T . O p e n , H T . V e r i f y ) . \mathrm{HT} = (\mathrm{HT.Gen},\mathrm{HT.Hash},\mathrm{HT.Open},\mathrm{HT.Verify}). HT = ( HT.Gen , HT.Hash , HT.Open , HT.Verify ) .
s e B A R G = ( s e B A R G . G e n , s e B A R G . P , s e B A R G . V , s e B A R G . E x t r a c t ) . \mathrm{seBARG} = (\mathrm{seBARG.Gen},\mathrm{seBARG.}\mathcal{P},\mathrm{seBARG.}\mathcal{V},\mathrm{seBARG.Extract}). seBARG = ( seBARG.Gen , seBARG. P , seBARG. V , seBARG.Extract ) .
We assume that the hash family H T \mathrm{HT} HT and the s e B A R G \mathrm{seBARG} seBARG are T ∗ T^{*} T ∗ -secure, where
T ∗ = poly ( 2 S , n , T , λ ) . T^{*} = \operatorname{poly}(2^{S}, n, T, \lambda). T ∗ = poly ( 2 S , n , T , λ ) .
As in Section 5, sub-exponential hardness allows their underlying security parameter to be chosen as
κ = poly ( λ , S , log T ) . \kappa= \operatorname{poly}(\lambda, S, \log T). κ = poly ( λ , S , log T ) .
Similar to the (privately verifiable) SNARG in Section 5, our SNARG construction also has the hash-and-seBARG structure. However, unlike the construction in Section 5, the SNARG in this section is publicly verifiable and the verifier does not extract any witnesses or check any answers against the oracle. Instead, the local relation checks a signature at every oracle transition. Extraction is used only in the soundness proof.
It is important that we use the somewhere extraction property of the underlying seBARG, rather than only ordinary soundness, since a verifying signature on an incorrect answer may exist. We must show that a successful adversary allows us to produce such a signature, and not merely prove its existence.
We assume without loss of generality that every execution halts in exactly T T T steps, by padding if needed. In contrast to the construction in Section 5, here there is no need to fix the number of oracle calls or to include a separate oracle table.
The local relation R s i g R_{\mathrm{sig}} R sig . In what follows, let v k \mathrm{vk} vk be the verification key corresponding to the oracle O s i g \mathcal{O}_{\mathrm{sig}} O sig , let h k \mathrm{hk} hk be a hash key, and r t \mathrm{rt} rt be a hash value (supposedly hashing the tableau of an execution of M O s i g M^{\mathcal{O}_{\mathrm{sig}}} M O sig ). An instance of the oracle-free relation R s i g R_{\mathrm{sig}} R sig is a string of the form ( z , i ) (z,i) ( z , i ) where i ∈ [ T ] i \in[T] i ∈ [ T ] and
z = ( v k , h k , x , r t ) . z = (\mathrm{vk},\mathrm{hk},x,\mathrm{rt}). z = ( vk , hk , x , rt ) .
A local witness corresponding to ( z , i ) (z,i) ( z , i ) is a string of the form
w i = ( C i − 1 , C i , ρ i , σ i ) . w_i = (C_{i-1}, C_i, \rho_i, \sigma_i). w i = ( C i − 1 , C i , ρ i , σ i ) .
The relation checks the following:
The opening ρ i \rho_i ρ i authenticates ( C i − 1 , C i ) (C_{i-1}, C_i) ( C i − 1 , C i ) at their prescribed positions in a transcript with hash value r t \mathrm{rt} rt .
If this is an ordinary step, ( C i − 1 , C i ) (C_{i-1}, C_i) ( C i − 1 , C i ) is a valid ordinary transition of M M M on x x x . In this case σ i = ⊥ \sigma_i = \bot σ i = ⊥ .
Analysis
If this is an oracle step, ( C i − 1 , C i ) (C_{i-1}, C_i) ( C i − 1 , C i ) is a valid purported oracle transition. Let u i u_i u i and a i a_i a i be the query and answer specified by these configurations. Check that
Sig.Verify ( v k , ( u i , a i ) , σ i ) = 1. \operatorname{Sig.Verify}(\mathrm{vk}, (u_i,a_i), \sigma_i) = 1. Sig.Verify ( vk , ( u i , a i ) , σ i ) = 1.
If i = 1 i = 1 i = 1 , then C 0 C_0 C 0 is the prescribed initial configuration. If i = T i = T i = T , then C T C_T C T is accepting. All configurations and transitions respect the prescribed bounds.
Let M s i g M_{\mathrm{sig}} M sig be the deterministic machine for this relation. Our SNARG construction uses the seBARG from Section 3.3 for the universal language BatchIndexTMSAT (Theorem 10), with respect to instances of the form ( M s i g , z , k , T l o c ) (M_{\mathrm{sig}}, z, k, T_{\mathrm{loc}}) ( M sig , z , k , T loc ) , where T l o c T_{\mathrm{loc}} T loc is a bound on the running time of M s i g M_{\mathrm{sig}} M sig , and z z z contains the instance-dependent data. Let n l o c n_{\mathrm{loc}} n loc bound ∣ M s i g ∣ + ∣ z ∣ |M_{\mathrm{sig}}|+|z| ∣ M sig ∣ + ∣ z ∣ , and let m m m bound the length of a local witness. We pad inputs and witnesses to their prescribed lengths.
We next describe our SNARG construction for the computation M O s i g M^{O_{\mathrm{sig}}} M O sig .
SNARG.Gen: On input ( 1 λ , n , v k ) (1^\lambda,n,\mathrm{vk}) ( 1 λ , n , vk ) , do the following:
Generate h k ← H T . G e n ( 1 κ ) \mathrm{hk} \leftarrow\mathrm{HT.Gen}(1^\kappa) hk ← HT.Gen ( 1 κ ) .
For each b ∈ { 1 , 2 } b \in\{1,2\} b ∈ { 1 , 2 } , independently generate
( c r s b , t d b ) ← s e B A R G . G e n ( 1 κ , n l o c , 1 m , T , 1 ) . (\mathrm{crs}_b,\mathrm{td}_b) \leftarrow\mathrm{seBARG.Gen}(1^\kappa,n_{\mathrm{loc}},1^m,T,1). ( crs b , td b ) ← seBARG.Gen ( 1 κ , n loc , 1 m , T , 1 ) .
Output c r s = ( v k , h k , c r s 1 , c r s 2 ) \mathrm{crs} = (\mathrm{vk},\mathrm{hk},\mathrm{crs}_1,\mathrm{crs}_2) crs = ( vk , hk , crs 1 , crs 2 ) . Discard both trapdoors.
Remark 28. Jumping ahead, the reason we use two independent seBARG common reference strings is that the second component allows us, in the analysis, to compare extractions at neighboring transitions.
SNARG.P: On input ( c r s , x , w ) (\mathrm{crs},x,w) ( crs , x , w ) , with access to O s i g O_{\mathrm{sig}} O sig , do the following:
Run the accepting execution of M O ( x , w ) M^{O}(x,w) M O ( x , w ) , obtaining the signatures for each query-answer pair. Let τ = ( C 0 , … , C T ) \tau= (C_0,\ldots,C_T) τ = ( C 0 , … , C T ) be its transcript.
Compute r t = H T . H a s h ( h k , τ ) \mathrm{rt} = \mathrm{HT.Hash}(\mathrm{hk},\tau) rt = HT.Hash ( hk , τ ) , and let z = ( v k , h k , x , r t ) z = (\mathrm{vk},\mathrm{hk},x,\mathrm{rt}) z = ( vk , hk , x , rt ) .
For every i ∈ [ T ] i \in[T] i ∈ [ T ] compute the local witness w i w_i w i corresponding to ( z , i ) (z,i) ( z , i ) in R s i g R_{\mathrm{sig}} R sig .
For each b ∈ { 1 , 2 } b \in\{1,2\} b ∈ { 1 , 2 } , compute
π b = s e B A R G . P ( c r s b , M s i g , z , 1 T l o c , w 1 , … , w T ) . \pi_b = \mathrm{seBARG.P}(\mathrm{crs}_b,M_{\mathrm{sig}},z,1^{T_{\mathrm{loc}}},w_1,\ldots,w_T). π b = seBARG.P ( crs b , M sig , z , 1 T loc , w 1 , … , w T ) .
Output π = ( r t , π 1 , π 2 ) \pi= (\mathrm{rt},\pi_1,\pi_2) π = ( rt , π 1 , π 2 ) .
SNARG.V: On input ( c r s , x , π ) (\mathrm{crs},x,\pi) ( crs , x , π ) , do the following:
Parse c r s = ( v k , h k , c r s 1 , c r s 2 ) \mathrm{crs} = (\mathrm{vk},\mathrm{hk},\mathrm{crs}_1,\mathrm{crs}_2) crs = ( vk , hk , crs 1 , crs 2 ) .
Parse π = ( r t , π 1 , π 2 ) \pi= (\mathrm{rt},\pi_1,\pi_2) π = ( rt , π 1 , π 2 ) .
Let z = ( v k , h k , x , r t ) z = (\mathrm{vk},\mathrm{hk},x,\mathrm{rt}) z = ( vk , hk , x , rt ) .
Accept if and only if, for each b ∈ { 1 , 2 } b \in\{1,2\} b ∈ { 1 , 2 } ,
s e B A R G . V ( c r s b , ( M s i g , z , T , T l o c ) , π b ) = 1. \mathrm{seBARG.V}(\mathrm{crs}_b,(M_{\mathrm{sig}},z,T,T_{\mathrm{loc}}),\pi_b) = 1. seBARG.V ( crs b , ( M sig , z , T , T loc ) , π b ) = 1.
Analysis
In this section we prove that the SNARG construction from § 6.2 satisfies the guarantees of Theorem 27 .
Completeness. Every oracle answer in an honest execution is accompanied by a verifying signature. Thus all local witnesses satisfy R s i g R_{\mathrm{sig}} R sig , and completeness follows from opening completeness, signature correctness, and seBARG completeness. The same reasoning holds when ( x , w ) (x,w) ( x , w ) is chosen after seeing the public parameters.
Adaptive soundness. We prove adaptive soundness via a reachability argument. For every x x x , t ∈ { 0 , … , T } t \in\{0,\ldots,T\} t ∈ { 0 , … , T } , and configuration C C C , define
Φ t x ( C ) = { 0 , if C is reachable in t steps of M O on x , 1 , otherwise. \Phi_t^x(C)=
\begin{cases}
0, & \text{if } C \text{ is reachable in } t \text{ steps of } M^O \text{ on } x,\\
1, & \text{otherwise.}
\end{cases} Φ t x ( C ) = { 0 , 1 , if C is reachable in t steps of M O on x , otherwise.
Reachability here allows all non-deterministic choices, but only correct oracle answers. The table of these values can be computed with oracle access in time poly ( 2 S , n , T ) ≤ poly ( T ∗ ) \operatorname{poly}(2^S,n,T) \le\operatorname{poly}(T^\ast) poly ( 2 S , n , T ) ≤ poly ( T ∗ ) , by dynamic programming on the configuration graph. The same computation determines whether x ∈ L M O x \in L_M^O x ∈ L M O .
For any valid ordinary transition, or any valid oracle transition using a correct answer, we have
Φ t x ( C t ) ≤ Φ t − 1 x ( C t − 1 ) . (6) \Phi_t^x(C_t) \le\Phi_{t-1}^x(C_{t-1}). \tag*{(6)} Φ t x ( C t ) ≤ Φ t − 1 x ( C t − 1 ) . (6)
Indeed, a genuine execution reaching C t − 1 C_{t-1} C t − 1 can be extended by this transition. Also,
Φ 0 x ( C i n i t ( x ) ) = 0 , \Phi_0^x(C_{\mathrm{init}}(x))=0, Φ 0 x ( C init ( x )) = 0 ,
and, if x ∉ L M O x \notin L_M^O x ∈ / L M O , then Φ T x ( C ) = 1 \Phi_T^x(C)=1 Φ T x ( C ) = 1 for every accepting configuration C C C .15
Fix a polynomial-size oracle adversary A d v \mathsf{Adv} Adv . For a , b ∈ [ T ] a,b \in[T] a , b ∈ [ T ] , let H a , b H_{a,b} H a , b be the experiment in which the two seBARG components have extraction indices a a a and b b b . Everything else, including the distribution of the oracle’s signing key, is unchanged. Let E E E be the event that the adversary outputs a false statement and both public verification checks accept. Thus the soundness error in the real experiment is Pr H 1 , 1 [ E ] \Pr_{H_{1,1}}[E] Pr H 1 , 1 [ E ] .
In H t , t H_{t,t} H t , t , extract the witness from the first component and denote its configurations by ( C ^ t − 1 , C ^ t ) (\widehat{C}_{t-1},\widehat{C}_t) ( C t − 1 , C t ) . Set
F t − = E H t , t [ 1 E ⋅ Φ t − 1 x ( C ^ t − 1 ) ] , F t + = E H t , t [ 1 E ⋅ Φ t x ( C ^ t ) ] . F_t^-=\mathbb{E}_{H_{t,t}}\left[1_E\cdot\Phi_{t-1}^x(\widehat{C}_{t-1})\right], \qquad F_t^+=\mathbb{E}_{H_{t,t}}\left[1_E\cdot\Phi_t^x(\widehat{C}_t)\right]. F t − = E H t , t [ 1 E ⋅ Φ t − 1 x ( C t − 1 ) ] , F t + = E H t , t [ 1 E ⋅ Φ t x ( C t ) ] .
Throughout the following argument, whenever an extracted witness fails its corresponding local relation R s i g R_{\mathrm{sig}} R sig , we set all potential contributions computed from that witness to zero. This convention is applied separately to each extracted witness.
Claim 29.
F t + − F t − ≤ negl ( λ ) . F_t^+ - F_t^- \le\operatorname{negl}(\lambda). F t + − F t − ≤ negl ( λ ) .
Proof of Theorem 29. Fix t ∈ [ T ] t \in[T] t ∈ [ T ] . In H t , t H_{t,t} H t , t , let B a d t \mathrm{Bad}_t Bad t be the event that the witness extracted from the first component is invalid. We first show that
Pr H t , t [ E ∧ B a d t ] ≤ negl ( λ ) . \Pr_{H_{t,t}}[E \wedge\mathrm{Bad}_t] \leq\operatorname{negl}(\lambda). H t , t Pr [ E ∧ Bad t ] ≤ negl ( λ ) .
By the somewhere argument of knowledge property of the seBARG (Theorem 11), and the fact that E E E implies that the first public verification check accepts, the probability that E E E occurs and the extracted witness is invalid is at most negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) , which is negl ( λ ) \operatorname{negl}(\lambda) negl ( λ ) .
To finish the claim, let W r o n g t \mathrm{Wrong}_t Wrong t be the event that ¬ B a d t \neg\mathrm{Bad}_t ¬ Bad t holds and the extracted witness contains an incorrect oracle answer. It remains to prove that
Pr H t , t [ W r o n g t ] ≤ negl ( λ ) . \Pr_{H_{t,t}}[\mathrm{Wrong}_t] \leq\operatorname{negl}(\lambda). H t , t Pr [ Wrong t ] ≤ negl ( λ ) .
This follows from the security of the underlying signature scheme, as follows. Suppose for the sake of contradiction that this event occurs with non-negligible probability δ ( λ ) \delta(\lambda) δ ( λ ) . We construct a forger that breaks the existential unforgeability of the underlying signature scheme. Specifically, the forger, given v k \mathrm{vk} vk , does the following:
Emulate S N A R G . G e n ( 1 λ , n , v k ) \mathrm{SNARG.Gen}(1^\lambda,n,\mathrm{vk}) SNARG.Gen ( 1 λ , n , vk ) to generate a hash key h k \mathrm{hk} hk and ( c r s b , t d b ) b ∈ { 1 , 2 } (\mathrm{crs}_b,\mathrm{td}_b)_{b\in\{1,2\}} ( crs b , td b ) b ∈ { 1 , 2 } , except that both seBARG components are generated with extraction index t t t rather than 1 1 1 . Retain both trapdoors, and let c r s = ( v k , h k , c r s 1 , c r s 2 ) \mathrm{crs}=(\mathrm{vk},\mathrm{hk},\mathrm{crs}_1,\mathrm{crs}_2) crs = ( vk , hk , crs 1 , crs 2 ) .
Run A d v ( c r s ) \mathrm{Adv}(\mathrm{crs}) Adv ( crs ) to generate ( x , π ) (x,\pi) ( x , π ) , where π = ( r t , π 1 , π 2 ) \pi=(\mathrm{rt},\pi_1,\pi_2) π = ( rt , π 1 , π 2 ) , while simulating each query u u u to O s i g \mathcal{O}_{\mathrm{sig}} O sig by querying O ( u ) \mathcal{O}(u) O ( u ) and requesting a signature on ( u , O ( u ) ) (u,\mathcal{O}(u)) ( u , O ( u )) from its signing oracle. Return the answer and signature to A d v \mathrm{Adv} Adv . Abort if the adversary’s output is malformed.
Extract w ∗ = s e B A R G . E x t r a c t ( t d 1 , π 1 ) w^*=\mathrm{seBARG.Extract}(\mathrm{td}_1,\pi_1) w ∗ = seBARG.Extract ( td 1 , π 1 ) .
Let z = ( v k , h k , x , r t ) z=(\mathrm{vk},\mathrm{hk},x,\mathrm{rt}) z = ( vk , hk , x , rt ) . If R s i g ( z , t , w ∗ ) = 1 R_{\mathrm{sig}}(z,t,w^*)=1 R sig ( z , t , w ∗ ) = 1 and this witness contains an incorrect oracle query/answer pair ( u , a ) (u,a) ( u , a ) along with a verifying signature σ \sigma σ , then output ( ( u , a ) , σ ) ((u,a),\sigma) (( u , a ) , σ ) . Otherwise, output ⊥ \perp ⊥ .
The forger simulates H t , t H_{t,t} H t , t exactly. Note that the message ( u , a ) (u,a) ( u , a ) was never submitted to the signing oracle, since every submitted message contained a correct oracle answer, whereas a ≠ O ( u ) a \ne\mathcal{O}(u) a = O ( u ) . Moreover, the signature verifies by the validity of the extracted witness. Thus, whenever W r o n g t \mathrm{Wrong}_t Wrong t occurs, the forger outputs a valid forgery.
The forger runs in polynomial time in λ \lambda λ under the stated polynomial bounds on n n n , T T T , S S S . In particular, it does not compute E E E or the reachability potential. Its success probability is therefore δ ( λ ) \delta(\lambda) δ ( λ ) , contradicting existential unforgeability even given access to O \mathcal{O} O . This proves the claimed bound on Pr H t , t [ W r o n g t ] \Pr_{H_{t,t}}[\mathrm{Wrong}_t] Pr H t , t [ Wrong t ] .
On a valid extracted witness outside W r o n g t \mathrm{Wrong}_t Wrong t , the transition is either a valid ordinary transition or a valid oracle transition using the correct answer. By Equation (6) , the potential cannot increase. On an invalid extracted witness, both potential contributions are zero by our convention. Since the potential lies in [ 0 , 1 ] [0,1] [ 0 , 1 ] , we conclude that
F t + − F t − ≤ Pr H t , t [ E ∧ W r o n g t ] ≤ Pr H t , t [ W r o n g t ] ≤ negl ( λ ) , F_t^{+}-F_t^{-} \leq\Pr_{H_{t,t}}[E \wedge\mathrm{Wrong}_t] \leq\Pr_{H_{t,t}}[\mathrm{Wrong}_t] \leq\operatorname{negl}(\lambda), F t + − F t − ≤ H t , t Pr [ E ∧ Wrong t ] ≤ H t , t Pr [ Wrong t ] ≤ negl ( λ ) ,
as desired.
Claim 30. For every t < T t<T t < T ,
∣ F t + − F t + 1 − ∣ ≤ negl ( λ ) . \left|F_t^+ - F_{t+1}^-\right| \le\operatorname{negl}(\lambda). F t + − F t + 1 − ≤ negl ( λ ) .
Proof of Theorem 30. Fix 1 ≤ t < T 1\le t<T 1 ≤ t < T . Start with F t + F_t^+ F t + and modify it by taking the expectation over H t , t + 1 H_{t,t+1} H t , t + 1 , as opposed to over H t , t H_{t,t} H t , t , while continuing to compute the potential using the witness from the first component. Note that both E E E and this potential contribution can be computed without the trapdoor of the second component. Moreover, they can be computed in time poly ( T ∗ ) \operatorname{poly}(T^*) poly ( T ∗ ) with oracle access to O \mathcal{O} O . The signed oracle can be simulated using O \mathcal{O} O and an independently generated signing key. Since the weighted potential lies in [ 0 , 1 ] [0,1] [ 0 , 1 ] , the T ∗ T^* T ∗ -index hiding property implies that this changes the expectation by at most negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) .
In H t , t + 1 H_{t,t+1} H t , t + 1 , the witness from the first component opens the configuration after step t t t , and the witness from the second component opens the configuration before step t + 1 t+1 t + 1 . Both therefore open the t t t th configuration. Let Bad be the event that either extracted witness is invalid, or that both are valid but open different configurations at this position. Since E E E implies that both public verification checks accept, the T ∗ T^* T ∗ -somewhere argument of knowledge property and T ∗ T^* T ∗ -collision resistance with respect to opening imply
Pr H t , t + 1 [ E ∧ B a d ] ≤ negl ( T ∗ ) . \underset{H_{t,t+1}}{\Pr}\left[E\land\mathrm{Bad}\right]\le\operatorname{negl}(T^*). H t , t + 1 Pr [ E ∧ Bad ] ≤ negl ( T ∗ ) .
Indeed, two valid witnesses opening different configurations at the same position give a collision with respect to opening. On E ∧ ¬ B a d E\land\neg\mathrm{Bad} E ∧ ¬ Bad , the two witnesses give the same value of Φ x T \Phi_{x}^{\mathsf{T}} Φ x T . We may therefore compute the 1 E 1_E 1 E -weighted potential using the witness from the second component instead, changing its expectation by at most
Pr H t , t + 1 [ E ∧ B a d ] ≤ negl ( T ∗ ) . \underset{H_{t,t+1}}{\Pr}\left[E\land\mathrm{Bad}\right]\le\operatorname{negl}(T^*). H t , t + 1 Pr [ E ∧ Bad ] ≤ negl ( T ∗ ) .
Next, change the extraction index in the first component from t t t to t + 1 t+1 t + 1 , while continuing to compute the potential using the witness from the second component. Since the weighted potential does not use the trapdoor of the first component, index hiding again preserves its expectation up to an additive negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) term.
In H t + 1 , t + 1 H_{t+1,t+1} H t + 1 , t + 1 , both extracted witnesses open the configuration immediately before step t + 1 t+1 t + 1 . By the same extraction-validity and collision-resistance argument, we may use the witness from the first component again, changing the weighted expectation by at most negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) . The resulting expectation is F t + 1 − F_{t+1}^- F t + 1 − . Summing the negligible additive differences, and using the fact that T ∗ ≥ λ T^*\ge\lambda T ∗ ≥ λ , gives
∣ F t + − F t + 1 − ∣ ≤ negl ( λ ) , \left|F_t^+ - F_{t+1}^-\right|\le\operatorname{negl}(\lambda), F t + − F t + 1 − ≤ negl ( λ ) ,
as desired.
These index-hiding reductions compute E E E and the reachability potential, and hence may take time poly ( T ∗ ) \operatorname{poly}(T^*) poly ( T ∗ ) . This is why we instantiate the hash family and seBARG with the stated security parameter. Their oracle queries can be simulated using O \mathcal{O} O and an independently generated signing key.
The initial and terminal checks give
F 1 − ≤ negl ( λ ) , F T + ≥ Pr H T , T [ E ] − negl ( λ ) . F_1^-\le\operatorname{negl}(\lambda),\qquad F_T^+\ge\underset{H_{T,T}}{\Pr}[E]-\operatorname{negl}(\lambda). F 1 − ≤ negl ( λ ) , F T + ≥ H T , T Pr [ E ] − negl ( λ ) .
Telescoping the equations in Theorem 29 and Theorem 30 therefore gives
Pr H T , T [ E ] ≤ O ( T ) ⋅ negl ( λ ) = negl ( λ ) . \underset{H_{T,T}}{\Pr}[E]\le O(T)\cdot\operatorname{negl}(\lambda)=\operatorname{negl}(\lambda). H T , T Pr [ E ] ≤ O ( T ) ⋅ negl ( λ ) = negl ( λ ) .
Finally, index hiding lets us change both extraction indices from T T T back to 1 1 1 , preserving Pr [ E ] \Pr[E] Pr [ E ] up to a negligible additive term. This proves adaptive soundness.
Efficiency. A local witness contains two configurations, their openings, and at most one signature. Thus
m = poly ( κ , S , log T ) . m = \operatorname{poly}(\kappa, S, \log T). m = poly ( κ , S , log T ) .
The common input has length n + poly ( κ , S , log T ) n+\operatorname{poly}(\kappa, S, \log T) n + poly ( κ , S , log T ) . The efficiency bounds from § 4.4 , together with κ = poly ( λ , S , log T ) \kappa= \operatorname{poly}(\lambda, S, \log T) κ = poly ( λ , S , log T ) , give the claimed parameter lengths and verification time. There are only two seBARG components. Neither setup nor verification queries the oracle, and the honest prover obtains one signature per oracle call in its execution.
A Fully Succinct Variant for Deterministic Computations
For deterministic computations we can avoid the dependence on S S S . We start by assuming that the oracle queries and answers are short. Specifically, let M M M be a deterministic Turing machine running in time bounded by T T T , and let ℓ ≤ T \ell\le T ℓ ≤ T be a public bound on the bit lengths of the queries and answers occurring in executions of M O M^{O} M O . We assume that
ℓ = poly ( λ , log T ) . \ell= \operatorname{poly}(\lambda, \log T). ℓ = poly ( λ , log T ) .
We later show how to avoid this assumption (see Theorem 38). We use the signed oracle from Theorem 25, which signs each query/answer pair.
Theorem 31. Let M M M be a deterministic oracle-aided machine with time bound T T T , and oracle-query bound Q ≤ T Q \le T Q ≤ T , whose queries and answers have bit length at most ℓ = poly ( λ , log T ) \ell= \operatorname{poly}(\lambda, \log T) ℓ = poly ( λ , log T ) . Let O s i g O_{\mathrm{sig}} O sig be a signed oracle as in Theorem 25, with the security parameter κ s i g = poly ( λ , log T ) \kappa_{\mathrm{sig}} = \operatorname{poly}(\lambda, \log T) κ sig = poly ( λ , log T ) . There exists a (publicly verifiable) SNARG for M O M^{O} M O , whose public parameters and proof have length poly ( λ , log T ) \operatorname{poly}(\lambda, \log T) poly ( λ , log T ) , and the verifier runs in time n ⋅ poly ( λ , log T ) n \cdot\operatorname{poly}(\lambda, \log T) n ⋅ poly ( λ , log T ) and makes no oracle calls. Setup also makes no oracle calls. The prover makes at most Q Q Q calls to O s i g O_{\mathrm{sig}} O sig and runs in time poly ( λ , T ) \operatorname{poly}(\lambda, T) poly ( λ , T ) .16 For polynomially bounded T T T the SNARG is adaptively sound assuming that LWE is polynomially hard even given oracle access to O O O . For larger T T T , the SNARG is adaptively sound assuming that LWE is poly ( T ) \operatorname{poly}(T) poly ( T ) -hard even given oracle access to O O O .
We next give the fully succinct SNARG construction. For simplicity, and without loss of generality, we assume that the query and answer tapes each consist of ℓ \ell ℓ cells throughout the execution; any additional information is kept on the work tape. In particular, before each oracle query, the query tape contains only the query, which is of length ℓ \ell ℓ , and after each oracle call the answer tape contains only the answer, which is also of length ℓ \ell ℓ .
Our Construction
As in § 6.2 and Section 5, our construction makes use of the following ingredients:
H T = ( H T . G e n , H T . H a s h , H T . O p e n , H T . V e r i f y ) . \mathrm{HT} = (\mathrm{HT.Gen}, \mathrm{HT.Hash}, \mathrm{HT.Open}, \mathrm{HT.Verify}). HT = ( HT.Gen , HT.Hash , HT.Open , HT.Verify ) .
s e B A R G = ( s e B A R G . G e n , s e B A R G . P , s e B A R G . V , s e B A R G . E x t r a c t ) . \mathsf{seBARG}=(\mathsf{seBARG}.\mathsf{Gen},\mathsf{seBARG}.\mathcal{P},\mathsf{seBARG}.\mathcal{V},\mathsf{seBARG}.\mathsf{Extract}). seBARG = ( seBARG . Gen , seBARG . P , seBARG . V , seBARG . Extract ) .
However, our construction requires the hash function HT to have the following additional property:
Definition 32 (Verification of local updates). For x ∈ { 0 , 1 } N x \in\{0,1\}^{N} x ∈ { 0 , 1 } N , j ∈ [ N ] j \in[N] j ∈ [ N ] , and b ′ ∈ { 0 , 1 } b' \in\{0,1\} b ′ ∈ { 0 , 1 } , let x [ j ← b ′ ] x[j \leftarrow b'] x [ j ← b ′ ] denote the string obtained from x x x by replacing its j j j th bit by b ′ b' b ′ . We say that HT supports succinct verification of local updates if it additionally provides a deterministic algorithm
H T . V e r i f y U p d a t e ( h k , r t , r t ′ , j , b , b ′ , ρ ) ⟶ { 0 , 1 } . \mathrm{HT.VerifyUpdate}(\mathrm{hk},\mathrm{rt},\mathrm{rt}',j,b,b',\rho)\longrightarrow\{0,1\}. HT.VerifyUpdate ( hk , rt , rt ′ , j , b , b ′ , ρ ) ⟶ { 0 , 1 } . Here r t \mathrm{rt} rt and r t ′ \mathrm{rt}' rt ′ are the old and new hash values, b b b and b ′ b' b ′ are the old and new bits at position j j j , and ρ \rho ρ is a local opening. The string length N N N is public and implicit in the verification algorithm. We require the following properties.
Update completeness. For every λ ∈ N \lambda\in\mathbb{N} λ ∈ N , N ≤ 2 λ N \le2^\lambda N ≤ 2 λ , x ∈ { 0 , 1 } N x \in\{0,1\}^{N} x ∈ { 0 , 1 } N , j ∈ [ N ] j \in[N] j ∈ [ N ] , and b ′ ∈ { 0 , 1 } b' \in\{0,1\} b ′ ∈ { 0 , 1 } , let
h k ← H T . G e n ( 1 λ ) and set \mathrm{hk} \leftarrow\mathrm{HT.Gen}(1^\lambda)\quad\text{and set} hk ← HT.Gen ( 1 λ ) and set r t = H T . H a s h ( h k , x ) , \mathrm{rt}=\mathrm{HT.Hash}(\mathrm{hk},x), rt = HT.Hash ( hk , x ) , r t ′ = H T . H a s h ( h k , x [ j ← b ′ ] ) , \mathrm{rt}'=\mathrm{HT.Hash}(\mathrm{hk},x[j\leftarrow b']), rt ′ = HT.Hash ( hk , x [ j ← b ′ ]) , ρ = H T . O p e n ( h k , x , j ) . \rho=\mathrm{HT.Open}(\mathrm{hk},x,j). ρ = HT.Open ( hk , x , j ) . Then, with probability one,
H T . V e r i f y U p d a t e ( h k , r t , r t ′ , j , x j , b ′ , ρ ) = 1. \mathrm{HT.VerifyUpdate}(\mathrm{hk},\mathrm{rt},\mathrm{rt}',j,x_j,b',\rho)=1. HT.VerifyUpdate ( hk , rt , rt ′ , j , x j , b ′ , ρ ) = 1. Succinctness. The update check uses the ordinary local opening ρ \rho ρ and runs in time poly ( λ , log N ) \operatorname{poly}(\lambda,\log N) poly ( λ , log N ) , without receiving either of the underlying strings. The opening length satisfies the succinctness requirement of HT.
Update soundness. For every polynomial-size adversary A \mathcal{A} A , there exists a negligible function negl \operatorname{negl} negl such that, in the experiment
h k ← H T . G e n ( 1 λ ) , \mathrm{hk}\leftarrow\mathrm{HT.Gen}(1^\lambda), hk ← HT.Gen ( 1 λ ) , ( x , j , b , b ′ , r t ′ , ρ ) ← A ( h k ) , (x,j,b,b',\mathrm{rt}',\rho)\leftarrow\mathcal{A}(\mathrm{hk}), ( x , j , b , b ′ , rt ′ , ρ ) ← A ( hk ) , r t = H T . H a s h ( h k , x ) , \mathrm{rt}=\mathrm{HT.Hash}(\mathrm{hk},x), rt = HT.Hash ( hk , x ) , we have
Pr [ H T . V e r i f y U p d a t e ( h k , r t , r t ′ , j , b , b ′ , ρ ) = 1 ∧ ( b ≠ x j ∨ r t ′ ≠ H T . H a s h ( h k , x [ j ← b ′ ] ) ) ] ≤ negl ( λ ) . \Pr\left[
\begin{aligned}
&\mathrm{HT.VerifyUpdate}(\mathrm{hk},\mathrm{rt},\mathrm{rt}',j,b,b',\rho)=1\\
&\land\left(b\ne x_j\lor\mathrm{rt}'\ne\mathrm{HT.Hash}(\mathrm{hk},x[j\leftarrow b'])\right)
\end{aligned}
\right]\le\operatorname{negl}(\lambda). Pr [ HT.VerifyUpdate ( hk , rt , rt ′ , j , b , b ′ , ρ ) = 1 ∧ ( b = x j ∨ rt ′ = HT.Hash ( hk , x [ j ← b ′ ]) ) ] ≤ negl ( λ ) .
The Merkle-tree construction satisfies these requirements assuming the existence of a collision resistant hash function. The update checker verifies the old root using ρ \rho ρ , and checks the new root using the same authentication path with the leaf changed from b b b to b ′ b' b ′ . An accepted incorrect update from the hash of x x x yields a collision by comparison with the honest path for x x x .
Remark 33. In the oracle-aided setting, update soundness is required to hold even for adversaries with access to O O O .
As in § 6.2 , we first take n , T n,T n , T to be polynomially bounded in λ \lambda λ , with T ≥ n T \ge n T ≥ n , and set κ = λ \kappa= \lambda κ = λ . In contrast to the preceding constructions, polynomial security of our primitives suffices here. All security properties, including update soundness, are required to hold even given access to O O O .
Definition 35 (Compressed configurations). A compressed configuration C ~ \widetilde{C} C consists of the machine state, head positions, oracle-call counter, the full contents of the query and answer tapes, and a hash of the work tape, using the hash function with local opening H T \mathrm{HT} HT . By our simplifying assumption, the two explicit query and answer tapes each have ℓ \ell ℓ cells. The read-only input x x x remains part of the common input.
The local relation R s h o r t R_{\mathrm{short}} R short . Let v k \mathrm{vk} vk be the oracle’s verification key, let h k \mathrm{hk} hk be a key for H T \mathrm{HT} HT , and let r t \mathrm{rt} rt be a purported hash of a sequence of compressed configurations. An instance of the oracle-free relation R s h o r t R_{\mathrm{short}} R short is of the form ( z , i ) (z,i) ( z , i ) , where i ∈ [ T ] i \in[T] i ∈ [ T ] and
z = ( v k , h k , x , r t ) . z = (\mathrm{vk},\mathrm{hk},x,\mathrm{rt}). z = ( vk , hk , x , rt ) .
A corresponding witness is of the form
w i = ( C ~ i − 1 , C ~ i , ρ i , η i ) , w_i = (\widetilde{C}_{i-1},\widetilde{C}_i,\rho_i,\eta_i), w i = ( C i − 1 , C i , ρ i , η i ) ,
where ρ i \rho_i ρ i contains the transcript openings and η i \eta_i η i contains the information needed to check the transition. The relation R s h o r t R_{\mathrm{short}} R short checks the following:
The opening ρ i \rho_i ρ i authenticates ( C ~ i − 1 , C ~ i ) (\widetilde{C}_{i-1},\widetilde{C}_i) ( C i − 1 , C i ) at their prescribed positions with respect to the hash value r t \mathrm{rt} rt , under the hash key h k \mathrm{hk} hk .
If this is an ordinary step, let r t i − 1 , r t i \mathrm{rt}_{i-1},\mathrm{rt}_i rt i − 1 , rt i be the work-tape hash values in C ~ i − 1 , C ~ i \widetilde{C}_{i-1},\widetilde{C}_i C i − 1 , C i , respectively, and let j j j be the work-tape head position in C ~ i − 1 \widetilde{C}_{i-1} C i − 1 . In this case, η i = ( b , ρ ) \eta_i=(b,\rho) η i = ( b , ρ ) contains the bit read from the work tape and its local opening. The relation R s h o r t R_{\mathrm{short}} R short checks that
H T . V e r i f y ( h k , r t i − 1 , j , b , ρ ) = 1. \mathrm{HT}.\mathrm{Verify}(\mathrm{hk},\mathrm{rt}_{i-1},j,b,\rho)=1. HT . Verify ( hk , rt i − 1 , j , b , ρ ) = 1.
Using b b b , the input x x x , and the explicit fields of C ~ i − 1 \widetilde{C}_{i-1} C i − 1 , it determines the prescribed ordinary transition of M M M . It checks that all explicit fields of C ~ i \widetilde{C}_i C i follow this transition, including the machine state, head positions, and contents of the query and answer tapes. In particular, cells of these explicit tapes that are not written remain unchanged, and the oracle-call counter does not change.
If the transition writes a bit b ′ b' b ′ to work-tape position j j j , the relation additionally checks that
H T . V e r i f y U p d a t e ( h k , r t i − 1 , r t i , j , b , b ′ , ρ ) = 1. \mathrm{HT}.\mathrm{VerifyUpdate}(\mathrm{hk},\mathrm{rt}_{i-1},\mathrm{rt}_i,j,b,b',\rho)=1. HT . VerifyUpdate ( hk , rt i − 1 , rt i , j , b , b ′ , ρ ) = 1.
where b ′ b' b ′ is the bit prescribed by the transition. If the transition does not write to the work tape, it instead checks that r t i − 1 = r t i \mathrm{rt}_{i-1}=\mathrm{rt}_i rt i − 1 = rt i .
If this is an oracle step, η i \eta_i η i contains a signature σ i \sigma_i σ i . The relation R s h o r t R_{\mathrm{short}} R short checks that the work-tape hash values in C ~ i − 1 \widetilde{C}_{i-1} C i − 1 and C ~ i \widetilde{C}_i C i are identical, and that all explicit fields follow the prescribed oracle transition, using the answer in C ~ i \widetilde{C}_i C i . This includes the machine state, head positions, query and answer tapes, and oracle-call counter.
In addition, letting u i u_i u i be the query in C ~ i − 1 \widetilde{C}_{i-1} C i − 1 and a i a_i a i be the answer in C ~ i \widetilde{C}_i C i , the relation checks that
Sig.Verify ( v k , ( u i , a i ) , σ i ) = 1. \operatorname{Sig.Verify}(\mathrm{vk},(u_i,a_i),\sigma_i)=1. Sig.Verify ( vk , ( u i , a i ) , σ i ) = 1.
If i = 1 i=1 i = 1 , then C ~ 0 \widetilde{C}_0 C 0 is the prescribed initial compressed configuration. If i = T i=T i = T , then C ~ T \widetilde{C}_T C T is accepting.17
Note that the relation R s h o r t R_{\mathrm{short}} R short does not query O O O .
Let M s h o r t M_{\mathrm{short}} M short be the deterministic Turing machine that, on input ( z , i , w i ) (z,i,w_i) ( z , i , w i ) , checks whether w i w_i w i is a valid local witness for ( z , i ) (z,i) ( z , i ) according to R s h o r t R_{\mathrm{short}} R short . Let n l o c n_{\mathrm{loc}} n loc bound ∣ M s h o r t ∣ + ∣ z ∣ |M_{\mathrm{short}}|+|z| ∣ M short ∣ + ∣ z ∣ , let m m m bound the length of a local witness, and let T l o c T_{\mathrm{loc}} T loc bound the running time of M s h o r t M_{\mathrm{short}} M short .
We next describe our SNARG construction for the computation M O M^O M O , using the signed oracle O s i g O_{\mathrm{sig}} O sig .
SNARG.Gen: On input ( 1 λ , n , v k ) (1^\lambda,n,\mathrm{vk}) ( 1 λ , n , vk ) , do the following:
Generate
h k ← H T . G e n ( 1 κ ) hk \leftarrow\mathrm{HT.Gen}(1^\kappa) hk ← HT.Gen ( 1 κ ) .
For each b ∈ { 1 , 2 } b\in\{1,2\} b ∈ { 1 , 2 } , independently generate
( c r s b , t d b ) ← s e B A R G . G e n ( 1 κ , n l o c , 1 m , T , 1 ) (\mathrm{crs}_b,\mathrm{td}_b)\leftarrow\mathrm{seBARG.Gen}(1^\kappa,n_{\mathrm{loc}},1^m,T,1) ( crs b , td b ) ← seBARG.Gen ( 1 κ , n loc , 1 m , T , 1 ) .
Output c r s = ( v k , h k , c r s 1 , c r s 2 ) \mathrm{crs}=(\mathrm{vk},hk,\mathrm{crs}_1,\mathrm{crs}_2) crs = ( vk , hk , crs 1 , crs 2 ) . Discard both trapdoors.
SNARG.P: On input ( c r s , x ) (\mathrm{crs},x) ( crs , x ) , with access to O s i g O_{\mathrm{sig}} O sig , do the following:
Run the accepting execution of M O ( x ) M^O(x) M O ( x ) , obtaining the signatures for its oracle answers. Let τ ~ = ( C ~ 0 , … , C ~ T ) \widetilde{\tau}=(\widetilde{C}_0,\ldots,\widetilde{C}_T) τ = ( C 0 , … , C T ) be its compressed transcript.
Compute r t = H T . H a s h ( h k , τ ~ ) \mathrm{rt}=\mathrm{HT.Hash}(hk,\widetilde{\tau}) rt = HT.Hash ( hk , τ ) , and let z = ( v k , h k , x , r t ) z=(\mathrm{vk},hk,x,\mathrm{rt}) z = ( vk , hk , x , rt ) .
For every i ∈ [ T ] i\in[T] i ∈ [ T ] , compute the local witness w i w_i w i corresponding to ( z , i ) (z,i) ( z , i ) in R s h o r t R_{\mathrm{short}} R short .
For each b ∈ { 1 , 2 } b\in\{1,2\} b ∈ { 1 , 2 } , compute
π b = s e B A R G . P ( c r s b , M s h o r t , z , 1 T l o c , w 1 , … , w T ) \pi_b=\mathrm{seBARG.P}(\mathrm{crs}_b,M_{\mathrm{short}},z,1^{T_{\mathrm{loc}}},w_1,\ldots,w_T) π b = seBARG.P ( crs b , M short , z , 1 T loc , w 1 , … , w T ) .
Output π = ( r t , π 1 , π 2 ) \pi=(\mathrm{rt},\pi_1,\pi_2) π = ( rt , π 1 , π 2 ) .
SNARG.V: On input ( c r s , x , π ) (\mathrm{crs},x,\pi) ( crs , x , π ) , parse c r s = ( v k , h k , c r s 1 , c r s 2 ) \mathrm{crs}=(\mathrm{vk},hk,\mathrm{crs}_1,\mathrm{crs}_2) crs = ( vk , hk , crs 1 , crs 2 ) and π = ( r t , π 1 , π 2 ) \pi=(\mathrm{rt},\pi_1,\pi_2) π = ( rt , π 1 , π 2 ) , and let z = ( v k , h k , x , r t ) z=(\mathrm{vk},hk,x,\mathrm{rt}) z = ( vk , hk , x , rt ) . Accept if and only if, for each b ∈ { 1 , 2 } b\in\{1,2\} b ∈ { 1 , 2 } ,
s e B A R G . V ( c r s b , ( M s h o r t , z , T , T l o c ) , π b ) = 1. \mathrm{seBARG.V}(\mathrm{crs}_b,(M_{\mathrm{short}},z,T,T_{\mathrm{loc}}),\pi_b)=1. seBARG.V ( crs b , ( M short , z , T , T loc ) , π b ) = 1.
As in § 6.2 , the second seBARG component allows us to compare extractions at neighboring transitions in the analysis. Neither setup nor verification queries the oracle.
Analysis
In this section we prove that the SNARG construction from § 6.5.1 satisfies Theorem 31 .
Completeness. We first note that every honest local witness w i w_i w i is a valid witness for ( z , i ) (z,i) ( z , i ) with respect to the relation R s h o r t R_{\mathrm{short}} R short . This follows from opening completeness, updated opening completeness, correctness of the hash function with local openings, and signature correctness. Completeness therefore follows from seBARG completeness. The same reasoning holds when x x x is chosen after seeing the public parameters.
Adaptive soundness. For every input x x x , let
C ~ 0 x , … , C ~ T x \widetilde{C}^{x}_{0},\ldots,\widetilde{C}^{x}_{T} C 0 x , … , C T x
be the compressed configurations of the real execution of M O M^{\mathcal{O}} M O on input x x x , using the sampled hash key h k \mathsf{hk} hk . Since M M M is deterministic, these configurations and their underlying tapes can be computed in time poly ( λ , T ) \operatorname{poly}(\lambda,T) poly ( λ , T ) with access to O \mathcal{O} O . For every t ∈ { 0 , 1 , … , T } t \in\{0,1,\ldots,T\} t ∈ { 0 , 1 , … , T } , define
Ψ t x ( C ~ ) = 1 [ C ~ ≠ C ~ t x ] . \Psi^{x}_{t}(\widetilde{C}) = 1[\widetilde{C} \ne\widetilde{C}^{x}_{t}]. Ψ t x ( C ) = 1 [ C = C t x ] .
This potential is zero at the honest initial configuration. If x ∉ L M O x \notin L^{\mathcal{O}}_{M} x ∈ / L M O , then Ψ T x ( C ~ ) = 1 \Psi^{x}_{T}(\widetilde{C}) = 1 Ψ T x ( C ) = 1 for every accepting compressed configuration C ~ \widetilde{C} C .
Fix a polynomial-size oracle adversary A d v \mathsf{Adv} Adv . Define H a , b H_{a,b} H a , b and E E E as in § 6.4 , using R s h o r t R_{\mathrm{short}} R short . Namely, in H a , b H_{a,b} H a , b , the two seBARG components have extraction indices a a a and b b b , and E E E is the event that the adversary outputs a false statement and both public verification checks accept. Everything else is distributed as in the real experiment. The soundness error is Pr H 1 , 1 [ E ] \Pr_{H_{1,1}}[E] Pr H 1 , 1 [ E ] .
In H t , t H_{t,t} H t , t , extract the witness from the first component and denote its configurations by ( C ^ t − 1 , C ^ t ) (\widehat{C}_{t-1},\widehat{C}_{t}) ( C t − 1 , C t ) . Set
F t − = E H t , t [ 1 E ⋅ Ψ t − 1 x ( C ^ t − 1 ) ] , F t + = E H t , t [ 1 E ⋅ Ψ t x ( C ^ t ) ] . F^{-}_{t} = \mathbb{E}_{H_{t,t}}\left[1_{E}\cdot\Psi^{x}_{t-1}(\widehat{C}_{t-1})\right],
\qquad
F^{+}_{t} = \mathbb{E}_{H_{t,t}}\left[1_{E}\cdot\Psi^{x}_{t}(\widehat{C}_{t})\right]. F t − = E H t , t [ 1 E ⋅ Ψ t − 1 x ( C t − 1 ) ] , F t + = E H t , t [ 1 E ⋅ Ψ t x ( C t ) ] .
As before, all potential contributions from an invalid extracted witness are set to zero.
Bounding the increase in potential. Let D e p a r t t \mathrm{Depart}_{t} Depart t be the event in H t , t H_{t,t} H t , t that the extracted witness is valid, C ^ t − 1 = C ~ t − 1 x \widehat{C}_{t-1}=\widetilde{C}^{x}_{t-1} C t − 1 = C t − 1 x , and C ^ t ≠ C ~ t x \widehat{C}_{t}\ne\widetilde{C}^{x}_{t} C t = C t x . A valid witness can increase the potential only on this event.
Claim 36. There exists a negligible function negl \operatorname{negl} negl such that for every t ∈ [ T ] t \in[T] t ∈ [ T ] ,
Pr H t , t [ D e p a r t t ] = negl ( λ ) . \Pr_{H_{t,t}}[\mathrm{Depart}_{t}] = \operatorname{negl}(\lambda). H t , t Pr [ Depart t ] = negl ( λ ) .
Proof of Theorem 36 . Fix t ∈ [ T ] t \in[T] t ∈ [ T ] . On D e p a r t t \mathrm{Depart}_{t} Depart t , the extracted witness is valid and C ^ t − 1 = C ~ t − 1 x \widehat{C}_{t-1}=\widetilde{C}^{x}_{t-1} C t − 1 = C t − 1 x . Suppose first that this is an ordinary step. Let W W W be the contents of the work tape in the real execution at time t − 1 t-1 t − 1 , let j j j be its head position, and let ( b , ρ ) (b,\rho) ( b , ρ ) be the work-tape bit and opening in the extracted witness. Let r t − 1 , r t r_{t-1},r_t r t − 1 , r t be the work-tape hash values in C ^ t − 1 , C ^ t \widehat{C}_{t-1},\widehat{C}_{t} C t − 1 , C t , respectively. Since the preceding compressed configuration is honest,
r t − 1 = H T . H a s h ( h k , W ) . (7) r_{t-1}=\mathsf{HT.Hash}(\mathsf{hk},W). \tag*{(7)} r t − 1 = HT.Hash ( hk , W ) . (7)
If b ≠ W j b \ne W_j b = W j , then ρ \rho ρ and the honest opening H T . O p e n ( h k , W , j ) \mathrm{HT.Open}(\mathrm{hk}, W, j) HT.Open ( hk , W , j ) are two valid openings of different bits at position j j j under the same hash value. This violates collision resistance with respect to opening.
Otherwise, b = W j b = W_j b = W j . By determinism and the checks in Step 2 of R s h o r t R_{\mathrm{short}} R short , all explicit fields of C ^ t \widehat{C}_t C t agree with those of C ~ t \widetilde{C}_t C t . If the transition does not write to the work tape, the relation checks that r t = r t − 1 r_t = r_{t-1} r t = r t − 1 , so the work-tape hash value is also correct. If the transition writes a bit b ′ b' b ′ at position j j j , then b ′ b' b ′ is the bit written in the real execution, and the relation checks that
H T . V e r i f y U p d a t e ( h k , r t − 1 , r t , j , b , b ′ , ρ ) = 1. \mathrm{HT.VerifyUpdate}(\mathrm{hk}, r_{t-1}, r_t, j, b, b', \rho) = 1. HT.VerifyUpdate ( hk , r t − 1 , r t , j , b , b ′ , ρ ) = 1.
Thus, a departure in this case requires
r t ≠ H T . H a s h ( h k , W [ j ← b ′ ] ) . r_t \ne\mathrm{HT.Hash}(\mathrm{hk}, W[j \leftarrow b']). r t = HT.Hash ( hk , W [ j ← b ′ ]) .
which violates update soundness (Theorem 32). Consequently, every ordinary-step departure gives either a collision with respect to opening or a violation of update soundness.
At an oracle step, the preceding configuration explicitly contains the honest query u u u . If the following answer is O ( u ) \mathcal{O}(u) O ( u ) , the transition checks force the honest next compressed configuration. Thus a departure gives an answer a a a and a signature σ \sigma σ such that
a ≠ O ( u ) and Sig.Verify ( v k , ( u , a ) , σ ) = 1. a \ne\mathcal{O}(u) \quad\text{and} \quad\operatorname{Sig.Verify}(\mathrm{vk}, (u,a), \sigma) = 1. a = O ( u ) and Sig.Verify ( vk , ( u , a ) , σ ) = 1.
We next formalize the reductions. For either of the two hash-security reductions, take h k \mathrm{hk} hk from the corresponding security experiment and independently generate the oracle’s signing key pair. Generate both seBARG components with extraction index t t t , retaining their trapdoors, and run Adv on the resulting public parameters. Simulate each signed-oracle query v v v by computing O ( v ) \mathcal{O}(v) O ( v ) and signing ( v , O ( v ) ) (v,\mathcal{O}(v)) ( v , O ( v )) using the generated signing key. Extract the witness from the first component, check its validity, and run M O ( x ) M^{\mathcal{O}}(x) M O ( x ) to compute the real configurations and work tapes.
This simulates H t , t H_{t,t} H t , t exactly. In the first ordinary-step case above, the opening-binding reduction outputs the two conflicting openings. In the second case, the update-soundness reduction outputs
( W , j , b , b ′ , r t , ρ ) . (W, j, b, b', r_t, \rho). ( W , j , b , b ′ , r t , ρ ) .
Since r t − 1 = H T . H a s h ( h k , W ) r_{t-1} = \mathrm{HT.Hash}(\mathrm{hk}, W) r t − 1 = HT.Hash ( hk , W ) , this is an accepted incorrect update in the experiment of Theorem 32. Thus each of these two cases has negligible probability. Notice that W W W is obtained by running the real computation; the reductions do not extract an arbitrary work tape from its hash.
For the signature reduction, take v k \mathrm{vk} vk from the unforgeability experiment, and generate h k \mathrm{hk} hk and both seBARG components internally, again with extraction index t t t . As in the proof of Theorem 29, simulate each signed-oracle query v v v by requesting a signature on ( v , O ( v ) ) (v,\mathcal{O}(v)) ( v , O ( v )) . If the extracted witness is valid and contains an incorrect oracle answer a a a to a query u u u , output its signature σ \sigma σ on ( u , a ) (u,a) ( u , a ) . This signature verifies, and ( u , a ) (u,a) ( u , a ) was never submitted to the signing oracle, since a ≠ O ( u ) a \ne\mathcal{O}(u) a = O ( u ) . Hence the probability of an oracle-step departure is negligible.
All these reductions run in time poly ( λ , T ) \operatorname{poly}(\lambda,T) poly ( λ , T ) with access to O \mathcal{O} O , which is polynomial in λ \lambda λ under our assumption that T T T is polynomially bounded. The three cases exhaust Depart t \operatorname{Depart}_t Depart t , and therefore
Pr H t , t [ Depart t ] ≤ negl ( λ ) , \Pr_{H_{t,t}}[\operatorname{Depart}_t] \le\operatorname{negl}(\lambda), H t , t Pr [ Depart t ] ≤ negl ( λ ) ,
as desired.
Theorem 36 implies that
F t + − F t − ≤ Pr H t , t [ E ∧ D e p a r t t ] ≤ Pr H t , t [ D e p a r t t ] ≤ negl ( λ ) . F_t^{+} - F_t^{-} \le\Pr_{H_{t,t}}[E \land\mathsf{Depart}_t] \le\Pr_{H_{t,t}}[\mathsf{Depart}_t] \le\operatorname{negl}(\lambda). F t + − F t − ≤ H t , t Pr [ E ∧ Depart t ] ≤ H t , t Pr [ Depart t ] ≤ negl ( λ ) .
Claim 37. For every t < T t<T t < T ,
∣ F t + − F t + 1 − ∣ ≤ negl ( λ ) . \lvert F_t^{+} - F_{t+1}^{-}\rvert\le\operatorname{negl}(\lambda). ∣ F t + − F t + 1 − ∣ ≤ negl ( λ ) .
Proof of Theorem 37. The proof of Theorem 37 is similar to the proof of Theorem 30. In each hybrid, where we switch between extracted witnesses, the probability that E E E occurs and either the witness is invalid or their transcript openings disagree at a common position, is negligible. This follows from the somewhere argument of knowledge property and collision resistance with respect to opening of H T \mathrm{HT} HT .
The index-hiding tests compute E E E and Ψ \Psi Ψ by running the real deterministic computation, in time poly ( λ , T ) \operatorname{poly}(\lambda,T) poly ( λ , T ) with access to O \mathcal{O} O . As before, each test uses only the trapdoor of the component whose index is not being changed, and the signed oracle is simulated using an independently generated signing key. Thus polynomial security suffices, and for every t < T t<T t < T ,
∣ F t + − F t + 1 − ∣ ≤ negl ( λ ) , \lvert F_t^{+} - F_{t+1}^{-}\rvert\le\operatorname{negl}(\lambda), ∣ F t + − F t + 1 − ∣ ≤ negl ( λ ) ,
as desired.
The initial and terminal checks, together with the somewhere argument of knowledge property, give
F 1 − = 0 , F T + ≥ Pr H T , T [ E ] − negl ( λ ) . F_1^{-}=0,\qquad F_T^{+}\ge\Pr_{H_{T,T}}[E]-\operatorname{negl}(\lambda). F 1 − = 0 , F T + ≥ H T , T Pr [ E ] − negl ( λ ) .
Telescoping yields
Pr H T , T [ E ] ≤ O ( T ) ⋅ negl ( λ ) = negl ( λ ) , \Pr_{H_{T,T}}[E]\le O(T)\cdot\operatorname{negl}(\lambda)=\operatorname{negl}(\lambda), H T , T Pr [ E ] ≤ O ( T ) ⋅ negl ( λ ) = negl ( λ ) ,
since T T T is polynomially bounded in λ \lambda λ . Finally, index hiding lets us change both extraction indices back to 1, preserving Pr [ E ] \Pr[E] Pr [ E ] up to a negligible additive term. This proves adaptive soundness without extracting an entire transcript or an arbitrary committed work tape.
Efficiency. A compressed configuration has length O ( ℓ ) + poly ( κ , log T ) O(\ell)+\operatorname{poly}(\kappa,\log T) O ( ℓ ) + poly ( κ , log T ) . A local witness contains two such configurations, their transcript openings, and either a constant number of work-tape authentication paths or one signature. Thus
m = poly ( κ , ℓ , log T ) = poly ( λ , log T ) . m=\operatorname{poly}(\kappa,\ell,\log T)=\operatorname{poly}(\lambda,\log T). m = poly ( κ , ℓ , log T ) = poly ( λ , log T ) .
The common input has length n + poly ( λ , log T ) n+\operatorname{poly}(\lambda,\log T) n + poly ( λ , log T ) ; the local relation takes time poly ( n , λ , ℓ , log T ) \operatorname{poly}(n,\lambda,\ell,\log T) poly ( n , λ , ℓ , log T ) . The seBARG efficiency bounds give public parameters and proof length poly ( λ , log T ) \operatorname{poly}(\lambda,\log T) poly ( λ , log T ) and verification time n ⋅ poly ( λ , log T ) n\cdot\operatorname{poly}(\lambda,\log T) n ⋅ poly ( λ , log T ) . The prover runs in time poly ( λ , T ) \operatorname{poly}(\lambda,T) poly ( λ , T ) and makes at most Q Q Q calls to O s i g \mathcal{O}_{\mathrm{sig}} O sig , obtaining one signature per oracle call. Setup and verification are oracle-free. None of the reductions enumerates the configuration graph, so no security parameter depending on S S S is needed.
Larger time bounds. For super-polynomial T T T , the same argument requires the security properties of HT, seBARG, and Sig against poly ( λ , T ) \operatorname{poly}(\lambda,T) poly ( λ , T ) -time algorithms, with errors negligible in T T T . If these guarantees are available with underlying security parameter κ = poly ( λ , log T ) \kappa= \operatorname{poly}(\lambda,\log T) κ = poly ( λ , log T ) then the stated succinctness bounds are preserved. For the non-deterministic construction in § 6.2 , the hash family HT and the seBARG must additionally withstand the poly ( 2 S , n , T , λ ) \operatorname{poly}(2^{S},n,T,\lambda) poly ( 2 S , n , T , λ ) -time reachability reductions. Ordinary polynomial security alone does not justify either extension to super-polynomial time bounds.
Incrementally Verifiable Computations
In this section we define the notion of IVC for oracle-aided computations and provide constructions. We provide two definitions: The first is for signed-oracles and is publicly verifiable. It is essentially the standard notion of IVC, except that the prover may use authenticated oracle responses. The second considers general, unsigned oracles. In this case verification is private, and soundness is required only for robust computations.
Definitions
Definitions
Fix an oracle-aided Turing machine M M M (deterministic or non-deterministic) with time bound T T T and space bound S S S , and an oracle O \mathcal{O} O . For an input x x x , let C i n i t ( x ) C_{\mathrm{init}}(x) C init ( x ) denote the initial configuration, and let Reach t O ( x ) \operatorname{Reach}^{\mathcal{O}}_{t}(x) Reach t O ( x ) be the set of configurations reachable after exactly t t t steps of M O M^{\mathcal{O}} M O on x x x .18
As in § 5 , Theorem 15, throughout § 7 , we assume that every configuration C C C includes a step counter time ( C ) \operatorname{time}(C) time ( C ) and an oracle-call counter queries ( C ) \operatorname{queries}(C) queries ( C ) . Both counters are zero in C i n i t ( x ) C_{\mathrm{init}}(x) C init ( x ) . At every transition, the step counter increases by one. The oracle-call counter increases by one at an oracle transition and remains unchanged at an ordinary transition. These counter updates are part of the transition rules and are required also in purported executions, regardless of whether the oracle answers are correct.
Definition 39 (Publicly verifiable IVC for signed oracles). Let O s i g \mathcal{O}_{\mathrm{sig}} O sig be a signed oracle associated with oracle O \mathcal{O} O with verification key v k \mathrm{vk} vk , as in Definition 25 . A publicly verifiable IVC scheme for M O M^{\mathcal{O}} M O consists of algorithms
( I V C . G e n , I V C . U p d a t e , I V C . V ) (\mathrm{IVC.Gen},\mathrm{IVC.Update},\mathrm{IVC.V}) ( IVC.Gen , IVC.Update , IVC.V ) with the following syntax.
I V C . G e n ( 1 λ , n , T , v k ) ⟶ c r s \mathrm{IVC.Gen}(1^\lambda, n, T, \mathrm{vk}) \longrightarrow\mathrm{crs} IVC.Gen ( 1 λ , n , T , vk ) ⟶ crs . The randomized setup algorithm outputs a common reference string c r s \mathrm{crs} crs , which includes the authenticated key v k \mathrm{vk} vk . Here n n n is the input length, and T T T is a bound on the runtime, both represented in binary.
I V C . G e n \mathrm{IVC.Gen} IVC.Gen does not query the oracle.
I V C . U p d a t e O s i g ( c r s , x , t , C t , π t , w t + 1 ) ⟶ ( C t + 1 , π t + 1 ) \mathrm{IVC.Update}^{\mathcal{O}_{\mathrm{sig}}}(\mathrm{crs}, x, t, C_t, \pi_t, w_{t+1}) \longrightarrow(C_{t+1}, \pi_{t+1}) IVC.Update O sig ( crs , x , t , C t , π t , w t + 1 ) ⟶ ( C t + 1 , π t + 1 ) . The prover is given the c r s \mathrm{crs} crs , input x x x , time t t t , configuration C t C_t C t , its proof π t \pi_t π t , and a local witness w t + 1 w_{t+1} w t + 1 . The witness specifies the non-deterministic choice, if any, and may also contain auxiliary information needed to compute the next configuration, such as authentication openings. The algorithm outputs the next configuration C t + 1 C_{t+1} C t + 1 and an updated proof π t + 1 \pi_{t+1} π t + 1 . Initially, C 0 = C i n i t ( x ) C_0 = C_{\mathrm{init}}(x) C 0 = C init ( x ) and π 0 = ⊥ \pi_0 = \perp π 0 =⊥ .
I V C . V ( c r s , x , t , C t , π t ) ⟶ { 0 , 1 } \mathrm{IVC.V}(\mathrm{crs}, x, t, C_t, \pi_t) \longrightarrow\{0,1\} IVC.V ( crs , x , t , C t , π t ) ⟶ { 0 , 1 } . The verifier checks the claim that C t C_t C t is reachable after t t t steps of M O M^{\mathcal{O}} M O on input x x x . It uses no private verification key and makes no oracle calls.
The following properties are required, where κ s i g = poly ( λ , log T ) \kappa_{\mathrm{sig}} = \operatorname{poly}(\lambda, \log T) κ sig = poly ( λ , log T ) denotes the security parameter of the underlying signature scheme, as in Theorem 26.
( v k , s k ) ← S i g . G e n ( 1 κ s i g ) , c r s ← I V C . G e n ( 1 λ , n , T , v k ) . (\mathrm{vk},\mathrm{sk}) \gets\mathrm{Sig.Gen}(1^{\kappa_{\mathrm{sig}}}), \qquad\mathrm{crs} \gets\mathrm{IVC.Gen}(1^\lambda,n,T,\mathrm{vk}). ( vk , sk ) ← Sig.Gen ( 1 κ sig ) , crs ← IVC.Gen ( 1 λ , n , T , vk ) .
Let O s i g \mathcal{O}_{\mathrm{sig}} O sig be the corresponding signed oracle. Then for every poly-size circuit that takes as input c r s \mathrm{crs} crs and has oracle access to O s i g \mathcal{O}_{\mathrm{sig}} O sig , and outputs an instance x ∈ { 0 , 1 } n x \in\{0,1\}^{n} x ∈ { 0 , 1 } n , a time bound t ∈ { 0 , 1 , … , T } t \in\{0,1,\ldots,T\} t ∈ { 0 , 1 , … , T } , and a sequence of local witnesses w = ( w 1 , … , w t ) w = (w_1,\ldots,w_t) w = ( w 1 , … , w t ) corresponding to an honest execution ( C 0 , … , C t ) (C_0,\ldots,C_t) ( C 0 , … , C t ) , the following holds:
Starting with C 0 = C i n i t ( x ) C_0 = C_{\mathrm{init}}(x) C 0 = C init ( x ) and π 0 = ⊥ \pi_0 = \perp π 0 =⊥ , for every i ∈ [ t ] i \in[t] i ∈ [ t ] let
( C i , π i ) ← I V C . U p d a t e O s i g ( c r s , x , i − 1 , C i − 1 , π i − 1 , w i ) , (C_i,\pi_i) \gets\mathrm{IVC.Update}^{\mathcal{O}_{\mathrm{sig}}}(\mathrm{crs},x,i-1,C_{i-1},\pi_{i-1},w_i), ( C i , π i ) ← IVC.Update O sig ( crs , x , i − 1 , C i − 1 , π i − 1 , w i ) ,
where w i w_i w i specifies the corresponding transition. Then, for every i ∈ { 0 , … , t } i \in\{0,\ldots,t\} i ∈ { 0 , … , t } ,
Pr [ I V C . V ( c r s , x , i , C i , π i ) = 1 ] ≥ 1 − negl ( λ ) . \Pr[\mathrm{IVC.V}(\mathrm{crs},x,i,C_i,\pi_i)=1]\ge1-\operatorname{negl}(\lambda). Pr [ IVC.V ( crs , x , i , C i , π i ) = 1 ] ≥ 1 − negl ( λ ) .
( v k , s k ) ← S i g . G e n ( 1 κ s i g ) , (\mathrm{vk},\mathrm{sk})\leftarrow\mathrm{Sig.Gen}(1^{\kappa_{\mathrm{sig}}}), ( vk , sk ) ← Sig.Gen ( 1 κ sig ) ,
c r s ← I V C . G e n ( 1 λ , n , T , v k ) , \mathrm{crs}\leftarrow\mathrm{IVC.Gen}(1^\lambda,n,T,\mathrm{vk}), crs ← IVC.Gen ( 1 λ , n , T , vk ) ,
( x , t , C , π ) ← A O s i g ( c r s ) , (x,t,C,\pi)\leftarrow\mathcal{A}^{O_{\mathrm{sig}}}(\mathrm{crs}), ( x , t , C , π ) ← A O sig ( crs ) ,
where O s i g O_{\mathrm{sig}} O sig is defined using s k \mathrm{sk} sk as in Definition 25 , we have
Pr [ ∣ x ∣ = n , 0 ≤ t ≤ T , C ∉ Reach t O ( x ) , I V C . V ( c r s , x , t , C , π ) = 1 ] ≤ μ ( λ ) . \Pr\left[
\begin{array}{c}
|x|=n,\quad0\le t\le T,\\
C\notin\operatorname{Reach}^{O}_{t}(x),\\
\mathrm{IVC.V}(\mathrm{crs},x,t,C,\pi)=1
\end{array}
\right]\le\mu(\lambda). Pr ∣ x ∣ = n , 0 ≤ t ≤ T , C ∈ / Reach t O ( x ) , IVC.V ( crs , x , t , C , π ) = 1 ≤ μ ( λ ) .
The underlying oracle O O O is fixed independently of setup.
Efficiency. The lengths of c r s \mathrm{crs} crs and π t \pi_t π t , and the running time of setup, are bounded by poly ( λ , S , log T ) \operatorname{poly}(\lambda,S,\log T) poly ( λ , S , log T ) . Proof update and verification take time poly ( n , λ , S , log T ) \operatorname{poly}(n,\lambda,S,\log T) poly ( n , λ , S , log T ) , independently of the number of preceding steps, except through log T \log T log T . The verifier makes no oracle calls. We say that the scheme is fully succinct if these bounds have no dependence on S S S .
General Oracles. We next consider general oracles, without signatures. For any input x ∈ { 0 , 1 } n x\in\{0,1\}^n x ∈ { 0 , 1 } n , any time t ∈ { 0 , 1 , … , T } t\in\{0,1,\ldots,T\} t ∈ { 0 , 1 , … , T } , and any configuration C C C that is unreachable in time t t t on input x x x , we say that C C C is ε \varepsilon ε -robust at time t t t on input x x x (extending Theorem 17) if every purported execution τ \tau τ (Theorem 16) from C i n i t ( x ) C_{\mathrm{init}}(x) C init ( x ) to C C C in exactly t t t steps satisfies
err O ( τ ) ≥ ε q ( τ ) , \operatorname{err}_{O}(\tau)\ge\varepsilon q(\tau), err O ( τ ) ≥ εq ( τ ) ,
where q ( τ ) q(\tau) q ( τ ) denotes the number of oracle calls in τ \tau τ .
Definition 40 (Privately verifiable IVC for robust computations). A privately verifiable IVC scheme for ε \varepsilon ε -robust computations of M O M^{O} M O consists of algorithms
( I V C . G e n , I V C . U p d a t e , I V C . V ) (\mathrm{IVC.Gen},\mathrm{IVC.Update},\mathrm{IVC.V}) ( IVC.Gen , IVC.Update , IVC.V ) with the following syntax.
I V C . G e n ( 1 λ , n , T , ε ) ⟶ ( c r s , t d ) \mathrm{IVC.Gen}(1^\lambda,n,T,\varepsilon)\longrightarrow(\mathrm{crs},\mathrm{td}) IVC.Gen ( 1 λ , n , T , ε ) ⟶ ( crs , td ) . The randomized setup algorithm outputs a common reference string c r s \mathrm{crs} crs and a private verification key t d \mathrm{td} td .
I V C . G e n \mathrm{IVC.Gen} IVC.Gen does not query the oracle.
I V C . U p d a t e O ( c r s , x , t , C t , π t , w t + 1 ) ⟶ ( C t + 1 , π t + 1 ) \mathrm{IVC.Update}^{O}(\mathrm{crs},x,t,C_t,\pi_t,w_{t+1})\longrightarrow(C_{t+1},\pi_{t+1}) IVC.Update O ( crs , x , t , C t , π t , w t + 1 ) ⟶ ( C t + 1 , π t + 1 ) . The prover updates its proof as in Definition 39 , using the current configuration and the non-deterministic choice w t + 1 w_{t+1} w t + 1 , if any.
I V C . V O ( c r s , t d , x , t , C t , π t ) ⟶ { 0 , 1 } \mathrm{IVC.V}^{O}(\mathrm{crs},\mathrm{td},x,t,C_t,\pi_t)\longrightarrow\{0,1\} IVC.V O ( crs , td , x , t , C t , π t ) ⟶ { 0 , 1 } . The verifier checks the claim that C t C_t C t is reachable after t t t steps of M O M^{O} M O on input x x x , using its private verification key t d \mathrm{td} td and oracle access to O O O .
The following properties are required.
( c r s , t d ) ← I V C . G e n ( 1 λ , n , T , ε ) . (\mathrm{crs},\mathrm{td}) \leftarrow\mathrm{IVC.Gen}(1^\lambda,n,T,\varepsilon). ( crs , td ) ← IVC.Gen ( 1 λ , n , T , ε ) .
Then for every poly-size circuit that takes as input c r s \mathrm{crs} crs and has oracle access to O \mathcal{O} O , and outputs an instance x ∈ { 0 , 1 } n x \in\{0,1\}^n x ∈ { 0 , 1 } n , a time bound t ∈ { 0 , 1 , … , T } t \in\{0,1,\ldots,T\} t ∈ { 0 , 1 , … , T } and a witness w w w (in case M M M is non-deterministic), corresponding to an honest execution ( C 0 , … , C t ) (C_0,\ldots,C_t) ( C 0 , … , C t ) , the following holds: Starting with C 0 = C i n i t ( x ) C_0=C_{\mathrm{init}}(x) C 0 = C init ( x ) and π 0 = ⊥ \pi_0=\bot π 0 = ⊥ , for every i ∈ [ t ] i \in[t] i ∈ [ t ] let
( C i , π i ) ← I V C . U p d a t e O ( c r s , x , i − 1 , C i − 1 , π i − 1 , w i ) , (C_i,\pi_i) \leftarrow\mathrm{IVC.Update}^{\mathcal{O}}(\mathrm{crs},x,i-1,C_{i-1},\pi_{i-1},w_i), ( C i , π i ) ← IVC.Update O ( crs , x , i − 1 , C i − 1 , π i − 1 , w i ) ,
where w i w_i w i specifies the corresponding transition. Then, for every i ∈ { 0 , … , t } i \in\{0,\ldots,t\} i ∈ { 0 , … , t } ,
Pr [ I V C . V O ( c r s , t d , x , i , C i , π i ) = 1 ] ≥ 1 − negl ( λ ) . \Pr\left[\mathrm{IVC.V}^{\mathcal{O}}(\mathrm{crs},\mathrm{td},x,i,C_i,\pi_i)=1\right] \ge1-\operatorname{negl}(\lambda). Pr [ IVC.V O ( crs , td , x , i , C i , π i ) = 1 ] ≥ 1 − negl ( λ ) .
( c r s , t d ) ← I V C . G e n ( 1 λ , n , T , ε ) , (\mathrm{crs},\mathrm{td}) \leftarrow\mathrm{IVC.Gen}(1^\lambda,n,T,\varepsilon), ( crs , td ) ← IVC.Gen ( 1 λ , n , T , ε ) ,
( x , t , C , π ) = A O ( c r s ) , (x,t,C,\pi)=\mathcal{A}^{\mathcal{O}}(\mathrm{crs}), ( x , t , C , π ) = A O ( crs ) ,
we have
Pr [ ∣ x ∣ = n , 0 ≤ t ≤ T , C ∉ Reach t O ( x ) , C is ε -robust at time t on input x , I V C . V O ( c r s , t d , x , t , C , π ) = 1 ] ≤ μ ( λ ) . \Pr\left[
\begin{array}{c}
|x|=n,\quad0\le t\le T,\\
C\notin\operatorname{Reach}^{\mathcal{O}}_t(x),\\
C\text{ is }\varepsilon\text{-robust at time }t\text{ on input }x,\\
\mathrm{IVC.V}^{\mathcal{O}}(\mathrm{crs},\mathrm{td},x,t,C,\pi)=1
\end{array}
\right]\le\mu(\lambda). Pr ∣ x ∣ = n , 0 ≤ t ≤ T , C ∈ / Reach t O ( x ) , C is ε -robust at time t on input x , IVC.V O ( crs , td , x , t , C , π ) = 1 ≤ μ ( λ ) .
The oracle O \mathcal{O} O is fixed independently of setup.
Efficiency. The lengths of c r s \mathrm{crs} crs , t d \mathrm{td} td , and π t \pi_t π t , and the running time of setup, are bounded by poly ( λ , S , log T , 1 / ε ) \operatorname{poly}(\lambda,S,\log T,1/\varepsilon) poly ( λ , S , log T , 1/ ε ) . Proof update and verification take time poly ( n , λ , S , log T , 1 / ε ) \operatorname{poly}(n,\lambda,S,\log T,1/\varepsilon) poly ( n , λ , S , log T , 1/ ε ) , independently of the number of preceding steps, except through log T \log T log T . In each invocation, the verifier makes O ( λ / ε ) O(\lambda/\varepsilon) O ( λ / ε ) queries to O \mathcal{O} O .
Preliminaries: Updatable Batch Arguments
Both constructions use as a building block an updatable BARG, defined by Aldema Tshuva and Oshman [20 ] , and formally defined below. In what follows we recall a slightly specialized version of the definition of an updatable BARG [20 ] , that captures the properties needed in this work.
Fix an NP relation R R R , and a polynomial-time consistency predicate C o n s \mathrm{Cons} Cons on pairs of statements. Intuitively, an updatable BARG allows the prover to maintain a short proof for an adaptively growing sequence of NP statements z 1 , … , z k z_1,\ldots,z_k z 1 , … , z k , together with witnesses w 1 , … , w k w_1,\ldots,w_k w 1 , … , w k such that R ( z i , w i ) = 1 R(z_i,w_i)=1 R ( z i , w i ) = 1 for every i i i , and
C o n s ( z i , z i + 1 ) = 1 \mathrm{Cons}(z_i,z_{i+1})=1 Cons ( z i , z i + 1 ) = 1
for every i < k i<k i < k . The proof can be updated efficiently upon receiving ( z k + 1 , w k + 1 ) (z_{k+1},w_{k+1}) ( z k + 1 , w k + 1 ) , without accessing the preceding witnesses.
Definition 41 (Updatable batch argument). [20 ] Fix an NP relation R R R and a polynomial-time consistency predicate Cons. We use the convention that Cons ( ⊥ , z ) = 1 \operatorname{Cons}(\perp,z)=1 Cons ( ⊥ , z ) = 1 for every valid first statement z z z .
An updatable batch argument UpBARG for ( R , Cons ) (R,\operatorname{Cons}) ( R , Cons ) is associated with an updatable hash family with local openings (Theorem 8)
H T = ( H T . G e n , H T . H a s h , H T . O p e n , H T . V e r i f y , H T . A p p e n d , H T . S i z e ) , \mathrm{HT}=(\mathrm{HT.Gen},\mathrm{HT.Hash},\mathrm{HT.Open},\mathrm{HT.Verify},\mathrm{HT.Append},\mathrm{HT.Size}), HT = ( HT.Gen , HT.Hash , HT.Open , HT.Verify , HT.Append , HT.Size ) , and consists of algorithms
( G e n , T G e n , U p d a t e , V e r , E x t r a c t ) (\mathrm{Gen},\mathrm{TGen},\mathrm{Update},\mathrm{Ver},\mathrm{Extract}) ( Gen , TGen , Update , Ver , Extract ) with the following syntax.
G e n ( 1 λ ) \mathrm{Gen}(1^\lambda) Gen ( 1 λ ) outputs a common reference string crs.
T G e n ( 1 λ , j ) \mathrm{TGen}(1^\lambda,j) TGen ( 1 λ , j ) outputs a common reference string crs and a trapdoor td for an extraction index j j j . The scheme supports any j ≤ 2 λ j\leq2^\lambda j ≤ 2 λ .
U p d a t e ( h k , c r s , v , π , z − , z , w ) ⟶ ( v ′ , π ′ ) \mathrm{Update}(\mathrm{hk},\mathrm{crs},v,\pi,z^{-},z,w)\longrightarrow(v',\pi') Update ( hk , crs , v , π , z − , z , w ) ⟶ ( v ′ , π ′ ) takes a hash key hk, a common reference string crs, the current hash value v v v , the current proof π \pi π , the last statement z − z^{-} z − , and a new statement-witness pair ( z , w ) (z,w) ( z , w ) . It outputs the updated hash value v ′ = H T . A p p e n d ( h k , v , z ) v'=\mathrm{HT.Append}(\mathrm{hk},v,z) v ′ = HT.Append ( hk , v , z ) and proof π ′ \pi' π ′ . In particular, Update does not receive any of the preceding statements or witnesses.
V e r ( h k , c r s , v , π , z − ) ⟶ { 0 , 1 } \mathrm{Ver}(\mathrm{hk},\mathrm{crs},v,\pi,z^{-})\longrightarrow\{0,1\} Ver ( hk , crs , v , π , z − ) ⟶ { 0 , 1 } takes, in addition to (hk, crs), a current hash value, proof, and claimed last statement, and outputs an acceptance bit.
E x t r a c t ( h k , t d , v , π ) ⟶ ( z , ρ , w , z p r e v , ρ p r e v ) \mathrm{Extract}(\mathrm{hk},\mathrm{td},v,\pi)\longrightarrow(z,\rho,w,z^{\mathrm{prev}},\rho^{\mathrm{prev}}) Extract ( hk , td , v , π ) ⟶ ( z , ρ , w , z prev , ρ prev ) extracts the statement z z z and witness w w w at the hidden index j j j , together with an opening ρ \rho ρ authenticating z z z at position j j j . If j > 1 j>1 j > 1 , it additionally extracts the preceding statement z p r e v z^{\mathrm{prev}} z prev and an opening ρ p r e v \rho^{\mathrm{prev}} ρ prev authenticating it at position j − 1 j-1 j − 1 . When j = 1 j=1 j = 1 , we interpret z p r e v = ⊥ z^{\mathrm{prev}}=\perp z prev =⊥ and ρ p r e v = ⊥ \rho^{\mathrm{prev}}=\perp ρ prev =⊥ .
The scheme satisfies the following properties.
Incremental completeness. For every λ ∈ N \lambda\in\mathbb{N} λ ∈ N , every h k ∈ Supp ( H T . G e n ( 1 λ ) ) \mathrm{hk}\in\operatorname{Supp}(\mathrm{HT.Gen}(1^\lambda)) hk ∈ Supp ( HT.Gen ( 1 λ )) , every c r s ∈ Supp ( G e n ( 1 λ ) ) \mathrm{crs}\in\operatorname{Supp}(\mathrm{Gen}(1^\lambda)) crs ∈ Supp ( Gen ( 1 λ )) , every k < 2 λ k<2^\lambda k < 2 λ , every ( v , π , z − ) (v,\pi,z^{-}) ( v , π , z − ) such that H T . S i z e ( v ) = k \mathrm{HT.Size}(v)=k HT.Size ( v ) = k , and every statement-witness pair ( z , w ) (z,w) ( z , w ) , such that R ( z , w ) = 1 R(z,w)=1 R ( z , w ) = 1 and Cons ( z − , z ) = 1 \operatorname{Cons}(z^{-},z)=1 Cons ( z − , z ) = 1 , the following holds.
The verifier accepts the empty state:
V e r ( h k , c r s , ⊥ , ⊥ , ⊥ ) = 1. \mathrm{Ver}(\mathrm{hk},\mathrm{crs},\perp,\perp,\perp)=1. Ver ( hk , crs , ⊥ , ⊥ , ⊥ ) = 1. Suppose that
V e r ( h k , c r s , v , π , z − ) = 1 , \mathrm{Ver}(\mathrm{hk},\mathrm{crs},v,\pi,z^{-})=1, Ver ( hk , crs , v , π , z − ) = 1 , and let
( v ′ , π ′ ) = U p d a t e ( h k , c r s , v , π , z − , z , w ) . (v',\pi')=\mathrm{Update}(\mathrm{hk},\mathrm{crs},v,\pi,z^{-},z,w). ( v ′ , π ′ ) = Update ( hk , crs , v , π , z − , z , w ) . Then
V e r ( h k , c r s , v ′ , π ′ , z ) = 1. \mathrm{Ver}(\mathrm{hk},\mathrm{crs},v',\pi',z)=1. Ver ( hk , crs , v ′ , π ′ , z ) = 1.
Efficiency and succinctness. After k < 2 λ k < 2^{\lambda} k < 2 λ successive updates, let m m m be the maximum length of any statement or witness added so far. The common reference string and hash value have length poly ( λ ) \operatorname{poly}(\lambda) poly ( λ ) , and the proof has length O ( m ) + poly ( λ ) O(m) + \operatorname{poly}(\lambda) O ( m ) + poly ( λ ) .
The update, verification, and extraction algorithms run in time polynomial in their explicit inputs. In particular, their running times are independent of the number k k k of preceding statements, except through the succinct state ( v , π , z − ) (v,\pi,z^{-}) ( v , π , z − ) .
c r s ← Gen ( 1 λ ) \mathrm{crs} \leftarrow\operatorname{Gen}(1^{\lambda}) crs ← Gen ( 1 λ )
and
( c r s , t d ) ← TGen ( 1 λ , j ) (\mathrm{crs},\mathrm{td}) \leftarrow\operatorname{TGen}(1^{\lambda},j) ( crs , td ) ← TGen ( 1 λ , j )
are computationally indistinguishable when the trapdoor is hidden. In particular, the common reference string computationally hides the extraction index j j j .
Somewhere argument of knowledge. For every polynomial-size adversary A \mathcal{A} A and every polynomially bounded K = K ( λ ) K = K(\lambda) K = K ( λ ) , there exists a negligible function μ \mu μ such that for every λ ∈ N \lambda\in\mathbb{N} λ ∈ N and every j ∈ [ K ] j \in[K] j ∈ [ K ] , the following holds.
Sample
h k ← HT.Gen ( 1 λ ) , ( c r s , t d ) ← TGen ( 1 λ , j ) \mathrm{hk} \leftarrow\operatorname{HT.Gen}(1^{\lambda}), \qquad(\mathrm{crs},\mathrm{td}) \leftarrow\operatorname{TGen}(1^{\lambda},j) hk ← HT.Gen ( 1 λ ) , ( crs , td ) ← TGen ( 1 λ , j )
and let
( v , π , z − ) = A ( h k , c r s ) , (v,\pi,z^{-}) = \mathcal{A}(\mathrm{hk},\mathrm{crs}), ( v , π , z − ) = A ( hk , crs ) ,
( z , ρ , w , z p r e v , ρ p r e v ) ← Extract ( h k , t d , v , π ) . (z,\rho,w,z^{\mathrm{prev}},\rho^{\mathrm{prev}}) \leftarrow\operatorname{Extract}(\mathrm{hk},\mathrm{td},v,\pi). ( z , ρ , w , z prev , ρ prev ) ← Extract ( hk , td , v , π ) .
Then
Pr [ Ver ( h k , c r s , v , π , z − ) = 1 ∧ j ≤ HT.Size ( v ) ≤ K ∧ ( R ( z , w ) ≠ 1 ∨ Cons ( z p r e v , z ) ≠ 1 ∨ HT.Verify ( h k , v , j , z , ρ ) ≠ 1 ∨ ( j > 1 ∧ HT.Verify ( h k , v , j − 1 , z p r e v , ρ p r e v ) ≠ 1 ) ) ] ≤ μ ( λ ) . \Pr\left[
\begin{aligned}
&\operatorname{Ver}(\mathrm{hk},\mathrm{crs},v,\pi,z^{-}) = 1\\
&\land\ j \le\operatorname{HT.Size}(v) \le K\\
&\land\ \bigl(R(z,w) \ne1\\
&\qquad\lor\ \operatorname{Cons}(z^{\mathrm{prev}},z) \ne1\\
&\qquad\lor\ \operatorname{HT.Verify}(\mathrm{hk},v,j,z,\rho) \ne1\\
&\qquad\lor\ (j > 1 \land\operatorname{HT.Verify}(\mathrm{hk},v,j-1,z^{\mathrm{prev}},\rho^{\mathrm{prev}}) \ne1)\bigr)
\end{aligned}
\right] \le\mu(\lambda). Pr Ver ( hk , crs , v , π , z − ) = 1 ∧ j ≤ HT.Size ( v ) ≤ K ∧ ( R ( z , w ) = 1 ∨ Cons ( z prev , z ) = 1 ∨ HT.Verify ( hk , v , j , z , ρ ) = 1 ∨ ( j > 1 ∧ HT.Verify ( hk , v , j − 1 , z prev , ρ prev ) = 1 ) ) ≤ μ ( λ ) .
For j = 1 j = 1 j = 1 , we use the convention z p r e v = ρ p r e v = ⊥ z^{\mathrm{prev}} = \rho^{\mathrm{prev}} = \bot z prev = ρ prev = ⊥ .
Pr [ 1 ≤ HT.Size ( v ) ≤ K , Ver ( h k , c r s , v , π , z − ) = 1 , z ~ ≠ z , HT.Verify ( h k , v , HT.Size ( v ) , z ~ , ρ ) = 1 | h k ← HT.Gen ( 1 λ ) , c r s ← Gen ( 1 λ ) , ( v , π , z − , z ~ , ρ ) = A ( h k , c r s ) ] ≤ μ ( λ ) . \Pr\left[
\begin{aligned}
&1 \le\operatorname{HT.Size}(v) \le K,\\
&\operatorname{Ver}(\mathrm{hk},\mathrm{crs},v,\pi,z^{-}) = 1,\\
&\widetilde{z} \ne z,\\
&\operatorname{HT.Verify}(\mathrm{hk},v,\operatorname{HT.Size}(v),\widetilde{z},\rho) = 1
\end{aligned}
\ \middle|\
\begin{aligned}
&\mathrm{hk} \leftarrow\operatorname{HT.Gen}(1^{\lambda}),\\
&\mathrm{crs} \leftarrow\operatorname{Gen}(1^{\lambda}),\\
&(v,\pi,z^{-},\widetilde{z},\rho) = \mathcal{A}(\mathrm{hk},\mathrm{crs})
\end{aligned}
\right] \le\mu(\lambda). Pr 1 ≤ HT.Size ( v ) ≤ K , Ver ( hk , crs , v , π , z − ) = 1 , z = z , HT.Verify ( hk , v , HT.Size ( v ) , z , ρ ) = 1 hk ← HT.Gen ( 1 λ ) , crs ← Gen ( 1 λ ) , ( v , π , z − , z , ρ ) = A ( hk , crs ) ≤ μ ( λ ) .
We emphasize that the somewhere argument-of-knowledge property will be important in the signed-oracle setting. Ordinary soundness would not suffice there: for an incorrect oracle answer a ≠ O ( u ) a \ne\mathcal{O}(u) a = O ( u ) , a valid signature on ( u , a ) (u,a) ( u , a ) exists under the signing key. Security follows from the fact that an accepting proof allows us to extract such a signature and thereby obtain a forgery.
Theorem 43 ([20 ] ). Updatable hash-and-BARG schemes (UpBARG) for NP satisfying Definition 41 exist assuming either polynomial hardness of LWE, or subexponential hardness of DDH, or polynomial hardness of DDH and k k k -Lin.
In our oracle-aided applications, we require the security properties of the UpBARG to hold even against adversaries with oracle access to O \mathcal{O} O .
IVC Construction for Signed Oracles
We construct a publicly verifiable IVC scheme for oracle-aided computations with signed oracles. Our construction is based on the UpBARG of § 7.3 , following the approach of Aldema Tshuva and Oshman [20 ] of constructing IVC for standard (non-oracle) computations.
The main observation is that signatures make oracle transitions locally verifiable without querying the oracle. Indeed, if an oracle transition uses query u u u and answer a a a , then a signature σ \sigma σ satisfying
S i g . V e r i f y ( v k , ( u , a ) , σ ) = 1 \mathrm{Sig.Verify}(\mathrm{vk},(u,a),\sigma)=1 Sig.Verify ( vk , ( u , a ) , σ ) = 1
serves as a witness for this transition.
There is, however, an important subtlety. Even when a ≠ O ( u ) a \ne\mathcal{O}(u) a = O ( u ) , a valid signature on ( u , a ) (u,a) ( u , a ) exists under the oracle’s signing key. Thus, ordinary soundness of the UpBARG does not suffice. Instead, we use its somewhere argument-of-knowledge property, which allows us to extract a signature from an accepting proof. We show that an accepting proof for an unreachable configuration yields a forgery of the signature scheme.
The local relation. Fix an oracle-aided Turing machine M M M with time bound T T T and space bound S S S , and let O s i g \mathcal{O}_{\mathrm{sig}} O sig be a signed oracle associated with O \mathcal{O} O with verification key v k \mathrm{vk} vk .
We define an oracle-free NP relation R s i g R_{\mathrm{sig}} R sig consisting of instance-witness pairs ( D i , η i ) (D_i,\eta_i) ( D i , η i ) , where
D i = ( i , v k , h k , v x , C i − 1 , C i ) D_i=(i,\mathrm{vk},\mathrm{hk},v_x,C_{i-1},C_i) D i = ( i , vk , hk , v x , C i − 1 , C i )
is a transition record, v x = H T . H a s h ( h k , x ) v_x=\mathrm{HT.Hash}(\mathrm{hk},x) v x = HT.Hash ( hk , x ) is a hash value authenticating the input x x x , and C i − 1 , C i C_{i-1},C_i C i − 1 , C i are consecutive configurations of M M M (excluding the read-only input tape).19
Remark 44 (Hashing the input). We represent x x x by its authenticated hash v x v_x v x to keep the instance of the local relation succinct. Since the read-only input tape does not count toward the space bound, the input length may be much larger than S S S . Local openings allow each input-tape access to be checked using a short witness. This is important because the UpBARG proof-length bound depends on the lengths of the local instances and witnesses. The IVC verifier still receives x x x and computes v x = H a s h ( h k , x ) v_x=\mathrm{Hash}(\mathrm{hk},x) v x = Hash ( hk , x ) itself. A valid witness η i \eta_i η i corresponding to D i D_i D i satisfies the following:
If C i − 1 → C i C_{i-1} \to C_i C i − 1 → C i is a valid ordinary transition of M M M , then the witness η i \eta_i η i specifies any non-deterministic choice made in this transition. If the transition reads a bit of the input tape, the witness also contains the bit and a local opening showing that it agrees with the authenticated input v x v_x v x .
If C i − 1 → C i C_{i-1} \to C_i C i − 1 → C i is a valid oracle transition, denoting by u i u_i u i and a i a_i a i the query and answer specified by these configurations, the witness η i \eta_i η i contains a signature σ i \sigma_i σ i such that
Sig.Verify ( v k , ( u i , a i ) , σ i ) = 1. \operatorname{Sig.Verify}(\mathit{vk},(u_i,a_i),\sigma_i)=1. Sig.Verify ( vk , ( u i , a i ) , σ i ) = 1.
In both cases, the relation checks that the transition also respects the machine’s prescribed time and space bounds, including the oracle-call counter. Importantly, R s i g R_{\mathrm{sig}} R sig makes no oracle calls.
We also define a polynomial-time consistency predicate Cons \operatorname{Cons} Cons . For two consecutive records
D = ( i , v k , h k , v , C , C ′ ) D=(i,\mathit{vk},\mathit{hk},v,C,C') D = ( i , vk , hk , v , C , C ′ )
and
D ′ = ( i ′ , v k ′ , h k ′ , v ′ , C ′ ′ , C ′ ′ ′ ) , D'=(i',\mathit{vk}',\mathit{hk}',v',C'',C'''), D ′ = ( i ′ , vk ′ , hk ′ , v ′ , C ′′ , C ′′′ ) ,
we define Cons ( D , D ′ ) = 1 \operatorname{Cons}(D,D')=1 Cons ( D , D ′ ) = 1 if and only if
i ′ = i + 1 , ( v k ′ , h k ′ , v ′ ) = ( v k , h k , v ) , C ′ ′ = C ′ . i'=i+1,\qquad(\mathit{vk}',\mathit{hk}',v')=(\mathit{vk},\mathit{hk},v),\qquad C''=C'. i ′ = i + 1 , ( vk ′ , hk ′ , v ′ ) = ( vk , hk , v ) , C ′′ = C ′ .
For the first record, Cons ( ⊥ , D ) = 1 \operatorname{Cons}(\bot,D)=1 Cons ( ⊥ , D ) = 1 if and only if its time index is i = 1 i=1 i = 1 and its starting configuration is the prescribed initial configuration for inputs of length n n n . Here the read-only input tape is represented externally, as above.
Notice that both R s i g R_{\mathrm{sig}} R sig and Cons \operatorname{Cons} Cons are oracle-free.
The IVC construction. Our construction uses the following ingredients:
H T = ( H T . G e n , H T . H a s h , H T . O p e n , H T . V e r i f y , H T . A p p e n d , H T . S i z e ) . \mathsf{HT}=(\mathsf{HT.Gen},\mathsf{HT.Hash},\mathsf{HT.Open},\mathsf{HT.Verify},\mathsf{HT.Append},\mathsf{HT.Size}). HT = ( HT.Gen , HT.Hash , HT.Open , HT.Verify , HT.Append , HT.Size ) .
An updatable batch argument for ( R s i g , Cons ) (R_{\mathrm{sig}},\operatorname{Cons}) ( R sig , Cons ) , as defined in § 7.3 , associated with the hash family H T \mathsf{HT} HT :
U p B A R G = ( U p B A R G . G e n , U p B A R G . T G e n , U p B A R G . U p d a t e , U p B A R G . V e r , U p B A R G . E x t r a c t ) . \mathsf{UpBARG}=(\mathsf{UpBARG.Gen},\mathsf{UpBARG.TGen},\mathsf{UpBARG.Update},\mathsf{UpBARG.Ver},\mathsf{UpBARG.Extract}). UpBARG = ( UpBARG.Gen , UpBARG.TGen , UpBARG.Update , UpBARG.Ver , UpBARG.Extract ) .
The signature scheme is the one underlying the given signed oracle, whose verification key is v k \mathit{vk} vk . We use two independent UpBARG instances, which will be useful in the soundness proof.
I V C . G e n ( 1 λ , n , T , v k ) ⟶ c r s \mathsf{IVC.Gen}(1^\lambda,n,T,\mathit{vk})\longrightarrow\mathit{crs} IVC.Gen ( 1 λ , n , T , vk ) ⟶ crs :
Generate a hash key h k ← H T . G e n ( 1 κ ) \mathit{hk}\leftarrow\mathsf{HT.Gen}(1^\kappa) hk ← HT.Gen ( 1 κ ) , where the security parameter κ \kappa κ is chosen to be
κ = poly ( λ , S , log T ) \kappa=\operatorname{poly}(\lambda,S,\log T) κ = poly ( λ , S , log T )
as discussed in the analysis below.
Generate two independent UpBARG reference strings c r s 1 , c r s 2 ← U p B A R G . G e n ( 1 κ ) \mathit{crs}_1,\mathit{crs}_2\leftarrow\mathsf{UpBARG.Gen}(1^\kappa) crs 1 , crs 2 ← UpBARG.Gen ( 1 κ ) .
Output c r s = ( v k , h k , c r s 1 , c r s 2 ) \mathrm{crs}=(\mathrm{vk},\mathrm{hk},\mathrm{crs}_1,\mathrm{crs}_2) crs = ( vk , hk , crs 1 , crs 2 ) .
Note that I V C . G e n \mathrm{IVC.Gen} IVC.Gen makes no oracle calls.
I V C . U p d a t e O s i g ( c r s , x , t , C t , π t , w t + 1 ) ⟶ ( C t + 1 , π t + 1 ) \mathrm{IVC.Update}^{\mathcal{O}_{\mathrm{sig}}}(\mathrm{crs},x,t,C_t,\pi_t,w_{t+1})\longrightarrow(C_{t+1},\pi_{t+1}) IVC.Update O sig ( crs , x , t , C t , π t , w t + 1 ) ⟶ ( C t + 1 , π t + 1 ) :
Parse c r s = ( v k , h k , c r s 1 , c r s 2 ) \mathrm{crs}=(\mathrm{vk},\mathrm{hk},\mathrm{crs}_1,\mathrm{crs}_2) crs = ( vk , hk , crs 1 , crs 2 ) and compute v x = H T . H a s h ( h k , x ) v_x=\mathrm{HT.Hash}(\mathrm{hk},x) v x = HT.Hash ( hk , x ) .
If t = 0 t=0 t = 0 , check that C 0 = C i n i t ( x ) C_0=C_{\mathrm{init}}(x) C 0 = C init ( x ) and π 0 = ⊥ \pi_0=\bot π 0 = ⊥ , and set v 0 = Π 1 , 0 = Π 2 , 0 = D 0 = ⊥ v_0=\Pi_{1,0}=\Pi_{2,0}=D_0=\bot v 0 = Π 1 , 0 = Π 2 , 0 = D 0 = ⊥ . Otherwise, parse π t = ( v t , Π 1 , t , Π 2 , t , D t ) \pi_t=(v_t,\Pi_{1,t},\Pi_{2,t},D_t) π t = ( v t , Π 1 , t , Π 2 , t , D t ) and check that
H T . S i z e ( v t ) = t and D t = ( t , v k , h k , v x , C ′ , C t ) \mathrm{HT.Size}(v_t)=t \quad\text{and}\quad D_t=(t,\mathrm{vk},\mathrm{hk},v_x,C',C_t) HT.Size ( v t ) = t and D t = ( t , vk , hk , v x , C ′ , C t )
for some configuration C ′ C' C ′ .
Compute C t + 1 C_{t+1} C t + 1 by applying the next transition of M M M to C t C_t C t , using the non-deterministic choice w t + 1 w_{t+1} w t + 1 , if any. If this is an oracle transition with query u u u , obtain
( a , σ ) ← O s i g ( u ) , (a,\sigma)\leftarrow\mathcal{O}_{\mathrm{sig}}(u), ( a , σ ) ← O sig ( u ) ,
and use a a a as the oracle answer when computing C t + 1 C_{t+1} C t + 1 .
Define the new transition record
D t + 1 = ( t + 1 , v k , h k , v x , C t , C t + 1 ) . D_{t+1}=(t+1,\mathrm{vk},\mathrm{hk},v_x,C_t,C_{t+1}). D t + 1 = ( t + 1 , vk , hk , v x , C t , C t + 1 ) .
Construct a witness η t + 1 \eta_{t+1} η t + 1 for R s i g ( D t + 1 , η t + 1 ) = 1 R_{\mathrm{sig}}(D_{t+1},\eta_{t+1})=1 R sig ( D t + 1 , η t + 1 ) = 1 . If this is an ordinary transition, the witness contains the non-deterministic choice w t + 1 w_{t+1} w t + 1 , if any, together with the local opening of the input bit read by the transition, when needed. If this is an oracle transition, the witness contains the signature σ \sigma σ obtained in Item 3.
For each b ∈ { 1 , 2 } b\in\{1,2\} b ∈ { 1 , 2 } , compute
( v b , t + 1 , Π b , t + 1 ) ← U p B A R G . U p d a t e ( h k , c r s b , v t , Π b , t , D t , D t + 1 , η t + 1 ) . (v_{b,t+1},\Pi_{b,t+1})\leftarrow\mathrm{UpBARG.Update}(\mathrm{hk},\mathrm{crs}_b,v_t,\Pi_{b,t},D_t,D_{t+1},\eta_{t+1}). ( v b , t + 1 , Π b , t + 1 ) ← UpBARG.Update ( hk , crs b , v t , Π b , t , D t , D t + 1 , η t + 1 ) .
By the correctness of the updatable hash family, the two resulting hash values are identical:
v 1 , t + 1 = v 2 , t + 1 = H T . A p p e n d ( h k , v t , D t + 1 ) . v_{1,t+1}=v_{2,t+1}=\mathrm{HT.Append}(\mathrm{hk},v_t,D_{t+1}). v 1 , t + 1 = v 2 , t + 1 = HT.Append ( hk , v t , D t + 1 ) .
Denote this common value by v t + 1 v_{t+1} v t + 1 .
Output ( C t + 1 , π t + 1 ) (C_{t+1},\pi_{t+1}) ( C t + 1 , π t + 1 ) , where
π t + 1 = ( v t + 1 , Π 1 , t + 1 , Π 2 , t + 1 , D t + 1 ) . \pi_{t+1}=(v_{t+1},\Pi_{1,t+1},\Pi_{2,t+1},D_{t+1}). π t + 1 = ( v t + 1 , Π 1 , t + 1 , Π 2 , t + 1 , D t + 1 ) .
I V C . V ( c r s , x , t , C , π t ) \mathrm{IVC.V}(\mathrm{crs},x,t,C,\pi_t) IVC.V ( crs , x , t , C , π t ) .
If t = 0 t=0 t = 0 , accept if and only if C = C i n i t ( x ) C=C_{\mathrm{init}}(x) C = C init ( x ) and π t = ⊥ \pi_t=\bot π t = ⊥ .
If t ≥ 1 t\geq1 t ≥ 1 , parse π t = ( v t , Π 1 , t , Π 2 , t , D t ) \pi_t=(v_t,\Pi_{1,t},\Pi_{2,t},D_t) π t = ( v t , Π 1 , t , Π 2 , t , D t ) and check that
H T . S i z e ( v t ) = t ∧ D t = ( t , v k , h k , v x , C ′ , C ) \mathrm{HT.Size}(v_t)=t\ \wedge\ D_t=(t,\mathrm{vk},\mathrm{hk},v_x,C',C) HT.Size ( v t ) = t ∧ D t = ( t , vk , hk , v x , C ′ , C )
for some configuration C ′ C' C ′ , where v x = H T . H a s h ( h k , x ) v_x=\mathrm{HT.Hash}(\mathrm{hk},x) v x = HT.Hash ( hk , x ) .
Accept if and only if, for both b ∈ { 1 , 2 } b \in\{1,2\} b ∈ { 1 , 2 } ,
UpBARG.Ver ( h k , crs b , v t , Π b , t , D t ) = 1. \operatorname{UpBARG.Ver}(h_k,\operatorname{crs}_b,v_t,\Pi_{b,t},D_t)=1. UpBARG.Ver ( h k , crs b , v t , Π b , t , D t ) = 1.
The verifier makes no oracle calls.
Theorem 45. Let M M M be an oracle-aided Turing machine with time bound T T T and space bound S S S , and let O s i g \mathcal{O}_{\mathrm{sig}} O sig be a signed oracle as in Theorem 25, with the security parameter κ s i g = poly ( λ , log T ) \kappa_{\mathrm{sig}}=\operatorname{poly}(\lambda,\log T) κ sig = poly ( λ , log T ) . Let
T ∗ = poly ( 2 S , T , λ ) . T^*=\operatorname{poly}(2^S,T,\lambda). T ∗ = poly ( 2 S , T , λ ) . Assume that UpBARG and HT, instantiated with κ = poly ( λ , S , log T ) \kappa=\operatorname{poly}(\lambda,S,\log T) κ = poly ( λ , S , log T ) , are T ∗ T^* T ∗ -secure even given access to O \mathcal{O} O , and that the signature scheme satisfies Theorem 26. Then there exists a publicly verifiable IVC scheme for M O M^{\mathcal{O}} M O with adaptive soundness, according to Theorem 39, with the following properties:
The public parameters and maintained IVC proof have length poly ( λ , S , log T ) \operatorname{poly}(\lambda,S,\log T) poly ( λ , S , log T ) .
Proof update and verification take time poly ( n , λ , S , log T ) \operatorname{poly}(n,\lambda,S,\log T) poly ( n , λ , S , log T ) .
Neither setup nor verification makes oracle calls.
The authenticated oracle responses needed by the prover are exactly those used by the underlying execution.
Proof. Completeness follows from the correctness of the signature scheme, the completeness of the hash family with local openings and updatability, and incremental completeness of the UpBARG.
The efficiency bounds follow from the fact that each record contains a constant number of configurations, together with public parameters and a time index. Thus, both a record and its witness have length
poly ( κ , S , log T ) = poly ( λ , S , log T ) . \operatorname{poly}(\kappa,S,\log T)=\operatorname{poly}(\lambda,S,\log T). poly ( κ , S , log T ) = poly ( λ , S , log T ) .
The two UpBARG instances increase the proof length and update time by only a constant factor.
Adaptive soundness. As in § 6.2 , let
T ∗ = poly ( 2 S , T , λ ) T^*=\operatorname{poly}(2^S,T,\lambda) T ∗ = poly ( 2 S , T , λ )
be large enough to bound the running times of the reductions below, including the configuration-graph computations. We assume that UpBARG and HT are secure against adversaries of size poly ( T ∗ ) \operatorname{poly}(T^*) poly ( T ∗ ) , even given oracle access to O \mathcal{O} O , with error negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) . We assume that the signature scheme is T ∗ T^* T ∗ -secure (see Theorem 26). Fix an oracle O \mathcal{O} O independently of setup, and let A \mathcal{A} A be an adversary with access to O s i g \mathcal{O}_{\mathrm{sig}} O sig . We first analyze adversaries that output a fixed time t ∈ [ T ] t \in[T] t ∈ [ T ] . At the end of the proof we show how to deal with adaptively chosen t ∈ [ T ] t \in[T] t ∈ [ T ] .
Let E E E be the event that A \mathcal{A} A outputs ( x , t , C , π t ) (x,t,C,\pi_t) ( x , t , C , π t ) such that
C ∉ Reach O ( x ) and IVC.V ( crs , x , t , C , π t ) = 1. C \notin\operatorname{Reach}_{\mathcal{O}}(x)
\qquad\text{and}\qquad
\operatorname{IVC.V}(\operatorname{crs},x,t,C,\pi_t)=1. C ∈ / Reach O ( x ) and IVC.V ( crs , x , t , C , π t ) = 1.
We prove that
Pr [ E ] = negl ( λ ) . \Pr[E]=\operatorname{negl}(\lambda). Pr [ E ] = negl ( λ ) .
To this end, parse π t = ( v , Π 1 , Π 2 , D t ) \pi_t=(v,\Pi_1,\Pi_2,D_t) π t = ( v , Π 1 , Π 2 , D t ) , and note that if event E E E holds then
HT.Size ( v ) = t and D t = ( t , v k , h k , v x , C ′ , C ) \operatorname{HT.Size}(v)=t
\qquad\text{and}\qquad
D_t=(t,\mathrm{vk},h_k,v_x,C',C) HT.Size ( v ) = t and D t = ( t , vk , h k , v x , C ′ , C )
for some C ′ C' C ′ , where v x = H T . H a s h ( h k , x ) v_x = \mathrm{HT.Hash}(h_k, x) v x = HT.Hash ( h k , x ) .
For every i ∈ { 0 , … , t } i \in\{0,\ldots,t\} i ∈ { 0 , … , t } and configuration C ′ C' C ′ , define
Φ i x ( C ′ ) = { 0 , C ′ ∈ Reach i O ( x ) , 1 , otherwise. \Phi_i^x(C') =
\begin{cases}
0, & C' \in\operatorname{Reach}_i^{\mathcal{O}}(x),\\
1, & \text{otherwise.}
\end{cases} Φ i x ( C ′ ) = { 0 , 1 , C ′ ∈ Reach i O ( x ) , otherwise.
For every valid transition C i − 1 → C i C_{i-1} \to C_i C i − 1 → C i using the correct oracle answer, we have
Φ i x ( C i ) ≤ Φ i − 1 x ( C i − 1 ) . \Phi_i^x(C_i) \le\Phi_{i-1}^x(C_{i-1}). Φ i x ( C i ) ≤ Φ i − 1 x ( C i − 1 ) .
For a , b ∈ [ t ] a,b \in[t] a , b ∈ [ t ] , let H a , b H_{a,b} H a , b denote the experiment in which the two UpBARG reference strings are generated using T G e n ( 1 κ , a ) \mathrm{TGen}(1^\kappa,a) TGen ( 1 κ , a ) and T G e n ( 1 κ , b ) \mathrm{TGen}(1^\kappa,b) TGen ( 1 κ , b ) , respectively. By index hiding, the probability of E E E in each of these experiments differs negligibly from its probability in the real experiment.
For every i ∈ [ t ] i \in[t] i ∈ [ t ] , consider H i , i H_{i,i} H i , i , and use the trapdoor of the first UpBARG to extract
( D ^ i , ρ i , η i , D ^ i − 1 , ρ i − 1 ) , (\widehat{D}_i,\rho_i,\eta_i,\widehat{D}_{i-1},\rho_{i-1}), ( D i , ρ i , η i , D i − 1 , ρ i − 1 ) ,
where
D ^ i = ( i ′ , v k ′ , h k ′ , v x ′ , B i , A i ) . \widehat{D}_i = (i',\mathrm{vk}',h_k',v_x',B_i,A_i). D i = ( i ′ , vk ′ , h k ′ , v x ′ , B i , A i ) .
We say that the extraction is valid if
R s i g ( D ^ i , η i ) = 1 , Cons ( D ^ i − 1 , D ^ i ) = 1 , R_{\mathrm{sig}}(\widehat{D}_i,\eta_i)=1,\qquad\operatorname{Cons}(\widehat{D}_{i-1},\widehat{D}_i)=1, R sig ( D i , η i ) = 1 , Cons ( D i − 1 , D i ) = 1 ,
and the extracted hash openings ρ i \rho_i ρ i and ρ i − 1 \rho_{i-1} ρ i − 1 verify at positions i i i and i − 1 i-1 i − 1 , respectively (the latter only if i > 1 i>1 i > 1 ). We say that the extraction is aligned if
( i ′ , v k ′ , h k ′ , v x ′ ) = ( i , v k , h k , v x ) . (i',\mathrm{vk}',h_k',v_x')=(i,\mathrm{vk},h_k,v_x). ( i ′ , vk ′ , h k ′ , v x ′ ) = ( i , vk , h k , v x ) .
We write V a l i d i \mathrm{Valid}_i Valid i and A l i g n i \mathrm{Align}_i Align i for the events that the extraction is valid and aligned, respectively. If either event fails, we set both potential contributions associated with the extraction to zero.
Define
F i − = E H i , i [ 1 E 1 V a l i d i 1 A l i g n i Φ i − 1 x ( B i ) ] F_i^- = \mathbb{E}_{H_{i,i}}\left[1_E1_{\mathrm{Valid}_i}1_{\mathrm{Align}_i}\Phi_{i-1}^x(B_i)\right] F i − = E H i , i [ 1 E 1 Valid i 1 Align i Φ i − 1 x ( B i ) ]
and
F i + = E H i , i [ 1 E 1 V a l i d i 1 A l i g n i Φ i x ( A i ) ] . F_i^+ = \mathbb{E}_{H_{i,i}}\left[1_E1_{\mathrm{Valid}_i}1_{\mathrm{Align}_i}\Phi_i^x(A_i)\right]. F i + = E H i , i [ 1 E 1 Valid i 1 Align i Φ i x ( A i ) ] .
By the somewhere argument-of-knowledge property, for every i ∈ [ t ] i \in[t] i ∈ [ t ] ,
Pr H i , i [ E ∧ ¬ V a l i d i ] ≤ negl ( T ) . \Pr_{H_{i,i}}[E \land\neg\mathrm{Valid}_i] \le\operatorname{negl}(T). H i , i Pr [ E ∧ ¬ Valid i ] ≤ negl ( T ) .
Claim 46. For every i ∈ [ t ] i \in[t] i ∈ [ t ] ,
F i + ≤ F i − + negl ( T ) . F_i^+ \le F_i^- + \operatorname{negl}(T). F i + ≤ F i − + negl ( T ) .
Proof of Theorem 46. Since invalid or unaligned extractions contribute zero to both potentials, it suffices to bound the probability that a valid and aligned extraction increases the reachability potential.
If this is an ordinary transition, the local relation verifies every input bit read by the transition against v x v_x v x . An incorrect bit would yield two different valid openings of the same position under H T . H a s h ( h k , x ) \mathrm{HT.Hash}(h_k,x) HT.Hash ( h k , x ) , contradicting collision resistance with respect to opening. Consequently, by collision resistance with respect to opening,
Pr H i , i [ V a l i d i ∧ A l i g n i ∧ O r d B a d i ] ≤ negl ( T ) , \Pr_{H_{i,i}}\left[\mathrm{Valid}_i \wedge\mathrm{Align}_i \wedge\mathrm{OrdBad}_i\right] \leq\operatorname{negl}(T), H i , i Pr [ Valid i ∧ Align i ∧ OrdBad i ] ≤ negl ( T ) ,
where O r d B a d i \mathrm{OrdBad}_i OrdBad i is the event that the extracted transition is ordinary but is not a valid transition of M M M on the actual input x x x .
If this is an oracle transition with query u u u and answer a a a , validity implies that the extracted witness contains a signature σ \sigma σ satisfying
Sig.Verify ( v k , ( u , a ) , σ ) = 1. \operatorname{Sig.Verify}(v_k,(u,a),\sigma)=1. Sig.Verify ( v k , ( u , a ) , σ ) = 1.
If a ≠ O ( u ) a \ne\mathcal{O}(u) a = O ( u ) , this signature constitutes an existential forgery. Indeed, the reduction simulates O s i g \mathcal{O}_{\mathrm{sig}} O sig by requesting signatures only on messages ( u , O ( u ) ) (u,\mathcal{O}(u)) ( u , O ( u )) . Thus ( u , a ) (u,a) ( u , a ) was never submitted to its signing oracle. Hence, by collision resistance with respect to opening and signature unforgeability,
Pr H i , i [ V a l i d i ∧ A l i g n i ∧ ( Φ i x ( A i ) > Φ i − 1 x ( B i ) ) ] ≤ negl ( T ) . \Pr_{H_{i,i}}\left[\mathrm{Valid}_i \wedge\mathrm{Align}_i \wedge\left(\Phi_i^x(A_i) > \Phi_{i-1}^x(B_i)\right)\right] \leq\operatorname{negl}(T). H i , i Pr [ Valid i ∧ Align i ∧ ( Φ i x ( A i ) > Φ i − 1 x ( B i ) ) ] ≤ negl ( T ) .
Since the reachability potential takes values in { 0 , 1 } \{0,1\} { 0 , 1 } , we conclude that
F i + − F i − ≤ Pr H i , i [ E ∧ V a l i d i ∧ A l i g n i ∧ ( Φ i x ( A i ) > Φ i − 1 x ( B i ) ) ] ≤ negl ( T ) , F_i^+ - F_i^- \leq\Pr_{H_{i,i}}\left[E \wedge\mathrm{Valid}_i \wedge\mathrm{Align}_i \wedge\left(\Phi_i^x(A_i) > \Phi_{i-1}^x(B_i)\right)\right] \leq\operatorname{negl}(T), F i + − F i − ≤ H i , i Pr [ E ∧ Valid i ∧ Align i ∧ ( Φ i x ( A i ) > Φ i − 1 x ( B i ) ) ] ≤ negl ( T ) ,
proving Theorem 46.
We next prove the following:
Claim 47. For every i < t i < t i < t ,
∣ F i + − F i + 1 − ∣ ≤ negl ( T ) . \left|F_i^+ - F_{i+1}^-\right| \leq\operatorname{negl}(T). F i + − F i + 1 − ≤ negl ( T ) .
Proof of Theorem 47. Start with F i + F_i^+ F i + in H i , i H_{i,i} H i , i . By index hiding, we may change the extraction index of the second UpBARG from i i i to i + 1 i+1 i + 1 , without changing the expectation by more than a negligible amount, since the quantity being evaluated uses only the trapdoor of the first UpBARG.
Consider the resulting hybrid H i , i + 1 H_{i,i+1} H i , i + 1 . The first extractor opens the record at position i i i , whereas the second extractor opens the record at position i + 1 i+1 i + 1 , together with its predecessor at position i i i . By the somewhere argument-of-knowledge property the probability that E E E holds and one of the extractions is invalid is negligible. Moreover, both extracted records at position i i i are authenticated with respect to the same hash value v v v . By collision resistance with respect to opening, these records agree, except with negligible probability.
Since the second extraction is valid, the consistency predicate holds between its extracted record at position i + 1 i+1 i + 1 and its predecessor. Thus these records have consecutive time indices, identical public parameters, and matching boundary configurations. Consequently, the record extracted by the first component at position i i i is aligned if and only if the record extracted by the second component at position i + 1 i+1 i + 1 is aligned, except with negligible probability. Furthermore, whenever both are aligned, the configuration at the end of step i i i extracted by the first component equals the configuration at the beginning of step i + 1 i+1 i + 1 extracted by the second component. Therefore, up to a negligible additive error, we may replace the potential contribution from the first extraction at position i i i by the potential contribution from the second extraction at position i + 1 i+1 i + 1 .
We may now change the extraction index of the first UpBARG from i i i to i + 1 i+1 i + 1 , while evaluating the potential using the second extractor. By index hiding, this changes the expectation negligibly.
In H i + 1 , i + 1 H_{i+1,i+1} H i + 1 , i + 1 , both extractors open the record at position i + 1 i+1 i + 1 . By the somewhere argument-of-knowledge property and collision resistance with respect to opening, the probability that E E E holds and either extraction is invalid, or their authenticated records disagree, is negligible. Their alignment conditions therefore agree, except on an event whose intersection with E E E has negligible probability.
We may consequently evaluate the potential using the first extractor again, changing the expectation by at most a negligible amount. The resulting expectation is F i + 1 + F_{i+1}^{+} F i + 1 + , proving Theorem 47.
Combining Theorem 46 and Theorem 47, we obtain
F t + ≤ F 1 − + t ⋅ negl ( T ) . F_t^{+} \le F_1^{-} + t \cdot\operatorname{negl}(T). F t + ≤ F 1 − + t ⋅ negl ( T ) .
Thus, to complete the soundness proof, it suffices to show that
F 1 − = 0 and F t + ≥ Pr H t , t [ E ] − negl ( T ) . F_1^{-} = 0 \qquad\text{and}\qquad F_t^{+} \ge\Pr_{H_{t,t}}[E] - \operatorname{negl}(T). F 1 − = 0 and F t + ≥ H t , t Pr [ E ] − negl ( T ) .
We establish these two bounds next.
For i = 1 i=1 i = 1 , validity implies Cons ( ⊥ , D ^ 1 ) = 1 \operatorname{Cons}(\bot,\widehat{D}_1)=1 Cons ( ⊥ , D 1 ) = 1 . Thus, whenever the extraction is valid and aligned, its starting configuration is C i n i t ( x ) C_{\mathrm{init}}(x) C init ( x ) . Consequently,
F 1 − = 0. F_1^{-} = 0. F 1 − = 0.
For the terminal condition, recall that D t D_t D t is the claimed last record explicitly included in the adversary’s proof π t = ( v , Π 1 , Π 2 , D t ) \pi_t=(v,\Pi_1,\Pi_2,D_t) π t = ( v , Π 1 , Π 2 , D t ) , whereas D ^ t \widehat{D}_t D t denotes the record extracted from the first UpBARG component. Let Acc \operatorname{Acc} Acc be the event that IVC.V ( c r s , x , t , C , π t ) = 1 \operatorname{IVC.V}(\mathrm{crs},x,t,C,\pi_t)=1 IVC.V ( crs , x , t , C , π t ) = 1 . Acc implies that the verifier’s checks pass. Namely,
HT.Size ( v ) = t and D t = ( t , v k , h k , v x , C ′ , C ) \operatorname{HT.Size}(v)=t \qquad\text{and}\qquad D_t=(t,\mathrm{vk},\mathrm{hk},v_x,C',C) HT.Size ( v ) = t and D t = ( t , vk , hk , v x , C ′ , C )
for some C ′ C' C ′ , where v x = HT.Hash ( h k , x ) v_x=\operatorname{HT.Hash}(\mathrm{hk},x) v x = HT.Hash ( hk , x ) .
Consider the hybrid H t , g e n H_{t,\mathrm{gen}} H t , gen in which the first UpBARG reference string is generated using UpBARG.TGen ( 1 κ , t ) \operatorname{UpBARG.TGen}(1^\kappa,t) UpBARG.TGen ( 1 κ , t ) , and the second is generated using UpBARG.Gen ( 1 κ ) \operatorname{UpBARG.Gen}(1^\kappa) UpBARG.Gen ( 1 κ ) . All other parts of the experiment remain unchanged. By the somewhere argument-of-knowledge property, the probability that Acc holds and the first extraction is invalid is negligible.
Suppose that Acc holds and the first extraction is valid. Then its extracted opening ρ t \rho_t ρ t satisfies
HT.Verify ( h k , v , t , D ^ t , ρ t ) = 1. \operatorname{HT.Verify}(\mathrm{hk},v,t,\widehat{D}_t,\rho_t)=1. HT.Verify ( hk , v , t , D t , ρ t ) = 1.
Moreover, acceptance of the second component implies that
UpBARG.Ver ( h k , c r s 2 , v , Π 2 , D t ) = 1. \operatorname{UpBARG.Ver}(\mathrm{hk},\mathrm{crs}_2,v,\Pi_2,D_t)=1. UpBARG.Ver ( hk , crs 2 , v , Π 2 , D t ) = 1.
Since HT . Size ( v ) = t \operatorname{HT}.\operatorname{Size}(v)=t HT . Size ( v ) = t , if D ^ t ≠ D t \widehat{D}_t \ne D_t D t = D t , these two conditions give a violation of last-statement collision resistance for the second UpBARG component. Formally, the reduction generates the first component together with its extraction trapdoor, runs the adversary, and outputs ( v , Π 2 , D t , D ^ t , ρ t ) (v,\Pi_2,D_t,\widehat{D}_t,\rho_t) ( v , Π 2 , D t , D t , ρ t ) . Consequently,
Pr H t , g e n [ A c c ∧ ( ¬ V a l i d t ∨ D ^ t ≠ D t ) ] ≤ negl ( T ) . \Pr_{H_{t,\mathrm{gen}}}\left[\mathrm{Acc}\land\left(\neg\mathrm{Valid}_t\lor\widehat{D}_t\ne D_t\right)\right]\leq\operatorname{negl}(T). H t , gen Pr [ Acc ∧ ( ¬ Valid t ∨ D t = D t ) ] ≤ negl ( T ) .
The event in this probability can be evaluated using only the public data and the first component’s extraction trapdoor. Thus, by index hiding, replacing the second reference string by one generated using UpBARG . TGen ( 1 κ , t ) \operatorname{UpBARG}.\operatorname{TGen}(1^\kappa,t) UpBARG . TGen ( 1 κ , t ) changes its probability by at most a negligible amount. We obtain
Pr H t , t [ A c c ∧ ( ¬ V a l i d t ∨ D ^ t ≠ D t ) ] ≤ negl ( T ) . \Pr_{H_{t,t}}\left[\mathrm{Acc}\land\left(\neg\mathrm{Valid}_t\lor\widehat{D}_t\ne D_t\right)\right]\leq\operatorname{negl}(T). H t , t Pr [ Acc ∧ ( ¬ Valid t ∨ D t = D t ) ] ≤ negl ( T ) .
Finally, E ⊆ A c c E\subseteq\mathrm{Acc} E ⊆ Acc . On the event E ∧ V a l i d t ∧ ( D ^ t = D t ) E\land\mathrm{Valid}_t\land(\widehat{D}_t=D_t) E ∧ Valid t ∧ ( D t = D t ) , the verifier’s checks imply that the extraction is aligned and that its ending configuration satisfies A t = C A_t=C A t = C . Since E E E also implies C ∉ Reach φ O ( x ) C\notin\operatorname{Reach}^{O}_{\varphi}(x) C ∈ / Reach φ O ( x ) , we have Φ t x ( A t ) = 1 \Phi^x_t(A_t)=1 Φ t x ( A t ) = 1 . Therefore, by the definition of F t + F_t^+ F t + ,
F t + ≥ Pr H t , t [ E ∧ V a l i d t ∧ ( D ^ t = D t ) ] ≥ Pr H t , t [ E ] − negl ( T ) , F_t^+\geq\Pr_{H_{t,t}}\left[E\land\mathrm{Valid}_t\land(\widehat{D}_t=D_t)\right]\geq\Pr_{H_{t,t}}[E]-\operatorname{negl}(T), F t + ≥ H t , t Pr [ E ∧ Valid t ∧ ( D t = D t ) ] ≥ H t , t Pr [ E ] − negl ( T ) ,
as desired.
Finally, we allow the adversary to choose t t t adaptively. Guessing t ∈ [ T ] t\in[T] t ∈ [ T ] loses a factor of at most T T T , so the soundness error remains T ⋅ negl ( T ) = negl ( T ) T\cdot\operatorname{negl}(T)=\operatorname{negl}(T) T ⋅ negl ( T ) = negl ( T ) , which is negligible in λ \lambda λ since T > λ T>\lambda T > λ . The case t = 0 t=0 t = 0 follows from the initial-state check.
Fully succinct deterministic computations. For deterministic computations, we can remove the dependence on S S S by using the compressed configurations of § 6.5 . We assume that the oracle queries and answers have length at most ℓ = poly ( λ , log T ) \ell=\operatorname{poly}(\lambda,\log T) ℓ = poly ( λ , log T ) .
For a full configuration C C C , let C ~ = Comp h k ( C ) \widetilde{C}=\operatorname{Comp}_{\mathsf{hk}}(C) C = Comp hk ( C ) denote its compressed representation, as in Theorem 35, in which the work tape is represented by its hash. In this variant, the IVC certifies compressed configurations C ~ t = Comp h k ( C t ) \widetilde{C}_t=\operatorname{Comp}_{\mathsf{hk}}(C_t) C t = Comp hk ( C t ) , rather than full configurations C t C_t C t .20 We modify the construction above as follows. The transition records have the form
D i = ( i , v k , h k , v x , C ~ i − 1 , C ~ i ) , v x = HT . Hash ( h k , x ) . D_i=(i,\mathsf{vk},\mathsf{hk},v_x,\widetilde{C}_{i-1},\widetilde{C}_i),\qquad v_x=\operatorname{HT}.\operatorname{Hash}(\mathsf{hk},x). D i = ( i , vk , hk , v x , C i − 1 , C i ) , v x = HT . Hash ( hk , x ) .
We use the same UpBARG construction, with a local relation R s i g c o m p R_{\mathrm{sig}}^{\mathrm{comp}} R sig comp for these records and the same consistency predicate on consecutive records.
The local relation checks transitions between compressed configurations, as in § 6.5 . For an ordinary transition, the witness contains the work-tape bit being read and its local opening. The relation verifies this opening with respect to the work-tape hash in C ~ i − 1 \widetilde{C}_{i-1} C i − 1 . If the transition writes a bit to the work tape, the relation checks the new work-tape hash using HT . VerifyUpdate \operatorname{HT}.\operatorname{VerifyUpdate} HT . VerifyUpdate ; otherwise, it checks that the work-tape hash remains unchanged. It also checks that all explicit fields follow the prescribed transition. Whenever the machine reads an input bit, the witness additionally contains a local opening authenticating this bit with respect to v x v_x v x .
For an oracle transition, the relation checks that the explicit fields follow the prescribed oracle transition, that the work-tape hash remains unchanged, and that the oracle answer is accompanied by a verifying signature. The initial consistency check requires the prescribed initial compressed configuration, whose blank work-tape hash can be computed efficiently by Theorem 34. Unlike R s h o r t R_{\mathrm{short}} R short of § 6.5 , this relation does not authenticate an entire transcript or require the final configuration to be accepting.
The update algorithm has the same syntax as in Theorem 39, with C ~ t \widetilde{C}_t C t in place of C t C_t C t . At an ordinary step, the local witness w t + 1 w_{t+1} w t + 1 contains the work-tape bit being read and its authentication path, together with an authenticated input bit when needed. If the prescribed transition writes to the work tape, w t + 1 w_{t+1} w t + 1 additionally contains the proposed updated work-tape root. The updater verifies the local openings and checks the proposed root using HT.VerifyUpdate, with the written bit determined by the prescribed transition. If no work-tape cell is written, it retains the current root. It then forms C ~ t + 1 \widetilde{C}_{t+1} C t + 1 from this root and the prescribed updates to the explicit fields, without accessing the entire work tape. At an oracle step, the updater obtains the answer and its signature from O s i g \mathcal{O}_{\mathrm{sig}} O sig , as in the construction above. It then updates the two UpBARG proofs and outputs ( C ~ t + 1 , π t + 1 ) (\widetilde{C}_{t+1},\pi_{t+1}) ( C t + 1 , π t + 1 ) .
The honest prover can generate the required local openings and updated roots by maintaining a dynamic Merkle tree alongside the computation. Since the work tape is initially blank, the tree can be initialized implicitly, without processing all S S S cells. Each read or write accesses or updates only O ( log T ) O(\log T) O ( log T ) authentication nodes, and hence requires poly ( λ , log T ) \operatorname{poly}(\lambda,\log T) poly ( λ , log T ) time. This auxiliary data structure is not part of the maintained IVC proof.
For polynomially bounded T T T , we set the underlying security parameter to κ = λ \kappa=\lambda κ = λ . For larger time bounds, we use κ = poly ( λ , log T ) \kappa=\operatorname{poly}(\lambda,\log T) κ = poly ( λ , log T ) , assuming the corresponding strengthened security guarantees for the UpBARG, hash family, and signature scheme, as in § 6.5 . Consequently, the public parameters, compressed configurations, and IVC proofs have length poly ( λ , log T ) \operatorname{poly}(\lambda,\log T) poly ( λ , log T ) , and proof update and verification take time n ⋅ poly ( λ , log T ) n\cdot\operatorname{poly}(\lambda,\log T) n ⋅ poly ( λ , log T ) . Neither setup nor verification makes oracle calls.
Formally, define the compressed reachability set
Reach ~ t O ( x ; h k ) = { Comp h k ( C ) : C ∈ Reach t O ( x ) } . \widetilde{\operatorname{Reach}}^{\mathcal{O}}_t(x;\mathsf{hk})=\{\operatorname{Comp}_{\mathsf{hk}}(C):C\in\operatorname{Reach}^{\mathcal{O}}_t(x)\}. Reach t O ( x ; hk ) = { Comp hk ( C ) : C ∈ Reach t O ( x )} .
Soundness of this variant is defined with respect to membership in this set. Since M M M is deterministic, this set contains the compressed configuration of the unique honest execution. As in § 6.5 , soundness follows the unique honest execution, rather than enumerating the configuration graph. The proof uses the same neighboring-record consistency argument as above, together with the local-update soundness argument of § 6.5 .
Privately Verifiable IVC for Robust Computations
We next turn to the setting of Section 5. Here the preceding argument does not apply. An unsigned oracle answer cannot be checked inside an ordinary NP relation, and the verifier must query O \mathcal{O} O itself.
The construction is based on grouping the computation into blocks, one block for each oracle call. More precisely, let A j − 1 A_{j-1} A j − 1 denote the configuration immediately after the ( j − 1 ) (j-1) ( j − 1 ) st oracle call, let B j B_j B j denote the configuration immediately before the j j j th oracle call, and let A j A_j A j denote the configuration immediately after it. The j j j th block therefore has the form
A j − 1 ⇝ B j → ( q j , a j ) A j , A_{j-1}\mathrel{\rightsquigarrow}B_j\xrightarrow{(q_j,a_j)}A_j, A j − 1 ⇝ B j ( q j , a j ) A j ,
where the first part consists only of ordinary transitions, and the last transition is the j j j th oracle call, with query q j q_j q j and purported answer a j a_j a j .
Importantly, the computation from configuration A j − 1 A_{j-1} A j − 1 to configuration B j B_j B j uses only ordinary transitions. Hence we can use a standard IVC proof to certify that B j B_j B j is reachable from A j − 1 A_{j-1} A j − 1 . Thus, each block proof contains the two boundary configurations of the ordinary interval, a short proof for the ordinary interval, and the following oracle transition.
This grouping is useful because robustness is measured with respect to the number of oracle calls, rather than the total number of computation steps. Hence, if a purported execution reaches a false ε \varepsilon ε -robust endpoint, then at least an ε \varepsilon ε -fraction of these blocks contain an incorrect oracle answer. The private verifier can therefore detect cheating by extracting and checking the query-answer pairs in a small number of hidden, randomly chosen blocks.
Ordinary intervals. Fix an oracle-aided Turing machine M M M with time bound T T T and space bound S S S on inputs of length n n n , and fix an input x ∈ { 0 , 1 } n x \in\{0,1\}^n x ∈ { 0 , 1 } n . We define the ordinary-execution relation R o r d x R_{\mathrm{ord}}^x R ord x as follows, suppressing its dependence on M M M , T T T , and S S S in the notation:
R o r d x ( ( A , B , ℓ ) , τ ) = 1 R_{\mathrm{ord}}^x((A,B,\ell),\tau)=1 R ord x (( A , B , ℓ ) , τ ) = 1
if and only if 0 ≤ ℓ ≤ T 0 \le\ell\le T 0 ≤ ℓ ≤ T and τ = ( C 0 , … , C ℓ ) \tau=(C_0,\ldots,C_\ell) τ = ( C 0 , … , C ℓ ) is a sequence of configurations such that C 0 = A C_0=A C 0 = A , C ℓ = B C_\ell=B C ℓ = B , and every transition C i − 1 → C i C_{i-1}\to C_i C i − 1 → C i is a valid ordinary transition of M M M on input x x x . In particular, none of these transitions is an oracle transition. Define the corresponding reachability language
L o r d x = { ( A , B , ℓ ) : ∃ τ such that R o r d x ( ( A , B , ℓ ) , τ ) = 1 } . L_{\mathrm{ord}}^x=\{(A,B,\ell):\exists\tau\text{ such that }R_{\mathrm{ord}}^x((A,B,\ell),\tau)=1\}. L ord x = {( A , B , ℓ ) : ∃ τ such that R ord x (( A , B , ℓ ) , τ ) = 1 } .
Thus, ( A , B , ℓ ) ∈ L o r d x (A,B,\ell)\in L_{\mathrm{ord}}^x ( A , B , ℓ ) ∈ L ord x if and only if B B B can be reached from A A A in exactly ℓ \ell ℓ ordinary transitions. We allow ℓ = 0 \ell=0 ℓ = 0 , in which case membership requires A = B A=B A = B .
We use the publicly verifiable IVC scheme from § 7.4 restricted to ordinary transitions, denoted by OrdIVC.21 As in § 7.4 , the input x x x is represented by its authenticated hash
v x = Hash ( h k , x ) , v_x=\operatorname{Hash}(\mathrm{hk},x), v x = Hash ( hk , x ) ,
and we authenticate input-tape accesses using local openings. Thus, writing θ = ( c r s o r d , h k , v x ) \theta=(\mathrm{crs}_{\mathrm{ord}},\mathrm{hk},v_x) θ = ( crs ord , hk , v x ) , where c r s o r d \mathrm{crs}_{\mathrm{ord}} crs ord denotes the common reference string of OrdIVC, which we assume includes the prescribed input length n n n , time bound T T T , and space bound S S S , the verifier checks a proof π \pi π for the claim that ( A , B , ℓ ) ∈ L o r d x (A,B,\ell)\in L_{\mathrm{ord}}^x ( A , B , ℓ ) ∈ L ord x by checking that
OrdIVC.Verify ( θ , ( A , B , ℓ ) , π ) = 1. \operatorname{OrdIVC.Verify}(\theta,(A,B,\ell),\pi)=1. OrdIVC.Verify ( θ , ( A , B , ℓ ) , π ) = 1.
The proof π \pi π has length poly ( λ , S , log T ) \operatorname{poly}(\lambda,S,\log T) poly ( λ , S , log T ) and can be updated after each ordinary transition without redoing the computation (or remembering the execution trace).
Oracle-call records. Consider a purported execution on input x x x , and set A 0 = C i n i t ( x ) A_0=C_{\mathrm{init}}(x) A 0 = C init ( x ) . Let B j B_j B j be the configuration immediately before the j j j th oracle call, and let A j A_j A j be the configuration immediately after it. Define
D j = ( A j − 1 , B j , A j ) and ℓ j = time ( B j ) − time ( A j − 1 ) . (8) D_j=(A_{j-1},B_j,A_j)\qquad\text{and}\qquad\ell_j=\operatorname{time}(B_j)-\operatorname{time}(A_{j-1}). \tag*{(8)} D j = ( A j − 1 , B j , A j ) and ℓ j = time ( B j ) − time ( A j − 1 ) . (8)
Thus, ℓ j \ell_j ℓ j is determined by D j D_j D j .
The statement supplied to the UpBARG is ( θ , D j ) (\theta, D_j) ( θ , D j ) . Its witness is an ordinary-IVC proof π j \pi_j π j for the interval ( A j − 1 , B j , ℓ j ) (A_{j-1}, B_j, \ell_j) ( A j − 1 , B j , ℓ j ) . More precisely, we define an oracle-free NP relation R b l o c k R_{\mathrm{block}} R block as follows. For D = ( A − , B , A ) D=(A^{-},B,A) D = ( A − , B , A ) , the relation
R b l o c k ( ( θ , D ) , π ) = 1 R_{\mathrm{block}}((\theta,D),\pi)=1 R block (( θ , D ) , π ) = 1
if and only if all of the following hold:
The configurations in D D D are well formed and respect the prescribed space and time bounds.
Setting ℓ = time ( B ) − time ( A − ) \ell=\operatorname{time}(B)-\operatorname{time}(A^{-}) ℓ = time ( B ) − time ( A − ) , we have 0 ≤ ℓ ≤ T 0\le\ell\le T 0 ≤ ℓ ≤ T .
The oracle-call counters in A − A^{-} A − and B B B agree; namely queries ( A − ) = queries ( B ) \operatorname{queries}(A^{-})=\operatorname{queries}(B) queries ( A − ) = queries ( B ) .
The ordinary-IVC proof verifies:
OrdIVC.Verify ( θ , ( A − , B , ℓ ) , π ) = 1. \operatorname{OrdIVC.Verify}(\theta,(A^{-},B,\ell),\pi)=1. OrdIVC.Verify ( θ , ( A − , B , ℓ ) , π ) = 1.
B B B is an oracle-query configuration, and A A A is obtained from B B B by applying the prescribed oracle transition using the answer recorded in A A A . In particular,
time ( A ) = time ( B ) + 1 and queries ( A ) = queries ( B ) + 1. \operatorname{time}(A)=\operatorname{time}(B)+1 \quad\text{and}\quad\operatorname{queries}(A)=\operatorname{queries}(B)+1. time ( A ) = time ( B ) + 1 and queries ( A ) = queries ( B ) + 1.
Let ( u , a ) (u,a) ( u , a ) be the query-answer pair specified by ( B , A ) (B,A) ( B , A ) . The fifth condition checks the machine’s transition using the supplied answer a a a ; it does not check that a = O ( u ) a=O(u) a = O ( u ) . Consequently, R b l o c k R_{\mathrm{block}} R block makes no oracle calls.
Define the corresponding NP language
L b l o c k = { ( θ , D ) : ∃ π such that R b l o c k ( ( θ , D ) , π ) = 1 } . L_{\mathrm{block}}=\{(\theta,D):\exists\pi\text{ such that }R_{\mathrm{block}}((\theta,D),\pi)=1\}. L block = {( θ , D ) : ∃ π such that R block (( θ , D ) , π ) = 1 } .
Consistency. For records D = ( A − , B , A ) D=(A^{-},B,A) D = ( A − , B , A ) and D ′ = ( A ′ − , B ′ , A ′ ) D'=(A'^{-},B',A') D ′ = ( A ′ − , B ′ , A ′ ) , define
Cons ( ( θ , D ) , ( θ ′ , D ′ ) ) = 1 \operatorname{Cons}((\theta,D),(\theta',D'))=1 Cons (( θ , D ) , ( θ ′ , D ′ )) = 1
if and only if
θ = θ ′ and A = A ′ − . \theta=\theta' \quad\text{and}\quad A=A'^{-}. θ = θ ′ and A = A ′ − .
For the first record, Cons ( ⊥ , ( θ , D ) ) = 1 \operatorname{Cons}(\perp,(\theta,D))=1 Cons ( ⊥ , ( θ , D )) = 1 if and only if A − A^{-} A − is the prescribed initial configuration for inputs of length n n n , with both the step counter and the oracle-call counter equal to zero. As in § 7.4 , the read-only input is represented externally by v x v_x v x .
The privately verifiable IVC scheme
Our construction uses the following ingredients:
OrdIVC = ( OrdIVC.Gen , OrdIVC.Update , OrdIVC.Verify ) . \operatorname{OrdIVC}=(\operatorname{OrdIVC.Gen},\operatorname{OrdIVC.Update},\operatorname{OrdIVC.Verify}). OrdIVC = ( OrdIVC.Gen , OrdIVC.Update , OrdIVC.Verify ) .
This scheme authenticates input-tape accesses using local openings to v x v_x v x .
An updatable batch argument UpBARG for ( R b l o c k , Cons ) (R_{\mathrm{block}},\operatorname{Cons}) ( R block , Cons ) , as defined in § 7.3 , associated with the hash family HT.
Setup. Fix a robustness parameter ε ∈ ( 0 , 1 ] \varepsilon\in(0,1] ε ∈ ( 0 , 1 ] , and let Q ≥ 1 Q \ge1 Q ≥ 1 be an upper bound on the number of oracle calls. The algorithm I V C . G e n ( 1 λ , n , T , ε ) \mathrm{IVC.Gen}(1^\lambda,n,T,\varepsilon) IVC.Gen ( 1 λ , n , T , ε ) proceeds as follows:
Set r = ⌈ 2 λ ε ⌉ r = \left\lceil\frac{2\lambda}{\varepsilon} \right\rceil r = ⌈ ε 2 λ ⌉ and H = ⌈ log 2 Q ⌉ H = \lceil\log_2 Q \rceil H = ⌈ log 2 Q ⌉ .
Set κ = poly ( λ , S , log T , log ( 1 / ε ) ) \kappa= \operatorname{poly}(\lambda,S,\log T,\log(1/\varepsilon)) κ = poly ( λ , S , log T , log ( 1/ ε )) .
Generate h k ← H T . G e n ( 1 κ ) \mathrm{hk} \leftarrow\mathrm{HT.Gen}(1^\kappa) hk ← HT.Gen ( 1 κ ) .
Generate public parameters c r s o r d ← O r d I V C . G e n ( 1 κ , n , T ) \mathrm{crs}_{\mathrm{ord}} \leftarrow\mathrm{OrdIVC.Gen}(1^\kappa,n,T) crs ord ← OrdIVC.Gen ( 1 κ , n , T ) .
For every h ∈ { 0 , … , H } h \in\{0,\ldots,H\} h ∈ { 0 , … , H } : (a) Set K h = 2 h K_h = 2^h K h = 2 h . (b) Independently sample j h , 1 , … , j h , r ← [ K h ] j_{h,1},\ldots,j_{h,r} \leftarrow[K_h] j h , 1 , … , j h , r ← [ K h ] . (c) For every i ∈ [ r ] i \in[r] i ∈ [ r ] , generate ( c r s h , i , t d h , i ) ← U p B A R G . T G e n ( 1 κ , j h , i ) (\mathrm{crs}_{h,i},\mathrm{td}_{h,i}) \leftarrow\mathrm{UpBARG.TGen}(1^\kappa,j_{h,i}) ( crs h , i , td h , i ) ← UpBARG.TGen ( 1 κ , j h , i ) . (d) Set c r s h = ( c r s h , i ) i ∈ [ r ] \mathrm{crs}_h = (\mathrm{crs}_{h,i})_{i\in[r]} crs h = ( crs h , i ) i ∈ [ r ] , t d h = ( ( j h , i , t d h , i ) ) i ∈ [ r ] \mathrm{td}_h = ((j_{h,i},\mathrm{td}_{h,i}))_{i\in[r]} td h = (( j h , i , td h , i ) ) i ∈ [ r ] .
Output c r s = ( h k , c r s o r d , ( c r s h ) h = 0 H ) \mathrm{crs} = (\mathrm{hk},\mathrm{crs}_{\mathrm{ord}},(\mathrm{crs}_h)_{h=0}^{H}) crs = ( hk , crs ord , ( crs h ) h = 0 H ) and t d = ( t d h ) h = 0 H \mathrm{td} = (\mathrm{td}_h)_{h=0}^{H} td = ( td h ) h = 0 H .
Setup makes no oracle calls.
Remark 48. We use several scales because the number q q q of oracle calls made by the current prefix is not known at setup time and may itself be chosen adaptively after seeing the public parameters.
The maintained IVC proof. For an input x x x , let
v x = H T . H a s h ( h k , x ) , θ = ( c r s o r d , h k , v x ) . v_x = \mathrm{HT.Hash}(\mathrm{hk},x), \qquad\theta= (\mathrm{crs}_{\mathrm{ord}},\mathrm{hk},v_x). v x = HT.Hash ( hk , x ) , θ = ( crs ord , hk , v x ) .
For each record D j D_j D j , denote the corresponding UpBARG statement by
Z j = ( θ , D j ) . Z_j = (\theta,D_j). Z j = ( θ , D j ) .
After a prefix ending at configuration C t C_t C t and containing q q q oracle calls, the prover maintains ( C t , π t ) (C_t,\pi_t) ( C t , π t ) where
π t = ( v , ( Π h , i ) 0 ≤ h ≤ H i ∈ [ r ] , D l a s t , η ) \pi_t = \left(v,(\Pi_{h,i})_{\substack{0\le h\le H\\i\in[r]}},D_{\mathrm{last}},\eta\right) π t = ( v , ( Π h , i ) 0 ≤ h ≤ H i ∈ [ r ] , D last , η )
satisfies the following properties:
v v v is the hash of the sequence Z 1 , … , Z q Z_1,\ldots,Z_q Z 1 , … , Z q , and Π h , i \Pi_{h,i} Π h , i is a UpBARG proof that Z 1 , … , Z q ∈ L b l o c k Z_1,\ldots,Z_q \in L_{\mathrm{block}} Z 1 , … , Z q ∈ L block and that they satisfy the consistency condition C o n s \mathrm{Cons} Cons , under c r s h , i \mathrm{crs}_{h,i} crs h , i .
( A q , C t , time ( C t ) − time ( A q ) ) , (A_q,C_t,\operatorname{time}(C_t)-\operatorname{time}(A_q)), ( A q , C t , time ( C t ) − time ( A q )) ,
with respect to θ \theta θ , where A 0 = C i n i t ( x ) A_0 = C_{\mathrm{init}}(x) A 0 = C init ( x ) .
Initially, C 0 = C i n i t ( x ) C_0 = C_{\mathrm{init}}(x) C 0 = C init ( x ) and π 0 = ⊥ \pi_0 = \bot π 0 = ⊥ . We interpret this initial proof as the state in which v = ⊥ v = \bot v = ⊥ , every Π h , i = ⊥ \Pi_{h,i} = \bot Π h , i = ⊥ , D l a s t = ⊥ D_{\mathrm{last}} = \bot D last = ⊥ , and η \eta η is the ordinary-IVC proof for the zero-length interval ( A 0 , A 0 , 0 ) (A_0,A_0,0) ( A 0 , A 0 , 0 ) .
Proof updates. The algorithm I V C . U p d a t e O ( c r s , x , t , C t , π t , w t + 1 ) \mathrm{IVC.Update}^{\mathcal{O}}(\mathrm{crs},x,t,C_t,\pi_t,w_{t+1}) IVC.Update O ( crs , x , t , C t , π t , w t + 1 ) updates the maintained proof as follows:
Ordinary transition. Compute C t + 1 C_{t+1} C t + 1 using the prescribed transition and the local non-deterministic choice, if any. Update η \eta η using the ordinary-IVC update algorithm. The hash v v v , the UpBARG proofs, and D l a s t D_{\mathrm{last}} D last remain unchanged.
D q + 1 = ( A q , B q + 1 , A q + 1 ) , Z q + 1 = ( θ , D q + 1 ) . D_{q+1}=(A_q,B_{q+1},A_{q+1}), \qquad Z_{q+1}=(\theta,D_{q+1}). D q + 1 = ( A q , B q + 1 , A q + 1 ) , Z q + 1 = ( θ , D q + 1 ) .
The current proof η \eta η is a witness for R b l o c k ( Z q + 1 , η ) = 1 R_{\mathrm{block}}(Z_{q+1},\eta)=1 R block ( Z q + 1 , η ) = 1 .
Set Z l a s t = ⊥ Z_{\mathrm{last}}=\bot Z last = ⊥ if q = 0 q=0 q = 0 , and Z l a s t = ( θ , D q ) Z_{\mathrm{last}}=(\theta,D_q) Z last = ( θ , D q ) otherwise. For every h ∈ { 0 , … , H } h\in\{0,\ldots,H\} h ∈ { 0 , … , H } and i ∈ [ r ] i\in[r] i ∈ [ r ] , compute
( v h , i ′ , Π h , i ′ ) ← U p B A R G . U p d a t e ( h k , c r s h , i , v , Π h , i , Z l a s t , Z q + 1 , η ) . (v'_{h,i},\Pi'_{h,i})\leftarrow\mathrm{UpBARG.Update}(\mathrm{hk},\mathrm{crs}_{h,i},v,\Pi_{h,i},Z_{\mathrm{last}},Z_{q+1},\eta). ( v h , i ′ , Π h , i ′ ) ← UpBARG.Update ( hk , crs h , i , v , Π h , i , Z last , Z q + 1 , η ) .
All resulting hash values equal
v ′ = H T . A p p e n d ( h k , v , Z q + 1 ) . v'=\mathrm{HT.Append}(\mathrm{hk},v,Z_{q+1}). v ′ = HT.Append ( hk , v , Z q + 1 ) .
Replace v v v by v ′ v' v ′ , replace each Π h , i \Pi_{h,i} Π h , i by Π h , i ′ \Pi'_{h,i} Π h , i ′ , and set D l a s t = D q + 1 D_{\mathrm{last}}=D_{q+1} D last = D q + 1 . Initialize η \eta η to be the ordinary-IVC proof for the zero-length interval ( A q + 1 , A q + 1 , 0 ) (A_{q+1},A_{q+1},0) ( A q + 1 , A q + 1 , 0 ) .
The update uses no private verification key and does not require the preceding execution trace.
Verification. The algorithm I V C . V O ( c r s , t d , x , t , C , π ) \mathrm{IVC.V}^{\mathcal{O}}(\mathrm{crs},\mathrm{td},x,t,C,\pi) IVC.V O ( crs , td , x , t , C , π ) proceeds as follows. It rejects if any parsing operation or required check fails.
Check that ∣ x ∣ = n |x|=n ∣ x ∣ = n that 0 ≤ t ≤ T 0\leq t\leq T 0 ≤ t ≤ T .
Check that C C C is a well-formed configuration respecting the prescribed space bound and satisfying time ( C ) = t \operatorname{time}(C)=t time ( C ) = t . Set q = queries ( C ) q=\operatorname{queries}(C) q = queries ( C ) and check that 0 ≤ q ≤ min { Q , t } 0\leq q\leq\min\{Q,t\} 0 ≤ q ≤ min { Q , t } .
Parse c r s = ( h k , c r s o r d , ( c r s h ) h = 0 H ) \mathrm{crs}=(\mathrm{hk},\mathrm{crs}_{\mathrm{ord}},(\mathrm{crs}_h)_{h=0}^{H}) crs = ( hk , crs ord , ( crs h ) h = 0 H ) .
Compute
v x = H T . H a s h ( h k , x ) , θ = ( c r s o r d , h k , v x ) . v_x=\mathrm{HT.Hash}(\mathrm{hk},x), \qquad\theta=(\mathrm{crs}_{\mathrm{ord}},\mathrm{hk},v_x). v x = HT.Hash ( hk , x ) , θ = ( crs ord , hk , v x ) .
If t = 0 t=0 t = 0 , accept if and only if C = C i n i t ( x ) C=C_{\mathrm{init}}(x) C = C init ( x ) and π = ⊥ \pi=\bot π = ⊥ . Otherwise, continue.
Parse π = ( v , ( Π h , i ) 0 ≤ h ≤ H i ∈ [ r ] , D l a s t , η ) \pi=(v,(\Pi_{h,i})_{\substack{0\leq h\leq H\\i\in[r]}},D_{\mathrm{last}},\eta) π = ( v , ( Π h , i ) 0 ≤ h ≤ H i ∈ [ r ] , D last , η ) and check that H T . S i z e ( v ) = q \mathrm{HT.Size}(v)=q HT.Size ( v ) = q .
If q = 0 q=0 q = 0 , check that v = ⊥ v=\bot v = ⊥ and that D l a s t = ⊥ D_{\mathrm{last}}=\bot D last = ⊥ and Π h , i = ⊥ \Pi_{h,i}=\bot Π h , i = ⊥ for every h ∈ { 0 , … , H } h\in\{0,\ldots,H\} h ∈ { 0 , … , H } and i ∈ [ r ] i\in[r] i ∈ [ r ] , and accept if and only if all these checks pass and
O r d I V C . V e r i f y ( θ , ( C i n i t ( x ) , C , t ) , η ) = 1. \mathrm{OrdIVC.Verify}(\theta,(C_{\mathrm{init}}(x),C,t),\eta)=1. OrdIVC.Verify ( θ , ( C init ( x ) , C , t ) , η ) = 1.
If q > 0 q > 0 q > 0 , parse D l a s t = ( A q − 1 , B q , A q ) D_{\mathrm{last}} = (A_{q-1}, B_q, A_q) D last = ( A q − 1 , B q , A q ) , and check that these configurations are well formed, satisfy the space bound restriction, and satisfy the following conditions:
queries ( A q − 1 ) = queries ( B q ) = q − 1 , queries ( A q ) = q \operatorname{queries}(A_{q-1}) = \operatorname{queries}(B_q) = q - 1,\qquad\operatorname{queries}(A_q) = q queries ( A q − 1 ) = queries ( B q ) = q − 1 , queries ( A q ) = q
and
0 ≤ time ( A q − 1 ) ≤ time ( B q ) , time ( A q ) = time ( B q ) + 1 ≤ t . 0 \le\operatorname{time}(A_{q-1}) \le\operatorname{time}(B_q),\qquad\operatorname{time}(A_q) = \operatorname{time}(B_q) + 1 \le t. 0 ≤ time ( A q − 1 ) ≤ time ( B q ) , time ( A q ) = time ( B q ) + 1 ≤ t .
Set Z l a s t = ( θ , D l a s t ) Z_{\mathrm{last}} = (\theta, D_{\mathrm{last}}) Z last = ( θ , D last ) .
For every h ∈ { 0 , … , H } h \in\{0, \ldots, H\} h ∈ { 0 , … , H } and i ∈ [ r ] i \in[r] i ∈ [ r ] , check that
UpBARG.Ver ( h k , c r s h , i , v , Π h , i , Z l a s t ) = 1. \operatorname{UpBARG.Ver}(\mathrm{hk},\mathrm{crs}_{h,i}, v, \Pi_{h,i}, Z_{\mathrm{last}}) = 1. UpBARG.Ver ( hk , crs h , i , v , Π h , i , Z last ) = 1.
Set ℓ t a i l = t − time ( A q ) \ell_{\mathrm{tail}} = t - \operatorname{time}(A_q) ℓ tail = t − time ( A q ) , and check that
OrdIVC.Verify ( θ , ( A q , C , ℓ t a i l ) , η ) = 1. \operatorname{OrdIVC.Verify}(\theta, (A_q, C, \ell_{\mathrm{tail}}), \eta) = 1. OrdIVC.Verify ( θ , ( A q , C , ℓ tail ) , η ) = 1.
Set h ∗ = ⌈ log 2 q ⌉ h^* = \lceil\log_2 q \rceil h ∗ = ⌈ log 2 q ⌉ and K = 2 h ∗ K = 2^{h^*} K = 2 h ∗ . Thus q ≤ K < 2 q q \le K < 2q q ≤ K < 2 q .
Parse t d = ( t d h ) h = 0 H \mathrm{td} = (\mathrm{td}_h)_{h=0}^{H} td = ( td h ) h = 0 H , and parse t d h ∗ = ( j h ∗ , i , t d h ∗ , i ) i ∈ [ r ] \mathrm{td}_{h^*} = (j_{h^*,i}, \mathrm{td}_{h^*,i})_{i \in[r]} td h ∗ = ( j h ∗ , i , td h ∗ , i ) i ∈ [ r ] .
For each i ∈ [ r ] i \in[r] i ∈ [ r ] , perform the following private check:
(a) Read ( j , t d h ∗ , i ) (j, \mathrm{td}_{h^*,i}) ( j , td h ∗ , i ) from the i i i th entry of t d h ∗ \mathrm{td}_{h^*} td h ∗ . If j > q j > q j > q , skip this component.
(b) Otherwise, compute
( Z ^ , ρ , π ^ , Z ^ p r e v , ρ p r e v ) ← UpBARG.Extract ( h k , t d h ∗ , i , v , Π h ∗ , i ) . (\widehat{Z}, \rho, \widehat{\pi}, \widehat{Z}^{\mathrm{prev}}, \rho^{\mathrm{prev}}) \leftarrow\operatorname{UpBARG.Extract}(\mathrm{hk}, \mathrm{td}_{h^*,i}, v, \Pi_{h^*,i}). ( Z , ρ , π , Z prev , ρ prev ) ← UpBARG.Extract ( hk , td h ∗ , i , v , Π h ∗ , i ) .
(c) Check that Z ^ = ( θ , D ^ ) \widehat{Z} = (\theta, \widehat{D}) Z = ( θ , D ) for some D ^ = ( U , B , A ) \widehat{D} = (U, B, A) D = ( U , B , A ) with
queries ( U ) = queries ( B ) = j − 1 , queries ( A ) = j . \operatorname{queries}(U) = \operatorname{queries}(B) = j - 1,\qquad\operatorname{queries}(A) = j. queries ( U ) = queries ( B ) = j − 1 , queries ( A ) = j .
Check that
HT.Verify ( h k , v , j , Z ^ , ρ ) = 1 and R b l o c k ( Z ^ , π ^ ) = 1. \operatorname{HT.Verify}(\mathrm{hk}, v, j, \widehat{Z}, \rho) = 1\quad\text{and}\quad R_{\mathrm{block}}(\widehat{Z}, \widehat{\pi}) = 1. HT.Verify ( hk , v , j , Z , ρ ) = 1 and R block ( Z , π ) = 1.
(d) If j = 1 j = 1 j = 1 , check that Z ^ p r e v = ρ p r e v = ⊥ \widehat{Z}^{\mathrm{prev}} = \rho^{\mathrm{prev}} = \perp Z prev = ρ prev =⊥ .
If j > 1 j > 1 j > 1 , check that Z ^ p r e v \widehat{Z}^{\mathrm{prev}} Z prev begins with θ \theta θ and that
HT.Verify ( h k , v , j − 1 , Z ^ p r e v , ρ p r e v ) = 1. \operatorname{HT.Verify}(\mathrm{hk}, v, j - 1, \widehat{Z}^{\mathrm{prev}}, \rho^{\mathrm{prev}}) = 1. HT.Verify ( hk , v , j − 1 , Z prev , ρ prev ) = 1.
In either case, check that
Cons ( Z ^ p r e v , Z ^ ) = 1. \operatorname{Cons}(\widehat{Z}^{\mathrm{prev}}, \widehat{Z}) = 1. Cons ( Z prev , Z ) = 1.
(e) If j = q j = q j = q , also check that Z ^ = Z l a s t \widehat{Z} = Z_{\mathrm{last}} Z = Z last .
(f) Let ( u , a ) (u, a) ( u , a ) be the query-answer pair specified by the oracle transition from B B B to A A A . Query O ( u ) \mathcal{O}(u) O ( u ) and check that a = O ( u ) a = \mathcal{O}(u) a = O ( u ) .
Accept if all checks pass.
The verifier makes at most r = O ( λ / ε ) r = O(\lambda/\varepsilon) r = O ( λ / ε ) oracle calls.
Theorem 49. Let M M M be a (possibly non-deterministic) time-T T T , space-S S S oracle-aided machine. We assume that the underlying primitives, UpBARG, HT, and (ordinary) IVC, are sub-exponentially secure, even given oracle access to O \mathcal{O} O . Then there exists a privately verifiable IVC for ε \varepsilon ε -robust oracle-aided computations.
Its public parameters, private verification key, and proof have length poly ( λ , S , log T , 1 / ε ) \operatorname{poly}(\lambda, S, \log T, 1/\varepsilon) poly ( λ , S , log T , 1/ ε ) .
Proof updates take time poly ( n , λ , S , log T , 1 / ε ) \operatorname{poly}(n, \lambda, S, \log T, 1/\varepsilon) poly ( n , λ , S , log T , 1/ ε ) .
Verification takes time poly ( n , λ , S , log T , 1 / ε ) \operatorname{poly}(n, \lambda, S, \log T, 1/\varepsilon) poly ( n , λ , S , log T , 1/ ε ) , and makes O ( λ / ε ) O(\lambda/\varepsilon) O ( λ / ε ) calls to O \mathcal{O} O . Setup makes no oracle calls.
Proof of Theorem 49. For completeness, first consider the experiment in which all outer reference strings are generated by UpBARG.Gen ( 1 κ ) \operatorname{UpBARG.Gen}(1^\kappa) UpBARG.Gen ( 1 κ ) . Completeness of OrdIVC, incremental completeness of UpBARG, and correctness of the hash family ensure that all public checks accept on an honest execution. Replace these reference strings, one at a time, by outputs of UpBARG.TGen ( 1 κ , j h i ) \operatorname{UpBARG.TGen}(1^\kappa, j_h{}_i) UpBARG.TGen ( 1 κ , j h i ) . In each hybrid, rerun the algorithm choosing the input and honest execution, followed by the prescribed proof updates. Public-check failure can be tested without any extraction trapdoor, in time poly ( T ∗ ) \operatorname{poly}(T^*) poly ( T ∗ ) with access to O \mathcal{O} O , where T ∗ T^* T ∗ is specified below. Thus, the strengthened index-hiding guarantee changes its probability by at most negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) per hybrid. Since there are r ( H + 1 ) ≤ poly ( T ∗ ) r(H+1) \le\operatorname{poly}(T^*) r ( H + 1 ) ≤ poly ( T ∗ ) components, all public checks accept in the real experiment except with probability negl ( T ∗ ) \operatorname{negl}(T^*) negl ( T ∗ ) .
In the real experiment, the somewhere argument-of-knowledge property ensures that, except with negligible probability, every unskipped extraction from an accepting component provides a valid witness and hash openings. By collision resistance with respect to opening, the extracted records agree with the corresponding records of the honest execution. Hence all private checks also accept. This proves adaptive completeness.
We prove adaptive soundness. To this end, as in Section 5, let
T ∗ = 2 O ( S ) poly ( n , T , λ , 1 / ε ) T^* = 2^{O(S)}\operatorname{poly}(n,T,\lambda,1/\varepsilon) T ∗ = 2 O ( S ) poly ( n , T , λ , 1/ ε )
be large enough to bound the reductions below. We assume that the primitives, instantiated with the chosen security parameter κ \kappa κ , satisfy the required security properties against the corresponding oracle-aided algorithms, with errors negligible in T ∗ T^* T ∗ .
Throughout the proof, δ = negl ( T ∗ ) \delta= \operatorname{negl}(T^*) δ = negl ( T ∗ ) denotes a negligible error term, which may increase to absorb polynomially many primitive-security errors. The bounds are uniform over the indices used below. In particular, the final accumulated error satisfies
Q ( r − 1 ) δ = negl ( λ ) . Q(r-1)\delta= \operatorname{negl}(\lambda). Q ( r − 1 ) δ = negl ( λ ) .
Fix an oracle O \mathcal{O} O independently of setup and an adversary with access to O \mathcal{O} O . Let ( x , t , C , π ) (x,t,C,\pi) ( x , t , C , π ) be the output of the adversary, and let q q q be the claimed number of oracle calls. If t = 0 t=0 t = 0 , the verifier accepts only when C = C i n i t ( x ) C=C_{\mathrm{init}}(x) C = C init ( x ) and π = ⊥ \pi=\perp π =⊥ , so soundness is immediate. Thus, from now on we assume that t > 0 t>0 t > 0 . The verifier checks that q = HT.Size ( v ) = queries ( C ) q=\operatorname{HT.Size}(v)=\operatorname{queries}(C) q = HT.Size ( v ) = queries ( C ) and that time ( C ) = t \operatorname{time}(C)=t time ( C ) = t .
If q = 0 q=0 q = 0 , an accepting certificate contains an ordinary-IVC proof from C i n i t ( x ) C_{\mathrm{init}}(x) C init ( x ) to C C C in exactly t t t ordinary steps. Soundness in this case follows directly from soundness of OrdIVC.
For q ∈ [ Q ] q\in[Q] q ∈ [ Q ] and s ∈ { 0 , … , r } s\in\{0,\ldots,r\} s ∈ { 0 , … , r } , let E q , s E_{q,s} E q , s be the event that the adversary outputs an unreachable, ε \varepsilon ε -robust endpoint with exactly q q q oracle calls, all public verification checks accept, including the ordinary-IVC check, and the first s s s private checks at scale h = ⌈ log 2 q ⌉ h=\lceil\log_2 q\rceil h = ⌈ log 2 q ⌉ accept. Set
p q , s = Pr [ E q , s ] p_{q,s}=\Pr[E_{q,s}] p q , s = Pr [ E q , s ]
in the real experiment. We prove that, for every s ∈ [ r − 1 ] s \in[r-1] s ∈ [ r − 1 ] ,
p q , s ≤ ( 1 − ε 2 ) p q , s − 1 + δ . (9) p_{q,s} \le\left(1-\frac{\varepsilon}{2}\right)p_{q,s-1}+\delta. \tag*{(9)} p q , s ≤ ( 1 − 2 ε ) p q , s − 1 + δ . (9)
Fix q ∈ [ Q ] q \in[Q] q ∈ [ Q ] and s ∈ [ r − 1 ] s \in[r-1] s ∈ [ r − 1 ] , and let
E = E q , s − 1 , h = ⌈ log 2 q ⌉ , K = 2 h . E=E_{q,s-1},\qquad h=\lceil\log_{2}q\rceil,\qquad K=2^{h}. E = E q , s − 1 , h = ⌈ log 2 q ⌉ , K = 2 h .
Thus q ≤ K < 2 q q\le K<2q q ≤ K < 2 q . We use components s s s and r r r at this scale in the hybrid argument. The event E E E uses neither of their trapdoors.
For a configuration U U U , let d x ( U ) d_x(U) d x ( U ) be the minimum number of incorrect oracle answers in a purported execution from C i n i t ( x ) C_{\mathrm{init}}(x) C init ( x ) to U U U , at the time specified by the step counter in U U U . Set d x ( U ) = + ∞ d_x(U)=+\infty d x ( U ) = + ∞ if no such execution exists, and define
Φ q x ( U ) = min { d x ( U ) , q } q . \Phi_q^x(U)=\frac{\min\{d_x(U),q\}}{q}. Φ q x ( U ) = q min { d x ( U ) , q } .
This potential lies in [ 0 , 1 ] [0,1] [ 0 , 1 ] and is zero at the initial configuration. On E E E , endpoint robustness gives
Φ q x ( C ) ≥ ε . \Phi_q^x(C)\ge\varepsilon. Φ q x ( C ) ≥ ε .
If a valid ordinary interval from A A A to B B B is followed by a purported oracle transition from B B B to A ′ A' A ′ with query-answer pair ( u , a ) (u,a) ( u , a ) , then
Φ q x ( A ′ ) ≤ Φ q x ( A ) + 1 [ a ≠ O ( u ) ] q . (10) \Phi_q^x(A')\le\Phi_q^x(A)+\frac{\mathbf{1}[a\ne O(u)]}{q}. \tag*{(10)} Φ q x ( A ′ ) ≤ Φ q x ( A ) + q 1 [ a = O ( u )] . (10)
These potentials and the event E E E can be evaluated by the bounded-space configuration-graph computation, together with the indicated private checks.
Let H a , b H_{a,b} H a , b denote the experiment in which components s s s and r r r at scale h h h have extraction indices a a a and b b b , respectively, with all other setup components generated as in the real experiment. A star denotes an independently uniform index in [ K ] [K] [ K ] .
For each j ∈ [ q ] j\in[q] j ∈ [ q ] , consider H ⋆ , j H_{\star,j} H ⋆ , j and extract record j j j using component r r r . Write its configurations as
D ^ j = ( A ^ j − 1 , B ^ j , A ^ j ) . \widehat{D}_j=(\widehat{A}_{j-1},\widehat{B}_j,\widehat{A}_j). D j = ( A j − 1 , B j , A j ) .
An extraction is valid if the local relation, consistency predicate, and required hash openings verify. It is aligned if its common context is the expected θ \theta θ and its starting and ending oracle counters are j − 1 j-1 j − 1 and j j j . Let
b j = 1 [ a j ≠ O ( u j ) ] b_j=\mathbf{1}[a_j\ne O(u_j)] b j = 1 [ a j = O ( u j )]
for the extracted query-answer pair, and define
F j − = E H ⋆ , j [ 1 E Φ q x ( A ^ j − 1 ) ] , F j + = E H ⋆ , j [ 1 E Φ q x ( A ^ j ) ] , F_j^-=\mathbb{E}_{H_{\star,j}}\left[\mathbf{1}_E\Phi_q^x(\widehat{A}_{j-1})\right],
\qquad
F_j^+=\mathbb{E}_{H_{\star,j}}\left[\mathbf{1}_E\Phi_q^x(\widehat{A}_j)\right], F j − = E H ⋆ , j [ 1 E Φ q x ( A j − 1 ) ] , F j + = E H ⋆ , j [ 1 E Φ q x ( A j ) ] ,
and
W j = E H ⋆ , j [ 1 E b j ] . W_j=\mathbb{E}_{H_{\star,j}}\left[\mathbf{1}_E b_j\right]. W j = E H ⋆ , j [ 1 E b j ] .
All contributions are set to zero when the extraction is invalid or unaligned.
The extracted witness contains an accepting ordinary-IVC proof under the expected context. By adaptive soundness of OrdIVC, except with negligible probability this proof certifies a valid ordinary interval on the actual input x x x . Applying Equation (10) , we obtain
F j + ≤ F j − + W j q + δ . F_j^+ \le F_j^- + \frac{W_j}{q} + \delta. F j + ≤ F j − + q W j + δ .
For every j < q j < q j < q , the two-component hybrid argument gives
F j + 1 − = F j + ± δ . F_{j+1}^- = F_j^+ \pm\delta. F j + 1 − = F j + ± δ .
Indeed, consider
H ⋆ , j , H j + 1 , j , H j + 1 , j + 1 , H ⋆ , j + 1 . H_{\star,j},\quad H_{j+1,j},\quad H_{j+1,j+1},\quad H_{\star,j+1}. H ⋆ , j , H j + 1 , j , H j + 1 , j + 1 , H ⋆ , j + 1 .
Each change of an extraction index is justified by index hiding while evaluating a quantity that uses only the other component’s trapdoor. In H j + 1 , j H_{j+1,j} H j + 1 , j , the two extractions authenticate the same record at position j j j . Collision resistance identifies these records, and the consistency predicate identifies the shared boundary configuration and propagates alignment. In H j + 1 , j + 1 H_{j+1,j+1} H j + 1 , j + 1 , both components authenticate the same record at position j + 1 j+1 j + 1 , so we may switch back to evaluating the potential with component r r r .
The first-record condition gives F 1 − = 0 F_1^- = 0 F 1 − = 0 . At the other endpoint, last-statement collision resistance identifies the record extracted at position q q q with the claimed last record, except with negligible probability. As in § 7.4 , this property is applied by changing the unused component s s s to ordinary generation while evaluating the extraction from component r r r , and then changing it back by index hiding.
The verifier’s checks therefore establish alignment of the last extracted record. Soundness of the trailing ordinary-IVC proof gives
Φ q x ( A ^ q ) ≥ Φ q x ( C ) ≥ ε \Phi_q^x(\widehat{A}_q) \ge\Phi_q^x(C) \ge\varepsilon Φ q x ( A q ) ≥ Φ q x ( C ) ≥ ε
on E E E , except with negligible probability. Since E E E does not use component r r r ’s trapdoor, index hiding also gives
Pr H ⋆ , q [ E ] = p q , s − 1 ± δ . \Pr_{H_{\star,q}}[E] = p_{q,s-1} \pm\delta. H ⋆ , q Pr [ E ] = p q , s − 1 ± δ .
Consequently,
F q + ≥ ε p q , s − 1 − δ . F_q^+ \ge\varepsilon p_{q,s-1} - \delta. F q + ≥ ε p q , s − 1 − δ .
Telescoping the potential inequalities now yields
∑ j = 1 q W j ≥ ε q p q , s − 1 − δ , \sum_{j=1}^{q} W_j \ge\varepsilon q p_{q,s-1} - \delta, j = 1 ∑ q W j ≥ εq p q , s − 1 − δ ,
where δ \delta δ absorbs the accumulated primitive-security errors.
It remains to relate this expected cost to the s s s th private check. For each j ∈ [ q ] j \in[q] j ∈ [ q ] , consider
H ⋆ , j , H j , j , H j , ⋆ . H_{\star,j},\quad H_{j,j},\quad H_{j,\star}. H ⋆ , j , H j , j , H j , ⋆ .
Index hiding and collision resistance allow us to transfer the statistic 1 E b j \mathbf{1}_{E_{b_j}} 1 E b j from the extraction by component r r r in the first experiment to the extraction by component s s s in the last. In the middle experiment, both components authenticate the same record at position j j j , and hence the same query-answer pair.
In the real experiment, component s s s has a uniformly sampled index in [ K ] [K] [ K ] . An extracted incorrect oracle answer causes rejection. Therefore,
Pr [ E ∧ the s th private check rejects ] ≥ 1 K ∑ j = 1 q W j − δ ≥ ε q K p q , s − 1 − δ ≥ ε 2 p q , s − 1 − δ . \Pr[E \wedge\text{the }s\text{th private check rejects}] \ge\frac{1}{K}\sum_{j=1}^{q} W_j-\delta\ge\frac{\varepsilon q}{K}p_{q,s-1}-\delta\ge\frac{\varepsilon}{2}p_{q,s-1}-\delta. Pr [ E ∧ the s th private check rejects ] ≥ K 1 j = 1 ∑ q W j − δ ≥ K εq p q , s − 1 − δ ≥ 2 ε p q , s − 1 − δ .
This proves Equation (9) .
Finally, the events E q , 0 E_{q,0} E q , 0 are disjoint, so ∑ q = 1 Q p q , 0 ≤ 1 \sum_{q=1}^{Q}p_{q,0}\le1 ∑ q = 1 Q p q , 0 ≤ 1 . Iterating the contraction and summing over all possible query counts gives
Pr [ bad acceptance with q > 0 ] ≤ ∑ q = 1 Q p q , r − 1 ≤ ( 1 − ε 2 ) r − 1 ∑ q = 1 Q p q , 0 + Q ( r − 1 ) δ ≤ e − λ + 1 / 2 + negl ( λ ) . \begin{aligned}
\Pr[\text{bad acceptance with }q>0]\le\sum_{q=1}^{Q}p_{q,r-1} \\
&\le\left(1-\frac{\varepsilon}{2}\right)^{r-1}\sum_{q=1}^{Q}p_{q,0}+Q(r-1)\delta\\
&\le e^{-\lambda+1/2}+\operatorname{negl}(\lambda).
\end{aligned} Pr [ bad acceptance with q > 0 ] ≤ q = 1 ∑ Q p q , r − 1 ≤ ( 1 − 2 ε ) r − 1 q = 1 ∑ Q p q , 0 + Q ( r − 1 ) δ ≤ e − λ + 1/2 + negl ( λ ) .
Here we used r = ⌈ 2 λ / ε ⌉ r=\lceil2\lambda/\varepsilon\rceil r = ⌈ 2 λ / ε ⌉ and the stipulated quantitative security of the underlying primitives. Together with the q = 0 q=0 q = 0 case, this proves adaptive soundness.
Instantiation under LWE. We instantiate OrdIVC using § 7.4 restricted to ordinary transitions, and use the LWE-based UpBARG from § 7.3 for both the inner and outer constructions. The composed reductions have size and losses poly ( T ∗ ) \operatorname{poly}(T^*) poly ( T ∗ ) : the ordinary-IVC analysis enumerates configurations of the original space-S S S machine, not of the proof verifier. Assuming sub-exponential hardness of LWE, with sub-exponentially small advantage, even given access to O \mathcal{O} O , we can therefore choose all underlying security parameters as sufficiently large polynomials in λ + log T ∗ \lambda+\log T^* λ + log T ∗ to obtain errors negligible in T ∗ T^* T ∗ , even after all reductions and hybrids.
Intermediate configurations. For an arbitrary intermediate configuration we require the natural endpoint version of robustness: either the configuration is genuinely reachable, or every purported execution reaching it contains an ε \varepsilon ε -fraction of incorrect oracle answers. For an accepting terminal configuration on an ε \varepsilon ε -robust no-instance, this condition follows immediately from Theorem 17.
AI Disclosure
We used generative AI tools to edit the writing, proofread the paper to catch potential bugs, suggest writing improvements, and for a literature review. All AI-generated text was reviewed and verified by the authors. All the ideas, including the proof ideas, were developed solely by the authors. We take full responsibility for the content of this work.
Acknowledgments
This work is supported by the U.S. National Science Foundation under award No. 2534400, and by the UK AISI alignment project.
References