# Lecture 12: Tensegrities & Carpenter's Rules

Flash and JavaScript are required for this feature.

Description: This lecture covers infinitesimal rigidity and motion, and tensegrity systems as an extension of rigidity theory. The rigidity matrix, equilibrium stress, and duality are introduced, and a proof to Carpenter's Rule Theorem is presented.

Speaker: Erik Demaine

PROFESSOR: All right before we get started, I just wanted to say goodbye to Eric Joisel, who died on Sunday, sadly. He's a master origami creator, and I encourage you all to come see "Between the Folds" on Tuesday, showing Tuesday evening, because there's a great interview with him, and it really captures his spirit. And sadly, I never met him in person. The last I corresponded with him was to get permission to show these photos in class. So that sucks.

And in particular, something called infinitesimal rigidity. So last class was mostly about generic rigidity.

Today we're going to talk about a variation, although related to generic rigidity. And this is going to be a very useful tool. It's a lot easier to work with algorithmically. It still captures essentially generic rigidity, but in a different way-- in a linear way. And it's going to be super useful.

So the idea is we think about rigidity-- does a linkage move or not-- to the first order. First order means first derivative. OK, so I'm going to do some analysis stuff-- calculus, which you should all know, because is the General Institute Requirement. Don't worry, you don't need to know much.

So in particular rigidity, is really about the lack of motion. So let's define the idea of infinitesimal motion, or first-order motion. This is, again, suppose we start somewhere. And somewhere would be a linkage configuration.

There's a linkage. There's a graph, with edge lengths plus configuration maps every vertex to a point. I'm going to assume we're working in the plane for now. But really this works in-- I'll say d dimensions.

So this is what I want to define. I'm going to say that it is a valid-- this is sort of an informal notion-- a valid first derivative of a motion. We've already defined motions.

I want to take such a motion, essentially, take its derivative with respect to time, And evaluate that derivative at time 0. This is a fancy way of saying the following picture-- I'd like a motion, which is some path in the configuration space-- remember, configuration space is some hugely dimensional object, d n dimensions-- and a point in that space corresponds to a configuration. We have a motion is some path in that space.

And motions are hard to think about. They can be really complicated. So I just want to say, well, how do you get started moving? What direction do you go in in a linear sense, to the first order? What's the derivative? What's the tangent right at the beginning?

And then this notion will, stated in terms of motions-- you can think about this in the absence of a motion. Say, well, yeah, I don't really know whether this curve exists, but let's just see, does this initial starting direction exist? And that's actually a little weaker than the whole motion existing.

If the motion exists, surely you can take this derivative and evaluate it. It's not totally obvious, but it's true. You need some smoothness. But if there's a way to get started moving, that doesn't actually mean you could actually move.

Why don't I give a more formal definition, and a more useful one-- but that's the intuition. So another way to think of an infinitesimal motion is, instead of saying how each vertex moves in d dimensions, you just give a velocity vector for each vertex. For every vertex v, we're going to get some velocity vector d of v-- that's direction or derivative of v.

And with motions, we were supposed to preserve edge lengths. So here we'd like to preserve edge lengths, but that's actually kind of hard to do. If you take an edge-- so I have two vertices, and I assign some velocity vectors, something like this-- as soon as you move a little bit in that direction, the edge length won't be quite the same.

But it'll be the same to the first order, so this is going to be a little subtle. And in the book, we take the derivatives. We work out all the details. But I'll just tell you what the condition is, because ultimately all we need is this condition.

I'm just defining an infinitesimal motion to be a velocity vector for every vertex, such that this property holds. This is a dot product between two vectors. If you have two vectors, a and b, you take their dot product, this is just something like this. You take the x-coordinates. You multiply them together. You take the y-coordinates. You multiply them together, and so on. Add them up.

And we're going to need some linear algebra. That's one useful linearity thing. So these are where the configuration places vertex v and vertex w. So this should be true for each edge v w on the graph.

This is a vector C of v minus C of w. Let me give some labels. Let's say this is w, and this is v.

Let's say these are the points that the configuration places w and v at. Then C of v minus C of w is this vector. It's a vector.

It doesn't really have any space. It's just been translated around. It's a vector that would point from w to v in the configuration. That's the left part.

The right part has no real intuitive meaning, but it involves this thing-- some velocity vector for w-- and the velocity vector for v. So this is some relation on this vector and these two vectors. It's actually a very intuitive relation. Let me tell you what it means.

Basically, we want to understand how this length changes to the first order. So this guy's moving to first order in this direction. In fact, it's moving on some curve, and the initial tangent is that direction.

And to understand how that motion changes this edge length, turns out the right thing to do is to project this vector onto this one. Makes sense. So as this guy moves in that direction, This is the first-order change. This distance here is the first-order change of this length as caused by this vertex moving.

OK, that projected length is actually very simple. This is again, some linear algebra stuff interpreted geometrically. This is a dot product in d of w-- that vector-- dot product with C of v minus C of w.

It turns out dot product corresponds to projection. So I'm taking this vector. I'm projecting onto this one. That's how you'd write it algebraically.

And same deal over here. If I project this vector onto this one, that's going to be the first-order change to this edge length caused by this vertex moving in that direction. So this is d of v dot C of v, minus C of w.

So if I want this edge length not to change at all to the first order, then this projected length should equal this projected length. And that's why I drew it this way. So it turns out this is a valid motion, because that projected length equals that one.

And in general, we want this thing to equal that thing. And if you rearrange terms, that's the same thing as this property. I just take this one minus this one, and set it equal to zero, and you get that.

OK, so this is some intuition. Maybe it makes sense, maybe not. In the end, this is all I care about.

And it's useful to realize that it's a first derivative of a motion, because what that implies is that if there's a motion-- a real, honest to goodness motion-- then there's an infinitesimal motion. I'm going to abbreviate that "inf motion." Infinitesimal is pretty long. Infinitesimal means smaller-- very tiny-- smaller than anything, I think is the literal meaning.

So this is useful to us, because the contrapositive says if a linkage is infinitesimally rigid-- which just means if there is no infinitesimal motion-- then it's rigid. So these are the same statements. This you prove just by taking a motion and taking its derivative. This is identical to that.

So this is useful because if we can ever find something and show that it's infinitesimally rigid, then we've determined that it's rigid. Question?

STUDENT: [INAUDIBLE] dot product [INAUDIBLE] at a left right turn is 0, or that the terms are at 90 degrees to each other?

PROFESSOR: Yeah, this dot product basically means these two vectors are at 90 degrees to each other. That's another geometric meaning. I don't have a geometric picture. Maybe there is one, but I have trouble thinking about d of v minus d of w. That's not an intuitive thing to me, but it's something.

And we're saying that that vector should be perpendicular to C of v minus C of w. However you want to think about, I like to think about it this way, but they're equivalent.

All right, so how do we tell whether something's infinitesimally rigid? Because somehow that's useful to us. Well, there's a saying that everything is linear to the first order-- sort of a tautology. And all you need to observe is that this constraint is linear in what we don't know.

So I want to know is there some set of velocity vectors d of v, and d of w, for all the vertices, so that these constraints hold. But I already know C of v, and I know C of w. This is just where are these vertices currently. And I want to know can I get started moving?

So these are my known quantities, and these are my unknown quantities. This is just some linear thing. And the dot product-- I mean, this is all just constant. I know what they are. So this is a linear equation.

The fancy way to write this is as a matrix equation, if you want. So this is the idea of a rigidity matrix. So we have a whole bunch of these constraints, one for every edge.

And whenever you have a bunch of linear constraints, you can write them as R-- some big matrix-- times the velocity, or call them d's equals 0. So I can absorb this into a matrix. If you're used to that, great. Otherwise, this is what it looks like.

My matrix R is going to have a row that has a whole bunch of zeroes. And then at some point, it has basically various versions of this vector. But because this is one equation, but in two dimensions, there's two parts to all these vectors. Two dimensions that'll look something like this-- why did I change the order? I think it's right.

OK, this is not very amazing. It's just there are going to be four terms in two dimensions in this equation, because we've got d of v times this vector. So there's a x-coordinate vector, and the y-coordinate vector, and in d dimensions, there will be d of them. Here in two dimensions, I've got the x-coordinate of the vector, and the y-coordinate of the vector.

So this will end up getting multiplied on the right hand side by d of v. So the two v rows, and this part will end up getting multiplied by d of w. yes, so these guys switched around. It's now w minus v in order to implement that minus sign.

So whatever-- the point is you get a matrix. And what we care about, what we're trying to solve for, is d. We know this entire matrix, because we know c. We know the configuration.

We just want to know is there some set of velocity vectors such that the rigidity matrix times this is equal to zero? This is called the set of d's i for which this is possible is called the-- anyone know? Good old linear algebra-- it's called the null space of this rigidity-- null referring to that 0, or the kernel.

So the set of all infinitesimal motions is the null space of that matrix, also known as the kernel of the matrix. And so what? Well this lets us use a bunch of theorems in linear algebra.

So one fun fact is that the dimension of this space-- the space of all infinitesimal motions-- seems like a useful thing to know. We want to know how many-- this is basically the number of degrees of freedom in infinitesimal land, which is not quite reality, but it's close. This is called the nullity of the matrix.

That's just the definition, but there's a fun theorem called the rank nullity theorem from linear algebra. Which says if you have a matrix, you take its rank-- which is another quantity-- you take its nullity, and you add them together, it will be the number of columns in your matrix.

Now in our case, the number of columns is d times n. We have n vertices down here, and each of them has d coordinates. So for us, this is d times n.

So this is like a conserved quantity. What we care about is the nullity. This is the space of motions-- infinitesimal motions. And so consequently, we care about this thing called the rank.

And if you've ever seen linear algebra, especially linear algebra algorithms, the bread and butter business is computing the rank of a matrix. This can be done in polynomial time. So this is good news.

And intuitively what it corresponds to is the number of useful edges. And this thing is the number of degrees of freedom. So it turns out these will always be equal to d times n in summation.

And what we care about, infinitesimal rigidity, means that-- or let's say it's infinitesimally rigid if and only if the nullity of the matrix is the space of rigid motions, which I have to look up. In general, in d dimensions, it's this-- d plus 1 choose 2. In two dimensions, there's three rigid motions. You've got the two translations and the rotation.

Those we're not getting rid of. They still exist in infinitesimal land. So in two dimensions, ideally your nullity is-- if you want rigidity, your nullity should be 3.

And what this is telling us is then the rank of the matrix should be d n minus that. In two dimensions, that is 2n minus 3. So this is telling us something we already knew, but essentially for free, which is kind of fun, if you know all this linear algebra. Which admittedly, even if you've learned linear algebra, that may not be the first thing you care about in that context, but for rigidity, this is a really useful way of thinking about things.

You've got all these columns-- d times n of them. You want to obliterate all the degrees of freedom you can, and leave just three of them in two dimensions-- d times d plus 1 over 2 in d dimensions, and you do that by adding useful edges. And useful edges here means that the rank is high, which essentially means none of the rows in this matrix cancel out with each other.

So it's another way of thinking about essentially everything we've seen. And if you know linear algebra, it's useful. Otherwise, I'll tell you how we can use it.

OK, one mathematical thing we can do is give another definition of a generic point set. Last class we talked about one definition of generic, which was that you forbid all non-trivial polynomial or algebraic rational equations on your points, which is very messy and infinite and hard to think about. This definition will be easy to think about if you're used to linear algebra.

So for some, it's an improvement. For others, it might be the reverse-- whatever. But at least this definition is finite, which I like.

OK, for this definition we need the notion of a minor. So we have some matrix. Actually, our matrices are pretty rectangular.

And I just choose, let's say k columns from the matrix-- let's say 3, and I choose k rows-- the same number of rows and columns. I look at those elements in the intersection. That's a square matrix. That's a minor-- that 3 by 3 square submatrix is called a minor.

So there's a whole bunch of minors, but it's only finitely many. It's exponential. It's not easy to check.

You take all the minors of your rigidity matrix. And here I'm imagining the complete graph, so there's tons of edges. There's n choose two edges. So this'll be independent linkage.

You could do it specific to the linkage, but it's better to do it for the complete graph. Then we take the determinant of that matrix, which I won't define. It's a number associated with that matrix.

And if it's non-zero-- now remember, rigidity matrix is defined as a function of C. It depends where you put the vertices. So what I'm saying is if it's non-zero for some choice of C, then it should be non-zero for this choice of C.

And if you find such a configuration C-- or I guess we call this a realization C-- then that C is generic. So if I gave you a specific configuration, you could, in principle, in finite time-- it won't be efficient-- you could check all of these things. And say, oh, I compute out, I work out what the determinant of that submatrix is, that minor.

It's some algebraic function. If it doesn't cancel out entirely, if it's not zero trivially, it's not zero always, then I just evaluate it at this configuration. And if it's non-zero there, good. That's generic. So it's not useful in a computable way, but it's a definition. It's a little bit nicer.

And now there's a bunch of fun facts about infinitesimal motions and rigidity, and the relation to the generic case. So there as we have before, this definition is not quite the same, but it's effectively the same as the last one. Almost every configuration is generic.

So maybe I should say realization-- whatever. I take some point set-- I take some vertex set. I assign random points to each vertex. Then with probability 1, it will be generic according to this definition. That's really obvious if you know linear algebra. That's a good thing.

But here's what's really cool-- if we take any of these generic configurations-- so just fix one-- rigidity is the same thing as infinitesimal rigidity, is the same thing as generic rigidity from last class. Wow, this is cool, because if I care about any one of these three things, I just have to pick my favorite generic point, which I can do randomly. I can just take a random point, and if I can evaluate any one of these three things, I learn about all the others.

So if you want to tell whether a 3D graph is generically rigid, you take a random realization in 3D. You compute the rank of this matrix generalized to the 3D case. You see is it 3 n minus 6, and that will tell you whether that generic realization is infinitesimally rigid. And if you chose it right, which you will do at probability 1, then that will tell you whether the graph is generically rigid.

So when I said last class generic rigidity in 3D is hard, it's hard in the sense we don't have a deterministic algorithm, but randomized-- super easy. Choose a random configuration, check the rank of the rigidity matrix-- done. So that's kind of cool. And that's why this infinitesimal rigidity stuff is so important, because it's so easy algorithmically. Things become a lot easier.

Let me draw you one example just to show what happens at non-generic points. I've actually drawn this example before. So here's a non-generic point. These three points are collinear. And you can work out there is some minor that is 0, but shouldn't be.

And this thing is rigid, because we have rigid triangle here. We have a rigid triangle here. So these two points are pinned relative to each other.

And then this thing is taut, so it can't move. But to the first order, it can move. And it's allowed to move straight up or down-- anything perpendicular to this segment.

That's always true. If you take a segment, and you move one vertex but not the other perpendicular to the segment, that's a valid infinitesimal motion. Why? Because if I project this onto the segment, I get 0. So this length is not changing to the first order.

And this is really necessary. To the first order, you can't really distinguish this guy actually moving up, and therefore getting slightly longer versus this guy moving along a circle centered at that point, which is a valid motion. To the first order, they look the same, because you're going straight up or down in first derivative.

OK, here, to the first order, you can't realize the fact that if you're going to go on this circle and you're going to go on this circle, you get a contradiction. But it's pretty accurate. And if you perturb this example, infinitesimal rigidity will give you the right answer.

This is an example where infinitesimal rigidity is a little bit weaker than-- no, infinitesimal flexibility having infinitesimal motion is a little weaker than having a motion, but the reverse holds. If there's a motion, there's always an infinitesimal motion. If you're infinitesimally rigid, you're always rigid. That example is rigid, but not infinitesimally rigid, so it's sort of strict.

OK so far? That's the more technical part of the lecture. Question?

STUDENT: Will [INAUDIBLE] be square matricies?

PROFESSOR: The rigidity matrices are almost never square. Good question. The minors are going to be square, because we told them to be.

But I think typically, in the ideal setting, we're going to have d n columns-- so let's say 2 times n columns in two dimensions. And we're supposed to have 2n minus 3 rows. So it's close, but in general, they should differ by about this much. So they're almost square, actually. Glad you asked.

PROFESSOR: You could always add extra edges and make it square, yeah.

STUDENT: [INAUDIBLE].

PROFESSOR: Well, no. So that's another good question. What happens if I add more edges than this many?

The rank just won't go up. Any edges you add will add redundant constraints, and so the rank can never go above this value. You need at least this many edges to get there, and we know we can get there with that many edges, but only in the minimal rigid case.

You could add more edges. You could make it a super-tall matrix if you want, but you're not going to increase the rank. All right, let's use this for something more fun. So maybe go over here. I don't need the rigidity matrix any more.

Tensegrity-- so this is in some sense an extension of rigidity theory to a whole other theory called tensegrity theory. The word tensegrity comes from tensional integrity, which is a very Buckminster Fuller term, and he invented it. I don't think he invented tensegrities, but he invented the word.

And they are things like this-- here's a tensegrity built and given to me by Bob Connolly. And it has well, I guess, there are three kinds of edges physically. There are the springs. There are these struts, and there are these wire cables. And its rigid. It's a little flexible, just because the springs aren't perfectly stiff, like all springs.

But there are three kinds of edges here, and we're going to model the three kinds of edges. The edges that we've modeled so far are most closely related to these springs, so that's not quite the right physical analogy. What I would call the edges and linkages is bars.

Bars are, like, solid attachments, like steel rods that are permanently attached to the two endpoints. The lengths of these edges should never change. That's been the world we live in, at least to the first order, whatever. Edge lengths of bars should never change.

Now we have these cables. Now cables really can get shorter. This cable is perfectly happy to get shorter. I can pull those two vertices together.

But what it prevents is getting longer. If I pull-- you can't tell, but I'm pulling really hard on these vertices apart. Nothing happens, because this cable can't get any longer.

So cables prevent extension, but they do not prevent compression. Struts, on the other hand-- they prevent compression. If I push on these two vertices, they don't get any closer. If I pull, it comes right out.

And you have to realize that these are eye hooks, and so really, those could come apart. All these struts are preventing is compression. They don't prevent expansion. So that's the thing we want to model.

This is a tensegrity. It's a generalization of a linkage and where we allow three kinds of edges. It can be a bar-- and this is the old case, which is that the length is fixed.

We can have cables, which is the length can decrease, but it can't increase. And there are struts, which are the reverse-- you can increase but not decrease. Seems like a useful generalization, especially because people build things they actually use struts and cables. Like you look at most bridges-- tons of cables around. I think I have an example here.

There's this guy, Ken Snelson, who makes a whole bunch of cool tensegrity sculptures. This is a particularly tall one in Washington, DC that I saw a couple years ago. That's to give you an idea of height.

And there's this really cool view if you stand-- here's a person. You stand in the center, and you look up. It has this really cool, sixfold rotational reflectional symmetry. I could stare at this for hours. I think that's just the [? zoom ?].

So we want to understand those structures. This one's also rigid, hopefully. It's been standing for 40 years.

So what can we define in this generalized setting of tensegrity? We want motions. We want rigidity. We want generic rigidity. We want infinitesimal rigidity.

All the good things we've defined, hopefully, carry over to this. Well, all but one of them carry over to this.

OK, we can define a configuration space. It's going to be a little smaller, or a little different from our old configuration space. It's a space of all possible configurations where these three things hold-- give you desired lengths for each of these things. As long as these constraints hold, that the lengths stay the same here, get smaller here or the same, or stay the same or get larger here-- that's a valid configuration.

So it's actually a slightly larger configuration space than what we had. A path through that space is going to be a motion, just like before. Configuration is just a bunch of points where this holds-- blah, blah, blah.

The problem is, there's no notion of generic rigidity. For example, this is a generically flexible linkage. We all know it. Now I take my yellow chalk and add struts. Maybe I'll put some arrows on it to make it more obvious.

These are things they can expand, but cannot contract. Then this configuration is rigid or flexible? Flexible, yeah-- this is a one degree of freedom linkage.

The white part is a one degree of freedom linkage, and if you move this thing in a particular direction, indeed, this increases and that increases. Check it.

This one is rigid. The only way to move the square-- or in fact, any generic convex configuration-- is one of these pairs has to get shorter. The other one will get longer, but one of them will get shorter.

So this is the same graph, and the same labeling of which edges are bars and which are struts, but in one configuration it's flexible. The other it's rigid. So we lose generic rigidity.

But infinitesimal rigidity still works, and generic configurations are still meaningful. It's just that they're not all the same. There's not, in this case, for four vertices, there's two kinds of generic configurations. So it makes life a little harder.

But let's say this part will work well. So why don't I be clever, erase this part. So this is the idea of an infinitesimal motion. of a tensegrity.

Well, I want to take the same dot product, and I claim this is really measuring-- it's a number, and it's measuring the sign's change in length of that edge. So if C of v minus C of w dot product with d of v minus d of w is greater than or equal to 0, that's the property I want for struts. That says it gets longer or stays the same to the first order.

Now of course, in reality it might get slightly shorter, but not in the first derivative. And it should be less than or equal to 0 for cables, and should be equal to 0 for bars. So that's the new notion of infinitesimal motion.

Now, this is no longer a linear system of linear equations. I can no longer write this as a matrix times a vector equals 0. But this is this more general thing called a linear program, where I have linear equations. I also have linear inequalities.

So in fact, I can write it as some other matrix R prime. Actually, it's the same matrix. R prime times d is greater than or equal to 0. This is the general form of a linear program.

And you can write an equality constraint in this world just by taking it and its negation, setting both of them greater or equal to 0. That forces them to be equal to zero. All you need to know is it there are fast algorithms to solve this, also.

So if I give you a tensegrity in polynomial time, you can tell whether there is a valid infinitesimal motion that does all things you want on the struts, cables, and bars. Cool, questions?

STUDENT: [INAUDIBLE]

PROFESSOR: This R-- this is some matrix, and this is your vector of all the d's.

STUDENT: Right. And saying that it's greater than or equal to 0 [INAUDIBLE].

PROFESSOR: Oh, that means element lines, sorry. You take a matrix times a vector. You get a big vector. This is a vector of zeroes. I should have said that. And it's just saying every element in the vector is greater than or equal to zero. So it's just a fancy way of rewriting this stuff again.

But this is what we call linear programs, and that's what's solvable.

STUDENT: And that's just for struts, then?

PROFESSOR: Well, for cables you could just negate the left-hand side. And then that's greater than or equal to zero. For bars you have to include the same left-hand side and its negation. Yeah, I'm skipping some steps. That's why I had to write R prime-- it changes a little bit.

How many people know about linear programming? OK, about 2/3, so for you guys, you also know that there's this thing called linear programming duality. If you have a linear program, the first thing everyone should do when they have a linear program is take the dual and see what you get. I'm just going to tell you what you get. But that's the next trick I want to pull.

So dual notion-- essentially what prevents you from solving that system-- in other words, what makes something rigid-- is something called equilibrium stress. So stress, for me, is just a real number assigned to every edge. And here I'm going to use the word edge to mean bar, strut, or cable.

So a real number s of e for each edge e, and have to have three properties. If I have a cable, then that number should be non-negative. If I have a strut, it should be non-positive. If I have a bar, I don't care-- could be positive, or negative, or zero.

And then there's the equilibrium condition, which is that if I take the sum over all vertices w, where v w is an edge, the weighted vector C of v minus C of w-- so I forgot to mention we're assuming we have some configuration of our tensegrity. This is the zero vector for all vertices v. Let me draw a picture.

I'll draw a real example, how's that? Here's a rigid linkage. I'm not going to say yet which edges are struts and cables. In some sense, I can do that later.

And I'm going to put numbers 1 along all the outside edges and the numbers 3 along all the inside edges-- sorry, negative 1 and positive 3. And then if you work out what this is saying, I'm taking the vectors-- so I'm looking at each vertex like this one, and saying OK, well, I take all of the incoming, whatever.

Let's think of all the edges incident to that vertex. I weight them by this number. In this case, they're all multiplied by 3.

So I take this vector. I multiply it by 3. It gets three times as long. Take this vector, multiply by 3, this vector multiplied by 3.

I add them up. I should get the zero vector. And if this is really an equilateral triangle, I will get the zero vector, so that's good.

And I'm going to draw arrows here to signify what this means intuitively is that this edge is pushing with a really big arrow. This is an arrowhead of size 3. Try to draw it to scale.

Then, of course, this vertex will not move subject to those forces. These forces balance out. On the other hand, this guy, I have these edges of weight negative 1. That means it's going to pull, and it's going to pull with the arrowhead of size 1.

OK, and I claim also that these vertices do not move subject to those three forces. How do you check that? The proper way to check it is to draw what's called a force polygon. Those who have done structural engineering know this.

So I take, let's see, there's this vector, which is length 3 times that, so it would be something like that long. And let's say I'm pushing in that direction, so I go there. Then I follow this thing with the weight of 1, but in sort of the opposite direction, so it will be like this. This is my attempt at copying that edge length and getting what I want.

And then the other force is this one. It doesn't actually matter which order I do these in. And if I end up back where I started, that means the total force is 0 as a vector, and so this vertex is stationary. That's the force polygon.

So you can just check this. It's a geometric condition, if you will, that each vertex is stationary. That is the notion of being in equilibrium. And this is just the algebra to write that down.

Now what the heck does this thing mean intuitively? If your tensegrity is going to be rigid, somehow the edges can prevent a motion. And intuitively, what that means-- I'm going to say this right-- so this is like an edge pushing really hard away from itself, against the vertices.

That's like a strut. A strut prevents compression. So that the force that it can actuate effectively is an outward force.

Whereas cables prevent extension, so they can sort of pull back, say, no, you can't get any longer. I'm going to pull towards me. So this is like a cable. This is like a strut.

Now bars can do both. That's why there's no constraint on bars. But assuming I've got this right-- and I didn't. I got it backwards. Minus 3 plus 1-- it's symmetric so it doesn't matter in some sense, but the intuition matches when cables can pull, and struts can push, and bars can do both, because they prevent motion in both directions.

All right, now, it would be nice to say you're rigid if and only if you have an equilibrium stress. But that's not true. Let me tell you what is true.

So this is duality. This goes back to Roth and Whiteley, 1981-- good year. So let's see, here's what's true-- if I look at all the equilibrium stresses, and I find some stress that is non-zero on a particular structure or cable-- I should mention there's always a trivial stress, which is you set all of these S's to zero. Then everything will hold.

So what we're interested in are nontrivial stresses, where you're nonzero somewhere, and the interesting case is when you're nonzero on some strut or cable, let's say. So if there is such an equilibrium stress, then it's not quite the case that you're rigid, but you're rigid on that edge. Every infinitesimal motion holds the length of that edge fixed.

So this is a strut or a cable. It could get longer or it could get smaller, depending which case we're in. But if there's a stress that's nonzero on that edge, then in fact, it can't change length at all. It effectively acts like a bar in this configuration.

That's what this theorem says. And these are equivalent. If you want to know can I possibly make the strut any longer? You just see can I find an equilibrium stress for that thing that's non-zero?

Another thing you can say-- almost equivalent to this or a consequence of that-- if I have some tensegrity, and I want to know is it infinitesimally rigid, that is the case if and only if two conditions hold. One is that every strut or cable is nonzero in some stress-- in some equilibrium stress-- and I'll say the corresponding linkage is rigid.

So all this is saying is if you can find a stress that is nonzero on every particular strut or cable, then all of those things are effectively bars. So you can convert your tensegrity into a linkage where all the edges are bars. And then it's just a matter of testing rigidity or infinitesimal rigidity of that linkage, which is something we already know how to do.

So in some sense, we already know how to do all of this, because this is just a linear program. We can solve it. But this is a more intuitive way of proving this.

If you want to prove to someone that tensegrity is infinitesimally rigid, you give them a bunch of stresses, one for each strut or cable, or maybe you just need one stress to hit all of them. And then you show that the linkage is infinitesimally rigid, which you could do by computing the rank of the rigidity matrix. Strut can have zero stress-- the weight is zero.

OK, let's keep going. Lots of a cool things to talk about, maybe over here. I want to do a little diversion for fun, something called spider webs, like this. You might have seen them before.

A spiderweb is something where every edge is basically a cable. You can see under wind and tension, they get a little bit shorter than they're supposed to be. But they can't really get longer. They are pretty strong at preventing expansion.

So a spiderweb is something that can be stressed with all positive weights. And the reason it holds in tension-- positive, yeah, cables-- all of the edges can have a positive stress, and it will be in equilibrium. And in spiderwebs, in fact, this is the same-- these two-- rigidity and positive stresses are the same thing.

This is sort of a special case, and Connolly studied these in 1982. There's some special points in a spiderweb. Here they're kind of off the page.

There's a point down here where it attaches to something, and up there, and up there. Those guys do not satisfy equilibrium, or you can say those edges have some negative stresses. Or another way to think of it is there's a point off to infinity, which is how this is drawn, and you can have a positive stress. And at infinity, you don't have to satisfy equilibrium.

So there's a little something special at the boundary, but everywhere else-- interior and all these vertices in here-- you have equilibrium, and all the stresses are positive. And it turns out in this case, you're automatically infinitesimally rigid. That tensegrity is infinitesimally rigid. Normally, we need to also check the underlying linkage is rigid, but for spiderwebs, you don't have to.

Why do I care about spiderwebs? Because they give us something called origami tesselations. This is a brand-new result from this summer at [? OSMI ?] by Robert Lang and Alex Bateman. Here's a little example of an origami tessellation, this fold by Jenny [? Ramsier ?], just the one I had hanging around in my office. It looks a little cooler that way.

Let me hold it up to the light. I can see it great. You don't see the light. It looks pretty cool.

It's folded from one square, and it's folded in some sense with a regular pattern. You can see regular hexagons, hexagonal pattern. And these guys have been around for a long time, probably at least the '60s, maybe earlier-- a lot of Japanese artists, lot of American artists. And there's been a lot of excitement about origami tesselations since the mid '90s.

I think Chris Palmer revitalized them, and then tons of people are looking at them. And there's this cool algorithm for building them.

So you take some tessellation like these squares, and triangles, and hexagons-- some collection of polygons. You shrink all of them a little bit, but all by the same amount. And then you twist them a little bit, all the same amount.

So here they are twisted. And then you just connect the dots. So these two edges used to be joined to each other. So I'm going to connect these guys, and connect these guys. That's the green edges.

And that's your crease pattern. You erase the red stuff, and you get your crease pattern, and you fold it, and you get this cool tessellation-- magic. Now the question is, when does this work?

This algorithm has been around forever, as far as I know. I don't know exactly how old it is, or who invented it, but it's pretty natural. It's how most tesselations are folded.

But when does it work? And there is a brand-new result from the summer that it works for some choice of those angles. So I had some flexibility-- how much do I shrink and how much do I turn? But this will work for some choice of turn and shrink amount, if and only if your graph or your initial tessellation is a spiderweb.

Pretty cool-- spiderwebs have this neat property that you can do the shrink and twist tessellation algorithm, and it works. And here is an example of that-- a spiderweb, so to speak, but drawn visually. And this is actually a proof that-- these are basically all the force polygons showing that you can get a positive equilibrium stress.

And you turn it into a crease pattern, fold it flat, and it works. This is, of course, in simulation, but you can really fold these things, and they work. So that's kind of fun-- a little bit origami out of linkages and tensegrities. Questions?

All right, then we move on. I want to tell you one more cool thing about stresses and tensegrities-- yet another characterization of stresses, which is polyhedral liftings.

A polyhedral lifting is going to work if I have a non-crossing configuration. So I don't want to have this-- two edges that cross each other. I only want to have pictures like this, where edges don't cross each other. They only share endpoints.

Then I can define what's called a polyhedral lifting. So this is a planograph, if you will. Polyhedral lifting is going to be an assignment of z-coordinates to the vertices. So it's going to be a z-coordinate z of v for each vertex v such that each face remains planar.

Because I forbid crossings, I end up decomposing space-- the plane here-- this only works in two dimensions. This is one thing that does not generalize to arbitrary dimension. So I get a bunch of triangles here.

And so I want to lift. I want to assign some z-coordinate to each of these vertices, such that each of these triangles remains planar. Well, actually, that always holds. Triangles are always planar.

But there's another face, which is the outside face out here. That's a quadrilateral. That one also has to remain planar. So these four vertices have to be lifted onto some plane.

This guy can be lifted however it wants in this particular picture. In general, you're going to have a lot of non-triangles. Those should all remain planar. That's a lifting.

One thing you can do-- there's some freedom here. If you have any lifting or, for example, you could not lift them at all. Set all the z-coordinates to zero. That's fine. You could also just lift everything onto some other plane, and generally have a rigid motion of freedom.

You can't translate around, but you have one two-degree two-rotational freedoms, I think. And so we would just like to get rid of those. So say remove rigid motions by forcing the outside face to lie in z equals 0.

So let's say these guys all stay at 0. So in this particular example, this guy can go to any value, positive or negative, but that's it. Now, this is a lot like stresses-- in fact, it's identical to stresses.

It's probably not obvious, but just like stresses where you could set everything to 0, here you can also set everything to 0. It's not a big connection, but it turns out they really are the same thing for non-crossing configurations. This is called Maxwell-Cremona Theorem.

This is probably one of the oldest theorems we will cover here-- I guess anywhere. Well, it's not that old-- 1864. That might be the oldest. Maxwell proved this, or claimed it in 1864.

Theorem is there's a one-to-one correspondence between the equilibrium stresses and polyhedral liftings.

And fun fact-- negative stresses correspond to valleys. So valley is something like this. You know what valleys are, but it's maybe a little bit subtle. We're not folding all the way here, so this would also be considered a valley, because it has sort of negative dihedral triangle.

It's really hard to see. What I meant was something like this. That's a valley edge here. This is another valley edge here-- whatever.

A positive stress corresponds to a mountain, which is the same picture upside down. A zero stress corresponds to a flat angle-- doesn't have to be horizontal, but it has to be flat. So it could be like this.

I'm going to need this in a moment proving the next thing. I'm not going to prove this theorem, but it would be fun to actually see it in action. I've never seen it implemented, so another fun project.

I give you tensegrity. You compute an equilibrium stress, which is easy to do by linear programming, and draw-- you can directly construct from that the 3D lifting, which would be kind of cool. I'm going to use basically everything I proved today to prove a big theorem-- the Carpenter's Rule Theorem. It's why I'm wearing this t-shirt that has nothing to do with the Carpenter's Rule Theorem.

And it's about non-crossing linkages. So this is the beginning. So far we've been allowing crossings, except for this very last theorem.

Now we begin this section where I forbid crossings between the edges, just like what that picture was. Prevent this, and this is a constraint on the configuration space now. I'm going to look at all the configurations where no two edges cross.

This is a smaller version of our old configuration space. I'm not going to define it formally. It's a bit messy. It's not too nasty. It's still defined by polynomial inequalities. Question?

STUDENT: What if you have one of those diagonals and switch it to be in relation to each other [INAUDIBLE]?

PROFESSOR: You want this picture and--

STUDENT: Either one.

PROFESSOR: And you want to add this? Or-- that's crossing-- not allowed. Whatever you're saying is not allowed. That's the easy answer.

I don't quite know what it is, but what we allow-- and in this case I'm just thinking about linkages for the moment. It's just you can hinge at common vertices. Two edges either share a vertex or not. And that's it. But they're not allowed to touch anywhere else.

And now what we care about is something called a locked linkage. And a linkage is locked if its configuration space is disconnected. So the configuration space would look something like this. Maybe it has three components.

If I have some configuration here, I can move to any other configuration here, and same over here, but there's no way to get from this configuration to that configuration. They're disconnected from each other. So this would be kind of sad news if you're looking for motions. It means you cannot get from everywhere to everywhere.

There are some locked configurations that cannot get back to start. However you define start and locked doesn't matter, but the linkage is locked when there's two things that cannot reach each other. And the Carpenter's Rule Theorem is about one case of that.

So this was essentially my Ph.D. thesis, so paper in 2000 by Bob Connolly who made that tensegrity, [? Gunta ?] [? Rota ?] and me. And it says that if we have a linkage, and say we take a configuration of that linkage, and let's say it's of maximum degree 2, so every vertex has at most two edges coming out of it. Then there's a motion of that linkage that straightens out-- so if you have maximum degree 2, you have paths, and you might have some cycles. You might have many of them.

And it's going to straighten all the paths and convexify all the cycles. And it's also expansive. But before I get to that, this is essentially showing that these configuration's bases are connected. It doesn't quite imply it the way I've worded it.

But for example, for paths, I take some path. I want to know, can I get from this configuration to some other configuration? Well, I could take this one, find a motion that straightens the chain. I could take this one, find a motion that straightens the chain.

So here I've drawn it straight. I take this motion. I apply it forwards. I take this motion. I apply it backwards, and I get from here to here.

So if I can straighten all the paths, I can definitely get from anywhere to anywhere. For convex cycles, it's a little less obvious, but it's also true. There's one catch which I didn't say here.

I need to add outermost. When you have nesting like this, you're in trouble. This guy is not going to get straightened out.

It could be super long. It may not have room to straighten out inside that convex chamber. So these guys will come along for the ride, but they won't actually get straightened. The outermost guys will get straightened and convexified.

The other fun property-- and this is how we actually proved the theorem-- so this was open for a long time. People thought this was true. And the key to proving it is by making the theorem stronger, which is that all pairwise distances between vertices increase or stay the same.

Some of them have to stay the same, because they're edges. They are bars in there. They can't change in length. But everything else will increase.

Now there's a couple reasons why this is useful. One is that it says you don't have to worry about crossings. If I have some edges that initially don't cross, and I'm worried about them crossing, that can't happen if you're expansive.

If I say, well, this distance has to increase, and this distance has to increase, there's no way that this vertex is going to cross over that edge. One of them would have to get shorter. So this essentially says, everything's flying away from each other.

So if initially you're non-crossing, you will be non-crossing forever. That really makes life easier, because crossings are hard to think about. This lets you not worry about crossings. You just have to worry about distances.

How do I worry about distances increasing? Tensegrities-- struts-- struts will force things to be expansive. If I want to model this picture, all I need to do is add a whole of struts. Let's go over here.

So we're going to prove this theorem in, like, five minutes-- easy. Once you build all this technology, which was existing, you can prove this theorem, once you realize this is the theorem you want to prove-- this expansiveness.

So what we're going to do is build a tensegrity. And it's going to have a bar for every edge of the given linkage. So that's just the same thing as we had given.

It's also going to have a strut between every other pair of vertices-- heck, every pair of vertices. It's kind of redundant for the bars, but every pair of vertices. That says that all pairwise distances must increase or stay the same.

So this is a tensegrity. What I want to prove is that this tensegrity is flexible. If I can prove that it's always flexible-- well, until the end, which is when everybody's straight or convex-- all the outermost guys are straight or convex-- then I'll have proved this theorem.

So while this theorem is about actual connectivity of configuration spaces, it says paths and cycles have connected configuration spaces. You get from everywhere to everywhere. It even gives you an algorithm for doing that, which we'll talk about next class.

We use just, is this thing rigid or flexible at all? And that's the power of all this rigidity stuff, just telling whether something can move a little bit, and then just doing that over and over again, you will be able to find that you can actually go all the way, and get to straight or convex. But how do we actually prove this thing?

So the point is, claim this tensegrity is infinitesimally flexible, meaning it is not infinitesimally rigid. And that will imply that there's at least an infinitesimal expansive motion. And then you have to use some fancy tricks-- not fancy, some tricks I don't want to talk about. You basically integrate that vector field, and that will give you an actual expansive motion.

Let's not worry about that. The interesting part is show that at least infinitesimally, this tensegrity moves a little bit. So what do know? Duality-- if I want to show not that it's rigid-- I want to show that it's flexible. But it's rigid if and only if this is true and this is true.

This will actually always be true-- the corresponding linkage is rigid-- because I put in every edge is in there. If I turn them all into bars, this thing's not moving at all. So fact, this second condition doesn't really matter.

What matters is the stresses. If I want to show that it's flexible, not rigid. I want to show these stresses don't exist. Now stresses always exist. I could set all the stresses to be 0.

But I claim actually pretty much all the stresses have to be 0, at least on the cables and the struts, which is what I care about here. They have to be 0. So this will be implied by every equilibrium stress is 0 on all struts and cables.

So you can never get this thing to hold for any of the struts and the cables. And therefore, in some sense, none of them are fixed, and therefore, you're actually flexible. That's implied by this duality statement.

OK, stresses are a little hard to think about. I prefer to think about polyhedral liftings, let's say. OK, the key here is to plug together all the right results. This will be true if and only if every polyhedron lifting is flat.

So I guess in our case, it will be 0, because the outside face sets all the z-coordinates to 0, so everything else will have to be in that plane. So all the z-coordinates will be 0.

So these are equivalent statements. All I need to prove is that every polyhedral lifting is flat. So we're going to prove this theorem by contradiction.

Suppose there was a non-flat polyhedron lifting. What could it look like? Did I just erase what I wanted? Probably.

Greater than or equal to 0 for cables, less than or equal to 0 for struts. That's the one I care about. Who cares about cables?

All right, so this is the stress. And equilibrium stress has to be less than or equal to 0 for every strut. Less than or equal to 0 corresponds to a valley edge or flat edge. Now in this linkage, almost all the edges are struts. There's a few that are bars, this, like, little path is a bar.

Those could be valleys or mountains. We don't know. But everything else has to be a valley or flat. For flat, we're good. We're happy. We want all the edges to be flat.

So how could it be that almost every edge in this picture is a valley? That seems a little tricky. And we're going to show it can't happen. If everything's a valley, something's going to go wrong at the top picture, because you've got to have mountains, like, turn around.

So let's look at the top. Look at the maximum z-coordinate. Now this could actually look like many different things, but I'm going to consider one case-- the easy case-- where you have, in the maximum z-coordinate, you have one point. And then around that, everything descends.

OK, these are all the edges incident to that point. You form some kind of-- OK, so this is maximum z. This is another plane. I'm going to slice that, which is maximum z minus epsilon-- slightly below the maximum z-coordinate.

And in a sort of typical case, we're going to get a polygon. Now note that this polygon has this nice property, that wherever it has a convex angle, you get a mountain here. Wherever you have a reflex angle, like this one, you get a valley edge here. You can see that 3-dimensional picture.

Every polygon has at least three convex vertices. That means there are at least three mountains incident to this maximum z-coordinate But mountains have to correspond to positive stresses. Positive stresses have to correspond to bars, because struts can't carry positive stresses.

So that means you have at least three bars incident to that edge. But I assumed I was maximum degree 2-- contradiction. Isn't that cool? It's very easy when you set it up right.

This works almost always, but there is another situation which can happen, which is, like, you have-- in the maximum z-coordinate you might have a couple of bars at the top. That's a worry. This is all in maximum z.

And so when you slice below, you don't actually get a whole polygon. You might actually only get something around here. But again, you can't get from here to around there without some mountain.

It's hard to even imagine, because it can't happen. But this is a mountain, and this is a mountain, and you want to somehow slope a surface below this plane, and get around to over here with only valleys-- ain't happening. You've got to have another mountain in here. And so that's the general picture.

And the only thing that can happen is you actually prove that all of this stuff has to be flat. So that's the one way it can happen. You can't have strict valleys, but you could have them all 0.

So in fact, the one case where you can have stress is when you have all of this outside stuff flat. And then inside you don't know. I can prove, using this generalized lemma, that all of these regions are locally flat. And therefore, this whole outside face has to be flat.

Therefore, I'm particular. I can't have a reflex vertex, because then this side would have to all be flattened. So then the whole thing is flattened. The only way the whole thing can't be flat is if your polygon is already convex, and then we're done.

Also straight this can happen. I think with straight, you don't get any stress. Here you can actually have a lifting. Actually, all these guys would be below the plane, because everything's a valley.

This would be like an actual valley, where you have a village or whatever. That can happen, but only when the boundary of your valley is convex. And so that proves the theorem. And that is the Carpenter's Rule Theorem.

Next time, we're going to talk about the other situations. This was two dimensions, and maximum degree 2. We can think about what happens with degree 3. Then you can get locked things.

What happens in three dimensions? Then you can get locked things. What happens in four dimensions? Then you can't get locked things, and other fun things like that.

Oh, and why is it called the Carpenter's Rule Theorem? Because this is a carpenter's rule. And in a carpenter's rule, actually, all the edge lengths are the same. But as far as we know that doesn't make this theorem any easier to prove.

And also in the carpenter's rule, you can have crossings, but other than that, it's just like a carpenter's rule. So there you go. So if you've never played with one, this is what people used before flexible measuring tape. They still use them a lot in Europe, but not so much in the US, but you can still buy them at the hardware store.

That's it.