Algebraic Geometry for SNARKs

Transcript

I'll be talking about, yeah, sort of algebraic geometry for SNARKs. Um, so maybe a subtitle is that uh, in our new sort of AI world, you should be a lot more ambitious about the kind of math that you can try to use for uh, um, cryptography applications. Uh, there's a lot more that's feasible than you might have thought before. Okay. So, yeah, basically I'm going to focus on two things. So, the first thing I'm going to focus on the sort of like, maybe I want to think of it as maybe a first case study of this algebraic geometry skip for optimizing some check round skipping. And then there's going to be a little bit of like general ideology of maybe how we should think about these kinds of results um, in the future. So, we'll start with kind of the the general framing. Um,

so right now there's a lot of pure math out there. There's a lot of very powerful stuff that tells you very difficult things about very complicated objects. But um, very little of that uh, has actually been worked down to any kind of practical application. So, you can say maybe a lot of it is not useful, but um, I think what's going on is that it's a little bit too difficult right now for a human to actually work the math down to practical application. So, there are a few reasons why this might be true. Um, so the first reason is uh, there's a problem of breadth that there are a lot of techniques and if you have a given question that you want to solve, you don't know which technique is going to be the most useful.

Um, second, there's a problem of sort of rabbit holes: that you can think that some technique is going to work, you spend like a year trying to learn it, you do a bunch of very complicated things trying to get it to connect, and then everything just falls apart and you don't get anywhere. So, you just waste a lot of time, you don't get anything. And uh, there's another problem of sort of complexity that um, if you have something that uses some like deep pure math, um, it takes a lot of effort to work it down to the kind of explicit computations that you need to actually get an application out of it. So, what just sort of happened like this year, like in the last few months, is that um AI models got to the point where they help a lot with these three issues.

So, first of all, um you don't have this rabbit hole problem anymore because it's very cheap to test ideas now. Um you don't have to spend a year learning everything and doing it yourself. You can just ask the model and get the answer back whether it works or not in like 6 hours. Um they also resolve the complexity issue. Um these models are very good at writing scripts and doing computations. So, once you get something abstractly working, you can just ask it, "Okay, now explicitly work out the details for this case that I need, write all the code." And it'll do it for you.

And finally, um they're kind of partially solving the breadth issue. So, they know all the techniques. Um sometimes they can find the connections. They don't always find the connections. But, with some human input and some cleverness, um you can improve the breadth issue a lot. Okay. So, this is what we can do. Um now maybe we have a lot more space opening up that there's a lot more fancy math that we can probably actually get something useful out of. So, the main focus, I'm going to talk about one particular thing. I'm like just think of this as a case study. So, this is a particular problem inside SumCheck. Uh there's an optimization you can do called round skipping. Um and uh there there's a way to use algebraic

geometry codes to uh make this a lot faster. So, where did this come from? Well, basically, uh we were playing with a bunch of uh random ideas, very speculative ideas, to use fancy error correcting codes to optimize parts of STARKs. Um this was maybe the fourth or fifth idea. Again, it was very cheap to just iterate through all of these and try to see if if anything comes out of them. And then the fourth or fifth one worked. Uh this was done with older models. Um basically, Opus 4.8, GPT 5.5 Pro. And, uh, uh, well, current models, you should just be able to feed them this slideshow, or maybe there's a paper that you can ask for and we can give you, and you can feed them that paper, and it should be able to reconstruct the entire project,

uh, even if you want to vary the parameters for your particular application. So, that's sort of the general state of what's going on with, uh, with this particular project. Okay. So, now let's get into the details. So, what is sum shipping? Uh, sum round skipping in sum check. Um, so what happens is, uh, okay, so assume you wanted to do a sum check, and, uh, you're doing something with binary fields, so maybe you want, uh, you have bit data, right? So, you have data inside F2. Um, so the problem is that sum check needs to work over a much bigger field, uh, for you to be able to get soundness of the of the round challenges.

So, in standard sum check, what happens is that there's a first round where you do an amount of work that's sort of proportional to the amount of data you have, and that work is over F2. Um, but as soon as you go past the first round, the later rounds have to be over a bigger field. So, the ith round, maybe it takes work that's 2 to the negative i times the amount of data you have, but that work is over the much bigger field. So, the issue is, um, these middle rounds end up being much more expensive than the first round. So, what you might want to do is you might want to move a little bit of work from these middle rounds to the first round, and then you can sort of skip all the super expensive middle rounds, and then you have a much cheaper sum check

overall. Um, so, the trick here is that if you have the right kind of error correcting code, it lets you move a bunch of work so that your round one work is over some F to the 2 to the k with for some small k, and uh if your error correcting code has message length 2 to the n, this lets you skip n rounds, and, uh, then you get a much better sum check. So, the standard way to do this is with Reed-Solomon's code, and this is something that's either called a Groen strip or univariate skip. Um and uh the this is the standard optimization. So, what's going on here is we're going to try to um optimize this further.

Okay. So, right. So, to do this, you need an error-correcting code of the right type. So, there's some abstract properties that you need this error-correcting code to satisfy. Let's just go over those properties. So, the key point is that the error-correcting code is multiplicative, um, which means that given the error-correcting code C, there's an associated product error-correcting code called C star that, well, first of all, um, if you have a codeword in C, and you have another codeword in C, and you take their Hadamard product, their sort of point-wise product, um, that becomes a codeword of C star.

So, it lets you define this uh this other product thing uh V cross W, which goes from messages of C, messages of C, and the product gives you a message of C star. Okay. And then basically, the next thing that you want is you want that this V cross W has prefix V*W or V Hadamard W. So, sort of you can take point-wise products on the message side, and that corresponds to some kind of point-wise product on the codeword side. That's what this first property is saying. And what this lets you do is it lets you do quadratic sum checks. Um so, somehow the data that you're sum checking over in the challenges are sort of point-wise products, and that has to do with like doing point-wise products of your data that you're encoding.

Uh the next property that you need is that this product code C star has very large minimum distance, and that minimum distance directly gives you the first-round challenge soundness. And the last product that you want is that um there's some kind of small product field. So, if you have two messages for C, and you multiply them together according to this cross product, um you get a message for C star, whose coordinates are inside some small extension of F2. And uh, well, for Reed-Solomon, uh, the size of this extension is basically the number of rounds that you're skipping.

Um, so yeah, this is what keeps your first round work in a small field that actually gives you the optimization. So, what you want to optimize the actual number you want to optimize of this code, is uh, basically this K (this field that the products live in) times the dimension of C star minus the dimension of C. If you try to do some accounting for how expensive the sum check is, this is what directly, um, tells you how much extra work you're doing in the first round. Um, you also care about the cost of computing V cross W. Okay.

So, now you can see we have some like pretty formal problem, right? We just want to find some error correcting code satisfying some formal properties, and we want to optimize a particular number of error correcting code. So, this is now a very AI-shaped problem. Um, so you can just throw the models at this. Um, so again, with the old models, they didn't quite solve it, so you had to give them the idea of what to do, but um, we'll see what happens if you can like throw this up like Astra or something and see what it does with these properties. So, what actually happens? So, we want to minimize this K times dim C star minus dim C. So, what do we do? Well, the actual construction that ends up working, um, is something called a differential Goppa code or differential algebraic geometry code. And the key

point of this is this lets you get away with K equals 1. So, just for comparison, right? So, Reed-Solomon, the K is the number of rounds you're skipping. Uh, the point that gives you the optimization here that makes this faster is that you can actually get K equals 1. And since K is a multiplicative factor and like the target that you're optimizing, this makes a pretty huge difference. You're allowed to sort of blow up the dimension of C star quite a bit, um, and you get to compensate a lot if K equals 1. So, the point here is that you want to get K equals 1. So, okay, what are these codes? So, what you do is uh basically you choose a system of polynomial equations in D variables that have more than 2 to the N solutions over F2.

Um and the system of equations has to satisfy sort of one-dimensional property. So, it has to define an algebraic curve. There's a way to formalize this, but you can just think of this at just the set of solutions if you pretended they were like if you actually plotted it as a graph, it would be a one-dimensional thing instead of a higher-dimensional thing. Um so, what the algebraic geometry does is when you're given the system of equations, um it gives you two spaces of rational functions that uh I'll call L1 and L2. And uh these rational functions, you can think of them as functions not on um all the variables, but just as functions on the solution set to the system of equations.

Okay? And these spaces of rational functions satisfy a few properties. So, first, if you have two things in the first space, and you take their product just as rational functions, you get something in the second space. So, you can see that this is basically the same kind of shape as kind of the multiplicative property from before. Um the next thing is that while you have greater than or equal to 2 to the N solutions over F2 to the system of equations, so what you need is that if you have something in the first vector space, um it can be interpolated from its values at these 2 to the N solutions.

And finally, um what you can do is you can look at things in the second vector space, and they can be interpolated from from their evaluations at these 2 to the N solutions, and also some derivative data. So, you have to take a few extra derivatives at these 2 to the N points. So, once you have all of this, then you can define your codes. So, what's your C going to be? So, your message is going to be the evaluations of one of these functions in our one after two to the end of F2 solutions. So then what you do to encode you interpolate and then you can evaluate at all the F solutions.

And that's sort of an error correcting code, right? You take this data in F2 and you get this this long code word in F. The the product code is going to be a very similar thing. So you take the data that you need to interpolate a function. You take all the F2 solutions and you take all its derivatives. You take the values and derivatives. You interpolate that and then you evaluate at the same F points. So you can check that this construction it satisfies all the properties that we want. So what does V times W become? Well, you basically you take your V.

It's this two to the end solution and two to the end evaluations. You have these other two to the end evaluations. You interpolate them to get their derivatives and then you can just multiply them together using just normal products for the evaluations and a product rule for the derivatives. And because everything is kind of defined over F2 here, you stay inside F2 and this product stays inside F2. >> Wait, sorry. >> Yeah. Yeah. >> I'm a little confused. So right now you're up Your your your object now is some algebraic function.

>> Yes. >> So what do you mean by its derivative like it what do you mean by its derivatives exactly? >> Yeah, so the way you can think of this is that so your your curve is kind of embedded into F2 to some number of variables. >> Yeah. >> And then this function is just because it literally just becomes a rational function. So you can talk about derivatives of the rational function sort of in some direction along the curve. >> Right. But are those even like I mean there's many non representatives know of the same function on the curve. Like is it >> Yeah, there are many representatives but um there's a way to formally define this. The The algebraic geometry word is a jet evaluation.

Um, and the theory all works out. >> Okay. >> But, yeah. >> But, basically you take derivatives by each variable, like you you have like >> It's a curve, so there's sort of one direction to take a derivative along. >> Oh, okay. So, there's one there's one derivative that's well defined. >> Yeah, yeah, yeah. Okay. All right. >> Yeah. Yeah. >> Yeah. A related question. So, you mean that the number of derivatives here or derivative evaluations is a small number, like constant-ish? >> Yeah, yeah, yeah, yeah. So, if you know the dimension of C star, then the number of derivative evaluations you have is sort of the the dimension minus the number of points.

>> I see. And And it's cheap to compute those derivatives. >> Yeah, yeah, yeah, yeah. Basically, it's just a linear map, right? If to get the interpolation and then get the the derivatives of the V and W, and then to product, you just use the product rule. So yeah. >> Um, since you brought up jets and since I have a work in progress submission to better.codes, which uses jets a lot, how have you found doing a lot of proofs with jets? Cuz at least on the Lean side, it's pretty painful.

>> Um >> And I have, you know, no prior knowledge of jets before getting into this, so that's it's kind of issue on my end. >> Yeah, so I'll get to this. The verification of this was not in Lean. >> Yeah, but even informally, I'm trying to just understand >> Oh, so informally, the way I think about jets is sort of um, you have like a power series expansion, and it's sort of the later coefficients of the power series expansion. Um >> Cuz cuz right now, like the approach we can talk about it later. It'll be easier. >> Yeah.

>> Uh, maybe one last So, if you don't use derivatives in C star, you you don't get advantage over a Reed-Solomon cuz right the regular AG code there's no derivatives. Uh >> Yeah, so you don't get an advantage because if you don't use derivatives then you have to involve points that aren't defined over F2. You have to talk about solutions in bigger fields. So you sort of lose this property that V times W stays inside F2. >> Oh, okay. Okay. >> Yeah. >> I I just maybe you'll explain this in bit but really define what the spaces of functions are that you you use L1 and L2.

>> Yeah, so I can say the word like the you just there there there's sections of line bundles. So you pick a line bundle and then it's it's the there's some divisor and you just double the divisor to get L2. Yeah. And you have to like you need these interpolation properties to hold. So you have to check that like the dimension of the space of sections of the line bundle minus like the sums of the points is actually zero. So yeah. >> Do you anticipate there a lot of constructions for C star that would have the desired properties?

>> Uh yes, I think yeah. So there's a lot of freedom in which line bundle you pick. Yeah. Yeah, so C and C star and I think the curve is pretty restricted based on the optimization you want to do but C and C star at the specific like L1 and L2 yeah there's freedom. Yeah. >> Is there an opportunity for further auto research on this? >> Uh there is. When I tried it I didn't get that much of an improvement.

Uh and it sort of it made other things slightly more complicated. Um okay, so I think I lied a little bit when I said that um this is a perfectly defined like problem to throw at an LLM. Um this cost of computing V times W is a little bit fiddly. Um there are ways you can actually get a shorter K uh or dimension of C star than than the construction that we have in the paper. Um but and it doesn't, like, there's some formal way in it where it doesn't include increase the cost of getting V times [clears throat][snorts] W, but like with this derivative the the way to define V times W is like simple enough that it works very well with sort of like packing the coordinates into words

and just like doing bit wise XOR and bit wise AND. Um that makes it a lot cleaner and a lot faster. Um just because of the way the product rule is is is a lines up. Um so there are optimizations you can do to like get these literal numbers better, but it doesn't actually make the final thing faster. So it's not it's not exactly a perfect L on problem. Yeah. Okay. Any more questions on the definition of the codes?

Uh yeah. So yeah, there there is a lot of like very technical algebraic geometry here, but um the point is that uh the LLM can handle all of that. It knows all of that and it just does all of that very easily. So it gets you Like what what do you actually need here, right? So you need this interpolation and what is this interpolation? Well, basically you have every one hot vector and you have a rational function for every one hot vector. So you just need that table of all the rational functions, like these 64 rational functions, or however many dimensions C star many rational functions. You just need this interpolation map. It's just a linear map. It's just like a single matrix that goes from uh the the the the V to like the V interpolated with all its

derivative values attached. So like in the end you just have this very elementary data and like all the properties you can check on that very elementary data. So yeah. >> Is the interpolation unique? >> Is the interpolation unique? Yes. Yeah, yeah, the interpolation is unique. >> Okay. >> Well, when I yeah, said on the previous slide that like the properties that you have interpolation, I meant unique interpolation. Sorry. Yeah, any more questions? Okay.

Yeah, so yeah, the goal for the explicit code, we have that cost above, so K equals 1, so we want optimize this dimension of C star. Okay, so yeah, you can explicitly construct this by AI. We're going to focus on skipping six rounds, 2 to the end of 64. So, algebraic geometry tells you that the dimension of C star, there there's a theorem called the Riemann-Roch theorem, that this is basically determined by an invariant of the curve X called its genus. So, what you want to do is you want to find the lowest genus curve with 64 solutions over F2 and explicitly compute L1 and L2 and the interpolation maps.

So, you can do this. The AI models did it in a weekend. This would probably have been a month-long computation requiring experts in explicit curve construction before LLMs, but now it's just a weekend and maybe now it's just like a 3-hour thing that you just feed to Astra and it just spits it out. Yeah, and yeah, the key point that I was just explaining is that once you have all the algebraic geometry construction, the actual the actual thing that spit out at the end is very explicit matrices and rational functions. So, the properties of C and C star that you want, they can be very easily verified by a script and a bunch of elementary math. You don't need to worry about geometry to verify the construction once you have it. You just

need to run these scripts and you just need to trust a slightly complicated computation with the with just like polynomials don't have too many roots unless the degree is big. >> And can can we see these matrices and polynomials? >> Yes, but not on this slide. It's in the paper which we have a draft that we can show anyone that wants >> Got it. Thanks. >> Yeah. Yeah. Uh well, okay. Sorry. The explosive polynomials um they're very big. Uh so, it takes a lot of data to present them all. So, there's 64 of them, and each one might be like degree 48, 49.

Um so, it's a lot, but uh yeah, there's also a There's just a file. Yeah. Any more questions? >> Well, I'll ask no big deal. Uh so, I I was confused what you said that you need derivatives to to keep it over the base field. No, because if you if you take the genus to infinity, can't you get as many points as you want over the base field also without the derivatives?

>> Right. Yes. But, if you take the genus to infinity, then the dimension of C star becomes very big. So, like if you do the Yeah. >> the dimension of >> want to minimize the dimension of C star, right? So, Right. So, by Riemann-Roch, um the dimension has to do with the degree of the line bundle. The dimension of the space of sections has to do with the degree of the line bundle and the genus. >> Yeah. >> So, sort of if you want to look at the line bundle, then you wanted to like twice that line bundle. Um and basically, the genus term comes in uh again with the dimension of twice the line bundle. So, you sort of have this overhead for the dimension of C star versus the dimension of C that depends on the genus.

>> Right. >> Thanks. Yeah. >> Uh hi. Uh I just have one simple question. Um are you actually viewing uh sumcheck as a version of the residue theorem? >> No. No, no, no, no. I'm just thinking of sumcheck in as a There's a sort of like tensor code interpretation of sumcheck, where sumcheck lets you do like linear evaluations on codes that are tensor products of of smaller codes. And yeah.

>> Okay, I was just asking because from an algebraic geometry perspective, uh we know how to add things uh in the residue theorem. That that's just my question. But thank you. >> Yeah. May-maybe we should talk afterwards. I'm not quite understanding exactly what you're asking. But yeah. Yeah, we should talk to you afterwards. Yeah. >> Oh, great. >> Okay. So yeah, what do you get? How well does this end up working? Well, you can look at this number that we're trying to optimize. Um for Reed-Solomon, it's about 384 if you want to uh skip six rounds.

Um for the algebraic geometry code that we that you find by the previous slide, um it's about 158. So this number goes down by quite a bit. Um it's even better because you get to stay in F2 and the arithmetic is much more friendly on hardware than F64, um especially on GPUs. So overall, um you can plug this into Flock and it gives about a 2x speed up for the zero check part. Yeah. Yeah. >> What's What's the genus you found? What's What's number of genus? >> Oh, what no Oh, the genus is 95.

>> Wow. >> Yeah. Yeah. Which is it it it Yeah, it's it's fun. When I tell the Yeah, when I tell like my math friends this that there's like a practical application of a genus 95 curve, they they're very happy. So. >> Um what's the consideration in choosing six rounds instead of like five, seven? >> Ah yeah, so this is an interesting thing. Um it's very important that the 64 is a small number here. There's sort of an asymptotic of how many points you're allowed to have based on the genus, and that asymptotic is actually pretty bad. Um so there's some very there's like a small number thing that's going on here that like genus 95 is like way better than it should be. If you go

by the asymptotics, it should be like genus like 150 or something. Um so yeah, if you if you do 128, then yeah, your genus is around like 400 or something, which is a lot worse. Um so 64 is kind of like a good balance between like you're not paying that penalty of like hitting the asymptotic, but it's also like enough that you're speeding up the the sum check by enough. >> We're also skipping six rounds, so that was kind of our starting point. Given these numbers, it would have been maybe nicer to do a seven round skip, but because what we were told we said we couldn't find so far a good enough code.

>> Is that like a search limitation or can you like do you think one might exist? >> I don't think a good one exists for 128. There's there's something called the Serre-Oesterle bound that sort of gives you a lower bound on what the or tells it it the genus can't get better than something. That lower bound is 89 for 64. I don't remember what it is for 128. Yeah. >> Um if if we didn't have the the Nvidia instruction, are you saying that AG skipped would have actually provided GP acceleration using a completely different route?

>> Uh so I think the point of this is that you sort of avoid needing the instruction because like you're moving all the work to just sort of hands and XORs. >> Right. >> Oh yeah, sorry. Yeah. Yeah. >> There's GF There's three fields in play. There's GF2 which is the base field. There's GH which is GF2 to the 128. And then so for unit period skin, you're sending things over everything with Benes introduces using the AS field GF2 to the 8, which is pretty friendly for SimMax. They are not, unfortunately, friendly to GPUs.

Uh so, there's no like built-in AS instructions. Um so, we could not leverage that on GPUs, but our our construction kind of avoids that. We're just staying with GF2. So, there's no use of the AS field. >> That's the issue. Yeah. >> You don't have to worry about the 64F. >> But, this does not avoid needing to work with G hash whatsoever. >> Okay. Got it. But, yeah. On your On your sampling, you're you're round samples. You have to still work with G hash. >> Okay. And is there more of a speed-up than 2x on GPUs? >> Is there more speed-up than 2x on GPUs? Do you remember the >> It's been a while, so I don't remember.

>> Okay. I'm sorry. >> Yeah. >> Hi. Another Another question. What's the relation between the dimensions of L1 and L2? And if if that's built in in the 2x speed-up? >> Yeah. Yeah. Yeah. So, the relation between L1 and L2 is basically this number 158. And that sort of passes into the 2x speed-up. Basically, the dimension of L2 is is twice the dimension of L1 plus the genus of the curve.

>> Oh. Okay. That's it. Thank you. >> Yeah. Which uh Okay. Right. So, uh yeah. So, the last slide um Right. So, right. So, here's one example of something that worked. There's some fancy math that you can do something with. Um I just wanted to throw out a bunch of like other random ideas of maybe sort of like error correcting code related things that fancy math let you do. Um I haven't found anything that these are good for yet, but maybe if everyone has these in mind, there might be something. Um So, okay. Yeah. First of all, their al Um, you don't have to have read Solomon

to get the N log N. There's some very special curves with certain structure in them that also have N log N encoding. Um I don't know what this is useful for. I don't think it helps that much with commitments, but like maybe it does. But this is something to be aware of. Um, one more thing and this is getting more and more fancy, but sort of again, you don't have to be scared of the fanciness. The the the AI knows all the fancy stuff and can do that for you. Um Yeah, so there are these things called Tanner codes, which are codes that you build on sort of graphs or like simplicial complexes by putting like local structures and you get like very nice global properties because of some properties of the graph. And uh there's a thing you can do where you can

Normally these Tanner codes have like a restriction where you can't do very much. Your local codes have to be very high rate, otherwise you don't get anything non-trivial globally. Um, but actually there are ways to have very low rate local codes and actually get interesting things globally. Um, when there's global algebraic structure to the complex and these you can get code words from homology classes or like automorphic forms or some other things. Um, this lets you do some stuff. Uh again, I haven't found an actual practical use for this. Um, and then sort of there's been a lot of recent progress in like constructing these expander complexes and people have used them a lot to like build a lot of interesting error correcting codes. Um, the constants of these have been completely impractical so far, but uh maybe there's

some That's like asymptotics, so there might be some like small number tricks and there might be like better constructions. Um, so yeah, with a lot of automorphic representation theory, you can uh do these with like a lot of There's a lot of structure you can give these complexes that might be different from the ones that like people know about. And then open eyes recent drop, they uh they figured out how to do a thing called co-boundary expanders in every dimension, which uh is very useful for some of the stuff also. So, sorry. This is a lot of like word dropping, but like these are things to sort of keep in mind. Yeah.

>> Um can you say a bit more about when you talk about having, you know, nice local properties and nice global properties, how does that relate to maybe more concrete aspects of the cryptography that we're interested in? Like where does the kind of global and local split between the properties come in with cryptography? >> Yeah, yeah, yeah. So, cryptography you care about what are the global properties you get. So, like one thing that you can ask for is you can ask for a sort of like local testability where um there's a error correcting code where instead of needing like a single >> much within the like proximity testing kind >> It's very much >> of within the information theory part of >> Yeah, yeah, yeah.

And again, like so far like all these constructions are extremely theoretical right now, but um they're things maybe to know exist and sort of at some point someone might find a bunch more clever ideas to like turn them into something practical or like the AI might be able to do something. Yeah. >> So, talking about algebraic geometry, there's breaking news right now where we have a new candidate for better at codes. So, potentially 69 bits. >> Oh my god. >> 69.11 bits [laughter]. So, Alex 6 is cooking some very fancy algebraic geometry using jets or whatever. So, >> Oh my god.

>> that would be a very exciting outcome if you're doing this workshop. We uh we have a new a new breakthrough. >> Yes. >> Um great. [laughter] So, the the trickiness in the proof seems to be that I can take a bunch of jets and I can get them to vanish and you can do proofs of a, you know, kind of it's progressed, you know, by degree by degree in in a very kind of painful slow way. Um the trickiness seems to be making sure that I have an exact an exhaustive count of every case over every possible curve and everything like this. That seems to be where it's stuck.

Which I I I don't basically fully understand so I mean, don't fully don't understand at all. [laughter] >> Yeah, I guess there's a lot of context here. >> Yeah, so I'm trying to I'll try to generate maybe like a a short report of the informalized stuff that I have and make it more legible and we can have a look at it. >> Yes. Okay, I Is that your last slide? >> This is my last slide, yes. >> Okay, amazing talk. Thank you so much. [applause] >> Let's have a warm clap.