Lecture 18: 0- and 2-Player Games

• Download English-US transcript (PDF)

The following content is provided under a Creative Commons license. Your support will help MIT OpenCourseWare continue to offer high quality educational resources for free. To make a donation, or to view additional materials from hundreds of MIT courses, visit MIT OpenCourseWare at ocw.mit.edu.

PROFESSOR: All right. Today, more games. Last time in general, we're going to look at this categorization of different types of games. So far we've been focusing on the one-player category, which normally think of as puzzles or not games at all. But today we're going to branch out in the other directions. And we're going to talk about zero-player games, which arguably are also not games, and two-player games. But to fill out this space, we probably won't get out here yet to EXPTIME and Undecidable games. But we will stick to this chunk.

We're going to start with zero-player games, also simulations-- Game of Life is the classic example here. And these can be very hard, despite being very simple and not really having any choices. So as a funny equality here, the sliding block puzzles and things that we looked at last time where you have agency, you have a choice of which move to make, will remain PSPACE complete even when you don't have that choice.

This category is not so interesting. If you a polynomially bounded zero-player game, that is a computer. And it can just compute something for polynomial time. And recall, this polynomially bounded number of moves. And this is an exponentially bounded number of moves.

Although you can actually go a little bit higher. And we'll talk about that and get even harder problems when you have potentially infinitely many moves. And then we'll go into two-player, in particular, two-player bounded, where we get another PSPACE completeness result.

As you may recall from time ago, all of these versions of games have constraint logic variations. So we've focused on this one. But I'll mention this one, and this one, and this one today. And they're all complete. So we can use them to reduce things.

But before we get to constraint logic, I'm going to be talking about both more classical ways of proving hardness in these classes, and then also the constraint logic way. And we'll start with the Game of Life. Let me write down a definition of the game in case you haven't seen it, or if you've forgotten.

So this was invented by Conway. '70s. So you have two types of cells-- living cells, which are the black cells; and dead cells, those are the white cells. And you have this iteration-- every cell in parallel updates. In general, this is called a cellular automaton.

And if we have a living cell, it will continue to live if and only if it has two or three living neighbors. This is among the eight neighbors in the 8-way adjacency. And then if we have a dead cell, then it becomes living-- it's born, if you will-- if and only if it has exactly three living neighbors.

And so those are the rules. We don't really need to know the rules except for verifying that very small gadgets work. Most of what I'll talk about are higher level than specifics of these rules.

But some things you should know is sometimes you get a periodic pattern like this pulsar. Sometimes you get a static pattern. These things don't change because for example, on the 2 by 2 square, each of the living cells has exactly three neighbors. And so it lives. And each of the dead cells has not exactly three neighbors. And so I guess one or two. And so they remain dead. And so nothing changes. That's called still life. There's tons of puns in this area.

And so that's well and good. And so one question you might ask is, given a pattern, is it a still life? Well, that's easy to check. Is it periodic? That's harder to check. Does it ever die out and become nothing? That's actually kind of common. And that, we will prove, is very hard to check. But all these questions are related, other than still life, which is easy.

So some other cool things you should know about are gliders. Gliders are a kind of periodic pattern, but with a diagonal offset. So they go off to infinity in a diagonal direction, unless they hit something. Then something might happen. But in the absence of anything else they'll just keep going on for infinity.

So this is a little different from most of our games. Most of our games we have a finite board. There's some rectangular thing. Sometimes Life is played on a torus. So when you go off the south edge, you end up on the north edge, and so on. In that setting, Life is going to be PSPACE complete.

So in general for zero-player games, if we have a polynomial number of moves, then of course we're going to be in polynomial time. If we have an unbounded number of moves but a polynomial space, basically, then we're going to get PSPACE. OK. No surprise.

So the finite versions of Life will be like that. But if we have infinite space, normally we can't think about infinite space. But with Life it's meaningful to have an infinite board. But initially only a finite rectangle has any stuff in it.

So if you just encode all of the positions of the living cells and say, well everything outside of that is dead, then you can think about infinite space. And here we will get that the problem is undecidable. So there's no finite algorithm to solve it. So that's cool.

And I'm going to tell you a little bit about both of these. Spaceship is like a glider, but it goes in one dimension instead of diagonally. So usually horizontally. There are many spaceships out there. This is one particularly efficient one.

And one of the coolest things is this thing called Gosper glider gun, invented by Bill Gosper, I think while he was at MIT. It's this construction up here. And it creates gliders. And so they just go off to infinity. And you just keep making more, and more, and more of them. So in some infinite sense, this thing is periodic, I guess. But at any finite time you have maybe n of these coming out. And you just keep making more and more. Gliders and glider guns are the key things you should know about for hardness proofs.

First I'm just going to show you a couple of pictures of fairly recent hardness proofs. This is an explicit construction of a particular Turing machine. I think it is a Turing machine that given a number represented in unary doubles that number. So it's a fairly clean machine, which is in here.

And there's two stacks. So you can think of a Turing machine, normally you have a tape. And you have your head at some cell in the tape. You can think of that as a stack going to your left, and a stack going to your right. Each time you can pop off an item from the stack and push it onto the other side. That would be the same as moving to the left or moving to the right.

So this is implementing what's called a pushdown automaton with two stacks, but basically a Turing machine with one tape. And you can do that. And this is done algorithmically. So he also applied it to a universal Turing machine, if you're more a fan of that. That's the Turing machine that takes a Turing machine as input and simulates it. So that's the code in here. It's much bigger.

Now this construction relies on the tape being finite. So it proves PSPACE completeness for the polynomial space version. It will remain in this rectangle, as big as it is. And it will run the machine. If it ran out of tape, then the machine might crash or not do the thing that it was supposed to do if it was a Turing machine.

So that's fine for PSPACE hardness, because simulating a Turing machine is hard. I mentioned that last time. But not good for undecidability.

 

Same guy a year later came up with a Turing machine that grows itself automatically. So it's a little hard to see, but this is the original thing. And then as you run it longer and longer, this machine moves along this dotted line. So it's moved here. This is like the dirt that it leaves behind. And simultaneously it's been building larger and larger versions of its stacks, so by the time it needs to use it, it will be available. Because space is bounded by time.

So limit on the rate of growth. Very complicated, obviously. But extremely powerful. This establishes that some version of Life like, will the thing ever stop growing, is undecidable. Cause if the machine halts, you could make this thing just stop.

It will non answer the question of, given a life setup, will everything eventually disappear? At least not easily. So I'm going to talk about that version and a somewhat older proof, partly because I like old proofs. And it's a very epic proof.

So this one, I don't understand the details of. But they are online if you want to study this thing. There is another proof by Berlekamp, Conway, and Guy in their series of books called Winning Ways, which is a very cool set of books. Interested in two-player games in particular.

But they have this chapter about life being undecidable. At a high level it's very simple. It's just if you have a glider, that's going to represent a 1 bit. If you don't have a glider in a particular area, that's going to represent a zero bit. And so you can think of streams of bits and doing stuff with them over time.

And so that's cool. Everything's going to be oriented diagonally, of course. Now one useful structure. That's going to be our wire.

We can also build a terminator. They call these eaters. So this is a particular construction where-- and this is frame-by-frame-- if the glider comes in here, it basically gets eaten by the eater, and the eater remains. The notation, by the way, is that the dots are going to be newly born positions in the next step. And the holes are going to die in the next step. So you can see the transition.

Stuff happens. These are just things you need to check. And boom, it ends up just the eater remains. The eater is otherwise still life. So it will just hang out.

So you can send gliders into an eater, and they'll just disappear. One thing to note is that the exact offset of this stream versus the eater is very critical. You do something a little different, eater might explode or do something else weird. So if you're going to build these, be careful. We'll talk a little bit more about parity and things in a moment.

OK. So here's a fun thing you can do with a glider gun up top, and a stream of bits. So if you have a stream of bits coming in here. And you have a glider gun shooting one, one, one, one down, then if you set up your gliders with the exact right offsets-- so I've got to shift that gun to be precise-- and then when gliders hit each other, they annihilate each other. Nothing is left with this particular offset.

So what that means is in some sense you're negating the signal. If a 1 comes in here, it'll hit another 1. And then 0 will come out here.

But in particular, if there's a 0 here, there will be nothing to stop this guy from going through, so you get a 1 out. So this isn't really a negation, because whenever it's horizontal, it's going to be one way. And whenever it's negative, it's going to be inverted.

But this is really a turn. So if I turn this and then turn it back, which I think is the next image, I can now turn a wire. So this is progress, but already a little challenging. So we have this input wire gets turned by the gun. Turn back, turn back, turn back. So sufficiently zoomed out, you can do arbitrary turns. You can use this to delay signals, which is useful, because timing is really sensitive here with the wires and when there's a one bit or a zero bit.

Another thing you can do with this is get a parity offset shift. Because there are actually many different offsets of the gliders that all lead to evaporation and into nothing. So you have to believe this a little bit, but there are enough different offsets here that by doing a bunch of turns like in this picture, with slightly different offsets of each of these guns, you can shift your signal to be anywhere you want on the grid. That's good, because all the gadgets will require very careful alignment.

So, that's a shift. So now here's how we can do AND and OR gates pretty easily. So on the one hand, if we have two streams A, B, and we want to make the end of them. We're going to use a single glider gun to kind of merge them together. So a 1 is going to get through here if and only if there was a 0 here. And in that case, it will prevent any A from getting through.

So if B was false, there's a 0, then there'll be a glider here. And it will annihilate whatever was an A, so the AND will be 0. On the other hand, maybe both of them are 0. Then the glider will just go up here to the eater and disappear. So that's also fine. And if A is zero, then there will be nothing over there, obviously.

And if they're both one, then A will get through, because B will prevent the gun here from getting there. So A and B have to be sort of offset in time, because it takes a little bit longer for the signal to get here, but you get the And.

And similarly for the OR, if you want to send up a gun here, and then it's essentially getting negated on the right. So for there to be an output in the OR, there must be nothing here. And so for a glider to be blocked, either A blocks it or B blocks it. So then the output is the OR of A and B. And because everything here is horizontal, we're not negating anything.

That's actually annoying. It would be better if we had an AND and an OR. Or an AND or an OR, cause then it would be done. So we still need negation. Yeah, question.

AUDIENCE: If you go back into this line, you are going to have this A and B output there as well, to get the terminator. In the right-hand diagram.

PROFESSOR: Right. Right. Sorry. So there should also be an eater here, because this is not fully occupied. Good. But because this is fully occupied, we don't need an eater there. Cause this is fully occupied, we don't need and eater here. You could put them in for good measure. But, cool.

So before I show you the next gadget, I need another fun tool called the kick back. So this is of somewhat weirder offset between two gliders. So one's coming in this way, the other is coming in this way.

And stuff happens. And then this glider goes backwards. Returns along its original spot. So this is really cool. It means if you're sending a glider, if you can kind of head it off at the pass with the perpendicular glider, you can cause that glider to come back the way it was going. Which I think exactly the same offset, even.

So this is useful for a lot of things. In particular, it lets us build a crossover. So the idea with a crossover is that instead of every-- a glider gun produces gliders at a certain rate. Call that rate one.

When it's so dense, if you cross two streams, you're guaranteed collisions and something unintentional will happen. But if I could just thin out the stream so that every 10th position is a glider, and then we only look at the bits, you know, modular 10, then there will be no problem to do crossings. You just have to set up the parity so that the gap happens whenever the other guy happens. And vice versa. So they'll never collide with each other. Even if it's all ones.

So here's how you thin out a stream. We have a single glider here, which is just going to be kicked back and forth, just hanging out. And on the other hand, we have these guns-- G1, G2, G3. So this is going to replace a single gun.

So this is the notation for the kickback minute mechanism. So mostly these guys are just going to shoot off. But they're set up so that if this glider comes here, he gets kicked back. And also we lose one glider here, but they're going to eat it all up anyway, so it doesn't matter.

And same thing over here. So this guy is mostly ones, but every once in awhile this glider will come in and get kickback, and consume one of the gliders down this G2 stream. So there will be a couple holes here. And then if you basically negate that stream, so you send another glider down through here, then only every once in awhile will you have a glider. And by controlling this width, you can control the rate. And I think in this proof, you just need all of them the same rate. Sufficiently large to allow crossovers.

OK. Cool. So that's thinning and crossover.

AUDIENCE: Quick question.

PROFESSOR: Yeah.

AUDIENCE: Are glider gun constructions that we know about, or as least know about it at the time [INAUDIBLE] enough that you can't just set the rate of fire from the gun construction use.

AUDIENCE: There's a gun for every period either greater than or equal to 14.

PROFESSOR: Oh, cool. According to--

AUDIENCE: Wikipedia.

PROFESSOR: Wikipedia. Must be true.

I'll make a weak claim to the extent to which I know glider guns, these are not like easily variable constructions. They're kind of magical, and they just work. There are probably many different glider guns, each with a different rate. But I don't think there's a general purpose glider gun with an arbitrary rate.

Now there might be one by now that has a slow enough rate that we're OK. But I don't know. So this certainly guarantees that yeah, you could do it. It's a little bit messy, but maybe there's a simpler one.

Life is still actively studied so there are many more guns and there were in the early '80s so I think I won't go through this construction in detail, but using orders and some kickbacks and some crazy ideas with guns, you could build a split and a not. Is that OK?

In particular, we're using this idea of rate limiting, so there's a lot of zeroes here. And this is, whatever, 10 spots-- there's only one every 10 spots. And there's two cases, depending on whether A is there or not. And by ORing it together with something, and then having all these chain reactions, we end up with a copy of A here, and a negated copy of A hear with different offsets. Yeah.

AUDIENCE: So for NOT, isn't there the super easy gadget of A equal gun, and then-- sorry-- the gun gets through if A is not there.

PROFESSOR: That's what we had for the turn gadget, but it always turns the signal.

AUDIENCE: And that's bad?

PROFESSOR: That's bad because it means if you think of your gadgets having inputs horizontally, then you need to negate and still be horizontal. So this negates and still is horizontal. In their writeup, they actually call the turn a NOT gadget. But I think that's not NOT. It depends on your perspective. You definitely need a direction-preserving NOT. OK.

So that's cool. And at this point, they say just give this to the engineers and they'll build a computer. Once you have AND or NOT, you can build binary logic, so you can do CIRCUIT-SAT style things. And you could make re-entrant circuits. And so you can compute on stuff and build a Turing machine with a finite size, or any machine of finite size, bounded size. So that's enough to prove PSPACE hardness.

But if you want to prove undecidability, you need some way to grow up to infinity. And their idea is to have a small number of registers. Two are enough. This is called a Minsky machine, is the two-counter version. And Minsky proved that you can simulate a Turing machine with two counters.

What's a counter? It stores a non-negative integer. And you have three operations-- increment, decrement, and check whether it's 0. So it's a little crazy. But that's enough to simulate an entire Turing machine with infinite tape.

So the rough idea is to store a bit onto the tape. You double it and possibly add one. And if you want to remove something from the stack, then you divide by 2.

So with four registers, you can use this one to represent one stack, and this one to represent the other stack. Dot, dot, dot. It's not too hard.

So how are we going to represent an arbitrary non-negative integer? We're going to have a little 2 by 2 box-- this is drawn diagonally-- somewhere along this ray. And then we're going to be able to increment or decrement the box by sending a wave of gliders using these constructions. Sorry, next slide we'll have the constructions for incrementing.

Here actually is a glider that's going to test whether this guy's currently zero. And he happens to be. And so here's how you test. I mean, you just send a glider through the box.

And there may be a cleaner test. This one is a destructive test. It destroys the box. But in particular, it destroys the glider.

So then you can have a gate on this side that says, well, if I didn't get a glider, then I know that I'm actually 0, and I can feed that back to my logic circuit. If I do get a glider, then I know this was empty. So that's pretty easy.

The only catch is then you've destroyed the box. You have to create a new box. And you can do that by sending two gliders with a slightly different offset. This looks like this same as all the others, but in this one you end up with a box at the end. So if you send like another one here and another one timed just right here, you'll recreate the box after you've discovered that it was there. So that's cool.

And then this is a swarm. I think it's actually drawn somewhat accurately to push this block forward by 1. I think it's this stream. So there are two constructions here. One is a wave of gliders that pulls it a block back by 3, another one pushes it forward by 1. Together you could use this to increment or decrement by 1. So I mean, lots of details to check here. This one is a little bit cleaner. We have one glider here, a second glide here. And it ends up moving. It goes in this order and then back. And we end up moving the box up to here, back three spaces.

I assume these are found by trial and error. And then to push a block forward 1, this is pretty crazy. Their second wave of five gliders. Where's the first wave?

AUDIENCE: Turning the block into a honey farm.

PROFESSOR: That's right. Turning the block into a honey farm, which is this particular still life pattern. Anyway. Dot, dot, dot. You check the results. It works. It's actually a lot of fun to implement these in a life simulator and check that it works. But for now I'm showing you the ancient diagrams, hand-drawn diagrams.

OK. So there's like a catch with this. In order to generate these gliders in this very specific pattern, currently the only way we have of making gliders is with the glider gun.

Glider guns are large objects. And you can't put them right next to each other. And even worse, if you have a glider gun, it's spitting out gliders in the middle of it. You can't put a glider gun shifted over a little bit even if you slide it this way or that way.

If you want to produce two streams very close to each other, one of them will go through the other glider gun and destroy the glider gun. So you can't actually build this kind of pattern with glider guns ultimately. But there's this trick using kickbacks to get a glider to go out far away from any guns.

And this is to-- so here's your original gun. And this one has some holes in it. So you can get a glider through here. And then get this glider to bounce back and forth until you have the right timing. Then this glider will escape through this little gap. And then the result is, you send the glider basically offset to the right from this gun.

So using that, you can have a bunch of glider guns sort of around where you need it. Get all the gliders to come up. And now you're very narrow. You could have two gliders right next to each other without any trouble.

So you do a bunch of these constructions at various heights. So this is the picture of two glider guns, one shooting a glider through the other. That's bad. So instead, we'll put these away from it, and send the gliders offset to be like that, using two of these constructions.

OK. So now we can increment and decrement, and test for 0. With this similar trick we can do some fun stuff in sending gliders forward and backward. So this is cool. Remember I said that you could send a glider and cause it to come back using the kickback.

So normally if you want to send the glider and have it come back, you need another glider to be shot this way. So that's OK in some cases. But here's a cool construction where all the gliders are way down here, and still I can make the glider go up and then come back at some desired time. And it's the same kind of idea. You use this construction to make this glider go back and forth, spend lots of time. And then eventually hit this guy at just the right orientation to send it back. And if you have some more stuff, you could actually get it to go back and forth many times and come over farther to the right.

Why do I care about this? For self-destruction. So the idea is if the Turing machine says yes, if it stops, then you want the entire thing to collapse to nothing.

And so when you get to this magical state, you're going to send out a whole bunch of gliders, and then turn them around using the mechanism I just showed-- the boomerang-- and get them to hit every gadget in the construction at exactly the right offset to make them disappear. This is how you kill an eater from going from slightly wrong orientation. This is how you destroy a gun. It ends up with nothing.

Oh. Sorry. This is a gun. This is a how you destroy a square. We already saw that.

So all of that infrastructure being able to precisely place gliders exactly where you need them, lots of details to check. But you should be able to get them all come out and come back. And you always hit them in the backside of the guns.

I think first you kill all the guns so they stop generating gliders. You let the gliders get eaten by eaters. And then you go out and destroy all the eaters and squares and so on.

So, pretty epic. But in the end we get undecidability of life in an infinite board. So zero-player is more interesting than you might expect. This is certainly one of the more epic proofs in that direction.

Next thing I want to tell you about is zero-player constraint logic. This is called deterministic constraint logic, as opposed to nondeterministic constraint logic, which we talked about last time. So let me define it for you.

So in deterministic constraint logic we have a little bit more state. Before it's just in the state of a machine is just the orientations of all the edges. Now we're also going to have-- it's a little hard to see on this projector-- but there's some highlighted edges which are active. So I'll describe what they are in a moment. So even if you can't see them, they are there.

Active literally means that you just flipped the edge in the previous step. So deterministic constraint logic, we're going to be flipping multiple edges at once in one round. And in the next round, those edges are all called active. And the rest are inactive. Now that's for edges.

We're going to define a vertex to be active basically if that reversal did something useful. So if its active incoming edges have total weight greater or equal to 2. So if the just flipped edges satisfy that vertex possibly in a new way, then we call the vertex active. It's been activated by what just got flipped.

And then here's what we're going to do in each round. We are going to reverse inactive edges pointing to active vertices. And we're going to reverse active edges pointing to inactive vertices. And then these reversed edges are the new active edges. OK.

So let's look at an example. So here's a little gadget. We're actually going to use this gadget in proving PSPACE completeness of this model. And initially just this edge is active. And if that's all that happens-- now there's some inputs and outputs here-- if that's all that happens, this edge is active. It alone does not satisfy this vertex. So this vertex is inactive. And in the inactive case, if the vertex is inactive, we're supposed to reverse the active edge.

This is basically bouncing back. If you try to satisfy a vertex, you didn't satisfy it, you just undo what you did. You're going to reverse the edge.

So what's going to happen here is this guy will just flip back and forth. First he's gonna go this way. Says, oh, I didn't satisfy this one. So I'll reverse this edge. Now it points into here. Still doesn't satisfy that vertex. It's inactive. So this guy will just flip back and forth forever until here we're drawing the picture where A reverses, so because of some gadget below it.

Suppose A reverses at the same time this one is reversing. So now this edge is active. And this edge is active. Still this guy didn't satisfy what he wants. So he's going to reverse again in the next step.

But this guy did satisfy the vertex because he has weight 2. So now it alone satisfies this vertex. So now both of these are going to reverse. This is the forward case. We have a active edge satisfying-- so now this vertex is active.

We're going to reverse these inactive edges which point to the active vertex. So we end up flipping those. Now they're pointing out of the vertex. This one remains pointing in. It's no longer active, because we didn't just flip it. So we propagate from this being active to these two being active. This is a splitter. We have the signal and we split it into two parts. So it's acting like the splitter that we know and love from last lecture.

OK. Meanwhile, this guy just reversed again. But now these two are simultaneously here. So together, those two active edges satisfy the vertex. So this vertex is active, which will flip that edge up there.

Yes. I should say this vertex is a little bit weird. You could think of there being a red to blue conversion here. This guy only has a desired weight of 1. This is basically a red edge, but it's subdivided to fix the timing. So we'll see how to get rid of that subdivision.

But you can think of this as a red to blue. And there's two blue edges here. But this one edge will actually satisfy this vertex. And so then this guy flips in the next stage. And then it's just going to hang out here, flipping back and forth along this path. And meanwhile, this will go off and do something until it comes back and reverses the edge.

And I should say at this point-- because there are a lot of timing issues here, we're going to set up all the gadgets so that they only get an input edge reversed at times divisible by 4. So this one happened at time 0. And then this one we know will happen at a certain parity relative to 4.

And so we know when this guy has gotten flipped, this one will also have just been flipped. And then stuff happens. And then this edge ends up getting reversed. And then more stuff happens. Then this edge gets reversed again. And then the A gets reversed again.

So this gadget has sort of three cycles. When you reverse A, first B will reverse, then C will reverse, then B will reverse, then A will reverse. It's a little bit overkill. But we're going to use this to check two options. We're just going to check one of them twice because that's what we can build easily.

OK. So now we want to prove PSPACE completeness of this model. The decision question is again, does a particular edge ever get reversed?

And so we're going to reduce in the usual way from quantified CNF-SAT. We have our blocks which represent quantifiers. They're going to produce variable settings. We're going to have some CNF logic. And then in the end, this is actually not quite accurate. We're going to get some satisfied signal which is piped into these guys.

So the first thing that has to change are the quantifier gadgets. In particular, the existential quantifier needs to change because before we let the player decide whether to choose x or x bar. So in this case, we're going to use the gadget you just saw, the little wheel, which will try x being false. Then it will try x being true, then it will try x being false. And all we need is that one of them is true.

So if at any point this formula is satisfied, we'll just output that formula satisfied. We have four edges here because everything needs to work modular 4 in timing. So there's a little bit more going on here, which I will get into in a moment.

On the other hand, universal quantifier is similar. I think I will leave it at that. There's this generator to try all the options. This is going to act in some sense like the one bit of memory, the latch, that we had before. So it's similar. But I think the details are not worth getting into. If you look at the appendix of Games, Puzzles, Computation, you'll see an explicit execution of this thing. I mean, it's like life. You just run it through and see if it works. And it does.

So what's going on up here is that when we set x bar to be false, we're going to flip this edge. And we're basically telling the circuit, hey, x is false. And then at some point it's going to acknowledge and say, OK. I understand that x is false.

 

But that's going to be on a different channel. So let me illustrate the issue. So this is how we used to do CNF logic. We did ANDs of ORs using OR vertices and AND vertices. And that was cool if we had a signal for what was true and what was false, we could throw away signals we didn't need.

Then this would propagate and produce a true answer. Nondeterministically it would. But deterministically there's a lot of timing issues here. Everything has to arrive at the inputs at exactly the same time. And AND will only work if this edge and this edge simultaneously reverse.

So OK. Maybe you could subdivide enough edges to fix the timing issue. But it's worse than that. If you're doing an AND of two things, and you discover that the answer is false, then all bets are off. So normally that would be OK, because we can always undo what we did. But we need to guarantee that the deterministic constraint machine will exactly undo what it was supposed to do. So it's an issue that if one of these comes in true and the other's false, this one will bounce back and then chaos will happen. We'll end up getting edges just randomly reversing it at annoying times.

So that seems messy. And so instead we build this much safer version called AND prime, OR prime, and split prime, I guess. There should be a prime there where each input is represented by two things. First the signal, and then the acknowledgement.

And so there's some details to check here. The OR is particularly messy. But these are just deterministic constraint logic machines. You see this gadget yet again to try various things.

But in this case, if input 1 comes at sometime before input 2, then it will essentially-- so this comes up. The signal gets split out here. And so we send off the acknowledgement. And then this edge will, I think, just be flipping back and forth. So it's basically holding the input for awhile. And later, the second input could come in. And it will trigger this to happen, and also trigger the output, and also trigger the acknowledgement, cause it does all the things.

So that is roughly how that works. So I think the details are not worth spending more time on. This is the final thing after you have all the CNF logic come out, then this is how you end up sending it to satisfy out to the quantifiers, which are here.

So it's a bit messy. But the main point is that this works. And so hopefully we can use deterministic constraint logic to prove lots of interesting zero-player games are hard. We don't know very many interesting zero-player games. So please help in finding them.

There's one detail I'd like to get rid of though. These degree 2 vertices, it would be nicer to avoid those. So this is a bunch of reductions to get rid of degree 2 vertices and keep things mod 4. So we're going to take every edge and subdivide it into a path of length 4, because then if we have two red edges in the original graph together, instead of replacing it by two red paths of length 4, we're going to replace it by two paths here, with the first and last edge being red, but everything else being blue. The motivation for that is now we just have blue, blue edges and red, blue edges. No red, reds.

To get a blue, blue, we just add on a thing like this that's forced to be out. And this will be satisfied if and only if one of these is in. So we've done that kind of trick before. And red, blue edges, we've explicitly done before. So we know how to deal with those. And so we do all the subdivision in order to get rid of the red, reds. Also where these guys have a smaller weight constraint, just one of them has to be in.

So now we have no degree 2 vertices. The other thing is, we have a non-planar graph. It would be nice to get rid of the crossings.

AUDIENCE: Don't you still have a timing issue?

PROFESSOR: This should preserve the fact that everything happens at time 0 mod 4. So we'll slow everything down by a factor of 4. But it shouldn't be a timing issue. And because these things are rigid, they don't have any timing.

OK. So next we get rid of crossings. This actually is a little easier for once. This was how we implemented a red, red, red, red vertex in the crossover gadget for NCL. But here it's actually enough as a crossover, because we have the luxury of timing in some sense. There are a lot of things that could've happened undeterministically that just can't happen deterministically.

So does it work? Here I pasted in the figure. You run it through and you check that it works in both cases. If they don't activate at the same time, then it works. Activated at the same time, I don't know what would happen. But we can offset all the timing so there are no collisions. And boom, we get crossovers.

So the conclusion is deterministic constraint logic is PSPACE complete for a planar and OR graphs. I think I actually want to also say split. So normally we think of AND and OR as the same thing. But it is helpful to distinguish them based on their initial orientations. An AND would probably be this way. Because you want to activate this, and you can only do that if both of these have been activated.

And so this is the output. For a split, this is the input. So it's initially not active. And then it wold look something like that.

So if you want to distinguish between these two vertex-- sorry. This should be the other way. If you want to distinguish what the initial orientations are, then you also need to list split here. So up to you whether you feel like doing that.

OK. That's all I want to say about zero-player games. Any questions?

AUDIENCE: What should happen in the end? Everything is--

PROFESSOR: In the end, if you satisfy the whole formula then you will get here, this edge will reverse. And so the decision question is, does this edge reverse? Either it will or it won't. In both cases, I think the behavior's periodic. Because it's a funny thing. Yeah.

AUDIENCE: So there were two decision problems for nondeterministic constraint logic. One of them was can you reach this configuration. Another one was can you fit this edge? Do you know anything about--

PROFESSOR: Yes. OK. If you want to solve configuration to configuration for DCL, I think you can basically add some red edges here. So if this thing activates-- well, you need to do a little bit more of a construction here. But I want to basically get an edge to start flipping over here. Whereas before it was not flipping. I think you can get an edge flipping, and then everything inverts. And then you will be in the original configuration, except this guy will be flipping. If you set your parity right, then he'll be flipped in a state where everything else is in its original state. So, pretty sure. I forget whether that's in the book. But I think configuration to configuration, also PSPACE complete for DCL. Good.

So let's move on to multiplayer games. First I'd like to reduce to the two-player case. So there's a big difference between one and two players. But there's not so big a difference between two and three and four and five and six players.

At least the usual decision problem is, does the first player have a winning strategy. Can the first player win, basically. Sometimes this is called a forced win. If a player forces a win.

If you think of it this way, and all the other players are free agents, then the worst case is when they all collude to try to make you not win. So that would be the opposite of a forced win. If it's not possible for you to force a win, that means the players can somehow work together in order to prevent you from winning. So in that sense, they are all essentially one player. You can thinking of them as one hive mind.

Now in the mechanics of the game, of course there are differences between two players and three players, because they have more power in some sense. They can do three things for every time you do one thing. But at some level that is just a two-player game again, where you are relatively impoverished compared to your opponent.

So the asymmetric, but still two-player game from a complexity standpoint. So we just need to think about two-player games and their complexity. Later we'll add some variations that make this not true. But in a perfect information deterministic game, this is true, this reduction is true.

So for a two players, we're going to have-- at least for the duration of this lecture-- the two players will be called white and black. In Winning Ways for example, they're called red and blue. But this is problematic because we have red and blue edges already. And I want red, white edges and blue, black edges and so on.

So the players will be white and black as in chess, checkers-- not checkers. Go, whatever. But color renaming.

OK. And I'm going to focus today on games that have a polynomial number of moves in any execution, which places the problem into PSPACE. So again, we're going to aim for PSPACE completeness.

It's PSPACE because you can think of this question as being equivalent to, do I have a move such that no matter how the opponent responds to that move-- so every move for the opponent, which I will call response-- I have another move such that no matter what the opponent does dot, dot, dot through the polynomial number of moves. If there's only a polynomial in many moves, then there's only a polynomial number of quantifiers here.

And then in the formula I'm going to write whatever the rules of the game are, and then AND it together with I win. I think you believe almost all games you can write as some Boolean formula to do that. Some polynomial-sized Boolean formula saying at each step you satisfy what you need.

And so this is a QSAT problem. And therefore, any two-player game where you can write moves and responses succinctly and have a polynomial number of moves is in PSPACE, because you can reduce it to QSAT. OK.

So that's why PSPACE is the class we care about for polynomially bounded games. So now we want to prove hardness. And first I want to give you some hard problems in this setting starting with SAT-style games.

This is from another paper by Shaefer, same guy who did Shaefer Dichotomy Theorem. He also did some nice stuff on games. So first game is just your favorite flavor of QSAT. You can think of it as a game. Because QSAT is exactly of this form, you can think of the game as-- in your first move you're going to choose this variable. In your second move, your opponent is going to choose this variable. In the third move you choose this variable. And so on.

Because play alternates, you are following exactly an alternating quantifier kind of thing. And the goal of player one is to satisfy this formula. The goal player two is to have it not satisfied in the end. And so player one will win if and only if this formula is true.

So in the game, you think of it as there are a sequence of variables-- x1, x2, x3. Play alternates between assigning xi and xi plus 1. Player one's always assigning the odd variables. Player two is always assigning the even variables. And then if the formula is satisfied, then player one wins.

OK. So this is what you might call the game version of a satisfiable formula is that player one wins if and only if the formula is satisfied in the end.

But there's some other goal conditions you might consider that Schaefer defines. One is called Seek, which is the first player to satisfy the formula wins. And so in general, if you're choosing some variables, you have a set of variables, some of them have been assigned 0 or 1. Some of them haven't been assigned yet. So when I say satisfy here, I mean that unassigned things are 0. So if you think of everything as initially 0, whoever satisfies the formula first wins.

Then the opposite version is Void. So the first person to satisfy the formula loses. So the formula starts false. And the first person to set it to true loses the game. Other person wins. OK. So those are some rule variations of the goal state. Now let me tell you about the moves.

So other than QSAT, we're going to have two types of moves. One is impartial moves. Impartial means that both players have the same moves.

So an impartial move is going to be whoever's playing sets an unassigned variable. So on all of these games, you can only assign a variable once. If you can assign it multiple times, then you're no longer polynomially bounded, and you get x time completeness.

But for the polynomially bounded games, we're going to define each variable can only be assigned once. And in a partial game, any player can assign any variable that's not yet assigned. OK. So whereas in QSAT, you had a fixed ordering. First x1, then x2, then x3.

An impartial game version of SAT, players take turns setting variables, any one they want. It's not yet assigned. And in the end, if the formula is satisfied, player one wins. That would be impartial game. But I could also do impartial seek, impartial void.

And then by the way, I made up these names. So they don't match what Shaefer calls them. But these are more modern. These terms are in Winning Ways, for example. Seek and Avoid he used. But the other ones I made up.

OK. Partisan version is that there are white variables and there are black variables. And the white player can only set white variables, black player can only set black variables. There's 50% of each. And so they balance if you play all the way to the end, like in the game version, then it's OK to have the white player play any unsatisfied white variable and set it to true or false.

I think that defines all the games that I want. Now let me tell you which combinations are PSPACE complete. A bunch of them. So impartial. In addition to this characterization, there's also all the different versions of SAT that we know.

So we have impartial game positive 11-SAT. So this is a version of CNF. Instead of 3-SAT, I have 11-SAT. There are no negative literals. And it's impartial. So anyone could set any variable. And it's the game version, so player one wants to set it true. Player two wants the formula to be false. That's PSPACE complete.

Also, if we do 11-DNF-SAT, so a DNF formula with positive. This is also as hard. I mean, that essentially corresponds to flipping all the quantifiers. So that doesn't make a big difference.

So this is cool because positive SAT is usually pretty easy with all existential quantifiers. With alternating quantifiers, not so easy. Yeah.

AUDIENCE: Is impartial game positive 10-SAT [INAUDIBLE]?

PROFESSOR: We don't know the exact cutoff. There is a paper, I think, proving six is enough. But the positive disappears. So I think that's an open problem, how low you could go.

It's hard to do the usual kind of reductions from many occurrences to fewer, because games are very sensitive about who's playing win, timing, and so on.

So next one is partisan game CNF-SAT. Here we don't have positive. And we don't have the bound 11. But we changed impartial to partisan. That still is hard.

And next we have a whole bunch of games that work both for impartial and partisan moves. OK. So we have avoid positive 2-DNF-SAT. We have seek positive 3-DNF-SAT. We have avoid positive CNF-SAT. And we have seek positive CNF-SAT.

So the main point is, most combinations are hard for some version of SAT. And these are the tightest ones that Shaefer could show. Doesn't necessarily mean that they're tight. And there's no dichotomy theorem here, so we don't know exactly which problems are hard. But this is a ton of games to start from. And in particular, we're going to use at least one of them.

OK. Let's maybe go over here. OK. A couple more problems which are in Shaefer paper. One's called Kayles, one is called Geography.

Kayles is essentially the two-player version of independent set. So there are a couple of versions. There is node Kayles and bipartite node Kayles. These are the traditional names. You could also think of this is impartial Kayles and this as partisan Kayles.

So here the moves are all the same. The moves are here. Pick any vertex, add to an independent set. That's a move. So players take turns adding. At all times, you must add a vertex that keeps it independent set. So you're effectively removing all of its neighbors and itself. Last player to move wins. You can't move, you lose.

Bipartite node Kayles, you have a bipartite graph. And one side you call white, one side you call black. A white player can only choose from the white side. A black player can only choose from the black side. So these are both PSPACE complete as well, via reductions from these problems. But I don't have those reductions with me.

OK. So that's independent set. Geography is essentially a two-player version of Longest Path. It's inspired by this real-life game where one person names a city or country or pick your favorite class of objects. And then the other player must name a word whose first letter equals the last letter of the previous word. So you're forming chains of words. And you can think of that as just having a graph where vertices are the words, the edges are valid moves between words. Do they have some common property.

So in general, you're given a directed graph and you're given a start node. And you have a token at that start node. A move in the game is to follow an edge, to move the token along an edge.

But then there's some non-repetition condition. So we have node geography where you're not allowed to repeat any notes. That would be the usual longest path. And again, the last player to move wins. If you can't make a move, you lose the game, just like the real game.

And on the other hand, we have edge geography, which is more like an [INAUDIBLE] path. The longest edge destroying path. So edge geography you're not allowed to repeat edges. And for each one, you could think of a directed graph, you have to follow directed edges or an undirected graph.

And here undirected, no geography is NP.

Directed, no geography if PSPACE complete. And for edge geography, surprisingly, both are PSPACE complete. So this is a useful problem. I've seen a ton of PSPACE completeness proofs based on geography. It's kind of conceptually clean. And I will show you one now.

Everyone play Othello, Reversi. In general, you have these pieces which are black on one side, white on the other. The black side is the one that you play if you're the black player. But then you can, for example, if you place a new black stone here, given this configuration, because there's a black string of whites and then a black here, you end up flipping that one over. Because this is black and then a bunch of whites, or black and then a space, nothing else happens.

In this picture though, if you place this black thing, this is black, a bunch of whites, then black, black, bunch of whites, black, black, bunch of whites, black. So all of those flip over. And your goal is to maximize your color. You want more more stones of your color than the opponent's. OK. Cool game.

Bounded number of moves, polynomial number of moves, because every time you add a new stone, you've occupied one of the squares on the board. And you'll never get that back. So n by n board would be exactly n squared minus 4 moves, because four is the original number. So this is PSPACE complete, given a particular configuration to decide whether black has a winning strategy, say, is PSPACE complete.

And most of the construction is in here. This box is actually this picture. And that's going to simulate geography.

But let me tell you about this other part. So right now white has a huge amount of area. This is actually really big. So I guess this is very thin, so there's not much action here.

Here you've got a huge amount of white area. So white will win unless black can take this part. And what happens is there's a gap here. And if black can play any of these spots, now black won't be able to play here if there's some corresponding black thing over here. So that's what these long horizontal channels will be. So if black can play over here, because there's a black stone and long white channels here, then this will flip to black.

And then in this picture is this. So if one of these stones up here is now black, that means you can play at position alpha. And if I play at position alpha, black plays there. Then I get black all the way here.

White can't really respond much to that. And then in the next black move, black can go here and flip that one. And then black can go here in the corner. Corners are very important in Othello. So once you take this corner and flip all these things to be black, then I can play here, here, here, here, here, here, here and take all of these.

And because this is the edge, white won't be able to take anything back. So that's the threat. Each of these lines is going to be a threat that if any of these become black over here, white has to turn them back to white. Otherwise, in the very next move, black will win the game. OK.

 

A lot of two-player game proofs have this constant notion of threat. One player's basically just slogging through trying to put out fires. And the other player is constantly causing fires in order to force the other player to do what they want. So it almost reduces to a one-player game. But there's still some choices involved.

Well, these are not terribly exciting. But let me show you the typical setup. This is just a turn gadget, or it could be a degree 2 vertex.

I should mention we're reducing from directed no geography, where this is directed no geography. Also max degree 3. So that means you might have a degree 2 vertex, or you might have a degree 3 vertex. There are two types of degree 3 directed vertices merging and branching.

So we need gadgets for each of these. Also, bipartite. Bipartite is useful because in geography you're always moving along an edge, which means you'll always be jumping from the left side of the bipartition to the right side. So you can color the edges black and white. And black player will only play in the black side, and white player will only play in the white side. So this is good. You can predict who's going to be playing in each gadget.

So in a degree 2 gadget, it works something like this. If white has played here, that will be because of the other gadget. This is the trigger. Then now this is black, a bunch of whites, and now black can play here, reversing all of these. This is a threat line. And there's now a black square, which means white must immediately play here in order to reverse all of those stones back to white.

But now this is a white stone, which lets this thing trigger. So now black can play at the end of this thing, et cetera. So this just propagates a signal, does a turn. It's a degree 2 vertex. Whatever. All those things.

And this is slightly different version for a different orientation, because these things have to go to the left. This looks a little different. OK.

More interesting are the degree 3 vertices. This is the type where I have two incoming edges and one outgoing. Key thing here is we need to check that we do not visit this vertex more than once. We came in here and then came in again. We want something bad to happen.

Now what should happen bad depends on whether it was the white player moving or the black player moving. if it was the white player moving and they double visit, it means white should lose. If it was the black player moving, and they double visit, it means black should lose.

Because of the bipartiteness, we know which gadget to use. They're almost the same gadget. Just these two dots have been added.

So something like, if this activates, and it's symmetric, but let's say this one activates by white playing here, then black can play here, flip all those, which has this threat line, which means white must play here. Flip them all back to white. But now this B1 position is white, which enables black to play here, flip all those to black. This is the threat line, therefore white must play here. Can't play there. And turn all these back to white. Now this is white. And now this activates down there. So that's just following the vertex. No big deal.

But if you came along a second time and activated this as white-- now this is already white. So when you play black, you get a black here. And white can't do anything. There's no white stone up there. Yeah.

Well it's entirely black. If there was a white on either side, white could flip it and get them back. But you can't. And so you actually have two threat lines activated. And then black wins. So this is the version where black wins.

If instead, we have a white thing here, everything else is the same. So this was white, this was white. Black now plays here. Now white can go here and completely make this thing white, and then black doesn't have any moves anymore. And that's the way that white's going to win is to prevent black from playing anymore. Then the area that was white is white, so we're done. There are lots of details here to check, but that's how it works.

There's one more gadget basically that says this is for one incoming edge and two outgoing edges. So here you want the players to have a choice, either I go this way, or I go this way.

And if it's a white vertex, you want white to make that choice. If it's a black vertex, you want black to make that choice. But black is still kind of doing all the action. So it can be done. When this activates, then black plays here, flipping all these things. Then white plays here, immediately flipping it back.

That's the trouble, is always black is in control. Now black plays here, flipping that one guy. And white has two choices. It can either play here and flip just this one, or play here and flip those guys. And either put a white here or here, and that will end up activating for black either this path, or this path. So white made the choice. And in this version, black makes the choice. That's a little easier. Yeah.

AUDIENCE: Are these gadgets constructable?

PROFESSOR: In an 8 by 8?

AUDIENCE: No. Like from a starting configuration. Can you get to a configuration of these gadgets?

PROFESSOR: Oh, I see. I think so. I didn't read that as [INAUDIBLE], but it wouldn't surprise me if it's in the paper. It's traditional in constructing these generalized games to actually show that you can reach this position from the initial state. Although the problem makes sense even if you can't.

It's more interesting to say, well we played like crazy. And then we ended up with this thing. Can you finish it off for me? That's basically the problem we'd like to solve.

Can white win? It's like the commentator problem. People are playing. And now I want to know who's going to win at this point. But I don't know for sure for this reduction. Usually they can.

OK. So that's a sketch of Othello PSPACE hardness reduction from geography. So the last thing I want to talk about, back to this picture, is the two-player setup for constraint logic. So polynomially bounded, two-player game should be PSPACE complete.

First I'm going to talk briefly about what does bounded mean in general for constraint logic. So in particular, for one player which we know, the bounded NCL means each edge can flip only once. That's our definition. And that game is clearly in NP, cause one you flip all the edges, you're done.

And in the same way, we prove that just finding and satisfying orientation of a constraint graph is NP complete, we can show just I changed the very top gadget, that bounded NCL, you just want to flip this one edge is NP complete. Because you basically have to make a choice for each of these vertices, which way to set them. And then you can propagate up. We don't have to flip any edges for this very simple proof. So NP completeness for a bounded NCL.

We do for this proof need a choice gadget. So all three red edges. It doesn't work to just blow it up like we could before in the bounded case. OK. And there's a crossover gadget in this setting as well. It's actually pretty simple because a bounded you can't revisit.

OK. So now bounded two-player constraint logic is called 2CL. This is PSPACE complete by pretty much the same proof structure. So what's the game? I have white edges and black edges. Each edge is white or black, and it's also red or blue. Exclusive ORs.

So they're drawn as-- these are all white edges. This is an example of a black edge. So the fill is white or black, the outline is red or blue, as before. White players can only flip white edges, black players can only flip black edges. And otherwise it's the same constraints. I mean, the inflow constraint doesn't care whether you're black or white. It's politically correct vertices, I guess.

So we just need one new type of vertex. Everything else is going to be done by the white player. There's one new type or vertex, which is an incoming black edge and an incoming white edge. Call this a variable. The idea is that wherever gets there first, white or black can flip it, preventing the other player from flipping their edge.

So that's what we're going to use for variable settings. And I'm reducing from-- remember the terminology here-- impartial game positive CNF-SAT. The very first one here. Impartial game positive CNF-SAT.

So player one's goal-- white is the player one. Player one's goal is to satisfy the formula and flip their edge. And it's the impartial version, meaning anyone can set any variable. So if black plays this edge, that's going to correspond to setting x2 false. If white plays the edge, it's going to correspond to x being true.

Because this is a positive formula, every time white choose a variable, they're gonna want to set it to true. And every time black sets a variable, they're going to set it to false, because they want to prevent satisfaction of the formula.

So that's why it's OK to just represent it this way. And then the rest just propagates. So if there are n variables, there's going to be n over 2 rounds where all the variables get set. And then black can't do anything else. Just sitting there. This one is not going to be flippable because of this gadget.

So white's just going to fill in the formula. And if it happens to be come out true, and white can flip their edge, then they win the game. And that will correspond to the formula being true. And otherwise, not. Yeah.

AUDIENCE: So is pass in that you can do? Or they're just like--

PROFESSOR: In this game you can pass. I think you could probably avoid that by just adding a bunch of floating black edges that you can flip, or just flip repeatedly until white either wins, or white doesn't win. The decision question is does white win?

Now we end up with a tie in the case white doesn't win. You can also change that by having a long path of blacks. And black is going to sit there flipping, trying to get to flipping their edge. And the length of the wire is exactly how long it takes to fill in all these things. Yeah.

AUDIENCE: The reason why they have that gadget there at the end is you need to set exactly a certain number of them true? Before black can, and so--

PROFESSOR: Oh. I see. Right. Yeah. That's a little more subtle.

 

OK. Zero minutes remaining. The same crossover works. And you can also build a protected OR. Protected OR is where you never have both of these coming in.

If you allow me the notion of a free edge, which is just floating there and can be reversed whenever you want, this is a white edge, then this will act as a OR, because this choice gadget can only go one way or the other. It's only one of the inputs can actually flip one of these edges, and then the OR will just take it. So we can build predicted ORs.

And then I have a bunch of PSPACE hardness proofs based on bounded constraint logic, but I suggest we wait til Thursday to see this. Because they're kind of fun. And I'd rather spend a little time going through the proof details.

So you'll have to wait in suspense before we get to Amazons, which is a very fun-- you should play Amazons meanwhile, if you get a chance. It's very fun if you have a chessboard around.

And Konane, which is an ancient, at least 300-year-old game from Hawaii, and Cross Purposes, which is a modern game. These are all three bounded two- player games. And they're all PSPACE complete by a reduction from bounded two-player constraint logic. Cool.