Given an arithmetic circuit encoded as a Rank 1 Constraint System, it is possible to create a ZK-proof of having a witness, albeit not a succinct one. This article describes how to accomplish that.
Given a Rank 1 Constraint System where each matrix has n rows and m columns, we write it as
La∘Ra=Oa
Where L, R, O are matrices with n rows and m columns, and a is the witness vector (containing a satisfying assignment to each of the signals in the arithmetic circuit). The vector a has 1 column and m rows and ∘ is element-wise multiplication (Hadamard product).
In this setup, we can prove to a verifier that we have a witness vector a that satisfies the R1CS simply by giving them the vector a, but with the obvious drawback that this is not a zero knowledge proof!
Zero knowledge proof algorithm for an R1CS.
If we “encrypt” the witness vector by multiplying each entry with G1 or G2, the math will still work properly!
To understand this, consider that if we carry out the matrix multiplication
[1324][45]=[1432]
and also
[1324][4G15G1]=[14G132G1]
The discrete logs of the two elliptic curve points in the second matrix multiplication are the same value as the elements of the first matrix multiplication.
In other words, each time we multiply the column vector by a row in the square matrix, we carry out two elliptic curve point multiplications and one elliptic curve addition.
Notation for elliptic curves
We say [aG1]1 is a G1 elliptic curve point created from multiplying the field element a by G1. We say [aG2]2 is a G2 elliptic curve point generated by multiplying a with the generator G2. Because of the discrete log problem, we cannot extract a given [aG1]1 or [aG2]2. Given a A∈G1 and B∈G2 point, we say the pairing of the two points is A∙B.
Prover steps
Let’s encrypt our a vector by multiplying each entry with the generator point G1 to produce the elliptic curve point [aiG1]1.
In anticipation of the Hadamard product becoming a list of elliptic curve pairings, we can use G2 points to also encrypt the a vector so the verifier can do the pairing.
After this operation, we have a single column of elliptic curve points in G1 originating from the multiplication La and a single column of G2 points from Ra.
The naive next step would be to encrypt the a vector with G12 points so that the verifier can pair the result of La with Ra to see if it equals Oa, but G12 points are massive, so we would rather have the verifier pair the Oa elliptic curve points in G1 then pair each entry with a G2 point. Pairing with a G2 point is, in a sense, “multiplying by one” but turning the G1 point into a G12 point.
The prover then hands the G1 vector and the G2 vector to the verifier.
The above vectors of G12 elements will be element-wise equal if and only if the prover has provided a valid witness.
Well, almost. We’ll get to that in a following section.
First we need to mention an important implementation detail
Public inputs
If our knowledge claim is “I know x such that x3+5x+5=y where y=155”, then our witness vector will probably look like the following:
[1,y,x,v]
where v=x2. In this case, we need [1,y] to be public. To accomplish that, we simply don’t encrypt the first two elements of the witness. The verifier will check the public outputs, then encrypt the public inputs by multiplying them with a G1 or G2 point so that the verification formula does not change.
Dealing with a malicious prover.
Because the vectors are encrypted, the verifier cannot immediately know if the vector of G1 points encrypts the same values as the vector of G2 points.
That is, the prover is supplying aG1 and aG2. Since the verifier doesn’t know the discrete logs of the vector of points, how does the verifier know that the vector of G1 points has the same discrete logs as the vector of G2 points?
The verifier can check for the equality of the discrete logs (without knowing them) by pairing both vectors of points with a vector of the opposite generator and seeing that the resulting G12 points are equal. Specifically,
This algorithm is very inefficient for the verifier. If the matrices in the R1CS are large (and for interesting algorithms, they will be), then the verifier has a lot of pairings and elliptic curve additions to do. Elliptic curve addition is rather fast, but elliptic curve pairings are slow (and cost a lot of gas on Ethereum).
However, it is nice to see that at this stage, zero knowledge proofs are possible, and if you have a good grasp of elliptic curve operations (and haven’t forgotten your matrix arithmetic), they aren’t hard to understand.
Making this technique truly zero knowledge
As it is right now, our witness vector cannot be decrypted, however it can be guessed. If an attacker (someone trying to discover the unencrypted witness) uses some auxiliary information to make an educated guess at the witness, they can check their work by multiplying their guessed witness vector by the elliptic curve point generators and seeing if the result is the same as the prover’s witness vectors.
We will learn how to defend against witness guessing in our coverage of Groth16.
Also, keep in mind nobody does the described algorithm in the real world, as it is too inefficient. However, if you implement it, it will help you practice implementing meaningful elliptic curve arithmetic and build a functional end-to-end (almost) zero knowledge proof.
You can see an example implementation of algorithm described here by Obront in this repo.