So the goal of this video is to prove the correctness of Kasaraju two-pass,
depth-first-search based, linear time algorithm that computes the strongly
connected components of a directed graph. So I've given you the full specification
of the algorithm. I've also given you a plausibility argument of why it might
work, in that at least it does something sensible on an example. Namely, it first
does a pass of depth first search on the reverse graph. It computes this magical
ordering. And what's so special about this ordering is then when we do a depth first
search using this ordering on the forward graph; it seems to do exactly what we
want. Every indication of depth first search to some new node discovers exactly
the nodes of the strong component and no extra stuff. Remember that was our first
observation, but that was unclear whether depth for search would be useful or not
for computing strong components. If you call depth first search from just the
right place, you're gonna get exactly the nodes of an SCC and nothing more. If you
call it from the wrong place, you might get all of the nodes of the graph, and get
no information at all about the structure of the strong components and at least in
this example this first pass with the finishing time seems to be accomplishing
seems to be leading us to invoking DFS from exactly the right
places. So remember how this worked in the example so in the top graph, I have
shown you the graph with the arch reversed. This is where we first invoked
DFS loop with the loop over the nodes going from the highest node name nine all
the way down to the node name one. And here we compute finishing time that's the
bookkeeping that we do in the first pass so we just keep the running count of how
many nodes we've finished processing. That is how many we've both explored that node
as well as explore all of the outgoing arches and so that gives us these numbers
in the red, these finishing times between one and nine for the various
nodes. Those became the new node names in the second graph and then we reverse the
arches again and get the original graphs back and then we saw that every time we
invoked DFS in our second pass we uncovered exactly the nodes of an SCC. So
when we invoked it from the node 9 we discovered that 9, 8 and 7 those
have a leader vortex 9. Then when we next invoked DFS from 6, we discovered
6, 5, and 1, and nothing else. And then finally we invoked it from 4, and
we discovered 2, 3, and 4, and nothing else. And those are exactly the
three, SCCs of this graph. So let's now understand why this works in any directed
graph, not just this, in this one example. So let's begin with a simple observation
about directed graphs, which is actually interesting in its own right. The claim is
that every directed graph has two levels of granularity. If you squint, if you sort
of zoom out, then what you see is a directed acyclic graph, of course
comprising its strongly connective components. And if you want, you can zoom
in and focus on the fine grain structure with one SCC. A little bit more precisely.
The claim is of the strongly connected components of a directed graph induce in
a natural way an acyclic metagraph. So what is this metagraph? What are the nodes
and what are the arcs, what are the edges? Well, the metanodes are just the SCCs, so
we think of every strong connected component as being a single node in this
metagraph. So call them say 'C1' up to 'Ck'. So what are the arcs in this metagraph?
Well, they're basically just the ones corresponding to the arcs between SCCs in
the original graph. That is, we include in the meta graph an arc from the strong
component 'C' to 'C-hat' if and only if there's an arc from a node
in 'C' to a node in 'C-hat' in the original graph 'G'. So for example if this is your 'C'
and so the triangle is your 'C-hat' and you have one or maybe multiple edges going
from 'C' to 'C-hat', then in the corresponding metagraph your just gonna have a node for
'C', a node for 'C-hat' and the directed arch from 'C' to 'C-hat'. So if we go back to
some of the directed graphs that we've used as running examples so we go back to
the beginning of the previous video and it's look maybe something
like this the corresponding directed acyclic graph has four nodes and four
arches. And for the running example we used to illustrate Kosaraju's algorithm with
the three triangles, the corresponding metagraph would just be a path with three
nodes. So why is this meta-graph guaranteed to be acyclic? Well, remember
metanodes correspond to strong components, and in a strong component you
can get from anywhere to anywhere else. So, if you had a cycle that involved two
different metanodes, that is two different strong connected components,
remember on a directed cycle you can also get from anywhere to anywhere else. So if
you had two supposedly distinct SCCs, that you could get from the one to the
other and vice versa, they would collapse into a single SCC. You can get from
anywhere to anywhere in one, anywhere from anywhere in the other one, and you can
also go between them at will, so you can get from
anywhere in this union to anywhere in the union. So not just in this context of
competing strong components but also just more generally, this is a useful fact to
know about directed graphs. On the one hand, they can have very complex structure
within a strong components. You have paths going from everywhere to everywhere else,
and it may be sort of complicated looking. But at a higher level, if you abstract out
to the level of SCCs, you are guaranteed to have this simple DAG, this simple
directed acyclic graph structure. So, to reinforce these concepts, and also segue
into thinking about Kosaraju's algorithm in particular, let me ask you a question
about how reversing arcs affects the strong components of a directed graph. So
the correct answer to this quiz is the fourth one. The strong components are
exactly the same as they were before, in fact the relation that we described is
exactly the same as it was before so therefore the equivalence classes of the
strong components is exactly the same. So if two nodes were related in
the original graph, that is a path from U to V and a path from V to U, that's still
true after you reverse all the arcs, you just use the reversal of the two paths
that you had before. Similarly if the two nodes weren't related before, for example
because you could not get from U to V, well that after you reverse everything,
then you can't get from V to U, so again you don't have this relation holding, so
the SCCs are exactly the same in the forward or the backward graph. So in
particular in Kazarogi's algorithm, the strong component structure is exactly the
same in the first pass of DFS and in the second pass of DFS. So now that we understand
how every directed graph has a meta graph with the nodes correspond to a strong
connected components, and you have an arch from one SCC to another if there's any
arch from any node in that SCC to the other SCC in the original graph, I'm in a
position to state what's the key lemma. That drives the correctness of Kosaraju's
two pass algorithm for computing the strong connected component of a directed graph.
So here's the lemma statement. It considers two strongly connecting
components that are adjacent, in the sense that there's an arc from one node in one
of them to one node in the other one. So let's say we have one SCC - 'C1', with a
node I, and another, SCC 'C2' with a node J, and that in G, in the graph, there's an
arc directly from I to J. So in this sense we say that these SCCs are adjacent, with
the second one being in some sense after the first one. Now let's suppose we've
already run the first pass of the DFS loop subroutine. And remember that works on the
reverse graph. So we've invoked it on the reverse graph. We've computed these
finishing times. As usual we'll let f(v) denote the finishing times computed in
that depth first search subroutine on the reverse graph. The lemma then asserts the
following. It says first, amongst all the nodes in 'C1' look at the one with the
largest finishing time. Similarly amongst all nodes in 'C2' look at the one with the
biggest finishing time. Amongst all of these the claim is that the biggest
finishing time will be in 'C2' not in 'C1'. So what I wanna do next is I wanna assume that
this lemma is true temporarily. I wanna explore the consequences of that
assumption and in particular what I wanna show you is that if this lemma holds, then
we can complete the proof of correctness of Kosaraju's two-pass SCC computation
algorithm. Okay, so if the lemma is true then after... I'll give you the argument
about why we're done. About why we just peel off the SCC one at
a time with the second pass of depth first search. Now of course a proof with a hole
in it, isn't a proof. So at the end of the lecture I'm gonna fill in the hole. That
is, I'm gonna supply a proof of this key lemma. But for now, as a working
hypothesis, let's assume that it's true. Let's begin with a corollary, that is a
statement which follows essentially immediately, from the statement of a lema.
So for the corollary, let's forget about just trying to find the maximum
maximum finishing time in a single SCC. Let's think about the maximum finishing
time in the entire graph. Now, why do we care about the maximum finishing time in
the entire graph? Well, notice that's exactly where the second pass of DFS
is going to begin. Right, so it processes nodes in order from largest
finishing time to smallest finishing time. So equivalently, let's think about the
node at which the second pass of depth first search is going to begin, i.e., the
node with the maximum finishing time. Where could it be? Well, the corollary is
that it has to be in what I'm gonna call a sink, a strongly connected component, that
is a strongly connected component without any outgoing arcs. So for example
let's go back to the, meta graph of SCCs for the very first directed graph we
looked at. You recall in the very first direc ted graph we looked at in when we
started talking about this algorithm there were four SCCs. So there was a 'C1', a 'C2',
a 'C3', and a 'C4'. And of course within each of these components, there could be
multiple nodes but they are all strongly connected to each other. Now, let's use
F1, F2, F3 and F4 to denote the maximum finishing time in each of these SCCs. So
we have F1, F2, F3 and F4. So, now we have four different opportunities to apply
this lemma. Right? Those four different pairs of adjacent SCCs. And so, what do
we find? We find that well, comparing F1 and F2, because C2 comes after C1,
that is there's an arc from C1 to C2, the max finishing time in C2 has
to be bigger than that in C1. That is F2 is bigger than F1. For the same
reasoning F3 has to be bigger than F1. Symmetrically we can apply the limit to
the pair C2, C4 and C3, C4 and we get that F4 has to dominate both of them. Now
notice we actually have no idea whether F2 or F3 is bigger. So that pair we can't
resolver. But we do know these relationships. Okay F1 is the smallest and
F4 is the smallest [biggest!!]. And you also notice that C4 is a sink SCC and the sink has no
outgoing arches and you think about it that's a totally general consequence of
this lema. So in a simple group of contradiction will go as follows. Consider
this SCC with the maximum F value. Suppose it was not a
sink SCC that it has an outgoing arch, follow that outgoing arch to get some
other SCC by the lema the SCC you've got into has even bigger maximum finishing
time. So that contradicts the fact that you started in the SCC with a maximum
finishing time. Okay. So just like in this cartoon, where the unique sink SCC has
to have the largest finishing time, that's totally general. As another sanity check,
we might return to the nine node graph, where we actually ran Kasaraja's
algorithm and looking at the ford version of the graph, which is the one on
the bottom, we see that the maximum finishing times in the three FCC are 4,6
and 9. And it turns out that the same as the leader nodes which is not an
accident if you think about it for a little while and again you'll observe the
maximum finishing time in this graph namely 9 is indeed in the left most SCC
which is the only SCC with no outgoing arks. Okay but it's totally general
basically you can keep following arks and you keep seeing bigger and bigger
finishing times so the biggest one of all it has to be somewhere where you get stuck
where you can't go forward but there's no outgoing arks and that's what I'm calling
a sink SCC. Okay. So assuming the lemma is true we know that the corollary
is true. Now using this corollary let's finish the proof of correctness, of
Kasaraja's algorithm, module over proof of the key lima. So I'm not going to do
this super rigorously, although everything I say is correct and can be made, made
rigorous. And if you want a more rigorous version I'll post some notes on the course
website which you can consult for more details. So what the previous corollary
accomplished, it allows us to locate, the node with maximum finishing time. We can
locate it in somewhere in some sink SCC. Let me remind you about the
discussion we had at the very beginning of talking about computing strong components.
We're tryna understand depth-first search would be a useful workhorse for finding
the strong components. And the key observation was that it depends, where you
begin that depth-first search. So for example in this, graph with four SCC's
shown in blue on the right. A really bad place to start. DFS called Depth For
Search would be somewhere in C1. Somewhere in this source SCC, so this is a bad DFS.
Why is it bad? Well remember what Depth For Search does; it finds everything
findable from its starting point. And from C1 you can get to the entire world, you
can get to all the nodes in the entire graph. So you can discover everything. And
this is totally useless because we wanted to discover much more fine-grain
structure. We wanted to discover C1, C2, C3 and C4 individually. So that would be
an disaster if we invoked depth first search somewhere from C1. Fortunately
that's not what's going to happen, right? We computed this magical ordering in the
first pass to insure that we look at the node with the maximum finishing time and,
by the corollary, the maximum finishing time is going to be somewhere in C4.
That's gonna be a good DFS, in the sense that, when we start exploring from
anywhere in C4, there's no outgoing arcs. So, of course, we're gonna find everything
in C4. Everything in C4's strongly connected to each other. But we can't get
out. We will not have the option of trespassing on other strong components,
and we're not gonna find'em. So we're only gonna find C4, nothing more. Now, here's
where I'm gonna be a little informal. Although, again, everything I'm gonna say
is gonna be correct. So what happens now, once we've discovered everything in C4?
Well, all the nodes in C4 get marked as explored, as we're doing depth first
search. And then they're basically dead to us, right? The rest of our depth first
search loop will never explore them again. They're already marked as explored. If we
ever see'em, we don't even go there. So the way to think about that is when we
proceed with the rest of our for loop in DFS loop it's as if we're starting
afresh. We're doing depth first search from scratch on a smaller graph, on the
residual graph. The graph G with this newly discovered strong component 'C'
deleted. So in this example on the right, all of the nodes in C4 are dead to us and
it's as if we run DFS anew, just on the graph containing the strong components C1,
C2 and C3. So in particular, where is the next indication of depth first search
going to come from? It's going to come from some sink SCC in the residual graph,
right? It's going to start at the node that remains and that has the largest
finishing time left. So there's some ambiguity in this picture. Again recall we
don't know whether F2 is bigger or F3 is bigger. It could be either one. Maybe F2
is the largest remaining finishing time in which case the next DFS indication's gonna
begin somewhere more from C2. Again, the only things outgoing from C2 are these
already explored nodes. Their effectively deleted. We're not gonna go there again.
So this is essentially a sink FCC. We discover, we newly discover the nodes in
C2 and nothing else. Those are now effectively deleted. Now, the next
indication of DFS will come from somewhere in F3, somewhere in C3. That's the only
remaining sink SCC in the residual graph. So the third call, the DFS will discover
this stuff. And now, of course, we're left only with C1. And so the final indication
of DFS will emerge from and discover the nodes in C1. And in this sense because
we've ordered the nodes by finishing times when DFS was reverse graph, that ordering
has this incredible property that when you process the nodes in the second pass we'll
just peel off the strongly connected components one at a time. If you think
about it, it's in reverse topological order with respect to the directed asypric
graph of the strongly connected components. So we've constructed a proof
of correctness of Kosaraju's, algorithm for computing strongly connected
components. But again, there's a hole in it. So we completed the argument assuming
a statement that we haven't proved. So let's fill in that last gap in the proof,
and we'll we done. So what we need to do is prove the key lemma. Let me remind you
what it says. It says if you have two adjacent SCCs, C1 and C2 and is an arc from a
node in C1, call it 'I' to a node in C2, say J. Then the max finishing time in C2 is
bigger than the max finishing time in C1. Where, as always, these finishing
times are computed in that first pass of depth-first search loop in the reversed
graph. All right, now the finishing times are computed in the reversed graph, so
let's actually reverse all the arcs and reason about what's happening there. We
still have C1. It still contains the node I. We still have C2, which still
contains the node J. But now of course the orientation of the arc has reversed. So
the arc now points from J to I. Recall we had a quiz which said, asked you to
understand the effect of reversing all arcs on the SCC's and in particular there
is no effect. So the SCC's in the reverse graph are exactly the same as in the
forward graph. So now we're going to have two cases in this proof and the cases
correspond to where we first encounter a node of C1 and union C2. Now remember,
when we do this DFS loop, this second pass, because we have this outer four loop
that iterates over all of the nodes we're guaranteed to explore every single node of
the graph at some point. So in particular we're gonna have to explore at some point
every node in C1 and C2. What I want you to do is pause the algorithm. When it
first, for the first time, explores some node that's in either C1 or C2. There's
going to be two cases, of course, because that node might be in C1, you might see
that first. Or it might be in C2, you might see something from C2 first. So our
case one is going to be when the first node that we see from either one happens
to lie in C1. And the second case is where the first node V that we see happens to
lie in C2. So clearly exactly one of these will occur. So let's think about case one.
When we see a node of C1 before we see any nodes of C2. So in this case where we
encounter a node in C1 before we encounter any node in C2, the claim is that we're
going to explore everything in C1 before we ever see anything in C2. Why is that
true? The reason is there cannot be a path that starts somewhere in C1, for example,
like the vertex V, and reaches C2. This is where we are using the fact that the
meta-graph on SCC is a cyclic. Right C1 is strong
connected, C2 is strong connected, you can get from C2 to C1 and, if you can also get
from C1 back to C2 this all collapses into a single strongly connected component. But
that would be a contraction, we're assuming C1 and C2 are distinct strongly
connected components, therefore you can't have paths in both directions. We already
have a path from right to left, via JI, so there's no path from left to right. That's
why if you originate a depth first search from somewhere inside C1 like this vertex
V, you would finish exploring all of C1 before you ever are going to see C2,
you're. Only gonna see C2 at some later point in the outer for loop. So, what's
the consequence that you completely finish with C1 before you ever see C2? Well it
means every single finishing time in C1 is going to be smaller than every single
finishing time in C2. So that's even stronger that what we're claiming, we're
just claiming that the biggest thing in C2 is bigger than the biggest of C1. But
actually finishing times in C2 totally dominate those in C1, because you finish
C1 before you ever see C2. So let's now have a look at case one actually in
action. Let's return to the nine-node graph, the one that we actually ran
Kosaraju's algorithm to completion. So if we go back to this graph which has the
three connected components, then remember that the bottom version is the forward
version, the top version is the reversed version. So if, if you think about the
middle SCC as being c1, pulling the row of c1 and the left most. Scc playing the role
of C2, then what we have exactly is case one of the key lemma. So, which was
the first of these six vertices visited during the DFS loop in the reversed graph?
Well that would just be the node with the highest name, so the node nine. So this
was the first of these six vertices that depth first search looked at in the first
pass, that lies in what we're calling C1. And indeed everything in C1 was discovered
in that pass before anything in C2 and that's why all of the finishing times in
C2, the 7,8,9 are bigger than all of the finishing times in C1 -
the 1,5, and 6. So we're good to go in case two. We've proven sorry, in case one,
we've proven the lemma. When it's the case that, amongst the vertices in C1
and C2, depth first search in the first pass sees something from C1 first. So
now, let's look at this other case, this grey case, which could also happen,
totally possible. Well, the first thing we see when depth first searching in the
first pass, is something from C2. And here now is where we truly use the fact that
we're using a depth first search rather than some other graph search algorithm
like breadth first search. There's a lot of places in this algorithm you could swap
in breadth first search but in this case two, you'll see why it's important we're
using depth first search to compute the finishing times. And what's the key point?
The key point is that, when we invoke depth first search beginning from this
node V, which is now assuming the line C2. Remember depth first search will not
complete. We won't be done with V until we've found everything there is to find
from it, right? So we recursively explore all of the outgoing arcs. They recursively
explore all of the outgoing arcs, and so on. It's only when all paths going out of
V have been totally explored and exhausted, that we finally backtrack all
the way to V, and we consider ourselves done with it. That is, depth first search.
In the reverse graph initiated at v. Won't finish until everything findable has been
completely explored. Because there's an arc from C2 to C1, obviously everything to
C2 is findable from V, that's strongly connected. We can from C2 to C1 just using
this arc from J to I. C1 being strongly connected we can then find all of that.
Maybe we can find other strongly connected components, as well, but for sure
depth-first search starting from V will find everything in C1 to C2, maybe some
other things. And we won't finish with V until we finish with everything else,
that's the depth-first search property. For that reason the finishing time of this
vertex V will be the largest of anything reachable from it. So in particular it'll
be larger than everything in C two but more to the point, it'll be larger than
everything in C1 which is what we are trying to prove. Again let's just see
this quickly in action in the nine node network on which we traced through
Kosaraju's algorithm. So to show the rule that case two is playing in this concrete
example let's think of the right most strongly connected component as being C1.
And let's think of the middle SCC as being C.2. Now
the last time. We called the middle one C1 and the leftmost one C2. Now we're calling
the rightmost one C1 and the middle one C2. So again, we have to ask the question,
you know, of the six nodes in C1 and in C2, what is the first one encountered in
the depth first search that we do in the first pass. And then again, is the node
nine? The, the node which is originally labeled not. So it's the same node that
was relevant in the previous case, but now with this relabeling of the components,
nine appears in the strongly connected component C-2, not in the one labeled C-1.
So that's the reason now we're in case two, not in case one. And what you'll see
is, what is the finishing time that this originally labeled nine node gets. It gets
the finishing time six. And you'll notice six is bigger than any of the other
finishing times of any of the other nodes in C1 or C2. All, the other five nodes
have the finishing times one through five. And that's exactly because when we ran
depth first search in the first pass, and we started it at the node originally
labeled nine, it discovered these other five nodes and finished exploring them
first before finally back tracking all the way back to nine, and deeming nine fully
explored. And it was only at that point that nine got its finishing time after
everything reachable from it had gotten there lower finishing times. So that
wraps it up. We had two cases depending on whether in these two adjacent SCC's, the
first vertex encountered was in the C1, or in C2. Either way it doesn't matter, the
largest finishing time has to be in C2. Sometimes it's bigger than everything,
sometimes it's just bigger than the biggest in C-1, but it's all the same to
us. And to re cap how the rest of the proof goes, we have a corollary based on
this lemma, which is maximum finishing time have to lie in sink SCC
And that's exactly where we want our depth first search to
initiate. If you're initiated in a strong component with no outgoing arcs, you do
DFS. The stuff you find is just the stuff and that strongly connected component. You
do not have any avenues by which to trespass on other strong components. So
you find exactly one SCC. In effect, you can peel that off and recurse on the rest
of the graph. And our slick way of implementing this recursion is to just do
the single second, DFS pass, where you just treat the nodes in decreasing order
of finishing times, that in effect, unveil, unveils all of the SCCs in
reverse topological ordering. So that's it, Kosaraju's algorithm, and the complete
proof of correctness. A blazingly fast graph primitive that, in any directed
graph, will tell you its strong components.