Privacy preserving statistics: ZKStats and MPCStats - ZK Jumpstart Series #2

Transcript

um Kevin would you mind to share your screen and then meanwhile I will start the record yeah sure um let me share the screen um Okay can could you see it yeah see my screen okay cool um so hi everyone um so J and I are working on this project and um this is the outline for the talk today so first I'll give an

introduction to our to what we are doing and our goal and the directions and then Jour will talk about the DK stat Library powered by the zkp and it's our it's also our first attempt so our first project and then um I will keep talking about the MPC stats Library which is our current focus and it's fared by the P the MPC yeah and then um after that is the next steps and then the potential future directions so um

so privacy preserving statistics so it's um it's a framework we're building so for user to ask the providers for to perform statistics computation so for example um there are data providers and data providers has data and user can ask the data provider about the statistic result of the data for example um the median of each column and then the average something like that so in this case dat provider will just do the computation and result

is returned so um what is difference um different from the usual database is that um so um user can can be convinced the result is correct so um user knows that the result is not something the provider randomly return and to achieve this data provider doesn't need to reveal their actual data so and nothing is revealed so um it's the our goal of our project so um we want to lower the barrier for average people for everyone

to to use pracy preserving statistics so um it's open source and we our Target is to make it user friendly and um about the use case we're targeting scientific research so people can do statistics operations on the medical and financial data Etc and um we hope as we build this this framework we can onboard more users to use the Privacy preserving statistics and it's possible we can enable more use cases in the

future and um so we have three major directions so as we we as I mentioned um the first is the St diary so user can query to one t provider so as this diagram shows and um we had we have a draft Library so we have a first version of library that people can use so we support 12 statistics operations and data filtering so um it's already usable and yeah and the second direction is the NPC stat Library so it allows user to query

computation to m multiple data providers and it's powered by NPC and also our Focus yeah and um and the third one is the platform so we want to we want to build a web application powered by these two libraries and um it will allow data providers to advertise their data sets and user can um can search for the DAT set and send a request to the data providers and get the result so um it's it's also ongoing and our grantee p is working on the

this so um in this talk we will focus on these two directions SK stats library and NPC stats library and um in the next slide um J will talk about the DK Library yeah um so I'll hand it over to J all right thanks very much Kevin and yeah let's talk more about CK stat Library so let's let's look at the broader level first right so we have two parties here users which is basically the one who don't have access to data

right but they can be analyst they can be student they can be the one who interested to get some insight from the data which in this case we call it confidential data sets because you cannot just provide it all like raw data publicly right because of maybe of the regulation maybe of the proprietary data like confidentiality of that and this all confidential data is like hold or like owned by the party called Data provider again as Kevin mentioned right our first step is to make the protocol work with just one data provider so basically we just request all the statistic computation from this just one provider but again like we mentioned one provider but it can be multiple data set right so it can be data set one two or to n or something like that so basically

we can request statistic computations so users will basically like see like oh which data set that I would like to request some statistic computation on and it can be mixed between like different data set right some data set may have like different shape different schema it's fine as long as is come from one data provider so yeah the flow is basically like user request some statistic operations on this data set that they're interested in and then data provider and our platform right the CK St Library basically allows the users to receive a verifiable result which is like when we mean ver verifiable it's just like we need to make sure like we need to convince users so that like this result that they get actually come from the data set that they want and they

actually perform a statistic computation that the user request so seeing these pictures right there are few trusted assumptions in this protocol and the first one is that like if we say about confidential data set right basically public just see this as just a encrypted format right just like some random number from encryption right so how how can we be sure that the data is really what it claims to be right let's say data set one it say like public data like the Health Data of this demographic in this certain city how can we be sure it's not just data provider don't just put some gabbage into the data because it's encrypted right and then the second part is that make sure that the result comes from the user defined computation because that's what the user is

interested in and then making sure it's the defined computation on selected data set which can be more than one right as long as it come from the like single data provider so basically the first part is very tricky because we would say we trusted by trusted party and what we mean by that is basically let's say this data provider is let's say if it's like B by law to not show This Confidential or this trusted party can be government and all they do is to basically to making sure that like this data set one that they claim to be let's say some health like data of this like people in this demographic in this city they just like need to make sure that this is the result from the true data that encrypted into that so I think like we think that this is makes sense because like it

making sure that like the data provider just don't put gra to it and that this translate party already know data so it's is f to like have like check and balance here to make sure that this confidential that is really what it is right but then the interesting part is that like to make sure that the result come from the users defile computation all on selected data set this is where the Cs that Library come in so let's see how we do that and if if you see the flow here right there's a huge gaps yeah basically like how to communicate about like how to say that oh I want this certain statistic computation which can be complicated right you can just ask some mean but you can also do some linear regression you can ask like mean of median of different data set this

stuff so basically want to have some share format to represent computation so that the users and data provider are on the same page so that understand that cool I want to compute or like I want to request some computation over my data set and actually there's a lot of format in noway world and we want to make sure that we leverate the one that is existed already and we actually decid to go with onx f which is the format that people mostly use it for the neural network and we think that like neural network can be applied to in this case because like even though we don't need like some like really deep learning or like deep multiple layers we can treat each layer as some like layer of like computation of statistics right let's say if you have like want to request some mean of

data you can treat one layer just like mean layer but then if you want to have like multiples like complex like statistic computation you can treat different operation as different layers let's say like mean of median or like regression of a media or something like that so we think Onix f is a good format to to work on so that like it can communicate between users and data provider What statistic computation or from now on we would call computation graph that they want to compute on data and luckily when we think about this that frame this problem in this way we find out that there's actually a project called eckl which is a also open source project that they given Onix format they can create the CK proof for that so basically like right now we just want to

make sure that like users can Define computation graph which can be exported into onx file and then from that point we can use e k which is another library to create Z knowledge group for that so let us like look closely at this like workb and see how that goes right so now we have users and have data provider again like data provider commit to data right so that they just have raw data and then create a commitment of that so to make sure it's just like private right the public just see the commitment and then the trusted party verifi that data provider doesn't put gabage as we talked before right and then the user just requests for data commitment right oh I want to know some inside of this data set and then what data provider what the platform or the library provide is basically show them like the data

shape and the schema so that user know that oh cool this like Excel far like have this column may have weight of people have like height of people or those stuff and the DAT data shape is pretty like important because in like onx f is pretty like fixed in the terms of like the shape of like the input so this is called information but basically this flow is just for selected data and to making sure the data provider commit to uh true data that they like really like honest about that and then from this point onward right this whole flow basically is just defining the computation CFT we can do multiple ways of this one like no Briner where is like just Define the computation and then send like code of the computation to data provider right

and then like both of them can like convert computation into pyto from pyos to Onix SP but again like we already talk right that we have the things called like share format Onix right so basically we can just skip all of these things into just like making users defy computation and Export into onx f and then send onx file into Data provider so can shorten this step there's a few trade-off though because like most like things cannot really read on SP that clear so basically like in this case right because the whole point of this project is to make sure that the user obtain the data like some insight from data provider without leaking data right so it's really dangerous let's say if the user Define computation like oh give me like first 100 raw data like of this

data set right and then if data provider is like automatically and then like they just like oh cool approve that that can leak right so the benefits of using like sending the raw code of this so that data provider can just run them locally and then say like oh like what's the result or like what's the logic behind this computation graph right because it's arbitrary it's like statistic function but you can shape it or like you can manage it to be like again like mean regression mean of median like geometric mean whatever right so yeah so this step is basically just to define a computation graph and set it out which can be just sent into onx or you can just set a huge code but it's pretty much the same not not a lot of work the work here is and on the later half is

this is all the ckp right so this one is again luckily because we use the Onix format it can be handled by E so the logic here is pretty simple both party has the same onx file on the user and use e to generate verifier which is really critical that it needs to be done on user right because they need to be sure that like cool I want to create the verifier that we verify yes if this like proof making sure that it's come from the data I select and it come from the same computation graph that I want which is the request computation and on data provider it's the same thing it just create the proof and then yeah send the proof here the verifier verify the proof and yeah just making sure that the data commitment is the same that the data set

that we selected right to make sure that data provider use the same data that the user prefer it looks fine like okay cool we we can like do stuff we can use ezl once we frame the problem this it looks fine but yeah what what are some challenges right so basically like there's a a few that I think is really like worthy to mention here so some challenges with the if is that like again their library is that is really good they given on SP you can create ckp but again like in this case user need to write their Pou computation which can be export to onx F right however a lot of operation in onx like on onx format is not really supported by e in the ckp and that can be limited to some of how like

Onix F processes so basically like some function is tricky like if F statement like it is pretty tricky to represent that and in ckp from onx f is really onx F pretty much like represent misleading information something like that so we want to make sure that like when allow users to write statistic function they don't come up with eror right so we just want to make sure we just write rapper function so that users can call like almost like we we make sure to support like python statistic operation so it's like mean geometric mean harmonic mean like this right median mode those stuff so we want to make sure that like users can just call a bit ear so first thing is that we need to write a rapper so in this case you can see right like you can just this is all the user need to do

like they just write some computation graph which is this is just like python so basically again right we can request from multiple data set as well as long as it come from the same like one individual data provider so in this case what we do is basically we call like cool we want to calculate median of this data set and then median of this data set and then calculate mean of this data set and yeah this rehap thing is just some tricky things to do with this here it's not a big deal but basically you can just put it at the end of the result so basically the code is pretty simple you can just like call median median mean and done and that's that's the first thing that we just make sure to write rapper because it's not like one size with o solution so we want to make

sure we write some custom function to support this thing and yeah this is how C we make sure to cover all like eligible python function stack function in Python Library more interesting or like more deeper like ckp related so if you guys know about like C proof right the the botton neck is that it's like it's really slow to generate proof and the botton neck is that like the circuit size can blow up really really fast and when when talking about circuit right the thing that represent in circuit is pretty much the field number which is field element which is basically the integer right so it's pretty tricky it you cannot just represent floating number or like decimal in in circum or like those stuff it's R so the way we handle with floating number which will be our favorite number for statistic

operation right a lot of floating number Point like and it's really matter so the way we do that we need to scale it up so basically like given let's say you have like 1.5 right as a number you need to scale into integer in this case it's easy right you have to times two or something like that but if you have some weird decimal you have like 1.13 26 something like that you need more scale up and when you scale up it's kind of like screw up the circuit because you just SC up everything and the circuit start just blow up so much and then this thing like apply as well for like division for like exponential like all this stuff that you actually need some look up table so that it can just like fit this like possible result from nonlinear function right because

nonlinear function like e to the something is just like really like huge and the circuit can blow up so here here was the solution that we like think and we already tried out and we implemented that usually improve it so instead of computing the result directly in this case let's say if we compute some nonlinear function like geometric mean so what what how do we do that right we just multiply everything together and we take the end root of that instead we just pre-calculate the result with mean that like we calculate this result outside of the circuit just like use normal computer to calculate the result and then just prove that it's actually within the acceptable calculation error of the real result so that like the good thing is that like we don't need to actually like calculate it inside the circuit we just calculate it outside the

circuit and then have the proof that it's actually within accept calculation and why why does that save like let's look at the example of geometric mean so this is naive things right so this is pretty bad like let's say if this number each number is like let's say thousand and you have like thousand of it like thousand to the thousands exponential power that's like blow up look up cable the C is really big and again like this this one over and root is pretty bad so yeah yeah sure we can optimize it to become like more naive version so that yeah instead of like multiplying huge number we can take log of it we can have e to the something but but this still blow up right because e to the something is is still like it's still non linear function and it's the blow up and the

division again what division bad is because it cost floating number which we need to scale again like some anything go up with division is pretty set because we need to scaling up because again zero knowledge proof doesn't really support like soting element so the way we do that is basically just calculate this as a result so we call it's really R right is the pre result and then we want to shake that like this result is actually within like some percentage acceptable percentage error from this right so basically we just calculate this like IES and then making sure it's the same like close enough to this thing and then to prove that they quite similar it's really like you don't need to actually calculate that right in this case you don't want to calculate e

right yeah that's far you can just take lck of it so that this like look ugly like formula it's basically just like com making sure that like this R is on really close error from this thing but then like you can just like get rid of e by picking lck on both side you can get rid of the division by take like multiplies n on both side other stuff so this equation just make it really easy for Z knowledge you don't need like e to the something you don't need to have division you don't need to scale like this stuff so we making sure that like all of our support stat function is like instead of calculating directly and things get worse right when like you do like standard divion like all harmonic mean which is like a lot of division and stuff we just want to make sure that

like we write each of that function into this term that's just like save the cost in the circuit and efficient more efficient uh last but not least that I want to mention here is about uh filtering right because like the data set will be useless if you cannot filter like let's say you have like X and Y column and you don't want to just like consider some stat function or like some inside of this like eight column given only like why great like less than this and and in Python it's really easy to write that like you can just like write this and then it just filter out for you but then this is really hard because you cannot put this into zero knowledge circuit why because like in the circuit they need to have predetermined size of this everything right and then if you

like have X have y as a input to circuit and then you calculate this thing inside Circ CC like the circuit doesn't know before like what's the result of this right like let's say x may be like 40 rows and they they don't know that like the result of this will be 20 rows or like 10 rows or something like they don't know how many numbers so it's pretty hard to to do that it's actually impossible because in ckp in zge Pro you need to make sure that you have preer size right so yeah the solution is that like instead of just allowing people to do that we just again need to write a wrapper function of this filtering and this wrapper function basically need to make sure to preserve the size because the Z proof need to have the cre mean size so basically yeah

let's look at example right let's say we have X here which is like just like six numbers and then like let's say filter x given like for X greater than it this is just a rapper function right and then yeah instead of like getting rid of everything and become just like three size array that that's that's not possible for for for ckb so we just like replace the non like non-satisfied like element into like some number M so let's say M can be any arbitary number that's unlikely in data set right and then from that like which like statistic computation you use after that you can just like substitute M to be that like corresponding number like when you mean like let's say mean right for mean you basically just need to sum everything and divide by the number and then in number my God in

number sorry in number you can like in this case you just put like M as z0 Z and then you can sum everything and divide by three which can receive for by counting non M number here right but then again like it can be different we we use M here because like if it's like let's say like mode or like median right this like M can be something else right like for for mode it can be like some random number to make sure it's not like the same as the real mode for like standard deviation you need to make sure it's become like the mean of the data so that it don't like add change the value because the challenge is that like we still need to have the same size but we want to make sure is that like given the same size we will still result in the

like Cor like statistic operation so yeah I think that's pretty much take away from CK stats but again I think we think that CK stat is not the end goal because even though we can request like arbitr stat operation on multiple data set it still just require one data provider right so in order to making sure that we can continue this with multiple data provider that's why we further develop into NPC stat which we have Kevin let's speak on that um thanks for J about the the intro introduction to St library and um yeah I for a question then I think we kind of

like in the stage so if anyone have a question for uh what Jour just shared uh you can ask now or uh you can raise your hand or you can put your question in the chat yeah hello yes please yeah so I wanted to just get back what he was talking about how how he soles the part a user can query like let's say give me the first 100 rules I also thinking about that as as an ed case like he can get the information he was talking how like he Sol I didn't really get it from him know if you can

just go through it again like briefly uh you mean like how to prevent data leaking from some computation like request right exactly exactly okay yeah yeah so basically like right now we it's pretty like non-automated because we think that like it's still not the best way to like I mean we can always have some algorithm to filter that right but it's actually no road map but to be to right now we just making sure that on the data provider side they can see the code like they can understand the comp station graph really easily so that they can like see that oh this this guy just obviously require some raw data like some raw data plus one or something that so I think solution right now is that in order for this whole process to work like the data provider actually need to click approve it's not like

automatically approved by our system to to send the request like result to that so it we just make it easy for data provider to see like what is requested and they need to manually click it right now okay okay good go that uh I think I saw this question are you already collaborating or building this on top of any ckp network can you can you clarify what do you mean by any ckp network like blockchain like like lha yeah I mean if you you guys mean

blockchain we don't really put put this all this thing blockchain yet it's just like library in like cryptography Library yeah okay uh we still have time for some question if not we will continue the talk right now we will just wait one more minute and uh question yeah please yeah so I wanted to know if like why like why they didn't try it in this way I understand that you can use on f p but like maybe if you use like something

like a l that will turn it into like an SQL query kind of then you can now know okay maybe you can Blacklist certain things about the SQL query so that then prevent the data leakage like maybe you know okay if this means that you're getting this amount of information that you feel like you're not supposed to give out and you just Blacklist that with a red kind of like prevent from yeah good good question actually it's funny because we we consider a lot about SQL so like first project is called Pro SQL but yeah actually when we think about onx F we think about like how how to make adoption like easier and we think like the data size Community

just offset about python so that's why we thinking that like maybe it's easier to unb people to to like statistic on the basis of like people who already use Python but yeah on SQL side I think we can use that as a like pre like to modulate data first right and then get into the PIP L and then like after that we can do statistic on top of that but yeah cool okay great thank you J and for the and and the question as well I think we will move on to the next one Kevin okay um thanks for the question um and I'll keep going so um about the NPC stat Library so um it allows user to carry to multiple data

providers and it's powered by NPC multi party computation so the technique um introduced in the last um is that in the last talk in this series and uh yeah so um when using NPC data providers um their data sets are the private inputs and um user will run the NPC with the data providers on this computation on the user defined computation and after that the users can the user can learn the

result and um and we we want to support data cont that's concatenating and joining so for example in this computation um data zero is from the provider zero and one from one and they can beated and um calculate the mean and in this example so it's it's calculating the average BMI where the height data is from the data provider zero and weight is from one so they can join the data sets on the ID and then computer

average so um how we are building NPC stat Library so um so our first step is to start with the framework called MP spe um so with this framework we can we can Define computation with their python DSL so for example um here we read the input from data data provider zero and another input from one and we can just do the um addition and multiplication and reveal the result and um npcps also support many

MPC protocols So based on um given different security models they have different um MPC protocol implemented so um once you define the circuit once you define a um computation you can run it with different NPC protocols by just changing your comand so it's pretty easy so um we decided to use MP speeds for now because um the the their DSL with the DSL we can support all of our statistic operations and data filter

ring and yeah and um and after we Implement all of the functionalities we just run the computation um we can just do the benchmarks with different NPC protocols and then we can um based on the based on the benchmarks results and the settings we want we can determine which NPC protocol to use so um after deciding the framework NPC framework we want to use well then um we can start to implement our MPC

stat library and and um we found that um we can reuse our ZK stat Library we um journ this um introduce before so um so it's the flow for the Z Library so it's in it's written in pytorch and transformed to onx and then hello to as a proven system so um we can reuse it just by transform it um from onx to kiras to circum into the arithmetic

circuit that the um circum to a r c def Define so um these um path are possible with these um tools but we we still need to confirm but in theory they they are working and um after we have the arithmetic circuit so um the arithmetic looks like this so it will be a sequence of gates and um we just need to write a loader so for example MPC MP spe loader so the the loader just cars this circuit and um do

some pre-processing and um translate the circuit into the corresponding code in mp Speed DSL so for example this is ADD and more so we just add we just write a translator loer um translate these into the corresponding operations in their DSL and then we can use we can translate you can get the translated um circuit in mpb DSL so um if you're interested you can check this QR code out so we have some um we have some code but um we

haven't sorted it out yet but it is working yeah so um with the past in the last page um there is some advantage for us so for example we um we only need to write oh we don't need to write the um NPC stat Library again because we already have it and um so we we yeah we don't need to implement it um for many times and if we want to support a new backend we just need to write a new loader so for example we support MP speed we have a MP

speed loader and MPV then we have a mpz loer and Etc so um they are they will work pretty similarly so doing something like this so um this our next steps so um we will still focus on the NPC stats and um we will finish the flow the the path we mention by reusing the the case St Library so we need to check each step in the path works so onx circum Etc and um after that um we can do

benchmarks and then determine which protocol to use and um we can also re refine the MP speeds loader we mentioned before so people can reuse it to write circom code and transform it to mpb so you can do NPC with circom as well and um so after the refinement we will have a template loader so we can easily modify it to the to for new back ends like f so we can try F and um for the platform we will ship the first version with the D stat

library and after the NPC stat library is ready we can just U support NPC stat Library as well so by the time people can um use our platform with stat library and MTC St Library so the um future potential future directions so um we want to we also wanted to have a way to tact data leading computations so it's I think it's um asked by um is asked by the audience before so um even though zkp and NPC can um can yeah so I'm sorry so zkp and

NPC um they only secure the process to avoid leading their inputs but um they the outputs can still leak the input so for example um in our framework the filter is necessary for users and um the filter can easily be used to leak data so in this computation um data zero at ID this ID will be leaked easily and for another example is that um in the NPC settings um if the

computation is like this and we have data provider zero and dat provider one so the DAT provider zero knows this knows the it knows the sum of its own data so um it has the output and it can just substract and get the um some of the inputs from dat provider one so these are the cases that outputs can leak um inputs so for now we just make we just that um data providers to check whether each requested computation is is safe and yeah they they need to do this

on their own right now so it will be great if we have a um automatic mechanism to detect for us and U we also want to intergrate other protocols as well um and it may introduce new cases new use cases as well yeah so um thanks for the people mention here for the ideas and the technical support so that's our talk and any question Kevin uh we have one question in the chat

room might take a look compation between two input circus we need yeah I can yeah okay go ahead okay so so the question is when you do operation between two input circuits it's a based on homomorphic encryption if not how it's safe to do operation um in terms of ckp because like we just request the computation to data provider right and data provider just do it all locally so that is safe because they just do it locally and then they just return the result with the proof uh for

NPC again we just have NPC operation so that like it's it's all like magic of cryptography so that you have like local data and then you just like come up to the like Center through NPC and speed out the result but then again like for f H yes it should be like homomorphy encryption yeah everything that in local yes local of the data provider Yeah question yes please um I know if the presentation slides will be available after the presentation I wanted to go through like much more deeply um sorry I I could I I didn't understand

it I was asking if the the slides like the presentation will be available after this call so I can go much more deep yeah yeah sure sure sure yeah definitely yeah yeah we will upload to the YouTube channel and then I will send out uh the link through the email you register uh on the event page so uh maybe uh later today or tomorrow I will send out the email okay okay thank you very much um how to cope with the situation like final slide with differential pracy um so yeah we we we know um we heard of

differential pracy be but we didn't dig much into that so so um it will be explor more in the future so at the moment we are not sure how how to do that properly yeah like like right now we just use it that be like or maybe like framework to educate the data provider right to to know that like oh is it leak or not but again with differential privacy we can adjust the result a bit right to make sure it's like differential privacy yeah but as in said we we haven't like because we feel like it's different part we can add on top of the result so I think we can add

it later if it's needed hope we be different for users when using stats andc stats oh um so in the case St uh um you can only request to one data provider and um and NPC you can request to multiple and at the moment so the in the case St you will get a zero knowledge proof after the request so you can share

the proof to others and you can also request the computation and um and you just go offline and the D provider calculate and generate the proof and and you receive it and you're convinced so you you don't need to um compute interactively with the DAT providers but um with NPC stats both the data providers and users they need to be online and they need to run the NPC and user can get convinced and there is isn't a way for now to share the proof so in NPC there's

there isn't a proof but yeah so I think that's different that would be a different um experience yes I wanted to ask about uh in general statistical functions like uh to generate proofs of to generate in general proofs and compare to statistical functions and while explaining the statistical function can you mark which party or which entity is the trusted party sorry um S I I I didn't understand

it could you repeat that yeah I'll write in the chat oh thank you and uh the last question my last question yes please I to know where can I meet the presenters after the maybe like if I want to ask F questions um so

um if you mean after after the presentation where you can ask the question right um yeah like maybe I have questions yeah um you can visit the PSC Discord and um I think there is a channel that you can ask questions and we'll be there but um me yeah just add on so you can find our Discord Channel Link in the uh the event page uh so we have this open channel uh for people to ask question there so yeah feel free to you know uh join our service and then you know ask

question there cool so next thank you no worry um moving ask question there n you will be next um we haven't explored yet so um I think that depends on the protocol NPC protocol we use the um so at the moment we haven't decided yet so we are not sure about that we don't know about that it it depends on again like the the Malaysia setting right you like semi on Malaysia setting and also on the protocol like different because

MP speeds is actually the aggregated list of protocol so that we need to do Benchmark of that as well yeah okay n hey h thank you um you guys done any benchmarking on let's say very simple standardize like a hypothesis testing like a t test or k Square test or um sorry I I didn't understand it like you know typical statistical analysis like if you have a data set it's very common to do like a simple hypothesis testing right let's say you have two

variable you want to know whether their means are same or their medians are same so typically you do this through hypothesis testing in stats um like a t test or Kai Square test or Anova these are like standard statistical analysis test like are there any bench benchmarking on any of these things um like how well how well the zik stat performs versus a you know like a standard how will we yeah

um so at the moment I um so J do you could you yeah actually we don't have explicitly standard about like pts TS but we actually we do have like the standards for like speeds or like those stuff of the like like traditional like statistic operations but yeah we we definitely like cleaning up report right now and yeah that that's really good idea thanks very much for suggesting to have simple like personal personal yeah personal experiments like you know you pick a ton of data sets open data sets just to see how well the Z St performs or doesn't perform because I

would assume uh definitely it should be pretty good when you're are doing some mean related statistics but as soon as you want to do some uh you know median curtois things like this then I think perform performance will be Sly degraded because of how the setup is done yeah yeah we we we we do yeah B that but yeah publish and especially with the yeah context of like TTS TTS hypothesis testing I think can put into that that context it would be nice to see the result like in that context as so thanks very much yeah understand what you mean can you explain a little on

statistical functions um right now it is out of scope because we um um we we haven't confirmed that yet but we will do it after the Benchmark as well yeah so so so the in what what in my slide right that say like trusted party right now is just to make sure that the data commitment right the encrypted version is actually from the data but again on the flow of like requesting the computation on the proof that the computation is done on this data set on like this St is it's not process part involved so it's out of

scope but yeah just just on the beginning right to to make sure that the data provider doesn't put some gabbage into into the the claim to be data set yeah thank you sorry I was talking about the NPC part oh you want to oh yeah please yeah no I I mean I mean I I was talking about the NPC part so um I I I think I misunderstood the question okay guys we have a time for one more question so um rest your hand or type your question in the chat and then like I say after where we will

upload the recording to our YouTube channel and I will send the link and of the slide and the video as well uh through the email so check your email if you wanted to know uh like you wanted to watch the video and also if you have a question after this you can go to PSC Discord Channel um to uh we have a like space there for public uh to ask question so yeah great um do we have more question from the AUD cool um we have uh the last

slide uh I'm sure the reference can Kevin present that please next next next yeah this one yeah oh um yeah it's just the the project we have reference in the slides so um yeah if you're interested you can check it out and uh for the MP speeds we have a um Fork because um right now our MP speed loer is is implemented in the in the in the for brange and we will separate it out in

the future so if you want to check the the mpb loader you can you can um check the link yeah and um I think yeah and the circum to arithmetic circuit it is developed by the um NPC research team so you can transform the circum to arithmetic Circ and you can try it out and you can um do something with the aritic C like us and maybe you can find some new um use case and find some way to to work with

MPC yeah cool thank you for sharing before we wrap up uh Jour you have something to share though uh no yeah that's that's that's all we have and yeah as as Kevin mentioned that we have Discord in PSE and yeah we welcome the suggestions everything again like there's a lot of things that we need to polish and we need to improve upon as well so welcome all your guys feedback and we appreciate for Al call today great thank you everyone thank you everyone for coming I will see you next time though bye bye bye bye bye thank you very much