# Class 15: General & Edge Unfolding

Flash and JavaScript are required for this feature.

Description: This class begins with defining handles and holes, and the Gauss-Bonnet Theorem applied to convex polyhedra. Algorithms for zipper unfolding, edge ununfoldable polyhedra, square-packing, band unfolding, and blooming of convex polyhedra are presented.

Speaker: Erik Demaine

PROFESSOR: We have a lot of fun material to cover today, so let's get started. We start with a few basic questions about-- well, first is a topology question. What is a handle? In general, a handle is really a transformation on a surface. I thought I will demonstrate in the context of glass blowing.

So this is what it looks like if you're making a cup. You take some hot glass. You attach it to your surface. You cut it off your hot pipe. And then you bring it around and attach it to another point, and so that's a handle.

You've probably used handles before in real life. In general, or in the mathematical setting, it's the same thing but on a 2D surface. So imagine you have some 2D surface. You take two disk-like regions on the surface and then you attach on a handle-- something like that.

So it's an operation you can do to a surface. And you can keep adding handles. I don't think there's a clear way to say, oh, this is clearly a handle, except to have added it as a handle.

In general, the nice theorem for two dimensional surfaces-- so here's a coffee cup being converted into a torus, because it has genus 1, meaning it has essentially one handle in it. In general, you take any orientable surface without boundary-- this is locally two dimensional-- then it will be a sphere plus some non-negative number of handles. And that's a classification theorem for orientable surfaces.

It's only slightly more complicated for non-orientable surfaces. And then 3D surfaces are even harder and was only recently solved. But this is two dimensional surfaces, which is easy and clean.

There is a way to compute genus and in some sense learn how many handles are there. But there isn't a unique thing of, oh, this part is clearly a handle. But when you draw it this way, it kind of becomes clear this is a handle. This is a handle. But there isn't a formal sense in which-- I don't know-- this thing is not a handle or some weird thing.

I think that's all about handles. Hopefully that answers things. Of course, things get more complicated when you have a boundary, which we usually call holes. But the next question is about holes in the unfoldings.

So I claim that convex polyhedron, when you unfold them, never have holes in the unfolded form. And this is to contrast this example, which is not convex. But you can unfold it by cutting these two edges. And you've got a little hole.

So I showed this in lecture. And natural question is, why isn't this possible for convex polyhedron? So I thought I would prove that.

And the proof uses a cool theorem, which we'll probably be seeing again, called the Gauss-Bonnet theorem. And it says that if you have some surface, which is homeomorphic to a sphere-- so I don't want any handles for this theorem. And of course, convex polyhedra our sphere-like. They don't have handles.

And I take a-- let me take a better color-- I take a closed curve non-self-intersecting closed curve on that surface-- that defines an interior and an exterior. Then what the Gauss-Bonnet theorem says is that if you look at the curvature that's enclosed by the curve-- the total curvature by this closed curve on the surface-- and you add on the total turn angle along the curve-- so here, the curve is turning right. Here, it's turning left, right, left. Left is positive. Right is negative.

Then these always add up to 360 degrees. We're not going to prove this theorem, but we're going to use it. So this is a nice invariant for sphere-like things.

When you have handles, this number changes. I think it's 0 for a torus. Well, I won't try to guess it, because it's a little bit subtle to get right.

One fun consequence of this-- let's just get warmed up-- suppose you take a sphere like object and you take a closed curve-- this is going to be pretty abstract-- in this direction, then it says, OK, the total amount of curvature in here plus the total turn angle equals 360. Now suppose that I turn the curve around. So I just reverse the direction-- like this.

And so now, the interior is this stuff out here. And then we get that the total curvature outside the curve, plus the total turn angle of the blue thing, equals 360. If I add those two equations together, the total turn angle cancels. Because wherever red turns, left blue turns right. And so this term disappears.

And so what we get is that the total curvature inside the curve, plus the total curvature outside the curve, equals 720. So this is a nice topological invariant of sphere-like polyhedra. You add up the total curvature everywhere-- it didn't really matter what the curve was-- you always get 720.

And so this is kind of neat. For convex polyhedra, this means you have to somehow divvy up this curvature. Because all curvatures are positive. So 720 is, somehow, spread around. But you have to have exactly that much.

For non-convex things, you could have some negative curvature that balances out a lot of positive curvature. So you can have a lot of both. But you have almost the same amount of each. Just you have exactly 720 excess.

that's just a fun fact. We'll be using that in the future, I think. OK, that was Gauss-Bonnet.

Now let's use it to prove that this can't happen for convex polyhedron. So the idea is, suppose you have an unfolding with a hole in it. So this is the surface out here. Then I'm going to take a closed curve that walks around the hole but stays inside the unfolding. And then, of course, I'm visualizing that really on the polyhedron.

So I want the interior of the curve to enclose the hole-- or what becomes the hole. Now, what we learned from Gauss-Bonnet is that the curvature enclosed by this thing, plus the total turn angle of the curve, equals 360. The total turn angle of the curve is 360. It's a planar walk here. So turn angle-- total turn here is 360 degrees.

Now, if we have a convex polyhedron, then this curvature has to be non-negative. Well, I mean, sorry. In any case here, this curvature better equal 0.

For convex polyhedra, this is a sum of vertex curvatures. For convex polyhedra, every vertex has strictly positive curvature actually. I mean the zero curvature vertices aren't vertices. They're just points on the surface.

So for convex polyhedron, if you're going to have zero total curvature, that means you actually have no curvature. So you have no vertices enclosed in here, which is a contradiction. That means there wasn't a hole to open up.

Technically, you could do something weird like-- I don't know, let's take a cube. You could say, OK, I'm going to make a couple cuts here that do nothing. This is kind of a weird situation.

We're going to add those cuts. And then, of course, you could draw this curve around it and say, oh yeah, look. I've got lots of zero curvature vertices inside here.

In general, whenever you have zero curvature vertices, you could always just suture them back up-- uncut them-- and there'd be no difference in the unfolding. So you have to assume that you've already removed pointless cuts. Then there'll be no vertices in there. And so then, in fact, there was no hole for convex polyhedra.

For non-convex polyhedra, you can have a negative curvature vertex that balances out some positive curvature vertices. And so the total curvature here equals zero. But you have three vertices. And that just can't happen for convex.

Next quick question is, when we're talking about the cut locus and the ridge tree, we drew some pictures. The claim is that it was a spanning tree of the polyhedron. And in particular, the leaves of the tree-- the degree 1 vertices-- are exactly the vertices of the polyhedron.

And I hadn't actually realized this, but in fact, it's not really literally true. It's kind of spiritually true. The vertices, in fact, have unique shortest paths to x.

So remember, we have some point, x, on the surface. And we're looking at points, like this one, they have non-unique shortest paths to x. This is, if you grow the fire around x, where does the fire meet itself. And it will meet itself along this edge, because you could go around this way or go around this way and it's equal length path.

But at the vertex, there's actually a unique way to go there. That's the black line. So technically, this point is not on the ridge tree. But all of these points are. So this is kind of like a limiting point of the ridge tree points.

So we think of it as being on the ridge tree. I mean, you could think of as cut are not cut. It doesn't really matter.

But you cut right next to it, so effectively the same thing. But it is a neat point-- a subtle point-- that these guys have unique shortest paths. Whereas, these do not. Still we cut all the way up to corner. All right, that is that.

So now we have a bunch of newer and more exciting things-- or updates that you haven't heard of. One question that we mentioned was generalizing the star and source unfoldings. And there's a new paper about this. This is with my PhD advisor, Anna Lubiw, and this is just a warm up to get started.

So here, we have a box, if we take a point x. And let's see, here we have the source unfolding from x. And here, we have the star unfolding, just for comparison. It's also kind of fun to see them side by side.

They're color coded. So where you cut is the ridge tree, in this case. And you end up gluing along the ridge tree in the star unfolding.

Now, we're going to generalize things a little bit in that we're going to generalize the source unfolding, specifically. So source unfolding, you have a point x. And you just sort of shoot shortest paths all from x, and that's what you keep. And you end up cutting along the ridge tree, which is the void in our diagram at this point.

So I'm going to generalize that a little bit and think of this as a tiny little circle. And in general, what I'm going to do is the source unfolding outside the circle. And so when the circle is really tiny, it is just the source unfolding.

But in general, I'm going to do the star unfolding inside the circle. OK. So in this case, nothing changes. But next example is going to be more general.

Instead of being a single point here, I'm going to take a geodesic arc-- a straight line on the surface. So here's an example of that. We have a square-based pyramid. We drew a straight line on the surface. If you unfolded it, it would be straight.

We're thinking of having a little-- I think it's called a racetrack curve in mathematics-- around that straight line. And I'm going to do star unfolding on the inside. In this case, there's no vertices on the inside, so nothing happens. And then we do source unfolding on the outside.

This is actually previously known to unfold by O'Rourke and others. But we have a simpler proof, essentially. And we're going to generalize it more.

But what we do is the source unfolding on the outside. So you take shortest paths-- from every point, you take its shortest path to this geodesic. That's, some of these blue lines show various shortest paths. That's what you keep.

The ridge tree is if you light fire simultaneously along this entire segment, where does it burn out? And that's the purple stuff. And this is the complementary diagram, where you do the reverse, which would be the star unfolding on the outside, source unfolding on the inside. So you glue along the purple stuff instead of cutting along the purple stuff. And this, we conjecture, doesn't overlap but we don't know.

All right, so fine. That looks easy. And you can prove that this doesn't overlap. Before you proved it, because you just had shortest paths emanating in all directions around x. Now, you have shortest paths emanating in 180 degrees of directions around this endpoint.

Then they are all just straight. And then they rotate around 180 degrees here. And then they're all just straight. And so there can't be anything overlapping, because you're just taking a continuum of these segments of varying lengths. They don't overlap.

Here, they're all parallel. Here, they sweep nicely. In general, if they always turn clockwise as you walk along the curve, you're fine.

OK, here's a more general one. In general, what we can prove is that if you have a convex curve on the surface-- so it always turns to the left, I think technically. The angle on the left hand side is always less than or equal to 180 degrees.

You have to be a little careful what it means to turn to the left. When you hit a vertex, you've got less than 360 total. So what does to the left mean? It just means you've got less than 180 degrees of material on your left side.

So this is an example of a convex curve. It's got some circular arcs. We're no longer tracking along some-- we're no longer just doubling along some curve.

Here, we enclose a vertex, which makes it a little more exciting, because now what we're going to do star unfolding on the inside, which remember was cutting along shortest paths from every vertex to your thing. In this case, your thing is no longer a point, x. It is now this convex curve.

So let's say this is the shortest path here. It might be than one choice, but we're going to-- actually, no. This is the shortest path. This is a root 2 diagonal. This is length 1.

So we're going to come along here and that's this dashed line. So it got opened up here, because we had too little material here. We open it up. But otherwise, it acts the same.

In particular, outside this red curve, it's just source unfolding. You've got all these shortest paths. And again, what we argue-- and I'm not going to prove it here-- is that all of these shortest paths keep turning clockwise and do so exactly 360 degrees.

There's some jumps when you hit these gaps. And you have to kind of jump over them. But still, you have no collision.

And drawn over here is the reverse, where we would star unfold the outside of a convex curve-- because it's a convex curve, the inside and outside are different-- and source unfold on the inside. And this, we conjecture, doesn't overlap. But we don't know how to prove it.

This thing is a generalization of the source unfolding. Because when this curve is super tiny, it is a source unfolding. This thing would be a generalization of the star unfolding, but we don't know whether works.

I think one more example here. This is a way to generate convex curves. You start from some point, x. And you design it-- you choose a direction so that if you go straight-- so this curve goes straight everywhere except x. If you set it up right, you come back to x.

So this, in particular, is a convex curve, because it's straight everywhere except x. And at x, it's convex.

And so, in this case, we enclose a few vertices. On the inside, we've got V3, V7, V6. So each of those ends up getting cut here in these green lines.

And so, like this one is a very tiny cut. We just cut there at V3. The other ones are little bigger. But they open up. And yeah, I guess, this is the-- well, it's a few different versions of the picture here.

But again, you look at the shortest paths. Here, they're all parallel. Here, they sweep. Here, they're all parallel. Here, we jump, but it's just the same as sweeping-- it doesn't hurt you.

Then they're all parallel. Then we jump. Then they're all parallel, in this particular example.

But they will always proceed clockwise around the curve, which here is drawn red. Gets split up a little bit, but you can show because of that sweeping, they won't hit each other. And you have non-overlapping unfolding.

So we call this sun unfolding, because of the rays that sweep around. And because we have a convex curve, it's kind of like the sun. So that's a new unfolding.

The obvious open question is the reverse, when you glue around the purple sides instead of the-- It's essentially, instead of having a convex curve, you have a reflex curve, exactly the opposite. What happens, we don't know.

It's a lot harder to prove. Because in particular, it's a lot harder to prove that the star unfolding doesn't overlap. And you've got to include at least that proof in any generalization of it.

Next topic of unfolding kind of related we call zipper unfolding. So these are some examples of real felt models with a zipper. The goal is, I want an unfolding that has a single zipper. And you just pull the zipper, and it makes your polyhedron.

So this is an example of an octahedron. This one is actually not even a polyhedron. It has two pyramidal pockets in it. And it's actually closed off in the middle.

I think we have a little video here of what it looks like to open that octahedron. So what does it take to have a single zipper line, that connects everything together? Well, if you think about it, that means that the cuts that you make must follow a single path.

So in general, the cuts form a tree on a convex polyhedron. We want that tree to be just a path. So it's like a Hamiltonian path.

It's got to visit all the vertices in some order. And you'd like it to unfold without overlap. So is this always possible?

This is a father, son, mother, son, son paper. So this is my advisor again and her two sons. Although we like to say this a paper with her three sons, because I'm her academic son-- or four, if you count Marty too. She was his advisor as well.

So here are some examples of good unfolding. So we have the platonic solids. These are just typical unfoldings. These are all zipper unfoldings.

So we're cutting along edges, along a Hamiltonian path that doesn't overlap. They all have this kind of nice snake like shape. And so all platonic solids can be made by zipper edge unfoldings.

Next, we did Archimedean solids. This is a lot more work. But again, you get these nice S-like curves. And they're all zipper unfolding, because they're all possible and they'll have these Hamiltonian paths, cuts, and avoid overlap.

But you may notice, there's one missing up there-- the great Rhombi-Cosi-Dodecahedron, my favorite Archimedean solid. And it has a rather different looking unfolding. As far as we can tell, there's no S-shaped one-- whatever that means. But you have to have a tree.

These examples all had path-like-- The dual graph was roughly a path. I guess it branches a little bit here. Here, it's very tree like, I guess.

So all Archimedean solids can be done. One open question, next category up, is Johnson solids, which are all polyhedron made with regular polygon faces-- convex polyhedron made by regular polygonal faces. Those we don't know, whether they always have zipper unfoldings.

But we do know there are some convex polyhedra-- like this rhombic dodecahedron-- that do not have zipper unfoldings if you only cut along edges. Because this graph has no Hamiltonian path. So never mind avoiding overlap. There's some polyhedra that just aren't Hamiltonian.

There's no path it visits every vertex exactly once and only follows edges. So there's nothing you could even hope to cut along and avoid overlap. So that's bad news for edge unfoldings.

The big open question here is for general unfoldings if you're allowed to cut anywhere on a convex surface and do things like the sun unfolding. I mean, edge unfoldings, we don't know how to do them anyway. So if you allow general unfoldings, we've got star unfolding, source unfolding, sun unfolding, all sorts of things.

But none of them are zipper unfoldings. They all cut along trees. Like star unfolding cuts along a star. The source unfolding cuts along the ridge tree, which is going to be very tree like thing.

Can you always convert a tree cut into a path cut? We've tried. It seems quite challenging. So that's the open problem. Does every convex polyhedron have a general zipper unfolding, because edge unfolding is always too much to hope for.

So those are some fun problems to think about. It's kind of like zipper unfolding.

So the next topic-- oh, right. One more thing to show, this is a very fun talk that we gave. All five of us gave this talk at Canadian Conference on Computational Geometry.

And one of the props in the talk was this cardboard box. And in the middle of the talk, it starts jiggling. And actually, initially, only four of the co-authors were giving the talk, because the fifth one was hiding inside the box. And then in the middle of the talk, he just jumps out and then starts speaking, as if nothing happened.

It was a lot of fun. At this point, our son, Jonah, is in the box. He was fairly small. He's grown up a lot since, but at the time he fit nicely into this cardboard box, which was maybe this big.

I think we give him a book and a flashlight and stuff to do while he was sitting there, waiting for his slides, waiting for the queue to come out. There we go. So those are unfolding of the cube or a box in general.

Next topic is going back to edge unfolding. I like this comment. I thought they were pretty obvious, but now you've convinced me otherwise. And some of the evidence for edge unfolding being difficult was this polyhedron, which we proved has no edge unfolding. I didn't say it in lecture, but we call it edge on unfoldable, because they cannot be unfolded.

This is actually the first example we came up with. I mention it only because it has fewer faces. We usually show this one because it's triangulated and that's kind of cooler. This one has convex faces still, so still topologically convex.

I mean, if I pushed these points in, the polyhedron would be convex but has fewer faces. It has I guess six faces per hat, times 4 hats, so 24 faces. This was done in '99.

It turns out at exactly the same time, there was this paper by Tarasov called, "Polyhedron with No Natural Unfolding." The paper has no figures, so I had to draw one to show you what it looks like.

It's just a cube. And then at each corner of the cube, you cut off the corner and then pull the point out. And they proved, by a pretty similar argument-- I mean, essentially you treat each of these as a hat. It's kind of a very simple hat. They happen to overlap; they share edges.

But again, because of these negative curvature vertices, you have to cut through the hat. And that cut has to keep going around. Eventually, it forms a cycle. So that's what Tarasov proved in the same year, '99.

And then Grunbaum-- he's a famous geometer in Seattle-- came up with some more examples. So he initially wanted to make a star shaped example. Star shaped means that there's a single point, namely the center, where you can shine a light in all directions and the light reaches the entire interior of the polyhedron.

He didn't know about our witch hat example. So he took the Tarasov example, made it a dodecahedron, and then it is star shaped. I think ours are already star shaped.

So that's kind of fun. It looks like some scary underwater creature. And then he learned about our paper, and he said, all right, I want to get as few faces as possible. And so we had 26, was it, 24?

This one has only 13 faces. And it has tetrahedral-- well, that's not actually tetrahedrally asymmetric, because this bottom spike is different from the others. But it's kind of like Tarasov's example down to its very minimal amounts, also star shaped.

And his conjecture is that, if you have 12 faces or fewer, there is no un-unfoldable polyhedron. So he says polyhedra with 12 faces are un-un-unfoldable. He wanted to one up us. Open problem is to define un-un-un-unfoldable. But we're up to three.

So that's some un-unfoldable polyhedra and some conjectured un-un-unfoldable polyhedra. This is fun to say.

The next result, which is very recent is that-- this is with Zach Abel and myself-- that it is NP-complete to decide, given a polyhedron, is it unfoldable or un-unfoldable-- by cutting along edges. These are all cutting along edges. And we reduce from this problem, which comes from parallel computers actually-- or geometry in general, you want to pack a bunch of squares into a square.

So you have squares of different sizes. And you want to pack those squares into a given square. Is it possible? Yes or no? Sometimes it is, sometimes it isn't.

This proof, by many people-- Long, et al.-- is from three partition, which is a problem we've seen. I won't go through it. But essentially, it's kind of like the disk packing proof, which I showed in lecture some time ago related to tree maker. But you set up this tiny space and you end up having to partition a bunch of your squares into groups, each with the same sum groups of size 3.

So starting from this problem of square packing, how do we convert it into an unfolding problem? This is a rough idea of the construction. So the big picture-- this is initially a polyhedron with boundary. Later on, we'll remove the boundary.

So just imagine a square, and in the square, there's a tower. Things are not drawn to scale here. The tower is super tall. This little pipe thing is very narrow and also very long. I think even way longer than anything in this picture.

OK, so now along the side of the tower-- so this is an unfolding. Like if you cut along these edges, you get a plus sign. This is the tower.

Now, this grid stuff is something that I haven't shown you yet. But basically, think of it as water. It's very malleable. It can be cut open in many different ways. And essentially, you don't have to worry about it being there. It's like the glue that holds everything together.

But then, there's these square faces, b1 up to bn. These are the things you need to pack. So our goal is to set things up that so, when you take this tower out, you have a square hole. That is your target square shape.

And then on the side of the tower, you've got all these squares. Basically those squares have to fit into that hole. So it is square packing. That is our goal.

Now, the challenge for that is to make all of this stuff get out of the way and also for these squares-- normally when you unfold, you're very constrained in how you lay out the faces. You can cut here or cut here, but there's a discrete set of choices. Our goal is to design this stuff so that these squares can just basically move willy-nilly without hitting each other. It's not easy to do, but that's the thing.

This is one big face on the outside-- this kind of L shape. We didn't want to go all the way around for a couple reasons. One is we need a place for things to get out. But also, we wanted this to be topologically convex. So we didn't want to face that is a donut.

OK, so what's the next part of the construction? Well, if we can arrange for these guys to move willy-nilly-- that's these very thin lines-- we can just imagine that if the squares are somehow packed, instead of having things overlapping like this, you can route all of those paths to avoid crossings. So as long as there's tiny gaps between all the squares, which doesn't turn out to change the square packing problem very much, you can do this.

And then there's another issue, which is there's a lot of stuff here. You've got to put it somewhere, so you end up-- it's very, very tiny-- so in some cases, you have to do this kind of wiggling just to eat up length in certain settings. It gets complicated.

So how do we do this wiggly stuff? Well, at the first level, there's a very fine grid with very small squares here. And we set it up so that we can follow everything along a single path. We can visit all of this great stuff along a single path. Occasionally, we will encounter squares, but the path length between any two squares is so big that these squares have room to kind of stretch out as far away from each other as they need to go.

Now, these squares are not squares. They are actually this construction, which we call atoms. It looks like a weird set of pyramids, or outside of towers. But in fact, there's many different ways to unfold this.

There's lots of different ways to cut it open. And some of them go straight. Some of them turn left. Some of them turn right. These are three of the unfoldings, I forget.

There's a few dozen unfoldings that we need that all have the right parameters. This one's clearly turning left. This one's going straight in a certain sense. This is coming from a left turn and then going straight. So there's lots of combinations here, slightly different parities, and so on.

But the end effect is that if you have a big grid of these and you're following them in a path, the path does some turns on the surface. But you can force it to do whatever turns you want in the unfolding. So you have complete freedom to move the squares around. As I showed you, you can avoid crossings, and it all works out.

Maybe one detail, which I didn't mention, is there's going to be a ton of extra stuff. Where does it go? It's going to fill the pipe up. It's going to push these guys up somewhat.

And this thing is so tall that there's room to put all the excess stuff in here. And it's also so tall that you can't just reach all the way out and put all the squares on the outside. OK, so if you make that super, super tall, none of the squares fit in here, because it's too narrow. And none of the squares can get up to the top, because it's too long. So that's how it works.

Now, that was a polyhedron with boundary. Without boundary, the construction is almost the same. You just add some extra stuff on the outside to make it a regular polyhedron homeomorphic to a sphere. But in the end, you have basically the same construction of this nice square. The pipe and some other stuff, you prove basically doesn't matter.

So that is NP-completeness of edge unfolding of topologically convex polyhedra, even orthogonal polyhedra, which is kind of nifty-- from last year.

If you actually want to unfold things-- if you want to build things out of paper, the current best heuristic unfolder is called Pepakura. It's a free download online, probably Windows only. You can take some weird 3D model. And it uses multiple pieces, in general, but you can add tabs and it's quite practical. And cut it out, either manually or with your computer controlled sign cutter or something and then fold up your pieces.

When a one piece unfolding is possible, it will typically find it. But it's not guaranteed. I don't know exactly what algorithm it uses. But some combination of brute force and just cutting into multiple pieces when it fails.

Next up, we have band unfolding. So I talked very briefly about band unfolding. I thought I'd show you some pictures about it.

And so remember, we're talking about volcano unfoldings, which is when you cut along all the edges from a point or it's sort of in the vertical thing. Band unfolding was when you had some side faces, you kept those intact and cut everything else away. So what do I have to show here?

This is an example of a band unfolding gone wrong-- I guess. It's a little hard to see. This is, in general, a prismatoid. We had a top polygon, A, here, and then below it, this is polygon, B. We took the convex hull, which adds all these other edges. And this is an example of a bad unfolding of a primatoid.

Here's an example of a bad-- this is really a band unfolding that has gone wrong. So imagine here the top polygon is this triangle. Bottom polygon is this triangle. That nicely nest. It's a very easy example, seemingly.

But for whatever reason, we also added this cut. And you can actually force that if I make this not quite-- actually, maybe it's not quite a triangle. It's a quadrilateral. Yeah, and this is slightly a quadrilateral.

So when you take a convex hull, you get that edge. If you cut along that edge and then cut along here and cut along here and do the band unfolding thing-- we're not even drawing the bottom polygon here-- just the band itself overlaps, which is annoying. Nonetheless-- so this is an old example-- but nonetheless, we proved that there's at least one place to cut the band-- like here would work-- that will avoid overlap.

And this is some parts the proof. In general, here we're looking at the inner polygon. And we cut it somewhere. And then we argue about where that vertex goes if we open up all the angles, which is what happens when you squash it flat. And in particular, we argue this vertex must stay in the gray region, like in the picture on the right, so it can't go up here.

And so in general, if you look at how these things unfold, if you're lucky, things will be convex when you open it. This is always going to be good. There's this weakly convex picture, where when you close the ends, it's not quite convex but only at one point. This is troublesome-- sometimes this works, sometimes it doesn't. If you look at this example, I believe it is in the weakly convex category.

I haven't told you the other one is a spiral. Here, if you draw a 90 degree angle from this last bar, then this guy is on wrong side of that 90 degree thing. This thing can't happen. So that's comforting. And it's related to this property.

But these things can cause problems like in the previous picture. And so you have to argue that there is a place to cut where you don't get this or if when you get it, it's still OK. And that's a messy argument-- a lot of case analysis I won't go through here. I think I have one picture of a nicely working example.

This is, I guess, a general primatoid. But here, we have a nice cutting that works. The original question that someone here posed was, what about prismoids?

So we know the band unfolds nicely. What we don't know is, can you attach the top polygon and the bottom polygons to the band and get an unfolding. We don't know, for example, whether all prismatoids have edge unfoldings, because we don't know how to place the top and bottom things. Probably possible but really hard to figure out where they would go.

A simpler problem is prismoids-- which this might actually be a prismoid. If you know that all of these edges are parallel initially-- so it's a very nice situation-- then that's a more special case from prismatoids-- then maybe you could attach the interface and outerface. We don't know.

We know volcano unfoldings work for prismoids. We don't know about band unfoldings. That could be an interesting open problem to work on. Maybe it's easy with prismoids. They seem pretty clean, but I don't know for sure.

Oh, another fun thing, which relates to our next topic, is that if you just unfold the band part, you can do it by continuous blooming-- meaning there's a continuous motion from the folded thing to the unfolded thing, or vice versa. And the easy way to see that-- you kind of get a sense from this picture-- in general, when you squash it all the way flat, it opens. Like this initial grey diagram is a projection of the original thing.

If you-- instead of opening it all the way-- if you kind of squish it from the top and just keep lowering that top face, at the end, it's fully in the plane. But in the middle, you have a motion. And by the same argument, at all times, you are non-self intersecting. So that actually gives you a continuous blooming of the band of a prismatoid, which is kind of cool.

So the next topic is blooming. This is the last topic also. A bunch of people asked about continuous booming and so the obvious one to learn more about. So I have some algorithms and examples for you.

This is the paper-- a bunch of authors, "Continuous Blooming of Convex Polyhedra." This problem was posed by Connolly, I believe, a bunch of years prior. It's still not known whether every unfolding continuously blooms. It could be that every unfolding-- every non-overlapping unfolding of a convex polyhedron-- continuously blooms.

I would guess the answer is, it doesn't but it's plausible. That was the original question. What we found are two different ways to continuously bloom any convex polyhedron, but we choose the unfolding.

So we have a couple different strategies for choosing unfoldings that do continuously bloom. Whether every unfolding continuously blooms, I don't know. There are definitely unfoldings of non-convex polyhedra that do not continuously bloom, based on knitting needles type examples, based on bad linkage stuff. But for convex polyhedra, I'm not sure.

So what do we have first? First strategy actually starts from any unfolding you have. So we start here from the cross unfolding of the cube. And then it refines it. So a similar strategy to hinged dissection, although I think this was done before hinged dissection.

Let's take some hinged structure, add extra cuts and extra hinges. In this case, I mean the hinges are going to be the same. It's just adding extra cuts. So we're going to cut along the red thing and also this red dashed line.

The red thing is a spanning tree of the-- or it's really the dual graph. So we have, the dual graph is you have a vertex for every face. You connect them together if they share an edge. In this case, when they share an edge, we're going to cut along there.

So we cut along all this red stuff. And the cool thing is, if you walk around the red structure, you get a cycle-- a Hamiltonian cycle that visits all the faces exactly once. We want to path, not a cycle, so we add one more cut.

So then this blue dash thing is a path. And the claim is, any path shaped unfolding-- where the faces are connected together in a path-- can be continuously bloomed. How do you do it? Roll.

So it's a little easier for me to think about unrolling rather than rolling, but they're the same thing. So imagine, you start with the cube. And then you just roll it-- you unroll one face at a time.

So initially, there was a 90 degree fold angle here. Just unroll it, so that now they're in the same plane. And there was initially a 90 degree angle here. Unroll that.

After three steps, I think-- this guy's been flattened, two, three-- we have this picture. In general, I would normally draw it rotated, so that the unfolded part lives in the floor of xy-plane. And the polyhedron lives in z greater than or equal to zero, so lives above that plane.

What you know at all times is that the unfolded part is a subset of the unfolding. It's a subset of this picture. So it doesn't overlap itself. If you start with a non-overlapping unfolding, you do this cutting. And then you just take some subset of the faces-- a prefix of the path-- then that will be a non-overlapping thing.

On the other hand, the polyhedron that remains, we haven't touched. I mean, it's rotating. You have to make sure it stays above the plane here. But it is just a subset of the faces of the cube.

The cube is also not self intersecting. So any subset is not self intersecting. So this thing doesn't self intersect. This thing doesn't self intersect.

Potentially, this cube will be resting on like f1 here. It's possible for this thing to unroll and just touch the plane-- xy-plane. But it won't penetrate it, just because this thing's convex and this is a plane. So you can always keep this thing above-- keep a convex shape above-- or what was a convex shape-- a partial version of a convex shape-- above a plane.

But they can be potentially touching, even along two dimensional surfaces. So if you allow touching, this is the path unroll algorithm. It works fine. If you don't want to allow touching, you need a slightly better strategy, which I'll tell you.

It's pretty simple. I won't argue that it works, but it's called the 2-step unfolding. This is named after the 2-step dance.

So we alternate between two kinds of steps. One is unfold of edge, ei, to be almost coplanar-- sorry, this should be a face-- face, fi, to be almost coplanar with the previous one, fi minus 1. So that does correspond to unfolding an edge, but I'm going to think about numbering the faces.

Almost means we unfold it to epsilon within the angle of 180 degrees. Then we finish unfolding the previous step-- fi minus 1. And then we repeat.

This is a little funny. So we're worried that if we unfold all the way flat, we'll actually live in the plane and then we'll touch things. We don't want to do that. So we're going to unfold it almost all the way. But when we're done, we do want to be flat.

So I don't want to just unfold everything almost all the way. That might work, but it's a little tricky-- the almost might interact. So what I'm going to do is just keep one guy almost unfolded. That will be the previous one.

When I've almost unfolded the next guy, I will finish unfolding the previous guy. Then we will almost unfold the next, next guy and then finish unfolding the next guy, and so on. And this turns out to work.

Essentially, you've got your fully planar part, which is everything before i minus 2. That would be completely flat. Then the next angle will be almost flat. And then the rest will be in its original state.

And you can argue the appropriate definitions of almost. There will be no-- in this case, there will be no two dimensional overlap. You still can get an edge resting on another thing-- still not quite perfect.

To make it completely perfect, we need a waltz. So the waltz is a three step dance. So the waltz, we have-- a little tricky-- we unfold fi to almost coplanar-- almost 180 degrees, with fi minus 1. Then we unfold fi plus 1 slightly. And then we finish unfolding fi minus 1.

So there's essentially a potential interaction between fi plus 1 and fi minus 1. We do a little bit of unfolding to prevent that from being an issue here. And so you end up with this three step waltz thing. Stefan Langerman is a dancer, so he liked this terminology. I won't argue here that that works, but now actually, you avoid all touching.

Last picture I wanted to show you is I said there were two ways to unfold. One was you take any unfolding, you make it Hamiltonian. And then you unroll it, using one of these three algorithms-- just regular unroll, two step, or waltz.

But another strategy we know works is the source unfolding. Here, no extra cuts required. Source unfolding is like the cleanest, coolest unfolding. It turns out it just unfolds. No problem.

How do we unfold it? We follow a post order traversal of the tree of faces, meaning we completely do one subtree. And now, here, we're in the middle of doing this subtree.

So here, we just have a cube with x being this point. And so the reds are the cuts. Pretty simple example. You just have a star of four prongs.

But here, we've completely unfolded this subtree. We've done one step of this subtree. The next thing we would do is flip it open. Then we do the next one, then we do the next one.

Essentially what we argue here, in one minute, is as you unfold you can think of-- well, there's a couple things going on. One is just look at a shortest path. Right? This source unfolding is made by a star of shortest paths. So just think of each shortest path individually for now.

Individually, if you look at a single shortest path, it hits some sequence of faces. Those faces form a path-like unfolding. So you just use path unroll. And that will work.

The only issue is potential interactions between the paths. And that's where you have to get into the post order traversal.

In general, you want this shortest path to stay shortest. What we're going to do is imagine the polyhedron in some sense as growing here. So as we unfold-- like, as we start unfolding this-- we can think of the interior of the polyhedron as just getting bigger.

And in that convex polyhedron, it turns out still these paths remain shortest. And by that, all the variants to work out. And you could argue that the paths basically don't interact with each other, because of post order traversal.

That was very hand wavy. The actual proof is a bit technical and more than I can do in zero minutes. That's a sketch of continuous blooming of source unfolding, which is pretty cool.

Star unfolding is open. Whether all unfoldings of convex polyhedra work is open. For non-convex polyhedra, there are bunch of non-convex polyhedra, which we'll be talking about in future lectures, that we know have unfoldings. Do they have continuous blooming? We have no idea.

This is the state of the art for bloomings. Still a lot of interesting open questions. Any other questions from you? All right, that's it.