Lecture 9: Communication Networks

• Download English-US transcript (PDF)

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

MARTEN VAN DIJK: So today, we're going to talk about communication networks. Communication networks is a great application of graph theory. So what we're going to study is, how do you route packets through networks? So you have the internet, which is a chaotic network. It's not organized. We are interested in highly structured networks and you can find them, for example, in parallel computers, where you want to route the data flow. You can find them in certain telephone switches networks and so on.

So we are going to talk about a few very special ones, binary trees, and then slowly we will figure out what all these performance measures really mean. This one has to do with latency. We have switches, their size, the number of them, congestion, and then we will slowly get down to Benes network, which is a really beautiful network with beautiful parameters. And we are going to prove those.

So let's start off with the first one, the complete binary tree, and let me draw it for you. In this network, we will have a root and let me just draw it first We have vertices that represent here the switches. So these circles-- let me explain it over here-- actually represent a switch.

And the idea is that these actually direct packets through the network. And these packets are fixed-size packets of data, so like, I don't know, say 4,000 bytes or bits or whatever the network wants you to comply to. So these are fixed-size pieces of data. So what we want is we want to be able from every terminal-- and the terminal I will denote by a square-- from every terminal, I want to be able to reach any other terminal.

So what is a terminal? A terminal is like a computer or something like that. It's actually the source and the destination of data. So what we are looking for is how can we route-- how we can find a network of switches that are connected through wires, fibers, or-- yeah? What's the question?

AUDIENCE: Can you move down a bit the top of the-- how it's getting cut off? No, the--

That one.

MARTEN VAN DIJK: Oh, sorry.

AUDIENCE: All right. Thank you.

MARTEN VAN DIJK: So what we want is we want to route packets that's come from any terminal to any other terminal. That is what our goal is and we want to make sure that that is efficient. So the first one is this binary tree. And let's see how this may work.

We may have switches that actually have inputs coming from terminals. And the switches may also output to terminals, so here at the bottom. At this site, we have a similar structure. this is the root of the tree. We have another switch over here. We go down, we go up here, and once more, like this. And again, we have-- oops. We have input coming in or an output coming out to their respective terminals.

So what is happening here is that I would like to have an input-- say input zero wants to travel all the way over to say, the output that is present over here. So let me label these. So we have the output zero, input one, output one, input two and output two, input three, and output four. So well, I can definitely reach every single output from any input so that's great.

So this looks like something that you are familiar with, right? It's just a tree. It's a directed graph, but these edges go in both directions, right? So I have an edge that goes from here to here and back from here to here. So this is the kind of layout that you could try out first to see whether this type of network would lead to good performance. So let's have a look at the different parameters and see how well this behaves. So here, we have a few parameters that we will be talking about.

So first of all, let's talk about the latency in this particular network. So how are we going to measure this? Well, we're going to look at this graph and we're going to measure it by the number of wires that you need to go through from an input to an output. So let me write this down. So the latency is the time that is required for a packet to travel from an input to an output. And how are we going to measure this? Well, we're just going to measure this by the number of wires that we need to go through.

So this you have seen before. We can measure this by the diameter of that particular graph. So here, we will define it for a network. So the diameter of a network is going to be the length of the shortest path between the input and output that are furthest apart. So let's have a look at the graph above.

So for example, we can clearly see that, for example, input and output-- so say, input zero and output one are connected by just going up one step over here, but just going up from here to here. Then, this switch forwards the packet to this switch. This switch reroutes it, forwards it over here, and then it goes back to the output, output one. So for example, this particular path only has 1, 2, 3, 4 edges.

And what we are interested in is sort of the worst-case time that it requires to go from an input to an output. So that means that we are interested in a diameter. And a diameter is in this case, well, the shortest path that you can find from an input to an output that are furthest apart. So what are those who are furthest apart?

Well, of course, you would like to go through here, right? So if I connect the input zero to say, output four, I will need to go all the way up through the route down to the output. And how many edges do we see here? 1, 2, 3, 4, 5, 6-- so in this example, we have a diameter that is equal to six.

And in general, if you are looking at n times n networks, what does it mean? n is the number of inputs and n is also the number of outputs. So in this case, we have a four times-- well, this is actually three over here-- we have four inputs and four outputs. So this particular example depicted on the board is a four times four network.

So if you generalize this for any size binary tree, say, an n times n network, then what's the diameter of such a general network? Well, if we have n inputs and n outputs, well, we have to go all the way up through towards the root and all the way down. So we actually count the length of a leaf to the root here twice. So in general, we have a diameter that looks like this. It's 2 times 1 plus the logarithm of n.

So in this lecture, we will have n is going to be a power of 2, just to make calculations simple. And the logarithm is always to the base two. So this is a diameter of a general binary tree.

And well, what are the other parameters? So that does not look too bad. It's logarithmic in answer. That sounds pretty good. What about the switch sizes? Well, how do I measure those? It's like the number of inputs that get into it and the number of outputs that get out. So in this case, I will have 1, 2 inputs that go into this switch and there are two outputs coming out. So this is what we call a two times two switch. So this will be a two times two switch.

But if you look at this one, for example, we see one, two, three outgoing edges and three ingoing edges. So this is actually a three times three switch. And in a general binary tree, we will see that all these intermediate nodes over here, they are all three times three switches. So approximately half of the switches are actually three times three switches. So that's the switch size.

Now, you may say, well, why don't I use a larger-sized switch? That would help me a lot, right? If I could use, say, a four times four switch, then I would be able to have more inputs coming in, more outputs coming out, and I can actually maybe use a ternary tree rather than a binary tree. In a binary tree, every note at the level has two children, right? But we could design a tree that has at every level three children. So then, they can use four times four switches.

But if you do that, then the path from the leaf up to the root is getting shorter and the diameter gets smaller. So if I increase the switch size-- so rather than three times three, we look at four times four or five times five, six times six and so on-- then the diameter will actually reduce. So what about having a monster switch, like I have just one switch and I have my input zero all the way up to input n minus 1 and then I have my outputs on the other side?

Well, of course, the switch size is n times n but the diameter is nothing, right? The diameter is reduced to one. You can immediately go from an input to an output through the switch. But this, of course, conceals the problem. So what we are interested in is, well, we're actually really interested in how to solve the problem of routing all these inputs to these outputs using smaller switches of size three times three or two times two.

What we're really interested in is, what is the internal structure in this monster switch? I sort of have concealed the problem by just saying, oh, I've got a big switch. But what we want to solve today is how do we do the routing in this case within the monster switch? So we want to use just small switch sizes and build up a network using these smaller ones, like three times three switches or two times two switches.

Now, so that brings us to yet another parameter, because here, we'd like to count the number or smaller switches that we use and that relates to the cost of the network, the amount of hardware that you need to put into it. So in this example, we have the switch count. Well, it's pretty simple, right? It's 1, 2, 3, 4, 5, 6, 7-- we have seven switches.

And in general, if we have n inputs-- so 1, 2, 3, 4 inputs-- then the number of switches that we use in the binary tree is 2 times the number of inputs minus 1. So let's write that down. So over here, we would have 2 times n minus 1, which is the number of switches that you actually use.

So how can you see that actually? So in general, we have 1 plus 2 plus 4 plus 8 and so on plus n. And it's a power of 2, according to our assumptions. And if you add them all up, I think you'll-- well, you can check for yourself that this is actually equal to 2 times n minus 1.

So now, we have the switches. So so far, this looks pretty good, actually. We use small switch sizes. The number of switches is linear in n. The diameter is logarithmic in n so that sounds good.

So what about congestion? Do you any idea-- what's the problem with this graph? What is the big, big problem here? What can happen in a very sort of worst-case scenario where the packets get routed from inputs to the outputs? If they need to go to certain locations, then they all may have to travel through the root. So you get congestion over here. We don't like that. So this root is actually then overloaded.

Actually, you can already see that say, this particular switch-- if this switch fails, then actually, we will have two disjoint trees that cannot even communicate to one another. So this brings us to the idea of congestion. And in order to define it better, you will need a few definitions.

So to start, we will define a permutation and we will use this to stipulate the requirement that we want on how inputs and outputs are related to another, which input needs to communicate to which output. So permutation is a function pi from the set 0 to n minus 1 to the same set. And it is such that no two numbers are mapped to more than once. So no two numbers are mapped to the same value. So what we really want-- to put it in mathematics, we want that pi of i is only equal to pi of j if and only if i is equal to j.

So let's have an example to plug into that picture over there. So a first example could be pi of i equals, say, n minus 1 minus i. This is a proper permutation. No two numbers map to the same value. Another one could be the identity permutation, like you map i to the same i. So that's another example.

Now, how do we use permutations to go towards the idea of congestion? So permutation can be used to formulate the permutation routing problem. And the permutation routing problem is defined like this. It's defined as follows. What we want is that for each i, we want to direct the packet at input i to output pi of i. So you want to do that for all i.

So let's have a look at this particular example, where we look at identity permutation. So if you do that, we can easily route this, right? So I want to send a packet from input zero to output zero. So I can simply go into this direction. I just go towards this switch and it gets routed back to this one. I can go like this and this one can go like this and this one goes like that.

Now, if you look at the other permutation, the picture looks very different. Now, we want to route input zero to output three. In order to do this, I will actually need to go all the way through here and then all the way down to this particular output. And now, the picture gets into a big mess because for input one, we have to go to output two. So for input one, well, we go all the way like this, we again go through the root, and then we go down to this particular output.

And as you can see, for input two, well, we need to connect to output one. So again, we go all the way up and we go all the way down. And for this one, we will again go all the way up and all the way down to input zero. So now, you can see that this particular switch over here has to serve packets from all the inputs. All the four packets have to travel through this particular node here. So this leads us to the following definition of congestion.

So the congestion-- oh, before we continue, let me first define a path. So for i, we direct a packet at input i to output pi of i. And the path that corresponds to this route is actually denoted as follows. So the path taken is denoted by P i pi i. So now, we can define the congestion of a set of such paths. So the congestion of the path corresponding to P zero to P pi zero and so on and we go all the way up to the n minus 1 input that needs to be mapped to pi of n minus 1.

So the congestion is now defined as the largest number of paths that pass through a single switch. So in our example, we saw that in the case of the blue arrows here for the identity permutation, well, this switch only needs to transmit one packet and all those actually zero packets. So actually, the congestion here is equal to 1. And for this particular permutation, well, we had to direct all the packets through the root and it's the most accessed switch. And that switch has congestion four, right? So the congestion over here is equal to 4.

Now, this does not look so good because for a binary tree, we always have this vulnerable root that is right here in the center connecting the left side to the right side. So we can always find a permutation-- actually, this permutation over here-- that leads to this worst-case congestion. So what we're interested in is the maximum congestion, which is sort of the worst-case scenario. And we'll define it as follows.

The maximum congestion is actually equal to the maximum over all permutations pi. So this is kind of the worst-case routing problem that I can imagine and it may occur in practice. So in the worst case, how can I solve it the best? So I want to find the minimum of the congestion of a path over here and the minimum is over these types of paths. So actually, this is our solution to this routing problem. We want to find the best kind of solution for this worst-case scenario-- so the minimum over all solutions for these paths

So well, for this particular tree structure, this permutation is really the worst-case scenario that you can have because every packet needs to be routed through the center over here. And it means that our maximum congestion for an arbitrary tree is actually equal to n. So that looks really bad, actually. So we don't like this at all.

So let's find out where we can do a little bit better and we come to look at the two-dimensional array and see what that would lead up to. And its structure is as follows. We essentially have inputs on the left and the outputs are on the bottom and they are in a grid structure. So we have input zero, input one, input two, input three. They all connect to their terminals. We have switches, four of those, and they are all connected in this grid.

And at the very bottom, we will have the outputs, the output terminals. So this is output zero and here, we will have output one, output two, and output three. So notice that my circle start to resemble my squares, but these are all the switches right here in the center.

So how does this work? Well, do we have a better parameter? So let's look at it together. So we need to first of all figure out what the diameter is. So what's the diameter of this particular network? So what's the shortest path between the furthest input and output? So if you look at that, we can see that if I go all the way from here and I go all the way down to this corner, that looks like the largest path and I need to cross all these wires. And in general, for any n, we will have that the diameter is 2 times n.

Now, what about the switch size? It looks a little bit smaller, right? Because over here, we had three inputs coming in and three outputs coming out but over here, we see that every single switch is only two inputs and two outputs. So that makes the size two times two. Now, the number of switches is pretty bad, right, because we have n squared switches. So that's really horrible. That's a lot. We would like to do much better.

And what about the congestion? Do you have any idea what the congestion could be in this particular case? We will prove a theorem on that. For any permutation, is there a way to route the inputs to the outputs in such a way that the switches get almost not congested? So in the binary tree, we had a congestion of n, which is linear in the switches.

But over here, we can do much better. We will show that the congestion of an n-input array is actually equal to 2. So that's great. So I'll prove it in a moment, but that looks really fantastic. And so it's way better than the binary tree.

Now, this is really not so good and this is also much larger, but still-- we will start to think next after we show this particular property how to combine these two and see how we can come up with another network that's able to combine in some ways these two properties. And maybe we can find a good solution that way. It turns out we will not immediately be able to do that. We will need to make another step and come to the last network. It really has good parameters.

So what about the theorem? So if you prove this, well, how do we start? You just start with any permutation. If I want to prove something about the congestion, it's defined as the maximum of all permutations. So let's take one of them and see what we can prove.

So let us define the paths for this permutation. So what we really want to do is we take any permutation and we want to find a really good solution for the routing. If that gives us a very low congestion, we are very happy. So the way to do this is well, maybe you have an idea already. So how would I route this? So I want to connect an input i, say, 1, 2, output two, for example. How can I do this? Any suggestions? So of course, I could go any path, but somehow, I want to have some uniform structure that hopefully helps me to prove that the congestion in every switch is very small.

So how could I think about this? Well, if I make sure that, say, a packet that goes from one to output two is only going to be participating in the wires off the i-th throw and the P-i-th column, then I know that every wire will only get traveled over twice by a packet. This could either be a packet that goes into this direction or-- so a switch will be accessed at most twice. A switch can either receive a packet from this direction or receive a packet from the upper part. So that will be a really good idea. So let's define that.

So we say that in our solution, we will design it such that the path from input i is actually going to be rightward to column pi i and then downward to the output-- so downward to output by i. So this is a really good solution to the routing problem because now, we can continue our proof as follows.

We just say, well, if you look at the switch in row i and column pi i, well, this one actually transmits at most two packets because a packet can only come from the left or it's going to go from the top. So either one of the two-- at most, those two packets will go through the switch. So this shows that we have a congestion of at most two for any permutation.

And in order to prove equality, because that's really what the theorem says, we also have to show that there exists a permutation that achieves a congestion of two. And that is pretty straightforward. We can, for example use a specific permutation that maps zero to zero and maps n minus 1 to n minus 1.

Well, for this particular permutation, when we look at the picture over here, we see that input zero needs to go to output zero. We also see that this lowest input, input three, needs to travel all the way up to here. But it's clear that the packet that needs to go over here needs to travel through that switch in the lower left bottom corner. And the input three also needs to travel through that. So here, we clearly see that we you have a congestion of two.

So now, the proof is complete because we have shown this upper bound. So for any permutation, the congestion is at most two and we see that this specific permutation achieves this congestion. So this is the end of this proof. So that's great. So now, what we'd like to do is we'd like to combine these two networks and see what we can learn from both. So now, we'll be taking out a lot of chalk over here.

So the idea is to construct a butterfly network and I will draw it in such a way that you can see the recursive structure. The idea is to do the following thing. So let me see how I can do this the best. So I will just do the top line first and I have the spacing. So we have input zero, a terminal, we have a switch, we have a switch, we have a switch, and another one, and here, we have the output zero.

So the whole idea is that I'm going to combine every two outputs by using a small butterfly structure. So we have two, output three, output four-- actually, I need a little bit more space. Do it once more, output one, two, three, four, five, six, and a last one, seven. This is going to be pretty tight on the board.

So what's happening is this. So these are all connected, of course, to switches. The switches output those. And the idea is that we create the following structure. This switch can either forward it over here or it can cross it over to this particular line. And this switch can either forward it or cross it over to this line. So this is a very small butterfly structure. Here, we have two inputs and two outputs. And we will repeat this process and we'll do the same on each of these other levels. So we forward those or we cross them, like this.

And now that we have constructed all these smaller butterfly structures, we can start to combine two butterfly structures together in the bigger one. So here, we had two outputs that we combined in a butterfly structure. Now, we use two butterfly structures that we put into a bigger version. So how do we do this? Well, we have that the upper half over here can either forward those packets or cross them over to the bottom part butterfly structure.

So for these, we can either forward them straight on or we can go to the top butterfly. So you see that these two inputs, these two switches, either can forward packets to this sub-butterfly network or to the top butterfly network. Now, we'll continue this process and for these, you'll do the same. So we can either go straight or we go down. And over here, we can go straight or we can go to the top butterfly network.

Well, now we have the final part where we combine essentially these two butterfly networks. We have two butterfly networks created here now composed again of smaller ones and these two are being composed to this bigger butterfly network. Again, we take these four switches. They can route their packets forward to the top butterfly sub-network or to the bottom one.

So they can either go straight ahead or this one can connect to the first over here, this one to the second, to the third, and this to the fourth. And in the same style, these can forward them straight like this and then go up like this. And these are all connected because in this example, let's just have an eight by eight network, butterfly network. We have input zero to seven.

So this is the butterfly network. In a way, what you can see here is you can see sort of the two-dimensional structure, like we have rows and columns. At the same time, we can also see this binary sort of tree feeling we get from it, which is that a switch can forward sort of its packets to either, say, the top butterfly or the bottom butterfly. So there's a split in two. The same for this one, right? This one goes either to this butterfly network or it goes to this butterfly network. So you have this tree structure sort of embedded in this two-dimensional structure.

So what are the properties of this one? So let me first define in more formal mathematics how the switches route their packets, so how the connections are. So in order to do that, we are going to label each switch. And the idea is that we're going to label it by its row and by its column.

So we will have-- the columns are numbered by level zero, level one, level two, level three, yes? And the rows are these integers, but we are going to represent them by binary numbers. So zero would be 000, 001, 010, 011-- oops-- 100, 101, and then we got 110 and 111.

So for example, this particular switch would be labeled by these three bits, 001, and the integer number, 1. This one would be 011 and its column is indexed by integer 2. So a switch is uniquely identified by its row and column. We will have b1 up to b logarithm of n, which are the number of bits to represent the row in digits, and to finally have an integer l and this we will call the level.

So this particular switch either directs or routes a packet to the switch that is indexed by b one up to-- and then we get b, l plus 1 and we take its complement. So instead of if b, l plus n would be 1, we would have a 0 here. If it would be a 0, we will have a 1 over here. But we repeat all the other bits and we get to b log n. And it routes us back to the next level. So we will have l plus 1.

Another possibility because there are two outgoing edges is if we have just b1 and we just copy b, l plus 1, essentially. We route a packet straightforward. We don't do anything special. We get b log n over here and then to the next level. So for example, let's see where we can see how this works.

So for example, take this particular switch. We have 010. So it can either go straight on to the next level. It would go to 010 but then instead of level one, we have level two, which is the right edge over there. The other one is if this one goes up, well, we will need to switch the first bit over here, a 1. We swap it into 0 and then we go to the three zeros over here and we go to the next level and that would be this particular rule.

So what we can do here is to-- so when we see this, we can start to figure out how we can direct inputs to outputs. So let's do this. So suppose I want to route a packet from a certain input, one of these, all the way to one of the outputs over here. So the way to do this is as follows.

We can just start-- for example, I want to go from switch x1 up to x log n comma 0. So I start completely at the left over here and I want to go somewhere of my choice to the right. So I want to somehow move all the way to some other row, y1 indexed by y by the bit pattern, y1 up to y log n, but now at the very last level, which is log n.

Well, how do I do it? Well, this switch, I can use that rule up there and simply change x1 to y1. I can either leave x1 as it is if it's the same as y1 or I can swap it to its complement if that's the value of y1. So what I can do is I can just simply route it to y1. And then, I leave all the other bits the same, which are x2, x3, all the way up to x log n. And we will have reached the first level.

Now, this one can go to-- well, now I'm going to swap the second bit into the bit of my choice. So I leave all the other bits the same, y1 the same, x3, all the others the same. I just swap x2 into y2. So we leave all those equal and we go to the second level. And then, we go all the way to the final level and we one by one swap all these bits.

So let's have an example. Suppose I want to connect, let's say, this one to for example, well, let's say this particular output. So what's the binary for this one? This is actually 101. So if the first bit is different, I need to cross. And otherwise, I need to pass straight on. So let's do this. So over here, I'm in 011. I need to go to 101 so we need to change the zero into a one. So I need to go down. I need to cross.

Now, if I look at the second bit, I also need to change it to a zero so again, I need to cross, which is over here. Now, the third bit is equal to 1 and it's the same. So now, I can go straight ahead. I do not cross and I end up at this output. So what did I do? For every bit that is different, I cross and for the bits that are the same, I go straight ahead. So this is how I can route packets from one input to another output.

So let's look at the parameters. First of all, if you look at the diameter, well, it turns out that that's approximately equal to the number of levels, which is the logarithm of n. And to be precise, it's actually equal to 2 plus the logarithm of n. So that's great. That's a good scaling. Again, it's back to the logarithm of n. So we have the best of these two parameters.

The switches that we see have two inputs and two outputs. So we again have a two times two switch. The number of switches is the number of rows times the number of columns. The number of columns is the logarithm of n and number of rows is equal to n. And to make it a little bit, precise, it's 1 plus the logarithm of n. So that's somewhere in between those two. But if you're thinking about it, it's much better than n squared. It's almost linear except for a logarithmic factor.

For the congestion-- and we are not going to talk about it here, but you have a problem set assignment that will ask you to solve this-- is that actually, the congestion is the square root of n or it's equal to the square root of n over 2, depending on whether n is an even power or n is an odd power. Now, we're not going to prove that here because we want to step forward to this particular network. It's very exciting. And you will prove this in your problem set.

So this one is somewhere in between, somewhere in between these two extremes. Now, it will be really fantastic if we can somehow transform this network with a trick to, again, have a really great congestion of just a constant, like two or three or whatever or maybe even one.

So for this particular network, in the 1960s, Benes, a Bell Labs researcher, had the great idea to use a butterfly network and attach to it, again, a butterfly network, back to back sort of.

So what was his idea? His idea was to do the following. So the butterfly network as we have it right now is this particular part over here. And the idea is now to start up mixing all those outputs that we got here together again using a similar rule.

So what do we do? We are going to essentially repeat this particular structure on this side. So how do we do it? Well, we go either straightforward or we start to mix them again. So it's like this output, this particular switch, can either go straight ahead or can cross to the lower part over here. It goes over here and this one goes over.

So as you can see, we have repeated this part. It's exactly the same as this structure over here. We'll do the same for this part. So we can either cross or we can go straight ahead. Oh, we also have, of course, that these switches can go straight ahead or can cross to the top. I forgot about that. So we have this-- oops-- as well. So as you can see, this particular structure repeats itself again and we slowly start to build up in mixing all the outputs again or the possibility, at least, to route them to any other row.

So how do we do this? Well, we continue this particular structure now over here. So all these can either go straight ahead. That's a possibility. Or they can go all down. So this switch can either go straight ahead or can go to the lower half. And for these, we have a similar structure. We can either go straight ahead or such a switch can cross over to the top over here.

So that's this. So this is Benes network and then over here, of course, we have the outputs, zero, one, and all the way down to seven. So as you can see over here, the structure again has a recursive nature to it.

You can see that this big Benes network over here consists of two smaller ones that are right here in the middle, this one that goes all the way up to here-- so maybe I should put a color boundary around it. Let me check I want to do this-- right. So this particular part, is again a Benes network and the top part in the same picture, the top subnetwork is also a Benes network, this part.

And if you look within those, we again see a top part and a bottom part. And over here, we see a top part and also a bottom part. So you see this recursive nature again reappearing. It turns out that with this trick, we can completely eliminate congestion and we can get it to only one, which is really surprising. And that what we're going to prove here. So this is a great invention at the time. It's really, really beautiful.

So let me put in the other parameters. So they stay approximately the same up to that the diameter is about twice as large because we added another sort of whole butterfly structure to it. The switch size stays the same. We, again, have about two times more switches so they sort of stay about the same up to a linear factor, like a constant factor. And the congestion, however, completely dropped down to one.

So that's what we're going to prove now. And in order to get some intuition, well, let me first write down the theorem. Actually, let me put this over here. So in order to get some insight into this, we are going to use this recursive nature. So we're going to use induction and we're going to say, oh, for any permutation, I can find really good routing for say, this red subnetwork and for this blue subnetwork. So I know that.

So what I need to do is, if I have my bigger Benes network, like this one, I would need to somehow map these inputs-- I need to route them to either the top and the bottom subnetwork, one of the two, in such a way that there will be absolutely no congestion, because we want to keep this one. So a switch should only see one packet coming in. So that means, for example-- and we'll come back to that-- that for example, for this switch, it should not receive a packet from both this input and from this input.

So the intuition that we are going to create is we're going to list our constraints, the constraints that we need to satisfy, like the zero and the fourth input should not both be mapped to this top subnetwork and so on. So we will get into that and then we will gain a lot of intuition on how to solve this.

So what's the theorem? So the theorem is that the congestion of the n-input Benes network is actually equal to 1. And we will prove this for n equal to a power of 2. We have assumed that at the start that we had with all the other networks, as well. And in this case, we will use induction on a. So that's the method that we will do because that's also the recursive structure of the Benes network itself. So we will use induction on a and we are going to define the induction hypothesis simply as, "The theorem is true for a."

Now, let us do the base case. We always start with the base case and that should be pretty easy because this is the most basic Benes network. So n equals 2 to the power of 1. We essentially have two inputs, an input zero and an input one. They are connected to these switches over here that can either forward them or can cross them over and then they go directly to the output.

Notice that in this case, we just have the most elementary butterfly network. It's the same. So we have output zero and output one. So this corresponds in this picture to these little small things over here, this one and this one and this one over here and the fourth one over here. So now, let's take any permutation. We want to show that we can route it in such a way that there's only a congestion of one. So let's do this.

So there are essentially only two permutations. Either zero is mapped to zero and one is mapped to one or zero is mapped to one and one is mapped to zero. So in both cases, we can just route them through their own switches. So we have that either pi of 0 equals 0 and pi of 1 equals 1, in which case we just direct them straight through and we go straight through and every switch only sees a packet once. So for this particular permutation, we have a congestion of one.

Now, the other permutation that we can have is if zero is mapped to one and if one is mapped to zero. Well, in that case, we just route this cross over to the bottom row and here we go from this switch to the top row. Again, every switch only sees a packet once. So in this case, in the base case, we are done. We are happy. We have shown that the congestion is equal to one.

So now, it gets to the harder part because for the inductive step, we are going to assume, of course, that it holds true for a smaller Benes network. So we assume that P a is true and well, let's try to gain some insight here. So we know from our induction hypothesis, within each subnetwork, we can solve any routing problem with congestion one and for this subnetwork, the same. That's our induction hypothesis.

So how do we go ahead? We need to somehow map these inputs according to the permutation of our choice. So that could be for some input zero goes to output five or input one goes to output two, et cetera. So somehow, we need to choose where we are going to map this particular input to. So packet zero that comes from this input should either go to the red network or it should go to the blue network. And for each of these inputs, we can make such a choice. But we have to be very smart about it because we need to avoid any congestion.

So the intuition is that we're going to set up a constraint graph, a graph that represents all the constraints that we need to satisfy in order to achieve congestion of one. So let's do an example so that we can figure out what's going on. Actually, let me put it over here. So just take an example permutation and we'll go through this example and then see how the proof works.

So let's as an example have pi of zero maps to one, pi of one maps to five, pi of two goes to four, input three goes to seven, four maps to three, five to six, six to zero, and seven to two. So this is just an arbitrary permutation. So what do we see? We want to make sure that, for example, this switch is only seeing one packet. So it cannot see a packet both coming from input zero as well as from input four. I cannot see that. I do not want that to happen.

Similarly, for this one, I do not want to see a packet coming from one or one from five. So let me define a constraint graph that sort of represents this. So the constraint graph that we are interested in is defined as follows. If two packets must pass through different networks, subnetworks-- so in our case, the red and blue subnetwork-- then we'll actually have an edge between those two. So then, there is an edge between them. So for this example, we're going to set up this constraint graph.

So I was just talking about this particular switch. It cannot see one coming from four and a packet from zero. So what he have, we have an edge between zero and four. In the same way, we have an edge from one to five. Why? Because a packet that comes from input one and a packet that comes from input five cannot both be routed through the switch because then the switch would see two packets and then the congestion would not be one, but two, right?

So one and five also have an edge in between. And in the same way, we have two and six and seven and three. So two and six is this constraint, like two and six over here. And three and seven is the other constraint. So if I have those constraints in place, well then, I know that the routing that goes from level zero to level one will not violate my congestion of one. So that's great.

Then, I hope to be able to use the induction hypothesis and I get a proper routing within the red subnetwork and one within the blue network. And then, I need to map all these to these outputs. So I also have constraints on these outputs because, well, For example, take this particular switch. It should not see a packet coming from this particular one and one from this one. So how do I code that up?

So let me first write out what we did here and then we'll do the same for the last level over there. So-- oh no, that's not really necessary. So at the output side over here, we have similar constraints as we did over here. And in this particular example, just as an example, suppose we look at the packet that is destined for output zero.

Well, what is this packet? Well, I know that's pi of 6 is equal to 0, according to my example. So packet six is destined for this particular output zero over here and goes through this particular switch. So this packet and also the packet for output four, which is if you look at the mapping, pi of 2 is equal to 4. So that's packet number two. Well, both of these packets cannot pass through the same subnetwork.

So why is this? So let's look at this particular example. So output zero, well, comes from packet six, somewhere over there. Now suppose packet six was routed through the red network and at the same moment also, output four-- the packet that is destined for output four, which is packet number two-- suppose packet two was also going through the red network.

Well, then I notice that both of these packets must arrive at this particular switch in order for one to be routed to output zero and the other one to be routed to output four. So in order to avoid congestion in this particular switch over here, we need to have a constraint. The constraint says that the packet for packets two and six, that those two cannot go through the same subnetwork. So essentially have another edge over here-- we already had the constraint but it's just the same edge. So let's look at the other constraints that we have.

Well, let's look at a different example. So for example, if I look at this switch, well, if a packet goes through here that needs to end up at one and a packet that's goes to five, if those two packets are routed through the same red subnetwork, they have to end up here in order to go to both here and to there. So we have congestion of two. So what are those packets? Well, what does pi map to to one and five?

Let's look over here. We see that pi 0 is equal to 1 and pi 1 is equal to 5. So packets zero and one are actually mapped to output one and five and they should not go both through the same subnetwork. So we have another edge over here. And now, we can continue this and we have five and seven. So just have a look over there. See, five and seven, they map to the outputs two and six. Again, we have two and six. If they are both mapped to the same network, this one, for example, then I will have a problem. So the other edge is over here.

So what did we do here? We started to write out the constraints on this side and we wrote out the constraints on this side. So I only looked at the red subnetwork. That's what I realize now. I could also have looked at the blue network. So let's do that also just to make the picture complete. So for example, let's look at this particular example. The packet six and two should not both be routed through the blue network because then they would both have to go through this switch, one going up to output zero and one going to the right to output four.

So in order to avoid congestion at all costs, we have this constraint graph. So now, we come to the key insight. And the key insight is to use a two-coloring of this graph. So the key insight is a two-coloring of the constraint graph, which will lead to a best solution for the routing problem. So let's do this.

So we will color this one blue. As you can see, this is an even cycle, blue, red, blue, red, and blue and red. We will make this one blue and this one red. Well, it turns out that we can now start our routing process. So for example, actually, I will draw a new graph to make that really clear. So I have my blue and my red chalk over here to demonstrate what I mean.

So what do I do? I have zero, one, two, three, four, five, six, and seven. I have the switches that correspond to those. Well, if it's colored red-- so zero over here is colored red-- I will direct it to the red subnetwork. So where is this red subnetwork? It's really contained over here and the blue one-- so this is the red one and the blue one is right here. And over here, we have the outputs ranging from zero, one, two, all the way to seven.

So input zero is colored red. We go straight ahead. We want to go to the red network. Input one is colored blue. It goes, therefore, to the blue network. So this is the only way how to do it.

Input two is colored red. Go straight ahead. Input three is also colored red. Go straight ahead. Input five-- oh, input four is colored blue-- goes to the blue network. Input five goes up to the red network and input six goes straight ahead to the blue network. It's colored blue and input seven is also colored blue.

Let's look at the outputs. So for example, well, let's have a look at output zero. so output zero-- which packet is mapped to output zero? It's packet number six. So six was mapped into the blue network and then it needs to be mapped to output zero. So there's only one edge that goes from the blue network to output zero, which is this particular one. And then somehow, this one needs to be mapped to this one over here.

Now, we can continue like this. Output one should receives a packet from-- let's look at the permutation-- from five. No, sorry, output one-- pi of 0 is equal to 1 so packet zero needs to go to this particular output. Now, packet zero is in the red network so there's only one edge that goes from the red network to this output. So we need to have a connection over here.

Now, we can continue this and note and demonstrate-- and you can test it for yourself, too-- that output four needs to receive a packet from the red network. Actually, it should be this particular one, which happens to be packet number two. And then, we have this one, right?

So let me just finish it. We have this and we have these two and we have this one. We have this one and we have this one. This one goes straight ahead. This one goes all the way up and this one goes all the way up.

So what do we see? We see that packets over here, that these switches only see a packet once and these ones, as well, these ones also and these ones also. So we have directed the packets, routed the packets to the red and the blue subnetworks in such a way that the congestion at the last level and at the first level is still equal to one.

Now, we use our induction hypothesis and we conclude that we can map the route that's going to have a routing from packets from here to here such that the congestion within the subnetworks is only one, so within the blue as well as in the red. So this is the insight into how this works and I notice I am running out of time. So the formal proof we will have to postpone until recitation, but that's actually really a very simple thing to do that right now.

So just keep this key insight and then you can easily prove the theorem. But this is the real insight. Thank you.