Interactive Verifiable Polynomial Evaluation

TL;DR

This paper introduces a highly efficient, interactive, and information-theoretically sound verifiable polynomial evaluation protocol suitable for cloud computing, with low user and server complexity and logarithmic rounds.

Contribution

It presents a novel doubly-efficient, information-theoretic verifiable polynomial evaluation algorithm that outperforms existing methods in efficiency and security.

Findings

Achieves user complexity of O(d^{psilon})

Requires O(psilon) rounds of interaction

Provides information-theoretic soundness against unbounded adversaries

Abstract

Cloud computing platforms have created the possibility for computationally limited users to delegate demanding tasks to strong but untrusted servers. Verifiable computing algorithms help build trust in such interactions by enabling the server to provide a proof of correctness of his results which the user can check very efficiently. In this paper, we present a doubly-efficient interactive algorithm for verifiable polynomial evaluation. Unlike the mainstream literature on verifiable computing, the soundness of our algorithm is information-theoretic and cannot be broken by a computationally unbounded server. By relying on basic properties of error correcting codes, our algorithm enforces a dishonest server to provide false results to problems which become progressively easier to verify. After roughly $\log d$ rounds, the user can verify the response of the server against a look-up table that has been pre-computed during an initialization phase. For a polynomial of degree $d$, we achieve a user complexity of $O(d^{\epsilon})$, a server complexity of $O(d^{1+\epsilon})$, a round complexity of $O(\log d)$ and an initialization complexity of $O(d^{1+\epsilon})$.

Equations

$$Z_i(\beta )=\prod _{j\in [0:\eta -1]\backslash \{i\}}\frac{\beta -{\alpha }_j}{{\alpha }_i-{\alpha }_j}.$$

$$g^{(b_1,\cdots ,b_{\ell -1})}(\alpha ,x)$$

$$+$$

$$f^{(b_1,\cdots ,b_{\ell })}(x)$$

$$\sum _{b_{\ell }\in [0:\eta -1]}{x}^{b_{\ell }}{f}^{(b_1,\cdots ,b_{\ell })}(x^{\eta })=f^{(b_1,\cdots ,b_{\ell -1})}(x).$$

$$h(b_1,\cdots ,b_r)=f^{(b_1,\cdots ,b_r)}(x),\forall (b_1,\cdots ,b_{\ell })\in [0:c\eta -1{]}^{\ell }.$$

$$\lambda =(c\cdot \eta {)}^r=c^r\cdot d.$$

$$a_i^{(b_1,\cdots ,b_{\ell })}=\sum _{j\in [0:\eta -1]}{a}_{j+i\eta }^{(b_1,\cdots ,b_{\ell -1})}{Z}_j({\alpha }_{b_{\ell }}),\forall i\in [0:\frac{d}{{\eta }^{\ell }}-1],(b_1,\cdots ,b_{\ell })\in [0:c\eta -1{]}^{\ell },$$

$$h(b_1,\cdots ,b_r)=a_0^{(b_1,\cdots ,b_r)}.$$

$$\sum _{s\in [0:\eta -1]}{x}^s{\hat{f}}^{(s)}(x^{(1)})=\hat{f}(x).$$

$$\sum _{s\in [0:\eta -1]}{x}^{\eta s}{\hat{f}}^{(b_1,s)}(x^{(2)})={\hat{f}}^{(b_1)}(x^{(1)}).$$

$$p\le \frac{1}{c}+\frac{c-1}{c}\cdot \frac{1}{c}+(\frac{c-1}{c}{)}^2\cdot \frac{1}{c}+\cdots +\cdot (\frac{c-1}{c}{)}^{r-1}\cdot \frac{1}{c}=1-(1-\frac{1}{c}{)}^r.$$

$$p^m=(1-\frac{1}{m}{)}^m<\frac{1}{e}<\frac{1}{2}.$$

$${\mathcal{C}}_{ini}=O(c^{\frac{\log d}{\log \eta }}\cdot d\cdot \eta ).$$

$${\mathcal{C}}_{ver}=O(m\cdot r\cdot \eta )=O(\eta \cdot (\frac{c}{c-1}{)}^{\frac{\log d}{\log \eta }}\cdot \frac{\log d}{\log \eta }).$$

$${\mathcal{C}}_{pro}=O(m\cdot d)=O(d\cdot (\frac{c}{c-1}{)}^{\frac{\log d}{\log \eta }}).$$

$${\mathcal{C}}_{rnd}=\frac{\log d}{\log \eta }.$$

$${\mathcal{C}}_{ini}=c^r\cdot \eta \cdot d$$

$${\mathcal{C}}_{ver}=O(\eta \cdot (\frac{c}{c-1}{)}^{\frac{\log d}{\log \eta }}\cdot \frac{\log d}{\log \eta })=O(d^{\frac{b}{\log \log d}}\cdot \frac{(\log d{)}^{\omega +1}}{\omega \log \log d})=O(d^{\frac{b}{\log \log d}}),$$

$${\mathcal{C}}_{pro}=O(d\cdot (\frac{c}{c-1}{)}^{\frac{\log d}{\log \eta }})=O(d^{1+\frac{b}{\log \log d}}),$$

$${\mathcal{C}}_{rnd}=\frac{\log d}{\log \eta }=O(\log d).$$

$$f(x_1,\cdots ,x_n)=\sum _{i_1\in [0:d-1]}\cdots \sum _{i_n\in [0:d-1]}{a}_{i_1,\cdots ,i_n}\prod _{j\in [1:n]}{x}_j^{i_j}.$$

$${\mathcal{C}}_{ver,n}=O(d^{\frac{bn}{\log n+\log \log d}})$$

$${\mathcal{C}}_{pro,n}=O(d^{1+\frac{bn}{\log n+\log \log d}})$$

$$g(x)=\sum _{i_1\in [0:d-1]}\cdots \sum _{i_n\in [0:d-1]}{a}_{i_1,\cdots ,i_n}{x}^{i_1+i_{2}d+\cdots +i_n{d}^{n-1}}=f(x,x^d,\cdots ,x^{d^{n-1}}).$$

Full text

1 Introduction

The recent rise in cloud computing platforms has created an increasing demand for verifiable computing protocols. A commercial server that sells its computation power to the users, is incentivized to return false results, if by doing so it can reduce its computation overhead and oversell its services. Therefore, a user who delegates a computationally demanding task to a server must be able to verify that the results are indeed correct. Verifiable computing algorithms require the server to send a “proof” to the user along with the results of computation [14]. By investigating this proof, a user is convinced with high probability that the server is honest. Clearly, a practical verifiable computing algorithm must be “doubly-efficient” [16]: it must have a super-efficient verifier (user) and an efficient prover (server). Put differently, if the complexity of computing the original function is $\chi$, the prover’s complexity must be comparable to $\chi$, and the verifier’s complexity must be substantially smaller than $\chi$.

The study of verifiable computing has led to novel cryptographic algorithms which are either applicable to arbitrary functions [15, 25] or tailored to computation of a specific function [13, 9]. The former has led to the development of Quadratic Arithmetic Programs and zkSNARKs for arithmetic circuits, while the latter has resulted in highly efficient and easy-to-implement algorithms that can be applied to, say, polynomial evaluation or matrix multiplication. Despite their enormous success, the security of cryptographic algorithms depends on hardness assumptions about certain mathematical problems. Algorithmic breakthroughs or technological advancements may falsify these assumptions at any time. This creates a demand for verifiable computing algorithms which remain secure in the face of computationally unbounded provers.

Our objective in this work is to design an information-theoretic algorithm for verifiable polynomial evaluation. Information-theoretic in this context means that the soundness of the algorithm is fundamental, and does not rely on hardness assumptions. An example of how such an algorithm can be applied in practice is blockchain networks where the capacity to verify a newly mined block against the history of the transactions is the distinguishing factor between a light node and a full node. This block verification process can generally be modelled as an instance of polynomial evaluation [20]. The full nodes can thus convince the light nodes of the correctness of a block via a verifiable polynomial evaluation algorithm.

Our setup is very similar to the classical notion of interactive proof systems, with one subtle difference: we allow for a one-time initialization or pre-processing phase during which the verifier may perform a computationally heavy task. This is acceptable because in the verifiable computing literature, it is generally assumed [14, 9, 13] that after this initialization phase, the verifier and the prover will engage in evaluating the function at many inputs. Therefore, this initialization cost amortizes over many rounds and can be neglected.

1.1 Setting and Objective.

Consider a polynomial of degree $d-1$, $f(x)=a_{0}+a_{1}x+\cdots+a_{d-1}x^{d-1}$. A verifier wishes to evaluate this polynomial at $x\in\{x_{1},x_{2},\cdots\}$ with the help of a prover. Similar to [16], we require the algorithm to be doubly-efficient with a small round complexity. On the other hand, we deviate from the classical notion of proof systems and allow the verifier to perform a one-time computationally heavy task. We impose the following performance criteria on the algorithm.

• •

Efficient initialization: the verifier is allowed to perform a one-time initialization phase and store the outcome for future reference. Although this phase is run only once, its complexity should be comparable to the complexity of computing $f(x)$.

• •

Super-Efficient verifier: for each $x\in\{x_{1},x_{2},\cdots\}$, the complexity of the verifier should be negligible compared to the complexity of computing $f(x)$.

• •

Efficient prover: for each $x\in\{x_{1},x_{2},\cdots\}$, the complexity of the prover should be comparable to the complexity of computing $f(x)$.

• •

Small round complexity: the number of rounds of interaction between the prover and the verifier must be polylogarithmic in $d$.

• •

Completeness: if the prover is honest, the verifier should accept his results with probability $1$.

• •

(Information-theoretic) soundness: If the prover is dishonest, the verifier should be able to reject his results with probability at least $\frac{1}{2}$.

1.2 Related Work.

An interactive proof (IP) system [17, 4] is an interactive protocol that enables a prover to convince a computationally-limited verifier of the correctness of a statement. It is well-known that IPs are very strong tools: any problem in PSPACE admits an interactive proof with polynomial complexity for the verifier [23, 31]. Nevertheless, the recent rise in cloud computing platforms has led to several intriguing questions surrounding the practicality of such algorithms. In particular, the provers in [23, 31] run in exponential time, making them unfit for real-world commercial servers. The concept of doubly-efficient interactive proofs was first introduced in [16] followed by [28, 27]. In this context, “doubly-efficient” means that the prover must run in polynomial time and the verifier must be “super-efficient”, i.e., his complexity must be close to linear in the size of the problem. Unfortunately, in many practical scenarios, even linear complexity is unacceptable for the verifier. Concrete examples of this are when the problem itself can be solved in linear time, however, due to the sheer size of the problem the verifier is incapable of performing the computation alone. In such cases, a high-degree polynomial-time prover is clearly impractical too.

A closely related line of work is Probabilistically Checkable Proofs (PCP) [6, 7, 3, 8, 26], where the prover is required to commit to a proof which is usually too long for the verifier to process. The verifier can then sample this proof randomly in a few locations and be convinced of the correctness of the proof with high probability. The celebrated PCP theorem [1, 2] states that any problem in NP admits a PCP with verifier complexity that is polylogarithmic in the size of the problem. However, from a practical perspective, it is not clear how this initial commitment can be implemented. One possibility is to rely on Merkle commitments with the help of collision-resistant hash functions and assume that the prover is computationally limited. Alternatively, the prover can send the entire proof to a trusted third-party which will be the point of contact for the verifier. However, these approaches alter the setup, and more importantly make strong assumptions such as the existence of trusted third parties or computational limitation of the prover. Other PCP-based proof systems that are secure against computationally limited provers include [19] and [24].

The notion of verifiable computing was introduced in [14]. Motivated by practical considerations, in a verifiable computing setting one assumes that a computationally limited verifier (user) delegates a task to a prover (server). The prover must then cooperate with the verifier in computation of the function in such a way that the verifier remains efficient and convinced of the validity of the results. There are subtle differences between this model and the classical notion of proof systems. In particular, it is usually assumed that the verifier may run a one-time initialization phase that is computationally expensive. The cost of this computation is amortized over many runs of the algorithms, corresponding to the evaluation of the same function over many different inputs. In Gennaro’s framework [14], the function to be computed is characterized by its boolean circuit which is evaluated with the help of Yao’s garbled circuits [32, 21] and Fully Homomorphic Encryption. In a subsequent work [15, 25] which led to the development of several zkSNARKs (zero-knowledge non-interactive arguments of knowledge) [18, 22, 10, 30], it was suggested to represent arbitrary arithmetic and logical circuits as Quadratic Arithmetic Programs and Quadratic Span Programs which are then evaluated at encrypted values to produce proofs of correctness. These algorithms can be proven secure against provers who are not powerful enough to reverse such encryptions.

Recently, a new line of work in the cryptography community has focused on the verifiable evaluation of specific functions such as high-degree polynomials or multiplication of large matrices. These functions serve as building blocks for many applications such as machine learning and blockchain. Advances in this area has led to extremely efficient algorithms for verifiable polynomial evaluation [9, 13, 5, 12], matrix multiplication [33, 13], and modular exponentiation [11]. Unfortunately, similar to the generic verifiable computing algorithms discussed above, these algorithms rely on unproven cryptographic assumptions. To overcome this limitations, recent efforts have focused on information-theoretic verifiable polynomial evaluation algorithms which are secure against unbounded adversarial provers [29]. Nevertheless, to achieve information-theoretic security, [29] pays a significant cost in terms of the complexity of the verifier. While the cryptographic approaches lead to logarithmic or even constant verification time, the verifier in [29] runs in $O(\sqrt{d})$.

1.3 Main Results.

we design an information-theoretic verifiable polynomial evaluation algorithm which is super-efficient for the verifier and efficient for the prover. Even though our algorithm is interactive, the number of interactions only grows logarithmically as a function of the degree of the polynomial. Similar to other verifiable computing algorithms, in our setting the verifier performs a one-time initialization phase whose complexity is comparable to the complexity of evaluating the polynomial once.

Theorem 1.1

There exists a public-coin verifiable polynomial evaluation algorithm with initialization complexity of $O(d^{1+\epsilon})$, verifier complexity of $O(d^{\epsilon})$, prover complexity of $O(d^{1+\epsilon})$, and round complexity of $O(\log d)$ which satisfies the completeness and soundness properties as defined in Section 1.1.

1.4 An Overview of the Algorithm.

Similar in nature to many other interactive proof systems [23, 6, 8], the core idea behind our algorithm is to enforce a dishonest prover to provide false results on problems that become progressively easier to verify throughout the interactions. To be more specific, let us look at a simple example where the polynomial $f(x)=a_{0}+a_{1}x+\cdots+a_{d-1}x^{d-1}$ is to be evaluated where $d$ is even. Suppose the prover provides a false answer $\hat{f}(x)\neq f(x)$. The protocol then requires the prover to provide his evaluation of two more functions, namely $f^{(0)}(y)=a_{0}+a_{2}y+a_{4}y^{2}+\cdots+a_{d-2}y^{\frac{d}{2}-1}$ and $f^{(1)}(y)=a_{1}+a_{3}y+a_{5}y^{2}+\cdots+a_{d-1}y^{\frac{d}{2}-1}$, both evaluated at $y=x^{2}$. Obviously, we must have $f^{(0)}(y)+xf^{(1)}(y)=f(x)$, which can be easily checked by the verifier. Since $\hat{f}(x)\neq f(x)$, the prover must either provide $\hat{f}^{(0)}(y)\neq{f}^{(0)}(y)$ or $\hat{f}^{(1)}(y)\neq{f}^{(1)}(y)$ in order to pass the verification $\hat{f}^{(0)}(y)+x\hat{f}^{(1)}(y)=\hat{f}(x)$. Voilà, the prover has been forced to lie again. Note also that the degree of $f^{(0)}$ and $f^{(1)}$ is only $d/2$. The verifier cloud then climb down the branches of this binary tree, and after $\log d$ rounds, verify the correctness of all the constant polynomials corresponding to the leaves of the tree. But this would take him $O(d)$ to accomplish. Instead, he computes a random linear combination $\alpha\hat{f}^{(0)}(y)+\beta\hat{f}^{(1)}(y)$ and uses this as the reference point for the next iteration. Provided that these random coefficients are selected over sufficiently large sets, we will have $\alpha\hat{f}^{(0)}(y)+\beta\hat{f}^{(1)}(y)\neq\alpha{f}^{(0)}(y)+\beta{f}^{(1)}(y)$ with high probability and the error will propagate to the next iteration of the algorithm. After $\log d$ iterations, the verifier is left with a constant polynomial that he needs to verify. We note that this algorithm is inspired by the Probabilistically Checkable Proof of Proximity recently proposed in [6] (despite this, our algorithm is clearly not a PCP but an IP).

As it turns out, the fact that the degree of the polynomial decreases by a factor of $2$ at each iteration does not immediately translate to an easier verification. Unfortunately, each coefficient of the newly constructed polynomial is now a linear combination of two coefficients in the original polynomial. Therefore, evaluating the new polynomial from scratch still takes $O(d)$. In particular, after ${\log d}$ iterations, we are left with a constant which is a (random) linear combination of all the $d$ coefficients of the original polynomial. To help the verifier ensure the validity of this linear combination, we allow for an initialization phase, whereby the verifier computes all the possible outcomes of the algorithm and stores them in a look-up table in his memory. For this to be feasible, we need the random coefficients to be selected from a set that is not too large. By properly choosing the size of this set, we guarantee that the look-up table is of size $O(d^{1+\epsilon})$ and that it can be computed in time $O(d^{1+\epsilon})$. The verifier can then check the validity of the constant polynomial at the end of ${\log d}$ iterations by comparing the returned result to the corresponding entry in the look-up table.

2 Interactive Verifiable Polynomial Evaluation

In this section we describe an interactive algorithm for verifiable evaluation of a function $f(x)=a_{0}+a_{1}x+\cdots+a_{d-1}x^{d-1}$ over members of a finite field $\mathbb{F}$. The coefficients $a_{0},\cdots,a_{d-1}$ are arbitrary members of $\mathbb{F}$.

2.1 Preliminaries.

Let $\eta>1$ be an integer and let $c>1,c\in\mathbb{R}$ be such that $c\eta\in\mathbb{Z}$. These two are design parameters that can depend on $d$ in general. Throughout this section, we will assume that $c$ is a constant, and that $\eta$ grows at most polylogarithmically with $d$. Let $L\subseteq\mathbb{F}$ be a set of size $c\eta$ and let $H\subset L$ be of size $\eta$. Let us represent the members of $L$ as $L=\{\alpha_{0},\cdots,\alpha_{c\eta-1}\}$. Without loss of generality, we can assume $H=\{\alpha_{0},\cdots,\alpha_{\eta-1}\}$. The sets $L$ and $H$ are publicly known. For $i\in[0:\eta-1]$ define

[TABLE]

Note that for $i\in[0:\eta-1]$ and $k\in[0:\eta-1]$ we have $Z_{i}(\alpha_{k})=1$ if $i=k$ and [math] if $i\neq k$. Let $r=\frac{\log d}{\log\eta}$. To simplify the matters, we assume $r$ is an integer (otherwise, we will set $r=\lceil\frac{\log d}{\log\eta}\rceil$). Iteratively, define the polynomials $g^{(b_{1},\cdots,b_{\ell-1})}(\alpha,x)$ and $f^{(b_{1},\cdots,b_{\ell})}(x)$, for $\ell\in[0:r]$ and $(b_{1},\cdots,b_{\ell})\in[0:c\eta-1]^{\ell}$ as follows. If $f^{(b_{1},\cdots,b_{\ell-1})}(x)=e_{0}+e_{1}x+e_{2}x^{2}+\cdots$ then

[TABLE]

and

[TABLE]

As the starting point of the iteration, let $f^{(b_{1},\cdots,b_{\ell-1})}(x)=f(x)$ for $\ell=1$. Note that $g^{(b_{1},\cdots,b_{\ell})}(\alpha,x)$ is a polynomial of degree $\eta-1$ as a function of $\alpha$. Furthermore, note that

[TABLE]

Define $h(b_{1},\cdots,b_{r})$ as

[TABLE]

Since $f^{(b_{1},\cdots,b_{r})}(x)$ is a constant function of $x$, $h(b_{1},\cdots,b_{r})$ only depends on $(b_{1},\cdots,b_{r})$ and not $x$.

2.2 The Initialization Phase.

In the initialization phase, the verifier computes and stores $h(b_{1},\cdots,b_{r})$ in a look-up table for all possible $(b_{1},\cdots,b_{r})\in[0:c\eta-1]^{r}$. In total, the number of evaluation points is

[TABLE]

We will now describe an algorithm for efficient computation of the look-up table. We will show that due to the recursive structure of $h(\cdot)$, its evaluation at all $\lambda$ points can be computed in $O(c^{r}\cdot d\cdot\eta)$.

2.2.1 Efficient Computation of the Look-up Table.

A naive approach to obtaining the $\lambda=c^{r}\cdot d$ entries of the look-up table is to compute them individually, which would take $O(\lambda\cdot d)$. However, due to the recursive structure of the function $h(\cdot)$, we can be much more efficient. Specifically, let $a_{i}^{(b_{1},\cdots,b_{\ell})}$ be the coefficient of $x^{i}$ in $f^{(b_{1},\cdots,b_{\ell})}(x)$ for each $\ell\in[0:r]$ and all $(b_{1},\cdots,b_{\ell})\in[0:c\eta-1]^{\ell}$. We have the following recursion

[TABLE]

for all $\ell\in[1:r]$. Furthermore, for $\ell=0$, we define $a_{i}^{(b_{1},\cdots,b_{\ell})}=a_{i}$. When $\ell=r$, the polynomial $f^{(b_{1},\cdots,b_{r})}(x)$ is of degree zero and is equal to $a_{0}^{(b_{1},\cdots,b_{r})}$. Therefore, we have

[TABLE]

In order to compute $h(b_{1},\cdots,b_{r})$, we start by computing a table of size $c\eta^{2}$ that stores all $Z_{i}(\alpha_{j})$, for $i\in[0:\eta-1]$ and $j\in[0:c\eta-1]$ 111We are assuming that $\eta$ grows at most polylogarithmically with $d$, so the complexity of computing $Z_{i}(\alpha_{j})$ will be negligible compared to the overall complexity of the initialization phase. More on the proper choice of $\eta$ in Section 3.1.. Afterwards, we iteratively compute the values of $a_{i}^{(b_{1},\cdots,b_{\ell})}$ until we reach the leaves of the tree which give us $h(b_{1},\cdots,b_{r})$. Since we have pre-computed the values of $Z_{i}(\alpha_{j})$, finding each $a_{i}^{(b_{1},\cdots,b_{\ell})}$ based on (2.10) only takes $O(\eta)$. At the $\ell^{\textnormal{th}}$ level of the tree, we must compute $a_{i}^{(b_{1},\cdots,b_{\ell})}$ for all $(b_{1},\cdots,b_{\ell})\in[0:c\eta-1]^{\ell}$ and all $i\in[0:\frac{d}{\eta^{\ell}}-1]$. Therefore, the computation at level $\ell$ takes $O((c\cdot\eta)^{\ell}\cdot\frac{d}{\eta^{\ell}}\cdot\eta)=O({c^{\ell}\cdot d}\cdot\eta)$ operations. As a result, the entire tree can be computed in $c\cdot d\cdot\eta+c^{2}\cdot d\cdot\eta+\cdots+c^{r}\cdot d\cdot\eta\leq c^{r}\cdot d\cdot\eta\cdot\frac{c}{c-1}=O(c^{r}\cdot d\cdot\eta)$. This procedure has been summarized in Algorithm 1. For an illustration, see Figure 1.

2.3 The Evaluation Phase.

The verifier is interested in evaluating $f(x)=a_{0}+a_{1}x+\cdots+a_{d-1}x^{d-1}$. We assume that both $f(\cdot)$ and $x$ are publicly known. The prover sends $\hat{f}(x)$ to the verifier. If the prover is honest, then $\hat{f}(x)=f(x)$. Otherwise, it can be an arbitrary member of $\mathbb{F}$. The prover also sends the verifier $\hat{f}^{{(s)}}(x^{(1)})$ for all $s\in[0:\eta-1]$, where $x^{(1)}=x^{\eta}$. The verifier checks whether

[TABLE]

If not, he rejects the result. Next, the verifier finds the polynomial $\hat{g}(\alpha,x^{(1)})$ of degree $\eta-1$ (in $\alpha$) by interpolating the points $(\alpha_{s},\hat{f}^{{(s)}}(x^{(1)}))$, $s\in[0:\eta-1]$. He then chooses $b_{1}\in[0:c\eta-1]$ uniformly at random and finds $\hat{f}^{(b_{1})}(x^{(1)})=\hat{g}(\alpha_{b_{\ell}},x^{(1)})$. The verifier then sends $b_{1}$ to the prover. Next, the prover sends the verifier $\hat{f}^{(b_{1},s)}(x^{(2)})$ for all $s\in[0:\eta-1]$ where $x^{(2)}=x^{\eta^{2}}$. The verifier checks if

[TABLE]

If not, he rejects the result. The algorithm now proceeds with $\hat{f}^{(b_{1})}(x^{(1)})$ taking the role of $\hat{f}(x)$. This process continues until the prover sends the verifier $\hat{h}(b_{1},\cdots,b_{r})=\hat{f}^{(b_{1},\cdots,b_{r})}(x^{(r)}).$ The verifier checks this against the correct value of ${h}(b_{1},\cdots,b_{r})$ stored in his look-up table. If they are not equal, the result is rejected. To amplify the prover’s probability of failure, this entire algorithm is run $m$ times. If all the $m$ experiments pass, the verifier accepts the result. We will see in Section 3 that the proper choice of $m$ is $(\frac{c}{c-1})^{r}$. This process has been summarized in Algorithm 2 and illustrated in Figure 2. For notational simplicity, the algorithm is described as $m$ consecutive rounds. But the $m$ rounds can be trivially parallelized to reduce the overall round complexity to $r$.

3 Performance Analysis

Completeness: If the prover is honest, he will provide the correct $f(x)$ and the correct values of $f^{(b_{1},\cdots,b_{\ell})}(x^{(\ell)})$ for all $\ell\in[1:r]$ which will clearly pass all the verification tests.

(Information-theoretic) soundness: Soundness follows from the simple principle that two distinct polynomials of degree $\eta-1$ must disagree on at least $(c-1)\eta+1$ points on any set of size $c\eta$. Suppose the prover starts by sending the verifier the wrong value of $\hat{f}(x)$. In order to pass (2.12), he must then provide the verifier with at least one wrong value $\hat{f}^{(s)}(x_{1})$. Because of this, the polynomial $\hat{g}(\alpha,x_{1})$, as a function of $\alpha$, will be distinct from the correct polynomial ${g}(\alpha,x_{1})$. Due to the observation above, these two polynomials will differ on at least $(c-1)\eta+1$ members of $L$. Therefore, if $b_{1}$ is chosen uniformly at random over $[0:c\eta-1]$, the value of $\hat{f}^{(b_{1})}(x_{1})=\hat{g}(\alpha_{b_{1}},x_{1})$ will be different from the correct value ${f}^{(b_{1})}(x_{1})$ with probability at least $\frac{c-1}{c}$. With high probability, the error continues to propagate through the interactions between the verifier and the prover, until it reaches level $r$, at which point, the verifier can detect it by checking it against its stored value ${h}(b_{1},\cdots,b_{r})$. The probability that an adversarial prover can successfully pass all the verifications is bounded by

[TABLE]

The verifier proceeds to run the experiment $m$ times and rejects the result if any of the $m$ experiments fail. We want to choose $m$ such that $p^{m}<1/2$. By choosing $m=(\frac{c}{c-1})^{r}$, we will have

[TABLE]

Computational Complexity of the Initialization: Based on the analysis in Section 2.2.1, the initialization phase can be done in time

[TABLE]

Computational Complexity of the Verifier: The verifier runs $m$ (parallel) experiments, each consisting of $r$ rounds. Each round takes $O(\eta)$ operations. Therefore, the overall complexity of the verifier is

[TABLE]

Computational Complexity of the Prover: An honest prover can also pre-compute the coefficients of the polynomials $f^{(b_{1},\cdots,b_{\ell})}(x)$ in its own initialization phase and store them locally in order to reduce its complexity. In round $\ell$, the prover must evaluate $\eta$ polynomials each of degree $\frac{d}{\eta^{\ell}}$. Therefore, the prover only needs to perform $m(d+\frac{d}{\eta}\cdot\eta+\frac{d}{\eta^{2}}\cdot\eta+\cdots+\frac{d}{\eta^{r}}\cdot\eta)\leq m\cdot d\cdot\frac{2\eta}{\eta-1}=O(m\cdot d)$ computation 222Even in the absence of an initialization phase for the prover, the complexity remains $O(m\cdot d\cdot\eta)$ for each of the $r$ rounds, resulting in an overall complexity of $O(m\cdot d\cdot\eta\cdot r)$. This is still of the form $O(d^{1+\epsilon})$ for the choice of $\eta$ and $c$ in Section 3.1..

[TABLE]

Round Complexity of the Algorithm: As mentioned in Section 2.3, we can run all the $m$ experiments in parallel. As a result, the round complexity of the algorithm is only

[TABLE]

3.1 The Proper Choice of the Parameters.

We have two parameters to play with, namely $c$ and $\eta$. Firstly, we want to make sure that the initialization phase can be done in ${O}(d^{1+\epsilon})$. For this purpose, we choose $\eta=(\log d)^{\omega}$ for an arbitrary real number $\omega>0$. We also fix $c\in\mathbb{R}$, $c>1$ to be a constant. To see why ${\cal C}_{ini}={O}(d^{1+\epsilon})$, note that

[TABLE]

Our second criterion is to achieve ${\cal C}_{ver}=O(d^{\epsilon})$. This requirement is automatically satisfied with the above choices of $\eta$ and $c$.

[TABLE]

where $b=\frac{1}{\omega}\cdot\log\frac{c}{c-1}$ is a constant. Finally, the complexity of the prover is given by

[TABLE]

and the round complexity is

[TABLE]

4 Discussion: Extending the Results to Multivariate Polynomials

Consider an $n$-variate polynomial of degree $d-1$ in each variable

[TABLE]

A verifier wishes to evaluate this polynomial at $(x_{1},\cdots,x_{n})$ with the help of a prover. A simple variation of Algorithm 2 can be used for this purpose. First, the verifier treats $f(x_{1},\cdots,x_{n})$ as a univariate polynomial in $x_{1}$ and applies Algorithm 2 in order to reduce the degree of $x_{1}$ to zero after $r=\frac{\log d}{\log\eta}$ interactions with the prover. Now, he is left with a new polynomial that only has $n-1$ variables. After $n\cdot r$ rounds, the number of variables will reduce to zero, and the verifier will be left with a constant that he can check against a look-up table of size $(c\cdot\eta)^{nr}$. It is easy to see that if we resort to this modified algorithm, all the results in Section 3 will remain valid, except $d$ must be replaced with $d^{n}$ (the number of terms in $f(x_{1},\cdots,x_{n})$). For instance, the complexity of the verifier will be

[TABLE]

and the complexity of the prover will be

[TABLE]

It is also noteworthy that any improvements in the multivariate case directly translates to a better univariate algorithm. To see why, consider an arbitrary univariate polynomial $g(x)$ of degree $d^{n}-1$. Without loss of generality, we can represent this polynomial as

[TABLE]

Applying Algorithm 2 on $g(x)$ results in a verifier complexity of $O(d^{\frac{bn}{\log n+\log\log d}})$ which is the same as ${\cal C}_{ver,n}$. If we can design an $n-$variate algorithm that achieves a verifier complexity smaller than ${\cal C}_{ver,n}$, we can apply it on $f(x,x^{d},\cdots,x^{d^{n-1}})$ and improve upon the complexity of Algorithm 2 applied on $g(x)$.

Acknowledgement

The authors would like to thank Ali Rahimi for the fruitful discussions.