Hi folks, Ed Amoroso here. So, what we're going to do in this video, in the previous one, you remember we introduced a couple systems, System Y-Prime and System Zed, that we said were deducibility secure. Alice can't signal Bob, User A can't signal User B. And I think you were comfortable with that. So showing them on the board right here, showing them on the screen, you see System Y-Prime System Zed-None. They're both deducibility secure. Now, if User B is the same user in both cases, then you don't even have to write in User A for the first one, because they don't have any interaction with the system. Then, I can show you in the next chart, that User B is reading the two parities. Do you follow? A is doing something to the first system, to System Y-Prime. It can't touch system Zed. So now it does something. And at the end of the game, so to speak, a bunch of inputs, User B sees the parity from both systems. That make sense? Now, here's the best part. If you do this, boom, now you can see in the new chart they just hook them up. That's why I drew them in that funny way. That I can take random stuff coming into and out of System Y-Prime, and the random stuff coming into and out of System Zed, just hook them up. There you go, you're done. So now the way the games will work is that we'll say, ready, go. And A will do a bunch of stuff. And again, A is going to be sending inputs to System Y-Prime. System Zed and System Y-Prime will then be doing their random things, sending and receiving messages. When the game ends, you add up the parity of the number of things that happened in Y-Prime, you add up the parity of all the things that happened in Zed, and you show both of theses parities to User B, okay. Let's do a couple little games. Let's look at our first one. So now, User A sends 0 messages. And let's say that nothing happens between Y-Prime and Zed. We said it was random, so random could be nothing. So we get no messages from A, no messages from Y-Prime, and no messages from Zed, just the whole thing is quiet. What's going to happen? Well, obviously, User B is going to see even parity at both places, 0 is even, okay. So if A does nothing, parities are even, as long as nothing happens in the middle there. Let's look at another case. How about, again, User A does nothing, but now the two systems are sending and receiving a total of 4 messages, 2 each. Well, Y-Prime is going to count up 4 things, Zed is going to count up 4 things, 4 and 4, they're both even, the parities then will be the same. So if User A does nothing, then in our first two games, we could see that the parities that B sees are even. What about now, if User A does nothing, but Y-Prime and Zed do an odd number thing, they do 5? Well then, they're going to see odd and odd. But notice, they're the same, think about this. As long as User A does nothing, all the traffic, all the adding up at Y-Prime and Zed, will be at the same at both systems. Do you follow? A just hangs out and does nothing, and the two parities will always be the same. Do you follow? So it's a way of forcing the parities to be the same, but now watch. User A does 1 thing. Now it doesn't matter what Y-Prime and Zed do, because Y-Prime will always count the A inputs, but Zed doesn't. So if A does an odd number of things, it'll always be 1 off in parity from Zed. Do you follow? In this case, User A sends 1 thing. Nothing happens between Y-Prime and Zed. I see odd parity at Y-Prime. I see even parity at Zed. Isn't that cool? Another example here. User A does 1 thing, and then a whole bunch of traffic happens between Y-Prime and Zed, 5 things total, 3 messages this way, 2 messages that way. You add it all up, it doesn't matter what they add up to, because you're always going to be counting one more at Y-Prime than Zed. You know what this means? It's pretty profound. Here's another example here, 3 from User A, and so on. The profound conclusion we come up with is that deducibility security doesn't compose, think about that. What that means is that, if I have one secure system here, we all agreed it was deducibility secure, and I've got another system here, it's perfectly fine, secure. You agreed, right, both secure? Y-Prime can't deduce, Z can't deduce, they're both deducibility secure. Hook them up in a logical way, and suddenly A can signal B through the respective parities. It doesn't compose. This is pretty crazy, right? I mean, from a theoretical perspective, this shows that just assuming that having a system that's secure, and another system that's secure, and putting them together, everything is going to be fine. I got secure, I got secure, put them together, it should be secure, well it's not necessarily true. That interesting? Look, if you're watching this from wherever in the world you're watching, and this is turning you on, and you go, I like that, this is fun, it's an interesting way of thinking about computer science, this is Theoretical Computer Science. That's what this is. If you go off to grad school somewhere, and you're studying computing, and so on, this is the kind of thing you can get yourself involved in. And I think it's very fun. It's like thinking about puzzles and a different way of modeling the universe. Now again, it may be that these models don't necessarily match reality. And that's what experimentation does for us. But I hope this has been fun for you. I think it's kind of interesting to look at these theoretical models, see what makes sense, and see what doesn't. We'll see you on the next video.
