Lecture 2: 3-Partition I

• Download this transcript - PDF (English - US)

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, are you guys ready for some more hardness proofs? Let's do it. So today, we start the universe of 3 partition. And in general, we're going to see today 2 plus problems, which are useful for dealing with numbers for reducing to number problems. Numbers here are going to be integers for the most part. Usually in complexity, it's a lot easier to think of all your numbers being integers. If they're not integers, use fixed point or rationals, and then they're basically integers.

So we're going to talk. My favorite is 3 partition. And pretty much all the proofs we'll do in the number context will be reduction from 3 partition. This is all about NP-hardness, I should say. But before we get to e partition, I'm going to talk about another problem, which is called 2 partition.

First, I'll just have to define all these problems, which will take a little while. Then we'll get to all the fun reductions. So in 2 partition, your given n integers. We'll call the set of them capital A and we'll call the integers themselves little a sub i-- i from 1 to n, let's say. And what we'd like to do is partition them into two groups. Let's say A1 and A2 equals A of equal sum. We want the sum of the integers in A1 to equal the sum of the integers in A2. And therefore, they will equal one half the total sum.

OK, so we just want to find our choice for each number. Should it go in A1 or A2? So this problem is NP-hard. And it's one of the original Karp problems. There's this famous paper by Karp in 1972. Before that, there was a paper by Cook that proved SAT is NP-complete. And then Karp wrote a paper with a zillion-- not literally, but dozens of NP-hardness proofs from SAT to things like 2 partition. I will not cover the proof here. If you're interested in it, read Garey and Johnson. There's some nice coverage of this problem and all the problems we'll be talking about today.

OK. As a sideline, I'll mention there is a generalization of this problem. So it's also NP-hard. Any generalization is going to be even harder. But it's useful to know about. It's called subset sum. Occasionally it's easier to think about subset sum instead of partition, although it's a generalization. So if you can reduce from subset sum, you can also reduce from partition.

And here the set up is similar. You're given n integers again, just like before. And you're given a target sum. This is one other integer. We'll call the target sum t. I'll also call this t. And what we'd like to do is find a subset S of A whose sum is t. OK, this is a strict generalization here. You're not given a number t, but you're essentially choosing a subset A1, whose sum equals the sum of A over 2.

So this is really just a particular choice of t. This is the general case where you're given t. So this is harder than that. But it's worth knowing about. In particular, there's a problem set problem, the problem set will be out in a couple of hours. And it's a little easier to think about subset sum, we think. You don't have to.

All right, so let's go to 3 partition, my favorite NP-complete problem. So start is the same, given integers A1 up to An. We're not given a target sum. What we'd like to do is partition them-- partition that set A into how many pieces?

AUDIENCE: 3.

PROFESSOR: 3. Nope. n over 3. Kind of like 3. Not quite. Let's say sets A1, n over 3 equals A. I'm using union with a dot to indicate it's disjoint union. So that's what a partition means. That's redundant. This is old fashioned notation. You probably haven't seen it, but when I was growing up, that was the notation of the day.

Then we have n over 3 sets. Cool, yeah, assume n is divisible by 3. Otherwise the answer is no. And then this is the easy case of equal sum. So we want the sum of each Ai to be equal to t, which is to the same thing. They're just going to be the sum of the A's divided by n over 3.

OK, if this problem were about partitioning to 3 sets, it would not be very interesting. It would be basically identical to 2 partition. With n over 3 sets, things are quite a bit different. And we will get to that difference in a moment. But first, let me tell you about some fun facts about 3 partition.

So we're partitioning into n over 3 sets, so you would expect, on average, most of these sets will have size 3. In fact, you could make all the sets have size exactly 3, because if you look at the reduction for this problem, you can assume that each Ai is strictly between t over 4 and t over 2. OK, if you're going to have a set of numbers that's summed to exactly t and each of them is strictly bigger than t over 4, then that means you can't have 4 of them because you would sum to too much. And they're strictly less than t over 2. And you can't just have 2 of them and hope to get to t. So you have to have exactly 3 in every set.

You don't have to assume that. In some situations, it's useful to just say, well, the Ai's are sum sets that sum to the right things. Sometimes it useful to assume that they're triples. It's up to you whether you consider that part of the problem statement, to ask for the Ai's to have size 3 or not. And it's useful to have both.

In fact, once you have this, you can make all the Ai's very, very close to t over 3 using a trick, which we'll see a bunch of times today. So let's say you could add-- I'll call it infinity-- to each Ai. In that case, of course, any solution that you had before is still a solution. Just think of infinity is a really large number, something like n to the 100 times maximum item in A. Something like that. That's really maybe to the 100th power, if you want, but a really big number.

This will preserve all solutions, because all solutions, every set has size exactly 3. So if you had 3 times infinity, they'll still have the same sums. And when you do that, then all the Ai's are basically equal to each other, which means they're roughly equal to t over 3. The leading term is the same for everybody. And then there's this little noise, which was the original integer that you're adding onto, that infinity. So then all the adds are roughly t over 3. Cool.

Let me tell you about a couple related problems to 3 partition. And then I'll tell you why we're even bothering to talk about two problems instead of just one. So next problem has a funny name, especially when you don't know what 3 dimensional matching is, but we will get to that second. Don't worry about the name for the moment. This is a closely related problem. It's really a specialization of 3 partition.

In this case, we're going to be given 3 sets of integers. And what we'd like to do is-- it's basically the same problem. Just think of taking the union of those sets, but each of these sets that we're choosing, the Ai's, should consist of one element from A, one element from B, one element from c. So how did I formalize that? Let's say a partition. This is a disjoint union into triples, Si, and cross product ABC. So you're choosing one from each of these guys in each Si, and they should be of equal sum.

And so the sum will be sum of A plus the sum of B plus sum of C divided by n , I think, because there's 3 of them. Cool. OK, so almost the same problem, I just changed what n was by a factor of 3. That's why there's n over 3 here and then here. But here, we're specializing in a sense to say that we're giving different types of numbers-- the red integers, the green integers, and the blue integers. You have to choose one of each color.

OK, for fun, let me show you why this problem is, in some sense, simpler. This also gives you a useful technique for playing with these number problems. So I want to reduce from this numerical 3 dimensional matching problem, which you might also call the ABC version of 3 partition. I will reduce it to 3 partition. So I'm given an instance, these numbers. So the basic idea is to take these numbers just throw them into one big set, A prime. But I want to force this ABC property that I choose one from each. Maybe any suggestions how? Yeah.

AUDIENCE: Well, I just have a question. You define these all as sets. You can't have duplicates of an integer?

PROFESSOR: I didn't say the word set. I actually meant multiset. Yeah, so this is a multiset. Good question. All of them are multisets. So it makes the notion of disunion a little bit weird. But you know what I mean. Yeah.

AUDIENCE: Could you add a really big number to all the B's and twice that really big number to all the C's?

PROFESSOR: OK, add a-- hadn't thought about this. So add a really big number to all the B's, and then twice that big number to all the C's. And then the target sum would be three times the big number, plus--

AUDIENCE: I'm sorry, so make it three instead, so you can't do three things from each side.

PROFESSOR: Yeah, right. So you don't want take two B's and then that looks like a C. So maybe you want three times a big number here and nine times a big number here. Something like that. I think actually one times a big number and three times a big number would do it. Yeah, cool.

So the way I did it in the notes was adding a small number, but either way, it works. Let's do it with the big number, because that's fun. So we will construct, I'll call it A prime to consist of a overall little a and big A. And then we'll say a plus-- usually big number I write with a capital B, but that's not very good because we already have a couple of B's. So I'll call it X. Or I should call it infinity for consistency.

So for each b and B, I will add infinity to it. And then c is going to be is 3 times-- let's do 4 times infinity. It makes me feel a little safer somehow, because we're constructing a set of size 3. So if you take 3 of these, I worry that looks like a C. It's not enough, but we'll be safe. Why not? We can choose pretty big numbers here. So happy? No?

AUDIENCE: You might be able to do a couple A's in a single set. The set should be small, because they're not-- [INAUDIBLE].

PROFESSOR: OK. a is our problem. You could maybe do more than 3 total. So let's do 1 infinity, then get a proper eraser. It's a good thing we have Sarah here to correct our proofs. 3 infinity 9.

AUDIENCE: I think it's enough, because then we need--

PROFESSOR: 6 would be bad, because then 2 of these would be 1 of those.

AUDIENCE: 13 infinities on [INAUDIBLE].

PROFESSOR: Right, so this means the new target sum should be the old target sum, which was the sum of these divided by n, plus 13 infinity.

AUDIENCE: Isn't infinity a function of the n's?

PROFESSOR: Infinity I should define. Let's make it, I think, just like 10 times max of A ought to do it. You could be it as a function of n. I don't think that's necessary here, because all of our sets are size 3. But if you're doing something like this for 2 partition, you'd want to multiply by n or n squared. This is a common trick to do this kind of scaling or offsets or things like that. Instead of infinity here, you can write epsilon, where epsilon is much smaller than 1. I think that would also work. And that's what's done in this.

AUDIENCE: So we just make it the max of the A as opposed to A prime?

PROFESSOR: Oops, this should probably be max of ABC. Yeah, you can't make it max of A prime. That would be cyclic. That infinity would actually be infinite. Good. So I think that works. There are things to check here, obviously. We need to check that whenever we have a solution to the original instance, we have a solution to this instance. That's pretty clear. You just take the same choices of the Ai's, Bi's, and Ci's.

And the infinities will always add up to 13. The tricky part is to show that if you have a solution to this 3 partition instance, you can convert that back into a solution to the numerical 3 dimensional matching instance. And that's where you essentially want to show that the infinities can be treated algebraically. Because they're so huge, you could never construct an infinity in another way.

But I'll leave that as an exercise to actually proof, because we're not really going to use this problem too much. You're welcome to, maybe on problem sets, maybe on open problems it would be good. But most the time, I would say we use 3 partition. I want you to know about this in particular, because it's related to another problem, which is called 3 dimensional matching. Yes?

AUDIENCE: Is the assumption that the Ai is all a cardinality of 3 built into the problem specification here?

PROFESSOR: You get a choice. You can either make this part of the problem specification or not. It won't matter.

AUDIENCE: OK, well I think in this case, if you don't know the problem specs, can you take 12 A's for something? And then you get 12 infinities and then they add up to another infinity?

PROFESSOR: Yes, we definitely want to take this as part of the specification for this reduction. Yeah. Good point. OK, so here's a problem. You've probably heard of the matching problem. Let's say the perfect matching problem is you're given a graph and you want to find a set of edges which are disjoint, meaning no two edges share a vertex, that covers all the vertices. So if you have n vertices, you'd like to find n over 2 edges that are disjoint from each other. That's perfect matching. You might call it 2 dimensional matching, because an edge has 2 ends.

3 dimensional matching takes place in a hyper graph. And in this case, it's going to be a tripartite hyper graph. You may not have seen hyper graphs before. They're just like graphs, but edges can have more than 2 endpoints. In this case, they will have exactly 3. So let's say the vertices are A disjoining in B disjoining in C. And let's say they all have like size n. And the hyper edge is E.

OK, maybe it's worth drawing a picture. So you have this set A, set B-- they're all the same size-- set C. And an edge might look like this or like this or so on. OK, you take one from each. And then your goal is to find n disjoint edges. If we find that many and they're disjoint, that means they will cover all of the vertices. Every vertex will be hit by exactly one hyper edge. OK, so this is the 3 dimensional version of bipartite matching, I guess. There's also the non-bipartite version.

For extra completeness, there's something called exact cover by 3 sets, 3 meaning the cardinality. This is called X3C. You do see 3DM and X3C frequently in the literature and especially in Garey and Johnson. So they're good problems to know about. Here is sort of the generalized version, where you're given non-tripartite, just a 3 uniform hyper graph. 3 uniform just means every edge has cardinality 3. And your goal is to find-- let's say it has n vertices-- n over 3 disjoin hyper edges.

OK, many times the almost same problem. How do these relate? Well, certainly if you take a numerical 3 dimensional matching problem, that is a 3 dimensional matching problem. You can convert it into a graph like this. You're just forgetting the fact that there's numbers. But then when you draw the edge, you draw one of these hyper edges exactly when Ai plus Bi plus Ci equals the targets sum.

So numerical 3 dimensional matching is a special case of 3 dimensional matching. Occasionally it's useful to start from 3 dimensional matching. Not for number problems though. If you have a number problem, you like the numerical version. Personally I prefer 3 partition, but these two are pretty close. We saw one connection between them.

Exact cover by 3 sets is, in some sense, even more general than 3 dimensional matching. Yeah, it is more general, because tripartite hyper graph like this is 3 uniform. So this is a strict generalization of that. But they all appear somewhat, so I thought it'd good for you to know about them. Again, 3 partition is where the action is.

All right, let me go back to this issue of 2 partition versus 3 partition. These are the two main problems I want to talk about. And they relate to an important distinction in NP-hardness, which is weak versus strong NP-hardness. So there are two types of NP-hardness for number problems. If your input is a graph, these two notions are the same, so you don't need to worry about it. But when your problem has integers as input, then there are two types.

Weakly NP-hard is, in some sense, the type you already know, if you think about it in the right way, in the intended way. We haven't been super formal about how numbers getting encoded, but usually we think of NP-hardness in terms of how hard your problem is in terms of the encoding size, which we usually call n, the encoding of your input.

OK, so in the usual form, what this means is that you allow numbers to have exponential value, because even when their value is exponential, the encoding of that value is polynomial. Coding length of such a number is, if you read it in binary, that's log base 2 of the number if the number is 2 to the n to the c, which is our definition of exponential. That's going to be n to the c. And that's polynomial.

OK, for here, I'm going to let n be the number of numbers to avoid circular definitions or something. So I'm saying there are n different numbers. If each of them is at most 2 to the n to the c in value and they're integers, then I can encode them in this many bits. And that's a polynomial number of bits. So I consider that a reasonable encoding.

And sometimes that's just fine. But there's a stronger notion, which is really useful, especially for a lot of problems we will see today and next class, which is called strongly NP-hard. And this is NP-hard even when your problem is restricted to numbers of polynomial value. So polynomial here is with respect to n and is the number of integers-- number of numbers.

OK, so strongly NP-hard is stronger than weakly NP-hard. If you're NP-hard even when your numbers are only polynomial in size, then of course your NP-hard when you allow the numbers to be as large as exponential. This is a weaker constraint on the problem.

So to cut to the chase, 2 partition up here and subset sum are weakly NP-hard. And if you believe that the P does not equal NP, then it's not strongly NP-hard. That's the best we can hope for, whereas 3 partition in every other problem we talked about is strongly NP-hard.

AUDIENCE: I have a question. What do you mean exactly by numbers having exponential value?

PROFESSOR: So again, exponential is like 2 to the n to the c. n is the number of numbers in your input.

AUDIENCE: OK.

PROFESSOR: Yeah. So that's what I allow. I mean, this is what would be allowed if you didn't say anything, if you interpret complexity theory in a way that I haven't necessarily told you, but generally you want to assume that all your inputs are reasonably encoded in an efficient way that most possible input strings are valid inputs. And so if you're encoding, then in particular, you should encode your numbers in binary or ternary or quaternary or hexadecimal-- anything bigger than one is good. OK? And you should know if you're writing that number, don't use unary.

But today we're going to use unary a lot. So this is the same thing as saying encode in unary. Strong NP-hardness is like saying, well, my problem is so hard that even if I encode my numbers in unary, it's still hard in the resulting input size. The input size would be if you write down every number in unary and add up all the numbers. That's your input size.

3-partition is that hard. 2-partition is not. OK? So if you can prove strong NP-hardness, you should. It's better. If you can only prove weak NP-hardness, it's OK. It's still hard.

Now you should know, there are corresponding notions on the algorithm side. So let's talk about that a little bit.

So corresponding algorithms are-- there are actually three of them. The main ones are pseudopolynomial and weakly polynomial. Sorry. The weaklies are unrelated to each other, but that's life. There's also a notion called strongly polynomial-- unrelated to strongly NP-hard. Well, there you go. OK.

So weakly polynomial is the usual notion of polynomial I should mention. When I say I have a polynomial time algorithm, what you mean is weakly, meaning that, let's say, I'll write it as polynomial in n-- the number of integers-- and let's say, log of the largest integer-- largest number in the input. OK? That's a reasonable encoding size. You write them in binary. You add them all up. So you'd multiply that by n or whatever. And the polynomial in that value is weakly polynomial.

Pseudopolynomial you omit the log. OK. So I want polynomial on n and the largest number.

And strongly polynomial, you omit that term altogether. So you just polynomial n the number of numbers. OK? So there's a different world of algorithms which we're not going to talk about here, which is weakly polynomial algorithms versus strongly polynomial algorithms. I'm not aware of any lower bounds about that, but there are famous open questions like, can you solve linear programming in strongly polynomial time? We don't know. There's no hardness notion there. So we're not going to talk about it any more than that.

What we care about more is this distinction between pseudopolynomial. This is polynomial when the numbers are written in unary, and this polynomial when the numbers are written in binary. So these two notions correspond to these two notions. So in particular, if you believe p does not equal NP, then weakly NP-hard means there is no weakly polynomial algorithm. But there might be a pseudopolynomial algorithm.

Strongly NP-hard means there's no M polynomial algorithm, and so therefore there's no weakly polynomial algorithm.

Adam.

AUDIENCE: So the difference between weakly polynomial and strongly polynomial is that we don't even necessarily give ourselves time to read all the numbers and put it in binary?

PROFESSOR: I didn't want to get too much into models of computation, but the model of computation here is that you're allowed to read an entire number in one time step. So if you've taken 6851 Advanced Data Structures, this is like a word RAM. So that's the only reason this would be reasonable. Otherwise you couldn't read the input. That would be pretty hard.

So the model is you could take a constant number of your numbers, do something with them, output another number of the same type roughly in constant time. And you want to do a polynomial number of such steps, usually arithmetic operations.

Here you don't have to be so careful about the model because any reasonable encoding, you could read it and do whatever you want with it. If you don't care about the exponent in the polynomial, like all models are equivalent. If you believe the Strong Church [INAUDIBLE] Thesis-- anyway. This one you have to be a little bit more careful what the model is.

Good. So let me draw my favorite diagram with the difficulty axis. But now instead of p, I'm going to distinguish between weakly polynomial, pseudopolynomial, and strongly polynomial. So these things are pseudopoly. These things are weakly poly. And these things are strongly poly. This is on the algorithm side, upper bounds-- be on the left of the particular position. And then on the hardness side we have-- let me use red. It's more dramatic. This thing is weakly NP-hard. This is if p does not equal NP then you're strictly to the right of pseudopoly. So there's no pseudopoly problem. There's also weakly NP-hard.

And then strongly NP-hard excludes even a weakly polynomial algorithm, so strictly to the right of that position. So obviously, strongly NP-hard is a better result because it's smaller than this class.

But for example, 2-partition, which is only weakly NP-hard, has a pseudopolynomial algorithm. You've probably even seen one in your algorithms class if you've ever done anything like Knapsack as a dynamic program. That is a dynamic program probably originally done for a 2-partition.

OK. So that problem is somewhere right in here. Weakly NP-hard-- whoops.

AUDIENCE: I think the diagram that's is backward, but I don't--

AUDIENCE: Yeah. Diagram is--

AUDIENCE: If a problem is strongly polynomial it ends [INAUDIBLE] a weakly polynomial.

PROFESSOR: So the middle one's right. Thank you. That seemed funny. But strongly polynomial is this tightest class. That's the best result. And pseudopoly is the worst result. Did I get my arrows in the right place?

AUDIENCE: You've got to shift over.

PROFESSOR: Shift over one. Strongly NP-hard. Whoops. So weakly NP-hard is here. Strongly NP-hard is there. OK. Cool.

So let's check. So 2-partition should be pseudopoly, so left of this line, but weakly NP-hard still right of that line. That looks good. So this is 2-partition. 3-partition is out here. I mean, I'd draw this is a region, but it's more like a point in my old diagram because 3-partitions are actually E and NP. So it's strongly NP-complete. So it's like right at the edge there.

Anyway, there's no pseudopolynomial algorithm for 3-partition, unlike 2-partition. That's the point of all that.

Let's do some. Shall we? NP-hardcore time. So that'll be over here. OK. The first reduction is going to be pretty--

AUDIENCE: May I ask a question before we move on?

PROFESSOR: Yeah.

AUDIENCE: So why is there a no corresponding notion for problems are not numeric? Like why can't for a graph problem we say, well, we're going to examine this graph problem assuming we're using an inefficient encoding of our graph to see how hard it is?

PROFESSOR: I guess you could try to define this in terms for graphs, but I don't think there is such an obvious inefficient notion of graphs. I mean, the obvious inefficient notion is like use a matrix instead of an adjacency list. But that's polynomially equivalent. So I mean there certainly are other notions you could imagine, but there aren't any in the literature.

All right. So just to warn you, the first reduction we do is going to be a little bit trivial. So don't get too excited yet. But this is where 3-partition comes from. Then we'll do lots of cool ones.

So multiprocessor scheduling. Let's say I have n jobs, and they have completion times. And that's it. You can start them whenever you want. And then on the other hand, I have p processors to run those jobs. Each processor is sequential and identical. So the model is you assign jobs to processors. Job can only be on one processor, and it runs to completion. Then it can run another job, and so on.

My goal-- I'll state the decision version-- is to finish all jobs in time less than or equal to t. OK? So I claim this problem is NP-hard of some variety. Let's start with a reduction from partition. Sorry. Partition is a synonym for 2-partition. Usually we omit the two. So reduction from partition. This problem over here.

So now I'm given some integers. I want to split them in half basically. Any suggestions on what I could do to turn that into a multiprocessor scheduling problem?

AUDIENCE: Two processors.

PROFESSOR: Two processors. Yeah. p equals 2. That is the reduction. I guess, technically, I also have to specify what t is, but it's over there. So you set t to be the sum of the A's over 2. And you don't change A. You just leave it alone. So you just feed in the same A i's into this problem. And that is 2-partition.

OK. Let's do a reduction from-- so now we know the problem is at least weakly NP-hard, but in fact, it is strongly NP-hard, because we can reduce from 3-partition. What do you do?

AUDIENCE: P equals n over 3.

PROFESSOR: P equals n over 3. That's it. You set t accordingly. Sum of the A's over p. Done. OK. So this problem comes from the paper that introduces 3-partition, which is by Gary and Johnson, the same people who wrote the book. So, I mean, this basically is 3-partition. That's why they cared about it. But here's a practical motivation for it.

Cool. Let's do something more interesting. And I kind of want a projector. Any questions about-- I think you've asked enough questions about pseudopoly, weakly poly, strongly poly, as I erase them. Don't forget them.

But I think for the rest of today we're just going to be doing strong polynomial reductions from 3-partition. I think next class we might do some weak ones, but today we're going to really use the fact that it-- use the strongness. And you'll see why, because we really want to encode some numbers in unary.

OK. Let's start with a problem-- rectangle packing. And this is going to lead us to a whole bunch of other types of packing problems. So this is what you might call packing rectangles into a rectangle. So I'm given n rectangles, and I'm given a target rectangle. So when I say I'm given a rectangle, what I really mean is I'm given the dimensions-- the width and the height-- as integers. We are usually going to assume all our numbers are integers, as I said. Do they fit?

So what I'd like, in a solution, is to rotate and translate the given rectangles so that they're disjointed from each other, they can't overlap, and they all fit inside the target rectangle. All right. So this might be the target rectangle. And then, I don't know, maybe this is my set of rectangles appropriately packed. So here maybe the answer is yes. If they don't fit inside the target rectangle, the answer is no.

This problem is strongly NP-hard, but I'm pretty sure we don't know whether it's E and NP. So there are lots of open problems. I don't mean to indicate everything is known. I should double check that this is definitely not known, but I'm pretty sure it's open. Because of this rotation issue there are kind of a lot of things to worry about. So it's not clear how efficiently you can encode a solution. Maybe you need a ton of bits of precision to say how things are rotated. Here they're all rotated at the same angle. They may not be. Who knows.

So we will consider a special case, which is exact packing. This also makes for a stronger hardness result. So exact packing means there are no gaps. None of this stuff. That's forbidden. So if you have no gaps and you look at a corner of the rectangle, that must mean there is a rectangle right there filling the corner, which means there's no rotation. Well, you could rotate by multiples of 90. But just know there are four rotations. Well, I guess two for rectangles-- integer times 90 degrees.

So then the problem is an NP, because also then you can show at that point-- because you have integer rectangles packing into an integer rectangle-- by induction, the translations are integers. Therefore, there are succinct encodings of them.

OK. We don't have to do this, but just to point out, this is one way to make the problem in E and NP. Now they are assisting solutions.

So we're going to prove both of these problems are strongly NP-hard. I think I'll skip the weak NP-hardness proof because it's not really any harder-- no pun unintended. So let's go there.

So the basic idea again, we're reducing from 3-partition. So that means we're given, on any instance of 3-partition, n integers. We want to represent those integers as rectangles. So kind of the obvious way to do that is we take each a i and we convert it into a rectangle. Let's say it's a i by 1. That seems pretty obvious. This is what you might call the a i gadget, since we're going to map this feature of our given instance to this feature of our constructed instance.

All that would be left at this point is what is the target rectangle, which I didn't give a name. So let me call the target rectangle B. I think that's what I used in my notes. Yep. So let's say B is going to be a rectangle. What is the height of the rectangle?

AUDIENCE: n over 3.

PROFESSOR: n over 3. Yes. Right. And then the width?

AUDIENCE: The sum divided by n over 3.

PROFESSOR: The target sum, t. Cool. So the intent is that the rectangles will look something like this. And always, however, if I fit three in here-- or maybe I could do more than three, but we know that won't happen with the actual 3-partition instances we get, because we can assume there are always three of them-- but anyway, we're not constraining there are only three. You put in however many rectangles. Add up to exactly the target sum. Boom. You've got the target sum. And there's just enough space for all of them if you pack them this way.

Question?

AUDIENCE: Shouldn't we specify that the a i rectangle is a i times n over 3 plus 1 to make sure that we can't accidentally rotate them?

PROFESSOR: Yeah. So part of my confusion in drawing this-- and I worry-- is you could take one of these rectangles and rotate it. And then this reduction is wrong. So this reduction is wrong. So I will cheat and make this epsilon, and then multiply this by epsilon. This is one way to fix it. Of course, now I have to scale everything up by 1 over epsilon. And I have to tell you what epsilon is. You were suggesting some multiple of n, which is a good suggestion.

I think as long as we make this much smaller than 1, then it's not possible to rotate, because these guys are length at least 1, because they're integers. So if I tried to rotate, it has to be a multiple 90 degrees. So I think as long as this is strictly less than 1, we are OK. I didn't change the intended solution. I just made everything narrower. And so I just need to set epsilon less than 3 over n. It would be that inequality.

But I want integers, so I should scale everything up by n over 3. So just multiply all the numbers by n over 3, and you're done.

In fact, you can be a little simpler. And I drew this diagram long ago, so I might as well show it to you. You can just add n over 3 to all your integers. That will also work, under the assumption that you can only take three numbers and add them up. Then you will always be adding 3 times n over 3 horizontally. So they a i's here are the yellow part of these rectangles, and then we're just adding this fixed n over 3 to all of them. So this is a 4, a 4, a 4, a 4, a 5, 5, 5, 6, 7. And that happens to be a positive instance of 3-partition. There is a solution. This is one way to do it.

So we're just adding n overall here, because we have 3 times n over 3. And the length of these is always smaller. Rotation should not be possible, because each of these guys is going to be length strictly larger than n over 3 because we add an integer to n over 3-- a positive integer-- and the height here is n over 3. So that just barely works. Same thing, more or less, just this is scaling by a multiplicative factor here. We're doing an additive thing, because we have this luxury of knowing there are three items in every triple. Cool. Rectangle packet.

Question.

AUDIENCE: This is a question about 3-partition. Is it assuming that they are positive integers?

PROFESSOR: Yes. All the integers are positive. You don't have to, but we can. So we will. Makes our life a lot easier. Other questions? OK. Time for some puzzles. So I think I'll show you some real life puzzles first. There's this notion of an edge-matching puzzle, which goes back to the 1890s. I believe this one is from the late 1890s, early 1900s. So it's one of the older ones. At least when I was growing up, we had these puzzle all over the place.

So what's going on here is you have physical triangles, and these half frogs are drawn on the edges of the triangles. And your goal is to pack all of these triangles into the big triangle. That's easy. It's a regular triangulation. But you need to half frogs to match up. I don't know. The hind end of the white-- I'm sorry-- yellow-speckled frog matches the front end of the yellow-black-speckled frog, as drawn here. This is a valid solution, but if I rotated this tile 120 degrees, it's not a valid solution even though it's all hinds matching to fronts and so on. OK? Rules clear?

So these are edge-matching puzzles. This is formulated in a different way. This is not a valid solution. The goal is to get these colors to all match up. So in general, you can think of there being a color on an edge. And here it happens to be composed of these two colors. And it would have to match both of the colors on the other side. So it's essentially like having a color on each edge.

Here, we also have a color on each edge, but we also have a sign, which is the front or the hind part of the frog. There's the yellow frog, the red frog, the green frog, the orange frog. So in general, we're going to formulate this. I'll get over here.

OK. There are many types of these puzzles I'll try to capture. It's not exactly either one of those. If you've ever studied something called Wang tiles, this is exactly that model. So I'll just throw in the word there. But what we have are n unit squares. Those are called the tiles. Each one has four colors-- a, b, c, d. So one per edge.

And you are also given a target rectangle. It's going to be integer, because these are unit squares. And you want to pack-- probably exactly pack so there are not going be any gaps-- the squares into the rectangle with colors matching. So whenever I have two squares that share an edge, the color that's written here better be the same color that's written there. Those are the rules. If you're on the boundary, no restriction. But if you're an interior edge, you restrict in that way. OK?

This actually closely matches what is currently maybe the most famous edge-matching puzzle called Eternity II. This one is still unsolved. Well, the creator has a solution. And if you ever find it, or one of the many other solutions-- who knows-- you win $2 million US. So time to get rich.

AUDIENCE: [INAUDIBLE].

PROFESSOR: Well, yeah. I guess that's the way to make the most money is first solve p equals NP. And then solve Eternity II, I guess. But you could easily solve this puzzle without p equals NP.

There are actually a lot of almost solutions out there. I believe this is one of the leaders. This guy, Louis Verhaad, got-- so this is a complete solution with all the pieces, but not all the edges match. So it's hard to find them, but here's one, for example, that mismatches. So I didn't explain, but everything is a square tile here, and there's a different shape and color. But it's basically a color from a mathematical perspective. Have to match them all up. Here he got 467 matches out of the 480 edges. And that won him already $10,000. And I believe it's found with a computer-aided search.

AUDIENCE: Is that--

AUDIENCE: [INTERPOSING VOICES].

AUDIENCE: That's not the person who--

PROFESSOR: I don't know for sure. I would guess that it's Louis's daughter. Here's a different almost solution where there are some missing tiles but everything matches. And then at the bottom of his web page, you should check it out. It's funny. It says, "And here is a solution to Eternity II." I looked at this for a long time, and I was like I don't see any edge matches, but you guys are smart, so you probably know there's one other cheat you could possibly do in this puzzle.

AUDIENCE: Add Different tiles?

PROFESSOR: Add different tiles? Maybe. Although these are nicely-printed tiles. So I would guess he bought two sets and just mixed some parts. I wrote a program to check yes, indeed, some tiles are repeated here. I forget exactly how many. 10 or 20 or something. It's still pretty cool. It looks like it's done.

AUDIENCE: [INAUDIBLE].

PROFESSOR: But there's no complete actual solution using each piece exactly once. It's probably clear here, but you only get one version of each square.

OK. So there's your motivation for solving edge-matching. So you might wonder, oh, can I solve it in polynomial time? And the answer is no unless p equals NP. And here we're going to use essentially rectangle packing and this reduction. So how could I-- again, we're going to reduce from 3-partition. How could I convert a number a i into something like a rectangle using edge-matching? I should probably copy over the one that we had in the end, which was a i goes to n over 3 plus a i by 1, because we want integers.

Yeah.

AUDIENCE: So you make it so that there is sort of one color, and that's for [INAUDIBLE] most things. And that's [INAUDIBLE] kind of on the outside of each rectangle. And then put together each rectangle. If you need like-- if the rectangle is like a i by 1, you're going to need a i squares, such that there's like one color for that rectangle that is only used to join the other squares of that rectangle.

PROFESSOR: Good. So we're going to convert this something by one rectangle into something different squares. And we're just going to sub-divide like that. And we're going to surround all these edges with the same color. That will work.

AUDIENCE: And the interior edges [INAUDIBLE].

PROFESSOR: The interior edges-- all right. So we're going to take a i, and we're going to convert it into-- OK. Don't make me draw all of them-- the width here, let's say, will be n over 3 plus a i. And we're going to use a special color-- I'll call it black-- on the outside. And this color I'm going to call-- I need some red so it's slightly visible-- I'm going to call i. This is going to be a different color for each a i.

This will require a little bit more work. You could also use a different-- you could use i1, i2, i3-- but I would really force this to go together in this way. If I'm trying to be conservative on colors-- only use n of them-- then I will put those all i. And then as long as none of these matched to the boundary, I'm OK. I guess even if I used the i1, i2, i3, it's possible some of those match the boundary. And then weird stuff could happen. But as long as all these i colors match up with each other, you have to build this rectangle. And then we don't care about how the rectangles are assembled with respect to each other. So we're basically simulating this reduction rectangle packing.

OK. The one I have drawn here is slightly different. I don't remember why we did it this way. This is [INAUDIBLE] work with Marty Dumaine, the cameramen. And here, just I guess to be as simple as possible, we made the width of each of the rectangles just a i. That has a problem that you could rotate. But to prevent rotation, we use a different color horizontal and vertical. So the top edges and the bottom edges all have the colored percent sign. I think this is a limitation of the drawing program I was using at the time actually. And dollar signs on the left and right side.

And then we're going to build frame. This is what you might call infrastructure for the proof. This is one gadget happens. You just execute it once. This we execute for each of the a i's. We're just going to have one copy of this big frame. The goal the frame is to hide the boundary so that none of these tiles could match with the boundary, because when they match the boundary then you're breaking a rectangle in half and bad things could happen.

So instead, what we're going to do is all of these capital letters on the outside-- and I ran out of letters and used a couple of symbols-- appear exactly once in the reduction. So they can't match anyone, which means they have to be on the boundary. So those guys have to be on the boundary. And then all these other colors appear exactly twice, so you have to join these tiles together in exactly this way. And now the boundary is gone. And we have set up dollar signs on the left side and the right side, and percent signs on the top and the bottom sides. In reality, these would be whatever t wide and n over 3 tall. This is just some different notation. And that's it. Now you're simulating rectangle packing.

Question?

AUDIENCE: Why do you need two rows at the bottom?

PROFESSOR: So this two rows is to indicate, for whatever reason, because in edge-matching puzzles, usually the target shape is not a rectangle, but a square. And we wanted the stronger result at packing unit squares into a square with edge-matching results E as NP-hard. So the point here is you just add however many rows or columns you need to make it a square. Yep. Good question.

Jason?

AUDIENCE: So your different symbols, I believe, are also to let you build this into the rectangle later on. Otherwise, you'll run into issues with rotating things.

PROFESSOR: We'll get there. Yeah. So I have different symbols here and here in order to prevent rotation. That's right. Instead of making them longer. I could've, instead, made these longer like we had with the rectangle thing, but I guess, at the time, I wasn't thinking of teaching a class about this. So I didn't reuse my previous reduction for this one. But oh, well. Yeah.

But the reason there are dollar signs in there like red or some actual color is because probably black and white printing was more common then. OK. Cool. That was one puzzle.

And now key point. What if we did this reduction from partition? So with partition, instead of having n over three groups here, we just have two groups? And same thing. Why not do that?

AUDIENCE: So that would be a weakly NP-hard.

PROFESSOR: That would be a weak NP-hard reduction. Now, this problem here-- edge-matching puzzle, n unit squares of four colors-- are there any numbers in this problem?

AUDIENCE: 4

PROFESSOR: Other than 4 and n? Are there any numbers that are inputs?

AUDIENCE: I guess the colors have to be represented as numbers.

PROFESSOR: The colors do you have to be represented as numbers, but this is sort of a sideline. Usually, when we're talking about colors, all we care about is whether the colors are equal or not. So you don't normally think of those as numbers. You can think of them as vertices in a graph or something. I mean, they're more like combinatorial objects. You're never adding two colors together.

Yes?

AUDIENCE: The other point is that the number of different colors that you can get is at most 4 times n because [INAUDIBLE].

PROFESSOR: The number of colors is in most 4 times n. Yeah, you could write down a color as 2 to 2 to the n, but why? It's supposed to be an efficient encoding. So there are really no numbers here. So it doesn't even make sense to say this problem is strongly NP-hard.

But even worse, if I started with 2-partition, and I did this reduction exactly as drawn but not as tall, I could still make it a square, but everything would break. Because for 2-partition to be hard, those numbers-- the a i's-- have to be exponential in value. If I have an exponential value a i, when I convert it into a rectangle, or actually I convert it into a bunch of tiles, I will have exponentially many tiles. This construction will be of exponential size. So I will get exponentially many different colors on the boundary. So that's very bad.

Even if you're clever and you say, oh, well, these tiles are all the same, so maybe I'll encode them efficiently and say there's an exponentially many of this one tile. The ones in the boundary are all different. So it's not a valid reduction. You should always take a problem that's supposed to run in polynomial time and produce a result of polynomial size.

So if I start with something where the input is polynomial size but it has exponentially large a i's, I'd get an exponential size puzzle, which is boring to solve. I don't know. It's not a valid NP-hardness reduction. This is why we want to start from 3-partition. Because then I know even if what I'm doing here is representing the a i's in unary. I take the a i and said, OK, I'm going to have that many square tiles. But that is exactly unary representation. And we know with 3-partition that will have polynomial size. And so we're good. This is why we care about strong NP-hardness so much, because a lot of puzzles you can only represent numbers in unary. Then you're forced to work with 3-partition.

OK. Next puzzle is signed edge-matching puzzles like the lizards. Suppose same set up, but now the colors aren't supposed to be equal. They're supposed to be opposites. So I'm just going to modify this diagram, and I will use capital letters to denote tails of lizards, and lowercase letters to represent heads of lizards. And little b only matches capital B. It does not match little b. You can't put two heads together or two tails together.

Well, you can reduce these things, which are called unsigned edge-matching puzzles, to these things, which are called signed edge-matching puzzles, with this easy gadget. If you have a tile with, let's just say, colors ABCD-- some of them might be equal-- I'm going to replace that one tile with these four tiles and scale everything up by a factor of 2-- scale the target shape by a factor of 2. These colors appear exactly once with each sign, and so again, because there's a frame and all the boundary is eaten up, you're forced to match these guys to each other. And therefore you're forced to make this 2 by 2 tile.

And so that 2 by 2 tile is supposed to represent this 1 by 1 tile. And the claim is signs no longer matter, because we put little a, big A, little b, big B, little c big C, and so on. So if I took another tile like over here, and it has something like capital D, lowercase d, that's going to match with this lowercase b lowercase b, if and only if b equals d.

So if the original colors are equal, the resulting colors will be equal and opposite. So it'll be the same letter of the alphabet, but with opposite signs, and so everything will match up, because this capital letter match here, and this lowercase letter will match there. Is that clear? So it really becomes the same puzzle, and this one's going to be solvable only if this one is. So we get strong-- well, just NP-hardness of signed edge-matching puzzles. Cool.

Next puzzle. These were all on the same paper. It was a fun paper. This is even older. Jigsaw puzzles. This is not the oldest jigsaw puzzles. It's one of the newest. It's our course poster turned into a jigsaw puzzle. If you want to make your own jigsaw puzzles, go there. They go back to the 1760s when they were made with jigsaws, hence the name. But basically, we have square pieces, and each side of the-- I'll assume that's a special kind of jigsaw puzzle, most common-- each edge can either be straight. That means it's on the boundary. It can be a pocked or a tab. And each pocket and tab is slightly differently shaped, although maybe not on this picture, usually they are.

I'm going to allow that some of the pockets and the tabs have the same shape. That's what you might call ambiguous mates. Most jigsaw puzzles sold in the world do not have ambiguous mates, but let's say they do. And to make it NP-hardcore, there is no image on the pieces. It's just a white puzzle. Now those are sold. You can buy all white or are all single color puzzles. But usually they don't have ambiguous mates. That's like the ultimate combo. If you don't assume either of those things, then the problem is easy. So we don't care about that. But our paper is about how to solve jigsaw puzzles in the practical case.

But in our situation, I mean, that basically is edge-matching puzzles with science. This is actually probably why I care about signed puzzles the most. I have lowercase letters. Those are going to correspond to pockets. I have uppercase letters. Those are going to correspond to tabs. And of course, a tab must meet a pocket, same as a lowercase letter must be an uppercase letter. And so that is the same thing.

I would like my target shape to be a square because that's clean. So whenever I have a unique color, which is one that I know has to be on the boundary, I'm going to make it a flat thing. And then I know in this series of reductions, I should draw this series of reductions, because it's kind of fun.

So far I kind of started with rectangle packing. I guess technically we started with 3-partition. I'll draw it like this. We reduce that to edge-matching puzzles. Then we reduce that to signed edge-matching puzzles. Then we reduced that to jigsaw puzzles. And if you follow this series of reductions and see what you get, we know that the boundary shape will be a square because that frame gadget is a square. And if we make all the unique things flat, then the shape will actually be square.

There's a reason I'm drawing it this way, because we have another one. So the next puzzle-- you might ask well, if Eternity II was an edge-matching puzzle, what was Eternity I? Well, it's something called a polyform packing puzzle. These are-- if you take an equilateral triangle and cut in half like that, that's a shape. If you take k copies of that shape, join them edge to edge along matching edge lengths, you can get all these shapes. It's like Tetris, but instead of the squares you start with that shape and you join a bunch more of them together. I don't know exactly how many. They may not even be all the same area.

And your goal is to fit inside this big dodecagon or something. This was solved. One million pounds were acquired by two people. I think they were mathematicians, Alex and Oliver, in 2000. So actually quite soon after the puzzle was posed, I think within less than a year. So there were articles about how the insurance company was not happy. That's why you get insured against a puzzle being solved, I guess. But in Eternity II, as a consequence, it is much harder. So no one had solved it yet, but it will happen someday I'm sure. So this gives you a clear sense of what the shapes look like.

So I want to prove these puzzles are NP-hard also by reduction from jigsaw puzzles. So let's just bring up the picture. So we just did this reduction. It actually works in both ways. They're really the same puzzle. This does not work so easily in both ways. But I'm going to take a jigsaw piece. I'm going to turn it into roughly a square made up of little squares. I'm not going to work on the half triangles, although I think it wouldn't be any harder. It's a lot easier to think about square puzzles more like Tetris. These are polyominos.

So polyomino packing is this type of puzzle. They also exist, but no one has won one million pounds from them. So that's why I showed Eternity. So almost a square, but then in the middle of the edge we're going to write in binary what this shape was here. I mean, if there was a color over here and a shape here, all we care about is whether they're the same or different. So there's only 4n different colors out there. So we're going to take log of 4n bits and write them in this way.

And if it was indented, whenever we have a 1, we're going to indent here. And if it's a tab instead of a pocket, wherever we have a 1, we're going to outdent. OK. So these are all different codes. And so none of them fit together, for example. And let's see. Does anything match up?

AUDIENCE: Yes.

PROFESSOR: This one matches with this one, because if I rotate it around, stick it on, it will match up. So you have to make sure you get the orientations to the codes all right, but you can do this. And two things will fit together and make a nice clean seem, if and only if the original colors matched. And so this represents that puzzle where we've blown everything up by like a logarithmic factor in each dimension. But the number of pieces is staying the same, in a sense.

So that was this reduction to polyomino packing. For fun, we close the loop, and reduce from polyomino packing to edge-matching in this way. So we're going to take our polyomino, carve it up into little squares, turn them into edge-matching puzzle. And here I actually want to allow rotation, so I'm going to change these colors to all percent signs. And now it's just the same puzzle again. So we have to use the frame again.

And so if you want, you could just keep following these reductions over and over and over. I think every time you do it, you increase the scale factor by like a log factor. But it's kind of fun. I mean, it really shows these puzzles are very close to identical in that we didn't have to blow up the puzzle size by very much to go from one puzzle to the next. So usually we're just thinking about polynomial blow up here. We have a very small notion of blowup, which is some tight sense in which these puzzles are almost the same.

OK. End of paper.

A fun open problem is this reduction used log n by log n-- order log n by log n pieces. What if your pieces only have area log n? So maybe they're root log n by root log n or something that. I'm sure it should still be in NP-hard, but you never know. For example, they're constant size. Actually, well, let's say, if they're size 2, its easy. Leave it at that even if the shape is very messy. But if there are also 2 by 2 blocks it's easy. So clearly small shapes are too easy. But probably logarithmic area is where it starts to get interesting. I don't know. What about log, log area? That's probably neither NP-hard nor polynomial, but oh, well. Cool.

So I want to talk about one more problem-- one more hardness proof in this similar vein. It's about packing. I already erased packing rectangles into rectangles or rectangles into a square. What about squares into a square? I don't know if you can tell if that's a square and not a rectangle.

OK. This is a nice paper. We've used it for other hardness proofs, which we'll probably talk about next class. So I'm given a bunch of squares, and I'm given a target square. Do these squares fit in there? And again, we will probably use exact-- well, initially we won't be exact packing. But let's say that the squares can only rotate by a multiple of 90. In other words, they can't rotate. We will fix that by making exact packing.

Why don't I jump to the reduction? The heart of the reduction is this idea-- we're just going to add a big number here. I am going to use capital B for the big number. That's what's in the paper. This is a paper from 1990. Motivation here is you have a big grid supercomputer, which were popular in the '80s and '90s. And you have a job, which was a square grid of processors, let's say. And you want to execute them all in parallel, but they're not allowed to overlap, because that would slow your supercomputing down. But you are allowed gaps, let's say.

So I'm just going to take each of my a i numbers, add this huge number to it. So they're all roughly the same size. This is the trick we did at the beginning of class with the 3-partition. All right. All these numbers-- all these sizes are almost the same. I've drawn them quite different, but imagine they're just like tiny fluctuations.

And then I make the height of this rectangle. For whatever reason I transposed my image. That's probably why I was confused earlier. And I just make the height three times the big number-- because I want three pieces to come together-- plus t, my target sum of the a i's. So this is a huge thing plus a super tiny thing. But what it's saying is well, you could have slop. They're almost the same size, but there's that little bit of extra. And that little bit of extra has to add up to exactly t. So this is one triple with the desired target sum. And then I want to get n over three of them.

Now here's where things get a little dicey. You say, OK, let's just say I take the largest one, or actually I'll go all the way up to B plus t. I know that every number I have is smaller than t, because I just saw the sum of three of them is t. So I'm always going to have a gap here. And let's say I just packed the next three there and then the next three there. And so I'll leave enough room that even with the slop I could fit everything in.

So each one is B plus t, and the number of them is n over 3. So that'll be the width of my rectangle. Looks like a lot of slop, but that's because I drew this with the squares very different in size. If we compute the amount of slop, the maximum, if you look at this distance, it's at most t, certainly. Even if a i were 0, which is not allowed, then this distance would be t. So it's going to be even smaller than that. But the gaps here are always at most t.

So we can take-- so this is total slop is t times the height. So that was like the width of one sliver of slop, and then the height is 3B plus t. And then times n over 3, because there's n over 3 of those things. And hopefully this works. I want to say this is less than B squared if B is bigger than t times n. 3s cancel. So if B is, I think this term won't matter, because B is going to be bigger than t. So maybe put a 2 there for extra safety. Then you're totally dwarfed. So just dividing both sides by B we're getting 3 times t times n over part 3. That's 2 times n. OK.

Cool. So the point is the total area of slop that I have here is less than a single square, because a single square is even bigger than this. So you're not going to be able to pack anymore squares, and that's a vague argument, but enough hand-waving later, and you've proved that, in fact, any packing of these squares will give you 3-partition. That requires more work, but this is some intuition why it is true.

OK. So this was actually packing squares into a rectangle. But that wasn't the problem I started with. I wanted to pack squares into a square. So for that you need an infrastructure gadget like the frame that we made before. And this is kind of acute number theory-ish trick. I'm going to take some integer x. We'll choose it later. It's just going to be big enough-- something like n. And we have one giant square, which is x times x plus 1 minus 1. But they're all squares, so by the same amount.

And then we're going to take these medium-sized squares of size x plus 1 and the small squares-- so much smaller-- of size x. And because this is just one smaller than what it's supposed to be-- I mean, if it was x times x plus 1 it would sort of come to here. So when you pack these guys up you go just one too far there. But there's exactly enough room for one more. If I put x plus one extra, this is x. That's the one, and so on. So this leaves, as a gap, a rectangle.

Now this is not the only solution these guys could slide down, but you can show that will only make your life harder. And the paper does that. That's sort of the easy part of the proof. And so now you're left with a rectangle, which is 1 by this thing. You multiply everything by the 3B plus t, because that was what we wanted one of our dimensions to be-- the smaller one. So that scaled up the rectangle.

And then the horizontal-- the width may not match exactly. But if there's too much space here, and let me just set x to be large enough, then there will be extra space. And just throw in a bunch of B by B blocks there to fill up the extra space. So you can figure out how much extra space there is and fill it in. So they you go-- packing squares into a square.

And this is strong NP-hardness of this. Even when the squares are only of polynomial area, this problem is hard, which is actually the case you care about when each of these 1 by 1 squares is a processor. Now this is not exact packing, and so you might wonder oh, what if I rotate the squares, and then crazy things could happen. Probably not, but you could also just compute how much extra slop there is, because you know the area of the input squares, and you know the area of the target square. And just add a whole bunch of 1 by 1 little chips, and that will fill in exactly the space. Then you have exact packing. Then you don't even have to worry about rotation. So that makes proof even cleaner. I think that wasn't in the original paper, but it's a nice little addition. And that is our packing through 3-partition.

Next class we'll do more 3-partition for different types of problems. So in case you lose lots of pieces in your jigsaw puzzle, we have the one-piece jigsaw puzzle. This is all the pieces are in one giant connected mess. And still it is not so trivial to solve. Wow.

AUDIENCE: [INTERPOSING VOICES]

PROFESSOR: All right. This is the one-piece jigsaw puzzle in solve state. It's the Simpson's addition. It's-- you get it.

AUDIENCE: [INTERPOSING VOICES]

AUDIENCE: And then you put that in. And then you put it in your slop.

AUDIENCE: Yep. [INAUDIBLE].

PROFESSOR: Ta-da.