Zeromorph
Presentation: https://www.youtube.com/watch?v=vFuqRHEjv5k
Introduction
Aztec uses Sumcheck to prove the proof of circuit satisfiability. In Sumcheck, a multilinear polynomial is used. Therefore, it is necessary to efficiently commit to and open this multilinear polynomial. Additionally, since Aztec is a privacy-focused Layer 2, an efficient way to achieve zero-knowledge (ZK) is also required. To address this, Aztec introduces a method called Zeromorph, which is currently implemented in Aztec Zeromorph.
Background
KZG
:
The verifier checks the following equation:
Here, the verifier learns the information , which presents two issues:
Since KZG is a computationally hiding commitment, if quantum computing becomes feasible, revealing may no longer satisfy the ZK property.
While it proves circuit satisfiability, it also reveals information of the polynomial with .
Hiding KZG
Instead of the naive KZG scheme outlined above, Zeromorph uses a more secure variant named "Hiding KZG."
:
The prover samples .
The prover constructs .
The prover can send only to the verifier.
:
This checks the following equation:
:
The prover samples .
The prover provides the verifier with and :
:
The verifier checks the following equation:
Proof.
This is only satisfied iff .
In comparison to naive KZG, HidingKZG's verifier learns of an additional that allows HidingKZG to stand up against the issues of naïve KZG in the following ways:
Since HidingKZG is a perfectly hiding commitment, even if quantum computing becomes feasible, revealing still satisfies the ZK property.
However, it still reveals while proving circuit satisfiability.
Later in this document, we explain an additional trick that ensures that only information about circuit satisfiability is revealed.
During the presentation, 이태훈asked a great question: "Why isn't the blinding technique introduced in the Plonk paper sufficient for the ZK property?". After internal discussion, we concluded that it requires more randomness and does not provide protection against post-quantum threats.
Multilinear Polynomial Identity
Zeromorph requires the use of the Sumcheck protocol, which is reduced to an evaluation claim for a multilinear polynomial :
where and .
By Lemma 2.3.1, The multilinear polynomial identity is defined as follows:
If there exist as defined below that satisfies the above, then .
For :
For :
Proof:
If , equation reduces to the following univariate polynomial identity:
Thus, if , then .
If , is divided by results in quotient with remainder as follows:
The polynomial has a degree of at most 1 in all variables. Therefore, must have a degree of at most 1 in , and a degree of at most 0 in . This implies . Using this information and recursive decomposition, we derive the following:
Iteratively substituting all the equations above yields:
Therefore, by equation , we confirm .
Computing
According to Lemma 2.3.1 in the Zeromorph paper, can be computed as:
Example:
Let's calculate , the quotient from dividing by :
will be evaluated as follows:
will be evaluated as follows:
Subtracting equation from equation allows us to compute as the following:
Now we can see that can be decomposed as the following:
The validity of this statement can be ensured by multiplying all terms out
Verifying the Multilinear Polynomial Identity
Verifying equation requires pairing operations, which imposes a computational overhead on the verifier:
Additionally, must be verified, which will be checked using the degree check protocol introduced later.
Protocol Explanation
Multilinear Polynomial Identity using Univariate PCS
To efficiently verify the multilinear polynomial identity, we first define the following mapping:
Given defined as:
the function transforms the following expression:
This seemingly expensive operation actually introduces no computational overhead. This is because the witness generation process for constructing a ZK proof already outputs polynomial evaluations, making this mapping essentially free.
If is a constant function, we can compute:
where is defined as:
This satisfies the following equation, meaning that evaluating at any point requires only multiplications and additions:
For example, if , we can compute:
Applying this mapping to both sides of equation , we transform it into:
Since is a linear isomorphism, satisfying equation implies equation is also satisfied. Instead of using a multilinear PCS to commit to , we can now use a univariate PCS via .
Next, we analyze how the verifier can efficiently verify the claim. The prover will commit to and , while can be easily computed. The key question now is: how can we efficiently compute ?
By Lemma 2.5.2, let and define . For , if , then , where .
For example, if and , then can be computed as:
By Lemma 2.5.3, if , we can compute:
For example, if , and , then multiplying by gives .
Thus, when , both and evaluate to 0. When , takes the same value as .
Applying Lemma 2.5.3 to equation , we transform it into:
At this stage, the verifier must check whether . We can verify this using through a degree check protocol. by substituting Lemma 2.5.2 into equation , which results in:
Since is defined as:
we can simplify:
Applying this to equation , we obtain:
Now we can define using equation (5), which is partially evaluated at on as:
Then the prover needs to commit to this polynomial . If the prover sends to the verifier, then the verifier can verify using 3 pairing operations with .
Note that since only is opened for , it is now possible to prove circuit satisfiability without revealing any additional information.
Degree Check Protocol
Single KZG Degree Check
Let's construct a protocol based on that verifies whether a given polynomial satisfies .
:
The prover samples .
The prover provides the verifier with :
:
The verifier checks the following equation:
This is satisfied iff .
Soundness Proof:
Suppose . Then, the degree of is at least , making it impossible to commit to .
Completeness Proof:
:
The prover samples .
The prover provides the verifier with :
:
The verifier checks the following equation:
This is satisfied iff .
Soundness Proof:
Suppose . Then, the degree of is at least , making it impossible to commit to .
Completeness Proof:
Batch Degree Check
Now, let’s consider a set of polynomials and their respective degree bounds . For , each belongs to , and we aim to construct a batch protocol to verify whether .
First, we choose . Let and be the set of commitments and randomness corresponding to .
:
The verifier samples and sends it to the prover.
The prover computes and sends it to the verifier:
The verifier samples (where ) and sends it to the prover.
The prover samples .
The prover sends to the verifier:
Here, is defined as:
The verifier checks the following equation:
The commitment is defined as:
This is satisfied iff for .
Soundness Proof:
Suppose that for some , we have . Then the degree of becomes:
which leads to:
making it impossible to commit to .
Completeness Proof:
In the above protocol, we designed the batch degree check using the protocol. However, as discussed in Section 5.4 of the paper, this method is applicable in a more general setting, provided that:
The commitment scheme satisfies additive homomorphism.
The evaluation protocol is knowledge-sound.
These conditions allow the batch degree check to be used in other polynomial commitment schemes as well.
Batch Evaluation with Degree Check
Now, let’s consider a set of polynomials and their respective evaluation values . For , each belongs to , and we aim to construct a batch protocol to verify whether and .
Let and be the set of commitments and randomness corresponding to .
:
The verifier samples and sends it to the prover.
The prover samples .
The prover provides the verifier with :
:
The verifier checks the following equation:
This is satisfied iff for .
Soundness Proof:
Suppose that for some , we have . Then the degree of the expression:
making it impossible to commit to .
Completeness Proof:
Put Together
To summarize, in order to prove , we transformed the problem as follows:
Now, let's prove the above equation using .
The prover computes commitments for , and sends them to the verifier.
The verifier randomly samples .
The prover computes for and sends the commitments to the verifier, where:
The verifier randomly samples (where ).
The prover samples .
The prover provides the verifier with :
Where the values are defined as follows:
The verifier checks the following equation:
Where the values are defined as follows:
Completeness Proof:
Analysis:
(structure reference string) size:
Prover work:
To compute each , it takes operations.
To compute , it takes at most operations. This is because has nonzero coefficients ranging from a maximum degree of to .
To compute , it takes at most operations.
To compute , it takes operations: .
Proof length:
:
:
Verifier work:
To compute , it takes operation.
To compute , it takes operations.
To compute , it takes operations.
To compute , it takes operations.
To compuete , it takes operations.
Here, represents MSM operations in , represents addition or multiplication in , and denotes a pairing operation.
Shift Evaluation
In permutation arguments or lookup arguments like Plookup, computing the evaluations of shifted polynomials is necessary. For example, if has the following evaluations:
then the evaluations of are:
Applying the mapping results in:
To prove , we construct the following equation:
and demonstrate the existence of a suitable satisfying:
Applying the transformation from equation to , we obtain:
Multiplying by , we get:
Thus, multiplying both sides of equation by , we obtain:
Since equation holds, we can prove that is indeed a shifted version of by committing only once to and then using it to verify the evaluation claim of .
If , the protocol simplifies even further! While the referenced paper discusses high-degree shifts and batched verification methods, these are omitted here for brevity. Interested readers are encouraged to refer to Sections 7 and 8 for more details!
Conclusion

The multilinear polynomial identity originally required pairing operations. However, thanks to mapping, the verifier can now perform the expensive pairing computation in just three operations.
Meanwhile, to prove that is bounded by a certain degree, the degree check protocol must be executed, which requires an proportional to in and . Fortunately, the verifier does not need to perform the costly operations.
Additionally, an important point is that for hiding, only elements in are required.
References
Last updated