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.
