Next Generation ZKP System and Single Slot Finality | Tiancheng Xie - Polyhedra Network

Transcript

and one day he come across with a prover maybe malicious prover on the internet and the prover makes the following claim there's no audio yeah and there is no audio and it's supposed to be a a here so I intentionally make it a Japanese sentence and I know most of you don't know Japanese it happens in the dkp world uh whever don't actually know what the pr

is going to claim and the pr is just saying random uh trashes for example the Prov claims that his circuit is a KK crash circuit or the pro is claiming that his circuit is a sh 22556 circuit but who knows he may make F false false claims right and to verify these claims the the verifier need to need someone to help her one way to solve the problem is you leverage a trust the third party that can help you to understand the

claim and here in this example we are using Google translate where you trust Google to translate this sentence for you and yeah and in the dkp world it's usually called The Trusted setup where you rely on a trusted third party to do some computation for you to identify the content of the circuit usually it's the people use scoss system or plun to do such task however such process require a lot of provs resources and it also introduce additional trust the pro also need to do

some very uh computation extensive uh computation like MSM or fft well another way is you the ver do the work by herself in this example you learn the Japanese then you obviously you can understand this sentence but the the the the this verifier will do a lot of work to understand the pr circuit he she need to at least scan the circuit where circuit can be potentially very large so the verifier computation in this uh solution is very expensive and there is another solution

where it we are going to introduce is based on a compiler and look at this sentences you can find that there is a pattern actually in these sentences where you may notice that they begin all of all of them begin with the same prefix and by leverage this kind of pattern you can actually uh make the very first computation easier and in this case you are going to actually going to translate one sentence and you're going to understand the rest so let's dive into the technical details

where here is a example Circuit of computing a very simple uh computation but if you compile the circuit you will find that this comp this compiled circuit this RCS compiled circuit is actually very large it's on the orders of 100 megabytes but the source code is actually very small very very short and you may already notice that the source the majority of the source code is doing this computation it's just a simple multiplication where you can express it with several bytes instead of 100 megabytes so the verifier for for the

worder to understand the circuit she doesn't need to look at the circuit the compil circuit itself where potentially it can be 100 megabyte she can look at the source code or in our term it's the hint from the compiler where compiler will tell you that this circuit is just simply uh repeat this sentence so here I'm going to anounce our revolutionary compiler where we don't have a off official name for it I I would tentatively call it log compiler because we are inspired from this ter it's called log space uniform

circuit and the circuit is actually the loog space uniform circuit is actually described this uh property where the circuit can be generated from a very small program and our compiler will initially support genox front end language at during the lunch and we will gradually expand our compilation to plank key Halo or Circle or even more and our plan for this open source is projected to be on May 2024 together with all approver so it's not only the compiler it's going to be

end to end Pro Tool chain so the overall architecture of this compiler is the following you take the programming language is described by a go language and you pass it to the Circuit compiler and the circuit compiler will output a circuit that has special structures special substructures and the for the verier to understand the circuit it only need to look at each individual Subs a subcircuit instead of look at the whole circuit itself so the rare can save the computation by orders of magnitude

and this new compiler potentially could enable a recursive snark where because the warier circuit is ERS of magnitude smaller so we can directly recurse on this Ware and and make everything infinitely recursive so oh okay let's talk about PR part we have the we have also the state-ofthe-art pr where it's a gkr based Pro and can operate more than 3 million constraint per second on a single CPU B 254 and here is the overall structure of

the approver where on the on this side this side the approver this aover on the middle side is proof structure and on the on this side is a verifier so the end to endend experience is like it's like you write a circuit program you execute it on our approver and the finally you can verify this proof on the Ean chain so that's okay that's never that's has never done before in this scale we can verify be in size circuit on

chain yeah thanks uh so if you really want to look at our documentation you you can look at the paper we PR represented and it's called Libra and pianist two papers and you could if you look up my name you can you can search these papers so these are technical documentations we can provide right now and after we open source of code you can look at the code directly another nice property is we can infinitely hor horizontal scale where

you can add a lot of machines without any overhead and let's let's let me explain why other people cannot do this and why we can't do this so if we look at fry protocol the fry protocol has a problem where it relies on the fft pro fft but fft itself has a problem of this distribut Computing where in the middle of fft if you look at it there is a linear size uh communication between machines where we in our experiment if you look at subcircuit of size 1 million and if you look at 200 machines they are

going to communicate gigabyte of data if you use fft or fry and this is not possible to decentralize you can only place this machines in the same I mean in the same data center to achieve this distributed computing we modify the fry we actually place the fry in our Prov framework we use the B kdg introduced by our one of our previous paper it's called pianist and this is very I mean this is too technical to introduced here maybe you can take a screenshot or take a photo

and so the nice property of this B kdg is it replace the fft okay if anyone want to a photo just do that so we replace the the the fft using this new polinomial commitment scheme and the nice property is due to the kdg the nice property is we only require constant communication between different machines and if you combine with the gkr protocol we in approver each node only need to send or receive in total 100 kilobytes of

data which you can I mean with 100 kiloby of data trans communication you can basically decentralize your prer globally so let's talk about decentralization and we did a experiment on verifying 200 uh sorry 20 uh 32 k k signature and the result is pretty uh impressive we only take five to six second to do that and the hardware requirement is going to be 64 of these machines handheld

machines globally distributed and well in the experiment we don't globally distribut this we just connect to the same Wi-Fi but we observe that the data transmission is very low and we think it's possible to globally distrib this machines so the hardware requirement will be very minimal and it can potentially enable uh I mean enable a new diagram where bators can purchase a very cheap machine and join the network to collaborative do proing next is about a new proposal actually not so new we proposed in last

year and so it's all valids in one slot where in current Insurance solution we have almost 1 million validators and due to scalability of is they cannot process 1 million validators in one slot they have to divide into 32 different slots where each slot has only uh 30,000 right daters and this can cause problem because people need to wait for a lot of slots or blocks to get a final to get a confirmed in this simple example you

need to waste three slot to get your transaction confirmed and in real is certain you need to wait for like 20 slots to get your transaction confirmed the problem is they the PTP network is get somehow get overloaded if you if you put more committee members into the P2P Network and we use our signature verification algorithm where can batch the signature into very small proof and instead of sending all the public Keys all the bit field in the uh I mean in in the network you can send a small proof so it can reduce the P2 the burden on the P2P Network and finally

you can achieve a single slot finality and that's all about this talk thanks so much and this is our official website there's no stuff here