Hi, John Jay. We're going to get started and we'll do it. I don't know if the guy who I promised that I was waiting for is back, but it doesn't matter because I've waited for him anyway. Okay, so we're going to talk about Layer 2 today. We're going to talk about particularly something which we've been calling the automatic virtual machine. Now, when most people think of a virtual machine, they think of stacks and registers and all these other things. And I'm not an incredibly advanced computer scientist, so I think I can make an argument that this thing is a virtual machine, but usually when I say OVM, people think of something else. So actually, what we're going to be talking about today is one particular subset helped optimistic game semantics. And basically the idea is what's going on with this Layer 2 and how can we try to bring it under a sort of more unified umbrella? What's up, guys? More unified umbrella. So what are we going to talk about today? First thing we're going to do is we're going to spend some time dissecting what Layer 2 is today and sort of looking at how it functions and what it accomplishes. The next thing that we're going to do is we are going to take all of the components that we use in trying to describe Layer 2 and talk about how we should try to use those to build Layer 2. Okay, and then the last thing here, which I don't know if this is really an agenda point, but it's something that I want, is I do not want to finish these slides. Okay, so the reason that this is like not a video that is up on our website or being posted on our Twitter is because of us, you guys. So what this means is that there's no point in us having this here unless people ask questions and engage, okay? So before I go forward, I'm not going to say no word until someone asks a question.  Presentation. I don't have too optimistic as an oxymoron. Okay, great. All right, so let's motivate this a little bit. So we got Layer 2. Layer 2 is popping. We could even say it's a Cambrian explosion. Can you start with this nice filament? I think don't call me on that one, not really Bitcoin. Very, very simple payment channels of Bitcoin. Then we have the Lightning Hour come out in 2015. Then we started seeing more different state channel designs, right? It's virtual channels, generalized channels, right? We started getting things like Truman and I come from a background of plasma. And plasma is perhaps the most exciting but also guilty of creating huge amounts of diverse designs and varying implementations. This is a small selection of called plasma flavors that we have in the plasma design world. Even more so, we've got other incredible things happening. We've got rollups, the optimism flavor, the ZK flavor. NoCas is a commit chain which is basically plasma if they didn't want to call themselves plasma because they're not plasma. Are we sure how we was in the room? Woo, it's another better version of Truman, right? There's lots and lots of these L2s coming about, right? So this is wonderful. As a researcher, this is very exciting. As a user who wants to be doing different things in Layer 2, this is very exciting. But it's not like all of these ideas are totally unique, right? At the end of the day, most of them are all around one thing and that is this notion of disputes, right? Usually, something happens on the off-main chain and then someone claims something happened on the main chain and then someone else disputes them about it, right? This is sort of the base things that happens. And what we see in a lot of papers is that we completely reinvent this wheel, right? So these are your two Layer 2 protocol N and Layer 2 protocol N plus 1. This is often sort of what we get. I mean this ingest, of course, you know, citations are very important and everyone's standing on the shoulders of giants. But everything uses disputes. This is the point, okay? Another thing that we're realizing is that the sort of meme of one L2 can rule them all other than outside maybe the Bitcoin world because, unfortunately, only Lightning is really possible on Bitcoin. This is a lie. This is just a blatant lie, okay? What we see is the different Layer 2 designs are built for different applications. They're built for different use cases. So what we need to say is C is not one L2 to rule them all but, like, you know, some L2s shaking hands and interoperating because in reality, users are going to want to use many such applications that Layer 2 can provide and it's not going to be just one that gives it to them. That's not to say that we're going to have, you know, thousands perhaps but it would probably have more than one. Okay, so why haven't I got any questions yet? So I'm just going to pause awkwardly again for questions. Does everyone agree with this? Any hot takes? Is everyone going to prove me wrong? There's only one L2 rule them all? Perhaps you've been L2 dev? No? Okay, good. That's what I'd like to hear. So let's try to understand a bit about what Layer 2 really is, okay? So, like, at a high level, I think there's, like, four pretty distinct things that go into Layer 2, okay? Four steps, if you were. So the one thing that you do is you check the blockchain state where the dev cons will say Ethereum. Check the blockchain state. See what's going on right now, right? The next thing that you do, and this is the sort of Layer part, the second Layer, is you get some local information and you look at it and observe it, right? The third thing that you do is you make some kind of an assumption, right? So this is usually of the form I will dispute things and we'll be talking about that a lot here but there's lots of different assumptions you can make. And then the last thing you do is you make some prediction about future L2 state. So when I have, you know, two coins in a channel, what this means is I believe in the future I will be able to withdraw two coins from the channel. It's not really anything other than that, okay? And so an example of this are state channels. I see on-chain there are 5Bs in a channel which is usually just implementable by multisig. I see that I've only signed some certain state, usually the one with the highest nods, right? And your sort of traditional Ethereum-style payment channel. I make the assumption that if someone tries to withdraw from an older state, I'm going to go ahead and bring that state forward and dispute it. And based on that, that loads through things. I can make an assumption based on that. The fourth thing that I will be able to withdraw is that it hits us. Okay, does that make sense to everyone? Questions, comments, concerns. Okay, I'm going to need questions at some point so you guys better buckle up. Okay, great. So we have some fun formalizations that we can make around this, which are very reminiscent of things in the CDC future. So here's the Ethereum blockchain, right? So here's sort of the headstate of Ethereum. And based on the headstate, there's some self-step of the next blocks that can appear, right? These are here. And based on the details of the EVM, you know, maybe you can't unburn money, for example, if you've sent it to zero address, it can't unburn back. But it can be sent to the zero address if it has to be unburned. So here's some money being burned. And now we know that these states are no longer possible, because this is the one that just got mined, right? And so the EVM via the consensus algorithm that we call Ethereum itself and ether is progressing through this futures tone of Ethereum, right? Which is like sort of borrowed from physics, you know, for all the meme, it's not getting the math, it goes into it. And this is what we're doing, right? So this is one thing that happens. What's the only thing that happens? The only thing that happens is we have this local information, right? I'll just bother passing things around. Signatures, inclusion proofs, we've got local information. TM, it's off-chain, right? Okay, the last thing that we do is we make some assumptions, right? So the EVM says that some set of future states are possible, right? This is a pretty large set. And what I do, as someone who's trying to make a prediction about future L2 state, is I make an additional assumption that is not inherent to the EVM, okay? So here imagine sort of two-fourths of the blockchain, right? So imagine that we're at a state right here and someone maliciously tries to withdraw some money, okay? I will assume if I have a channel balance and I'm trusting that I have a channel balance, that at some point in the future, this thing will get disputed, right? So what that means is basically what I'm doing is I'm looking at any such chain where no disputes have occurred and I say I don't believe that this is going to happen. It's an assumption. It's an additional quality of the state. And it's an assumption that you make about the state, right? So we divide those two things. We get something like this, right? We have the finalized blocks that we saw before, right? We have the same Ethereum futures come as before. But now, based on this layer, right? Some of these states which are possible according to EVM are no longer possible according to my assumptions because I believe that I'm going to do something about them. That's usually the assumption, right? This is what we see. And furthermore, one of the things that gives us the great scalability in Ethereum is that this column does not just restrict as new blocks come out. It actually restricts as messages are passed around. So if I get a new message and it tells me I can do a new dispute, this narrows in the cone of future states that I'm assuming are possible. So we can call this our optimistic futures. Okay, with me so far. Yes, nods. Excellent. Questions. Okay, I got a question. Yes. Yes! There you go. Why can we assume that it's going to be this assumption is here in its content but why can we assume that someone doesn't have an outside motivation not to result in the correct state? Ah, so that's a great question. And so, you know, extra protocol incentives are talked a lot about even in layer one and certainly in layer two. And they're an active area of research and we need to continue researching these things. In general, however, we believe this because we think that blockchains are meant to be censorship-resistant. So usually in layer two we use the properties that we're assuming that L1 fulfills to make our assumptions sound reasonable. So in a proof of work world, right, we have this decentralized network where anyone can start, you know, burning some electricity to mine a block and because anyone in the world is going to do that, I have my fingers crossed that in the next, you know, whatever the dispute period in terms of blocks are, at least one of those people are going to be willing to accept my transaction. But that's not to be said that there aren't, like, important nuances to be analyzed here. So one critical example of this that we have to be careful about is what if the dispute, to keep my money safe, costs me more money than the dispute itself, it costs me more money than the dispute is going to get me, right? So that happens when we're in trouble. So we want to be careful and design our protocols carefully so that the assumptions that we make are as reasonable as possible. Can I ask another question? That was one. You may ask a third one. That's the one that I just saw. It looks like it's not invented anymore, but it is still invented.  What a segue. Is this what we can do? You're totally right. So unfortunately, we can't just write a computer program that does a for loop over all the future Ethereum states that are possible and checks whether they analyze your assumptions. This is computationally infeasible, right? So this is a great tool for, what we've described so far is a great framework, a great model for describing how Layer 2 protocols that exist work. But you're right that it's not really useful in constructing some sort of Layer 2 client that is unified or magically combined everything in one way, because this is a very, very large set in fact, infinite. Now, maybe with the gas limit and the fact that there's only so many lights, it's actually kind of finite, but there's way more atoms than atoms in the universe worth of these things, right? Yeah, so exactly right. So what we've been doing here is we've been looking at Layer 2, right? This framework that we just talked about is a way that you look at Layer 2 systems. It is not, however, very as useful in building Layer 2 systems, right? But somehow this is what we really want to do, right? At the end of the day, research should be motivated by actionable things, and what we really want is to be able to build Layer 2 protocols in some framework that extends beyond, you know, a particular plasma researcher who has intuitions for what plasma does and a particular channel's researcher has intuitions for what channels do and so on and so forth. We want to try to unify this under one sort of shared framework, right? So we want, like, what I like to think of that is dispute Legos, right? We want some way to contextualize and instead of replacing, so like in plasma, for example, we feel like very guilty of this, we have like limbo swaps and limbo exits and, you know, it-a-it challenges and all these things. And these are very, very useful for us as plasma researchers to be able to talk to each other, but they're not good when we want to bring someone new on board because we have to teach them all of this stuff, right? And what, you know, the people who want to be taught to do to understand is like logic and math and models, right? So we want to be able to push that and so that's going to be sort of the goal of what we're going to do here today. Great question, great question. So we want to be able to build things because the space is just too large, it's basically infinite, you know, for all intents and purposes, right? This is too big to compute. Here we go. I wish you could ask them one slide later. I would have been able to switch from you really or I just put this slide earlier. But you're exactly right, right? So we want something that is easier to compute, but we also want something that is flexible enough to build a protocol, right? So for example, there's a layer 2 protocol that says I can burn all of my money whenever I want and of course once it's burnt, you're never going to go back from it being unburnt. This is a very useful protocol, right? So we want somewhere in the middle between the spectrum of just like four looping over all Ethereum blocks, this can't be done without, you know, a magically infinite computer and something that's actually useful. So that's what we're going to try to pull out here today. Okay, other questions? Other questions? All right, good. Okay, well, I'll push on for now. So let's talk about some hints, okay? I pulled these from a couple of different layer 2 sort of designs and protocols. So in the upper right here, upper right here we have some local information. This is a great paper called NoCust. It's a commit chain. It's very similar to Plasma. So they, lo and behold, have this notion of local information, right? It's the same thing that we were talking about before. A few slides back of what we call the iLocal. They're using that in their paper. Okay, now there's another hint that I'd like to share here, which is from the generalized state channels paper. So great work by the counterfactual team, which is now being unified across almost all state channels for Ethereum. This is very exciting. There's a for all here. Okay, I like for alls. And you'll see me talk about for alls a lot for the rest of these slides. So there's another hint, for all. So here's one from a co-worker of mine. Challenges. This is from a Plasma paper. And there's a notion of challenges, right? It seems like disputes are primarily based on challenges. One person says one thing, another challenges it with another. And in more advanced protocols we even have several layers of challenges. One guy says one thing, another guy challenges, and then the first guy responds again, okay? So here's some sort of, these are what I think are hints that will sort of lead us to being able to construct something very useful. Okay, that makes sense. Questions there? Okay, everyone has a talk slide. If they talk, so I'll have mine here. One of, the word that I love from this tree, which I'll, okay, I guess I'll read it. Not to insult you all. We're not able to block you, not to prove existence, it's proof of inexistence. The ability to prove the message has to be one and only one sort of type that is inside, or the message of some type has not been published yet. So this is very often a property that we see in our L2 protocols. Someone makes a challenge and there is a possible response that can be made, but after some time out, that response isn't made. And we take that as to say, well, this must be the response that doesn't exist, okay? And so existence particularly is the word here I want to pull out. So we've seen some challenges, we've seen some for-alls, and we've seen existence. And it turns out that there is something that has a lot of those same words, okay? So it's the first order logic, right?  So what we're going to go through and the rest of this is we're going to look at this within the context of L2, right? So we looked at this for a while, and it was very interesting to us as researchers that there were sort of analogies here, and we came up, we tried to come up with some designs for how this could be sort of integrated into L2 in practice. It took us a while to hit one that we thought was pretty solid. But a big, big key moment that helped us understand this was we found something called Dialogical Logic, okay? This is related to a broader field called Game Semantics, and I started this talk by saying Game Semantics, right? So Dialogical Logic is an interpretation of these first order logic sort of expressions and evaluating whether the truths or false by interpreting each expression as a game. And it interprets truth of this expression as the existence of a winning or losing strategy for the equivalent game, okay? So this is very interesting. And just for context, so semantics, it took me a long time to figure out what semantics meant because I've never taken a semantics course or anything. So semantics is like meaning, right? So first order logic, there's actually lots of logics which are sort of satisfied by the language that uses for all and exists, right? And so these are very important, by the way. So remember, the upside down A is like for all, you know, I don't know why you put it upside down. But new, the backwards E is exists. I guess we're just like inverting letters in the language they mean A and E. What's that? Otherwise they mean A and E. Otherwise they mean A and E. That sounds very tautologically true, I suppose. Okay, so it's worth understanding that there are different semantics for the same sort of language of first order logic, okay? So a simple example of this is like classical logic is the one that you learn in logic 101, it's what everyone's familiar with. And this is where you can prove something like true or false, right? There's also something called intuitionistic logic which turns out it was like philosophers arguing about logic and saying, we don't like this thing called the law of excluded middle. So classical logic, for any proposition P, you can say P or not P, right? And then that's decided to be true. Sounds reasonable, right? It's either true or it's false. But apparently these philosopher guys are like, well, I don't know if everything's true or false. Like maybe something's not, right? And so intuitionistic logic is like a version of logic which removes the ability to say true or P or not P, okay? So these are semantics. Depending on how you interpret what the language means, these are called semantics. And so we want to have one of these for layer two. So we're going to call it optimistic game semantics because basically the way that layer two scales is you use an optimistic property. You assume that everyone's going to play along and so the blockchain has to process less information for the total computation that went into the state machine that was running off-chain, okay? That was making these optimistic decisions. Okay, so that was a lot. So I hope that we have some questions at this point in time. Come on, someone had to leave a poll in there. Do you have a concrete example? Absolutely, okay. A concrete example of what? How does it relate to L2? Ah, so that's going to be the rest of the presentation. Let me give you a simple example, okay? So in logic, we'll hit on this later, but in logic there are these things called atomic predicates, okay? So it's very simple atomic predicates like equals, right? Like one equals two is either true or false. I think it's false. Yes, and so on and so forth. So here's another example of an atomic predicate, okay? Verify signature, okay? This is another example of an atomic predicate, okay? So in state channels, what is a state channel? Well, you can build a state channel out of a multi-state and thankfully Bitcoin has multi-stakes and this is why Bitcoin can do channels. So here's an example of intuition for how we're going to do this. You can write a function called verify multi-state, right? It's an atomic predicate that verifies a multi-state. So let's say there's like some participants, right?  So let's say there's like five participants, right? We can write a verify multi-state, right? Which takes in the participants, right? Saves, right? And the message being signed, right? Okay, so this is another example of an atomic predicate, right? The value of this is true or false. Wouldn't it be nice if instead of having to redefine this thing, we could say for all P in participants verify C, right? Okay, so hopefully that's an instructive example. So the idea that we're trying to do here is we're trying to pull out these sort of very, like very large monstrosity Frankenstein layer two solutions where we have to write a bunch of custom things like this and try to, like, convince them down into a composition of these logical statements, okay? So we want to say for all the P in participants verify the sync of that individual P.  So hopefully that's a helpful example. Great, other questions? So when you said that the logic you're talking about is a strategy, a winning strategy and losing strategy for a game, what does that mean? Okay, so I'll get into that. And so maybe I'll just try to provide intuition now because I'll have an actual game tree example soon. But what that means is we take the logical expression and we convert it into a game tree, okay? So let me actually, let me go outside. So here I really should have switched to this slide immediately because this is the answer to the first question. Here's some intuitions for what this is. There does not exist a signature such that. This is an example, interesting layer 2e logical proposition, right? For all blocks such that. The signature satisfies x and y, right? We have this logical connective and y. You have to be really careful about there does not exist a signature in systems like this because there exists a signature, right? There is some string of bits that's a valid signature. Absolutely, so this is a great question. And not to skip the gun a little bit. Logical omniscience. This is the problem that we face. So in theory all signatures exist. In from a logical perspective all hash functions have an unlimited number of pre-images that satisfy the given hash, right? So we're going to talk about how to solve that problem. And one of the more important future works that I hope will take, I can get out of someone in this audience is to do a much better job analyzing that than I can because I did a very bad job and there's some minimal approach to be able to get this thing out there. Okay, so spoiler alert. Okay, all right. Okay, yes, so we have to be very careful about how we construct these things. But we're doing it in layer 2s anyway, so it's really just saying we have to be careful about how we do it in layer 2. But again, this is an important distinction. So even though in some logical interpretation, right? A semantics, there is a semantics for the precise logical expression that says that this is always true because all signatures exist out there. There's always a string of bits. But we're going to provide a semantics that sometimes will be false, namely if I haven't sent that signature to anyone else. So, right, I mean, one of the standard approaches is to talk about a party having knowledge of a signature. Correct. Right, which is a different kind of statement. Correct. So there are lots of approaches to knowledge. I went down a long rabbit hole on this and it's called Cricky Semantics, which defines a set of worlds, W. You'll see something borrowed from that here in these slides. It defines an accessibility relation, a way to progress through worlds. So if it's in the future, if we want to talk about temporal logic to do with time, and there's one for knowledge as well, and so on and so forth. We're not going to give a rigorous treatment of that here. What we're going to talk about today is just the first step in sort of formalizing all of L2, which is let's just look at the games. Let's just look at the games. And so we'll do a very simple, crappy job of the knowledge that is not rigorous, and I don't think you could prove. Hopefully there's someone here or at DevCon that I will be able to talk to more about universal feasibility and these computability assumptions that's going to be able to inform much better than I ever could. Yes? I know that you spoke to some researchers that are specializing in normal logic. I have, I have. So I'm lucky enough to see a few of those faces in the crowd, and there's definitely more to speak to. So one of the goals of this work is to be able to pass that part off to someone else who can do this much better than I can because there's only so much time of the day and I can't, but I can try to help. Okay, so, oh wait, other questions. Excuse me, I should not have done that yet. Other questions? Again, the goal is to not go through these slides, guys. I'm telling you, that is the successful stage. So ask away, ask away. Okay, but no questions, so let's get into it. Okay, so let's define this language that we're in orbit with. Okay, it's a very simple first order language. Okay, these guys are called quantifiers. Okay, this guy's four all, the upside down A and inverted A, I guess it's weird, upside down depending on how you treat it. This is your four all, also known as universal quantification. This is four all, it's sort of universal. This exists, it's called the dual of four all. It's existential quantification. So we actually, when we write this in practice, we write something like four all x in x, okay? And we write exist x in x, right? And then this is like a such that, you know, like some p of x, right? Some p of x. And then notably, in most logics, these two quantifiers are the duals of each other, so not, so this is going to be our not, by the way, so not four all, not is the same thing as exist and not exist, not is the same thing as four all. Okay, so that's just an interesting little tip there. Anyway, so then we're also going to use and, okay, so you're sort of upside down B or, you know, inverted B, whatever, because we've got the same problems in universal quantifier. This is your and, this is your not, this is your or. Okay, good, makes sense? Yes, yes, okay, excellent. Okay, so I'm just going to briefly talk about some notations that we will use within this language. So there are these, I wrote a p over there that wasn't coincidental.  So this is any expression in this language which evaluates to true or false, okay? And technically that means it's closed, so there's no variable floating around in there, all the variables are well-defined, and it's well-formed, aka, you know, the string not not with nothing after it is not a well-formed proposition, it's just like this weird vacuous statement that has no meaning, right? Okay, now along with propositions, we also have formulas, okay, which accept as an input some variable. So for example, x equals five is an example of a p of x, right? p of x, you know, sorry, x greater than five is an example of a formula because you can plug in different x's and they'll be true or false and they're free in x, right? Okay, that makes sense, everyone? Excellent, okay. And we're going to use this weird notation for p of t. So this is a little tricky, but what we're doing here is we're plugging in t for x, okay? So, right, we say out there, any more fancy words than I can speak on stage. But for example, for the p of x greater than five, p of x slash ten would be ten greater than five, right, which would happen to be true, right? Good, makes sense, makes sense? Questions, comments, concerns? So the notation is just the particular evaluation of p where x is equal to two. Correct, it's a particular, you plug in it, it's very hard to see the bottom. Ah, yes, okay, okay, apologies for that. Please shout out if you can't see things and we will whiteboard them or I will go out of full screen and zoom in or whatever we need to do to make it work. Yes, exactly. So in fact, why don't I just go ahead and do that? So p of x, can you read that? Maybe that's the same exact time. Can you read that? Okay, so we've got some p of two, p of x, let's say p of x will define it with a dot dot equals this thing, you know, is x greater than five, then, you know, p of x, which direction do I get to slash, p of x to slash ten would, you know, would be equivalent to ten greater than five, okay? So we have x is free here and now ten has been substituted into seven corrects. Good, okay, excellent, excellent. Thank you. Now it happens, oh, I have a microphone. I don't even have a microphone. Can you even read out the top line on the very right? I absolutely can. I'm sorry, is this the top line or is this? Okay, yes. What does it say? Well, let's read it out loud. So there's actually two, there's actually, I'm gonna just draw a dotted line here, there's actually two of them. Ah. So that's maybe what it was trying to do. Yes. So this expression right out now says for all x and x, so little x and big x, right, is the set, the domain of quantification, p of x, okay? And this says there exists x in x such that p of x, okay? Right, and so what we will see, right, what we'll end up seeing is we're gonna be, we're gonna start building up disputes where if someone says for all x and p of x, somebody else is gonna say, ah, I have this x and I claim not p slash, you know, whatever the special case is that they're trying to discourage. Just kidding. Great. Okay, other questions? Excellent. And how are we doing on time? Oh, great. I don't think we'll finish. It's fantastic. When do we get out here? 3.15? Does anyone know? Okay, let's call it 3.15. Okay, and then the last thing that we're gonna cover in this language, which we touched on before, you've got atomic propositions. So if the other thing was too small, this is definitely too small, but what's a simple atomic proposition? Equals. So actually that's a bit of a lie. Equals is really a connective, so really five equals 10. That's an atomic proposition and evaluates to false, right? But things where both sides of the equals are filled become an atomic proposition. Greater than, there's another example, right? Less than, there's another example. Okay, and then there's three in particular which are gonna be very interesting to us building layer two things, which is, is this thing the hash preimage? So is this little h the hash preimage to this big h? Which basically is equivalent to saying hash of little h equals h, right? These are these two atomic propositions. Well, we got lights turned off. What's going on there? Ah, thank you, no worries. Right, okay. Another one is verify signature, right? So we're all familiar with signatures in the wild west of cryptocurrency. Signatures are very important. Actually, you can build a signature with a hash function, it turns out. Lamport, largely lamport, great guy. And the last thing, verify inclusion, okay, where you verify inclusion of the thing over. Yes. All functions that are evaluated to true are false atomic propositions. Any function you can imagine? Um, so I, I'm only as a, my, my intuitive answer is yes. And I think intuitively you should think of this as, no, no, no, actually. Without other ways? Okay. So, no, no, no, no. The important thing is that it is free of these logical connectives, okay? So if you have some ands and some nots and some ors or some quantifiers, this isn't. So A and B, where A are true atomic propositions, is not atomic. That might be breaking, I don't know, it's possible. I'm not a super, super deep logicians. It's possible that that's broken. But that's how I think about it. But the big one that, that, that is, makes an atomic proposition is not having for all and exists, right? Not having quantification. That's, that's, that ends up being the big one. Um, yeah, great question, great question. So anything that evaluates to true or false is a proposition. And atomic proposition is one that doesn't have many of these, these bad boys in there. Because these are sort of indicators that there's more logical structure beyond just some sort of simple function evaluation. Yeah, yeah, yeah, yeah. Yeah, you can go back to the constant. Um, is there, yeah, with all the constant. Yeah, is that the reason for the inconsistent use of language? Where like, I mean the atomic propositions like, is equal to, is hash pre-image but all of a sudden then you're, instead of like, is valid signature? Do you have like, very high signature? Which sounds like, is that just bad? Well, it's certainly my accident. It's a great product. So I, you know, I should, I should make a note to update the paper to have more consistency there. Yeah. I was actually the most egregious, I obviously, there's something more egregious in consistency than that, which is that I should have in the parentheses here, you know, signature message pubkey and I should have, you know, the four inputs to verify the solution. But absolutely, yeah. So that is, that is my bad, my bad, small political consistency. But hopefully, hopefully gets the point across. Yes. Um, are there quantifiers you don't like? Because, like, if you're considering, like, atomic binary evaluations and those things, those are like, all those, like, built-in. But it is, it seems strange that you can't express, like, uh, player I know that there exists H so that H is a pre-image of... Uh, and you're listening to the knowledge, you want the knowledge to be a quantifier. Yeah. Is that what you're saying? Yeah. Um, so I, I, I, I, this is why I'm excited to jam with you after this BI, because that's totally a valid question. So there's, like, you can think of two layers happening here, okay? So the layer that we're going to cover mostly in all these slides is the unshamed layer, okay? And there's, there's a relationship to off-chain, but it's not as well defined off-chain as it is for on-chain. What we're doing here is we're just building the dispute games that go on-chain, okay? So what we're going to end up doing is going to try to construct a contract that sort of implements the ability to check the truth or, you know, false evaluation of these things. Um, so it, it, it is sort of more, even less classical logic than these ones. The, the, my knowledge versus your knowledge is actually ends up being a quantifier. Um, that, that's absolutely right. We're going to ignore that for now. We'll, we'll treat that very simply. We'll, we'll have something called a computability model. It's not as well formed as, as, as to be, like, you know, very, very well quantified. Um, but you're absolutely right. But for now, for the intensive purposes of this, um, all we're going to think about is for all, and exist. And, and it should be noted that there are many extensions of the semantics I'm going to cover here. Um, so, for instance, the binary search game, which the true-the-guides use, I've, I've, I've messed around with writing it as before all exists, for all exists. Uh, but I'm not sure if it doesn't denote its own quantifier or, uh, or, or connect it. It, it, it might even want that. Right. Okay. Other questions before proceeding? Let's get to it. So, what we want to do is we want to take these expressions, right? Things of, you know, the form of some of the things that we're looking at here. And we want to turn them into games, okay? This is our goal. We want to, so these logical expressions, we want to evaluate their sort of truthiness, whether they're true or false, in relation to some game, okay? And eventually the goal is for this to be a game played on chain. It's going to correspond to the dispute contract or the deposit contract, you know, depending on what layer two protocol we're going to ask. Um, so we're going to, we're going to, for now, we're going to talk about two players.  That sounds good. And as sub-ins, A and B, capital A and capital B, are going to be variables representing either the prover or the opponent, such that A is not equal to B, but they might be one or the other, okay? Does that make sense? So, very often we want to talk about a player generically and we want to talk about the other player generically, so we'll call one A and we'll call one B. Everyone good with that? Great. Okay, okay. So these are the two people that are playing this imaginary game. And this game, again, is our interpretation of the logic. It's what gives the semantics the meaning to the logic that we're going to try to make into layer two constructions. Good. Great. Okay. So here's a game stage. So a game stage is a tuple of two things. A player, remember A, what you said is either, this is either the prover or the opponent, but we don't care about this at this point. We call this the defending player, okay? Now the other thing here is the current proposition. We also think of it as the proposition being defended by the defending player, okay? So this is a state of the game, okay? So if the game is currently in some position, there's going to be a defending player specified and a current proposition specified, right? Sound good? Sound good, everyone? Makes sense? And what did I say here? Okay, yeah, so this is saying that in some words with maybe the people in the back can't read. Oh, yeah. So we might say that this game stage is A signed, I don't know, this is something that I found in a lot of games and antics and logic. So an A signed state is one in which A is the defending player. Just an extra little notation. That I may or may not slip up and use through the rest of this presentation. Okay, that makes sense to everyone, right? Pretty straightforward. Okay, so the next thing we've got to find, now that we know what the state of a game can be, we want to talk about how the state of a game can progress, right? How does it move through the iterations? Okay, the way that we're going to do it is this return-based sequence of challenges, okay? So this is going to be one game state, okay? That's something that's going to happen, this is going to be the new game state, okay? That's something that's going to happen, this is going to be the next game state, okay? Okay, does that sound reasonable, everyone? Makes sense? Right, I know that these are going to be different propositions, okay? So this is P0, P1, P2, right? These are going to be different expressions. Makes sense so far? Always back and forth between base. What's that? Always back and forth between base. Always turn-based, yeah, always turn-based. One thing that's important to illustrate here is that these semantics that I'm going to define, I know Sebastian's going to yell at me immediately after this for saying a bunch of things that don't reflect some of the nuances of things like copycat strategies and other really strange things in very developed game semantics, but this will be sufficient to provide this will be sufficient to provide some intuition for why this is possible and what the contract that we want to know should look like. So for our purposes, for the intro to purposes, A says something, B says na-ah, something else, A says na-ah, na-ah, something else, something else, and so on and so forth, right? Okay, yeah, cool. Does that make sense to everyone? Okay, now we get the real neat and bones, okay? This is like the B's knees of what we're going to talk about here. Let's define the rules from which A, P0 goes to B, P1, okay? So here are the rules. Rule number one. Okay, well, first of all, I'll just talk about how this table is, okay? This table is a mistake. And now the opponent, so B here might or might not have to make a choice, might have to provide some input, okay? In this case, they don't. And this is going to be our new resulting state, okay? So this is our thing to the left of the arrow and this is going to be our thing to the right of the arrow, okay? So we call these challenge rules. This is how the game will progress through the steps. Makes sense? Okay, so what's the first challenge rule? It's very, very simple. If A is defending a statement of the form then B may challenge by claiming P, okay? It makes a lot of sense. I say that, you know, the sky is not blue and my opponent responds with, well, the sky is blue, okay? Makes sense. Why is it not the other way around? It will make more sense than if A says it's P and B says it's not P because I say I have a balance of 50 and P says no, you don't. Great question. So the reason that we want to avoid that is because what we want to do is we want to slowly take these very complex expressions and reduce them down. So for example, if A could say P and then B could say not P, then A could say not not P and then B could say not not not P and then C could say not not not P, right? And so all we're doing is growing this logical expression. What we really want to do is make the expression smaller because we want to get down to something eventually that we can evaluate on chain very easily. So that's a great question and intuitively this makes sense that in A you can play not A but what we want to do is providing such a way that these games sort of reduce so that ends up being the reason. Great question. Great question. But the intuition is there. The idea is that the game can transform in a way that if one person says something the other person says something else that disengages. So that's exactly the right intuition. Okay, does this rule make sense? Nice. Here's a final one. So A says P0 and P1 that B has a choice. B may either choose 0 or 1. They choose the left of the AND or the right of the AND. And B says not PI. So here's an example of where not does get added on. But we've reduced the AND into something else. Okay, so hopefully that makes sense. Sounds very logical. If A says the sky is blue and it is raining then B may either say the sky is not blue or it is not raining. This is how we respond. And so notably, if we were to be here then the next, the miserable would apply. And A and B are sort of switched now. But now we would get the A over here and actually saying PI over here. So this should start to give an intuition for how these games progress. Okay, here's another one, or. So or is something that either if the left is true or the right is true, then it's true. So what happens if A says P0 or P1 then B has to respond by saying not P0 and not P1. So the only way for this statement to sort of be false is if both of these things are false because this is what the or does. It's conjunction or distraction or something like that. So does that make sense to everyone? This one is bigger? This one is bigger. So it is bigger, that's true but now it feeds into this rule. So notably this outcome has this rule applied to it and this outcome is able to have this rule applied to it which will then be able to have this rule applied to it. So what we'll find is that even though this one looks a little bigger because there's now two knots and a hand as opposed to just one orb eventually things will reduce down. We'll always get smaller and smaller. So it's not a repetition from a core proposition? No, it's not a size. It's a distance from a core proposition. Yeah, it's an intuitive reduction. The goal is to eventually go around so we're just checking one signature. So to verify a multi-sync example that I gave we want to say for all P less than participants. The great thing about doing a multi-sync this way is you can disprove the multi-sync not by checking all participants but by simply providing the one that's not true. And so this ends up being what happens a lot in layer 2 protocols. For example, in plasma you make a rule that says for all blocks less than the one I'm exiting from this condition is satisfied. It would be very expensive and it would break the scalability of your system to check all those blocks on chain but instead you only check the individual ones that people decide to respond to. Great question. Okay, oh others before we get to you. Great. Here's a fun one. This one takes maybe a little more hair here. These are pretty straightforward. Now we're going to throw them into quantifiers. The first one we'll talk about is the existential quantifier. Okay? So the existential quantifier let's just read the statement. A is defending the proposition there exists X such that P of X. Okay? So how do we respond to this? The way that B is allowed to respond to this is that I disagree. For all X, not P of X. Okay? So this should make sense. So if I say every day in the last year or there was a day last year when it rained. Okay? Someone else could respond and say no. Every day last year it did not rain. Okay? So hopefully that makes sense. It should be fairly intuitive. And again, these are all very intuitive, right? We're just providing a particular formulation for this. Okay, so now we have the last one and as well as the caption the universal quantifier and this is a big one. So if A says for all X, P of X B may choose a particular T in X and say not P of T replaced in X or yes, P replaced in X. Okay? So if player B says it rained every day last year player B can say it did not rain on January 3rd of last year. Right? So this is a very important one. It is one of the main things that gets us the scalability of these solutions is that we can evaluate whether something is true for all of these things with this dispute assumption by simply only analyzing particular ones that people are claiming it's not true for. So this is the really key to the meat and potatoes of our scalability under this construction. Yes? Could all of these rules lead to infinite challenges? Ah, great question. Can all of these rules lead to infinite challenges? My gut says no. I don't have a proof for you so I won't say that absolutely. But my gut says no and I think that would hold up and there's lots of results. So this is, by the way, I very, very close to stole this from this dialogical logic thing and in dialogical logic there are lots of results that say that a semantics that are very similar to the structure have few differences but very similar exactly correspond to things like classical logic. There's another version that corresponds to intuitionistic logic. There's another that corresponds to linear logic and all these other and blah, blah, blah. I think there's one for dependent types because apparently types are also I don't know any of that. But I believe that there would be a result and when you think about it it kind of makes sense. These things are sort of getting smaller and I don't see any place for you to start looping when you do anything. Question? Yes. Sorry, could you speak up a little bit? Yes, sorry. The last few conditions can you explain why they go into a loop? Ah, so they don't go into a loop. So it exists, turns into a four-all but a four-all does not turn into exist. A four-all just gets rid of the four-all and puts a knot in front. Right? So maybe I'll just do a progression now, okay? So let's say someone says exists x in x such that p of x okay? Let's say a, a says this and the next thing we would have we would have b say four-all x in x p of x and then we would have a say again a would pick a particular t and a would say knot, knot, p of t. Yeah, so the four-all doesn't loop back into exist so we're okay, we're good, we're good. No internal loops as far as I've made it see. So for the last one that means which means the p t is not p t, right? That the last one? So the middle one says let me just read this off a says a says there was a day last year such that it rained b says for all days last year it did not rain a says it did not not rain on January 12th of last year okay and of course the not knot will eventually be solved in the p saying not p and then a saying p as we respect not knot increases to not knot p increases to p okay does that help? Cool, oh screen died other questions I thought I said does the challenge game allow you to ban strikes? I mean like for example if someone says that for all previous blocks the statement a holds and then the other guy says oh it doesn't hold for block 0 and then the other guy says no it holds for block 0 but the other guy said oh I actually meant it doesn't hold for block 1 but that's how it works Great question so just to read the questions that everyone can hear the question is do we allow sort of replays do we allow maybe some guy says for all blocks some guy says not for this block but really it was not for this block we might get stuck down this wrong trail when the right trail is over here so we have a contract design that basically makes it so that A and B where it really P and O are like these sort of imaginary players we replace that with one in which anybody can sort of play on behalf of P and O so what we go is from one string of plays to trees of plays and so this allows you multiple people to dispute multiple blocks all in parallel so great question others cool so with that there's one last thing to cover which is what the heck happens at the end of this game that's the one thing that we haven't gone over what the hell is going on at the end game outcomes so the game is going to end when we hit an atomic proposition so for example over here if P had been an atomic proposition the next thing we'd get here was B saying not P of this thing and then we'd have A saying P and now we don't know how to reduce it any further so when we can't reduce it any further this is when the game is either one or lost and the outcome that you assign is quite as you would expect if A is true so let's say the game state is B A so again B is one player either the proof of the opponent we don't know which but not the same as A and some atomic proposition A so I have a little A for this atom so if the game state has ended in B A then if A is true because again atomic propositions have a truth's value associated with them if A is true then B wins therefore A loses but really B can win because if you were to actually play the game B could make a mistake and lose absolutely right so we'll talk about that a little bit more later but for right now all we're going to be doing is talking about if the game had ended this way so what you're talking about is the behavior of how people play the game so if I say for all days last year I could definitely lose depending on which day I pick if I pick the wrong day right and this matters because you can't if you actually play the game between two players in a real system you can't go back and say well A won therefore A must have been right in the beginning that's correct so there actually are layer 2 designs that correspond to doing precisely that that's actually something that's a pretty reasonable design so maybe that would be too much of a sidetrack to get into that all now but there are cases in which maybe you might want to be lenient in that way because it does give you some advantages but it's a good point I mean from a security standpoint the fact that A the fact that A won the game doesn't establish that little A was true in the beginning right so you would need an additional argument about incentives somehow absolutely so you would have to make to get to any kind of conclusion absolutely right however if you make the assumption that everybody knows that if any game plays out that involves them in some way and it's one then we assume all the possible sub games that could have been played out would have been one then that's okay so there's nuance there and I know the hesitation that you have through multiple terms it's only like really if a game was one all possible challenges would have been lost that's really the assumption that you can make that other way which your protocols make but that's not correct right if you and I play chess and you win it doesn't mean that well it could it doesn't mean that I never had a sure win position on the board it might be that I actually had a winning position I just missed it right so this is the case however there are somewhere this is a bit of a sign so I'll try to keep it relatively short but there are some cases in which we can make that and particularly we're okay making an assumption if we tell you ahead of time hey buddy your life depends on this chess game because every other chess game that you're playing next in the future is going to be dependent on whether you're able to win this game it's okay if I suffer because the game came out that way but if everybody else suffers because I messed up the game very true that's a design problem very true so some of the major design problems there we can tackle and the ones that are sort of contextual subjective decisions you might want to make or not make in your later two protocol those are choices that you can make yes is it the game that you're playing a game on the results of the game that was already played in which case like you would already know who won the chess game so now you're playing a game of like did you win the chess game problem is that about it but even so if then won the chess game I might he might mess up then we play a game about who really won the chess game if he makes a mistake I could win the second game and convince the room that I beat him in chess right and then all the people who put down bets on him have to pay me even though they deserve to if I make a mathematical claim and then someone says no but I have a count example and the count example turns out not to be true that doesn't mean that my claim is correct but someone else can find a valid count example if you have an exit claim like a exit period like a claim that's a dollar and a claim can not be true other people can sit and make other claims absolutely right so like one claim one pale claim doesn't mean there's no contest anymore right that's maybe an illuminating example I think I think we'll cut it short because there's a whole separate discussion right now it's pretty separate from the way that you implement a contract and so one of the key things that you want to do when you turn these semantics into a smart contract that you're running on a blockchain is that if someone else makes the wrong move and you know that they're making the wrong move you can't let that screw them over you have to be able to sort of start a new game from a different point in the tree where you make the move that you believe is right and so there's a contract design that allows you to do that but anyway there's one I want to have but I also well I said I didn't want to get through outside but I want to get through a couple more I don't want to get through a couple more okay okay so does this make sense to everyone you're defending some game you're defending something if you're defending something that's true you won if you're defending something that's false you've lost right make sense cool excellent okay come on master here we go okay so now we have a game tree it's called comic propositions f and t how will they be assigning truth values do you guess it f is false t is true okay can everyone read this by the way it's possible some people can't read this so game tree for false or true so the game always starts with a prooper I haven't mentioned that yet but it's pretty obvious the game is initiated by the prooper they're the one trying to prove it so they make the first defense of the thing being proven so false or true now there's only one response according to the challenge rules that O has which is to say not false and not true so that is according to rule number 3 here p0 or p1 not p0 and not p1 so false or true, not false and not true make sense ok so now we have an and for an and p now has a choice p can either say not on the left or not to the right so let's say p chooses i equals 0 a.k.a the left now p is going to say not the thing on the left which is not not false ok and of course not not false by p is retorted by not false by O which is retorted by false by p right and so of course this game outcome is going to be 1 by O so the reason that it's 1 is because f is in the time of proposition p is defending a false time proposition is 1 by p so does that side make sense 1 by O ok and of course the other side is going to be the case where 1 which is the side that you should always pick if someone says not false and not true well you should obviously go ahead and say not not true because that's true so we have not not true the same thing happens we reduce the not true and we reduce the true and that's 1 by p we have now taken this expression this expression in the syntax just the language of first order logic and we've interpreted it as this tree is everyone here good awesome ok so that's great so now we've divided tree but we still haven't answered the question what does it mean for this thing to be true or false we've interpreted this expression as a tree now how do we look at this tree and understand whether or not the thing is actually true or false but that's going to be the next question that we're going to ask and the answer is going to be strategies ok so what is the strategy and I promise we're almost through we're almost to the good stuff the finding way to do protocols so of course a strategy is a sub tree and actually maybe I'll just skip to the TLDR of the game strategy a strategy for player A is where you start off with the base state and you look at all the possible challenges that B can make what's everything that B could say if player A said the first thing so for all challenges winning strategy says for all the challenges that B could have done A must have a response to that I have to be able to deal with that case so you look at all the challenges by B you pick a specific counter challenge that should say A pick a specific counter challenge and I'm offline that thing highlighted right there is A hopefully I can hit present again oh baby don't worry unless my phone died we're going to be good so a strategy is when player A says ok I'm playing A I'm going to win this what's my strategy here my strategy is I'm going to look at all the possible things that B could do I don't know what I'm going to do in response and then for everything that's done in response what are all the things that they could do in response to that and for each one of those I've got to pick something as well ok and so this defines a strategy for player A so for example we're going to reload here what slide was that 46 I can fix it 8 ok so we repeat this process let me just go to the board because the board is going to be useful here so at a high level what is the strategy let's look at a strategy for the prover P ok so we have some root state here this is you know P you know P I'm not going to write out this thing for all the examples but what is the strategy for the prover P a strategy is we look at all the possible next nodes in the tree so these are all the things that could be played by O ok so these are all going to be in the form O something O something else and so P has to be able to account for every single one of those so everything that O says P's got to have an answer ok so what that means is we're going to pick one answer for each of these that P's going to play in response so these are played by O now these are played by P said one thing P has to be able to say ok here's all the things that O can say and here's what I'm going to say in response this is my strategy does that make sense it's what I'm choosing to play in response to anything possibly that can be played by O and so again this could repeat so for example imagine maybe the game maybe the game terminates terminates here and this is like the end but for this one there's more stuff that could happen so these are all you know counter counter claims by O now again P has to be able to not have any response to each of these ok so in effect what we get is that perhaps O could have made this decision or you know this decision as well but we want to pick just one so this has to be chosen this has to be chosen this has to be chosen this has to be chosen so these are all unique all possible plays by the opponent have to be have to be enumerated does that make sense this is a strategy anything that O does this is what I'm going to do anything that O does after that this is what I'm going to do that's a strategy does this make sense questions, comments, concerns let's look at a strategy so we just did the game streamer go for false or true ok and it turns out the strategy is very easy to look at what a shocker is one of these so notably this subtree or this subtree are both strategies the strategy here turns out to be pretty easy because we've got a lot of knots here we've got a lot of things where there are main choices to be made so if P says this O only has one response so P has to but now for O's response a strategy for P has to either choose one or the other action to make so let's say P is going to choose this action ok now of course we have the response by O and then P chooses the response again now there's not many branches here so it's very easy to see that P is going with but this is a strategy does it make sense to everyone how this would be a strategy is this interactive or is this not interactive is this interactive or not interactive so without any highlights this tree here is the full possible set and all interactions so these games are definitely interactive they're meant to be described P and O interacting by challenging and counter-challenge and counter-challenge so this defines all the possible actions a strategy for one player defines the specific action that they are going to take that they could take in response to all possible actions by the other person so every time a strategy for P every time we have a play by O we have to write one particular response by P so it's my strategy because it shows which one I'm going to so realistically like O would not send that first one he would just jump down to the last time he sends an interaction and then P would multiply it so realistically if we want to make this an efficient smart contract we don't want to have a timeout through this part because it's more of a proof it's not always reduced to not and not not always reduced to the thing and not always reduced to the thing so obviously this would all be condensed into one dispute period in the actual smart contract but we'll ignore that for here because we're just trying to give some meaning some semantics that's an implementation detail so to take this like in another example is this similar to how Tic Tac Toe is a salt game where there's a strategy to always win Tic Tac Toe exactly right so like the first assertion, I don't remember what you called it but the first on the left side is like setting up the game board for Tic Tac Toe exactly right the next steps are all the games but in our case the game board is not a Tic Tac Toe board the game board is a logical statement and the logical statement progresses through each thing and this is why for a layer 2 protocol you would not play chess or play Tic Tac Toe because we always want to know that we have our money we don't want to have to compute it I'm not infinite but a massive set of strategies exactly right so chess wouldn't be very useful I was chess solved, I don't know maybe AI solved like all the games possible there's some game which is unsolvable we wouldn't want to apply this framework to it we want to solve the games so would he really have to enumerate all the strategies or just enumerate as little as that to find the winning strategy absolutely just as to find a winning to have a secure layer 2 that was another for all that irritates me you don't have to you just find one strategy that leads to the outcome you intend to have and then don't continue so to have safety in a sense of layer 2 what we want to say to say that a protocol is safe in layer 2 is that the winning strategy can always be found by the person defending their money that's up at stake in this deposit contract yes, but it's possible to calculate all the different possibilities because if we have a graph that is huge we end up with just a brute forcing all the strategies and we need to have a way to select one over another because otherwise we would select just like maybe one day but we just select the best strategy ever on this giant chain or whatever so how do you do that on a really complex set of data so what we're not doing here is proposing that all logical expressions can be interpreted as a different layer 2 game that is meaningful most of the expressions that we interpret with this semantics are not going to be meaningful they're going to be unsafe protocols they're not going to be useful maybe they're not going to be able to move money around or whatever the point is that we can find some of them that do correspond to layer 2 protocols so particularly state channels plasmas things like troubad and optimism grow up all of these things are very simple games which do have computer learning strategies so like Carl said you don't make chess out of this you make tic-tac-toe something that is playable so this is what layer 2 protocols developers were doing when they invented state channels they didn't realize it but they were finding these sequences of expressions these challenges and responses in which the client could have a chance at actually computing what's going on could you do something like turn complete maybe sit on this bit and then do chess on top of that big architecture absolutely so state channels are a good example of this I can play a chess game in a state channel but the dispute game is not going to be about it's not going to be me fighting my winning strategy for the chess game it's going to be me fighting the winning strategy for proving the highest signed mutually signed nonce to the smart contract and that's the channel stuff and the chess stuff is a layer on top of that exactly right finding the correct finding if you have a winning strategy for the for all is kind of hard because you need to find the tic absolutely right and so the for all in practice there's two ways common ways to be able to compute for all so one for all that we can compute pretty easily is if we say for all things such that signed by me I know exactly what I signed and I can enumerate that so that's a nice for all plasma is for all blocks less than x and now when we can enumerate because we're just going to go with x x minus one x minus two to zero so it's a finite set and so absolutely there are tons of games here that we can come up with that are not computable and are like very very hard to reason about but some of them turn out to be later than protocols and so we think that's pretty cool other questions great questions yes so like each step in the tree itself they would add an extra at this good period right in theory each step would have to add an extra in reality when you actually add this is what was mentioned earlier is only when there's a choice to be made so particularly the time that really ends up getting you would have to add an extra time up is when you have a new for all or an and and you have to make a choice either not the left side of the and or not the right side of the end and you can and should design the contract so that the expression not dot t is automatically reduced to t because this is the only possible place so why play a time out it could automatically be reduced yeah well like in first of all you can pause my mvp or more vp self like each like every game has to share the same period so like from the start to the end they have to be in the same period but you cannot have different games having different periods yes so actually so we touch on this in the paper mvp is one of the very interesting examples of games that doesn't fit into this mechanism you need a new connective to do it do the logical connected so to not be playing inside baseball here plasma mvp the sort of like original spec for plasma have this thing called an exit queue and basically there could be like transactions forged and inserted by this malicious user and the way that you prove that they were forged or malicious was you prove that the sum of all the UTXOs that led up to the forged ones was equal to the total amount deposited into the contract and so this actually seems to be like a summation operation so we would need to define some sort of mvpq um summation operation so that hasn't been done in this because there's a lot to do without that but you're actually right that's a great example of more sort of game interactivity absolutely yeah other questions right well I like him so keep him coming okay where were we ah okay great so this is an example of a winning strategy why is it winning because every possible leaf every game outcome was one by p so a winning strategy is it is one in which all of these branches was all in the way okay so if we go back here right we numerator the so for instance tic-tac-toe has a winning strategy right because we can numerate all the responses by the opponent and then one particular play after that and so on and so forth and they're all one so if these are all one then this is a winning strategy for p because they've all been one right and so when this corresponds to in layer two world is the reason that I know I have some money is because I know whatever however someone tries to dispute me whatever they do I'm going to be able to win that outcome okay and like this is why I have some layer two states because I know winning strategy that proves that that state was legitimate so we can sort of interpret the truth of these expressions based on whether or not there's a winning strategy in the tree for that for the particular that corresponds to particular expression makes sense nice nice other questions comments and so some interesting notes on this one of the ways that you can understand the not is it reverses the roles right so if you have the expression p right not p is that not p reverses the rules right reverses the roles are you reverses so if someone trying to prove p then it's like the opponent is trying to prove a not p okay so this reverses the roles so if there's a winning strategy for p then there's not a winning strategy for o and if there's a winning strategy for o there's not a winning strategy for p so thankfully we've recovered that at least so what this means is that if p is sort of true because it is a winning strategy then not p will be false because now the other guy is the opponent so the guy who had the winning strategy is now the one who's going to win but he's now the opponent as opposed to the prove so this is sort of good there's no logic in other semantics in which if statement a is true statement not a is false so we release our cover down okay I want to pause for a question I don't know why I have this slide I'll do it once again okay great but what about cryptography okay so this is something that we've totally ignored up to now and this is something that does add a more complexity most of what we've gone over here is very very similar to existing works in game semantics and dialogical logic and these things the complex nature that comes about is inlayer to protocols the truth of a particular proposition changes off-chain so for example there's a game corresponding to a channel a state channel exit it basically is a claim that says uses this multi-sync existence I claim that this is a valid state because I claim for all states higher than this for all nonces higher there does not exist a multi-sync signed by everyone and so that is what a state channel is so let's say that state n that's true at time x maybe at time x plus 1 we sign the next nonce well now this statement is false because this one is true here and so there's some notion in the layer 2 world that is subjective truth it's not like true or false it's obviously true the expression true or false that's true but the expression signature exists or hash privilege exists that's dependent on what the players know and what they're allowed to place this is the point the facts it's not that what exists abstractly changes the player's knowledge exactly right so players knowledge about particular data changes over time and this changes the computability of what's going on so we have a model for this this problem is called logical omissions and so we have a problem for this we have a solution for this it's a problem we have a solution there we go so I definitely won't claim to you that it is nearly as advanced as the rest of massive amounts of work that have gone into the systemization of knowledge and cryptographic knowledge and computability but it's enough to be a proof of concept that we can express layer 2 systems as logical expressions and sort of unify them all under one framework so the way we think about it is we can find some set W and this is like a set of worlds so one world in this set might say Alice has the private key K but she's not signed anything another world might say Alice possesses the private key K and she signed the message M and sent it off to the opponent so the opponent knows about Alice's signature but only on the message M and so as we progress through this world that progression so Alice when I started out I didn't sign anything and then at world 0 and then at world 1 she assigned a message M this is what will allow us to change a statement from true or false because in this world it's not true for anything that there exists a signature by Alice in this world it's true for message M that there is a signature by Alice and so this progression through worlds is what you actually do when you execute a layer 2 protocol and you send them on your off-chain make sense so we can define this a little more precisely by saying there's a computability a computable subset so we call this x-pop and this is like the set notation but what you really care about is it's a function it takes the current world and which player it is either the prover or the opponent and returns some subset of the total state which they can compute which they are therefore allowed to play so for example in the world where Alice is not saying anything Bob cannot play your signature as a challenge so if the world W here says Alice is not saying anything then x computable is a subset of x which does not include Alice's signature and therefore exists such that signed by Alice will end up being false end of being false ok, so in practice this has to affect the game somehow so the way that we can affect the semantics is we change the final challenge rule so we have those 5 challenges rules before the university quantifier for all we've now changed it so instead of t and x we can only pick tech t in the computable subset of x in the current world by the current player who's going to be providing the challenge this is now a subset of the tree whereas before all possible things were known by the logic and therefore all possible things could be played in a theoretical notion now we might say we're in a particular W0 in this set of worlds and in this world maybe this was false but in this world it turns out that O cannot play this branch so we're good we still have a winning strategy it cannot be computed it's impossible for O to play it because it's computer's only finite it only knows the things that it's downloaded off the internet and because Alice has not signed a thing and therefore it could not have been downloaded from the internet or computed then this game state is inaccessible so we restrict these sort of theoretical game trees to only ones which are computable moves the only way to play something is if your computer can get in there and now note of course that in each world W there's a different game tree so maybe in W0 this was not playable but maybe in W1 now this is playable again I don't know how to race next there we go so maybe in this world it is playable again now this thing becomes false because the strategy doesn't check out the strategy doesn't work this is lost so what this means is that as we progress through worlds propositions can go from being true to being false it's no longer meaningful to interpret the truth of a statement in a vacuum you have to interpret it in the particular computability world that corresponds to the state of affairs so we say that now there's a strategy that is winning or losing even world W that a logical proposition is true or false in world W it's not in a vacuum it's not true or false on its own it's true or false in world W makes sense so in practice the world W that you're going to be tracking is for instance what have I assigned so in this example what the party can't compute is whether they would win or lose if they went down that right path or is it that they can't compute what the choice is so what it is they can't compute the move therefore they can't play it so the game tree is so they don't even know what their set of moves is they know what their set of moves is it's what their computer can come up with but so for example more importantly I know that my opponent can never come up with my signature unless I've given it to them so that allows me to restrict the subject so essentially you're taking the original tree and you're just pruning out the steps exactly right you're pruning out any moves which are computationally infeasible to have been played in the first place and this is what removes the logical omniscience problem and makes things true or false objectively so I have a set of moves that I can if in the game one of the moves I can play is to exhibit Alice's signature on some string right there's a set of strings of a certain length that I know I can play it's not that I it's not that I don't know that I am allowed to play that string of bits, it's just that I don't know that's the string I should play in order to win it's that I don't know that I can't figure out how long the enormous number of moves that are available to me which of them is winning okay so maybe I more loosely than I should have thrown around allowed so it's not really allowed it's really capable right the game tree is restricted because people are incapable of playing moves that are not computable by their computers so maybe that refinement of learning would help there let's take this offline yeah let's take it offline, excellent and now we have time by the way okay we have about 10 minutes other questions can you look at the traversal this is very reminiscent if you want to see what is the set of winning strategies based on on a certain truth basically what's the support right so you could compute pathways over these right to to see because the path or the ones that are not computable will give you zero right because there's no support right but if you're if you're integrating the path over the worlds DWI and you're going you can express it through paths that you can actually because it's you can treat this as a power series you can then exponentiate them so now you actually now you actually have a have a corresponding you can compute total total values of sets of strategies beautiful path integrals I didn't know they applied but that sounds great so this is let's talk after this exactly what I'm trying to do here is make up something that sounds legit enough that you believe me that L2 will be supported by it but then you can stick on your actual knowledge of computability and cryptography because mine is woefully inadequate to deal with these sort of systemic problems that you work on more not me I don't share that's great okay absolutely so let's jam after yeah in general I'll be around after everyone wants to come let's come talk about this stuff okay it's like a very a very simple computability model that you can build which is one that we sort of deal with in this statement which may or may not of course be accurate at all is maybe maybe the way that we define our worlds is we say that the world is that the world with a set of worlds is by these things a set of public information a set of secret information to P and a set of secret information to O right and we maintain the rule whatever the world is in particular we say that in all worlds it holds true that if something set on X is in the secret information of A then it is not in the public information okay so if A has some significant information it is not in the public information and then further we say the computable the computable moves that can be played is the intersection of all possible moves with the public information set so what this means is that if X is in I I be secret then therefore it's not in I public and therefore it's not in this intersection and it's not playable so this is a very simple very rudimentary way to try to restrict these game trees it's probably has nothing to do I mean you know we want to hit this with like the possibility and get it you know get an actual security model that corresponds to crypto slapped on it this is probably not it but it gives you a good intuition for what's going on yes yes question it's public but is it known for a prior P yeah so we'll come over right so we'll say the public the public information is known by both parties that's what we're calling it public right and so maybe this isn't accurate to the meaning so for example if we extend this to the end party world in which there are many different player people playing things there's not one public set of information there's a set of information that I have downloaded and there's a set of information that's secret to me that I know that no one else has downloaded but maybe the local information that is public that I have downloaded is not is not that downloaded by someone else right so there's many more complex models you can build far more complex models and that's what we need we need a better model but this is a very simple one that we can throw together just to pull out the core sort of elements of what goes on right to other questions you have five minutes which I'm pretty pleased because we're pretty much there okay so a really simple example with this very very very simple model which again probably not accurate to the computer science out there but it's accurate enough to give us a layer 2 game tree that actually corresponds to what really is done on chain in layer 2 so the pretty much existence you know sort of predicate is like the simplest sort of rudimentary example of what happens right so the game or proposition is as follows there exists a hash in the set of bytes such that is has pretty much H and H not for some fixed H not is known okay so this game has a different game tree depending on whether or not H the particular like little H is known in the public information or is not right so this is a game we'll just put the game up there for example W in which H not is in I pub then this game is true this game is true right because the previous says there exists H right so the previous says this thing then the opponent says no for all H not is hash pre-image but because H not is in the public information P may choose it it's in the computable subset so it may be played and so now we're left with P not not is hash pre-image not is hash pre-image is hash pre-image and this is true right so it's one by P so in a world in which H not is in the public domain then this proposition is interpretive is true because this is a winning strategy for that proposition for the prover however if instead H not is secret right it's secret to the opponent then this will not be true because this step which we previously had is not computable therefore it's not possible right now maybe allow us to our moment it's not possible because H not is not in P's is not in the public set of information so it cannot be played and no matter what the actual world is right so maybe the rest of the elements in the set we might play some H prime or some H prime prime but no matter what happens there those are going to be false because at the end of the day only H only this H not which is secret and therefore not playable is going to be the thing that gets us to a true statement at the bottom a true beef a true game outcome okay and so notably what this means is that if we start out in this world in which H not is secret to O then this proposition is false but if desired by the by the opponent O may reveal that preimage and in doing so it would change the world the world would no longer have H not my secret it would this one and it would not be true so we've changed the truth so we started a world where the thing is false and we ended a thing in which the thing is true right and because we can do that off chain and because we can enforce these games on chain this is how we get the scalability of player two solutions wouldn't it be sort of cleaner and easier to think about if you just said P knows H such that sure that might be cleaner it absolutely might yeah so this is a very simple thing that I started together because the point I want to get across is these games are what happened on the main chain in the earlier two's and someone could be able to do this very rigorously and effectively yes you're referring to local public information with the example of revealing a preimage it doesn't make the statement necessarily true for all participants just in the party that actually was revealed to absolutely right and that's why so far I've defined these semantics as between two imaginary players and proven opponent but you're absolutely right we're going to hit this with the universal possibility like you know epic like formal proof for all layer two model is we need to have that we need to have a distributed system of many many many people public sharing information what has been publicly shared to anyone what has been publicly shared to only some people and what has not been publicly shared a.k.a. is private right so absolutely this is what we need and if you think you know it or know a good way to do it or have someone who knows a good way to do it come find me yes so what is it useful for so so as we have exactly one minute to go what is it useful for well here is a state channel so the thing that we've been doing all along which we can look on state channels and we thought of as a unique thing is actually simply this expression okay so this is a preimage reveal state channel so we imagine there's a set of hashes which are all secret to the opponent in the beginning and as we progress through worlds we selectively reveal each hash and by associating a game of the form channel s to a payout of the form s so that we pay say s coins out to someone we can actually associate money with this game and by selectively revealing these three images we selectively pay a one coin denomination through the play so that's a state channel okay we can also do sort of more ethereum style state channels so here's our multi-sync there's our multi-sync and the game for an ethereum style channel is I claim for this state there exists a multi-sync and there does not exist a higher state such that there is a multi-sync and the state means indeed higher with the higher knots right so there's that here's optimistic roll up Unipig.exchange we just released a demo of this this is a roll up chain the computer availability model here for roll ups are really nice because the ethereum main chain always makes data available so the computer availability model is much easier for any information that's on the main chain because it's always known it can't be hidden this is a very great property and makes a very very very simple, graceful, elegant elegant thing which gives us a nice layer 2.12 lastly, plasma which is a god awfully complicated expression it's the simplest plasma cash construction I can come up with but I can tell you that this indeed works so we've got a gamer that talks more about how to associate money with this we've got to go let's go