ZK Study Club - STARKs overview - Session 4

Transcript

we go alright nice so hello everybody today today we're gonna be taking a look at the second of the Starks talks that Ellie gave at the Technion summer school so the first part the first part was hide like I mean it was a high-level review of Starks and this one was getting into the topic of low-degree testing additionally there is a paper that is the I guess the basis of this talk which is the Frey paper which unpacked is is this the fast reed-solomon interactive Oracle proofs and proximity I also linked to this paper inside of our Google Doc notes for each session

and so this this was kind of the I guess this was kind of the meat of this talk so the overview was split into three parts so what is the reed-solomon proximity problem which is effectively the low-degree proximity testing and then he went deeper into what is the Frey protocol that they made and then it ended in a very very in-depth look at or tried to make the comparison of fast Fourier transforms and how it's similar to fry basically in the recursive nature and how you're going to split the problem into some subproblems so the format that we're going to be doing is at 10 minutes of introduction by me

who's leading the session and then we'll ask everybody who's on the call for questions that that they have either related directly to this presentation or some ideas that get sparked as we're talking about it and then we'll have about 40 minutes of discussion all right so so for me when I'm looking when I was watching this presentation I think the things that stood the things that stood out again were something similar from the first talk which is when you're saying that you're assuming when you're assuming a function f to think of it also as a as a lookup table this this helps me a you know kind of better reason about what you know what is happening here so just that you you have

you have an F that's taking in and if you were to have that employed let's say sex you could just build that lookup table and this is very useful in practice because you could have pre computed this lookup table so again the overall problem statement is that you have F and it's in you know it's in some set s and we're saying that s is something huge so you know it could be billions and as it turns out this is really important for for the works that Eli had done in another and another of his theorems in 2005 that only until the set is very large do you start getting the cost/benefit and so I guess this is why they wanted to come back and take a

look at Fri so that you could lower the number of queries in order to construct the proof so so kind of going through this so it was an I guess he made he made a note about saying that you know the previous talk the starks one talk was about using low degree polynomials to express the statements of computation and here he you know wanted to hear what he's talking about is not really talking about the computation at all but just breaking it out into you know that the algebraic form which again for me was realizing that okay I don't have such an intuition as I'm looking at the notes and the formulas that he's writing on

the screen and I found that there was a lot of gems listening to the way that he described this so for me my notes are you know half of what he has on the slides and more about what he talked about and how he kind of unpacked it so I could better understand how different parts of the of the formula are talking to each other so at least for me that was really important so really watch the talk and don't just read this lives because yeah he explains it in a great way so so yeah just again add you know adding slackness is kind of the important part so the problem the problem statement truly is that if you were to have this zero point one far so if you roll out so if you're allowed to

have you know 10% of all the entries in F to be off but not but not more than 10% can you can you still have an efficient way to query to query into F and so so we have the first step what we're saying let's simplify it and then to further to further simplify it we're saying that we want to have an error an error of 1/2 still with this minimal Q and so specifically what that means is that when F is this low degree polynomial Alice must accept F if it's if it's an honest polynomial and if F is very far

from being low degree polynomial then she must reject it with the probability of 1/2 of this 10% so really this is the simplification the slackness that allows that allows I guess know the underlying math to all line up and so breaking it down starting with just a simple polynomial which is a line so when you have these two points if you want to reject any lookup table that's not close to representing that line and so that means you need to change more than 10% of the entries you know how would you how would you do that well you can say that we'll find the slope in the intersection of the line by reading two points so for a line you can just read three points and so for the first two

points you know find find the slope and the intersect and then take the next two points and see if it is matching so then for a for any polynomial as you're increasing the degree you're going to need at least degree many points so degree many queries to interpolate that polynomial so the first theorem that he talks about is is this work that was done in 95 I forgot that I forget the person's name but the theorem is stating that you can you can do this with exact weight degree plus 1 points so when we had the example that that we want we want to query sorry that we want to have this degree of G that is 1000 you can

you can query with 1000 plus 1 queries however this is not with a proof so we you know we we can't we can't trust this yet and so he continues you know so he can use to to solve this and the important part of the or the important note I thought was that we are in a transparent system so for the proof pie that that Bob makes he writes down the F and the PI and commits to them and so you can commit to this using a miracle tree and then later on he's going to open up some entries and so I guess it's you know kind of by side not so important but by side you know there's no cryptography and all this low-degree

testing or even in the Starks one talk cryptography is only being used to enforce the commitments and later on when you when you're revealing so that you know the revealed entries are agreeing with what was committed to and he called this transparent lands I don't know I don't know if anybody else has set it this way but it was interesting to note what parts of it are you know just completely the mat like you know the mathematics and then which and then when do you start adding proofs which I mean for me it wasn't such a surprise that it's only about you know committing and revealing this is where you're gonna have these who are you gonna have the add these cryptographic assumptions and when you start needing to to use cryptography so so that that was that I was you know the introduction to load

degree testing and then he goes a little bit deeper into into what fry actually is and so concretely for the problem that we had we're we're we're in a set of 1 billion and we have a degree G which is one thousand concretely we plug in some numbers and it turns out that the Krueger complexity is concretely large at twenty seven thousand queries so it versus the previous theorem which we have been 1,000 plus one so this is this is great because it's asymptotic result because we have this log see I

log to the C inside however they're only kicking in when you have a very when we have a very large value he shows another example later on where it's actually more expensive you need more queries using this Fry's setup so this is something I guess to keep in mind that if you don't have a very large execution trace then using this is not going to using this is going to be more expensive but I'd imagine that most of the time it is a large execution trace that we're working on and so this is why you would do such a thing to begin with yeah so then he he digs a little bit deeper to what fry protocol is maybe people have specific questions that we

could get into later otherwise it was a lot of it was a lot of breaking it down and the tricks that he used made sense you know exactly in the part so we could just come we could just come to the part where we say you know when we have an F which is some set F enough so yeah the function little F and it's a set in the field F and again we're saying that we have 1 billion and the degree is 1,000 then the 3 the the you know the previous work was that ok you have 1,000 plus 1 or 27,000 queries but you have a proof and with this fry protocol you're gonna have query 80 because you're going to have 20 queries to get this soundness

for area of 10% and then you're repeating this four times more so that the soundness is no more than half of this Florida so this 10% farness so this was you know this was interesting I don't I don't know why or if there is a generality to be made here but why it's 4 times more to get this error reduction of half and additionally he was saying that future worked you know there's not there's not much left to save in the prover in the verifier complexity but possibly there's something that could be dude that could be done for the number

of for the number of rounds I had missed it I think it was the number of rounds of querying and additionally he made a side note that I wish we could make fast Fourier transform even faster he gave me in size - if you stumbled upon something or just that it was a wish of him and additionally this is an interactive protocol so he he made mention that you could apply the the Fiat schmear heuristic to remove the interactiveness and make it non interactive and then for those that are really interested he made a he walked through and broke down what is fast Fourier transform is the inverse and it's kind of mathematical statements about what these are doing and then

trying to show how Frey is somewhere and I end up writing a lot of notes here it took me took me a while to unpack it I still didn't quite quite follow all of it so I think this is where I might start leaning more into doing things with pen and paper and so just taking notes but yeah I'm and I ended it with more to come so I will finish taking notes for that for that section of the talk it's really just the last three minutes that's missing um but I guess the you know the trick the one weird trick to make this all work and why and why it's quite fast is that you are splitting the problem domain so for fast Fourier transform you are you know mathematically splitting it into two

subproblems and then continuing to iterate and so you end up with you know a constant value that you're trying to solve and then roll back up and he's saying that it's something somewhere in Fri except instead of splitting the sub-problem into two instead of splitting the current problem into two subproblems you're getting a reduction of half but kind of only following along one branch you don't have two new things to solve you just still solving the same one um yeah so this was this was my overview of things that stood out for me so now to turn it to the group and say what what were you thinking over what open questions do you have and then we can start a discussion on that

thank you I didn't get to the end like in part you just described that's where I was like and then we started doing the set up so this is good to hear but it sounds like I'm maybe even after this be my watch it and like watching multiple times I think we wanted to use the next like five minutes or not even but just to see if there are some like larger themes questions that we could cover so I don't know if you guys had specifics I mean I have some points but these are possibly also just points that I didn't fully understand the kind of like for example the point one or one 10% far I

actually didn't understand what I didn't like fully get what that is like what what that meant being out of range or something so that in general like I'd like to talk about there was some talk of randomness or there's this like pie and I like when you talked about it being transparent I didn't really accept I didn't understand how those were exactly related I mean I kind of actually I have some idea I thought that might be related but I wanted to and then I also agreed with you on the Forex I don't know why that like I like rudimentary math doesn't check out if it's 1% at 20 it's 10% at 20 it's not

50% at 80 so that's also when yours Ben yeah okay but maybe I just misunderstood what he meant by yeah I guess those were that covers most of the ones that I wanted to begin to I'm capturing all these questions that's why I'm muting see you have to listen to me type alistair did you have anything questions no did you undergo I have some questions but not about to talk okay do you you know how to explain and maybe because you also had this Christopher that Forex questioned no I'm not even sure what the

where it came from really so like the idea I mean yeah cuz it was sort of like you repeated and weathered in rounds was remember the rounds were actually happening so it's four times that round I was trying to do the math because it was like if you do it once you get ten percent if you do it four times to Chris this point it's like if you do it four times then is it like 0.1 times 0.1 times 0.1 or the probability of you being off being very small right I also didn't get that part and so the question is if no one gets it then how do we solve it well we what we are doing with these questions that's actually get really

good christian so like last time because we have this group and actually Ellie's in the group what you can actually do is in this in this conversation if we're not able to solve something between us we will just drop it in there and hopefully either get his attention or somebody else's attention who can help us explain that or point us in the right direction last time Alistair found a an issue or like you were you found something where we weren't able to figure it out and so we just dropped it in the group yeah that was very helpful he gave an answer which also leads to some complications in describing this thing that he completely ignored in the talk but never mind that because that would only confuse people so yeah but 10% far here

is what that means is that we disagree on more than 10% two points so is that sort of like a fuzziness like they're they're wrong or yeah we're simply we can't tell if we're exactly a low degree polynomial without or not without checking almost every point but you're allowing for some like I'm just sure is it sort of allowing for some error or allowing her because I mean I don't understand how that lowers the number of queries so if you want to hide that your low degree polynomial that you're not

allowed to be polynomial then the way you could do that is start with a low degree polynomial then change one point and there's no way that anyone's going to be able to detect that unless they have the actual polynomial so but if you change a lot of points then there's a possibility that they're going to be at that you know they look at a random point it's not going to be from this this low degree polynomial so to visualize that I if I think of a line right I'm very simple all right think of a line you add one point you get a

parabola you'll have another point you know that's not on the line of course sorry these are adding a bunch of you saying add a bunch of points basically you're increasing the complexity of polynomial by a degree every single time well no so this is so if you imagine having a line you know and we have a number of points where X equal to Y and then you change a single point so it's not on the line so we have we have a line and then one outlier that's not on the line and if we look at one the point we just can't find this one point right so I guess this is for me where it helps to think of this function f instead as a lookup table so if we were trying to hide you know if you're trying to hide

points and we could say we have this line and so you have you know you have an int you technically have an infinite number of points right between an x and a y on the line because you could keep making smaller values so okay great and then you could pick a random point and put it in that lookup table so as Alistair said unless you unless you look at everything that's in that lookup table F that would be hidden because yeah if you had if you have a you know if you have so many points inside just changing one or two of them the chance of you finding it is quite small it's if that makes sense because I feel don't

understand how that helps lower the number isn't like the purpose of this to have lower the number of queries needed I think we want to it kind of if this really was 10% far they should be nothing the prove I could say to the verify to convince them that it's temp said far but if we only change one point then it makes the problem it makes the problem of hiding that we're not allowed to befall know me a lot easier the malicious prove her and so it's very much more difficult than to find it difficult to proof that actually works

so it seems like there should be some chance of if the approver were lying discovering the error on a random query to a random point as a function of the actual will degree of the crew risk polynomial versus ten to the third or whatever we expect to be open one far from all right but yeah we own tell me a chance of doing that if we if a random point will give us something useful it's yeah I guess because it's the same coordinates okay I'm referring to my notes so this is paraphrase directly from the talk but it's the same game as what we were discussing from the previous talk where F is a load when F is a low degree polynomial there exists

some PI this proof that that Bob is proving in and he's proving it over multiple rounds rate because that's where the randomness comes in that the randomness that Alice the verifier is sending gets included in the next group so you have you know a P p1 p2 all the way up to a P of n for n number rounds so when you when F is a low degree polynomial there exist some PI that that should be accepted by the verifier and when F is not low degree then for any PI that Bob tries to fake Alice should find out so when we're dropping I guess we get to drop the number of queries because well because a couple things we've relaxed it right we're saying that

even when we've done this 80 rounds of querying we're still saying that there's a 5 percent error rate so it could you know it could be that that Bob is able to cheat that the prover is able to lie but you could continue to pump it sounds like you can continue to increase the rounds I'm not this is what I'm wondering I'm not sure what the ratio is there you know four rounds more dropped it to half so maybe maybe that is you know for some reason if that is the math then every time you do four more rounds you're you're dividing it by two is that it or is it actually a square they're like you need to do four by four but but yeah that's I think that that to me is my

current understanding of the relationship to dropping the query number so yeah I think here we actually need to use this did this thing with it from them from the last talk this equality of polynomials by looking at a low degree polynomial by looking around the points we kind of need to do that here hmm and then in the end would reducing to testing if something is a line or something or it is a is a degree one or two polynomial mm-hmm yeah which which once again the power the power and beauty of recursive algorithms yeah but then in this base case you this is where we kind of definitely need this 10% farthing if we're just if we're checking

random points it should be it's impossible to tell if with what if we if we only change a few points away from line or go after I think we can't tell that if we change ten percent of points if ten percent points away then all we need to do is to look at tools to a three points to work out what the what the thing is and then keep testing other points and say if they're still on it and we are there'll be many points to get to land a point to get something from this 10% do you do you have any and is anybody have any intuition why 10% far was the number described in this

talk I mean each each time Ellie is saying I'm not gonna go deep into the math so I'm you know until now I'm kind of trusting that the example he set up is somehow representative but does it does anybody know why 10% far was chosen a good question I'm gonna I'm gonna write that down for the future because I was also and as other point 10% far what what is this and maybe why work if you were to come creamy case why why would you use 10% or how do you pick that number I mean I I feel that it's the end result is you're

trying to choose an error rate which is acceptable yes I think looking at the paper there was something where they don't quite know how to make this descale with the error in the way they'd like okay so they probably do have to deal with a quite big number like 10 descent as opposed to point 1 percent this could be totally wrong but like thinking from the perspective of a lookup table if you want to find out if something is you know if you want to find in your likelihood of maybe the dye against this is just a plan if you wanna the likelihood of you finding an error is sample this n times and you should

find at least one error I don't know if that's relevant at all whatsoever or like thinking from different perspective again that that's exactly that that's exactly it but one of the reasons we're all wondering why why you can sample it full time to get get to 1/2 because oh yeah make sense no matter what you multiply it's it's hard to get 1/2 out of this whole thing sample the sample is it sample specific points and one be off well yeah if you think of it as like Matt said look at his a lookup table right don't think here does it continuous function there's

basically a table of all these points that someone puts up as hey this is this in my polynomial if if someone tells you that there's a 10% error or 10% of those points are bad should only need a sample statistically 10 times and one of those 10 samples should be wrong well right yeah you'd probably do more to actually get that but you imagine right you can actually just do 10 well I statistically saying right you technically need you to use tested it's like coin flips right you can do a bunch of coin flips get heads in a row 50 times right yeah and this this then just a chain onto that this leads into the other question you had Anna which is what what

is pi and how does that relate to randomness so is that like is there anything public like this concept of transparent land was this that it's public randomness that's included exactly well so it's PI like also PI of it maybe I'm just I'm just really not used to looking at math that's much but is the pi is that just a symbol for anything or is that like hi that's on no so it's pi it's pi as a placeholder supply as a variable and so the idea i guess the idea of transparent land I don't know that's a new word for me but the idea there is that it is public randomness so what yeah my

interpretation of that transparent was in like I think from what I recall and I watched video very quickly apologies for that is it was sort of in the context of like sea cash and the privacy-preserving like stuff right like that hey all of this stuff is actually happening out in the clear no one's encrypting anything no one's hiding anything right now this is just sort of representation of knowledge right so that's where I that's what highly different that it could be wrong but in my head it was like yeah you want to sort of make clear that hey this is likely nothing to do with cryptography nothing to do with any anything and be able to hide something but really just about this well yeah this is about there not being this toxic

race this descript crypto stuff but of course this is their own knowledge we can have we are we the proven might be hiding something right yeah and so math and so this is it mathematically were trying to reduce the you know reduce the amount of stuff or reduce at all if you try to drive that error rate to a very very small number trying to reduce the amount of times and also the amount of points that the prover could lie about but so for all for all this public for all this public stuff like anytime you hear coin flips it's it's essentially saying you could have taken a value from you know a like a public random beacon as it's getting

talked about in some of these you know implementations additionally additionally if it's mentioned you can be using a block hash right that's also a public source of randomness you don't know what the block hash is gonna be until it's there so this is why I don't know if that's quite right I think I had only true if the prover is never like the miner of a block right I think they're sort of simplifying the assumption there yeah so agreed there's you know they're they're ignoring shady miners right yeah no the prover knows the randomness they can cheat it's not it's not public in that sense so but I guess what you're saying here is you can you can sort of you're

you're putting this your lumping this together with those kinds of ideas of the random beacons or using block headers are just introducing randomness in order to make it more and more difficult to be uh and I guess at least for me when I'm thinking about this having a good source of randomness is hard and probably having a public source of randomness is also saying somebody could go back and check that you weren't having a bad seed to whatever random function you were using so Alice the verifier wasn't also doing something weird right or something nasty and then that public source of randomness is getting fed into the next round of of Pi which is this proof of proximity and so

this is the auxiliary data that bob is is including and until you do n number of rounds and then at that point that's also going to be committed right so first thing is I'd love to give the lead the session where we start talking about the fit Jim a heuristic yeah because so that this is how we have this thing where the the verifier has randomness but we want to make it non interactive then of course the prover has to cope with the randomness themselves but yeah later also linked I have not yet read it and

so cannot summarize it but the kulluk has a blog post on Fri although it's called something else that seems to summarize what pi is and why adding that axillary data reduces the number of queries required I'll try to read it in the next five minutes maybe yeah don't don't rush it but if you want to you could drop a link in the telegram channel I have a quick logistical question is is it possible to join this now because Mike the gears out the dial are enjoying for my phone thank you I think it's okay I got a weird error that didn't let me show everybody this on YouTube later so you can also just watch

it okay okay okay other so 4x is still a question making it interactive it's super interesting and I'd love to just go more into that because that could be a bigger topic so I'm sorry hey Louise what are we doing to this making it non interactive it's interactive and we don't like interactive because interactive plus blockchain doesn't work right in front of me it is interactive I should have known that this is a topic of a later talk almost certainly is that

yeah you know I was understand the understan the question about the announcer activeness and what did the pro about it that the problem is that the proofer has to come up with the randomness to premiere the future Mir does yeah exactly yeah that's it that's what this fits in your esteem or right now it's right now the prover needs to also come up with randomness yeah that's always a case every time you have an interactive system the interactive version which is

what we're at the moment the the but this is why this is why the the verify is only allowed to give random numbers right because we're eventually planning to have the birth I have the proof of do all the rounded numbers yeah that was all that was all the questions that we had come up with we said I had written down if I miss something or if something else has popped up let's let's kick it off I think I've definitely covered most of this stuff Oh actually I had a

question about I have an idea of what the answer is but prove her complexity was 27,000 and I thought I guess like like when when he when he says prove her complexity that's a good thing I guess the high number is good given the low number of queries I didn't really get why that was sort of like yay the prove a complexity is bad if it's big it's bad not if it's big yes you don't want it to be big you don't want it to be big confusing to me well so the way I think about that one here's how I rationalize that is if it's gonna take a lot of work to prove this thing then if you try to run this on a blockchain then it's gonna be a lot of gas in the

contract to prove that it was right is that right or wrong that's what I thought when I saw it but at the same time it sort of like wasn't that shown at the end kind of like achieved Kreuger complexity yeah yeah this this this is this is it's bad if it's large but 27,000 is much smaller than it it might have been okay and additionally emedia probably the proveer complexity is always going to be octane at least so really having the verifier like the verifying complex station should be quite low otherwise it's not gonna be suitable at all but yeah definitely this hot chain work should be small as well but the thing we're doing the degree that this a thousand whatever we're so for instance the degree before

was the length of the execution trace so it's got to be at least a thousand for the proofer the fact that it's only twenty seven thousand it's great it's much better than a million and I think there are zero knowledge things where at least one of the systems I remember the the approval complexity was quadratic in the length mm-hmm so that would be millionths say twenty seven thousand is great but this is not twenty-seven thousand is not the number of queries queries in this case where eighty this is how much computing time the computer takes okay so like the prover you know the prover needs to do some work this is not produce pie right that's what we're

talking about is it is it only pyre is it also about setting up the F because there's something to be done there about finding a polynomial for the thing that the prover wants to make a proof of well I said that's a good question I'm not sure it seems like this is sort of an independent construction like for any such F but they already have good like at least the the prover complexity note comes much further after that section so I don't know the hmm it's it's an I'm so I'm just I'm looking through my notes because 27,000 comes up twice once at once Anna it does

come up as the number of queries and so this was the work that was done previously by Ellie and this is where it went from 27,000 down to 80 in this Fri protocol and then the second time it comes up is when he's saying concretely with Fri when when you have this log to the C and we're using a billion as the execution trace size is a set size then that that number is exactly 27,000 also I think that's just coincidence great there was hmm I guess anecdotally there was one other part that was

exciting for me which is when he was talking about the properties of of fry that he was you know as he breaks it down you end up with this T sub P which is the number of arithmetic operations that the prover is making and he was saying that some of them are additions not just having a multiplication cost and additionally that this T sub P was paralyzed Abul so you're getting logarithmic time and you can you know Hardware accelerate it to split it up so that that for me was after me was really interesting or exciting rather because anytime you can anytime you can chop it up definitely hardware keeps getting better faster stronger and so this this

is nice what they're also a comparison there there where it said the I think it was the IFFT or Liza Bowl like remember he's saying like you don't have to because you can so I didn't actually watch the end of the video so I didn't actually see it I was just following your notes on that part but where you said like it's actually faster because you're only doing one branch I mean he did he did make us I mean it was it was apples and oranges as he said it that he was trying to show that Fri is similar to fast Fourier transform because of the algorithm because you're you know recursively going to a subproblem if that's that's what you had in mind I

need to watch that part okay yes you're backing like I think oh we can't hear you though okay so then so then yeah last last call for open questions or any other thoughts you had for today's session otherwise otherwise Ana you want to want to close this out yeah okay so um I think we spent I would say we spent

probably like more time than I will try to in the future on the beginning getting it set up and stuff like that but I really liked the I really liked your overview I'm now kind of annoyed that I didn't watch that last part because like it's kind of interesting and I can't talk about it there's still some there's some points that I can tell I'm gonna have to like go over a few times before they fully sink in but it was really cool I don't I thought this was a it was a good session I think this is like were you Alistair maybe it's not super deep but for me at least and and maybe for some of you guys I think it was like

pretty cool to see some of the like inner workings and some of the maths but my good and I'd love to do more of these um - yeah I don't know if I need to say anything else we're gonna be doing another session next week I think we're gonna have a guest lead we're gonna talk about it in the next few days and like I said if you guys want to do one alistair if you want to do one on premiere heuristics that would be awesome Christopher if you want to do one let you know and yeah yeah would I guess the three people who were on this call still find a discussion of how to construct simple Sigma protocol Sarah knowledge juice interesting you like into into

deep into the math that's what I want to understand like I mean so I was in it I was in a trusted set up workshop and it was really cool but I'd love to do more on that because I was just watching anything there was a lot of stuff I couldn't do like that the multi-party computation up it was actually about the ceremony or the requirement for toxic waste it was the ceremony and there were certain kinds of I think it's very much like in I don't know that it was going past what Zeke ash did but it was kind of like replicating it's like the planning of ceremony ciao we could do one better that we could do a ceremony to that that

I like hey I just like I can't remember off the top of my head it was like bye damn it wait actually I wrote it down in here I think it was one second bilinear herring and I know I think that was the one I know I was talking to rob alistair rob Havemeyer about that he was like oh yeah that's like complicated so that was a part where I just like think going through the steps might be interested in a little bit more depth there is it that you like that could be cool to do a ceremony I guess something else that's been kicking around in my

mind was how - yeah maybe how to go deeper into the math I think I'm I would be very excited to have Alistair lead us through Piazza mere heuristic and how that gets constructed that they have another paper on how their specific thing does works which I'll have to look into I don't listen to talk anywhere that's what we need to find right yeah I mean I'm I guess I'm actually doesn't have to be a talk it's like but it like ideally a want like one piece of content that could be read or watched or what-have-you in like half a day so like not a whole course I think we're not ready for that for this I think the idea here is like we have a group of people

who often are working and they have like other things going on but we want to see if they can take some time to like a look at a piece of material yeah yeah so I guess for me that the interesting part would be or or the unknown part is if we do something that's very mathematically heavy what do we do do we have the video you know the video running and make sure that you're in a room with a white board so you can lead everybody through because I guess this is the challenging part about having having us on a hangouts call how'd it go how do ya walk through an example of it well there are some other tools that we can look at there are some tools where you can like do combo joint like drawing on

whiteboards and we can do a screen share on that maybe but I think for now maybe we keep it to some content no but yeah cool I think I'm ready to stop it yeah thanks everybody for joining today that's representing you guys him