# How to Design a Better Proof Recursion Scheme

Nearly all of the problems encountered in the ZkRollup or zkEVM tracks can be attributed to algorithmic issues. ZK-Proof hardware acceleration is often mentioned because current algorithms are generally slow. To avoid falling into the embarrassing trap of “the algorithm is too slow, the hardware is used as a substitute”, we must solve the problem by looking at the core of the algorithm. This problem can be solved by designing a delivery-proof recursion scheme. With the rapid development of smart contracts, more Web3 applications are being released. The transaction volume of Layer 1 such as Ethereum is increasing rapidly and there may be congestion at any time. It is now a pressing problem to find a way to increase efficiency while maintaining Layer 1 security. zkRollup uses the zero knowledge proof algorithm to move the complicated calculations that were required to be done on Layer 1 off-chain. This provides proof of execution accuracy to the chain. This track includes projects like StarkWare and Scroll. Each zkRollup project improves the architecture and algorithm to ensure a short proof length. Fox, for example, has combined the most recent zero-knowledge proof algorithms with its proof algorithm FOAKS to achieve the shortest proof time and longest proof length. In order to improve efficiency, the first thing everyone thinks of is to pack multiple proofs into one proof, commonly referred to as Proof Aggregation.Intuitively speaking, verifying the proofs generated by zkEVM is a linear process, and the Verifier needs to verify each generated proof value in turn. This verification method is not very efficient and has a high communication overhead. Higher verifier-side overhead in the zkRollup scenario will result in higher Layer 1 calculations. This will also mean higher Gas fees. Alice wants to prove that she visited Fox Park between the 1st and 7th of each month. In general, proof aggregation refers to connecting multiple proofs together and verifying them in a linear sequence. This means that the first proof is verified first, then the second. There are two proofs and subsequent ones. This approach does not change the proof’s size or time, which is the same thing as verifying each proof one at a time. Logarithmic space compression is possible with the Proof Recursion method. Consider merging them. Alice could take a photo of the 1st, then take the 2nd photo and the newspaper 2nd. Then, she would take the photo of the 2nd photo and the newspaper 3rd. Analogously, Alice took the 7th photo with the photo 6th and the newspaper 7th. Other friends can verify that they are in the correct order when they see the 7th photo. Alice and her friends all went to the park. The proof photos from the previous seven days have been merged into one. This process requires the ability to “photos containing photographs,” which is equivalent of recursively nesting previously taken photos into newer photos. This is different than putting together many photos and taking just one photo. Each transaction will generate proof. We set the original transaction calculation circuit C0, P0 to verify C0’s correctness, and V0 to calculate P0. Prover also converts V0 to the corresponding circuit, denoted C0′. For proof calculation purposes, C1 from another transaction can be used to merge the circuits of C0’ and C1. Once the correctness proof P1 for the merged circuit has been verified, it can be used to verify the above two circuits simultaneously. The transaction is verified to be correct, or the compression. We need lower-level optimization and innovation to improve efficiency. FOAKS, an algorithm developed by Fox, does this by using recursive ideas within a proof to this end. FOAKSFoxTech is a zkEVM based zkRollup project. The proof system also uses the technique of Recursive Proof, but the connotation differs from the recursive method. Fox uses the idea Recursion within a proof. This is the main difference. To express the core idea behind Fox’s recursive proof, which allows them to continually reduce the problem until it is reduced to a manageable level, we need another example. In the above example, Alice proves she went to Fox Park on a particular day by taking a photograph. Bob offers a different suggestion. He believes that the problem of proving Alice has been there can be reduced to proving Alice’s mobile phone was there. This can be done by proving that Alice’s mobile phone’s location is within the park’s reach. To prove Alice has been to the park she needs to send a location from her mobile phone while she is there. This allows the proof to be reduced from a photo (very large-dimensional data) and converted to 3-dimensional data (latitude/longitude and time), thereby saving money. This example is not entirely appropriate because some people may question that Alice’s mobile phone has been to Fox Park does not mean that Alice has been there, but in actual situations, this reduction process is strictly mathematical.Specifically, the use of Fox’s recursive proof is recursion at the circuit level. Zero-knowledge proof involves writing the problem into a circuit, and then calculating the equations that must be satisfied by the circuit. Instead of proving that these equations are satisfied we will write them as circuits and then calculate the equations that need to be satisfied through the recursive process. The complexity is O(g(n)), then the total computational complexity becomes O1(n)=O(f(n))+O(g(n)) after one recursion, and O2(n) after two recursions )=O(f(f(n)))+O(g(n))+O(g(f(n))), after three times it is O3(n)=O(f(f(f(n) )))+O(g(n))+O(g(f(n)))+O(g(f(f(n)))), …, and so on. Therefore, such a recursive technique can work effectively only when the two functions of f and g corresponding to the characteristics of the algorithm satisfy Ok(n)<O(n) for a certain k. In Fox, this recursive technique is effectively used to compress the proof complexity.The recursive proof scheme used by ZK-FOAKSConclusionThe complexity of the proof has always been one of the most important keys in the application of zero-knowledge proofs. As the things to prove become more complex, particularly in large ZK applications such as zkEVM, the nature of the proof complexity will be more important. The complexity of the proof will have a significant impact on product performance as well as user experience. The optimization of the core algorithm is one of the best ways to reduce the complexity and complexity of the final proof. Fox has created an exceptional delivery proof scheme that is based on the most advanced algorithm and uses this technology in order to create the best zkEVM. The ZK-FOAKS algorithm will be the most successful in the zkRollup market. We encourage you to do your own research before investing.Join us to keep track of news: https://linktr.ee/coincuHaroldCoincu NewsTags: Fox TechHalo2Proof RecursionScrollSTARKStarkWareZK-ProofzkEVMzkrollupZksync