Proposal for Handling The Memory of zkVM

Hanh Tang (NTU), Minh Pham (Orochi Network), and Chiro Hiro (Orochi Network)

Generalize the memory for zkVM (zkMemory)

The idea is to create an independent module that can be used by any zkVM. You might aware that the memory can be constructed as a simple state machine with

$2$ instructions READ and WRITE, and configurable WORD_SIZE. Our memory state machine is only able access the exactly WORD_SIZE for every executed instruction. That is, if you want to access arbitrary data size, it must be translated to multiple accesses.

These instructions need to be satisfied following conditions:

• READ instruction
  • READ on a memory was not wrote should return 0
  • EveryREAD access for the same location, must have the value to be equal to the previous WRITE.
• WRITE instruction
  • Every WRITE access must write on writable memory chunks (some areas of the memmory might be read only).

Questions:

• How could we handle the memory boundaries?
• Do we need to deal with memory allocation/deallocation?
• How could we deal with configurable WORD_SIZE?

Memory trace

To prove the accuracy and consistent of the memory, every memory accesss needs to be recorded. We propose the following trace table, (this table might be a well know among many zkVM projects).

Address	Time Log	Instruction	Value
0x0000000000000000	1	READ	0x0000000000000000
0x0000000000000000	2	WRITE	0x0000000000000a20
0x0000000000000020	3	WRITE	0x0000000000000010
0x0000000000000020	4	READ	0x0000000000000010
0x…	..	…	…

We're epxecting these tuple for every memory access.

$$(\text{address},\text{time\_log},\text{instruction},\text{value})$$

• address: The location that we applied the memory instruction.
• time_log: Incremental value that will be increased for every access.
• instruction: READ, WRITE.
• value: Value of size WORD_SIZE.

Proposing for the first implementation

We suppose to implement the first version of zkMemory following this wishlist:

• Building up the memory trace.
• Committing every state of memory to the Verkle tree.
• Providing the witness after each state is committed allowing the prover to prove the correctness of entier memory.

KZG Polynomial Commitment

KZG polynomial commitment scheme was introduced by Kate, Zaverucha and Goldberg. It allows us to commit to a polynomial

$p(X)$. Then open

$p$'s evaluations at specific points later.

KZG is widely used due to various reasons:

• KZG commitment and opening proof sizes are constant, even when opening at multiple points. The proof of evaluation only consists of one group element. Thus, the scheme achieves constant proof size.
• Verification time is also constant, namely, only a pairing operation.
• The commitment is homomorphic. Given the commitment
  $c$ and
  $c^{\prime }$ and opening
  $\pi$ and
  ${\pi }^{\prime }$ of
  $p$ and
  $p^{\prime }$, then the commitment and openings of
  $p+p^{\prime }$ is just
  $c+c^{\prime }$ and
  $\pi +{\pi }^{\prime }$.

$\Rightarrow$ Using KZG commitment scheme greatly reduces communication cost.

Now, we give a formal description to the KZG commitment scheme. Notice that for indexing, we use

${\omega }^i$ instead of

$i$, where

$\omega$ is a primitive root.

• $\mathsf{Setup}(1^{\lambda })$: Sample
  $s\in \mathbb{F}$ and output
  $(\{[s^i{]}_1{\}}_{i\in \{0,\dots ,k-1\}},\{[s^i{]}_2{\}}_{i\in \{0,\dots ,k-1\}})$
• $\mathsf{Commit}(p(X)\in {\mathbb{F}}_{<k}[X],crs)$: For
  $p(X)=\sum _{i=0}^{k-1}{p}_i{X}^i$, output
  $C=[p(s){]}_1=\sum _{i=0}^{k-1}{p}_i[s^i{]}_1$
• $\mathsf{Open}(C,p(X))$: Output
  $p(X)$.
• $\mathsf{Verify}(crs,C,p(X))$: Check if
  $[p(s){]}_1=\sum _{i\in [k]}{p}_i[s^i{]}_1=C$
• $\mathsf{OpenWitness}(p(X),{\omega }^i,crs)$: To open
  $p(X)$ at index
  ${\omega }^i$, let
  $h_i(X)={\displaystyle \frac{p(X)-p({\omega }^i)}{X-{\omega }^i}}$. Then, output
  $\pi =({\omega }^i,p({\omega }^i),[h_i(s){]}_2).$
• $\mathsf{VerifyWitness}(C,\pi =({\omega }^i,y,h_i(s{)}_2),crs)$: Verify
  $p({\omega }^i)=y$ by checking
  $e(C-[y{]}_1,[1{]}_2)=e([s{]}_1-[{\omega }^i{]}_1,[h_i(s){]}_2)$.

Commitment to Verkle Tree

Verkle tree was introduced by John Kuszmaul.

It is a

$k-$ary tree having

$\ell +1$ layers, where:

• Each leaf node contains a key and a value.
• Each parent node
  ${\mathbf{N}}_j^{(i)}$ has
  $k$ children and the value
  ${\mathbf{v}}_j^{(i)}$ of
  ${\mathbf{N}}_j^{(i)}$ of is the commitment to its children.

We see that, unlike Merkle tree, which is a binary tree, in a Verkle tree each parent node can have many more children.

To provide proof for a Verkle tree, we just need to provide a path from the node to the root. To do so, we employ the KZG commitment scheme.

Now, we will describe how to commit and open a path in a Verkle tree. It is possible to open multiple paths using the same technique. More details can be found in Dankrad Feist's blog.

• $\mathsf{VerkleSetup}$: Sample
  $s\in \mathbb{F}$ and output
  $(\{[s^i{]}_1{\}}_{i\in \{0,\dots ,k-1\}},\{[s^i{]}_2{\}}_{i\in \{0,\dots ,k-1\}})$.

• $\mathsf{VerkleCommit}$: For integers
  $k,j$, let
  $j^{\prime }=k\cdot j$. For each node
  ${\mathbf{N}}_j^{(i)}$, where
  $i\in \{0,\dots ,k-1\}$, with children whose values are
  $v_{j^{\prime }}^{(i+1)},v_{j^{\prime }+1}^{(i+1)},\dots ,v_{j^{\prime }+k-1}^{(i+1)}$, find a polynomial
  $p_j^{(i)}(X)$ such that
  $p_j^{(i)}({\omega }^t)=v_{j^{\prime }+t}^{(i+1)}$ for
  $t=0,1,...,k-1$. Then the value
  $v_j^{(i)}$ of
  ${\mathbf{N}}_j^{(i)}$ is
  $\mathsf{Commit}(crs,p_j^{(i)}(X))$. For the leaf layer, namely, layer
  $\ell$, the value
  $v_j^{(\ell )}$ for
  $j\in \{0,\dots ,2^{\ell }-1\}$ is simply the original value at location
  $j$. Output
  $v_0^{(0)}$, the root of the tree.

• $\mathsf{VerkleOpen}$: For a path
  ${\mathbf{v}}_{j_0}^{(0)}\to {\mathbf{v}}_{j_1}^{(1)}\to {\mathbf{v}}_{j_2}^{(2)}\to ...\to {\mathbf{v}}_{j_{\ell }}^{(\ell )}$, we have to prove that
  $p_{j_i}^{(i)}({\omega }^{j_i})={\mathbb{v}}_{j_{i+1}}^{(i+1)}\mathrm{\forall }i\in \{0,\dots ,\ell -1\}$. We proceed the following steps:
  – Let
  $h_{j_i}^{(i)}(X)={\displaystyle \frac{p_{j_i}^{(i)}(X)-{\mathbb{v}}_{j_{i+1}}^{(i+1)}}{X-{\omega }^{j_i}}}$ and
  $r=H({\mathbf{v}}_0^{(0)},...,{\mathbf{v}}_{j_{\ell -1}}^{(\ell -1)},{\mathbf{v}}_{j_1},...,{\mathbf{v}}_{j_{\ell }}^{(\ell )},{\omega }^{j_0},...,{\omega }^{j_{h-1}})$.
  – Let
  $G(X)=\sum _{i\in [h]}{r}^i{h}_{i,j_i}(X)$, compute
  $D=[G(s){]}_1$.
  – Let
  $r^{\prime }=H(D,r)$ and
  $h(X)=\sum _{i\in [\ell ]}{r}^i{\displaystyle \frac{p_{i,j_i}(X)}{r^{\prime }-{\omega }^{j_i}}}$. Compute
  $E=[h(s){]}_1$. Note that
  $E$ can be computed by both prover and verifier, si nce the verifier has already known
  $[p_{i}i,j_i(s)]$, which belongs to the opening path.
  – Finally, let
  $y=\sum _{i\in [\ell ]}{r}^i{\displaystyle \frac{{\mathbb{v}}_{j_{i+1}}^{(i+1)}}{r^{\prime }-{\omega }^{j_i}}}$.
  – Output
  $D,\pi ={\left[{\displaystyle \frac{h(s)-G(s)-y}{s-r^{\prime }}}\right]}_1$

• $\mathsf{VerkleVerify}\mathsf{:}$ Check if the root node element is equal to the first opening element and for
  $r$,
  $r^{\prime }$,
  $y$ defined earlier, compute
  $E=\sum _{i\in [\ell ]}{r}^i{\displaystyle \frac{[v_{j_i}^{(i)}{]}_1}{r^{\prime }-{\omega }^{j_i}}}$ check whether
  $e(E-D-[y{]}_1,[1{]}_2)=e(\pi ,[s{]}_2-[r^{\prime }{]}_2)$

There are several benefits of commiting to a Verkle tree using KZG than hashing in a Merkle tree.

• Because the width Verkle tree is larger, the opening path is much shorter.
• The opening proof of Verkle tree is constant sized. As mentioned by Buterin in his blog,the proof size is much smaller than a Merkle proof (6 to 8 times smaller).

Proposal of Folding Scheme for Vector Commitment

We construct a folding scheme for correct evaluation of vector commitment by R1CS-in-the-exponent. The vector commitment to a vector

$\mathbf{x}=(x_0,\dots ,x_{k-1})$ in our solution employs the KZG polynomial commitment scheme and is realized by committing to a polynomial

$p(X)$ whose evaluations at

${\omega }^0,\dots ,{\omega }^{k-1}$, where

$\omega$ is some reasonable primitive root, are equal to

$x_0,\dots ,x_{k-1}$, respectively.

Remark. The solution we propose here, following Nova, is not complete for R1CS-in-the-exponent for vector commitment with respect to KZG commitment scheme and Verkle tree. It requires additonal adaptations to make it suitable with the form of relaxed R1CS-in-the-exponent.

To make polynomial commitment suitable with folding scheme, we remind the polynomial representations (i) by coefficients and (ii) by Lagrange basis, and show how to commit such a polynomial with respect to these presentations.

Polynomial representation by coefficients

The coefficient representation of a polynomial

$p(X)\in {\mathbb{F}}_{<k}[X]$ of degree at most

$k-1$ is represented by

$$p(X)=p_0+p_{1}X+p_2{X}^2+\cdots +p_{k-1}{X}^{k-1}.$$

Polynomial representation by Lagrange basis

In case we would like to construct a polynomial

$p(X)\in {\mathbb{F}}_{<k}[X]$ satisfying

$p({\omega }^i)=x_i$ for all

$i\in \{0,\dots ,k-1\}$, using Lagrange basis

$\{L_i(X){\}}_{i\in \{0,\dots ,k-1\}}$ helps construct such polynomial in a cleaner way. That is,

$$p(X)=\sum _{i=0}^{k-1}{x}_i{L}_i(X).$$

Polynomial commitment by

$2$ ways of representations

Thus, in KZG polynomial commitment scheme, we can compute commitment to

$p(X)$ by computing either

$$[p(X)]=\sum _{i=0}^{k-1}{p}_i\cdot [s^i]\text{ or }[p(X)]=\sum _{i=0}^{k-1}{x}_i\cdot [L_i(X)]$$
by using the common reference string

$\{[s^i]{\}}_{i\in \{0,\dots ,k-1\}}$. However, commitment to

$p(X)$ by using Lagrange basis asks us to prepare

$\{[L_i(X)]{\}}_{i\in \{0,\dots ,k-1\}}$ in advance.

Proposal of Folding Scheme for Memory Accesses with Polynomial Commitments

In this section, we discuss the technique for constructing folding scheme for memory accesses with respect to polynomial commitments. In particular, we assume that our memory is a

$k$-element array

$\mathbf{v}=(v_0,\dots ,v_{k-1})$. We commit the entire memory by using the KZG commitment scheme and describe the proof of correct accesses, namely, reading and writing, to the memory.

Using the KZG commitment scheme, we assume that the commitment to the memory is equal to

$$c=[p(X)]=\sum _{i=0}^{k-1}{x}_i\cdot [L_i(X)]$$
by using

$\{[s^i]{\}}_{i\in \{0,\dots ,k-1\}}$. This computation is in fact equivalent to evaluating

$p(X)$ at a secret point

$s$.

We first describe the technique for handling READ access to the memory. Specifically, we would like to prove that the

$i$-th element of array

$\mathbf{v}$, namely,

$v_i$, is equal to

$y$ for some public value

$y$. In case of polynomial commitment, it is equivalent to proving that

$p({\omega }^i)=y_i$.

The proof for opening at the

$i$-th position is computed as

$$w_i=\left[\frac{p(X)-p({\omega }^i)}{X-{\omega }^i}\right].$$

And, to verify the correctness of the proof, we simply check that

$$e([s]-[{\omega }^i],w_i)=e(c-[y_i],[1]).$$

R1CS-in-the-exponent for vector commitment. It is now reasonable for us to define the correct form of matrices

$\mathbf{A}$,

$\mathbf{B}$ and

$\mathbf{C}$, and witness vector

$\mathbf{w}$.

• We first realize the structure of witness vector
  $\mathbf{w}$. Notice that the verification of evaluation at
  ${\omega }^i$ require the involvement of
  $[s],c,[{\omega }^i],[y_i],w_i$ and
  $[1]$. Since there is no secret element here, we simply define the witness vector
  $\mathbf{w}$ to be
  
  $$\mathbf{w}=\left(\begin{array}{c}[s]\\ c\\ [{\omega }^i]\\ [y_i]\\ w_i\\ [1]\end{array}\right).$$
• The matrix
  $\mathbf{A}$ simply computes
  $[s]-[{\omega }^i]$. Hence,
  
  $$\mathbf{A}=\left(\begin{array}{cccccc}1& 0& -1& 0& 0& 0\end{array}\right).$$
• Similarly, matrix
  $\mathbf{B}$ is defined to be
  
  $$\mathbf{B}=\left(\begin{array}{cccccc}0& 0& 0& 0& 1& 0\end{array}\right).$$
• Matrix
  $\mathbf{C}$ is defined to be
  
  $$\mathbf{C}=\left(\begin{array}{cccccc}0& 1& 0& -1& 0& 0\end{array}\right).$$

Handling WRITE Access

Notice that, since

$c=[p(X)]=\sum _{i=0}^{k-1}{x}_i\cdot [L_i(X)]$ is computed by Lagrange basis, to update

$x_i$ to

$x_i^{\prime }$, we simply compute

$$\begin{array}{rl}{c}^{\prime }& =x_i^{\prime }\cdot [L_i(X)]+\sum _{j\ne i}{x}_j\cdot [L_j(X)]\\ & =(x_i\cdot [L_i(X)]+\sum _{j\ne i}{x}_j\cdot [L_j(X)])+(x_i^{\prime }-x_i)\cdot [L_i(X)]\\ & =c+(x_i^{\prime }-x_i)\cdot [L_i(X)]\end{array}$$
which is a vector commitment to the vector

$(x_0,\dots ,x_{i-1},x_i^{\prime },x_{i+1},\dots ,x_{k-1})$.

Hence, to update

$c$ to

$c^{\prime }$, we simply make the addition for

$c$ and

$(x_i^{\prime }-x_i)\cdot [L_i(X)]$.

Proposal of Verkle Tree with R1CS-in-the-Exponent

Recall that a

$k$-ary Verkle tree of height

$\ell$ has

$\ell +1$ layers, indexed from

$0$ to

$\ell$, of the following structure:

• The unique node in level
  $0$ is the root of the tree and its value is denoted by
  $v_0^{(0)}$ which is a vector commitment to the sequence of values
  $(v_0^{(1)},\dots ,v_{k-1}^{(1)})$ of its direct
  $k$ child nodes in layer
  $1$, to be described later.
• For each intermediate layer from
  $1$ to
  $\ell -1$, the
  $i$-th layer has exactly
  $k^i$ nodes with values denoted by
  $v_j^{(i)}$ for
  $j\in \{0,\dots ,k^i-1\}$. The value
  $v_j^{(i)}$ is a vector commitment to the sequence of values
  $(v_{k\cdot j}^{(i+1)},\dots ,v_{k\cdot (j+1)-1}^{(i+1)})$ in the
  $(i+1)$-th layer.
• The last layer, namely, layer
  $\ell$, has exactly
  $k^{\ell }$ nodes with values denoted by
  $v_0^{(\ell )},\dots ,v_{k^{\ell }-1}^{(\ell )}$.

To prove correct opening of Mekle tree, we need to prove correct opening of each respective vector commitment in each layer from

$0$ to

$\ell -1$. Hence, in this way, we can concatenate all component of all verifications, i.e., for all opening according to a path in Verkle tree, to make it an R1CS form.

Conclusion

• We can provide a library/crate that handle memory commitment for multiple prover, especially the prove that friendly with KZG.
• The library/crate we're developing can be used in any zkVM with configurable WORD_SIZE.
• Verkle tree will redurce the overhead to commit and open at arbitrary node.
• Constructing folding scheme for vector commitment.