Shielding Probabilistically Checkable Proofs: Zero-Knowledge PCPs from Leakage Resilience

Probabilistically Checkable Proofs (PCPs) allows a randomized verifier, with oracle access to a purported proof, to probabilistically verify an input statement of the form “x∈L” by querying only a few proof bits. Zero-Knowledge PCPs (ZK-PCPs) enhance standard PCPs to additionally guarantee that the view of any (possibly malicious) verifier querying a bounded number of proof bits can be efficiently simulated up to a small statistical distance. The first ZK-PCP construction of Kilian, Petrank and Tardos (STOC 1997), and following constructions employing similar techniques, necessitate that the honest verifier makes several rounds of queries to the proof. This undesirable property, which is inherent to their technique, translates into increased round complexity in cryptographic applications of ZK-PCPs. We survey two recent ZK-PCP constructions—due to Ishai, Yang and Weiss (TCC 2016-A), and Hazay, Venkitasubramaniam and Weiss (ITC 2021)—in which the honest verifier makes a single round of queries to the proof. Both constructions use entirely different techniques compared to previous ZK-PCP constructions, by showing connections to the seemingly-unrelated notion of leakage resilience. These constructions are incomparable to previous ZK-PCP constructions: while on the one hand the honest verifier only makes a single round of queries to the proof, these ZK-PCPs either obtain a smaller (polynomial) ratio between the query complexity of the honest and malicious verifiers or obtain a weaker ZK guarantee in which the ZK simulator is not necessarily efficient.

Zero-Knowledge PCPs. Zero-Knowledge PCPs (ZK-PCPs) [6] are proofs systems that combine the advantages of PCPs and ZK proofs. These are PCPs with the additional guarantee that the view-encompassing all the knowledge which the verifier posses of the interactionof any (possibly malicious) verifier V * who queries an a-priori bounded number of proof bits can be efficiently simulated given only the input, up to a small statistical distance.
ZK-PCPs differ from traditional PCPs in several respects. First, whereas the PCP prover is traditionally deterministic, in ZK-PCPs the proof is randomized, and this is inherent to obtaining ZK. Second, ZK-PCPs are used to protect the prover's private information (e.g., an NP witness) against malicious verifiers. More specifically, the system is associated with an a-priori query bound q * , where ZK holds only against verifiers V * who query at most q * proof bits. We stress that this is the only restriction on V * , and no further assumptions or limitations are made on its computational power or the manner in which it operates. It is important to note that bounding the query complexity is inherent in systems with efficient provers-an essential requirement for such systems to be useful for cryptographic applications. Indeed, the proof has polynomial length len, so any (efficient) verifier running in time len could read the entire proof, thus necessarily learning some information about the witness. Finally, we note that ZK against query-bounded verifiers is a stronger guarantee than Honest-Verifier ZK (HVZK), namely ZK only against the honest verifier. This is because the honest verifier is always query bounded.
The models also differ in the main parameters of interest. Specifically, for PCPs these consist of the randomness and query complexities of the verifier (i.e., the number of coins it tosses and the number of queries it makes to the proof), which also determine the proof length. Moreover, it is standard to consider a constant soundness error-with a verifier that queries a constant number of proof bits-since this setting has strong connections to proving hardness of approximation results. We currently have PCPs, the length of which is a quasi-linear length in the witness length, with a constant soundness error (which can be amplified through repetition), and a non-adaptive honest verifier that queries a constant number of proof bits [3,7].
On the other hand, for ZK-PCPs we desire the soundness error to be negligible (in the input length, or some security parameter) as is standard in cryptographic systems, and thus the query complexity is necessarily polylogarithmic. The query bound q * on malicious verifiers is another important parameter of the system, and would ideally be much larger than the query complexity of the honest verifier, e.g., polynomial in the input length. Thus, the query gap between the query complexity needed to verify the proof, and the number of queries a malicious verifier can make without violating ZK, would be exponential. Finally, we would like the honest verifier to be non-adaptive, namely to make a single round of queries to the proof. This should be contrasted with adaptive verifiers the queries of which might depend on the oracle answers to previous queries, and who therefore necessarily make several rounds of queries to the proof. As we will shortly explain, whereas the verifier in traditional PCPs is non-adaptive, the honest verifier in certain ZK-PCP constructions is (inherently) adaptive. We note that similar to traditional PCPs, the proof length is also of interest.
The focus on these parameters in ZK-PCP constructions stems from their effect on the properties and parameters of cryptographic systems using ZK-PCPs. Specifically, the query complexity and adaptivity of the honest verifier translates into communication and round complexities; the query-bound on malicious verifiers corresponds to the privacy guarantee of the resultant system; and in distributed proof systems (as in, e.g., [8]) the proof length and query bound translate into the total number of parties and the number of corrupted parties, respectively.
ZK-PCP Constructions. The first ZK-PCP for NP, due to Kilian, Petrank and Tardos [6], obtained a negligible soundness error with an honest verifier that queries q = polylog(|x|) proof bits, and ZK against verifiers making q * = p(|x|) queries to the proof for a fixed polynomial p that is much smaller than the proof length, but is much larger than q. (Earlier constructions, e.g., [9], obtained only limited ZK guarantees such as HVZK). Later works [10,11] simplified the system, making it more modular, and also generalized it to other proof models (specifically, PCPs of proximity with zero knowledge [11]). While obtaining a desirable exponential query gap, the honest verifier in all these constructions is adaptive, namely it makes several rounds of queries to the proof, a severe limitation when the system is used in cryptographic applications. Unfortunately, the honest verifier's adaptivity is inherent to these constructions, as we now explain. (We note that another line of works obtain non-adaptive verification by "pushing" adaptivity to the prover side; see Section 1.3. Having adaptive proof generation has similar disadvantages to having adaptive verification.) These ZK-PCP constructions follow the blueprint of [6], who show a 2-step compiler from a standard non-ZK PCP into a ZK-PCP. In the first step, the PCP is transformed into a PCP with HVZK-a weak ZK guarantee that holds only for the honest verifier. In the second step, HVZK is "boosted" into full-fledged ZK, against any (possibly malicious) query-bounded verifier V * . This is obtained by forcing-through modifications made to the proof-V * 's queries to be distributed similarly to the queries of the honest verifier V. This restriction on the verifier's queries is imposed by combining an information-theoretic analogue of a standard cryptographic commitment, called a "locking scheme" [6], with a modified version of the PCP obtained in the first step. The proof generated in this second step requires adaptive verification, due to the structure of the modified version of the proof, as well as the use of locking schemes. We note that this description of V * 's queries as being distributed "similarly" to the queries of V is in fact a gross over-simplification-for example, V * can query many more proof bits compared to V. Somewhat more accurately, these works effectively force V * 's queries to be distributed similarly to a "repeated" version of V (obtained by emulating V multiple times with independent random coins). We refer the interested reader to [11,12] for more details. We stress that these works do not make any assumptions on the query pattern of V * , but rather by appropriately constructing the proof they guarantee that any query pattern will be "harmless" in the sense that it reveals no information about the NP witness.
The second step can be very roughly (and somewhat inaccurately) illustrated through the following example: Alice is trying to locate a particular CD cd in Bob's CD collection, which Bob has mixed in the following way: (1) the CDs were taken out of their cases and randomly placed back into the cases (where Bob knows which case contains which CD), and then (2) each CD case was locked in a transparent box. To get cd, Alice must first ask Bob in which case he put cd. Once this is known, she can locate the box in which this CD case is, but still needs to ask Bob for the key which unlocks the box. Since Alice cannot predict in which case cd is, she must first wait for Bob's answer to her first query, before making her second query. (The PCP-version of this example will have Bob somehow write Table 1. Comparison of Existing ZK-PCP constructions. Here, "Underlying LR primitive" refers to the type of building block used in the leakage-resilience based constructions; "WI" stands for witness-indistinguishable; "ZK quality" refers to the efficiency of the ZK simulator (which is efficient in ZK systems and inefficient in WI systems); "Query ratio" is q * /q, where q * is the bound on the query complexity of a malicious verifier (ZK holds against any verifier querying at most q * proof bits), and q is the query complexity of the honest verifier (needed to achieve soundness); "Underlying PCP" describes the properties which the transformations needs the underlying PCP system to have; and "Honest verification" refers to the adaptivity of the honest verifier, where "NA" stands for non-adaptive.

Underlying LR Primitive ZK Quality Query Ratio
Underlying PCP Honest Verification [8] Circuits WI Exponential Any standard PCP Nonadaptive [13] Encodings ZK Square-root ZK-PCP, large alphabet Nonadaptive [6,11] -ZK Exponential Any standard PCP Adaptive Hazay et al. [13] construct a non-adaptive ZK-PCP in which the ratio between the bound q * on the query complexity of a malicious verifier, and the query complexity q of the honest verifier, is polynomial.
The leakage-resilient primitive they employ is a Leakage-Resilient Encoding (LRE). Roughly, an LRE consists of a randomized efficient encoding procedure Enc mapping a bit string m to an encoding c, and an efficient deterministic decoder algorithm that given an encoding c of m, outputs m. The leakage-resilience guarantee is that for any pair m, m , if c ← Enc(m), c ← Enc(m ), then any small subset of bits in c, c are identically distributed. (They actually need a stronger leakage-resilience guarantee, see Section 3.1.) Non-explicit constructions of such encodings easily follow from the existence of linear error-correcting codes with sufficiently "good" parameters, such as random linear codes (see, e.g., [14]). In Section 3, we also describe an explicit construction of such encodings.
The leakage-resilience guarantee of an LRE is restricted to protecting the codeword once it has been encoded, and does not protect the encoding procedure itself (as opposed to leakage-resilient circuits, see below). Therefore to obtain PCPs with full-fledged ZK against arbitrary query-bounded verifiers, the underlying PCP should possess a zero-knowledge property, which is weaker than full-fledged ZK, but stronger than the HVZK property used in [6,10,11]. Specifically, they use a ZK-PCP variant over a large alphabet, which is much easier to obtain compared to full-fledged ZK for standard PCPs, in which the proof is binary.
A ZK-PCP variant over a large alphabet can be thought of as a (standard) PCP which is divided into "regions", each corresponding to a single symbol in the large alphabet, where ZK is guaranteed only as long as the verifier queries "full" regions (i.e., all bits in the region). Thus, a malicious verifier does not have to follow the honest verifier's query pattern, but ZK holds only against verifiers querying at most q * full regions, for some a-priori bound q * . Such ZK-PCPs are constructed from general secure multi-party computation protocols in [15].
Given a ZK-PCP variant over a large alphabet, [13] design an alphabet reduction that preserves ZK. (Naïve alphabet reduction techniques do not preserve ZK; see Section 3.) This reduction uses the underlying PCP (P , V ) as a black box, transforming it into a ZK-PCP (P, V ) in which the proof is over bits. The high-level idea is to interpret each symbol of a proof π generated by P as a bit string, and encode it using the LRE. V then emulates V , answering an oracle query i by reading the entire encoding of the i'th symbol from its proof, decoding it, and then providing V with the resultant symbol as the oracle answer.
Hazay et al. [13] then apply their alphabet reduction to the ZK-PCP variant of [15] to obtain the following (see Theorem 3 in Section 3 for the formal statement).

Informal Theorem 1.
There exists a constant ∈ (0, 1) such that for any ZK parameter q * ∈ N and any NP-language L there exists a ZK-PCP for L with ZK against q * -query bounded verifiers, and a negligible soundness error with a non-adaptive honest verifier that queries (q * ) proof bits.
We note that the ZK-PCP system described in Informal Theorem 1 requires a tighter analysis of the ZK-PCP variant of [15], which [13] provide. See Section 3 and [13] for further details. Ishai et al. [8] construct a non-adaptive ZK-PCP in which the ratio between the bound q * on the query complexity of a malicious verifier, and the query complexity q of the honest verifier, is exponential, but ZK holds with an inefficient simulator.
Their starting point is a standard PCP with no zero-knowledge guarantees. Consequently, to obtain full-fledged ZK, they rely on a stronger leakage-resilient tool. To describe their construction, it would be easier to consider the NP-relation R = R(x, w) associated with the NP-language L, and its corresponding verification circuit C. We will assume without loss of generality that a witness w for x has canonical form, namely it consists of the entire wire values of C given input x, w , for some w such that C(x, w ) = 1. (In particular, w is the information that we wish to keep secret.) The PCP prover generates the proof from this canonical NP witness w. Therefore, each proof bit is an information bit on w, i.e., on the wire values of C when evaluated on x, w . This can be thought of as leakage on the computation in C, the purpose of which is to reveal information about the secret input w of C. While in general, leakage on the wire values of C might reveal information on the secret input w , there are tools to compile C into a leakage-resilient circuit C that resists such leakage.
However, it is well known that one cannot protect circuits against general polynomialtime leakage [16]. Consequently, leakage-resilient circuits are associated with a restricted leakage class from which leakage functions can be chosen, and the circuit only resists leakage computed by a function from the class. The main observation of [8] is that every PCP system naturally has such a restricted class LE AK of leakage functions associated with it. Indeed, while V * can choose which proof bits to query, it has no control over the type of functions applied to w to generate the proof bits-these functions are determined solely by the prover algorithm. Specifically, for every subset I of at most q * indices in the proof, the corresponding leakage function I ∈ LE AK applies the PCP prover function to w, then outputs the restriction of the proof to the indices in I.
The main building block is therefore a Leakage-Resilient Circuit compiler (LRCC)-a compiler that transforms a given circuit C into a leakage-resilient circuit C-that resists leakage from the class LE AK associated with the underlying PCP system. Informally, an LRCC is associated with a function class LE AK (the leakage class) and a (randomized) input encoding scheme E = (Enc, Dec), and compiles a deterministic circuit C into a deterministic circuit C that emulates C's operation over encoded inputs. C is guaranteed to emulate C on properly encoded inputs, and is leakage resilient in the sense that for any pair of inputs z, z for C such that C(z) = C(z ), and any ∈ LE AK, the output of on the wire values of C when evaluated on a random encoding z ← Enc(z) is statistically close to its output when C is evaluated on a random encoding z ← Enc(z ). (We stress that we will only need to consider stateless circuits C, in which we wish to hide the circuit's input. We additionally do not allow the leakage-resilient circuit C to have randomized, leak-free components, and instead the needed randomness will be provided as part of its input encoding.) Notice that if the prover generated the proof from the wire values w of C (instead of the wire values w of C), then V * 's queries to the proof-which constitute leakage from LE AK on w-would reveal no information about w .
This observation gives a general blueprint for compiling traditional PCPs into ZK-PCPs: given a PCP system (P , V ) with an associated leakage class LE AK as described above, and a compiler that transforms a given circuit into one that resists leakage from LE AK, the ZK-PCP system (P, V ) operates as follows. P on input x, w generates the leakage-resilient version C x of the circuit C x = C(x, ·) (i.e., C with x hard-wired into it), uses w to generate the entire wire values w of C x , then emulates P on w to generate a PCP π. V given input x and oracle access to π generates C x similarly to P, and emulates V on π to check that C x is satisfiable. In particular, whereas the claim which V set out to verify can be phrased as "C x is satisfiable", the underlying PCP system (P , V ) is used to verify a different claim, namely that the leakage-resilient circuit C x is satisfiable.
Unfortunately, this blueprint does not actually work. The reason is that the internal system (P , V ) is used to prove a different statement, namely that C x is satisfiable. For (P, V ) to be sound, it should be the case that C x is satisfiable only if C x is. This, however, is not generally guaranteed by LRCCs, as we now explain. Recall that the LRCC is correct for properly encoded inputs, in the sense that on such inputs, C emulates C. However, LRCCs in general have no guarantee for inputs which are not properly encoded. This is not just an artifact of the definition, but is rather essential for leakage resilience to hold in existing constructions. A main technical contribution of [8] is in defining and constructing an LRCC that also guarantees soundness, in the sense that the leakage-resilient circuit C is satisfiable (even by using invalid encodings as inputs) only if the original circuit C is satisfiable.
To turn this into an actual construction, one needs to design a sound LRCC for a leakage class LE AK associated with some standard PCP system. The most common leakage classes considered in the literature are either the "Only Computation Leaks" (OCL) model that assumes leakage is "local" in the sense that different "regions" of the circuit leak independently [17], or classes of functions that are "computationally simple" [18], i.e., from a low complexity class such as AC 0 . It is known that the leakage classes associated with a PCP system cannot be of the former type [19], so Ishai et al. [8] focus on the latter. Specifically, they show that the PCP system of Arora and Safra [2] has the property that "small" subsets of proof bits can be generated using the class LE AK of AC 0 circuits (i.e., constant-depth polynomial-sized circuits with ∧, ∨, ¬ gates of unbounded fan-in and fanout) augmented with a small number of ⊕ gates. (See section 4.3 for a formal definition of this leakage class.) Then, they use correlation bounds of Lovett and Srivinasan [20] to show that their sound LRCC resists leakage from LE AK. This yields the following result, where a witness-indistinguishable PCP is a ZK-PCP in which the ZK property holds with an inefficient simulator (see Theorem 7 in Section 4 for the formal statement).

Informal Theorem 2.
For any ZK parameter q * ∈ N and any NP-language L there exists a witness-indistinguishable PCP for L with witness-indistinguishability against q * -query bounded verifiers, and a negligible soundness error with a non-adaptive honest verifier that queries polylog(q * ) proof bits.
Assuming the existence of one-way functions (a minimal assumption in cryptography), as well as a Common Random String (CRS) that is available to both parties, and using a standard cryptographic technique-the so-called "FLS technique" [21]-the witnessindistinguishable PCP of Informal Theorem 2 can be transformed into a ZK-PCP system where ZK holds against computationally-bounded query-bounded verifiers in the CRS model. (We refer the interested reader to [8] for further details, including a formal definition of the model).

Comparison between Different ZK-PCP Constructions
The ZK-PCPs of [13] (Informal Theorem 1) obtain ZK with efficient simulation as in the ZK-PCPs of [6,11], with a query gap of q * /(q * ) . The query gap is inherited directly from the underlying ZK-PCP variant of [15], which requires the honest verifier to query Ω((q * ) ) proof symbols to obtain a negligible soundness error. Therefore, the query gap could potentially be improved by replacing the underlying building block with a ZK-PCP variant with a larger query gap.
On the other hand, the witness-indistinguishable PCPs of [8] (Informal Theorem 2) obtain an exponential query gap, similar to the ZK-PCPs of [6,11]. This is possible because the underlying (non-ZK) PCP has a negligible soundness error with an honest verifier that queries a poly-logarithmic number of proof bits. However, the construction is only witness-indistinguishable, which is weaker than ZK (see Section 2.1.1). Ref. [8] show that unless NP = BPP, obtaining ZK-PCPs (i.e., with efficient simulation) using their technique would require a new and entirely different approach towards designing and analyzing security of leakage-resilient circuits. We further note that while the techniques of [6,13] extend also to PCPs of Proximity (see Section 2.1.1 for a description of this model, and [11,13] for the constructions), the technique of [8] does not seem to readily lend itself to designing zero-knowledge (or even witness-indistinguishable) PCPs of proximity.
Finally, all the aforementioned ZK-PCP constructions [6,8,11,13] have polynomiallength proofs (whereas traditional PCPs can have quasi-linear length). However, while a polynomial blowup in proof length is inherent to the constructions of [6,11] due to their use of locking schemes, this is not the case for the leakage resilience based constructions [8,13], which could potentially have shorter proofs. This is an additional advantage of taking the leakage resilience based approach. The discussion is summarized in Table 1.

Related Notations, Extensions, and Cryptographic Applications
Many different variants of proof systems and ZK proof systems have been considered in the literature (see, e.g., Thaler's survey [22], and references therein). We briefly mention two notable notions that are closely related to ZK-PCPs; see also Table 2. The first is Interactive Oracle Proofs (IOPs) [23,24] (a special case of IOPs appeared earlier in [25]) which combine aspects of IPs and PCPs. Specifically, in an IOP the verifier and prover interact as in an IP, but the verifier has oracle access to prover messages as in PCPs. These proof systems have received increasing attention, partly due to their uses in blockchain applications. Unlike ZK-PCPs, which can be obtained from standard PCPs through generic compilers, existing ZK-IOPs (see, e.g., [25,26] and references therein) are constructed in an ad-hoc manner, in which ZK is "tailored" to a specific non-ZK IOP. (It is of course preferable to have a generic compiler, since it can be used to enhance any new IOP construction to also guarantee ZK.) The second notion is PCPs of Proximity (PCPPs) [3,7,27]-a generalization of PCPs in which the verifier does not read its entire input. Instead, V has oracle access to x, π, and wishes to check whether x is close to L in relative Hamming distance. Zero-Knowledge PCPPs (ZK-PCPPs) [11] extend ZK-PCPs to the PCPP realm. They guarantee that the view of any verifier V * making q * queries to the input and the proof can be efficiently simulated, up to a small statistical distance, by making only q * queries to the input. Ishai and Weiss [11] construct ZK-PCPPs for NP with comparable parameters to the ZK-PCPs of [6,10], where soundness holds for inputs which are δ-far from the language, for δ which is constant or inverse polylogarithmic. The honest verifier in their construction is adaptive. Hazay et al. [13] show how to extend their techniques to the setting of PCPPs, constructing ZK-PCPPs for NP with a polynomial query gap with a non-adaptive honest verifier. Table 2. Comparison Between Different Probabilistic Proof Systems. IOPPs are IOPs of Proximity, considered in, e.g., [28], in which the verifier has full access to the input, and oracle access to the witness. Here, "P ↔ V Communication" refers to whether there is direct communication between the prover and verifier (in particular, whether the verifier can send messages to the prover); "Access to Prover Messages" states whether the verifier reads prover messages in full, or has oracle access to them; similarly, "Access to Input" indicates whether the verifier reads the input in full, or only has oracle access to it; "Soundness Guarantee" refers to the type of inputs which are guaranteed to be rejected, where "Full" means that all inputs not in the languages are rejected, whereas "Promise (input)" means that only inputs that are far (in relative Hamming distance) from the language are guaranteed to be rejected, and "Promise (witness)" only guarantees that V rejects when given oracle access to a witness which is far (in relative Hamming distance) from all valid witnesses for the input; "ZK Variant Hides" of a system X states, for the ZK variant ZK-X of system X , which input of the prover remains hidden from the verifier, where "Witness" means verification reveals no information about the underlying NP witness, and "Witness, input (partial)" (resp. "Witness (partial)") roughly means that a verifier making q queries to the input and proof(s) (resp. witness) learns only q physical bits of the input (resp., witness). ZK-PCPs (and ZK-PCPPs) are motivated not only from a purely theoretical perspective as a natural model of a proof system, but also from their usefulness for cryptographic applications. Specifically, they enable modular design of cryptographic proofs systems, by separating a "clean" information-theoretic proof system component, from the cryptographic assumptions (such as hardness assumptions or an augmented model of computation) which can then be used to transform-i.e., "compile" through a cryptographic compiler-the information-theoretic system into a computationally-secure system than can be implemented. Thus, one can design, analyze and optimize the information-theoretic proof system, then apply different cryptographic compilers to obtain different properties of the resultant system. This paradigm has been extremely successful, and is widely used. For example, ZK-PCPs are the underlying combinatorial building blocks in constructions of succinct zero-knowledge arguments [29].

P ↔ V Communication
ZK-PCPs and ZK-PCPPs also have more direct cryptographic applications both to two-party and multiparty scenarios which require highly efficient verification methods on secret data. In the two-party setting, these include constructions of constant-round (or non-interactive in the random-oracle model) black box arguments for NP with statistical ZK [10] (whereas constructions based on non-ZK PCPs are not black box [30,31]). ZK-PCPPs can additionally be used to design two-party and multiparty black box commit-and-prove protocols for NP [11]. While these applications only require a weaker ZK guarantee (specifically, ZK against the honest verifier), applications in multiparty settings require fullfledged ZK against malicious verifiers. These include constructions of certifiable versions of verifiable secret sharing from ZK-PCPPs, as well as sublinear ZK proofs in a distributed setting from ZK-PCPs. (Various other notions of ZK proofs in a distributed setting have been considered recently.) In the latter application, the prover and verifier are aided by multiple (potentially corrupted) servers. The motivation for this distributed setting is to minimize the round complexity, and underlying assumptions, of sublinear ZK proofs. Specifically, using PCPs with ZK against malicious verifiers, [8] construct distributed 3-round witness-indistinguishable proofs (respectively, ZK proofs in the computational setting with a common random string) for NP, which are unconditionally secure (respectively, based on the existence of one-way functions) in which the total communication involving the verifier is sublinear in the input length. This should be contrasted with standard sublinear ZK arguments, that require at least four rounds of interaction, and require the existence of collision resistant hash functions [10,30].

Preliminaries
Basic notations. We denote the security parameter by κ. A function µ : N → N is negligible if for every positive polynomial p(·) and all sufficiently large κ's it holds that µ(κ) < 1 p(κ) , and negl(κ) denotes the set of all negligible functions. We use the asymptotic notations O(·) and Ω(·), where O(n) and Ω(n) denote n · poly(log)n and n/poly(log)n ,respectively. We use the abbreviation PPT to denote Probabilistic Polynomial-Time, and denote by [n] the set of elements {1, . . . , n}. For a string s of length n, and a subset I ⊆ [n], we denote by s| I the restriction of s to the coordinates in I.
We usually denote vectors using boldface letters (e.g., a), or as a. For a pair x, y of vectors, x, y denotes their inner product, and Ham(x, y) to denote their Hamming distance, i.e., Ham(x, y) = |{i : x i = y i }|. For functions f , g, we denote their composition as ( f • g)(x) := f (g(x)). The composition of families F, G of functions is defined as For a distribution D, sampling according to D is denote by X ← D, or X ∈ R D. For a pair of random variables X, Y, we use X ≡ Y to denote that X, Y are identically distributed. For random variables X κ and Y κ over a finite domain Ω, the statistical distance between them is defined as X κ and Y κ are -statistically close if their statistical distance is at most (κ). Ensembles {X κ } κ , {Y κ } κ are statistically close, denoted X κ ≈ Y κ , if there exists an (κ) = negl(κ) such that X κ , Y κ are (κ)-close for every κ. We say that {X κ } κ , {Y κ } κ are computationally indistinguishable if they have a negl(κ) computational distance, i.e., for every PPT distinguisher D there exists an (κ) = negl(κ) such that for every κ: Languages and Relations. We will consider NP-relations R = R(x, w), and the corresponding NP-languages L = {x : ∃w s.t. (x, w) ∈ R}. We sometimes write R L to refer to the NP-relation, the corresponding language of which is L. Encoding Schemes and Leakage-Resilient Encoding Schemes. Our constructions will rely on encodings schemes with leakage-resilience properties. We now provide a simple definition of an encoding scheme, and refer the reader to Section 3.1 for a more detailed discussion of the notion. Definition 1. Let k, n ∈ N. An Encoding Scheme over an alphabet Σ is a pair (Enc, Dec) where Enc is a PPT algorithm, and Dec is a (deterministic) polynomial-time algorithm, that satisfy the following.
• Syntax. Enc on input a secret x ∈ Σ k outputs a codeword c ∈ Σ n . Dec on input c ∈ Σ n outputs x ∈ Σ k or a special error symbol ⊥. • Correctness. There exists a t ≥ 0 such that the following holds for every x ∈ Σ k , and every c ∈ Σ n : if there exists c x ∈ Supp(Enc(x)) such that Ham(c, c x ) ≤ t then Dec(c) = x, otherwise Dec outputs ⊥.
A note on terminology. In this section and in Section 3, we use k, n respectively to denote the input and output lengths of Enc, as is customary in the context of error-correcting codes. In Section 4, the input and output lengths are denoted by n, n, respectively, which is sometimes used in the context of leakage resilience.
We now define two useful properties of encoding schemes. The first is that the scheme is linear. The second is that the scheme is onto, meaning any c ∈ Σ n can be interpreted as the encodings of some x ∈ Σ k , in the sense that c would be decoded to x. Definition 2. An encoding scheme (Enc, Dec) over a field F is linear if for every k: (1) k divides n; and (2) there exists a decoding vector d such that for every x ∈ F k : (1) every x ∈ Supp(Enc(x)) can be partitioned into k sub-vectors x = x 1 , . . . , x k , such that Dec(x) = d, x 1 , . . . , d, x k .
(Enc, Dec) is onto, if Dec is defined (i.e., does not output ⊥) for every c ∈ Σ n .
Section 4 will use a parameterized notion of encoding schemes. In such encoding schemes, the encoding and decoding algorithms are given an additional input 1 σ , which is used as a security parameter. The encoding length can then depend also on σ (and not only on k), and we require that for every σ the resultant scheme is an encoding scheme. A parameterized encoding scheme is onto (linear, respectively) if it is onto (linear, respectively) for every σ.
We now define leakage resilience of distributions and encodings.
For the construction of Section 3 we will be particularly interested in probing-resilient encoding schemes, namely ones that are leakage resilient against leakage functions that probe bits of the codeword.
For a function family LE AK, we sometimes use the term "leakage family LE AK", or "leakage class LE AK", and refer to functions in LE AK as "leakage functions".

PCPs and ZK-PCPs
The probabilistic proof system we focus on in this work is Probabilistically Checkable Proofs (PCPs) with zero-knowledge guarantees. We first describe the (standard, non-zeroknowledge) notion of PCPs.
At a high level, PCPs allow a randomized verifier to probabilistically verify the validity of some input statement by querying few bits of a purported proof to which it has oracle access. PCPs can be defined (and have been studied) in relation to various complexity classes (e.g., DTI ME(n)). In this work, we focus on PCPs for NP since cryptographic applications usually require proof systems for NP (and this also simplified the presentation). In the context of complexity theory, the system consists solely of the verifier and the proof oracle, where the proof generation process is implicit. However, cryptographic applications necessitate that proof generation be efficient, given the NP-witness. Thus, we define PCPs as a system consisting of efficient prover and verifier. (This is by now standard in the literature of PCPs for cryptographic applications, e.g., [6], as well as other proof systems such as interactive oracle proofs [23,24].) More specifically, a PCP system for a language L ∈ NP consists of a polynomial-time prover P that given x ∈ L and a corresponding witness generates a proof π for x, and a PPT verifier V having direct access ("oracle access") to individual symbols of π. V will read only part of its proof string π (called oracle), where the queries to π are determined by V's input and coin tosses. Formally, Definition 4 (PCP). A Probabilistically Checkable Proof (PCP) for a language L ∈ NP consists of a polynomial-time prover P and a PPT verifier V such that there exists a negligible function ngl = negl(κ) for which the following holds: • Syntax: The prover P has input 1 κ , x, w (κ is the security parameter), and outputs a proof π ∈ {0, 1} * for x. The verifier V has input 1 κ , x, and oracle access to π. It makes q queries to π, and outputs either 0 or 1 (representing reject or accept, respectively). q is called the query complexity of the system, and the system is called a q-query PCP. • Semantics: The system satisfies the following semantic properties: -Completeness: For every (x, w) ∈ R L , and every proof π ∈ P (1 κ , x, w), where the probability is over the randomness of V. -Soundness: For every x / ∈ L and every oracle π * , where the probability is over the coin tosses of the verifier. negl(κ) is called the soundness error of the system.

Zero-Knowledge PCPs (ZK-PCPs).
Intuitively, ZK-PCPs are PCPs in which the witness remains entirely hidden throughout the verification procedure, in the sense that even a malicious verifier which deviates from the specified verification procedure learns nothing but the validity of the claim. Achieving this property requires some modifications to the standard notion of a PCP. First, the prover must now be probabilistic. Indeed, completeness of the PCP requires (intuitively, at least) that the proof encode the witness. That is, certain proof bits will carry some information about the witness, and by querying them a malicious verifier V * may learn information about the witness. Allowing randomized proof generation is akin to having a probabilistic prover in zero-knowledge interactive proofs (whereas in standard interactive proofs the prover may be deterministic). Second, while we do not impose any restrictions on the query pattern (i.e., the strategy) of a malicious verifier V * , we impose a bound on its query complexity, namely the number of queries it makes to the proof. To see why imposing some restriction is needed, recall that cryptographic applications necessitate an efficient honest prover, meaning the proof will have polynomial length. Therefore, a polynomial-time verifier V * that is unrestricted in its access to the proof could potentially read the entire proof and thus necessarily learn information about the witness (since, as noted above, the proof carries information about the witness). There are several possible methods of restricting V * to reading only part of the proof (e.g., requiring its runtime to be smaller than the proof length), where the one used in the literature is to restrict its query complexity to some a-priori bound q * which is known prior to proof generation (in particular, the proof length may depend on q * ). One advantage of restricting the query complexity is that it allows us to obtain information theoretic ZK, namely that ZK holds against malicious verifiers with unbounded computational power, so long as the verifier makes at most q * queries to the proof. It is also more inline with the main efficiency measures of standard PCPs, which focus on the query (and randomness) complexity.
To define ZK-PCPs, we first formalize the restriction on the query complexity of the verifier.
Definition 5 (Query-bounded verifier). We say that a (possibly malicious) verifier V * with oracle access to a proof π is q * -query-bounded if it makes at most q * queries to π.
As noted above, we will allow a malicious verifier to be computationally unbounded. Moreover, we will allow its query bound q * to be much larger than that of the honest verifier. Ideally, the honest verifier will only make polylog(q * ) queries, and the proof will have length poly(q * ). We note that traditional PCPs can be verified with a constant number of queries, achieving a constant soundness error. However, since cryptographic applications usually necessitate a negligible soundness error, the query complexity of the honest verifier is necessarily polylogarithmic in the security parameter κ, or in q * .
Another aspect in which we allow a malicious verifier to be more powerful than the honest verifier is adaptivity: whereas we would like the honest verifier to be non-adaptivenamely, make a single round of queries to the proof (as in standard PCPs), we allow a malicious verifier to be adaptive-i.e., make several rounds of queries to the proof. This is formalized in the following definition.
Definition 6 (Adaptive and-non adaptive verifiers). We say that a (possibly malicious) verifier V * is non adaptive if its queries are determined solely by its input x and randomness (in particular, V * can make all its queries to the proof in a single round). Otherwise, we say that V * is adaptive (in particular, the queries of an adaptive verifier may depend on the answers to previous queries).
We are now ready to define ZK-PCPs. Similar to zero-knowledge interactive proofs (and, more generally, cryptographic protocols), we formalize zero knowledge by requiring the existence of an efficient simulator algorithm that, given the input 1 κ , x, can simulate the view of the verifier, namely the verifier's input, random coins, and the oracle answers (the queries of the verifier can be computed from these values). Intuitively, this guarantees zero knowledge because the view of the verifier captures the entire "knowledge" it obtained through verification, and in particular by querying the proof oracle. Since the view can be simulated from the input alone, without any access to the NP-witness, this implies that the view contains no information about the witness. We now formalize this intuition. Notation 1. For a PCP system (P, V ) and a (possibly malicious) verifier V * , we use View V * ,P (κ, x, w) to denote the view of V * when it has input 1 κ , x and oracle access to a proof that was randomly generated by P on input (1 κ , x, w).

Definition 7 (ZK-PCP).
We say that a PCP system (P, V ) for L is a (q * , ε)-Zero-Knowledge PCP (ZK-PCP) if for every (possibly malicious and adaptive) q * -query-bounded verifier V * there exists a PPT simulator Sim, such that for every ( One prevalent approach for designing simulators (which we will use) is to have the simulator emulate the verifier V * , simulating the answers to V * 's oracle queries.

Restrictions, Extensions and Generalizations
Definition 7 can be restricted, or alternatively, generalized, in several ways, as we now discuss. A taxonomy based on ZK quality. While we define a statistical notion of ZK as the default for ZK-PCPs, one can also consider stronger or weaker forms of ZK. Specifically, we can require a stronger perfect ZK guarantee in which the simulated view is distributed identically to the real view of the verifier.

Notation 2.
We say that a ZK-PCP has q * -ZK if it has perfect ZK against q * -query bounded verifiers.
Alternatively, we can settle for a weaker computational ZK guarantee which only holds against computationally-bounded verifiers V * , where the simulated view is computationally indistinguishable from the real view. One particular relaxation of ZK which we consider in this work is Witness-Indistinguishability which does not require that the ZK simulator be efficient. This can be obtained by removing the requirement that Sim be PPT in Definition 7, but the following alternative formulation would be more useful.

Definition 8 (WI-PCP).
We say that a PCP system (P, V ) for L is a (q * , ε)-Witness-Indistinguishable PCP (WI-PCP) if for every (possibly malicious and adaptive) q * -query-bounded verifier V * , for any x ∈ L, and any pair of corresponding witnesses w 1 , There are also various flavors of ZK based on different qualities of the ZK simulator. These include, for example, whether the simulator is straight line-i.e., it emulates the verifier without having to rewind it, and whether the simulator interacts with the verifier as a black box. The ZK-PCP constructions described in this work have straight line, black box simulators. Honest-Verifier ZK. Another natural restriction of the definition is by considering zero knowledge only against the honest verifier V. Such systems are called Honest-Verifier ZK (HVZK). As we explain below, it is fairly simple to obtain an HVZK PCP system from a standard PCP system (e.g., such a system was presented already in the paper of Kilian, Petrank and Tardos on ZK-PCPs [6], and a weaker construction with a large soundness error was presented in [9]). However, such a restriction is generally too weak to be used in cryptographic applications, for example, to prove honest behaviour in cryptographic protocols, in which case the verifying party might be maliciously corrupted. To see why settling for HVZK simplifies the problem considerably, notice that HVZK is preserved under standard soundness amplification techniques. More specifically, assume we have an HVZK PCP system with a large soundness error (obtaining such systems is relatively easy given known techniques such as "MPC-in-the-head" [15]). Soundness can then be amplified by having the prover generate many fresh, independent copies of the proof, and having the honest verifier repeat the verification procedure several times, each time using a fresh proof copy. HVZK of this verification procedure easily reduces to the HVZK of the original system. However, this amplification does not preserve full-fledged ZK (i.e., against malicious verifiers) even if the original system is ZK against malicious verifiers. Indeed, the reason is that the query complexity-even of the honest verifier-increases through this transformation, and in particular would exceed the ZK query bound of the original system. Thus, a malicious verifier that "concentrates" all its queries to a single proof copy might be able to violate the ZK of the underlying system. Verifier Adaptivity. In non-ZK PCP constructions, the honest verifier is non-adaptive. In contrast, the classic ZK-PCP of [6], and all consequent ZK-PCPs-except the ones based on leakage resilience [8,13]-have an adaptive honest verifier. As discussed in Section 1, this is because, very roughly, they enhance an HVZK PCP to have full-fledged ZK, by modifying the proof such that even honest verification requires multiple rounds of queries to the proof. Moreover, this is inherent to their technique of using "locking schemes" [6]. Having a non-adaptive honest verifier is a major advantage of leakage resilience based ZK-PCPs (see Table 1 for a comparison of existing ZK-PCP systems), since having non-adaptive honest verification is a desirable feature of the system. Indeed, an adaptive honest verifier translates into multiple interaction rounds in cryptographic applications of ZK-PCPs.

Notation 3.
We say that a ZK-PCP system (P, V ) is a non-adaptive ZK-PCP if the honest verifier V is non-adaptive.
We note that an orthogonal measure of adaptivity is whether a malicious verifier is restricted to being non-adaptive. Unlike having a non-adaptive honest verifier, guaranteeing ZK only against non-adaptive malicious verifiers is an undesirable restriction of the system, since it means there are no guarantees against adaptive verifiers. Universal vs. Non-Universal Simulation. Definition 7 requires ZK to hold with a nonuniversal simulator, requiring, for every malicious verifier V * , the existence of a simulator Sim V * . A stronger possible definition would require the existence of a universal simulator Sim that can simulate the view of any query-bounded verifier V * . We note that all the ZK-PCPs described in this work (in fact, to the best of our knowledge, all existing ZK-PCP constructions) satisfy this stronger definition. The Alphabet. Similar to PCPs, ZK-PCPs are defined as bit-strings. One could also consider a relaxed notion in which the proof is over some larger alphabet Σ (and this indeed has been done in the PCP context). We note, however, that while for standard PCPs the choice of alphabet affects only the parameters of the scheme (but not its its semantic properties), this is not the case for zero-knowledge PCPs. Indeed, any PCP over Σ can be transformed to a PCP over {0, 1} by replacing each symbol with a bit-string representation of it, without violating completeness or soundness. (We note that while more elaborate alphabet reduction techniques have been employed in the context of traditional PCP, e.g., in [3], their goal was to improve the system's parameters.) However, as we explain in Section 3, doing so for a ZK-PCP does not preserve ZK against malicious verifiers. ZK-PCPs over a large alphabet Σ can still be useful as a building block for obtaining ZK-PCPs (with proofs over {0, 1}), see Section 3. PCPs of Proximity. A useful generalization of PCPs are PCPs of Proximity (PCPPs), that allow verification of an input claim while reading only a small portion of it. This is formalized by giving the verifier oracle access to the input, similar to how it accesses the proof. Of course, in this case the verifier cannot be expected to distinguish a true claim from a claim that is false, but very close to being true (e.g., a 3-CNF for which there exists an assignment that satisfies all but a tiny fraction of the clauses). Instead, soundness is defined similarly to correctness of promise problems: any input which is sufficiently far from the corresponding NP-language will be rejected with high probability. PCPPs are an important building block in PCP constructions, and a useful notion in its own right. There are PCPP constructions matching the properties of the best-known standard PCPs [32,33].
Zero-Knowledge PCPPs (ZK-PCPPs) [11] have a stronger ZK guarantee than ZK-PCPs: while ZK-PCPs guarantee that the witness remains entirely hidden through verification, ZK-PCPPs additionally guarantee that the input itself remains mostly hidden, in the sense that the verifier (even a malicious one) learns only few physical input bits. This is formalized using the simulation paradigm as in ZK-PCPs, where instead of giving the entire input to the simulator, it has oracle access to it, and is restricted to making q * queries (where q * is the query complexity of the verifier).
Certain techniques for constructing ZK-PCPs extend also to PCPPs, while others do not (or, at least, it is not clear how to extend them). In particular, the original ZK-PCP construction of [6] can be extended to also apply to ZK-PCPPs [11], and the ZK-PCPs based on leakage-resilient encodings described in Section 3 also applies to PCPPs (see [13] for a full description of the construction). On the other hand, the construction of ZK-PCPs from LR circuits (Section 4) does not seem to easily extend to the PCPP realm.

The ZK-PCPs of Hazay et al.: ZK from LR Encodings
The main result of this section is a construction of ZK-PCPs for NP with a non-adaptive honest verifier and a polynomial query gap (between the query complexity of the honest and malicious verifiers) due to [13]: Theorem 3 (ZK-PCPs for NP, Formal statement of Informal Theorem 1). There exists a constant ∈ (0, 1) such that for any ZK parameter q * ∈ N there exists a non-adaptive (q * ) -query Ω(q * )-ZK-PCP for NP.
We describe a simplified version of the construction of [13] which nonetheless suffices for designing ZK-PCPs. The interested reader is referred to [13] for a description of the more general paradigm which employs an equivocal notion of secret sharing instead of the weaker leakage-resilient encodings used here.
The construction employs Leakage-Resilient (LR) Encodings. The starting point is a ZK-PCP variant (P , V ) over a large alphabet Σ, namely where the proof π is over Σ. To obtain a standard ZK-PCP (P, V )-i.e., one in which the proof π is over bits-we need an alphabet reduction. That is, we are looking for a transformation that replaces each symbol π i ∈ Σ with a bit-string "segment" segm i ∈ {0, 1} * . Then, given a proof π = π 1 , . . . , π N , the resultant proof would be π = (segm 1 , . . . , segm N ).
As mentioned in Section 2.1.1, the naive alphabet reduction which replaces each symbol of Σ with a bit string representing it does not preserve ZK. Indeed, this alphabet reduction necessarily increases the query complexity of the honest verifier V, who will need to query q · |segm| proof bits (where q is the query complexity of V ). Thus, a malicious verifier-the query complexity of which is at least as that of the honest verifier-with oracle access to the resultant proof π may query subsets of bits in many segments segm i , effectively learning partial information about many proof symbols (in particular, more than the ZK guarantee of π ), and violating ZK. Therefore, we need an alphabet reduction which preserves ZK.
Viewed through the leakage-resilience lens, the information which a malicious verifier obtains on a symbol π i ∈ Σ by querying bits of segm i constitutes probing leakage on segm i , and consequently also on π i . Thus, intuitively, ZK can be guaranteed by protecting the segments segm i from probing leakage. This gives a general blueprint for a ZK alphabet reduction: replace each symbol σ of Σ with its binary representation s σ , then encode s σ using a probing-resilient encoding. While this roughly describes the alphabet reduction of [13], there are a few subtleties, as we now describe. Simulation Strategy for Malicious Verifiers. A probing-resilient encoding can only protect against probing of a sufficiently small subset of bits of the encoding, namely against probing of some a-priori fixed fraction τ of bits. (Indeed, since the message can be decoded from the encoding, an adversary that probes the entire encoding necessarily learns the underlying message.) However, a malicious verifier V * may query an entire segment segm i . To see why, notice that the query bound q * imposed on the malicious verifier is expected to be much larger than the length of the encoding. Indeed, q * should be at least as large as the query complexity of the honest verifier, which would need to read at least a few symbols of the original PCP, i.e., a few full encodings of symbols of the original PCP. More generally, V * may read more than a τ-fraction of a segment, in which case the probing-resilience of the encoding cannot be used. We solve this issue in the simulation by dividing the segments segm i into two types: "heavy" and "light" segments. Intuitively, heavy segments are ones from which V * queried many bits, in particular, more than a τ-fraction. Light segments are segments that are not heavy. We use the probing-resilience of the underlying encoding to claim that V * learns no information about the symbols encoded in the light segments, and use the ZK guarantee of the underlying ZK-PCP system (P , V ) to simulate the symbols encoded in heavy segments. This gives us a simulation strategy for (P, V ): simulate heavy symbols using the simulator of the underlying system (P , V ), and simulate light symbols using random and independent encoding of an arbitrary value (e.g., the all-zeros string). Simulating Partially-Leaked Symbols. The simulation strategy defined in the previous paragraph necessitates that the simulator Sim knows in advance which segments are heavy and which are light, since this determines how to generate the answer to a query. Whether or not a segment is heavy is a function of the entire query pattern of V * . Thus, this proof strategy only works against non-adaptive malicious verifiers, namely ones which make a single round of queries to the proof. (Indeed, in this case Sim learns all of V * 's queries before it needs to simulate the oracle answers.) ZK against adaptive malicious verifiers, namely ones which make several rounds of queries to the proof, where each query may depend on the answers to the previous queries, requires a somewhat different simulation strategy, and a stronger LR guarantee from the probing-resilient encoding, as we now explain.
The high-level idea is as follows. At the onset of the simulation, Sim treats all segments as light, answering queries using random and independent encodings of 0. At certain points in the simulation, a certain segment i may become heavy-namely, the number of queries V * made to it exceeds the probing threshold τ. At this point, Sim uses the simulator Sim of the underlying ZK-PCP system (P , V ) to simulate the symbol π i . To continue with the simulation, Sim must now generate an encoding of π i which is (1) consistent with the bits already probed from the i'th segment; and (2) is distributed as a random encoding of π i subject to (1). For this, we need the underlying probing-resilient encoding to be equivocal-allowing one to efficiently sample from this distribution. Such encodings are called Reconstructable Probabilistic Encodings (RPEs) [34,35]. Putting It Together. We are now ready to describe the full alphabet reduction (see Section 3.2, and Figure 1 in particular) that transforms a ZK-PCP variant (P , V ) over alphabet Σ into a ZK-PCP (P, V ) (over bits). The reduction employs an RPE (see Section 3.1). For proof generation, the prover P first runs P to generate a proof π = π 1 , . . . , π N over Σ. Then, it replaces each proof symbol π i with its binary representation s i , and uses the RPE to encode s i into a segment segm i . P outputs the proof π = (segm 1 , . . . , segm N ). The verifier V, given oracle access to π, verifies the proof by emulating V . Whenever V queries a symbol π q of π , V queries segm q from π, RPE-decodes it to obtain the binary representation s q of a symbol σ q ∈ Σ, and provides σ q to V as the answer of the oracle. When the emulation ends, V outputs whatever V outputs. In the following sections, we describe the RPE building block (Section 3.1), and analyze the resultant ZK-PCP scheme (Section 3.2).
Verifier algorithm. V is given input 1 κ , x and oracle access to π. It runs V with input 1 κ , x, and emulates the oracle π for V as follows. Whenever V reads a symbol σ from π , V reads the entire encoding of σ from π. Then, it uses Dec to recover the symbol σ, which it gives to V as the answer of the oracle. When the emulation terminates, V outputs whatever V outputs.
Codes, or encoding schemes, are extensively used in computer science, the most notable example being Error-Correcting Codes (ECCs), which are used to guarantee that the data can still be recovered even if faults occur (i.e., some of the symbols of the data are erased or corrupted). A code consists of an encoding procedure Enc which maps a message to a codeword, and a decoding procedure Dec which decodes the message from a (possibly corrupted) codeword. In the context of error-correction, Enc, Dec are usually deterministic. Most ECCs are linear codes, where the code is defined by a generator matrix, and encoding simply multiplies the generator matrix with the message. The main parameters of interest for such codes are: (1) the rate of the code-the ratio between the length of the encoding (also known as a codeword) and the length of the original message; (2) its distance-namely the minimal distance between a pair of codewords, which is the number of coordinates in which they differ; and (3) the alphabet size (where most ECCs are binary). There are numerous extensions and generalizations of ECCs that guarantee additional properties beyond error correction.
We will be interested in a generalized notion of an ECC which also guarantees probingresilience in the sense that few codeword symbols reveal no information (in an informationtheoretic sense) on the encoded message. Of course, such a guarantee cannot be satisfied if encoding is deterministic. Probing-resilient encodings therefore allow for a randomized encoding procedure, where each message has a subset of codewords to which it can be mapped, and encoding chooses one of them at random. It is fairly simple to obtain such a leakage-resilient encoding from a linear code, as long as its generator matrix has a "good" structure. (See, e.g., [38] for a description of the needed properties and how encoding works.).
As explained above, probing-resilience alone is insufficient to guarantee ZK against adaptive malicious verifiers. Instead, we rely on a stronger equivocation property which guarantees that as long as the probing threshold τ had not been violated, the probed bits can be efficiently "explained" as the bits in an encoding of any arbitrary message msg. Intuitively, an RPE is an encoding scheme (se defined in Section 2) which is probingresilient, and is additionally associated with a resampling/reconstruction algorithm Rec that can "explain" the probed bits. Formally: Definition 9 (Reconstructable Probabilistic Encoding (RPE)). Let k, n, ∈ N. A (k, n, )-Reconstructable Probabilistic Encoding (RPE) is a triple (Enc, Dec, Rec) where Enc, Rec are PPT algorithms, and Dec is a (deterministic) polynomial-time algorithm, that satisfy the following.

•
Syntax. Enc on input a secret x ∈ {0, 1} k outputs a codeword c ∈ {0, 1} n . Dec on input c ∈ {0, 1} n outputs x ∈ {0, 1} k or a special error symbol ⊥. Rec on input a secret x, a set I ⊂ [n] of size |I| ≤ , and bits (c i ) i∈I , outputs c ∈ {0, 1} n ; • Correctness. There exists a t ≥ 0 such that the following holds for every x ∈ {0, 1} k , and every c ∈ {0, 1} n : if there exists c x ∈ Supp(Enc(x)) such that Ham(c, c x ) ≤ t then Dec(c) = x, otherwise Dec outputs ⊥; • -Secrecy (of partial views). For every pair of secrets x, x , and any subset I ⊆ [n] such that |I| ≤ , Enc(x)| I ≡ Enc(x )| I ; • -Reconstruction (from partial views). For any secret x, any subset I ⊆ [n] of size |I| ≤ , and any set c i i∈I of bits, Rec x, I, c i i∈I is distributed identically to an encoding c ∈ Supp(Enc(x)) that is random subject to being consistent with c i i∈I .
A few remarks are in order. First, our constructions can make do with a relaxed RPE notion in which the secrecy and reconstruction properties hold statistically with statistical distance . (In this case, the resultant ZK-PCP will have statistical ZK with a statistical error of roughly N · , where N denotes the proof length, see [13] for details.) Second, while we define RPEs for a single message length k, the notion naturally generalizes to families of codes such that for every k ∈ N there exists a code the codewords of which have length n = n(k); and there exists a uniform algorithm that given 1 k as input, generates the encoding, decoding and resampling procedures for message length k. We will only consider (efficiently encodable and decodable) families of codes in this work. For simplicity and clarity of the definitions, we do not explicitly refer to a family of codes, but k should be understood as a general input length parameter. (This is standard in the literature.) Finally, we note that non-explicit constructions of RPEs follow easily from the existence of linear error-correcting codes with sufficiently "good" parameters, which are satisfied by random linear codes (see, e.g., [14]). Indeed, such codes posses the secrecy property of RPEs, which guarantees that for every subset of codeword symbols, the resultant system of linear equations has a solution for any possible secret. This gives an efficient reconstructor Rec. We note that the final ZK-PCP construction will use an explicit RPE construction due to [37,39].

The ZK-PCP Construction
We now describe the alphabet reduction for ZK-PCPs, which uses RPEs to transform a ZK-PCP variant over a large alphabet to a ZK-PCP (over bits).
Construction 4 transforms a PCP system over a large alphabet into a PCP (over bits). The following theorem of ( [40], Theorem 9) states that if the underlying PCP system is ZK, and the RPE is secure, then the resultant scheme is also ZK.
Theorem 5 (ZK-PCPs from LR encodings [13]). Assume Construction 4 is instantiated with: Then, Construction 4 is a ((q * + 1) · ( + 1) − 1, )-ZK-PCP for L. Moreover, the transformation preserves the soundness and completeness of (P , V ). Furthermore, if (P , V ) has proofs of length N that can be verified non-adaptively with q queries, then Construction 4 has proofs of length N · n that can be verified non-adaptively with q = q · n queries.
Proof. Completeness follows directly from a combination of the completeness of (P , V ) and the correctness of the RPE (which guarantees that V perfectly emulates the proof oracle for V ). The claim regarding q follows directly from the construction.
Soundness. Let x * / ∈ L, and let π * be a purported proof oracle for V. We show that V rejects x * with the same probability as V . We partition π * into N length-n segments π * ,1 · · · π * ,N , where the i'th segment π * ,i contains the bits in locations (i − 1)n + 1, . . . , i · n. (Notice that the i'th segment in an honestly-generated proof would contain the RPE-encoding of the i'th symbol in a proof over Σ.) Then the correctness of the RPE implies that for every 1 ≤ i ≤ N there exists a σ i ∈ Σ such that Dec π * ,i = σ i (indeed, if Dec π * ,i =⊥ then we set σ i to some arbitrary symbol in Σ). Let π * = (σ 1 , . . . , σ N ) ∈ Σ N , and notice that when V has oracle access to π * , it emulates V with oracle access to π * . The soundness of (P , V ) therefore guarantees that V (and consequently also V) accepts with probability .
Zero Knowledge. Let q * * = (q * + 1) · ( + 1) − 1, and let V * be a (possibly malicious and adaptive) q * * -query bounded verifier. For simplicity of the description, we assume V * makes its queries one at a time, and never repeats queries (this is without loss of generality). We describe a simulator Sim for V * , which relies on the simulator Sim of the underlying ZK-PCP system (P , V ), and emulates a proof oracle π * for V * as follows: 1.
Sim answers each oracle query Q of V * as follows. Assume that Q is a query to the j'th bit of the i'th segment (meaning Q queries the (i − 1)n + j'th bit of the proof); (a) If Cnt i < , or Cnt i ≥ + 1, then Sim answers with the j'th bit of segm i , increases Cnt i by 1, and adds j to I i ; Otherwise, Cnt i = , meaning V * has already queried bits from the encoding in the i'th segment. In this case, Sim uses Sim to simulate the i'th symbol σ i of a proof of the underlying ZK-PCP system. Then, Sim resamples an encoding of σ i by computing segm i ← Rec σ i , I i , (segm i )| I i (this resamples a fresh encoding of σ i consistently with the oracle answers already simulated), sets segm i := segm i , and provides the j'th bit of segm i as the answer of the oracle. Finally, it increases Cnt i by 1.
We now prove that the simulated and real views of V * are -statistically close, using a hybrid argument.
H 0 : This is the view of V * in the simulation described above; H 0 1 : H 0 1 is obtained from H 0 by replacing the simulated answers of Sim with the actual proof symbols of a proof π honestly generated by P .
Then H 0 and H 0 1 are -statistically close by the (q * , )-ZK of (P , V ). Indeed, since Sim is used to simulate the i'th proof symbol only when Cnt i = , i.e., only on the + 1 query to the i'th segment, and since q * * = (q * + 1)( + 1) − 1, Sim is only used to simulate at most q * symbols, and so the (adaptive) ZK of (P, V ) implies that the simulated answers are -statistically close to the corresponding symbols in a real proof π .
by replacing the simulated answers of Sim with the actual bits in the i'th section of the proof π. (In particular, these are bits in random RPE-encodings of π 1 , . . . , π N .) Then H i−1 1 and H i 1 are identically distributed by the -secrecy or -reconstruction of the RPE. To see why this holds, we consider two cases depending on whether or not V * made more than queries to the i'th segment. If V * made at most queries to the i'th segment, then all queries in H i−1 1 were answered according to an RPE-encoding of 0 k , whereas all queries in H i 1 were answered according to an RPE-encoding of (the binary representation of) π i . The bits queried in the i'th segment (and consequently, also the entire hybrids) are therefore identically distributed by the -secrecy of the RPE.
If, on the other hand, V * made more than queries to the i'th segment, then the first queries in H i−1 1 were answered according to an RPE-encoding of 0 k , and the remaining queries were answered using a resampled encoding of (the binary representation of) π i , resampled consistently with the answers to the first queries; whereas in H i 1 all queries to the i'th segment were answered according to a random encoding of (the binary representation of) π i . In this case, the distributions are identically distributed by the -reconstruction of the RPE.
We conclude the proof by noting that H N 1 is distributed identically to the real view of V * .
Remark 5 (ZK-PCPs from weaker primitives). We note that if one only requires that ZK hold against malicious non-adaptive verifiers, then it suffices for the underlying ZK-PCP system over Σ to have ZK against non-adaptive verifiers. Additionally, the reduction can be instantiated with an RPE in which secrecy and reconstruction hold statistically with some error , in which case the overall simulation error will be + (N − q * ). We refer the interested reader to [40] for a proof of these claims.

ZK-PCPs with Square-Root Gap
In this section we describe the √ q * -query q * -ZK-PCPs of [13] (i.e., the system has q * -ZK with an honest verifier that makes √ q * queries), which are obtained by appropriately instantiating the building blocks of Construction 4. These are the only known PCPs to date that have full-fledged ZK with a non-adaptive honest verifier. We first describe how we instantiate the building blocks. The Building Blocks. Hazay et al. [13] instantiate Construction 4 with a ZK-PCP of [15] (using an improved soundness analysis given in [13]), and an RPE based on linear codes.
More specifically, the ZK-PCP over Σ is obtained using the "MPC-in-the-head" technique. It has perfect ZK against malicious verifiers querying at most a constant fraction of proof symbols (for an a-priori bounded constant), where the honest verifier obtains a negligible soundness error by non-adaptively querying only a square-root of the proof symbols. We note that the original soundness analysis of [15] required the honest verifier to make as many queries as a malicious verifier, but this analysis was recently improved by [13].
Theorem 6 (Non-adaptive ZK-PCPs over large alphabets with √ Q-gap, implicit in [15]). For any L ∈ NP, any Q ≥ 3, and any input length n, there exists an alphabet Σ of size |Σ| = 2 poly(n,log Q) for which there exists a ZK-PCP for L over Σ, with negl(Q) soundness error with a non-adaptive honest verifier that makes log Q · √ Q queries, proofs of length Q, and perfect Ω(Q)-ZK.
The RPE that [13] uses is obtained by applying a general observation of [37,39]that the existence of linear codes implies the existence of RPEs-to the linear codes of Decatur [41]. Specifically, Ball et al. ( [37], Lemma 2) prove the following, where a code C ⊆ {0, 1} n is linear if its encoding procedure simply multiplies the input with a public generator matrix, and the distance of the code is min c∈C Ham(c, 0 n ) (i.e., the minimal weight of a non-zero codeword): Lemma 1 (RPEs from linear error-correcting codes [37]). If there exists a linear error-correcting code C ⊆ {0, 1} n with messages in {0, 1} k and distance d, then there exists a (k, n, d − 1)-RPE.
To obtain an RPE with good parameters, we apply Lemma 1 to any explicit family of linear codes with constant rate and constant relative distance. For example, we can use the codes of ([41], Theorem 2.1), which already posses secrecy from partial views. (We note that the construction of [41] relies on Toeplitz matrices of logarithmic size which generate codes with good parameters. Such a matrix can be efficiently found by traversing all these matrices by some pre-defined order, and using the first matrix satisfying the desired properties.) In particular, we have Corollary 1 (RPEs). For every message length k ∈ N, there exists a (k, O(k), Ω(k))-RPE.
A ZK-PCP with Square-Root Query Gap. With these building blocks in place, we are ready to prove Theorem 3.
Proof of Theorem 3. We instantiate Theorem 5 with the ZK-PCP system of Theorem 6 and the RPE of Corollary 1. We assume without loss of generality that q * ≥ n (where n is the input length). Since we set Q below to be polynomially-related to q * (and consequently also to n), there exists a constant c such that the PCP of Theorem 6 is over an alphabet of size 2 Q c . Let α = 1/(c + 1), then we instantiate Theorem 6 with Q := (q * ) α , and set k = Q c in Corollary 1. Then Theorem 5 guarantees that the resultant ZK-PCP has proofs of length Q · O(Q c ) = O Q c+1 = (q * ) α·(c+1) = O(q * ) with perfect ZK against (possibly malicious and adaptive) verifiers making Ω(Q) · Ω(Q c ) = Ω(q * ) queries, and a negl(Q) = negl(q * ) soundness error with a non-adaptive honest verifier the query complexity of which is The theorem now follows for any which is larger than (c + 1/2)/(c + 1) (and for a sufficiently large q * ).
Theorem 3 allows one to choose the ZK query bound q * . Hazay et al. [13] also give an alternative formulation of Theorem 3, in which the square-root query gap obtained by the ZK-PCP system is more clearly manifested.
Corollary 2 (ZK-PCP with √ n query gap, Corollary 10 of [40]). There exists a constant c > 0 such that there exists ZK-PCP with perfect Ω n c+1 -ZK, and negl(n) soundness error with an honest verifier that non-adaptively queriesÕ n c+1/2 proof bits, where n denotes the input length.
Proof. We instantiate Theorem 5 with the ZK-PCP system of Theorem 6 and the RPE of Corollary 1. Setting Q = n in Theorem 6, let c be a constant such that the PCP of theorem 5 is over an alphabet of size n c . We set k = n c in Corollary 1. Then Theorem 5 guarantees that the resultant ZK-PCP has proofs of length n · O(n c ) = O n c+1 with perfect ZK against (possibly malicious and adaptive) verifiers making Ω(n) · Ω(n c ) = Ω n c+1 queries, and a negl(n) soundness error with a non-adaptive honest verifier the query complexity of which is log n · √ n · O(n c ) =Õ n c+1/2 .

The ZK-PCPs of Ishai et al.: ZK from LR Circuits
The main result of this section is a construction of witness-indistinguishable PCPs for NP with a non-adaptive honest verifier and an exponential query gap (between the query complexity of the honest and malicious verifiers), which was given in [8]: Theorem 7 (WI-PCPs for NP, formal statement of Informal Theorem 2). Let n ∈ N be an input length parameter. For any query bound q * = poly(n) there exists a non-adaptive poly(log q * , κ)-query (q * , negl(q * ))-WI-PCP for NP with negl(κ) soundness error, where κ is a statistical security parameter.
The WI-PCP system is constructed from leakage-resilient circuits. Historically, this construction was presented before the ZK-PCPs of Section 3, and was the first to show a connection between ZK-PCPs and leakage resilience. Moreover, it was the first construction of PCPs with (relaxed) ZK against malicious verifiers with non-adaptive honest verification. Compared to the ZK-PCPs of Section 3, the scheme we describe in this section has the advantage of obtaining an exponential query gap: the scheme is ZK against q * -query bounded verifiers, but the honest verifier only needs to query polylog(q * ) proof bits to verify the proof (setting κ = polylog(q * )). However, the PCP system described in this section obtains a weaker form of ZK called Witness Indistinguishability (WI) in which the ZK simulator is not guaranteed to be efficient. The construction of Section 3 has the added feature of being simpler.
The main building-block in the transformation of [8] are leakage-resilient circuits-a stronger primitive than the leakage-resilient encodings used by [13]. Indeed, leakage-resilient encodings only protect information, whereas leakage-resilient circuits protect computations. Thus, while Hazay et al. [13] could only use leakage-resilient encodings to protect the proof once it was already generated, Ishai et al. [8] employ leakage-resilient circuits to protect proof generation itself. When used in the context of proof generation, these leakage-resilient circuits in effect amplify leakage resilience: from a relatively low leakage bound on the witness, to a much larger leakage bound on the entire computation. This amplification results in an exponential query gap, which eluded the ZK-PCPs of Section 3. High-Level Idea: Leakage-Resilient Proof Generation. The goal of the prover P is to convince the verifier V that x ∈ L, where P has a corresponding witness w. Recall from Section 1.1.2 that one way of doing so is to emulate the verification circuit C of the corresponding NP-relation R L on (x, w), where V then checks that this computation was performed correctly. Indeed, without loss of generality we can assume that R L has a canonical form in which the witness consists of the entire wire values of C. In particular, in a PCP system the prover would generate the PCP from the entire wire values of C, which we denote by [C, x, w]. While this might blatantly violate ZK (e.g., w itself is part of [C, x, w], and the PCP might explicitly contain these wire values), the main observation of [8] is that by querying few proof bits, V is leaking on a computation-namely, the evaluation of C on (x, w). Therefore, one can use leakage-resilient circuits to guarantee that this leakage gives V no information on the witness w (i.e., C's input).
Concretely, one can first replace C with a leakage-resilient version C, then have V check the computation performed in C. If V were reading directly from the wire values of C, then we would need C to resist probing leakage (similar to Section 3). However, V is actually probing bits in the PCP π, which was generated by applying the prover algorithm to the wire values of C. Therefore, V obtains more evolved forms of leakage on these wire values, and we thus need leakage resilience against a wider class of potential leakage functions. Still, V cannot obtain any leakage that it wants on the wire values of C, but rather it is restricted to whatever the prover computes on these wire values during proof generation. In particular, by restricting the types of functions the prover applies to the wire values of C, we can "control" the type of information which even a malicious verifier V * obtains on the witness. (Indeed, V * can deviate from an honest verification strategy by choosing to read different-and a larger number of-proof bits than the honest verifier, but cannot affect the proofs generation itself.) This gives a general blueprint for transforming standard PCPs into ZK-PCPs: the prover and verifier both hard-wire x into the verification circuit C, to obtain a circuit C x . Then, they generate the LR-version of it C x , which operates on encoded inputs (see Section 4.1 below). Then, P randomly encodes the witness w as w, and generates the PCP from the wire values C, w . Finally, the verifier V runs the PCP verifier to verify the proof. Achieving Soundness. While (for an appropriate choice of the family of leakage functions) the blueprint described above would indeed yield ZK proofs, they would not be sound. The reason is that soundness of the original PCP relied on the fact that C(x, ·) is satisfiable only if x ∈ L, i.e., there exists a corresponding witness w such that (x, w) ∈ R L . This, however, is not preserved in the leakage-resilient version C x of C(x, ·). In fact, in many (if not all) existing constructions, C x is necessarily satisfiable-leakage resilience relies on this fact! To understand why this is the case, and how we can still achieve soundness, we need to first take a closer look at how these LR constructions work.

Leakage-Resilient Circuit Compilers (LRCCs)
In this section we describe the main building block used in the ZK-PCPs of this section: Leakage-Resilient Circuits Compilers (LRCCs). Compared to the LR encodings used in Section 3, LRCCs offer a stronger LR guarantee: they protect computation rather than information. More specifically, LRCCs are compilers which transform a given circuit C into a functionally-equivalent circuit C, which is leakage resilient in the sense that leakage on the wire values of C reveals no information on its input. Of course, this cannot be obtained if the input of C is given to C in the clear, since then leakage on the wire values reveals information about the input. Instead, the LRCC is associated with a (LR) encoding scheme, which is used to encode the inputs to (and intermediate values in the computation of) the LR circuit C.
We first define the circuit model which we use, then define circuit compilers, and finally define leakage-resilient circuit compilers. Circuit Model. An (arithmetic) circuit C over the field F and the set X = {x 1 , . . . , x n } of variables is a directed acyclic graph the vertices of which are called gates and the edges of which are called wires, and are labeled with functions over X. Every gate in C of in-degree 0 has out-degree 1 and is either an input gate labeled by a variable from X; or a constant gate const α labeled by a constant α ∈ F. Gates of in-degree 2 and out-degree 1 are labeled by one of the operations +, −, ×, i.e., addition, subtraction, and multiplication over F. (Jumping ahead, we will use an LRCC of [42], which employs additional gates, e.g., to duplicate values in the circuit. Since we do not explicitly use these additional gates, we omit their description to simplify the presentation.) The size |C| of a circuit C is the sum of the number of wires, input gates, and output gates, in C. The depth of C is the number of gates on the longest path from inputs to outputs. We also consider Boolean circuits, with ∧, ∨ gates (replacing the +, −, × gates of arithmetic circuits), const 0 and const 1 gates, and ¬ gates with in-and out-degree 1.
We define several circuit complexity classes, which restrict the size and depth of Boolean and arithmetic circuits. Specifically, Notation 4. SHALLOW (d, s) denotes the class of all depth-d, size-s arithmetic circuits over F. Similarly, BOOL(d, s) denotes the class of all depth-d, size-s Boolean circuits. Somewhat abusing notation, we use the same notations to denote the families of functions computable by circuits in the respective class of circuits. AC 0 denotes all constant-depth and polynomial-sized Boolean circuits over unbounded fan-in and fan-out (i.e., in-degree and out-degree) ∧, ∨, ¬, const 0 and const 1 gates.

Definition 10 (Satisfiable Circuits). A circuit C
We define the notion of a circuit compiler. Informally, it consists of an encoding scheme and a compiler algorithm, that compiles a given circuit C into a circuit C that emulates the operation of C over encoded inputs. Formally, Definition 11 (Circuit compiler over F). A circuit compiler over F is a pair (Comp, (Enc, Dec)) such that the following holds: • Syntax: -(Enc, Dec) is an encoding scheme, where Enc is a PPT algorithm that on input a vector x ∈ F n , and an additional length parameter 1 len (which is used to determine the amount of random masks needed to protect the computation from leakage; see Definition 13), outputs a vector x, and Dec is a polynomial-time algorithm; We assume that x ∈ F n for some n = n(n, len).

-
Comp is a polynomial-time algorithm that on input an arithmetic circuit C over F outputs an arithmetic circuit C; • correctness: For any arithmetic circuit C, and any input x for C, we have Pr C( x) = C(x) = 1, where x ← Enc x, 1 |C| .
As discussed above, we will need circuit compilers that are also "sound" in the sense that the compiled circuit C is satisfiable only if the original circuit C is satisfiable. We stress that this property should hold even when the inputs of C are not valid encodings according to Enc. (Comp, (Enc, Dec)) is SAT-respecting if for every circuit C : F n → F, if C = Comp(C) is satisfiable then C is satisfiable. That is,

Definition 12 (SAT-respecting circuit compiler). A circuit compiler
• For arithmetic C: if there exists an x * ∈ F n such that C( x * ) = 0, then there exists an x ∈ F n such that C(x) = 0; • For Boolean C: if there exists an x * ∈ {0, 1} n such that C( x * ) = 1, then there exists an x ∈ {0, 1} n such that C(x) = 1.

Leakage-Resilient Circuit Compilers.
We now define Leakage-Resilient circuit compilers. An LRCC is associated with a class LE AK of leakage functions, and guarantees that when the input to C is properly encoded, then leakage from LE AK on the wire values of C reveals no information about the input and internal computations, except for the output of C. This is formalized by requiring that the wire values are distributed statistically close for every pair of inputs x, x such that C(x) = C(x ). We first set some notation. Definition 13 (LRCC). Let F be a finite field, LE AK be a function class, S(n) : N → N be a size function, and (n) : N → R + . A circuit compiler (Comp, (Enc, Dec)) is (LE AK, (n), S(n))leakage resilient if for all sufficiently large n's, every arithmetic circuit C : F n → F m (for some m) of size |C| ≤ S(n), every ∈ LE AK of input length C , and every x, x ∈ F n such that where x ← Enc x, 1 |C| and x ← Enc x , 1 |C| . LRCCs for Boolean circuits are defined similarly.
A few remarks are in order. First, we note that the LR guarantee of Definition 13 is a relaxed version of the standard notion. Specifically, while Definition 13 only guarantees indistinguishability-namely, leakage functions cannot distinguish between the wire values of C when evaluated on two different inputs (so long as C has the same output on both), the standard definition (e.g., in [18,[42][43][44]) is simulation-based. That is, the standard definition requires the existence of a PPT simulator which, for every circuit C, every input x for C, and any leakage function ∈ LE AK, can simulate the leakage on the wire values of C given only the description of C and its output C(x). To see why this guarantee is stronger, notice that if for some input x there exists no x such that C(x) = C(x ) then Definition 13 provides no secrecy guarantee for x. Moreover, Definition 13 is equivalent to a slightly modified version of the standard definition-specifically, in which there exists a simulator as specified above, but it is not guaranteed to be efficient. Indeed, given C, C(x) the simulator could find on its own an x such that C(x) = C(x ), then simulate the leakage by computing C, x . We focus on the relaxed version because it captures the security guarantee which we achieve (in fact, Ishai et al. [8] give strong indications that SAT-respecting LRCCs for "useful" leakage, with the stronger LR guarantee with efficient simulation, do not exist-see Section 1.2).
Second, we note that for simplicity, the error in Definitions 12 and 13 depends (only) on the input length n. This can be naturally extended such that the error depends also on a security parameter κ, which is given as input to Comp. Gadget-Based LRCCs. A leading technique in constructing LRCCs -which is the one employed in all LRCCs described in this work -is gadget-based. Such constructions employ a double-layer of encoding, where the LRCC (Comp, E) is associated with an internal encoding scheme Enc in , Dec in , and Comp outputs a circuit C in which the gates and wires of the circuit C over F are replaced with gadgets and bundles. A bundle b is an encoding (according to Enc in ) of some b ∈ F, representing the value of a wire in C; and a gadget G g is a (Boolean or arithmetic) circuit over F which operates over bundles and emulates the operation of the corresponding gate g. More specifically, in addition to taking as input bundle-encodings of g's inputs, G g has additional masking inputs. These masking inputs are encodings (according to Enc in ) of some masking values in F * with a specific, pre-determined structure (for example, in [42] a masking value is the all-0 string), which are used to obtain LR. We associate with G g a set W F g ⊂ F * (for Well-Formed) which consists of all encodings of masking values with the "correct" structure. We say that the masking inputs of G g are well formed if they are in W F g (otherwise we say they are ill-formed). A gadget G g is guaranteed to emulate g when its inputs are valid encodings of inputs for g, and its masking inputs are well-formed. For example, if g = ×, then for every x 1 , x 2 ∈ F, for every bundle encodings x i ← Enc in (x i ), i = 1, 2, and for every well-formed masking input bundles m, G g (x 1 , x 2 , m) encodes x 1 × x 2 .

Remark 8.
We note that the double layer of encoding described above is implicit in most works on leakage resilience. The reason is that, as described in Section 1.1.2, standard LRCCs in the literature are described as randomized circuits that generate the needed randomness internally (sometimes, using "opaque" gates which are assumed to be leak-free), whereas we describe the LR circuit as deterministic, and provide the needed randomness as part of the input to the circuit. For this reason, we need to explicitly use a double layer of encoding.
Leakage resilience of C will follow from a combination of the leakage resilience of the internal encoding scheme Enc in , and the following leakage-resilience guarantee of the gadgets. If the masking inputs are uniformly distributed over Enc in W F g , then given any valid encodings as standard inputs to the gadget: (1) the outputs are random subject to encoding the correct output (as determined by the standard inputs and the gate operation); and (2) the internal wire values of G can be reconstructed (i.e., regenerated) in a low complexity class, where the reconstructed and actual wire values are statistically close.
The masking inputs for all gadgets of C are provided as part of the inputs to C, using the double-layered encoding, as we now explain. To simplify the description, we focus on describing how this is performed for the LRCC of [42] (see Remark 9 below on how the double-layered encoding extends to other LRCCs as well). In the LRCC of [42], the masking values for all gates g are simply the all-0 string, and different gates only differ in the length of the string (i.e., the number of 0's). Let M denote the upper bound on the number of masking values used by any gate g. Then E = (Enc, Dec) where Enc takes as input an x ∈ F * , and a size bound S, and outputs an encoding (x, m) = Enc in x, 0 M·S . For a given a circuit C of size |C| ≤ S, its leakage-resilient version C = Comp(C) takes as input encodings of the form (x, m), where x are the input bundles of C, and m are used as the masking inputs of the gadgets of C. Since each gadget uses at most M encodings from m, and C has at most S gadgets, m contains sufficiently-many encodings (according to Enc in ) of 0 to enable the evaluation of all gadgets ofĈ.
The computation in C is performed over encodings, so the outcome of this computation -at least as it was described above -results in an encoding of the output of C. Since C should have the same output as C, the final step in C consists of a decoder which decodes the output.

Remark 9.
We note that the double-layer encoding idea described above naturally extends to other LRCCs as well. Indeed, all that is needed is that all gadgets use the same masking values (differing only in the number of masking values they use). In fact, this idea can also be used if different gadgets use different masking values, in which case m can include S sets of masking inputs, each set containing masking inputs for every possible gate g, from which C can choose the appropriate masking inputs for each gate. This will result in a correct and leakage resilient (albeit less efficient) construction.

An SAT-Respecting LRCC for Arithmetic Circuits
In this section we describe a SAT-respecting LRCC of [8] for arithmetic circuits, which is based on the LRCC of [42]. We first explain why the LRCC of [42] (and similar LRCCs) are not SAT-respecting. Why are standard LRCCs not SAT-Respecting? Recall that an LRCC is SAT-respecting if for every circuit C, the following holds: if its leakage-resilient variant C is satisfiable, then so is C. This is not the case for many LRCCs, and specifically for gadget-based ones such as [42][43][44]. Indeed, in such LRCCs, the correctness of the computation relies on the assumption that the masking inputs of the gadgets are well-formed. However, C does not necessarily emulate C if its masking inputs are ill-formed. In fact, in these LRCCs one can force the output of C to be any desired value by appropriately choosing the masking values. This property is crucial for leakage resilience, since the security proof uses such ill-formed masking inputs to switch the input from x to a different x . Therefore, the main challenge in obtaining the SAT-respecting property is to guarantee that the masking inputs are well-formed while still allowing the security reduction to use ill-formed masking inputs.
Before describing how this is done, we make two comments. First, recall that (as noted above) in the leakage-resilience literature the masking inputs are usually assumed to be generated by leak-free components, or opaque gates. In particular, the outputs of these components are guaranteed to be distributed according to the correct distribution (i.e., be well-formed), and their internal wires are unavailable to the leakage function. To eliminate this trust assumption, we instead have these encodings provided as part of the input, and check their validity to achieve the SAT-respecting property. Second, we note that the LRCC of [18] does posses the property that C is satisfiable only if C is, but this LRCC only resists AC 0 leakage [45], a leakage class which does not seem sufficiently strong to contain the function one needs to apply to an NP-witness to obtain a PCP. Checking Validity of Encodings While Preserving Leakage Resilience. The main technical ingredient in the SAT-respecting LRCC of [8] is their component which checks wellformedness of encodings in a leakage-resilient manner. The technique is reminiscent of the "2-key trick" of [46] (used to convert a CPA-secure encryption scheme into a CCA-secure one) where they hold two copies of C, and in the security reduction one of the copies is used to achieve the SAT-respecting property, whereas the other is used to obtain leakage resilience. This component is tailored to the LRCC of [42], exploiting the fact that well-formed masking inputs of [42] are simply encodings of the all-0 string.
More specifically, the SAT-respecting LRCC of [8] consists of 3 parts. The first is two copies C 1 , C 2 of the circuit C, obtained using the LRCC of [42]. The second is a maskchecking component C 0−check , which checks that at least one of the copies C 1 , C 2 uses well-formed masking inputs. The important point is that, for the security proof to go through, C 0−check must hide which of the copies uses well-formed masking inputs. (This is because in the security proof first C 1 and then C 2 use ill-formed masking inputs; for the hybrids to be indistinguishable it must be the case that one cannot distinguish between the two cases.) As it turns out, this can be achieved by replacing C 0−check with its leakageresilient version C 0−check (obtained using the LRCC of [42]). This now introduces a further complication since C 0−check has masking inputs of its own, the well-formedness of which must be verified. Indeed, if C 0−check is allowed to use any masking inputs, then it is no longer guaranteed to emulate C 0−check . In particular, by using ill-formed masking inputs in C 0−check one can flip its output, thus causing it to accept even when the masking inputs of both C 1 , C 2 are ill-formed, rendering the C 0−check component completely useless. The third component-a mask decoder C dec -is used to guarantee that C 0−check uses well-formed masking inputs. Using a double-layer of mask checking (i.e., checking the masks of C 1 , C 2 , and then checking the masks of the mask-checker) is helpful because the computations in C 0−check are not directly related to the inputs of C 1 , C 2 . As such, the masking inputs of C 0−check can be checked directly by simply decoding them (and checking that all decoded values are 0) without violating LR. We now formally describe each of the components, and the resultant SAT-respecting LRCC. The Mask Checker C 0−check . The mask checker verifies that at least one of the copies C 1 , C 2 uses well-formed masking inputs, while hiding which one. Recall that in the LRCC of [42] well-formed masking inputs are encodings of the all-0 string. Thus, if m 1 , m 2 denote the masking values whose encodings are used in C 1 , C 2 , it suffices to check that m 1 j × m 2 l = 0 for every j, l. (We note that this check assumes that any masking input is a valid encoding -according to Enc in -of some masking value, namely that the internal encoding scheme is onto. This is indeed the case for the internal encoding scheme used in [42].) We construct C 0−check in two stages. We first describe a "binarization" component T which checks that a given field element is 0, then use it to construct C 0−check .
The mask decoder C dec . As noted above, the mask decoder simply decodes the masking inputs used in C 0−check , and checks that all decoded values are 0. Decoding is performed using the decoder Dec in of the internal encoding procedure of [42]. We note that this encoding procedure is linear, and so decoding is performed simply by computing the inner product of the input encoding with some fixed vector (e.g., the all-1 vector). In particular, for each encoding length n, the corresponding decoding circuit Dec in can be implemented using O( n) gates arranged in O(log n) layers. The SAT-Respecting LRCC. Having defined the three components of the SAT-respecting LRCC, we are now ready to describe the compiler itself, which is given in Figure 2.
The following claim summarizes the properties of Construction 11. Roughly, it states that if the internal encoding scheme used in Construction 11 is leakage resilient against a leakage family LE AK E , then Construction 11 is an SAT-respecting LRCC against a slightly weaker leakage family LE AK. N → N be a size function, and (n) : N → R + . Let E in = Enc in , Dec in be a linear, onto, (LE AK E , (n))-leakage-resilient encoding scheme with parameters n, σ and n = n(n, σ), such that LE AK E = LE AK • SHALLOW 7, O n 4 (1, S(n)) · S(n) . Then, there exists an SATrespecting, (LE AK, 4 (n) · ( n(1, S(n)) + 1) · S(n), S(n))-LRCC over F. Moreover, for every C : F n → F, the compiled circuit C has size C = O |F| 2 · n 4 (1, S(n)) · |C| 2 .
The proof of Claim 10 used the following fact regarding the LRCC of [42].
The Encoding Scheme. Enc : F n × {1} * → F 2 n in +2 M+2 M 0 on input x, 1 σ outputs an encoding ( x 1 , x 2 ), where x i ← Enc in x, 0 M+M 0 , 1 σ , and n in , M, M 0 denote the lengths of encodings of messages of length m, M, M 0 , respectively. Dec on input ( x 1 , x 2 ), 1 σ computes Dec in ( x 1 , 1 σ ), and discards the last M + M 0 field elements. We use n = n(n, σ) to denote the length of encodings output by Enc.
i encodes x, and r i , r i,0 encode 0 M , 0 M 0 , respectively. (We note that r 2,0 is not used by the leakage-resilient circuit, but is included in x 2 because the same internal encoding scheme Enc in is used to generate both x 1 and x 2 .) The Compiler Comp. On input a circuit C : F n → F, the compiler Comp outputs the circuit C : F n(n,|C|) → F that on input x in 1 , r 1 , r 1,0 , x in 2 , r 2 , r 2,0 operates as follows.

Lemma 2.
If E in is linear and onto, then Construction 11 is SAT-respecting.
Proof. Assume that C( x) = 0 for some x ∈ F n , and denote x = x * 1 , r 1 , r 1,0 , x * 2 , r 2 , r 2,0 . We show that there exists an x ∈ F n such that C(x) = 0. Since C( x) = 0 then by the definition of C, we have (1) f = 1, and (2) C 1 x * 1 , r 1 = 0. By (1), C 1 x * 1 , r 1 = C 2 x * 2 , r 2 , and C dec , C 0−check output 1. Notation 8 then guarantees that r 1,0 is well-formed which-by the correctness of Comp -guarantees that C 0−check emulates C 0−check . (Here, we also use the fact that C dec is independent of all other components of, and inputs to, C.) Moreover, since the encoding scheme is onto then r 1 , r 2 define inputs to C 0−check which cause it to output 1(because C 0−check outputs 1, and its masking inputs are well-formed). Notation 7 then guarantees that at least one of r 1 , r 2 is well-formed. Assuming (without loss of generality) that r 1 is well-formed, then the correctness of Comp guarantees that C 1 emulates C, so , where x ∈ F n is obtained by computing x = Dec in x * 1 (x is well-defined because E in is onto).

Lemma 3.
If E in is (LE AK E , (n))-leakage resilient, then for every function class LE AK such that LE AK • SHALLOW 7, O n 5 (S(n)) · S(n) ⊆ LE AK E , every circuit C : F n → F of size |C| ≤ S(n), and every x, y ∈ F n such that C(x) = C(y), it holds that C, x and C, y are (LE AK, 4 (n) · ( n(1, S(n)) + 1) · S(n))-leakage resilient, where x ← Enc x, 1 |C| and y ← Enc y, 1 |C| .

Proof of Lemma 3
In this section we prove the leakage-resilience property of Construction 11. The analysis follows a (by now standard) proof paradigm for gadget-based LRCCs, but is more complex (compared to, e.g., the analysis in [42]) because of the mask-checker and mask-decoder components.

High-Level Description of the Leakage-Resilience Argument.
Recall that the goal is to prove that leakage functions in some leakage class LE AK cannot distinguish between the wire values of C when evaluated on (encodings of) two different inputs x, y. This is achieved by reduction to the leakage resilience of the underlying encoding scheme E against leakage classes in a somewhat larger leakage class LE AK E . The wire bundles of C are divided into two sets: internal bundles that are part of the internal computations in a gadget, and external bundles that connect two gadgets. The proof uses a hybrid argument in which we first replace all the internal bundles from carrying the real encodings to "simulated" encodings, and then replace all external bundles from encodings of the real values to encodings of random values. We then prove leakage resilience by showing that each pair of adjacent hybrids are computationally indistinguishable.
More specifically, consider two hybrid distributions H, H in which we replace some external bundle i. Proving that H ≈ H is by reduction to the leakage resilience of the underlying encoding scheme, where we show that if H and H are distinguishable by a function ∈ LE AK, then there exists a function E ∈ LE AK E that can distinguish between encodings of two different values v, v . The idea is that given an encoding e of either v or v , E would use e to generate the entire hybrid distribution (which would be either H or H , depending on whether e encodes v or v , respectively), then evaluate . It turns out that the only wires of H, H that depend on e are the internal wire bundles of the (at most two) gadgets that "touch" bundle i, in the sense that bundle i is either an input or output bundle of the gadget. Thus, while all other wire bundles can be hard-wired into E , it would still need to generate the internal wire bundles of the gadget(s) that touch bundle i. In particular, the computational complexity of E would be higher than that of , which causes a loss in leakage resilience. It is therefore imperative that the internal wire values of the gadgets could be generated from their inputs and outputs by a function in a low complexity class. These functions are called local reconstructors. The crucial point here is that the local reconstructor is given not only the gadget's inputs, but also its outputs (otherwise, it would be impossible to generate the internal wires in a low complexity class, because some of the gadgets perform complex computations). Before delving deeper into the details of the analysis, we first set the needed terminology regarding gadgets and their local reconstructors. Properties of Gadgets. The analysis will use two properties of gadgets. The first is local reconstructibility: for every pair of "legal" input and output encodings, the internal wires of the gadget (as determined by the input-output pair, and its masking inputs), can be simulated in a low complexity class.
Definition 14 (Local reconstructibility). Let G be a gadget and W F denote its set of well-formed masking inputs. A pair (x, y) of encodings is plausible for G if G(x, m) = y for some m ∈ W F . For > 0, and families LE AK, F G of functions, G is (LE AK, )-reconstructible by F G if the following holds. There exists a distribution REC over functions rec such that: • rec takes as input G's inputs and output, and simulates the masking inputs, and internal wires, of G. • The following distributions are (LE AK, )-leakage resilient for any plausible pair (x, y) for G: (1) rec(x, y) for rec ← REC; and (2) the actual distribution of the wires of G (as determined by the distribution of the masking inputs), conditioned on x, y.
We will need the following result of [42] which shows that all gadgets in their LRCC (Comp , E ) are locally reconstructible in a low complexity class. (We note that Faust et al. [42] actually prove a stronger result, where some of the gadgets have local reconstructors in lower complexity classes than the one stated here, and indistinguishability holds regardless of the leakage resilience of E. For clarity reasons, we chose to give a simplified and weaker version of their results which nonetheless suffices for our needs).
The second property is that gadgets are re-randomizing in the sense that the encodings at the output of each gadget are uniform subject to encoding the "correct" value. Formally, Definition 15 (Gadget Re-Randomization). A gadget G with set W F of well-formed masking inputs is re-randomizing if for every standard input x = Enc(x), when the masking input is sampled m ← W F then G(x, m) is random subject to encoding the correct output (as determined by x, and the gate which G emulates).
The Hybrid Argument. Let C : F n → F be an arithmetic circuit of size |C| ≤ S(n), and let x, y ∈ F n . We show that for every ∈ LE AK,

SD
C, x , C, y ≤ (n) where (n) := 4 (n) · ( n(1, S(n)) + 1) · S(n). We bound the statistical distance using a hybrid argument. We define: H x := C 1 , x 1 , r 1 , C 2 , x 2 , r 2 , C 0−check , r 1 , r 2 , r 1,0 , C dec , r 1,0 H y := C 1 , y 1 , r 1 , C 2 , y 2 , r 2 , C 0−check , r 1 , r 2 , r 1,0 , C dec , r 1,0 H y,x := C 1 , y 1 , r 1 , C 2 , x 2 , r 2 , C 0−check , r 1 , r 2 , r 1,0 , C dec , r 1,0 and notice that H x are the wire values of C on input an encoding of x, H y are the wire values of C on input an encoding of y, and H y,x is a hybrid distribution, consisting of the wire values of C when the first copy C 1 has input (an encoding according to Enc in ) of x, whereas the second copy C 2 has input (an encoding according to Enc in ) of y. We note that H y,x is only used in the proof-it is never obtained in an actual evaluation of C. The proof proceeds by showing that for every ∈ LE AK, SD( (H x ), (H y,x )) and SD( (H y,x ), (H y )) are upper bounded by 2 (n) · ( n(1, S(n)) + 1) · S(n), through a sequence of hybrids. Bounding SD( (H x ), (H y,x )) for a leakage function . The difference between these distributions is that in H x both copies C 1 , C 2 of (the leakage-resilient version of) C are evaluated on input x, whereas in H y,x the first is evaluated on y (and the second on x). We bound the statistical distance through a sequence of hybrids, defined as follows.
H x in : this hybrid distribution replaces the internal wires of gadgets, and is obtained by: (1) evaluating C honestly on x ← Enc x, 1 |C| ; (2) picking local reconstructors for all gadgets of C 1 (such reconstructors exist by Lemma 4), and re-computing their internal wires using these reconstructors; and (3) re-evaluating C 0−check on the new masking inputs generated for the gadgets of C 1 , by re-computing the internal wires of all gadgets G of C 0−check , the inputs of which are masking inputs used in gadgets of C 1 -but without changing the masking inputs these G gadgets use, or their outputs. Lemma 5 below shows that this is indeed possible. (Crucially, since reevaluating C 0−check does not influence its masking inputs, this does not influence the computation in C dec , so there is no need to re-evaluate it.) H x ext : this distribution replaces the external wires (i.e., wires connecting gadgets), and is obtained as follows: • Generating the wires of C 2 : encode x = x 1 , r 1 , r 1,0 , x 2 , r 2 , r 2,0 ← Enc x, 1 |C| , and honestly evaluate C 2 on x 2 with masking inputs r 2 .
• Generating the wires of C 1 : pick a random encoding out ← Enc in 1, 1 |C| for the output of C 1 , and honestly compute the wires of the output decoder of C 1 . (As discussed in Section 4.1, C 1 contains an output decoder, which is needed because the computations in C 1 are performed over encodings.) Then, pick a random input z ∈ R F n for C 1 and encode z 1 ← Enc in z, 1 |C| . Next, pick random encodings (according to Enc in ) for the outputs of all gadgets (except the gadgets the outputs of which are the inputs of the output decoder, since the outputs of these gadgets have already been fixed). This effectively determines the standard inputs, and outputs, of all gadgets of C 1 . Next, pick local reconstructors for all gadgets of C 1 , and use them to compute the internal wires of the gadgets. The reconstructors determine the (possibly ill-formed) masking inputs of the gadgets, which we denote by r 1 . r 1 together with r 2 form the standard inputs of C 0−check . H y,x ext : this hybrid is generated similarly to H x ext , except that instead of evaluating C on an encoding of x, we use the internal encoding scheme to generate encodings of y 1 , r 1 , r 1,0 and x 2 , r 2 , r 2,0 (where y 1 , x 2 encode y, x, respectively), and use them as inputs to C 1 , C 2 , respectively. H y,x in : this hybrid is generated similarly to H x in , except that instead of evaluating C on an encoding of x, we use y 1 , r 1 , r 1,0 and x 2 , r 2 , r 2,0 as inputs to C 1 , C 2 , respectively.
We now bound the statistical distance between the outputs of leakage functions on each pair of adjacent hybrids. The following notation will be useful.

Notation 9.
We say that a gadget G of C 0−check is connected to a gadget G 1 C 1 (alternatively, a gadget G 2 of C 2 ) if an input of G is a masking input of G 1 (alternatively, G 2 ).
Bounding SD (H x ), H x in : we show that SD (H x ), H x in ≤ (n) · n(1, S(n)) · S(n) for all ∈ LE AK such that LE AK • SHALLOW 5, O n 5 (1, S(n)) · S(n) ⊆ LE AK E . We use a hybrid argument, replacing the internal wires of the M ≤ S(n) gadgets of C 1 one at a time. We define hybrids H 0 , . . . , H M where H i is obtained by evaluating C on (an encoding of) x, then recomputing the internal wires of the first i gadgets of C 1 using their local reconstructors. Additionally, we recompute the internal wires of gadgets G of C 0−check connected to one of these i gadgets, but without changing the masking inputs of G (this is possible by Lemma 5 below). Then H 0 = H x , H M = H x in . To show that SD (H x ), H x in ≤ (n) · n(1, S(n)) · S(n) for all ∈ LE AK , we show that for every m ∈ [M], and any ∈ LE AK , it holds that SD( (H m ), (H m−1 )) ≤ (n) · n(1, S(n)). Denote the m'th gadget by G. We use Lemma 4 to show that this follows from the leakage resilience of the internal encoding scheme E in . For this, we will need to generate-in a low complexity class-the entire hybrid distributions given only the (either real or reconstructed) internal wires of G. The problem is that since the internal wires of G contain also its masking inputs, changing them affects also computations in C 0−check . The following lemma from [8] states that the influence of modifying the masking inputs of G can be blocked, specifically: (1) that it only affects the internal wires of gadgets G of C 0−check connected to G, and more importantly (2) these internal wire values can be reconstructed without changing the masking inputs used in G .
Lemma 5 (Restating of Lemma 3.13 of [47]). Let G be a gadget of C 0−check connected to gadgets of C 1 , C 2 . Then for any fixed well-formed inputs r 1 , r 2 from gadgets of C 1 , C 2 (respectively), and any fixed well-formed masking inputs m for G , the following holds. For any r 1 , the internal wires of G on input r 1 , r 2 , m can be computed in SHALLOW 2, O n 2 (1, S(n)) given r 1 and the output out of G when evaluated on input r 1 , r 2 and masking inputs m.
Using an averaging argument, we can fix all wires of C 2 , and all wires of C 1 except the internal wires of G (its input and output wires can be fixed). Lemma 5 (which can be used because C 2 and C 0−check use well-formed masking inputs) shows that we can further fix all wires of C 0−check and C dec , except for the internal wires of all gadgets G of C 0−check connected to G (crucially, the masking inputs of these gadgets can be fixed).
Consequently, given the wire values of G (either the real values W R , or the reconstructed wires W S ), we can generate the entire hybrid distribution (either H m−1 or H m , respectively) in SHALLOW 2, O n 5 (1, S(n)) · S(n) by recomputing the internal wires of each of the (at most) O n 3 (1, S(n)) · S(n) gadgets of C 0−check connected to G. (Here, we use Fact 12-G uses at most n(1, S(n)) masking inputs; C 2 has at most O( n(1, S(n)) · S(n)) gadgets, each using at most n(1, S(n)) masking inputs; and each masking input of G is connected to every masking input used in C 2 .) Using Lemma 5, the internal wires of each G can be computed in SHALLOW 2, O n 2 (1, S(n)) , and all these computations can be performed in parallel. Therefore, the hybrid distributions can be generated in SHALLOW 2, O n 5 (1, S(n)) · S(n) . By the assumption of Claim 10, E in is (LE AK E , (n))-leakage resilient, which by Lemma 4 implies that W R , W S are (LE AK , (n) · n(1, S(n)))-leakage resilient for any class LE AK of leakage functions such that LE AK • SHALLOW (3, O( n(1, S(n)))) ⊆ LE AK E . We now claim that H m−1 , H m are (LE AK , (n) · n(1, S(n)))-leakage resilient for every family LE AK of leakage functions such that LE AK • SHALLOW 2, O n 5 (1, S(n)) · S(n) ⊆ LE AK , i.e., for any LE AK such that LE AK • SHALLOW 5, O n 5 (1, S(n)) · S(n) ⊆ LE AK E . Indeed, this follows from the following lemma of [42] (by choosing F to be a singleton containing the function described above which generates H m−1 , H m from W R , W S ). , H x in ≤ (n) · S(n) for all ∈ LE AK such that LE AK • SHALLOW 4, O n 4 (1, S(n)) · S(n) ⊆ LE AK E . We again use a hybrid argument, this time replacing the M ≤ S(n) inputs bundles of C 1 (i.e., bundles corresponding to input wires of C), and bundles at the output of gadgets of C 1 (except for bundles that are used as input of the output decoder of C 1 ). We define hybrids H 0 , . . . , H M , where H i is generated as follows. We evaluate C on a random encoding of x. Then, we replace the first i bundles with random encodings of random values, except if one of these bundles corresponds to the output wire of C, in which case we replace it with a random encoding of 1. Finally, we recompute the internal wires of the gadgets of C 1 using their gadget reconstructors (Lemma 4), and recompute (using Lemma 5) the internal wires (except the masking inputs and outputs) of all gadgets G of C 0−check connected to one of these gadgets. In particular, since the inputs of C 0−check contain also masking inputs used in gadgets of C 1 , this re-computation of wires of C 0−check uses the masking inputs generated by the reconstructors (for any gadget of C 1 whose internal wires were re-constructed). Then Let b denote the value encoded by the m'th bundle in H x in . Let W R ← Enc in b, 1 S(n) , and W S ← Enc in r, 1 S(n) for a random r (except when the m'th bundle corresponds to the output wire of C, in which case we set W S ← Enc in 1, 1 S(n) ). Then W R , W S are distributed identically to the m'th bundle in H m−1 , H m , respectively. We define a distribution F over SHALLOW 4, O n 4 (1, S(n)) · S(n) as follows. Sampling a function f ← F is performed by sampling rec o , rec i from the distribution over reconstructors for G o , G i , respectively (see Definition 14). The function f has all the hard-wired values of H m−1 hard-wired into it. On input e ∈ F n(1,S(n)) , f performs the following: (1) evaluates rec o on the (hard-wired) inputs of G o , and the output e (this reconstructs the masking inputs, and internal wires, of G o ); (2) evaluates rec i on e as one of the inputs, and the other (hard-wired) input and output of G i ; and finally (3) for every gadget G of C 0−check connected to G o or G i , generates its internal wires using Lemma 5 (without changing the output or masking inputs of G ). Then f ∈ SHALLOW 4, O n 4 (1, S(n)) · S(n) . Indeed, by Lemma 4, rec o , rec i ∈ SHALLOW 2, O n 2 (1, S(n)) (and given e, they can be evaluated in parallel). Moreover, given the internal wires of G o , G i , the wires that need to be computed in a gadget G connected to them are computable in SHALLOW 2, O n 2 (1, S(n)) (by Lemma 5, and since the masking inputs of C 2 and C 0−check are well-formed). We conclude by noting that there are at most O n 2 (1, S(n)) · S(n) such gadgets, and they can be evaluated in parallel.
Denote W R := f (W R ), W S := f (W S )) for f ← F , then W R ≡ H m−1 and W S ≡ H m because the gadgets are re-randomizing (which, in particular, guarantees that these equivalences hold despite the fact some of the values in the computation were fixed in advance). By the assumption of Lemma 3, W R , W S -which are encodings according to E in -are (LE AK E , (n))-leakage resilient. Therefore, by Lemma 6, W R , W S (and consequently also H m−1 , H m ) are (LE AK , (n))-leakage resilient for any LE AK such that LE AK • SHALLOW 4, O n 4 (1, S(n)) · S(n) ⊆ LE AK E . ext because the hybrids are independent of the input for C 1 (since the input is re-sampled as a fresh z ∈ R F n in both hybrids).
Bounding in , (H y,x ) ≤ (n) · n(1, S(n)) · S(n) for all ∈ LE AK , where LE AK • SHALLOW 5, O n 5 (1, S(n)) · S(n) ⊆ LE AK E . The proof is similar to the proof that SD (H x ), H x in ≤ (n) · n(1, S(n)) · S(n), because the argument was independent of the actual inputs used in C 1 , C 2 . Bounding SD( (H y ), (H y,x )) for a leakage function . The argument here follows the same blueprint as the one used to bound SD( (H x ), (H y,x )), but is more involved because we now need to switch the input of the second copy C 2 . In particular, the wire values in this hybrid argument will no longer correspond to the values in an actual evaluation of C 2 . While the computations in C 1 will still be performed honestly, we will no longer be able to claim that reconstructing the internal wires of gadgets of C 2 (or the external wires connecting gadgets of C 2 ) does not affect the computations in C 0−check and C dec . This is because the manner in which C 0−check uses the masking inputs from C 1 , C 2 is not symmetric, and in particular, resampling the masking inputs used in C 2 (as is performed by the local reconstructors of gadgets of C 2 ) will affect the computations in C 0−check , and will necessitate reevaluating it. This, in turn, will affect the masking inputs used in C 0−check , which will affect the computations in C dec . However, we cannot simply re-evaluate C 0−check and C dec in the hybrid argument. Indeed, this would require evaluating circuits of large depth, and the leakage resilience guarantee will therefore deteriorate significantly. Instead, Ishai et al. [8] use an alternative method of locally reconstructing the needed wire values of C 0−check , C dec . Specifically, they show a low-depth reconstructor for the gadgets G of C 0−check connected to gadgets of C 2 , which generates the "correct" distribution if the input of G from C 1 , and G 's output, are well formed. In particular, this implies that the internal wires of G can be reconstructed without modifying its output. They also show a low-depth reconstructor for each decoding circuit of C dec , that generates the "correct" distribution if its inputs are well formed (again, without changing the output of these decoding circuits). Specifically, we will use the following results from [8].
Lemma 7 (Local reconstructors for C 0−check , C dec , restatement of Lemmas 3.17 and 3.18 of [47]). There exists a distribution REC over SHALLOW 2, O n 2 (1, S(n)) such that the following holds for any gadget G of C 0−check connected to a gadget of C 1 or C 2 . For every plausible pair r 1,0 , r 2,0 , c for G such that r 1,0 is well formed, when rec ← REC then rec r 1,0 , r 2,0 , c is distributed identically to the wire values of G in a real execution, conditioned on the input-output pair r 1,0 , r 2,0 , c . In particular, c and the masking inputs computed by rec are well-formed.
Moreover, for a fixed rec ∈ Supp(REC), and any fixed well-formed r 1,0 , c, there exists a function rec r 1,0 ,c,rec Dec ∈ SHALLOW (2, O( n(1, S(n)))) such that the following holds for any input r 2,0 of G . If r 1,0 , r 2,0 , c is a plausible pair for G , then rec r 1,0 ,c,rec Dec r 2,0 generates the wire values of the decoding sub-circuits of C dec , the inputs of which are the masking inputs of G which rec generated. In particular, because the masking inputs generated by rec are well-formed, the outputs of these decoding sub-circuits are 0.
The proof now follows using a hybrid argument. The hybrids are similar to the ones used to bound SD( (H x ), (H y,x )), except that we will need to regenerate the internal wires of C 0−check , C dec using the reconstructors of Lemma 7. We now define the hybrids. • Generating the wires of C 1 : encode y = y 1 , r 1 , r 1,0 , y 2 , r 2 , r 2,0 ← Enc y, 1 |C| , and honestly evaluate C 1 on y 1 with masking inputs r 1 ; • Generating the wires of C 2 : pick a random input z ∈ R F n for C 2 , and generate random encodings out ← Enc in 1, 1 |C| , z 1 ← Enc in z, 1 |C| for the output and input of C 2 . Next, pick random encodings (according to Enc in ) for the outputs of all gadgets (except the gadgets whose outputs are the inputs of the output decoder, since the outputs of these gadgets have already been fixed). Then, pick local reconstructors for all gadgets of C 2 , and use them to compute the internal wires of the gadgets. The reconstructors determine the (possibly ill-formed) masking inputs r 2 of the gadgets, which (together with r 1 ) form the standard inputs of C 0 H y,x ext,2 : this hybrid is generated similarly to H y ext , except that instead of evaluating C on an encoding of y, we use the internal encoding scheme to generate encodings of y 1 , r 1 , r 1,0 and x 2 , r 2 , r 2,0 (where y 1 , x 2 encode y, x, respectively), and use them as inputs to C 1 , C 2 , respectively; H y,x in,2 : this hybrid is generated similarly to H y in , except that instead of evaluating C on an encoding of y, we use y 1 , r 1 , r 1,0 and x 2 , r 2 , r 2,0 as inputs to C 1 , C 2 , respectively.
The indistinguishability of the hybrids now follows similarly to the proof bounding SD(H x , H y,x ), and we only sketch the difference.
Bounding SD (H y ), H y in

:
We show that SD (H y ), H y in ≤ (n) · n(1, S(n)) · S(n) for all ∈ LE AK such that LE AK • SHALLOW 7, O n 4 (1, S(n)) · S(n) ⊆ LE AK E . We define the hybrids H 0 , . . . , H M , where H i is obtained by: (1) evaluating C on (an encoding of) y, then recomputing the internal wires of the first i gadgets of C 2 using their local reconstructors; (2) re-computing the internal wires of C 0−check that are influenced by this re-computation of the first i gadgets of C 2 (i.e., gadgets of C 0−check that are connected to one of these i gadgets); and (3) (using the functions of Lemma 7) recomputing the internal wires of C dec that were influenced by re-computing C 0−check . Then H 0 = H y , H M = H y in , and we show that SD( (H m ), (H m−1 )) ≤ (n) · n(1, S(n)) for every m ∈ [M], and any ∈ LE AK . Denote the m'th gadget by G. We can fix all wires of C 1 , all wires of C 2 except the internal wires W of G (its input and output wires can be fixed), and all the internal wires of C 0−check , C dec that are influenced by W. (These consist of the internal wires-but not the output-of any gadget G of C 0−check connected to G, and the internal wires-but not the outputs-in the decoding sub-circuits of C dec that decode masking inputs of G .) We now describe a distribution F over SHALLOW 4, O n 4 (1, S(n)) · S(n) , where given the wire values of G (either the real wire values W R or the reconstructed wires W S ), f ∈ F generates the entire hybrid distribution (either H m−1 or H m , respectively), as follows. For every gadget G of C 0−check connected to G, F chooses a reconstructor rec G ← REC (see Lemma 7). The function f has all the hard-wired values of H m hard-wired into it. On input W it evaluates the rec G 's on the masking inputs of G (as reported in W) and the hard-wired values, to generate the internal wires (including the masking inputs) of G , and then uses the functions defined in Lemma 7 to reconstruct the internal wires of the decoding sub-circuits of C dec that decode the masking inputs of G . Then f ∈ SHALLOW 4, O n 4 (1, S(n)) · S(n) because by Lemma 7 the reconstructors for the G 's (the decoding sub-circuits, respectively) are computable in SHALLOW 2, O n 2 (1, S(n)) (S HALLOW (2, O( n(1, S(n)))), respectively); the reconstructors of all the (at most) O n 2 (1, S(n)) · S(n) gadgets G can be computed in parallel); and the reconstructors for all of the (at most) O n 3 (1, S(n)) · S(n) decoding sub-circuits (each G is connected to O( n(1, S(n))) decoding sub-circuits) can be computed in parallel.

Bounding
for all ∈ LE AK such that LE AK • SHALLOW 6, O n 4 (1, S(n)) · S(n) ⊆ LE AK E . The proof is by a hybrid argument in which we replace the input bundles of C 2 , and the bundles at the output of gadget of C 2 , one at a time. More specifically, we define hybrids H 0 , . . . , H M , where H i is generated from H y in , by: (1) replacing the first i bundles with random encodings of random values (except for the bundle corresponding to the output of C 2 , which is set to a random encoding of 1); (2) recomputing the internal wires of the first i gadgets of C 2 using the gadget reconstructors; (3) re-computing the internal wires of C 0−check that are influenced by this re-computation of the first i gadgets of C 2 ; and (4) (using the functions of Lemma 7) recomputing the internal wires of C dec that were influenced by re-computing C 0−check . Then H 0 = H y in and H M = H y ext , and we show that SD( (H m ), (H m−1 )) ≤ (n) for all m ∈ [M] and ∈ LE AK . We denote by G o (G i ) the gadget whose output (input) is the m'th bundle, and fix all wires in H m , H m−1 except for: the m'th bundle; the masking inputs, outputs, and internal wires of G o ; the masking inputs, and internal wires, of G i , as well as its input wire corresponding to the m'th bundle; the internal wires of all gadgets G of C 0−check connected to G o or G i ; and the internal wires of the decoding sub-circuits of C dec whose inputs are masking inputs of one of these G 's.
Let W R ← Enc in b, 1 S(n) (where b is the value encoded by the m'th bundle in H y in ), and W S ← Enc in r, 1 S(n) for a random r (except if m corresponds to the output bundle, in which case W S ← Enc in 1, 1 S(n) ). We define a distribution F over SHALLOW 6, O n 4 (1, S(n)) · S(n) as follows. Sampling a function f ← F is performed by sampling rec o , rec i from the distribution over reconstructors for G o , G i , respectively (see Definition 14), and sampling reconstructors rec G for the gadgets of C 0−check connected to G o or G i . The function f has all the hard-wired values of H m−1 hardwired into it. On input e ∈ F n(1,Sn) , f : (1) evaluates rec o on the (hard-wired) inputs of G o , and the output e (this reconstructs the masking inputs, and internal wires, of G o ); (2) evaluates rec i on e as one of the inputs, and the other (hard-wired) input and output of G i ; (3) for every gadget G of C 0−check connected to G o or G i , uses rec G to generate its internal wires; and finally (4) uses the functions of Lemma 7 to generate the internal wires of the decoding sub-circuits that decode the masking inputs used in the G 's. Then f ∈ SHALLOW 6, O n 4 (1, S(n)) · S(n) because the reconstructors rec o , rec i ∈ SHALLOW 2, O n 2 (1, S(n)) (by Lemma 4) and can be evaluated in parallel, the O n 2 (1, S(n)) · S(n) reconstructors rec G ∈ SHALLOW 2, O n 2 (1, S(n)) (by Lemma 7), and can be evaluated in parallel, and the O n 3 (1, S(n)) · S(n) reconstructors of the decoding sub-circuits are each computable in SHALLOW (2, O( n(1, S(n)))) (by Lemma 7) and can be evaluated in parallel.
Consequently, if W R := f (W R ), W S := f (W S ) for f ← F , then W R ≡ H m−1 , W S ≡ H m and by Lemma 6, W R , W S are (LE AK , (n))-leakage resilient for any LE AK such that LE AK • SHALLOW 6, O n 4 (1, S(n)) · S(n) ⊆ LE AK E . in,2 , (H y,x ) ≤ (n) · n(1, S(n)) · S(n) for all ∈ LE AK such that LE AK • SHALLOW 7, O n 4 (1, S(n)) · S(n) ⊆ LE AK E . The proof is similar to the proof that SD (H y ), H y in ≤ (n) · n(1, S(n)) · S(n), because the argument was independent of the actual inputs used in C 1 , C 2 . Bounding SD( (H x ), (H y )) for ∈ LE AK . From this analysis, we can now conclude using the union bound that for every ∈ LE AK such that LE AK • SHALLOW 7, O n 5 (1, S(n)) · S(n) ⊆ LE AK E it holds that SD( (H x ), (H y )) ≤ 4 (n) · S(n) · ( n(1, S(n)) + 1).

An SAT-Respecting LRCC Against "Useful" Leakage
Ishai et al. [8] use Construction 11 to devise an SAT-respecting LRCC which they later employ in their WI-PCP construction (described in Section 4.4). This is performed in two steps. First, since the LRCC will be used to compile verification circuits of NP relations, we need the compiler to be Boolean. Second, we need to instantiate the internal encoding scheme E such that it would resist leakage computable by functions that: (1) apply the PCP-prover algorithm, and then (2) restrict the output to a small subset of bits. Indeed, this is exactly the "leakage" on the witness which a query-bounded verifier (even a malicious one) obtains by querying the proof. We now provide more details on each of these steps.
Step (1): An SAT-Respecting LRCC for Boolean Circuits. The high-level idea is to transform the Boolean circuit C : {0, 1} n → {0, 1} into a functionally-equivalent arithmetic circuit C 3 over F 3 (i.e., the field with 3 elements), use Construction 11 over the field F 3 to compile C 3 into its leakage-resilient version C 3 , and then output the Boolean circuit C that emulates C 3 using Boolean operations. This is an over-simplified description of the compiler, where the actual construction needs to address several subtleties. We now describe each of these steps, and the subtleties that arise, in more detail.
From Boolean to Arithmetic Operations. The circuit C 3 is obtained from C by representing each Boolean operation using an appropriate polynomial over F 3 in the natural way. While C 3 is guaranteed to be functionally equivalent to C on binary strings, two issues arise concerning the SAT-respecting property. First, satisfiability over F 2 means that C(x) = 1 for some x, whereas satisfiability over F 3 means C 3 (y) = 0 for some y. In particular, we want the leakage-resilient circuit to output 1 only if there exists an x such that C(x) outputs 1, whereas the SAT-respecting property guarantees only that if C 3 ( y) = 0 for some y, then C 3 (y) = 0 for some y. Therefore, we need to "translate" a 1-output of C into a 0-output of C 3 , and a 0-output of C into a non-0-output of C 3 . Thus, we will have that C 3 = ( y) = 0 for some y only if C 3 (y) = 0 for some y. This brings us to the second issue: while we would like to use the function-equivalence of C and C 3 to claim that if C 3 (y) = 0 for some y ∈ F n 3 then C(x) = 1 for some x ∈ F n 2 , this is not necessarily the case, because C 3 's inputs are from F n 3 and might not correspond to an input in F n 2 . To overcome this issue, we add to C 3 an "input checker" component which checks that each of its n inputs is a bit. We denote this "enhanced" version of C 3 -which flips the output and checks validity of the inputs-by C 3 . From Arithmetic Back To Boolean. Once we generate the leakage-resilient version C 3 of C 3 , we need to represent it using a Boolean circuit. (Indeed, the original circuit C was Boolean, and its leakage-resilient version should also be a Boolean circuit.) We do so by replacing each field element with a binary string representing it, and implementing each gate over F 3 by a Boolean sub-circuit. We also flip the output of C 3 , so the resultant circuit would again be functionally-equivalent to C. There are two important points that we need to handle. First, while we can represent field elements using any (injective) encoding scheme, to preserve the SAT-respecting property it must also be onto. Otherwise, the Boolean circuit could potentially be satisfied using invalid encodings, namely ones that do not encode any field element, and thus the computation in the Boolean circuit would not correspond to a computation in C 3 . In particular, the Boolean sub-circuits implementing gates over F 3 must be defined for all possible encodings-even ones that would not be used in an honest evaluation of the circuit.
Second, these Boolean sub-circuits should have small depth and size. The reason is the reduction from the leakage resilience of the final circuit C to the leakage resilience of C 3 . More specifically, the reduction proceeds by assuming that a leakage function in some class LE AK can distinguish between the wire values C, x of C on an encoding x of some input x, and its wire values C, x on the encoding x of some other input x such that C(x) = C(x ). It then uses this to break the leakage resilience of C 3 for some leakage function 3 in the leakage class LE AK 3 against which the arithmetic LRCC is secure. This is performed as follows: given the wire values of C 3 on some input (these values are elements of F 3 ), the reduction first replaces the field elements with the corresponding encodings. The resultant values constitute only part of the wire values of C. Specifically, these are the values of the wires between the sub-circuits emulating the gates over F 3 , whereas C contains also the internal wires of these sub-circuits, namely wires which do not appear in C 3 . Thus, the leakage function 3 must first generate these missing wires, and only then can it evaluate . In particular, LE AK ⊂ LE AK 3 , where the difference between the two classes depends on the complexity of the Boolean sub-circuits implementing gates over F 3 . Fortunately, these sub-circuits are both shallow and small.
Step (2): Leakage Resilience Against "Useful" Leakage. The second component of the construction is an internal encoding scheme E in -resisting leakage from a "useful" class of leakage functions-with which we instantiate Claim 13. More specifically, the leakage class consists of AC 0 circuits (namely, constant-depth, polynomial-sized Boolean circuits over unbounded fan-in and fan-out ∧, ∨, ¬ gates), augmented with a sublinear number of ⊕ gates of unbounded fan-in and fan-out. Formally, Notation 10 (L m n,d,s,⊕t leakage family). Let n, d, s ∈ N be length, depth and size parameters (respectively), and let t ∈ N be a parity gate bound. The family L n,d,s,⊕t consists of all functions computable by a Boolean circuit C : {0, 1} n → {0, 1} of size at most s and depth d, with unbounded fan-in and fan-out ∧, ∨, ¬, ⊕ gates, out of which at most t are ⊕ gates. We denote L d,s,⊕t = ∪ n∈N L n,d,s,⊕t . The encodings scheme we use encodes elements γ ∈ F 3 as binary strings whose sum mod 3 is γ. Formally: Notation 11. For γ ∈ {0, 1, 2} and n ∈ N, U n γ denotes the uniform distribution over v ∈ {0, 1} 3n : # 1 (v) ≡ γ mod 3 , where # 1 (v) denotes the number of 1's in v.
Ishai et al. [8] show that the encoding scheme of Definition 16 resists leakage from AC 0 circuits augmented with few ⊕ gates: Corollary 3 (Corollary 3.44 in [47]). For every constant depth parameter d ∈ N there exist constants c, ∈ (0, 1), such that for every constant l ∈ N there exists a minimal length parameter n 0 ∈ N such that for every n ≥ n 0 the encoding scheme Enc 3 (·, 1 n ) of Definition 16 is L 3n,d,n l ,⊕n , 2 −n c -leakage resilient.
Instantiating Claim 13 with the encoding scheme of Definition 16 as the internal encoding scheme, and using Corollary 3, ref. [8] show the existence of a Boolean LRCC resisting leakage from AC 0 circuits with few ⊕ gates: Theorem 15 (Boolean SAT-respecting LRCC for AC 0 circuits with ⊕ gates, Theorem 3.37 in [47]). Let n ∈ N be an input length parameter. For every positive constant d, c, polynomials m = m(n), t = (n), and polynomial size bound s = s(n), there exists a polynomial l(n), such that the following holds. There exists an SAT-respecting L m l,d,l c ,⊕t , 2 −n c , s(n) -LRCC over {0, 1}, which on input a circuit C : {0, 1} n → {0, 1} of size |C| ≤ s(n) outputs a circuit C of size C ≤ l(n).

The Witness-Indistinguishable PCP
In this section, we describe the WI-PCPs for NP of [8], which rely on the Boolean SAT-respecting LRCC of Theorem 15. They use also a PCP system (P , V ) for the language 3SAT of all satisfiable 3CNF formulas, in which the prover algorithm can be implemented in a low complexity class.
The high-level idea of the construction for an NP-relation R with verification circuit C is that given input x, instead of verifying that C x (·) := C(x, ·) is satisfiable (which holds if and only if x ∈ L for the corresponding NP-language L), the verifier will check that the leakage-resilient version C x is satisfiable. For this, the prover and verifier will first represent C x as a 3CNF formula ϕ in the natural way. That is, ϕ will have a variable for each wire of C x . It will contain, for each gate g of C x , a sub-formula verifying that the output wire of g is consistent with the input wires and the operation of g, and it will also check that the output wire of C x is 1. A satisfying assignment for ϕ is the wire values of C x when evaluated on (an encoding of) a witness w for x. Then, the prover and verifier will use the PCP system (P , V ) to verify that ϕ ∈ 3SAT. The construction is described in Figure 3.

Construction 16 (A Witness-Indistinguishable PCP)
. Let R = R(x, w) be an NP-relation with verification circuit C. (We note that R is actually associated with a family {C n } of circuits, where C n is applied to inputs x ∈ {0, 1} n . Somewhat abusing notation, we refer to all these circuits simply as "C".) Building blocks: • A PCP system (P , V ) for 3SAT; • A Boolean LRCC (Comp, E = (Enc, Dec)).
Prover algorithm. P, on input (x, w) ∈ R, operates as follows: • Computes C x (·) = Comp(C x ), where C x denotes the circuit C with x hard-wired into it.; • Samples a random encoding w ← Enc w, 1 |C x | , and evaluates C x on w to generate the wire values W of C x ; • Constructs the 3CNF ϕ x representing C x ; • Computes a PCP π = P (ϕ x , W ) for the claim "ϕ x ∈ 3SAT", and outputs π.
Verifier algorithm. V is given input x and oracle access to π. It computes C x (·) = Comp(C x ), and constructs the 3CNF formula ϕ x . Then, V emulates V with input ϕ x and oracle access to π, and outputs whatever V outputs. The following theorem (which is a combination of ( [47], Proposition 4.4) and ( [47], Corollary 4.10)) asserts the connection between the properties of the LRCC and the resultant PCP system (P, V ). Theorem 17. Let n ∈ N be a length parameter, q * = q * (n), S = S(n) be query and size functions, , ∈ [0, 1], and LE AK be a family of leakage functions. Assume that Construction 16 is instantiated with: • A Boolean SAT-respecting (LE AK, , S)-LRCC such that there exists a polynomial g(·) for which |Comp(C)| ≤ g(|C|) for every circuit C; and • A PCP system (P , V ) for 3SAT with proofs of length len(n), such that for every (ϕ, W ) ∈ 3SAT, every subset Q of q * bits of an honestly-generated proof π = π(ϕ, W ) is computable from W by a function f ϕ,Q ∈ LE AK. Then for every NP-relation R with verification circuit C of size |C| ≤ S, the PCP system (P, V ) is a (q * , * )-WI-PCP for R, where * = O · q * · len 2q * (t) + e −Ω q * ·len q * (t) and t = O(g(|C|)). Moreover, if V is non-adaptive, the so is V. Furthermore, the system is (q * , )-WI against non-adaptive (possibly malicious) verifiers. Moreover, proofs generated by P have length len(t), and if V has query complexity q(n) and tosses r(n) coins, then V has query complexity q(t), tosses r(t) coins.
Proof. We first analyze the parameters of the system. The wire assignment W to C x has size |W | = C x ≤ g(|C x |) ≤ g(|C|), and |ϕ x | = O C x ≤ O(g(|C|)). Therefore, the internal PCP system (P , V ) is emulated using inputs of size t = g(|C|).
Completeness follows directly from the completeness of the building blocks. Soundness follows from a combination of the soundness of (P , V ) and the SATrespecting property of (Comp, E), Indeed, if x / ∈ L, then C x is not satisfiable, and so (by the SAT-respecting property) C x is not satisfiable, i.e., ϕ x / ∈ 3SAT. Therefore, by the soundness of (P , V ) we have that Pr V π * (x) = 1 = Pr V π * (ϕ x ) = 1 is negligible.
Witness-indistinguishability. Let x ∈ L, ϕ x be the 3CNF formula representing C x , and w 1 , w 2 be two witnesses for x. We first show witness indistinguishability against non-adaptive verifiers. Let V * be a non-adaptive q * -query-bounded verifier, and let π i ← P (x, w i ) for i = 1, 2. Since V * 's entire view can be generated from the oracle answers to its queries (and this cannot increase the statistical distance), it suffices to show that SD(π 1 | Q , π 2 | Q ) ≤ for every set Q of queries of V * such that size |Q| ≤ q * , where π i | Q denotes the restriction of π i to the entries in Q. Since |C| = |C x | ≤ S, the leakage resilience of the LRCC guarantees that SD C x , w 1 , C x , w 2 ≤ for every ∈ LE AK. We conclude the proof by noting that f ϕ x ,Q ∈ LE AK, and π i | Q = f ϕ x ,Q C x , w i . We have shown that (P, V ) is (q * , )-witness indistinguishable against non-adaptive verifiers V * . Using Theorem 18 below, this implies that (P, V ) is (q * , * )-WI (even against adaptive verifiers), for * = O · q * · len 2q * (t) + e −Ω q * ·len q * (t) .
The proof of Theorem 17 used the following theorem, which is implicit in [48] (see also [47], Theorem 4.11).
Theorem 18 (Implicit in [48]). Let (P, V ) be a PCP system that is (q * , )-WI against nonadaptive verifiers, with proofs of length len. Then (P, V ) is (q * , * )-WI against adaptive verifiers, where * = O · q * · len 2q * + e −Ω q * ·len q * . Theorem 7 now follows as a corollary of Theorem 17, using the SAT-respecting LRCC of Theorem 15, and a PCP system of [2], whose prover algorithm can be implemented in a low complexity class (the analysis of the prover complexity is due to ([47], Appendix B)): Theorem 19 (PCPs for NP, [2]). 3SAT has a PCP system (P, V ) with soundness error 1/2 with an honest verifier that queries O log 2 n proof bits. The proofs have length poly(n), where every proof bit can be generated by an AC 0 circuit with a single ⊕ gate of unbounded fan-in.
We are now ready to prove Theorem 7.
Proof of Theorem 7. We instantiate Construction 16 with the PCP system (P , V ) of Theorem 19 and the LRCC of Theorem 15. By Theorem 19, there exist constants d, c ∈ N such that every bit in a proof generated by P is computable from the NP-witness in L d,n c ,⊕1 , where n is the witness length, and the proofs have length n c , for some constant c .
Let R be an NP-relation with verification circuit C, then |C| = n c for some constant c . We instantiate Theorem 15 with parameters d * = d, s * = |C|, n * = n, t * = 1, m * = q * , and c * ≥ c which is a sufficiently large constant whose value is set below. Here, the superscript * is used to denote the parameters of Theorem 15, and s * , t * , m * are in poly(n). Let (Comp, E) denote the LRCC obtained from Theorem 15. We compute C = Comp(C), where C ≤ l(n) which, because |C| ≤ s * , is L q * d,l c (n),⊕1 , 2 −n c * -LR (where l(n) is the polynomial whose existence is guaranteed by Theorem 15).
Let ϕ denote the 3CNF representing C. Then by Theorem 19 (and using the fact that |W | = C ≤ l(n)), every bit of a proof generated by P for ϕ can be generated from a wire assignment W of C in L d,l c (n),⊕1 , so every q * proof bits are computable from W in L q * d,l c (n),⊕1 . Therefore, Theorem 17 guarantees that the system (P, V ) of Construction 16 is a nonadaptive WI-PCP system for R, with q * , O 2 −n c * · q * · len 2q * (l(n)) + e −Ω q * ·len q * (l(n)) -WI (where len(l(n)) denotes the proof length), and soundness error 1/2 with an honest verifier that queries O log 2 (l(n)) = polylog(n) ≤ polylog(q * ) proof bits. We set c * to be sufficiently large, such that the statistical LR error satisfies O 2 −n c * · q * · len 2q * (l(n)) + e −Ω q * ·len q * (l(n)) = negl(q * ) ≤ negl(κ).
(We note that such a constant exists since we assume that q * = poly(n).) We conclude the proof by noting that soundness can be amplified to negl(κ) with only a poly(κ) blowup in the query complexity of the honest verifier.

Discussion
The works of [8,13] show a connection between ZK-PCPs and the seemingly-unrelated field of leakage-resilient cryptography, and use it to circumvent an inherent limitation of previous constructions-that the honest verifier is adaptive. Specifically, using tools from the leakage-resilience literature, [8,13] put forth two new paradigms of constructing ZK-PCPs, yielding PCPs with ZK against malicious verifiers, in which the honest verifier is non-adaptive. In the context of cryptographic applications of ZK-PCPs, non-adaptive verification translates into fewer communication rounds. The paradigm of [13] also extends to ZK-PCPs of proximity.
Despite this recent progress, several interesting questions remain open. The obvious open problem is to obtain ZK-PCPs and ZK-PCPPs with an exponential query gap as in [6,11] but which can be verified non-adaptively. One possible approach is to design a ZK-PCP variant over a large alphabet with negligible soundness error and an honest verifier that makes fewer queries than [15] (hopefully, polylogarithmic). Another interesting research direction is to extend the techniques of [8,13] to other related proof systems, such as interactive oracle proofs. Finding further applications of ZK-PCPs and ZK-PCPPs is also an interesting question. Finally, though in this survey we have focused on other parameters of ZK-PCPs, reducing the proof length is a fascinating open problem worthy of study. Whereas the locking-scheme-based ZK-PCPs of [6,11] inherently incur a polynomial blowup in proof length, another advantage of the leakage-resilience-based approach is that it opens up the possibility of reducing the proof length of ZK-PCPs, potentially even matching the proof length of non-ZK PCPs.