An Approach to the Construction of a Recursive Argument of Polynomial Evaluation in the Discrete Log Setting

: Succinct Non-interactive Arguments of Knowledge (SNARks) are receiving a lot of attention as a core privacy-enhancing technology for blockchain applications. Polynomial commitment schemes are important building blocks for the construction of SNARks. Polynomial commitment schemes enable the prover to commit to a secret polynomial of the prover and convince the veriﬁer that the evaluation of the committed polynomial is correct at a public point later. Bünz et al. recently presented a novel polynomial commitment scheme with no trusted setup in Eurocrypt’20. To provide a transparent setup, their scheme is built over an ideal class group of imaginary quadratic ﬁelds (or brieﬂy, class group). However, cryptographic assumptions on a class group are relatively new and have, thus far, not been well-analyzed. In this paper, we study an approach to transpose Bünz et al.’s techniques in the discrete log setting because the discrete log setting brings a signiﬁcant improvement in efﬁciency and security compared to class groups. We show that the transposition to the discrete log setting can be obtained by employing a proof system for the equality of discrete logarithms over multiple bases. Theoretical analysis shows that the transposition preserves security requirements for a polynomial commitment scheme.


Introduction
Zero-Knowledge Succinct Non-interactive Arguments of Knowledge (zk-SNARKs) are non-interactive proof systems between the prover and the verifier. They provide a way for the prover to convince the verifier that the statement claimed by the prover is true without disclosing any other information except the validity of the statement while maintaining a short proof size and an efficient verification by the verifier. Since their adoption to cryptocurrency systems, such as Zcash [1] and Ethereum [2], zk-SNARKs are regarded as an essential technique for solving data privacy issues in blockchain-based applications. There have been numerous SNARK proposals in the literature. Some constructions present very efficient proof systems with the help of a trusted setup [3][4][5]. Because the transparent property is desirable for applications, such as cryptocurrency, recent constructions [6][7][8] have focused on a proof system with a transparent setting, i.e., they have no trusted setup.
The construction of SNARKs with no trusted setup heavily relies on a transparent and efficient polynomial commitment scheme. At a high level, transparent zk-SNARKs can be constructed using the framework from polynomial interactive oracle proofs (IOP) [3,6] as follows: (1) The prover expresses the required computation for proving a statement as a set of low-degree polynomials over a finite field F, which is a representation of its witness. (2) The prover sends commitments to low degree polynomials to the verifier, and the verifier then checks the proof by querying evaluations of polynomials for points chosen uniformly at random from F, where we crucially require a polynomial commitment scheme.
(3) Finally, one can obtain the non-interactive version of the previous proof systems by applying the Fiat-Shamir heuristic [9].
In this paper, we focus on polynomial commitment schemes. Let f (X) be the prover's secret polynomial over a field F with the degree at most d, i.e., deg( f ) ≤ d. In polynomial commitment schemes, the prover sends the commitment to f to the verifier. Later, upon input of a public point (x, y) ∈ F × F, the prover convinces the verifier that the committed polynomial f holds y = f (X) with a proof. We call a polynomial commitment scheme transparent if it requires no trusted setup to generate public parameters for the scheme. Since the first construction was developed by Kate et al. [10], a variety of polynomial commitment schemes have been proposed in the literature.
For polynomial commitment schemes, the main factors of efficiency consist of the computation complexities of the prover (prover complexity) and verifier (verifier complexity), and the communication complexity between them. Usually, constructions with a trusted setup provide higher efficiency than those with a transparent setting. Recently, Bünz et al. [6] proposed an efficient polynomial commitment scheme with a transparent setting. Asymptotically, it achieves a logarithmic verifier complexity and proof size for evaluation (communication complexity). In brief, it improves efficiency by applying an evaluation protocol in a recursive manner. It reduces the degree of a polynomial f by half at each iteration; hence, log deg( f ) iterations overall. Transparency in the scheme relies on the use of a group of unknown order whose concrete candidate is an ideal class group of imaginary quadratic fields.
The security of a group of unknown order stems from the infeasibility of computing the order of the group. Previous cryptographic constructions over a class group considered concrete group parameters, such as a 1665-bit negative fundamental discriminant for 128-bit security [11,12], which was used in Bünz et al.'s scheme [6]. However, recent works report that the above parameters for class groups provide less security than expected. Notably, Dobson and Galbraith estimate that class groups with a 1665-bit discriminant only offer 55-bit security [13]. They, therefore, claim that orders of a random class group should be at least 2 3328 for a 128-bit security level. Those parameters correspond to approximately a 6656-bit discriminant. This leads to a decreased efficiency for the cryptographic primitives based on class groups.
In this paper, we put forward a study to overcome the efficiency degradation of Bünz et al.'s construction caused by the use of class groups. To do this, we focus on transposing their techniques in the discrete log setting, preserving a no-trust setup. This approach brings about two advantages. First, the (elliptic curve) discrete log problem is one of the standard cryptographic assumptions as opposed to the order assumption of class groups. To date, its security has been well-understood. Second, the group operation in the discrete log setting (e.g., elliptic curve groups) is much more efficient than that in the class groups, which significantly reduces the actual computation cost for both the prover and the verifier. In addition, a group element in the discrete log setting is shorter than that in class groups. This advantage cuts the cost of bandwidth spent by the prover and the verifier when applying the evaluation protocol of a polynomial commitment scheme.
Our approach is built on an information-theoretic abstraction given in [6] to construct a polynomial commitment scheme. The abstraction requires two properties, a linear homomorphism and a monomial homomorphism, which the underlying commitment scheme should provide. These two properties enable the verifier to apply the computations among polynomials over their committed forms, such as a linear combination (a linear homomorphism) and a degree-shift operation (a monomial homomorphism) of polynomials. The two properties are necessary for an evaluation protocol using a recursive call, which is critical in achieving a logarithmic verifier and communication complexities. To realize these properties in a discrete log setting, we utilize a polynomial encoding method devised by Bootle et al. [14]. This method uses a variant of the Pedersen commitment scheme [15], which naturally provides a linear homomorphism. Unfortunately, however, the Pedersen commitment scheme is not a monomial homomorphism, which is easily obtained in a class group-based scheme [6]. Thus, we focus our attention on the study of a discrete log-based proof system to prove that a monomial homomorphism is verifiably computed in the discrete log setting. The contribution of this work is as follows.

•
We clarify a proof system that proves the correct computation of a monomorphism in the discrete log setting. Specifically, we show it suffices to have a proof system to check the equality of a discrete logarithm over multiple bases, say PoE mDL . Given two subsets {g 1 , · · · , g d } and {h 1 , · · · , h d } of a group G, PoE mDL allows the prover to convince the verifier that i have equal exponents, i.e., a i = b i for i = 1, . . . , d, without disclosing raw exponents. A number of studies on PoE mDL have been carried out independently of the construction of polynomial commitment schemes. This work bridges two rather independent proof systems and provides a blueprint to combine these proof systems for the construction of an efficient, transparent polynomial commitment scheme in the discrete log setting. • We propose a recursive argument to show the correct polynomial evaluation by employing PoE mDL . Our approach is to transpose a recursive argument from a class group in [6] to that from the discrete log setting. We present a security analysis to demonstrate the completeness and soundness of the proposed protocol. In addition, We present a zero-knowledge version of the obtained polynomial commitment scheme. A zero-knowledge version ensures that no information of the prover's secret polynomial f (X) is leaked while the prover convinces the verifier that y = f (x) holds for a point (x, y).
The remainder of this paper is organized as follows. In Section 2, we review related works. In Section 3, we provide the background on the hardness assumption and building blocks for polynomial commitment schemes. In Section 4, we present our approach to transpose Bünz et al.'s techniques in the discrete log setting and investigate a sub-routine protocol as a sufficient condition for our approach. In Section 5, we discuss the performance and security of our approach. In Section 6, we extend the polynomial commitment scheme in the previous section to the version with a zero-knowledge evaluation protocol. Finally, we provide some concluding remarks in Section 7.

Related Work
A lot of recent research on polynomial commitment schemes have been carried out in the context of Succinct Non-interactive ARguments of Knowledge (SNARKs). In particular, a polynomial commitment scheme provides a key tool to generate a zk-SNARK from a polynomial interactive oracle proof (IOP) [3,6].
Kate et al. first constructed efficient and succinct polynomial commitment schemes for univariate polynomials [10]. The construction is based on bilinear pairings over elliptic curves and requires a trusted setup. Its extension to multivariate polynomials has been proposed by Papamanthou et al. [16] and Zhang et al. [17]. Zhang et al. [18] also presented the zero-knowledge version of their work [17]. These schemes all use bilinear pairings and require a trusted setup.
Associated with transparent SNARKs, polynomial commitment schemes with a transparent setting have received significant attention and, along with the previously mentioned constructions, many schemes can be found in the literature. Bootle et al. [14] constructed a transparent polynomial commitment scheme in the discrete log setting. They represent a polynomial of degree d as a matrix with √ d rows and columns and then write a polynomial evaluation as matrix multiplications. This leads to a O( √ d) commitment size, verifier complexity, and communication complexity. Wahby et al. presented a transparent polynomial commitment scheme [7] for multilinear polynomials under the discrete log assumption. The scheme is built on the ideas of a matrix commitment of Bootle et al. [14] and the innerproduct argument of Bünz et al. [19]. For a polynomial of degree d, the O( √ d) commitment size, verifier complexity, and communication complexity are required. Ben-Sasson et al. [20] introduced the Fast Reed Solomon IOP of Proximity (FRI), which implicitly yields a transparent polynomial commitment scheme. Kattis et al. [8] and Zhang et al. [21] independently presented a method for obtaining polynomial commitment schemes from FRI.
Their construction has O(λ) size commitments for the security parameter λ and O(log 2 d) communication complexity and supports quantum resistance. In addition, Lee [22] proposed a multivariate polynomial commitment scheme with a transparent setting using pairing-based commitments. The scheme builds on inner product arguments given in Bootle et al. [14] and Bünz et al. [6]. Recently, Boneh et al. [23] studied additive polynomial commitment schemes, where commitments form an additive group [6,10,14,19,22]. They showed that the additive property yields a batch evaluation of polynomial commitments, which can be used for the efficient construction of SNARKs.
Groups of unknown order provide a mathematical structure for interesting cryptographic applications, such as delay functions [24], accumulators [25], and polynomial commitment schemes [6]. Most cryptographic applications consider two candidate groups of unknown order, i.e., RSA groups [26] and ideal class groups of imaginary quadratic fields [27]. RSA groups assume a trusted setup in generating the RSA modulus and hence do not meet our current interest. By contrast, class groups do not require a trusted setup and thus have been used in recent constructions with a transparent setting [6,24,25]. Dobson and Galbraith [13] analyzed the security of the candidate parameters for class groups proposed in [11,12]. They argued that the parameters in [11,12] do not meet the desired security level and present much larger parameters, which lead to an extremely large size-up for commitments in previous constructions. In this line of research, Belabas et al. [28] recently reported that the order assumption in class groups of imaginary quadratic fields does not hold in certain special classes of prime numbers. Some studies have explored alternative source groups of unknown order with a transparent setting. As an example, Dobson and Galbraith [13] suggested the Jacobian of hyperelliptic curves of genus 3, whereas Lee [29] pointed out that the order of the Jacobian of a hyperelliptic curve can be efficiently computed.

Preliminaries
Throughout the paper, λ denotes the security parameter written in unary. The function negl : N → [0, 1] denotes a negligible function, i.e., negl(λ) = 1 − λ ω (1) . For a set S, we use e $ ← S to denote that an element e is sampled uniformly at random from S. For a probabilistic algorithm A, we write y ← A(x) to denote that y is returned as the result of A on input x together with a randomness r picked internally.

The Discrete Logarithm Assumptions
Let Ggen be an algorithm that takes on input λ and returns a λ-bit prime number p, cyclic group G of order p, and a generator g of G.
Definition 1 (Discrete Logarithm Assumption). The discrete logarithm assumption holds relative to Ggen if for any polynomial-time adversary A, Definition 2 (Discrete Logarithm Relation Assumption). The discrete logarithm relation assumption holds relative to Ggen if for any polynomial-time adversary A, In the above definition, ∏ n i=0 g a i i = 1 for some a i = 0 is called a non-trivial discrete logarithm relation. It is well-known that the discrete logarithm relation assumption is equivalent to the discrete logarithm assumption [14].

Zero-Knowledge Arguments of Knowledge
Let R ⊂ S × W be a polynomial-time-decidable binary relation. s ∈ S and w ∈ W are called a statement and a witness, respectively. We define L R as the set {s ∈ {0, 1} * : ∃w ∈ {0, 1} * such that (s, w) ∈ R}, which is called the language of R. We consider an argument system for a relation R consisting of three probabilistic polynomial-time algorithms (Pgen, P, V ). A non-interactive algorithm Pgen takes the security parameter λ as an input and returns a common reference string (crs) pp. P and V are called a prover and a verifier, respectively, and both are interactive algorithms. In addition, P takes as input a triple of pp, a statement s ∈ S, and a witness w ∈ W. Moreover, V takes as input a pair of pp and a statement s ∈ S and outputs 0 or 1. We denote the transcript produced by P and V for an interaction by tr ← P (pp, s, w), V (pp, s) and write P (pp, Definition 3 (Argument of Knowledge). We call the triple (Pgen, P, V ) an argument of knowledge for relation R if it has completeness and witness-extended emulation, as defined below.
Definition 4 (Perfect Completeness). (Pgen, P, V ) has perfect completeness if for all nonuniform polynomial-time adversaries A, [30,31]). (Pgen, P, V ) has witness-extended emulation if for every deterministic polynomial-time prover P * there exists an expected polynomial-time emulator E such that for all non-uniform polynomial-time adversaries A, the difference between the following two probabilities is less than or equal to negl(λ):

Definition 5 (Witness-Extended Emulation
Pr   A(tr) = 1 : where the oracle called by E P * (pp,s,st),V (pp,s) permits rewinding to any round and running again on fresh verifier randomness, and st is the initial state of P * . Definition 6 (Public Coin). An argument system (Pgen, P, V ) is called public coin if the verifier chooses its messages uniformly at random, and independently of the messages sent by the prover, i.e., the challenges correspond to the verifier's randomness.
We recall special honest verifier zero-knowledge, which states that the view of the verifier can be simulated if the verifier follows the protocol honestly and if challenges made by the verifier are known in advance.

Definition 7 (Perfect SHVZK).
A public coin argument system (Pgen, P, V ) is called a perfect special honest verifier zero-knowledge (SHVZK) argument for relation R if there exists a probabilistic polynomial-time simulator Sim such that for all interactive non-uniform polynomial-time adversaries A, where ρ is the public coin randomness used by the verifier.
The general forking lemma [6,14] is useful for proving that an argument system has witness-extended emulation. Consider a public coin interactive argument system with r rounds. We view ∏ r i=1 n i distinct accepting transcripts as having a tree format with depth r and ∏ r i=1 n i leaves, which we call an (n 1 , . . . , n r )-tree. For 1 ≤ i ≤ r, let c i be the i-th round challenge chosen among exactly n i ≥ 1 values. The root node is labeled with a statement s and has exactly n 1 children labeled with a distinct value for c 1 , where each edge from the root to a child is labeled with a message from the prover to the verifier on c 1 . Similarly, each node in depth 1 ≤ i ≤ r − 1 is labeled with a distinct value for c i and has n i+1 children labeled with a distinct value for c i+1 , where each edge from c i to c i+1 is labeled with a message from the prover to the verifier on c i . Note that each path from the root to a leaf then corresponds to an accepting transcript.
Lemma 1 (General Forking Lemma [6,14]). Let (Pgen, P, V ) be a public coin argument system for relation R with r rounds. Let χ be a witness extraction algorithm that succeeds with overwhelming probability in extracting a witness from an (n 1 , . . . , n r )-tree of accepting transcripts in probabilistic polynomial time. If ∏ r i=1 n i is bounded above by a polynomial in the security parameter λ, (Pgen, P, V ) has witness-extended emulation.

Commitment Schemes
We review the definitions and security properties regarding the polynomial commitment schemes. In the following, we use a tuple (a 0 , . . . , a n ; b 0 , . . . , b n ) for arguments or a returned tuple of the prover P and the verifier V. In a tuple, (a 0 , . . . , a n ) before the semicolon and (b 0 , . . . , b n ) after it denotes public variables known to both P and V, and secret variables known to only P, respectively.

Definition 8 (Commitment Scheme).
A commitment scheme is a triple (Cgen, Commit, Open) of probabilistic polynomial-time algorithms defined as follows: • pp ← Cgen(1 λ ) takes the security parameter λ on input, and outputs the public parameter pp, which specifies a message space, a randomness space, and a commitment space; • (c; r) ← Commit(pp; m, r) takes a secret message m and an optional random r chosen uniformly at random on input and returns a commitment c and (optionally) a secret opening hint r; A commitment scheme is hiding if for all non-uniform polynomial-time adversaries A = (A 0 , A 1 ), In a polynomial commitment scheme, V additionally checks whether the evaluation at any point is correct with respect to the committed polynomial f (X) given by P. The below definition of polynomial commitment schemes is given by Bünz et al. [6], which extends that of Kate et al. [10].
Definition 9 (Polynomial Commitment Scheme [6,10]). Let (Cgen, Commit, Open) be a commitment scheme for a message space R[X] over a ring R. A polynomial commitment scheme additionally consists of a protocol Eval as follows: is an interactive public coin protocol between P and V. Both P and V have as input a commitment c, points x, y ∈ R, and a degree d. In addition, P knows the opening of c to a secret polynomial f (X) ∈ R[X] with deg( f (X)) ≤ d and a secret opening hint r. P convinces V that f (x) = y by applying the protocol.

Privacy-Preserving Blockchain with SNARKs
Recently, SNARKs have been receiving a lot of attention from the blockchain industry as a solution for balancing privacy and publicly-verifiable integrity. For instance, Zcash employs SNARKs to provide Bitcoin with user anonymity and privacy of transaction data with anonymous coins [1]. SNARKs are also used to verify Ethereum smart contracts over private input [2]. Figure 1 presents a high-level architecture of privacy-preserving blockchains with SNARKs. A typical way that SNARKs are used in blockchains is as follows. The real data is stored in off-chain storage. The data posted to the on-chain blockchain (blockchain ledger) consist of the commitment to the transaction and its proof that the target transaction is valid. Cryptographic commitment schemes ensure that it is very difficult to obtain the original input value from the committed value, and the proof generated using SNARKs can be verifiable by any node in the blockchain network. Therefore, the privacy problem is solved because the data is hidden in the public on-chain blockchain. In addition, since zero-knowledge techniques provide fast verification, they are being used in various ways to improve the performance and minimize the size of the blockchain. It is worth noting that a polynomial commitment scheme is a key building block to compile a polynomial IOP system, which is a formal representation of a proving statement, into a SNARK [3,6].

Our Approach
In this section, we present our approach to transpose Bünz et al.'s techniques in the discrete log setting. We investigate and identify a sufficient condition for a transposition. Specifically, we show how to employ a proof system for the equality of discrete logarithms. For the rest of this paper, we encode a polynomial f (X) = ∑ d−1 i=0 f i X i over a field F into a vector f = ( f 0 , . . . , f d−1 ) ∈ F d . For a group G let g be a vector (g 0 , . . . , g −1 ) ∈ G for some positive integer . For d ≤ we denote the multi-exponentiation ∏ d−1 i=0 g f i i by g f . When it is clear from the context, we write the commitment to a polynomial f (X) as Commit( f ) instead of Commit(pp; f (X), r) for the sake of convenience. We also take a finite field F as Z p for a prime p. Table 1 presents frequently-used notations in the paper. the computation cost for group operation in G f (X), deg( f (X)) a polynomial f (X) ∈ F[X] and its degree, respectively f L (X), f R (X) the left and right half parts of a polynomial f (X), respectively f the vector representation

Bünz et al.'s Abstraction
Bünz et al. [6] presented a polynomial commitment scheme for their construction of SNARKs. The proposed scheme operates in a recursive way by reducing the degree of polynomial f by half during each iteration, and hence, there are log deg( f ) iterations overall. More precisely, given an odd degree d polynomial f (X) = ∑ d i=0 f i X i , the prover splits it into two polynomials which both polynomials have a degree of roughly d/2 satisfying The prover then sends the verifier the commitments Commit( f L ) and Commit( f R ) to f L (X) and f R (X), respectively. At the end of each iteration, the prover takes the next input polynomial as for a random α received from the verifier. Because the verifier needs to check if f (x) = y from committed polynomials, the verifier should be able to homomorphically compute a committed form of the current f (X) and the next f (X) from Commit( f L ) and Commit( f R ) to see whether (1) holds. The verifier also needs to compute a commitment to a polynomial in (2) for the next iteration from Commit( f L ) and Commit( f R ).
To support the computation of the committed form, Bünz et al. [6] define the following two abstract properties.

•
linear homomorphism Commit( f ) a · Commit(g) b = Commit(a · f + b · g) for polynomials f and g, and scalars a and b (a linear homomorphism);

Base Commitment Scheme to Polynomial
We construct a polynomial commitment scheme based on a generalization of the Pedersen commitment scheme [32]. In the generalized Pedersen commitment, pp consists of a group G of a prime order p, and group elements g, g 0 , ..., g n−1 It is well-known that the generalized Pedersen commitment is perfectly hiding and computationally binding under the discrete logarithm relation assumption [32]. It is also important to note that the generalized Pedersen commitment scheme is homomorphic, i.e., Commit(pp; m, r) · Commit(pp; m , r ) = Commit(pp; m + m , r + r ).
We consider a commitment scheme, which does not use the randomness in the generalized Pedersen commitment scheme, as follows: • Cgen(1 λ ): On input of the security parameter λ, it first samples G ← Ggen(1 λ ) of a prime order p of length λ. It then chooses g 0 , . . . , g d $ ← G and returns pp = (G, p, g) where g = (g 0 , . . . , g d ).
Open(pp, c, f (X)): On input c and f (X), the verifier computes c ← ∏ d i=0 g f i i and checks if c = c in G. Because the generalized Pedersen commitment scheme is computationally binding under the discrete logarithm relation assumption, so is the commitment scheme above.

Evaluation Protocol
As presented in Section 4.1, Bünz et al.'s approach considers two properties (a linear homomorphism and a monomial homomorphism) for the underlying commitment schemes, which is crucial for the verifier to compute (1) from the commitments to the polynomials f L and f R on the right-hand side. However, our base commitment scheme does not provide monomial homomorphism, while it immediately holds the linear homomorphic property. A monomial homomorphic commitment scheme is not known thus far in the discrete log setting with no trusted setup. This is because a monomial homomorphic property may require some special structures for base elements in the group, which is impossible to generate without a trusted setup.
Thus, our approach focuses on providing a way to check the integrity of f L and f R , i.e., f = f L + X d/2 · f R using the linear homomorphic property only. The idea behind our approach is presented in Figure 3. To avoid monomial homomorphism, our approach simply lets the prover send one additional commitment to X d/2 · f R besides two commitments to f L and f R so that f = f L + X d/2 · f R can be verified using the linear homomorphic property. Our approach for recursive argument. Aside from two commitments, Commit( f L ) and Commit( f R ), the verifier additionally receives Commit(X d · f R ) to confirm they properly come from the input polynomial f using linear homomorphic property only.
We present the evaluation protocol Eval in Algorithm 1, which is a transposition of Bünz et al.'s construction [6] in the discrete log setting. In Line 13 of the Eval protocol, the prover sends one additional commitment c RR ← Commit(X d/2 · f R ). The verifier is then able to compute Commit( f ) = Commit( f L ) · Commit(X d/2 · f R ) using a linear homomorphic property of the underlying commitment scheme (Line 13). However, because the polynomial f R (X) is committed to c R and c RR independently, it is required for the prover to prove that c R and c RR are generated from the same polynomial f R (X). More precisely, given public parameter pp(= {g 0 , . . . , g d }) and two target instances d +1+i , the prover needs to convince the verifier that c R and c RR have the same exponents. Thus, we require a proof for equality of discrete logarithms, which is invoked as a sub-protocol PoE mDL in the Eval protocol (Line 12). PoE mDL takes pp, c R , c RR , and deg ( f R (X)) = d on input and returns 1 if c R and c RR have the same exponents and 0 otherwise. If the returned value is 0, V aborts the Eval protocol because P is a cheating prover. We remark that several cryptographic protocols on PoE mDL have been proposed [33,34]. The works for PoE mDL have been developed independently from the construction of polynomial commitment schemes.
V returns 1 if all checks pass, 0 otherwise 6: else 7: P and V compute d ← d : d +1+i in G 10:

13:
V checks that c = c L · c RR in G and returns 0 if the equation does not hold 14: V checks that y = y L + y R · x d +1 in Z p and returns 0 if the equation does not hold 15: V chooses α $ ← Z p and sends it to P 16: : // deg( f (X)) = d

Discussion: Performance & Security Analysis
Let Π = (Cgen, Commit, Open, Eval) be the polynomial commitment scheme described in Section 4. In this section, we analyze the performance and security of the Eval protocol.

Performance
We analyze the efficiency of our approach in comparison with the recently proposed schemes with a transparent setting found in the literature. For a concrete performance analysis, we borrow the examples of groups and parameters at the 128-bit security level given by Lee [22], which is presented in Table 2. In Table 2, G denotes a cyclic group of known order, which is implemented by curve25519-dalek [35]. An imaginary class group G U [36] is taken as an example group of unknown order. The discriminant of G U is fixed as ∆ = −(2 6656 − 26, 745), which is estimated to offer the 128-bit security level [13]. This is implemented by ANTIC [37]. For a pairing-based construction, G 1 , G 2 , and G T denote the two source groups and the target group of a pairing P. The groups of pairing are implemented by RELIC [38] over the curve BLS12-381 [39].
We analyze the efficiency of our approach. Let |G| and |PoE mDL | be the size of an element in G and the communication complexity of PoE mDL , respectively. Let [G], [PoE mDL ] P , and [PoE mDL ] V be the computation cost in G, the prover's computation cost for PoE mDL , and the verifier's computation cost for PoE mDL , respectively. Below we focus on the dominated terms for each complexity comprising the transmission and operations of the group elements, i.e., we neglect operations over a field Z p . The Eval protocol makes recursive calls roughly log d times. The messages between the prover and the verifier consist of log d times of three elements in G, and |PoE mDL |, respectively. Thus, the communication complexity is equal to 3 log d · |G| · |PoE mDL |. The prover applies log d times of three multi-exponentiations [40] of roughly d/2 size and one operation over G, and PoE mDL on the prover's side. This leads to O(d) · [G] · [PoE mDL ] P computation complexity for the prover. The verifier applies log d times of one exponentiation and two operations over G, and PoE mDL on the verifier's side, which leads to O(log d) · [G] · [PoE mDL ] V computation complexity overall. The size of public parameter pp is d · |G| · |PoE mDL |.
We now provide a comparison for polynomial commitment schemes [6,22] with a transparent setting, which achieves a logarithmic verifier complexity in Table 3. The table focuses on the dominated terms for each complexity comprising the transmission and operations of the group elements. As mentioned above, We apply multi-exponentiation techniques [40] to both our approach and Bünz et al.'s construction to reduce the prover complexity by a factor of log d. In the case of Bünz et al.'s construction, it is possible to reduce the size of public parameter pp to a single element of G U when multi-exponentiation techniques are not applied. Table 3 summarizes the efficiency analysis on communication and computation complexities, and the size of the public parameter for recent polynomial commitment schemes with transparent setting and our approach. Table 3 shows that the efficiency of our approach depends on that of PoE mDL . If PoE mDL has a constant communication/computation complexity, we observe that each complexity is almost the same across the schemes, and the efficiency of a scheme depends highly on the underlying group. The benchmark result on base groups in Table 2 shows that the sizes of the element in G U and G T are approximately 25× and 6× larger than that of G, respectively. For the operation time, G U and G T are approximately 844× and 18× slower than that of G, respectively. EC pairing operation P -1600 Table 3. Comparison between polynomial commitment schemes with a transparent setting. | · | and [·] denote the size of an element and the computation cost of a group operation in the corresponding group, respectively. We express communication complexity in the number of group elements and computation complexity in a number of group operations.

Scheme Bünz et al. [6] Lee [22] Our Approach
The above discussion shows that our scheme based on an elliptic curve group in the discrete log setting is very promising in the case that we have an efficient PoE mDL . Unfortunately, currently known PoE mDL protocols have O(d) communication complexity for the number of bases, i.e., degree of a polynomial in our setting, which is not desirable for our purpose of logarithmic complexity. However, we emphasize that it is meaningful to observe that two independent cryptographic primitives are closely connected and suggest a stepping stone for the construction of an efficient, transparent polynomial commitment scheme with a recursive argument in the discrete log setting.

Security
We analyze perfect completeness (Definition 4) and witness-extended emulation (Definition 5) of the proposed polynomial commitment scheme. Theorem 1. The Eval protocol of the polynomial commitment scheme Π has perfect completeness.
Proof of Theorem 1. First, we show that the case of d = 0 satisfies the perfect completeness. When d = 0, the valid input consists of the constant polynomial f (X) = f 0 , c = g f 0 0 ← Commit(pp; f (X)), and y = f 0 . Thus, the verification equations checked by V immediately hold.
Next, we consider the case of d > 0. For the polynomial , let t in ← (c, x, y, d; f (X)) and t out ← (c , x, y , d ; f (X)) be the input and output tuples for every recursive step in the Eval protocol. For the perfect completeness, it suffices to show that t out satisfies the relations c = g f , y = f (x), and deg( f (X)) ≤ d when the relations c = g f , y = f (x), and deg( f (X)) ≤ d hold for t in .
When d + 1 is odd, we can see that (c , y , f (X)) from t out is exactly equal to (c, y, f (X)) from t in and deg( f (X)) = deg( f (X)) ≤ d ≤ d = d + 1. Thus, the relation holds for t out . When d + 1 is even, we have f L (X) and f R (X), such that f (X) = f L (X) + X d+1 2 f R (X) and f (X) = α · f L (X) + f R (X). Thus, we can see that the following equations hold: This completes the proof of the perfect completeness.
We now prove that the Eval protocol is sound, i.e., it has witness-extended emulation. In brief, we need to show that we can extract a witness polynomial f (X) from a tree of accepting transcripts, where the number of transcripts is bounded in a polynomial in λ. This can be done by extracting an intermediate secret polynomial at each iteration of Eval, i.e., from Level i + 1 to Level i in the tree. In Lemma 2, we first show that given two accepting transcripts, we can extract an intermediate witness polynomial at each iteration of the Eval protocol. We then prove the witness-extended emulation for the whole Eval protocol by using the lemma from leaf nodes to the root node sequentially in Theorem 2.

Lemma 2.
Let pp = (G, p, g 0 , . . . , g d ) be the public parameter generated by Ggen. Suppose we have two accepting transcripts (x, c L , c R , c RR , y L , y R , α, f (X), y) and (x, c L , c R , c RR , y L , y R , α , f (X), y ) for two distinct numbers α, α ∈ Z p , such that g f = c α L c R and g f = c α L c R . Furthermore, suppose f (X) and f (X) are polynomials in Z p [X] with a degree of at most d and y = f (x), y = f (x) ∈ Z p . Then on the input of the above transcripts, there exists a probabilistic polynomial-time algorithm E that extracts either f L (X), f R (X) ∈ Z p [X] with a degree of at most d such that y L = f L (x) ∈ Z p , y R = f R (x) ∈ Z p , or a breach of the binding property of the Pedersen commitment scheme relative to Ggen.
Proof of Lemma 2. Because the two transcripts are valid, it holds that We then have Thus, E is able to compute from the binding property of the Pedersen commitment scheme. In addition, because it holds that f (x) = y = α · y L + y R and y = f (x) = α · y L + y R , we let y L ← y−y α−α and y R ← αy −α y α−α . Then, y L and y R are identical to the evaluations of the above f L (X) and f R (X) at X = x, respectively.

Theorem 2.
The Eval protocol has witness-extended emulation for a relation if the discrete logarithm relation assumption holds for Ggen.

Proof of Theorem 2.
For witness-extended emulation, we call the general forking lemma (Lemma 1). Thus, we need to construct an expected polynomial-time extractor E that extracts a witness from a tree whose number of leaves is bounded above by a polynomial in λ.
For the statement (c, x, y, d) ∈ L R Eval , we consider the following tree of the accepting transcripts. The root node is labeled with the first input statement (c, x, y, d) to Eval. Including the root node, let N be a node labeled with the statement (c, x, y, d). We denote the corresponding witness polynomial to (c, x, y, d) by f (d) (X) ∈ Z p [X]. N has two child nodes as follows. By rewinding the oracle P * , V two times with two different challenges α 1 and α 2 on the same input statement (c, x, y, d), each child node for the given challenge is labeled with the update statement (c , x, y , d ). Finally, nodes with d = 0 are leaf nodes of the tree. Because the number of levels with a branching factor of 2 is bounded by log(d + 1) , there are at most 2 1+ log 2 (d+1) ≤ 4(d + 1) transcripts in total, which is a polynomial in λ.
We now prove that there exists an extractor E that extracts a witness f (X) from the above tree, which we construct in a recursive way. That is, we construct an extractor E (d) to extract f (d) (X) for a statement (c, x, y, d) at each node starting from the leaf nodes in the tree. We note that E (d) for the degree bound d in the root node is a desired extractor E .
We fist consider E (0) to extract a witness from the leaves of the tree, i.e., d = 0. In this case, E (0) directly obtains a witness f (X) = f 0 ∈ Z p from the transcript given by the prover, such that f 0 = y and c = g f 0 0 . We now move to the case of d > 0. From the construction of the tree, the node has two child nodes, where each node is labeled with the update statement c , x, y , d = d 2 on the same input statement (c, x, y, d) with two distinct challenges α 1 and α 2 . We assume that we have the extractor E (d ) that returns the valid witness f (d ) for each child node. We then construct the extractor E (d) . E (d) extracts f , whose degree is bounded by 2d = 2 d 2 ≤ d. Because the tree consists of the accepting transcripts, we have c = g f (d) and Then, by the general forking lemma, we conclude that Π has witness extended emulation.

Extension to Zero-Knowledge Polynomial Evaluation
In this section, we extend the polynomial commitment scheme from Section 4 to a zero-knowledge version. The zero-knowledge protocol enables the prover to convince the verifier that the prover has a polynomial f (X) with deg( f ) ≤ d such that f (x) = y for a public point (x, y) but does not leak any other information about f that is formally defined in the notion of perfect SHVZK (Definition 7). For this, we require a hiding commitment scheme to polynomials, such as the generalization of the Pedersen commitment scheme, which uses randomness when generating a commitment [32]. Below, we give a formal description of the generalization of the Pedersen commitment scheme (Cgen H , Commit H , Open H ) over the polynomials in Z p [X].
and checks if c = c in G. We present our zero-knowledge evaluation protocol EvalZK in Algorithm 2. The EvalZK protocol is also obtained by transposing the corresponding zero-knowledge evaluation protocol given by Bünz et al. under the discrete log setting [6]. The basic idea is to mask the prover's secret polynomial with a random polynomial using the blinding technique introduced in [14,19,41] and then run the Eval protocol on it.
) and y =f (x) 8: P and V run Eval(pp, c, x, y, d;f (X)) The EvalZK protocol receives a hiding commitment to the prover's secret polynomial f (x) on input, i.e., c f ← Commit H (pp H ; f (X), d, r f ), which is perfectly indistinguishable to a random element in G. To hand it over to the Eval protocol, it is necessary to remove the randomization part g r f from c f = g r f ∏ d i=0 g f i i , which is equal to Commit(pp, f (X)). However, because this reveals information on f (x), the protocol lets the prover and the verifier collaboratively blind f (x) byf (X) = h(X) + α f (X) (Line 5). Here, h(X) ∈ Z p [X] is a random polynomial selected by the prover (Line 1) and α ∈ Z p is a random number selected by the verifier (Line 4). Consequently, both the prover and the verifier succeed in generating a non-hiding commitment tof (X) under Π and the point (x, y =f (x)), and then start the Eval protocol (Lines 7-8).
Proof of Theorem 3. (perfect completeness) We show that Π H has perfect completeness. Because the Eval protocol has perfect completeness (Theorem 1), it suffices to show that c and y are a valid input to Eval. That is, c is the correct commitment tof (X) = h(X) + α f (X) under Π and y is the evaluation off (X) at X = x in Z p . Given f (X) = ∑ d i=0 f i X i of a degree of at most d and h(X) = ∑ d i=0 h i X i of degree d, we have gf i i = Commit(pp,f (X))) and y = y h + α f y f = y(x) + α f f (x) =f (x) mod p.
(witness-extended emulation) We show that Π H has witness-extended emulation. From Theorem 2, we have an expected polynomial-time extractor E that extractsf (X) for the Eval protocol. Using E , we construct an extractor E H to extract a witness f (X) from EvalZK.
The extractor E H runs the prover to obtain {c h , y h }. At this point, E H then rewinds the oracle P * , V twice with distinct challenges α f and α f and obtains the corresponding commitments (c, y) and (c , y ) to the witnessesf (X) andf (X), respectively. Then, E H runs E on inputs (pp, c, x, y, d) and (pp, c , x, y , d) and receives the corresponding witnesses f (X) andf (X), respectively. Finally, E H is able to extract the witness f (X) fromf (X) and f (X), similarly to Lemma 2. This completes the proof of the witness-extended emulation.
(perfect SHVZK) We construct the simulator Sim. Given only the public input, the simulator Sim outputs a simulated transcript that is identical to the valid transcript produced by the prover and the verifier in the real interaction. The simulator Sim first samples a random polynomialf (X) of degree d and rf $ ← Z p . In addition, Sim samples a random challenge α f $ ← G and computes c h = c · c −α f f · g rf and y h = y − α f · y f . The simulator Sim then simply applies the Eval protocol honestly usingf (X) as the witness. Because in a real execution, the values α f and rf are distributed uniformly at random over Z p , the simulated α f and rf are identically distributed to real values. In addition, the real c f andf (X)) are distributed uniformly at random over G and Z p [X] of degree d, respectively, and the same distributions hold for the simulated c f andf (X), respectively. The simulated c h is also distributed uniformly at random over G, and thus the real c h is, because of the perfect hiding property of the underlying commitment scheme. Clearly, the simulated (c h , y h , α f , rf ) holds the relations Finally, the Eval protocol does not leak more thanf (X) itself, which contains no information about f (X). Therefore, the views of the simulated and real transcripts are identically distributed. This completes the proof of the perfect SHVZK.

Conclusions
In this paper, we presented how to transpose a recursive argument of polynomial evaluation over a class group proposed by Bünz et al. to the discrete log setting as a way to improve the efficiency. The transposition follows from their information-theoretic abstraction. We found that the challenge for a transposition is to provide a monomial homomorphism for an underlying commitment scheme. We observed that when we use a polynomial encoding method that presents coefficients of the polynomial to the power of random group elements, an essential sufficient condition is a proof system for the equality of discrete logarithms (PoE mDL ) over multiple bases. We believe that our approach suggests a stepping stone for the construction of an efficient, transparent polynomial commitment scheme with a recursive argument in the discrete log setting. Currently, the efficiency of known proof systems for PoE mDL is not sufficient to hava logarithmic communication and verifier complexities. Therefore, in future work, we will continue to research how to improve the efficiency of PoE mDL , which leads to high-efficiency gains for the proposed construction in the discrete log setting.
Funding: This research received no external funding.