Then, for each pair of colors, we have to exclude that they are both true for every nodes.

We're going to average it for the n nodes in the graph.

log base 2 of n, specifically.

We generate a graph on n 2 nodes and call it G2 different graph.

With that as our insight, can we actually write down what the formula is for a graph with n nodes?

The sum of results, so all the hubs' shortest path distance is stored?

So these statements here are going to get executed once per node.

The correct answer is Marcie.

Now we have to introduce some extra constraints so that this truth assignment has to be satisfied.

The algorithm first preprocesses the graph, and for each vertex it computes labels, and let's say for simplicity the graph is undirected.

This is how we're going to do it. We're going to imagine that every node has a label. That label is a bit pattern.

That's going to total up to n clauses in the formula.

The first two invariants you know, are just really cosmetic.

That's a heap operation there's n things in the heap, so this is a logn operation.

And if this is actually a densely connected graph like a clique, we're talking about n² for each of the nodes in the graph which totals up to n³ and n³ for something like the Marvel Comics graph where you have 6000 nodes, 6000³ is a pretty substantial number even by current computing standards.

And for each pair of neighbors, it does a calculation to compute how connected it is and then returns a measure of how densely connected the neighbors are.

So a useful thing to know about a social network is whether everything is connected to everything else or whether there's some subset of nodes that's isolated from the main body of nodes.

What expand is, is a table of the same size as grid that maintains at what step each node was expanded.

I used numbers here, because it was really easy to do.

It's going to do this one main computation, this adding whatever value it gets back to this quantity here, then it returns.

I am going to say that the clustering coefficient for graph is just the average of the clustering coefficients of the nodes in the graph.

What it actually looks like internally is the list of the nodes.

And here's a graph it's kind of a binary tree, starting from h and expanding the nodes using breadth first search, when node o be added to the open list.

So let's do this.

Then we post ordered the nodes and now what do we do next.We now compute the number of descendents for each node in the graph and the number of descendents is the number of nodes that are either the node or reachable from the node by following green edges only.

It's not so hard to figure out that we're essentially running down heapify which is a log in operation on each of the node sort as a root.

What we're going to do with that node is look up the dictionary for that node in other words, look up all the connections that that node has in the graph, and look up the length of that, put it together in a big list.

What node 0 is is a dictionary of all the nodes that it is connected to directly.

We've got five nodes and five edges.

Node

Node

Node...

Nodes

Dodge

If we have some value in the heap and we know that the heap property is satisfied and what does that mean?

Here's a game tree for a stochastic 2 player game.

This isn't too hard we just make a note that degree centrality just means that degree which node has the highest degree.

For this to make sense, we're assuming that n is a perfect square, so that we can actually arrange the nodes and form a square as so.

Andrew Goldberg described a data structure that can be used to very rapidly compute shortest path distances between nodes in a network.

We're going to again generate a graph on n nodes recursively. Same structure as before.

Otherwise, we recursively generate the two subgraphs.

This expression actually, from this bracket here to this bracket here gives us a list of the degrees of all the nodes.

Because the nodes are filled in the tree from top to bottom and left to right, we can number them very naturally as follows.

We're going to make a link in the ring from node i to node i 1 mod n.

This algorithm captures a different notion of centrality.