A First Course in Network Science 1st Edition By Filippo Menczer, Santo Fortunato, Clayton A. Davis

INSTRUCTOR'S SOLUTION MANUAL

A First Course on Network Science: Exercise Solutions Filippo Menczer, Santo Fortunato, Clayton A. Davis November 4, 2019

Chapter 0 Exercise 0.1. b. Road segments Exercise 0.2. b. Street intersections Exercise 0.3. A flight Exercise 0.4. d. Hub nodes with many links Exercise 0.5. Undirected Exercise 0.6. Directed

Chapter 1 Exercise 1.2. A link connects two nodes. A node can be connected to at most N − 1 other nodes.

Exercise 1.3. The most common degree in a square grid is k = 4.

Exercise 1.4. The most common in-degree and out-degree are kin = kout = 2.

Exercise 1.5. We can represent traffic volume by link weight.

Exercise 1.6. c. Total in-degree must be equal to total out-degree Exercise 1.7. d. Directed, weighted Exercise 1.8. b. Undirected, weighted Exercise 1.9. a. Undirected, unweighted Exercise 1.10. d. Directed, weighted 1

Exercise 1.11. A clique with Exercise 1.12. Lmax =

N 2

25 2

= 300 links.

links.

Exercise 1.13. Lmax = N1 N2 = N1 (N − N1 ) links. The value of N1 that maximizes the number of links is obtained by setting the derivative of Lmax to zero: dNd 1 Lmax = N − 2N1 = 0 =⇒ N1 = N/2, so that Lmax = N 2 /4.

Exercise 1.14. a. Network A has more links than network B. Intuitively, you have to add links in B among nodes in the same group to obtain the complete network A that is not bipartite. To prove this mathematically, compare Lmax from the previous two exercises.

Exercise 1.15. Yes. If it was not complete, we could find a pair of unconnected nodes, so N the number of pairs of nodes would exceed 2 , a contradiction.

Exercise 1.16. d. Directed, weighted Exercise 1.17. N = 6, L = 10, no self-loops.

Exercise 1.18. F has links to every other node. No node has links from every other node.

Exercise 1.19. C is a sink.

Exercise 1.20. sin (C) = 5, sout (C) = 0 Exercise 1.21. N = 6, L = 9 Exercise 1.22. kmin = 2, kmax = 5, hki = 3, d = 0.6 Exercise 1.23. They do not necessarily have the same minimum and maximum degree.

Consider the networks S and P in Fig. 1.2 as a counter-example of networks with the same number of nodes (N = 6) and links (L = 5) but different kmax . Rewire an edge from either network to leave a singleton, so that kmin will be different as well. The average degree hki = 2L/N depends on only N and L, so it must be the same. = 2d.

Exercise 1.24. With a doubling of L alone, density would increase (double): d0 = 2L (N2 ) With a doubling of N , the maximum number of links would grow roughly quadratically, so a doubling of L would not suffice to keep the density constant; it would decrease. Mathe2L matically, you can prove that d0 = 2N < NL = d.

(2) (2) Exercise 1.25. Let us use the subscripts u and m for users and movies, respectively. L = L ui ui Nu hku i = 33 × 109 . d = Lmax = NNuuhk = hk ≈ 10−2 . So the network is fairly sparse.

Nm Nm L ui ui Exercise 1.26. d = Lmax = NNuuhk = hk . This does not depend on Nu , only on quantities Nm Nm that have remained constant, therefore the density has stayed the same.

2

Chapter 2 Exercise 2.2. True Exercise 2.3. True Exercise 2.4. Lmin = 0 in general. If the network is connected, the minimum number of links is the case of a tree, Lmin = N − 1.

Exercise 2.5. True Exercise 2.6. True Exercise 2.7. False Exercise 2.8. Yes, there are cycles. The network is not strongly connected. It is weakly connected.

Exercise 2.9. No Exercise 2.10. `max = 2 Exercise 2.11. Yes. Weakly connected means connected if we disregard link directions, so by definition the undirected version is connected.

Exercise 2.12. c. It has increased or stayed the same Exercise 2.13. b. Weakly connected Exercise 2.14. sin (D) = 11. sout (C) = 3.

Exercise 2.15. One. Exercise 2.16. b. Weakly connected Exercise 2.17. (1, 2, 4, 6) Exercise 2.18. (1, 2, 4, 5, 6) Exercise 2.19. c. 10 Exercise 2.20. a. 0.05 (it might be zero, hard to tell) Exercise 2.21. A social network would likely have higher clustering.

Exercise 2.22. a. Strongly connected Exercise 2.23. `max = 5 3

Exercise 2.24. `max = 2 Exercise 2.25. False Exercise 2.26. c. First compute the shortest-path lengths between each pair of nodes. The diameter is the maximum of these values Exercise 2.27. True Exercise 2.28. d. Social networks have small average path length Exercise 2.32. Cmax = 1 by definition.

Exercise 2.33. Zero — there are no triangles in a tree.

Exercise 2.34. C =

3

(52)

= 0.3

Exercise 2.35. ` = 1, 2, 2, 3, 3, 4, 4, 1, 1, 2, 2, 3, 3, 1, 2, 2, 3, 3, 1, 1, 2, 2, 2, 3, 3, 1, 1, 2 Exercise 2.36. The four leaves have undefined clustering coefficient. For the other nodes, C = 1/3, 1, 1/6, 0.

Exercise 2.37. `a,b = 2, `a,c = 2, `a,d = 4, `a,e = 3, `a,f = 1, `a,g = 1, `a,h = 3, `b,c = 1, `b,d = 2, `b,e = 1, `b,f = 2, `b,g = 1, `b,h = 1, `c,d = 2, `c,e = 1, `c,f = 2, `c,g = 1, `c,h = 2, `d,e = 1, `d,f = 4, `d,g = 3, `d,h = 3, `e,f = 3, `e,g = 2, `e,h = 2, `f,g = 1, `f,h = 3, `g,h = 2. h`i ≈ 2.0.

This would have been quicker to do in code than by hand: FIG12 = nx . Graph () FIG12 . add_edges_from ([( 'd ' , 'e ' ) ,( 'e ' , 'c ' ) ,( 'e ' , 'b ' ) ,( 'c ' , 'b ') , ( 'c ' , 'g ' ) ,( 'b ' , 'g ' ) ,( 'b ' , 'h ' ) ,( 'g ' , 'f ') , ( 'g ' , 'a ' ) ,( 'f ' , 'a ' )]) p = dict ( nx . s h o r t e s t _ p a t h _ l e n g t h ( FIG12 )) for s in p : for t in p [ s ]: print ( ' length (% s ,% s ) = % d ' % (s , t , p [ s ][ t ])) print ( ' APL = ' , nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( FIG12 ))

Exercise 2.38. C(a) = 1, C(b) = 1/3, C(c) = 2/3, C(e) = 1/3, C(f ) = 1, C(g) = 1/3.

C ≈ 0.6. In code (building upon the previous exercise): for n , c in nx . clustering ( FIG12 ). items (): print ( 'C (% s ) = % f ' % (n , c )) print ( 'C = ' , nx . a ve ra ge _c lu st er in g ( FIG12 ))

Note that NetworkX includes nodes with degree below 2 and assigns clustering coefficient zero to them, instead of excluding them as undefined. As a result, the network clustering coefficient calculated by NetworkX is lower.

4

Exercise 2.40. d. Social networks are highly clustered, yet are not dense.

Exercise 2.41. Let’s answer using code: # 1 G = nx . read_edgelist ( ' socfb - Northwestern25 . edges ') N = G . number_of_edges () print ( ' The network has ' , N , ' links ') # The network has 488337 links # 2 if G . is_directed (): if nx . i s _ s t r o n g l y _ c o n n e c t e d ( G ): print ( 'a . Strongly connected ') elif nx . i s_ w e ak l y _c o n ne c t ed ( G ): print ( 'b . Weakly connected ') else : if nx . is_connected ( G ): print ( 'c . Connected ') else : print ( 'd . Disconnected ') # d . Disconnected # 3 print ( ' There are % d pairs of nodes ' % ( N *( N -1)/2)) # There are 119236268616 pairs of nodes # 4 ( considering only pairs in same component ) sum = 0 n = 0 for _ in range (1000): i , j = random . sample ( G . nodes , 2) if nx . has_path (G ,i , j ): sum += nx . s h o r t e s t _ p a t h _ l e n g t h (G ,i , j ) n += 1 print ( ' Estimated APL using % d pairs is %.1 f ' % (n , sum / n )) # Estimated APL using 994 pairs is 2.7 # 4 ( using Eq 2.5) sum = 0 for _ in range (1000): i , j = random . sample ( G . nodes , 2) if nx . has_path (G ,i , j ): sum += 1 / nx . s h o r t e s t _ p a t h _ l e n g t h (G ,i , j ) print ( ' Estimated APL using trick of Eq 2.5 is %.1 f ' % (1000/ sum )) # Estimated APL using trick of Eq 2.5 is 2.6 # 5 max = 0

5

n = 0 for _ in range (1000): i , j = random . sample ( G . nodes , 2) if nx . has_path (G ,i , j ): l = nx . s h o r t e s t _ p a t h _ l e n g t h (G ,i , j ) if l > max : max = l n += 1 print ( ' Estimated diameter using % d pairs is % d ' % (n , max )) # Estimated diameter using 993 pairs is 5 # 6 print ( 'C = ' , nx . a ve ra ge _c lu st er in g ( G )) # C = 0.23 79 91 39 48 28 06 04 # 7 a = nx . d e g r e e _ a s s o r t a t i v i t y _ c o e f f i c i e n t ( G ) if a > 0: print ( ' Using first method , G is assortative ( a =% f ) ' % a ) else : print ( ' Using first method , G is disassortative ( a =% f ) ' % a ) knn_dict = nx . k _ n ea r e st _ n ei g h bo r s ( G ) k , knn = list ( knn_dict . keys ()) , list ( knn_dict . values ()) r , _ = scipy . stats . pearsonr (k , knn ) if r > 0: print ( ' Using second method , G is assortative ( r =% f ) ' % r ) else : print ( ' Using second method , G is disassortative ( r =% f ) ' % r ) if ( a > 0 and r > 0) or ( a < 0 and r < 0): print ( ' The two methods agree ') else : print ( ' The two methods disagree ') # Using first method , network is assortative ( a =0.034441) # Using second method , network is assortative ( r =0.361860) # The two methods agree

Chapter 3 Exercise 3.2. 2L/N = 400/100 = 4 Exercise 3.3. 1. The graph is not connected. 2. The mode is one. 3. The largest cliques have four nodes. 4. This network does not have hubs.

Exercise 3.4. We use the max function with degree as key: # 1 Finding node with largest degree for graph G highest_d e gr e e _n o d e = max ( G . nodes , key = G . degree )

6

highest_d e gr e e _n o d e # 2 Printing the value of the maximum degree G . degree ( h i gh e s t _d e g re e _ no d e )

Exercise 3.5. c. G.node[5567][’salary’] Exercise 3.6. d. node size list = [G.degree(n) for n in G.nodes] Exercise 3.7. b. A scholar has coauthored publications with two other scholars Exercise 3.8. b. A variety of degrees is to be found Exercise 3.9. The network has to be connected. However, even if the network is not connected, one often calculates the closeness centrality for the nodes in each connected component separately.

Exercise 3.10. 1. The node with the largest closeness is the red node (degree 2, closeness 1/11), not the black node (degree 3, closeness 1/12).

2. The nodes with the largest betweenness are the black ones (betweenness 10 each, as there are 10 pairs of nodes whose shortest paths must cross the black nodes; their closeness is 1/12). The ones with the largest closeness are the red ones (betweenness 4.5, as there are 9 pairs of nodes whose shortest paths cross a red node, but each of them counts 1/2 because they can go through the other red node as well; their closeness is 1/11).

Exercise 3.11. 1. Three nodes: 2, 3 and 5 (all with degree 3). 2. Two nodes: 2 and 5 (betweenness 9: for node 2 it corresponds to the 9 paths connecting 1, 3, 4 with 5, 6, 7; for node 5 it corresponds to the 8 paths connecting 1, 2, 3, 4 with 6, 7 plus the path from 6 to 7). 3. Node 2, whose closeness is 1/9.

7

Exercise 3.12. Using the formula hki = 2L/N we get L = hkiN/2 = 1.8 × 10/2 = 9 links.

Since the network is connected and L = N − 1, the network must be a tree. To maximize the heterogeneity we must achieve the largest value of the average square degree, which is obtained when the tree is a star as in the figure below, with one node having the largest possible degree of k = N − 1 = 9 and all other nodes having k = 1.

Exercise 3.13. 1. The distribution is not heavy-tailed, shoe sizes vary in a small range. 2.

It is heavy-tailed, there is a big inequality in income with many orders of magnitude between top and bottom wealth. 3. It is heavy-tailed: most people have a few followers while some can reach millions. 4. It is not heavy-tailed: distances vary in a small range, from one to the diameter of the network, which is usually a small number (of the order of 10).

Exercise 3.14. No, because such large values, albeit infrequent, would still be reachable by a heavy-tailed distribution.

Exercise 3.15. 1. 108 . 2. A couple of million. 3. About 10,000.

Exercise 3.16. For the network describing the total number of partners over all years since sexual initiation (Fig. 1b in the paper), the maximum degree is close to 1,000 (the number cannot be estimated with precision because the plot shows a binned distribution). This means that there are subjects who had close to 1,000 sexual partners. The distributions of the number of sexual partners are markedly different for men and women. This is not surprising, in principle. Given that most relationships are heterosexual, we expect that the mean degree is the same for both distributions (since both networks would have approximately same number of nodes and links), but this does not mean that the shape of the curves has to be the same. For females the distribution falls off more rapidly and the average and maximum degree are much smaller than for males. This may be an indication that men tend to inflate the number of partners, while women tend to underestimate it.

Exercise 3.17. Let us use NetworkX: G = nx . read_edgelist ( " openflights_usa . edges " ) # 1 average_degree = 2 * G . number_of_edges () / G . number_of_nodes () average_degree # 10.18681 31 86 81 31 86

8

# 2 sorted ( G . nodes , key = G . degree ( G . nodes ) , reverse = True )[:5] # [ ' ATL ', ' ORD ', ' DEN ', ' DFW ', ' MSP '] # # # # #

3 solution using collections . Counter from collections import Counter counter = Counter ([ G . degree ( n ) for n in G . nodes ()]) counter [1]

# solution without external packages number_deg ree_o ne = 0 for i in G . nodes (): if G . degree ( i ) == 1: numb er_deg ree_on e += 1 number_deg ree_o ne # 156 # 4 highest_cl_node = max ( G . nodes , key = nx . c l o s e n e s s _ c e n t r a l i t y ( G ). get ) highest_cl_node # ' DEN ' # 5 highest_btw_node = max ( G . nodes , key = nx . b e t w e e n n e s s _ c e n t r a l i t y ( G ). get ) highest_btw_node # ' ANC ' # 6 from statistics import mean average_k2 = mean ([ G . degree ( n ) ** 2 for n in G . nodes ()]) kappa = average_k2 / ( average_degree ** 2) kappa # 5.3474947701 44302

Exercise 3.18. We import the graphml version, so we can access title attributes of the Wikipedia pages: W = nx . read_graphml ( " enwiki_math . graphml " ) #1 from statistics import mean average_k_in = mean ([ W . in_degree ( n ) for n in W . nodes ()]) average_k_out = mean ([ W . out_degree ( n ) for n in W . nodes ()]) print ( ' average k_in = ' , average_k_in , ' average k_out = ' , average_k_out ) # average k_in = 12.7531537450722 average k_out = 12.7531537450722

9

We note that the average in-degree and out-degree are the same. In any directed network the two scores are identical, because they count the average number of tips and tails of the directed links, and each directed link has one tip and one tail. # 2 max_k_in_node = max ( W . nodes , key = W . in_degree ( W . nodes )) W . nodes [ max_k_in_node ][ ' title '] # ' Mathematics_Genealogy_Project ' # 3 max_k_out_node = max ( W . nodes , key = W . out_degree ( W . nodes )) W . nodes [ max_k_out_node ][ ' title '] # ' L i s t _ o f _ I n t e r n a t i o n a l _ C o n g r e s s e s _ o f _ M a t h e m a t i c i a n s _ P l e n a r y _ ... # ... and_ I n v i t e d _ S p e a k e r s ' # 4 print ( ' max k_in = ' , W . in_degree ( max_k_in_node ) , ' , max k_out = ' , W . out_degree ( max_k_out_node )) # max k_in = 5171 , max k_out = 1356

The maximum in-degree is larger than the maximum out-degree. This is expected for Web graphs. Reaching large out-degree requires a lot of activity by the owner/administrator of the Web page, as they have to create hyperlinks to other pages. Being pointed to by other Web pages depends on others: popular sites can easily attain in-degrees of multiple millions. # 5 and 6 average_k_in_2 = mean ([ W . in_degree ( n ) ** 2 for n in W . nodes ()]) average_k_out_2 = mean ([ W . out_degree ( n ) ** 2 for n in W . nodes ()]) kappa_in = average_k_in_2 / ( average_k_in ** 2) kappa_out = average_k_out_2 / ( average_k_out ** 2) print ( ' kappa_in = ' , kappa_in , ' , kappa_out = ' , kappa_out ) # kappa_in = 38.210 20457 626352 , kappa_out = 6.622 016155 632556

Exercise 3.19. Using NetworkX: def avg_d e g r e e _ n e i g h b o r s (G , friend ): if G . degree ( friend ) > 0: k_nn = 0 for node in G . neighbors ( friend ): k_nn += G . degree ( node )/ G . degree ( friend ) return k_nn else : print ( ' The k_nn of ' , friend , ' is undefined because ' , friend , ' has no neighbors ! ')

The average degree of the nearest neighbors of the nodes is 64.05, much larger than the average node degree 10.19 — a result consistent with the Friendship Paradox.

10

Exercise 3.20. If the network is regular, i.e. if all nodes have the same degree, the average degree of the nearest neighbors of a node coincides with the degree of the node, and the averages match.

Exercise 3.21. Networks with heavy-tailed degree distributions are more vulnerable to attacks targeted on the hubs, because hubs have many neighbors and their removal creates much more damage than attacking nodes at random. For grid-like networks all nodes have the same degree (except possibly at the boundary of the network) and the effect of an attack is the same if the targeted nodes are chosen randomly or according to the degree.

Exercise 3.22. d. Nodes/edges with high betweenness centrality. High-betweenness nodes are often bridges, so their removal can rapidly lead to the disconnection of the network. (c) is also a valid answer. Nodes with highest closeness are nearest, on average, to all other nodes of the network. Their removal thus eliminates many short paths and increases the average path length. If a node has high clustering coefficient its neighborhood is cohesive, so not many shortest paths are expected to go through the node. In fact, any path including the subpath A − B − C, where B is a node with high clustering coefficient and A and C two of its neighbors, can be made shorter by going directly from A to C, as they are likely to be adjacent. If a node has low degree, it is not expected to be involved in many shortest paths, and its removal should not cause major damage to the network (though the node can still have high betweenness, as shown in Figure 3.1 of the book).

Exercise 3.23. The node with lower clustering coefficient. A high clustering coefficient means that many neighbors of the node are connected to each other, so paths going through the node can be made shorter by going directly from the neighbor of the node preceding it in the path to the neighbor following it in the path. Therefore not many shortest paths are expected to go through a node with high clustering coefficient (see also the solution of Exercise 3.22 above).

Exercise 3.24. To answer one of the questions we are going to use the numpy package: G = nx . read_edgelist ( " socfb - Northwestern25 . edges " ) # 1 nodes_above_100 = 0 for i in G . nodes (): if G . degree ( i ) >= 100: nodes_above_100 += 1 print ( '% d %% of the nodes have degree at least 100 ' % round (100 * nodes_above_100 / G . number_of_nodes ())) # 38% of the nodes have degree at least 100 # 2 and 3 max_k_node = max ( G . nodes , key = G . degree ) print ( ' The maximum degree is ' , G . degree ( max_k_node ) , ' and the node with this degree is ' , max_k_node ) # The maximum degree is 2105 and the node with this degree is 8262

11

# 4 import numpy as np degrees = [ G . degree ( n ) for n in G . nodes ] int ( np . percentile ( degrees , 95)) # 244 # 5 round (2 * G . number_of_edges () / G . number_of_nodes ()) # 92 # 6 plt . hist ([ G . degree ( n ) for n in G . nodes ()]) plt . xlabel ( ' degree ') plt . ylabel ( ' nodes ')

The histogram is not very informative, because the distribution is broad but it is difficult to see the counts for high degree. As explained in the text, we can plot the cumulative distribution (Box 3.1) in log-log scale (Box 3.2). To this end we define a function to calculate the cumulative probabilities: from collections import Counter def CCDF ( degrees ): counter = Counter ( degrees ) sorted_degrees = sorted ( list ( counter )) N = len ( degrees ) remaining = N cumcount = {} for d in sorted_degrees : cumcount [ d ] = remaining / N remaining -= counter [ d ] return cumcount ccdf = CCDF ([ G . degree ( n ) for n in G . nodes ()]) plt . plot ( ccdf . keys () , ccdf . values ()) plt . xlabel ( ' degree ') plt . ylabel ( ' CCDF ')

12

plt . xscale ( ' log ') plt . yscale ( ' log ')

Now it is clear that the distribution is right-tailed (answer (c)).

Chapter 4 Exercise 4.2. Here is one way to do this using Beautiful Soup: from bs4 import BeautifulSoup import urllib . request # 1 # extract links from ' See Also ' section of wiki page def extrac t_ wik i_ li nk s ( wiki_url ): soup = BeautifulSoup ( urllib . request . urlopen ( wiki_url )) sa = soup . find ( ' span ' , { ' id ': ' See_also ' }) if not sa : return [] element = sa links = [] while element . name != ' h2 ': if element . name == 'a ': if element [ ' href ' ]. startswith ( '/ wiki ' ): links . append ( ' https :// en . wikipedia . org ' + element [ ' href ' ]) element = element . next_element return links G = nx . DiGraph () seed = ' https :// en . wikipedia . org / wiki / Network_science ' neighbors = ex tr ac t_ wi ki _l in ks ( seed ) for n in neighbors : G . add_edge ( seed , n ) print ( ' The outdegree is ' , G . out_degree ( seed )) # The outdegree is 30

13

# 2 and 3 # build ego network ( may take a while ) neighbor_set = set ( neighbors ) neighbor_set . add ( seed ) reciprocal_links = 0 for n in neighbors : second_neighbors = ex tr ac t_w ik i_ li nk s ( n ) for sn in second_neighbors : if sn in neighbor_set : G . add_edge (n , sn ) if sn == seed : reciprocal_links += 1 print ( ' The number of reciprocal links is ' , reciprocal_links ) # The number of reciprocal links is 4 # 4 print ( max ( G . nodes () , key = G . out_degree )) # https :// en . wikipedia . org / wiki / Network_science # 5 print ( max ( G . nodes () , key = G . in_degree )) # https :// en . wikipedia . org / wiki / Dual - phase_evolution

Exercise 4.3. Using Beautiful Soup again: # extract categories from a wiki page def e xt ra c t _ w i k i _ c a t e g o r i e s ( wiki_url ): soup = BeautifulSoup ( urllib . request . urlopen ( wiki_url )) cat = soup . find ( 'a ' , { ' title ': ' Help : Category ' }) if not cat : return [] catlist = cat . next_sibling . next_sibling cats = catlist . find_all ( 'a ') return [ c [ ' title ' ]. split ( ': ' )[1] for c in cats ] # calculate cosine similarity between two sets of tags def cosine_sim ( s1 , s2 ): return len ( s1 & s2 ) / ( math . sqrt ( len ( s1 )) * math . sqrt ( len ( s2 ))) # extract categories from pages in ego network ( may take a while ) categories = {} for page in G . nodes (): categories [ page ] = set ( e x t r a c t _ w i k i _ c a t e g o r i e s ( page )) # calculate pairwise similarities , avoiding duplication sim = {} for a1 in G . nodes ():

14

for a2 in G . nodes (): if a1 >= a2 : continue sim [( a1 , a2 )] = cosine_sim ( categories [ a1 ] , categories [ a2 ]) # 1 most_similar = max ( sim . keys () , key = sim . get ) print ( ' The most similar articles are ' , most_similar , ' and their similarity is ' , sim [ most_similar ]) # The most similar articles are # ( ' https :// en . wikipedia . org / wiki / Complex_network ', # ' https :// en . wikipedia . org / wiki / Core - p e r ip h e ry _ s tr u c tu r e ') # and their similarity is 1.0 # 2 least_similar = min ( sim . keys () , key = sim . get ) print ( ' The least similar articles are ' , least_similar , ' and their similarity is ' , sim [ least_similar ]) # The least similar articles are # ( ' https :// en . wikipedia . org / wiki / Network_science ', # ' https :// en . wikipedia . org / wiki / Network_topology ') # and their similarity is 0.0 # 3 # for pairs at distance 1 n1 = 0 sum1 = 0 # for pairs at distance 2 n2 = 0 sum2 = 0 # ignore direction when calculating distance UG = G . to_undirected () for a1 in G . nodes (): for a2 in G . nodes (): if a1 >= a2 : # avoid duplication continue dist = nx . s h o r t e s t _ p a t h _ l e n g t h ( UG , a1 , a2 ) if dist == 1: sum1 += sim [( a1 , a2 )] n1 += 1 elif dist == 2: sum2 += sim [( a1 , a2 )] n2 += 1 else : print ( " Error : distance should be 1 or 2 but is " , dist ) print ( ' Avg similarity is %.2 f for adjacent articles ' % ( sum1 / n1 )) print ( ' Avg similarity is %.2 f for farther articles ' % ( sum2 / n2 ))

15

if sum1 / n1 > sum2 / n2 : print ( " These measurements provide evidence of topical locality " ) else : print ( " These articles do not display topical locality " ) # Avg similarity is 0.18 for adjacent articles # Avg similarity is 0.07 for farther articles # These measurements provide evidence of topical locality

Exercise 4.4. We can do this by hand or with code. The PageRank update formulas for the three pages with α = 0 are: A(t + 1) = B(t) + C(t)/2, B(t + 1) = A(t)/2 + C(t)/2, C(t+1) = A(t)/2. In the table below we calculate the values rounding to the second decimal digit. They converge to the second decimal digit after 8 steps. step 0 1 2 3 4 5 6 7 8 9

A 0.33 0.50 0.42 0.46 0.44 0.45 0.44 0.45 0.44 0.44

B 0.33 0.33 0.33 0.33 0.33 0.33 0.33 0.33 0.33 0.33

C 0.33 0.17 0.25 0.21 0.23 0.22 0.22 0.22 0.22 0.22

Exercise 4.5. Let’s do this version by code: R = { 'A ': 1/3 , 'B ': 1/3 , 'C ': 1/3} alpha = 0.2 epsilon = 0.01 def update_pagerank ( pr ): R_A = alpha /3 + (1 - alpha ) * ( pr [ 'B '] + pr [ 'C ' ]/2) R_B = alpha /3 + (1 - alpha ) * ( pr [ 'A ' ]/2 + pr [ 'C ' ]/2) R_C = alpha /3 + (1 - alpha ) * pr [ 'A ' ]/2 change = max ( abs ( R_A - pr [ 'A ' ]) , abs ( R_B - pr [ 'B ' ]) , abs ( R_C - pr [ 'C ' ])) return ( change , { 'A ': R_A , 'B ': R_B , 'C ': R_C }) change = 1 i = 0 while change >= epsilon : print ( ' step % d : R ( A )=%.2 f , R ( B )=%.2 f , R ( C )=%.2 f ' % (i , R [ 'A '] , R [ 'B '] , R [ 'C ' ])) change , R = update_pagerank ( R ) i += 1 print ( ' step % d : R ( A )=%.2 f , R ( B )=%.2 f , R ( C )=%.2 f ' % (i , R [ 'A '] , R [ 'B '] , R [ 'C ' ]))

16

# # # # #

step step step step step

0: 1: 2: 3: 4:

R ( A )=0.33 , R ( A )=0.47 , R ( A )=0.41 , R ( A )=0.43 , R ( A )=0.43 ,

R ( B )=0.33 , R ( B )=0.33 , R ( B )=0.33 , R ( B )=0.33 , R ( B )=0.33 ,

R ( C )=0.33 R ( C )=0.20 R ( C )=0.25 R ( C )=0.23 R ( C )=0.24

Exercise 4.7. We can use Astropy for pretty printing the table: W = nx . read_graphml ( ' enwiki_math . graphml ') PR = nx . pagerank ( W ) top_10_by_PR = [ W . nodes [ p ][ ' title '] for p in sorted ( W . nodes () , key = PR . get , reverse = True )][:10] top_10_by_kin = [ W . nodes [ p ][ ' title '] for p in sorted ( W . nodes () , key = W . in_degree , reverse = True )][:10] from astropy . io import ascii from astropy . table import Table t = Table ([ range (1 ,11) , [ s [:25] + ( s [25:] and ' .. ') for s in top_10_by_PR ] , [ s [:25] + ( s [25:] and ' .. ') for s in top_10_by_kin ]] , names =( ' rank ' , ' PR ' , ' k_in ' )) ascii . write (t , format = ' f i x e d _ w i d t h _ t w o _ l i n e ') # rank PR k_in # ---- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - # 1 Mathematics M a t h e m a t i c s _ G e n e a l o g y _ P r o .. # 2 M a t h e m a t i c s _ G e n e a l o g y _ P r o ..

Mathematics # 3 Mathematician Mathematician # 4 A m e r i c a n _ M a t h e m a t i c a l _ S o c ..

Mathematical_Reviews # 5 M a t h e m a t i c a l _ R e v i e w s A m e r i c a n _ M a t h e m a t i c a l _ S o c .. # 6 Statistics M a c T u t o r _ H i s t o r y _ o f _ M a t h e .. # 7 Edmund_F . _Robertson Edmund_F . _Robertson # 8 M a c T u t o r _ H i s t o r y _ o f _ M a t h e ..

Mathematical_analysis # 9 A p pl i e d_ m a t he m a ti c s I n t e r n a t i o n a l _ C o n g r e s s _ o f .. # 10 Mathematical_analysis A p p li e d _m a t he m a ti c s

We can see the top articles are not the same. PageRank is not the same as in-degree, as it also considers the sources of the incoming links.

Exercise 4.9. Let’s use Twython as in the book’s tutorials: # 1 from twython import Twython API_KEY = ' ... ' API_SECRET_KEY = ' ... '

17

ACCESS_TOKEN = ' ... ' ACCESS_TO K EN _ S EC R E T = ' ... ' twitter = Twython ( API_KEY , API_SECRET_KEY , ACCESS_TOKEN , A CC E S S_ T O KE N _ SE C R ET ) user = twitter . show_user ( screen_name = ' clayadavis ') user [ ' friends_count '] # 179 --- so answer is b . # 2 import itertools user = twitter . show_user ( screen_name = ' truthyatindiana ') NUM_TWEET S _T O _ FE T C H = user [ ' friends_count '] cursor = twitter . cursor ( twitter . get_friends_list , screen_name = ' truthyatindiana ' , count =200) friends = list ( itertools . islice ( cursor , N UM _ T WE E T S_ T O _F E T CH )) from statistics import mean , median followers = {} for friend in friends : followers [ friend [ ' screen_name ' ]] = friend [ ' followers_count '] print ( 'I have ' , user [ ' followers_count '] , ' followers , while my ') print ( ' friends have ' , round ( mean ( followers . values ())) , ' on average ') # I have 3295 followers , while my # friends have 224245 on average # 3 print ( 'I have ' , user [ ' followers_count '] , ' followers , while ') print ( ' most of my friends have ' , median ( followers . values ())) # I have 3295 followers , while # most of my friends have 3598 # 4 most_popular = max ( followers , key = followers . get ) print ( ' Among my friends , ' , '@ '+ most_popular , ' has most followers : ' , followers [ most_popular ]) # Among my friends , @WhiteHouse has most followers : 18891275

Exercise 4.10. Each line in the file has a tweet JSON object: # read tweets from file import json tweets = [] with open ( ' repealthe19th . jsonl ') as f : for line in f : tweets . append ( json . loads ( line )) len ( tweets ) # 23343 # extract retweets

18

retweets = [] for tweet in tweets : if ' retweeted_status ' in tweet : retweets . append ( tweet ) len ( retweets ) # 14858 # build retweet network D = nx . DiGraph () for retweet in retweets : retweeted_status = retweet [ ' retweeted_status '] retweeted_sn = retweeted_status [ ' user ' ][ ' screen_name '] retweeter_sn = retweet [ ' user ' ][ ' screen_name '] if retweeted_sn == retweeter_sn : continue if D . has_edge ( retweeted_sn , retweeter_sn ): D . edges [ retweeted_sn , retweeter_sn ][ ' weight '] += 1 else : D . add_edge ( retweeted_sn , retweeter_sn , weight =1) # 1 print ( D . number_of_nodes ()) # 14862 # 2 print ( D . number_of_edges ()) # 14795 # 3 (# 6: out - strength is a measure of influence ) most_influential = max ( D . nodes () , key = D . out_degree ( weight = ' weight ' )) print ( '@ '+ most_influential , ' has highest out - strength : ' , D . out_degree ( most_retweeted , weight = ' weight ' )) # @Samandjunk has highest out - strength : 901 # 4 second = sorted ( D . nodes () , key = D . out_degree ( weight = ' weight ') , reverse = True )[1] print ( '@ '+ second , ' has second - highest out - strength : ' , D . out_degree ( second , weight = ' weight ' )) # @m_kaish_esq has second - highest out - strength : 394 # 5 (# 6: in - strength is a measure of retweeting activity ) most_active = max ( D . nodes () , key = D . in_degree ( weight = ' weight ' )) print ( '@ '+ most_active , ' has highest in - strength : ' , D . in_degree ( most_active , weight = ' weight ' )) # @JenTromans has highest in - strength : 48

19

# 7 ( the account that posted # https :// twitter . com / user / status / 7 8 63 3 5 04 4 9 81 9 0 74 5 6 # was suspended ) retweet_count = {} for retweet in retweets : retweeted_status = retweet [ ' retweeted_status '] retweeted_sn = retweeted_status [ ' user ' ][ ' screen_name '] retweeter_sn = retweet [ ' user ' ][ ' screen_name '] if retweeted_sn == retweeter_sn : continue retweeted_id = retweeted_status [ ' id_str '] if retweeted_id in retweet_count : retweet_count [ retweeted_id ] += 1 else : retweet_count [ retweeted_id ] = 1 most_retweeted = max ( retweet_count , key = retweet_count . get ) print ( ' The most retweeted tweet has ID ' , most_retweeted ) print ( ' It was retweeted ' , retweet_count [ most_retweeted ] , ' times ') # The most retweeted tweet has ID 78 63 35 04 49 81 90 74 56 # It was retweeted 901 times # 8 (# 9: c . The user hasn 't been retweeted by anyone ) z er o_ o ut _ s t r e n g t h _ c o u n t = 0 for n in D . nodes (): if D . out_degree (n , weight = ' weight ') == 0: z e r o _ o u t _ s t r e n g t h _ c o u n t += 1 print ( zero_out_strength_count , ' nodes have zero out - strength ') # 12916 nodes have zero out - strength # 10 if nx . is _ s t r o n g l y _ c o n n e c t e d ( D ): print ( 'a . Strongly connected ') elif nx . i s_ w e ak l y _c o n ne c t ed ( D ): print ( 'b . Weakly connected ') else : print ( 'd . Unconnected ') # d . Unconnected # 11 LWCC = max ( nx . w e a k l y _ c o n n e c t e d _ c o m p o n e n t s ( D ) , key = len ) print ( ' The largest weakly connected component has ' , len ( LWCC ) , ' nodes ') # The largest weakly connected component has 11909 nodes

Exercise 4.11. Let us search for the hashtag #2020: import itertools NUM_TWEET S _T O _ FE T C H = 1000

20

cursor = twitter . cursor ( twitter . search , q = ' #2020 ' , count =100 , result_type = ' recent ') search_tweets = list ( itertools . islice ( cursor , N U M _T W E ET S _ TO _ F ET C H )) len ( search_tweets ) # 1000 # build the network R2020 = nx . DiGraph () for tweet in search_tweets : if ' retweeted_status ' not in tweet : continue retweeted_status = tweet [ ' retweeted_status '] retweeted_sn = retweeted_status [ ' user ' ][ ' screen_name '] retweeter_sn = tweet [ ' user ' ][ ' screen_name '] if retweeted_sn == retweeter_sn : continue if R2020 . has_edge ( retweeted_sn , retweeter_sn ): R2020 . edges [ retweeted_sn , retweeter_sn ][ ' weight '] += 1 else : R2020 . add_edge ( retweeted_sn , retweeter_sn , weight =1) # 1 singletons = [] for n in R2020 . nodes (): if R2020 . degree ( n ) == 0: singletons . append ( n ) for n in singletons : R2020 . remove_node ( n ) import matplotlib . pyplot as plt plt . figure ( figsize =(10 ,8)) node_size_list = [20 * R2020 . degree ( n ) for n in R2020 . nodes ()] edge_weight_list = [2 * R2020 . edges [ e ][ ' weight '] for e in R2020 . edges ()] nx . draw ( R2020 , node_size = node_size_list , width = edge_weight_list )

21

# 2 most_retw e et e d _u s e r = max ( R2020 . nodes () , key = R2020 . out_degree ( weight = ' weight ' )) print ( ' Most retweeted user for #2020 is ' , '@ '+ m o s t_ r e tw e e te d _ us e r ) # Most retweeted user for #2020 is @ANI

3. Observations will depend on hashtag. We typically observe heterogeneity in degree, perhaps in weights as well.

Exercise 4.12. We can compute the correlation(s) for a generic dataset file: def c o r r _ d e g r e e _ w e i g h t _ u n d i r e c t e d ( edgesfile ): G = nx . read_edgelist ( edgesfile , data =[( ' weight ' , int )]) degrees = [ G . degree ( n ) for n in G . nodes ()] strengths = [ G . degree (n , weight = ' weight ') for n in G . nodes ()] r , _ = scipy . stats . pearsonr ( degrees , strengths ) return r def c o r r _ d e g r e e _ w e i g h t _ d i r e c t e d ( edgesfile ): D = nx . read_edgelist ( edgesfile , data =[( ' weight ' , float )]) in_degrees = [ G . in_degree ( n ) for n in G . nodes ()] in_strengths = [ G . in_degree (n , weight = ' weight ') for n in G . nodes ()] out_degrees = [ G . out_degree ( n ) for n in G . nodes ()] out_strengths = [ G . out_degree (n , weight = ' weight ') for n in G . nodes ()] r_in , _ = scipy . stats . pearsonr ( in_degrees , in_strengths ) r_out , _ = scipy . stats . pearsonr ( out_degrees , out_strengths ) return ( r_in , r_out ) # weighted , undirected network ( s ) print ( 'co - star network : correlation = ' , c o r r _ d e g r e e _ w e i g h t _ u n d i r e c t e d ( ' actors_costar . edges ' )) # co - star network : correlation = 0. 89 09 51 91 36 33 64 09 # weighted , directed networks for dataset in [ ' retweet - digraph ' , ' email - Enron ' , ' celegansneural ' , ' eco - everglades ' ]: r_in , r_out = c o r r _ d e g r e e _ w e i g h t _ d i r e c t e d ( dataset + '. edges ') print ( dataset , ': corr_in = ' , r_in , ' corr_out = ' , r_out ) # retweet - digraph : corr_in = 1.0 corr_out = 1.0 # email - Enron : corr_in = 1.0 corr_out = 1.0 # celegansneural : corr_in = 1.0 corr_out = 1.0 # eco - everglades : corr_in = 1.0 corr_out = 1.0

We observe that nodes with high degree tend to also have large stregth.

Exercise 4.13. Let us use a copy of the #2020 retweet network:

22

def r e m o v e _ e d g e s _ b e l o w _ t h r e s h o l d (D , theta ): ed ge s _ b e l o w _ t h r e a s h o l d = [] for e in D . edges (): if D . edges [ e ][ ' weight '] < theta : e d g e s _ b e l o w _ t h r e a s h o l d . append ( e ) for i , j in e d g e s _ b e l o w _ t h r e a s h o l d : D . remove_edge (i , j ) D2020 = R2020 . copy () density = {} N = D2020 . number_of_nodes () number_of_pairs = N * ( N - 1) weights = [ D2020 . edges [ e ][ ' weight '] for e in D2020 . edges ()] for threshold in range (0 , max ( weights )+1): r e m o v e _ e d g e s _ b e l o w _ t h r e s h o l d ( D2020 , threshold ) density [ threshold ] = D2020 . number_of_edges ()/ number_of_pairs # 1 import matplotlib . pyplot as plt plt . plot ( density . keys () , density . values ()) plt . xlabel ( ' threashold ') plt . ylabel ( ' density ') plt . yscale ( ' log ') # 2 percent_drop = ( density [0] - density [3]) * 100 / density [0] print ( " Density drops %.1 f %% with a threshold of 3 retweets " % ( percent_drop )) # Density drops 99.7% with a threshold of 3 retweets # 3 half_init i a l _ d e n s i t y = density [0] / 2 for threshold in range (0 , max ( weights )+1): if density [ threshold ] <= h a l f _ i n i t i a l _ d e n s i t y : print ( ' Density is reduced below half for threshold ' , threshold ) break # Density is reduced below half for threshold 2

Chapter 5 Exercise 5.2. Both models generate networks with a fixed number of nodes N . In the model by Erdős and Rényi a fixed number of edges L are set between randomly selected pairs of nodes, whereas in the one by Gilbert an edge is set between each pair of nodes with a given probability p. This way the number of edges varies for different network realizations, 23

though the values remain concentrated around the expected number pN (N − 1)/2.

Exercise 5.3. The expected number of links in Gilbert’s random graph model is hLi = pN (N − 1)/2. If we want hLi = 3000 and N = 1000 we need to have p = 2hLi/[N (N − 1)] = 0.006.

Exercise 5.4. The average node degree hki = p(N − 1) (Eq. 5.2), so p = hki/(N − 1). For N = 50 and hki = 10, p = 10/49 ≈ 0.2.

Exercise 5.5. Equation (5.5) gives a rough estimate of the diameter `max of the network: `max = log N/ loghki = log 50/ log 10 ∼ 1.7. Since the diameter is the longest shortest path of the network, the average cannot be larger than the diameter, so the answer is (a).

Exercise 5.6. We can check using this function: def APL (N , avk =10): p = avk / (N -1) G = nx . gnp_random_graph (N , p ) return nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( G )

We get h`i ≈ 2.9 for N = 500, so the answer is (d). Another approach is to use Equation (5.5), which gives a rough estimate of the diameter as well as the average path length of the network: h`i ≈ log N/ loghki. For h`i = 3 and hki = 10 we get: log N ≈ h`i loghki = 3 log 10 = log 1000, so N ≈ 1000. The closest answer is (d).

Exercise 5.7. The numerical answers depend on the specific realization of the network, however they should be close to the values reported below: G = nx . gnp_random_graph (1000 , 0.002) # 1 max ([ G . degree ( n ) for n in G . nodes ]) # 8 # 2 from collections import Counter counter = Counter ([ G . degree ( n ) for n in G . nodes ]) mode , number = counter . most_common (1)[0] print ( ' The mode is ' , mode , ' and ' , number , ' nodes have this degree ') # The mode is 1 and 285 nodes have this degree # 3 if nx . is_connected ( G ): print ( ' The network is connected ') else : print ( ' The network is not connected ') GC = sorted ( nx . c o n n e c t e d _ c o m p o n e n t _ s u b g r a p h s ( G ) , key = len , reverse = True )[0] print ( ' The giant component has ' , GC . number_of_nodes () , ' nodes ')

24

# The network is not connected # The giant component has 795 nodes # 4 nx . average _c lu st er in g ( G ) # 0.00 186 6 6 6 6 6 6 6 6 6 6 6 6 6 6 # 5 # since the network is not connected , let us # calculate the diameter on the giant component nx . diameter ( GC ) # 20

As expected, the average clustering coefficient is close to the expected value p = 0.002.

Note that we knew from part 3 that the network was not connected, therefore in part 5 we computed the diameter of the giant component.

Exercise 5.8. The question is equivalent to asking what is the number of possible links that a network with N nodes can have. The answer is N (N − 1)/2.

Exercise 5.9. b. Increases slowly until some threshold, increases very quickly for a short time, and then increases slowly afterwards. As we have seen in Section 5.1 and Figure 5.2, the giant component emerges suddenly near a critical threshold, grows rapidly for a while, then slowly until all nodes join it.

Exercise 5.10. Here is Python code using NetworkX: from statistics import mean , stdev averages = [] errors = [] ps = [ i /5000 for i in range (26)] for p in ps : GC_ratios = [] for _ in range (20): G = nx . gnp_random_graph (1000 , p ) GC_ratios . append ( len ( max ( nx . c o n n e c t e d _ c o m p o n e n t s ( G ) , key = len ))/1000) averages . append ( mean ( GC_ratios )) errors . append ( stdev ( GC_ratios )) plt . errorbar (p , averages , yerr = errors ) plt . xlabel ( 'p ') plt . ylabel ( ' relative size of giant component ')

25

Exercise 5.11. d. Random networks have low clustering coefficients Exercise 5.12. Due to the symmetry each node has the same clustering coefficient. Since it depends only on the neighborhood of the node, the size of the network plays no role. In the diagram below we isolate one node (black dot) and its neighbors (blue dots), along with their mutual connections. The connections between neighbors are indicated in red. Of the six possible links, three are present (continuous red lines) and three are missing (dashed red lines), so the clustering coefficient of the black node is 3/6=1/2.

Exercise 5.13. d. High clustering coefficient. Both the Watts-Strogatz model and ErdősRényi random graphs have the small-world property (short average path lengths).

Exercise 5.14. Here is code to generate the plot. Note this will take a while to run. from statistics import mean APL_averages = [] C_averages = [] ps = [ i /20 for i in range (21)] for p in ps : print ( 'p = ' , p , ' ... ' , end = " \ r " ) APLs = [] Cs = [] for _ in range (20): G = nx . w a t t s _ s t r o g a t z _ g r a p h (1000 , 4 , p ) APLs . append ( nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( G )) Cs . append ( nx . ave ra ge _c lu st er in g ( G )) APL_averages . append ( mean ( APLs ))

26

C_averages . append ( mean ( Cs )) norm_APL_a verag es = [ x / APL_averages [0] for x in APL_averages ] norm_C_averages = [ x / C_averages [0] for x in C_averages ] plt . plot ( ps , norm_APL_averages , label = " APL " ) plt . plot ( ps , norm_C_averages , label = " C " ) plt . xlabel ( 'p ') plt . ylabel ( ' relative quantity ') plt . legend ()

Exercise 5.15. We start with a function that takes a degree sequence and returns a dictionary with the cumulative distribution (CCDF): import collections def CCDF ( degrees ): counter = collections . Counter ( degrees ) sorted_degrees = sorted ( list ( counter )) N = len ( degrees ) remaining = N cumcount = {} for d in sorted_degrees : cumcount [ d ] = remaining / N remaining -= counter [ d ] return cumcount

Use NetworkX to generate the networks and then plot the distributions: ps = [0.0001 , 0.001 , 0.01 , 0.1 , 1] for p in ps : G = nx . w a t t s _ s t r o g a t z _ g r a p h (1000 , 4 , p ) ccdf = CCDF ([ k for _ , k in G . degree ()]) plt . plot ( ccdf . keys () , ccdf . values () , label = 'p = '+ str ( p )) plt . xlabel ( 'k ') plt . ylabel ( ' CCDF ') plt . legend ()

27

Exercise 5.16. Note that when we use the configuration model to randomize links, we can generate a multi-graph — an undirected network with self-loops and/or more than one link between the same two nodes.

USAN = nx . read_edgelist ( " openflights_usa . edges " ) USAN_degr e e _ s e q u e n c e = [ USAN . degree ( n ) for n in USAN . nodes ] RUSAN = nx . c o nf i g ur a t io n _ mo d e l ( U S A N _ d e g r e e _ s e q u e n c e ) # 1 degree_dis tr_US AN = Counter ([ USAN . degree ( n ) for n in USAN . nodes ]) degree_dis tr _R US AN = Counter ([ RUSAN . degree ( n ) for n in RUSAN . nodes ]) i de nt i ca l _ d i s t r i b u t i o n s = True for n in d egree_ distr_ USAN : if deg ree_di str_US AN [ n ] != d eg re e_ di st r_ RU SA N [ n ]: i d e n t i c a l _ d i s t r i b u t i o n s = False break if id en t i c a l _ d i s t r i b u t i o n s : print ( ' The distributions are identical ') else : print ( ' The distributions are different ') # The distributions are different # 2 USAN_G = USAN . copy () if not nx . is_connected ( USAN ): USAN_G = sorted ( nx . c o n n e c t e d _ c o m p o n e n t _ s u b g r a p h s ( USAN ) , key = len , reverse = True )[0] print ( ' USAN is not connected , so we use the giant component ') print ( ' APL of USAN is ' , nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( USAN_G )) RUSAN_G = RUSAN . copy () if not nx . is_connected ( RUSAN ): RUSAN_G = sorted ( nx . c o n n e c t e d _ c o m p o n e n t _ s u b g r a p h s ( RUSAN ) , key = len , reverse = True )[0] print ( ' RUSAN is not connected , so we use the giant component ') print ( ' APL of RUSAN is ' , nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( RUSAN_G ))

28

# # # #

USAN is not connected , therefore we use the giant component APL of USAN is 3.1973 57077 335835 RUSAN is not connected , therefore we use the giant component APL of RUSAN is 2.954 284476 221428

# 3 print ( ' The average clustering coefficient of USAN is ' , nx . a ve ra ge _c lu st er in g ( USAN )) # the randomization can generate a multigraph , which causes # problems for calculating the clustering coefficient , # therefore we transform RUSAN into a simple network print ( ' The average clustering coefficient of RUSAN is ' , nx . a ve ra ge _c lu st er in g ( nx . Graph ( RUSAN ))) # The average clustering coefficient of USAN is 0.493 045386 882247 # The average clustering coefficient of RUSAN is 0. 19 73 88 25 68 43 22 29

The numerical values of APL and C for RUSAN depend on the specific configuration generated by the randomization of USAN. However, they should change little across configurations and be close to those reported below. The shortest paths, which are strongly affected by the presence of hubs, have approximately maintained their length after the degree-preserving randomization, on average. The average clustering coefficients are different: as expected, the random rewiring of the links has destroyed many of the original triangles.

Exercise 5.17. b. Hub nodes with degree many times larger than that of a typical node Exercise 5.18. 1. We can use the CCDF function shown in the solution of Ex. 5.15: # 1 BA = nx . b a r a b a s i _ a l b e r t _ g r a p h (1000 , 3) ccdf = CCDF ([ k for _ , k in BA . degree ()]) plt . plot ( ccdf . keys () , ccdf . values ()) plt . xlabel ( 'k ') plt . ylabel ( ' CCDF ') plt . xscale ( ' log ') plt . yscale ( ' log ')

29

The numerical values depend on the specific configuration generated by the model. However, they should change little across configurations and be close to those reported below. # 2 -- 5 print ( ' average degree : ' , 2 * BA . number_of_edges () / BA . number_of_nodes ()) print ( ' average clustering coefficient : ' , nx . a ve ra ge _c lu st er in g ( BA )) print ( ' is the network connected ? ' , nx . is_connected ( BA )) print ( ' APL : ' , nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( BA )) # average degree : 5.982 # average clustering coefficient : 0 . 0 30 0 3 17 9 1 09 8 4 87 7 3 # is the network connected ? True # APL : 3. 46 51 11 11 11 11 11 13

2. The average degree should be approximately 2m = 6 because each new node brings m links into the system, so it adds 2m units of degree. Tiny deviations from 2m are due to the initial configuration of the model, which is a clique with m nodes, so each of these nodes starts with degree m − 1 < 2m. 3. The average clustering coefficient indicates that not many triangles are formed, as expected. 5. Paths are very short on average, which confirms the role of hubs in shortening paths between nodes.

Exercise 5.19. 1. We can again use the CCDF function shown in the solution of Ex. 5.15: # 1 BA = nx . b a r a b a s i _ a l b e r t _ g r a p h (1000 , 3) ER = nx . gnm_random_graph ( BA . number_of_nodes () , BA . number_of_edges ()) ccdf_BA = CCDF ([ k for _ , k in BA . degree ()]) ccdf_ER = CCDF ([ k for _ , k in ER . degree ()]) plt . plot ( ccdf_BA . keys () , ccdf_BA . values () , label = ' BA ') plt . plot ( ccdf_ER . keys () , ccdf_ER . values () , label = ' ER ') plt . xlabel ( 'k ') plt . ylabel ( ' CCDF ') plt . xscale ( ' log ') plt . yscale ( ' log ') plt . legend ()

2. The numerical values depend on the specific configuration generated by the model. However, they should change little across configurations and be close to the following.

30

# 2 print ( ' Average clustering coefficient of BA : ' , nx . a ve ra ge _c lu st er in g ( BA )) print ( ' Average clustering coefficient of ER : ' , nx . a ve ra ge _c lu st er in g ( ER )) print ( ' APL of BA : ' , nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( BA )) if nx . is_connected ( ER ): print ( ' APL of ER : ' , nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( ER )) else : GC = sorted ( nx . c o n n e c t e d _ c o m p o n e n t _ s u b g r a p h s ( ER ) , key = len , reverse = True )[0] print ( ' APL of giant component of ER : ' , nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( GC )) # Average clustering coefficient of BA : 0 . 0 33 9 8 34 5 4 65 7 6 81 9 5 # Average clustering coefficient of ER : 0 . 0 0 7 3 6 9 7 5 8 0 1 9 7 5 8 0 1 3 5 # APL of BA : 3.4491 63163 163163 # APL of giant component of ER : 4.050 510095 750382

The much lower average clustering coefficient in the random network indicates that triangles are rare, more infrequent than for BA networks with equal number of nodes and links.

The random graph is not connected; the average path length for the giant component is appreciably larger than for BA networks with equal number of nodes and links. This is because there are no hubs in the network, so it takes more steps to go from one node to another, on average.

Exercise 5.20. There are two main differences between the attractiveness (A) and the fitness (F) model. First, in the A model the attractiveness constant enters as an additive term in the expression of the link probability, whereas in the F model the fitness enters as a factor. Second, the degree-independent appeal of a node is a constant in the A model while it is node-specific in the F model. This way, in the A model there is no way for newer nodes to overcome the degree-based advantage of the old nodes, which end up becoming hubs. In the F model, instead, new nodes with large fitness values may overcome the degree deficit with respect to old nodes with much lower fitness and become hubs.

Exercise 5.21. If ηj = kj for node j, the link probability for the fitness model P every 2 2 (Equation 5.12) becomes kj /( l kl ), so it takes the expression of the link probability of the non-linear preferential attachment (Equation 5.10) with α = 2. Therefore, we expect that one of the nodes will end up being connected to a fraction of all other nodes while all other nodes will have approximately the same (low) degree.

Exercise 5.22. In the BA model when m links are set between a new node and old nodes, the latter are selected exclusively based on their degree. The probability that two of the target nodes are connected to each other, such that they form a triangle with the new node, is as low as the network density.

Exercise 5.24. If we do link selection and the new node is wired to both endpoints, both nodes are chosen with probability proportional to their degrees, so we still have a preferential 31

attachment model in disguise. In addition we close one triangle with each pair of links, so the clustering coefficient is going to be very high. In the random walk model, the first node is always chosen at random, regardless of its degree, and both the average clustering coefficient and the shape of the degree distribution depend on the value of the parameter p.

Exercise 5.25. One option could be a variant of the random walk model, in which after choosing the first target node t at random, with some probability p the next m − 1 targets are selected among the neighbors of the neighbors of t, so as to close squares.

Exercise 5.26. The age of nodes leads to a strict ranking that does not change in time (because at each time step the age of each node increases by one unit, which does not alter the ranking). The degree instead changes at different paces for different nodes. However, there is a strong correlation between age and degree, so we do not expect that the ranking according to degree, albeit variable, changes too much during the evolution of the network (old nodes will typically be ranked higher than new ones). Therefore, if the rankings by age and degree are strongly correlated, the networks generated by the ranking model are very similar.

Exercise 5.27. Using NetworkX as usual: G = nx . read_edgelist ( " socfb - Northwestern25 . edges " ) N = G . number_of_nodes () L = G . number_of_edges () ER = nx . gnm_random_graph (N , L ) degrees = [ ER . degree ( n ) for n in ER . nodes ] # 1 print ( ' The 95 th percentile for degree is ' , int ( np . percentile ( degrees , 95))) # The 95 th percentile for degree is 108

2. True. The mean degree is hki = 2L/N , so as long as N and L do not change, hki stays the same. # 3 plt . hist ( degrees ) plt . xlabel ( ' degree ') plt . ylabel ( ' nodes ')

32

The degree distribution is normal (b): most node degrees are near the mean, dropping off rapidly in both directions. # 4 import random sum_shortest_path_lengths = 0 for _ in range (1000): i , j = random . sample ( ER . nodes () , 2) s u m _ s h o r t e s t _ p a t h _ l e n g t h s += nx . s h o r t e s t _ p a t h _ l e n g t h ( ER , i , j ) print ( ' The estimated APL is ' , s u m _ s h o r t e s t _ p a t h _ l e n g t h s / 1000) # The estimated APL is 2.432 # 5 print ( ' The average clustering coefficient is ' , nx . a ve ra ge _c lu st er in g ( ER )) # The average clustering coefficient is 0 . 0 0 8 7 4 3 5 3 9 8 5 8 7 5 9 4 4 7

Chapter 6 Exercise 6.2. In the diagram below, the community enclosed in the dashed contour is a weak community, because its internal degree, which equals twice the number of internal links, is 16, whereas the external degree (number of black stubs sticking out of the contour) is lower (9). However, it is not a strong community, because the green node has internal degree (2) lower than its external degree (3).

Exercise 6.3. The weak community condition is kCint > kCext , where kCint and kCext are the internal and external degree of a community C, respectively. Since kCint = 2LC , the condition can be written as LC > kCext /2. So if LC were, say, 2/3 of kCext the condition would hold but the number of internal links would be lower than the number of external links. In the figure we show an example of a weak community, enclosed in the dark contour. Here LC = 5, kCint = 2LC = 10 and kCext = 8 < kCint , but LC < kCext .

33

Exercise 6.4. Since each partition is totally identified by the group of two nodes, the number of partitions is the number of pairs of nodes out of N nodes: N (N − 1)/2.

Exercise 6.5. In a clique all nodes are connected to each other, so all partitions in two groups of N/2 nodes each are equivalent. The cut size is the number of links connecting the groups. Since there is a link between any node of the first group and every node of the 2 second group the cut size is N2 · N2 = N4 .

Exercise 6.6. The problems are not equivalent because even if one minimizes the separation between the clusters, the latter are not guaranteed to be communities because the density of internal links might not be high. A simple example is illustrated in the figure below. The dotted vertical line shows the best solution of the bisection problem for a chain-like network with eight nodes. The two clusters separated by the cut, however, cannot be considered communities, as they have the lowest possible density of internal links (they are both trees).

Exercise 6.7. The clusters found by the Kernighan-Lin algorithm are: K = nx . karate _club_ graph () nx . community . k e r n i g h a n _ l i n _ b i s e c t i o n ( K ) # ({8 ,14 ,15 ,18 ,20 ,22 ,23 ,24 ,25 ,26 ,27 ,28 ,29 ,30 ,31 ,32 ,33} , # {0 ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,9 ,10 ,11 ,12 ,13 ,16 ,17 ,19 ,21})

The two groups are basically the same as the groups generated by the split of the club. Only nodes 8 and 9 are misclassified.

Exercise 6.8. Since every time there is a merger the number of groups decreases by one and we start with N groups (singletons), the number of horizontal lines of the dendrogram is N , regardless of the network and its specific features.

Exercise 6.9. Let us first verify that the max-modularity partition returned by the GirvanNewman (GN) algorithm is the one with five clusters:

34

K = nx . karate _club_ graph () partitions = nx . community . girvan_newman ( K ) max_mod_pa rtiti on = max ( partitions , key = lambda p : nx . community . quality . modularity (K , p )) print ( ' The GN partition with max modularity ' , nx . community . quality . modularity (K , ma x_mod_ partit ion ) , ' has ' , len ( max _mod_p artiti on ) , ' clusters ') # The GN partition with max modularity 0.40129848784 has 5 clusters

Greedy modularity optimization requires NetworkX version 2.2 or later. It delivers a partition in three clusters: greedy_mo d _ p a r t i t i o n = nx . community . g r e e d y _ m o d u l a r i t y _ c o m m u n i t i e s ( K ) print ( ' The greedy partition with max modularity ' , nx . community . quality . modularity (K , g r e e d y _ m o d _ p a r t i t i o n ) , ' has ' , len ( g r e e d y _ m o d _ p a r t i t i o n ) , ' clusters ') # The GN partition with max modularity 0.38067061143 has 3 clusters

The greedy modularity algorithm returns a partition with lower modularity than the GN algorithm’s best partition.

Exercise 6.10. In a bipartite network with NA and NB nodes in classes A and B, respectively, there are no links within the clusters corresponding to the classes. So, in modularity’s equation 6.4 LC is zero for C = A and C = B and the degree kC of both clusters is the number of links L of the network, as the degree of cluster A (B) concides with the external degree, i.e. with the number of links joining A (B) with B (A). Therefore, the modularity for the bipartition {A, B} is L2 1 L2 − − =− , 2 2 4L 4L 2 independently of the values of NA , NB and L. QA,B = −

Exercise 6.11. Let us consider the general case of a partition P into q > 1 clusters, with N1 , N2 , . . . , Nq−1 , Nq nodes. To compute the modularity, for each cluster C we need to compute the number of internal links LC and its degree kC (see Equation 6.4). Since each cluster is a part of a clique, there are links between any two of its nodes, so LC = NC (NC − 1)/2. Also, each node has the same degree N − 1, as it is connected with all other nodes, so the degree of cluster C is kC = NC (N − 1).

X NC (NC − 1) N 2 (N − 1)2 − C2 QP = N (N − 1) N (N − 1)2 C P P N [ C (NC2 − NC )] − (N − 1) C NC2 = N 2 (N − 1) P P N C NC2 − N 2 − (N − 1) C NC2 = N 2 (N − 1) P 2 2 C NC − N = , N 2 (N − 1) 35

P P P where we have used C NC = N . Since ( C NC )2 = N 2 we have C NC2 < N 2 (unless NC = N for one cluster and zero for all others, which would not give a valid q-partition), which implies that QP < 0.

Exercise 6.12. Due to the symmetry of the network, we just have to compute the contribution to modularity of any cluster and multiply it by the number of clusters. From Equation 6.4 for each cluster we need to know the number of internal links LC and its degree kC . For the partition into 16 communities, corresponding to the 4-cliques, LC = 6 and kC = 14, the number of links of the network being 112. So, the partition into 16 4-cliques has modularity Q16 given by

142 6 1 89 6 − = − = ≈ 0.795.

Q16 = 16 2 112 4 · 112 7 16 112 For the partition into eight clusters obtained by combining consecutive cliques, LC = 13, kC = 28, and we obtain

13 282 13 1 45 Q8 = 8 − = − = ≈ 0.804.

2 112 4 · 112 14 8 56 Exercise 6.13. The schematic figure highlights the two clusters A and B and the rest of the network (grey oval).

A

B The contribution to modularity of the rest of the network, however it is subdivided, is the same for both partitions (Equation 6.4); we call it QR . Let QA,B and QA+B be the modularity scores of the partitions where A and B are distinct clusters or merged into a single cluster, respectively. We can readily compute QA,B , as we have both the number of internal links of int ?

A and B (Lint A and LB ) and the degrees of the clusters (both equal to k ): int Lint Lint (k ? )2 Lint (k ? )2 (k ? )2 B A + LB A − + − + Q = − + QR R L 4L2 L 4L2 L 2L2 where L is the total number of links of the network. For QA+B we need to compute the number of internal links LA+B of the merged cluster and its degree kA+B . The number of internal links is given by the sum of the numbers of internal links of the clusters, plus the number LAB of links joining the clusters to each other, so

QA,B =

int LA+B = Lint A + LB + LAB .

The degree of the merged cluster is given by the sum of the degrees of A and B, so kA+B = 2k ? . Now we can compute QA+B : QA+B =

int Lint 4(k ? )2 A + LB + LAB − + QR , L 4L2

36

so the variation of Q between the two partitions is ∆Q = QA+B − QA,B =

int Lint Lint + Lint (k ? )2 (k ? )2 LAB (k ? )2 A + LB + LAB B − A − − + = .

L L L2 2L2 L 2L2

Therefore, the partition where A and B are merged has higher modularity if p ∆Q > 0 =⇒ k ? < 2LLAB . √ We conclude that it is convenient to merge clusters if their degree is smaller than 2LLAB .

Even if LAB = 1, which means that there is a single link joining A and B, which √ are then ? clearly separated from each other, it is still advantageous to merge them if k < 2L. Exercise 6.14. Be sure to have NetworkX version 2.4 or later for this exercise, or the label propagation algorithm might not converge. The code is very simple: K = nx . karate _club_ graph () print ( nx . community . a s y n _ l p a _ c o m m u n i t i e s ( K ))

Label propagation returns somewhat different partitions when executed multiple times.

One such partition has three communities: {0, 1, 3, 7, 11, 12, 13, 17, 19, 21}, {4, 5, 6, 10, 16}, and {2, 8, 9, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33}. Another has two clusters, one of them being {0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 16, 17, 19, 21}, whereas the other is {32, 33, 8, 9, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}. While these partitions are different, there is significant overlap among them and with the natural clusters of the network.

Exercise 6.15. This means that there are no links joining nodes of different blocks (the probability that there is a link between any two groups is zero), so the network is disconnected and has q connected components, corresponding to the blocks. Note, however, that there could be actually more than q connected components: if the probability of having links within any block is very low, that block could be in turn fragmented into smaller connected components. So the correct answer is that there are at least q connected components.

Exercise 6.16. Here is a function that generates a GN benchmark given the expected external degree: import itertools def GN_benchmark ( k_ext ): comm = [0 for i in range (128)] G = nx . Graph () G . add_nodes_from ( range (128)) # step 1 for i in range (128): comm [ i ] = i // 32 # step 2 p_ext = k_ext / 96.0 p_int = (16.0 - k_ext ) / 31.0

37

# step 3 for i , j in itertools . combinations ( G . nodes , 2): r = random . random () if comm [ i ] == comm [ j ]: if r < p_int : G . add_edge (i , j ) else : if r < p_ext : G . add_edge (i , j ) return G

Exercise 6.17. According to the definition in Section 6.4, a node is correctly classified if it, and at least half of the other nodes in the same community in the detected partition are in the same community in the benchmark partition. Below is a function that given a partition dictionary, calculates the fraction of correctly classified nodes. We determine the community of a node in the benchmark partition using the same rule used in the function defined in the previous exercise. Note that if a node is in a community by itself, we assume it is correctly classified: def fccn ( partition ): # first group members of each community members = {} for n in partition : c = partition [ n ] if c in members : members [ c ]. append ( n ) else : members [ c ] = [ n ] # then check each node correct_count = 0 for n in partition : ground_class = n // 32 # from ex 6.16 c = partition [ n ] fellow_count = 0 for member in members [ c ]: if member == n : continue if member // 32 == ground_class : fellow_count += 1 # special case : assume correct if node is alone if len ( members [ c ]) < 2: correct_count += 1 elif fellow_count / ( len ( members [ c ]) - 1) >= 0.5: correct_count += 1 return correct_count / len ( partition )

38

We can reuse the function defined in the previous exercise for the GN benchmark and the community module from the python-louvain package for the Louvain algorithm: import community from statistics import mean , stdev averages = [] errors = [] k_ext_values = [2 , 4 , 6 , 8 , 10 , 12 , 14] for k_ext in k_ext_values : correct_fraction = [] for _ in range (10): GN = GN_benchmark ( k_ext ) # from ex 6.16 partition = community . best_partition ( GN ) correct_fraction . append ( fccn ( partition )) averages . append ( mean ( correct_fraction )) errors . append ( stdev ( correct_fraction )) plt . errorbar ( k_ext_values , averages , yerr = errors ) plt . xlabel ( ' expected external degree ') plt . ylabel ( ' fraction of correctly detected nodes ')

We observe that as hk ext i increases, the similarity between the detected and planted partitions decreases. This is because the communities in the benchmark networks become harder to detect when there are more links connecting them.

Exercise 6.18. We can use the community module not only for the Louvain algorithm, but also to compute modularity: import community average_k = [] modularities = [] n_communities = [] Ls = [5000 , 10000 , 15000 , 20000 , 25000 , 30000] for L in Ls : RG = nx . gnm_random_graph (1000 , L ) average_k . append (2 * L / 1000) partition = community . best_partition ( RG ) n_communities . append ( max ( partition . values ()))

39

modularities . append ( community . modularity ( partition , RG )) print ( modularities )

The modularity values are not very close to zero: they start around Q ≈ 0.3 for L = 5000 and go down to Q ≈ 0.1 for L = 30000. The number of communities oscillates around 10: plt . plot ( average_k , n_communities ) plt . xlabel ( ' average degree ') plt . ylabel ( ' number of communities ')

This suggests that the Louvain algorithm can detect spurious communities in random networks, especially if they are not too dense.

Exercise 6.19. To compute the normalized mutual information (Equation(6.9)) we need to calculate the entropies defined in Box 6.3. The main ingredients are the probabilities that a randomly selected node belongs to cluster x of partition X (P (x)), to cluster y of partition Y (P (y)) and to both clusters x and y of X and Y (P (x, y)). In our case X is the partition including all nodes in one cluster, so P (x) = 1 (there is only one cluster x, comprising all nodes), and Y the partition in singletons, so P (y) = 1/N (for every cluster/singleton y).

The joint probability P (x, y) = 1/N , because the overlap between the only cluster of X and any cluster y of Y consists of a single node. From the probabilities above we can calculate the entropies: X H(X) = − P (x) log P (x) = 0, x

H(Y ) = −

X

P (y) log P (y) = log N,

y

H(X|Y ) = −

X

P (x, y) log[P (y)/P (x, y)] = −

x,y

X 1 y

N

log 1 = 0.

From these quantities we obtain NMI(X, Y ) = 0. This result is independent of any specific network feature. The NMI computes the similarity between groupings of objects. Once the groups are set, the score is uniquely determined by them, regardless of what objects we are talking about.

40

Exercise 6.20. Here are two functions to sample the network. For snowball sampling we use the NetworkX function that returns edges in breadth-first search order: def random_sample (G , n_nodes ): sampled_nodes = random . sample ( G . nodes , n_nodes ) return nx . subgraph (G , sampled_nodes ) def snowball_sample (G , n_nodes ): root = random . choice ( list ( G . nodes ())) ordered_edges = nx . bfs_edges (G , root ) ordered_nodes = [ root ] + [ v for _ , v in ordered_edges ] sampled_nodes = ordered_nodes [: n_nodes ] return nx . subgraph (G , sampled_nodes )

Let us read and sample the actor co-star network. We’ll ignore the weights: costar = nx . read_edgelist ( ' actors_costar . edges . gz ' , data =[( 'w ' , int )]) costar1k_random = random_sample ( costar , 1000) costar1k_s nowba ll = snowball_sample ( costar , 1000)

1. Let us compare the densities of the two subnetworks: print ( ' density of random sample : ' , nx . density ( costar1k_random )) print ( ' density of snowball sample : ' , nx . density ( co star1k _snowb all )) # density of random sample : 2. 60 26 02 60 26 02 60 25 e -05 # density of snowball sample : 0 . 0 0 6 7 6 4 7 6 4 7 6 4 7 6 4 7 6 5

The densities are not the same: the random subnetwork has much lower density because it is more likely to sample peripheral nodes with low degree (the majority) and less likely to sample hubs with high degree (the minority). Also it misses many of a sampled node’s links because the chances are low that it will sample the node’s neighbors. Snowball sampling gets all the links of a node and is more likely to find the hubs by following the links. 2. Let us compare the average path lengths. Note that the random subnetwork is not necessarily connected, whereas the snowball subnetwork is connected by definition: if nx . is_connected ( costar1k_random ): print ( ' APL of random sample is ' , nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( costar1k_random )) else : GC = max ( nx . c o n n e c t e d _ c o m p o n e n t _ s u b g r a p h s ( costar1k_random ) , key = len ) print ( ' APL of random sample giant component is ' , nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( GC )) print ( ' APL of snowball sample is ' , nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( co star1k _snowb all )) # APL of random sample giant component is 1. 33 33 33 33 33 33 33 33 # APL of snowball sample is 4.257 621621 621622

In fact the random subnetwork is not connected and we must focus on its giant component, which has a much shorter APL than the snowball subnetwork. A likely reason is the small 41

size of the random subnetwork’s giant component. 3. To compare the distributions we use the CCDF function defined in Ex. 5.15: ccdf_random = CCDF ([ k for _ , k in costar1k_random . degree ()]) ccdf_snowball = CCDF ([ k for _ , k in costa r1k_sn owball . degree ()]) plt . plot ( ccdf_random . keys () , ccdf_random . values () , label = " random sample " ) plt . plot ( ccdf_snowball . keys () , ccdf_snowball . values () , label = " snowball sample " ) plt . xlabel ( 'k ') plt . ylabel ( ' CCDF ') plt . legend ()

The distributions are very different: the snowball sampling preserves the heavy tail of the original network’s degree distribution, while the random sampling does not. In fact, we do not use log scale in the plot because the majority of nodes in the random subnetwork are singletons and we would not see k = 0 with log scale. The random sample method not only misses the hubs, but does not preserve the degree of the sample nodes.

Exercise 6.21. Let us use a snowball-sampled subnetwork as shown in the previous exercise. To find communities, let us use the Louvain algorithm from the community module (python-louvain package, see Section 6.3.2) and the label propagation algorithm, because they are fast. # two largest communities using LPA part_lpa = nx . a s y n _ l p a _ c o m m u n i t i e s ( cost ar1k_s nowbal l ) top2_lpa = sorted ( list ( part_lpa ) , key = len , reverse = True )[:2] # two largest communities using Louvain import community part_louvain = community . best_partition ( co star1k _snow ball ) part_louva in_di ct = {} for n , c in part_louvain . items (): part_louva in_dic t . setdefault (c , []). append ( n ) top2_louvain = sorted ( pa rt_lou vain_d ict . values () , key = len , reverse = True )[:2]

42

# a few stars in each community print ( ' Using LPA the top 2 communities include ' , random . sample ( top2_lpa [0] , 3) , ' and ' , random . sample ( top2_lpa [1] , 3)) print ( ' Using Louvain the top 2 communities include ' , random . sample ( top2_louvain [0] , 3) , ' and ' , random . sample ( top2_louvain [1] , 3)) # Using LPA the top 2 communities include # [ ' nm0933727 ', ' nm0000579 ', ' nm0149491 '] and # [ ' nm0269416 ', ' nm0688228 ', ' nm4001519 '] # Using Louvain the top 2 communities include # [ ' nm0000855 ', ' nm0005512 ', ' nm0605363 '] and # [ ' nm0001657 ', ' nm0001847 ', ' nm0371376 ']

The results are not consistent across community detection methods. When we inspect these stars, we note that the two largest communities detected by LPA include English-speaking and Italian actors, respectively. Both Louvain clusters have English-speaking stars, but those in the larger cluster are contemporary while those in the smaller one are deceased. These results depend on the random seed node of the snowball sample; you will find different results.

Exercise 6.22. Carefully following the hints, we read the network from file as undirected, remove self-loops, and apply core decomposition before running the Louvain community detection. Then we can color the nodes using the community labels: import community email = nx . read_edgelist ( ' email - Enron . edges . gz ' , create_using = nx . Graph () , data =[( ' weight ' , int )]) email . remove _edges _from ( nx . selfloop_edges ( email )) email_core = nx . k_core ( email , k =43) email_part _l ou va in = community . best_partition ( email_core ) colors = [ e ma il _p ar t_ lo uv ai n [ n ] for n in email_core . nodes ()] sizes = [ email_core . degree ( n ) for n in email_core . nodes ()] nx . draw ( email_core , node_color = colors , node_size = sizes )

The yellow community is the module at the right-hand side of Figure 0.4 43

Exercise 6.23. Let us follow the hints as in the previous exercise to focus on the network core, and again use the fast Louvain algorithm: import community W = nx . read_graphml ( ' enwiki_math . graphml . gz ') W = W . to_undirected () W . remove_edges _from ( nx . selfloop_edges ( W )) wiki_core = nx . k_core (W , k =30) wiki_part = community . best_partition ( wiki_core ) colors = [ wiki_part [ n ] for n in wiki_core . nodes ()] sizes = [ wiki_core . degree ( n ) for n in wiki_core . nodes ()] nx . draw ( wiki_core , node_color = colors , node_size = sizes )

Now let us look at a few pages in the five largest clusters: communities = {} for n , c in wiki_part . items (): communities . setdefault (c , []). append ( n ) top_n = 5 top_communities = sorted ( communities . items () , key = lambda x : len ( x [1]) , reverse = True )[: top_n ] for c in top_communities : page_sample = random . sample ( communities [ c [0]] , min ( len ( communities [ c [0]]) , 2)) print ( ' Cluster ' , c [0] , ': ' , [ W . nodes [ p ][ ' title '] for p in page_sample ]) # Cluster 8 : [ ' M a t h e m a t i c a l _ i n d u c t i o n ', ' M a t h e m a t i c a l _ f i n a n c e '] # Cluster 7 : [ ' Jean - Pierre_Serre ', ' Morton_Brown '] # Cluster 5 : [ ' Oscar_Zariski ', ' Oswald_Veblen '] # Cluster 0 : [ ' Al - Biruni ', ' Ulugh_Beg '] # Cluster 4 : [ ' W i l l i a m _ G e m m e l l _ C o c h r a n ', ' Jianqing_Fan ']

You can do some research about the topics of these pages and those in other clusters.

Exercise 6.24. We can try different values of k in the k core() function; we get a core with N ≈ 2000 for k = 19. Note that while we run Louvain community detection on the core, we use the degrees from the original network for node size: 44

import community routers = nx . read_edgelist ( ' tech - RL - caida . edges . gz ') router_core = nx . k_core ( routers , k =19) # N =2039 router_part = community . best_partition ( router_core ) colors = [ router_part [ n ] for n in router_core . nodes ()] sizes = [ routers . degree ( n ) for n in router_core . nodes ()] nx . draw ( router_core , node_color = colors , node_size = sizes )

Let’s find the cluster with largest average degree, again using the degree from the original network: from statistics import mean clusters = {} for n , c in router_part . items (): clusters . setdefault (c , []). append ( n ) av er ag e_c l u s t e r _ d e g r e e = {} for c in clusters : av er a g e _ c l u s t e r _ d e g r e e [ c ] = mean ([ routers . degree ( n ) for n in clusters [ c ]]) print ( ' The community with the largest hubs has average degree ' , round ( max ( a v e r a g e _ c l u s t e r _ d e g r e e . values ()))) # The community with the largest hubs has average degree 103

Modern Internet routers can have this many physical connections (ports). Wireless routers can also handle this many connections, but with a drop in connection speed.

Chapter 7 Exercise 7.2. Yes, because the pressure exerted by the active node 6 is 5 > 4. If the threshold is 5, node 1 is still activated because 5 ≥ 5. The weights of the links joining 1 to the nodes other from 6 are irrelevant because those nodes are not active, so the weights of their links do not enter the activation condition.

Exercise 7.3. The network is disconnected and in at least one connected component there are no active nodes. Therefore all nodes in that component remain inactive.

45

Exercise 7.4. Any of the nodes 2, 3, 5 and 8 would trigger a cascade leading to the activation of all nodes of the respective community to which they belong. For instance, if we activate node 2, node 1 would be activated as it has two neighbors, one of which is active (1), then node 3 would be activated, since it has two active neighbors out of three (1 and 2) and finally 4 would become active because 2/3 of its neighbors are active (2 and 3). The process stops there, however, because node 5 has four neighbors and only one of them is active (4), which is not sufficient to activate 5. So, in order to trigger a cascade that activates all nodes we need to activate at least one node in each community, e.g. 2 and 5.

Exercise 7.5. The expected number na of activated nodes is given by the product of the influence probability times the number of inactive neighbors. So na = 4 21 = 10 15 = 2 for both s and t, which then have the same influence.

Exercise 7.6. On average there will be 3.5 activated nodes. In fact, 1 is always activated by 2 because the influence probability 2 → 1 is one, and analogously 4 is always active when 1 is active. On the other hand 3 is activated by 4 with probability 1/2 and never by 2 (since the influence probability 2 → 3 is zero), so it will be active in half of the cascades, on average.

Exercise 7.7. d. The adoption of a specific smartphone among members of a community.

This is a social contagion process, where the person who has not yet bought a specific smartphone (susceptible) could be convinced to do so with a certain probability by acquaintances who have adopted it (infected), like in a standard SI process. In answer (c), the failure of a power station may lead to the overload and consequent failure of other power stations if enough power stations fail, which resembles more closely threshold models of social influence than epidemic models. Indeed, threshold models are regularly used to describe the dynamics of cascading failures.

Exercise 7.9. In the epidemic threshold condition of Equation 7.5 the basic reproduction number R0 is proportional to the average number of contacts (degree) hki. If a fraction f of the population is immune, the effective number of contacts of an individual will be on average (1 − f )hki < hki, hence the basic reproduction number is (1 − f )R0 < R0 and the risk of an epidemic spread is lower than in the case with no immune people. This holds for both SIS and SIR, as the condition of Equation 7.5 is valid for both models.

Exercise 7.10. From Equation 7.5 we see that the basic reproduction number R0 is proportional to the average number of contacts (degree) hki and inversely proportional to the recoevery rate µ. If we can decrease hki by a half, the reproduction number goes down to R0 /2 = 1.25, still above the threshold. So, if we can increase µ by a factor of 1.25 (25%) or more, we can bring R0 below one, and stop the epidemic.

Exercise 7.11. Let us follow the example in the Chapter 7 Tutorial and use the Simulation class in the simulation.py file. We need to slightly modify the initial state() and state transition() functions from the SIS model in the tutorial to account for the initial condition and recovered (R) state in the SIR model: 46

from simulation import Simulation def initial_state ( G ): state = {} for node in G . nodes : state [ node ] = 'S ' infected = random . sample ( list ( G . nodes ) , 10) for i in infected : state [ i ] = 'I ' return state def state_transition (G , current_state ): next_state = {} for node in G . nodes : if current_state [ node ] == 'I ': if random . random () < 0.5: next_state [ node ] = 'R ' elif current_state [ node ] == 'S ': for neighbor in G . neighbors ( node ): if current_state [ neighbor ] == 'I ': if random . random () < BETA : next_state [ node ] = 'I ' return next_state from collections import Counter # to count nodes by states def r u n _ u n t i l _ n o _ m o r e _ i n f e c t e d (): sim = Simulation ( nx . gnp_random_graph (1000 , 0.01) , initial_state , state_transition , name = ' SIR ') n_i = 10 n_i_timeline = [] while n_i > 0: n_i = Counter ( sim . state (). values ())[ 'I '] n_i_timeline . append ( n_i ) sim . run () n_i_max = max ( n_i_timeline ) steps_until_max = n_i_timeline . index ( n_i_max ) print ( ' BETA = ' , BETA , ': ' , n_i_max , ' infected after ' , steps_until_max , ' steps ') for BETA in [0.02 , 0.05 , 0.1 , 0.2]: r u n _ u n t i l _ n o _ m o r e _ i n f e c t e d () # BETA = 0.02 : 10 infected after 0 # BETA = 0.05 : 10 infected after 0 # BETA = 0.1 : 166 infected after 8 # BETA = 0.2 : 355 infected after 6

steps steps steps steps

When β is low, no more individuals are infected. When β is high enough, a portion of the 47

population is infected; the larger β, the more individuals are infected and the faster. But these are not huge outbreaks. We expect a major outbreak above the epidemic threshold: R0 = β/µ = β/0.5 > 1 or β > 0.5. Let’s try: BETA = 0.55 r u n _ u n t i l _ n o _ m o r e _ i n f e c t e d () # BETA = 0.55 : 673 infected after 3 steps

Now that R0 > 1, the epidemic infects the majority of the population.

Exercise 7.12. The dynamic of the process is identical to the rumor spreading model described in Section 7.2.2. So, there is no threshold effect here, and even a low β can lead to a major spread in aggressive behavior, on any kind of network.

Exercise 7.13. There are ten active links.

Exercise 7.14. By selecting links at random, nodes are sampled with probability proportional to their degree (Section 3.3). If the nodes have approximately the same degree, we do not expect any important difference in the dynamics. If the network has a heavy-tailed degree distribution, instead, hubs will be selected much more often than low-degree nodes, which can have important consequences on the development of the dynamics; for example, it can accelerate spreading processes.

Exercise 7.15. We can follow the examples in the Chapter 7 tutorial for the initial state and state transition functions. However, due to oscillations, this model may not converge to a stationary state with synchronous updates. Let us therefore follow the hint and update the states asynchronously and in random order in the state transition function: def initial_state ( G ): state = {} for node in G . nodes : if random . random () < 0.5: state [ node ] = 0 else : state [ node ] = 1 return state # asynchronous updates in random order ! def state_transition (G , current_state ): state = current_state . copy () shuffled_nodes = list ( G . nodes ()) random . shuffle ( shuffled_nodes ) for node in shuffled_nodes : sum = 0 for neigh in G . neighbors ( node ): sum += state [ neigh ] double_sum = 2 * sum if double_sum > G . degree ( node ):

48

state [ node ] = 1 elif double_sum < G . degree ( node ): state [ node ] = 0 else : if random . random () < 0.5: state [ node ] = 1 else : state [ node ] = 0 return state

To run the model until convergence to a stationary state, if using the Simulation class from the tutorial, we have to write a function that implements a stopping condition. Alternatively we can run the model without the Simulation class, but we still need a function to determine if the model has converged. This one takes two state dictionaries and returns True if they are identical. Note that this could happen even if some states are still unstable, so we have to double check that all states are stable: def convergence (G , old , new ): for n in old : if old [ n ] != new [ n ]: return False # make sure that all states are stable for n in new : concordant_neighbors = 0 for neighbor in G . neighbors ( n ): if new [ neighbor ] == new [ n ]: c o n c o r d a n t _ n e i g h b o r s += 1 if c o n c o r d a n t _ n e i g h b o r s * 2 <= G . degree ( n ): return False return True

Now let us run the model on the grid network. The solution below does not use the Simulation class: from collections import Counter grid = nx . grid_2d_graph (20 ,20) consensus_runs = 0 opinion_one = [] active_links = [] for _ in range (100): old_state = initial_state ( grid ) while True : new_state = state_transition ( grid , old_state ) if convergence ( grid , old_state , new_state ): break old_state = new_state counts = Counter ( new_state . values ())

49

if counts [0] == 0 or counts [1] == 0: consensus_runs += 1 else : opinion_one . append ( counts [1]) active = 0 for i , j in grid . edges (): if new_state [ i ] != new_state [ j ]: active += 1 active_links . append ( active ) print ( '% d %% of the runs lead to consensus ' % ( consensus_runs )) # 69% of the runs lead to consensus

Finally we can plot the histograms of the proportion of opinion one and fraction of active links in the non-consensus stationary states: fraction_one = [ n1 /400 for n1 in opinion_one ] plt . hist ( fraction_one ) plt . xlabel ( ' proportion of opinion one in non - consensus states ') plt . ylabel ( ' runs ')

act ive_ li n k s _ f r a c t i o n = [ na / grid . number_of_edges () for na in active_links ] plt . hist ( a c t i v e _ l i n k s _ f r a c t i o n ) plt . xlabel ( ' fraction of active links in non - consensus states ') plt . ylabel ( ' runs ')

50

Exercise 7.16. Let us reuse the state transition and convergence functions from the solution to the previous exercise. However, we can pass p as a parameter to the initial state function: def initial_state_p (G , p ): state = {} for node in G . nodes : if random . random () < p : state [ node ] = 1 else : state [ node ] = 0 return state

Let us now run the model without using the tutorial’s Simulation class: from collections import Counter from statistics import mean grid = nx . grid_2d_graph (20 ,20) ps = [0.1 , 0.2 , 0.3 , 0.4 , 0.5 , 0.6 , 0.7 , 0.8 , 0.9] exit_prob = [] for p in ps : opinion_one = [] for _ in range (20): old_state = initial_state_p ( grid , p ) while True : new_state = state_transition ( grid , old_state ) if convergence ( grid , old_state , new_state ): break old_state = new_state counts = Counter ( new_state . values ()) if counts [0] == 0 or counts [1] == 0: opinion_one . append ( counts [1] / 400) if opinion_one : # might be empty exit_prob . append ( mean ( opinion_one ))

51

else : exit_prob . append ( None ) plt . plot ( ps , exit_prob ) plt . xlabel ( 'p ') plt . ylabel ( ' exit probability ')

Exercise 7.17. Let us reuse the initial state function from the solution of the previous exercise. The state transition and convergence functions must be updated for the voter model: # asynchronous updates in random order ! def state_transition (G , current_state ): state = current_state . copy () shuffled_nodes = list ( G . nodes ()) random . shuffle ( shuffled_nodes ) for node in shuffled_nodes : neighbor = random . choice ( list ( G . neighbors ( node ))) state [ node ] = state [ neighbor ] return state def convergence ( old , new ): for n in old : if old [ n ] != new [ n ]: return False # make sure that all states are stable # which for the voter model is consensus n1 = 0 for n in new : n1 += new [ n ] if n1 > 0 and n1 < len ( new ): return False return True

Let us again run the model without using the tutorial’s Simulation class: 52

from collections import Counter from statistics import mean grid = nx . grid_2d_graph (20 ,20) ps = [0.1 , 0.2 , 0.3 , 0.4 , 0.5 , 0.6 , 0.7 , 0.8 , 0.9] exit_prob = [] for p in ps : opinion_one = [] for _ in range (20): old_state = initial_state_p ( grid , p ) while True : new_state = state_transition ( grid , old_state ) if convergence ( old_state , new_state ): break old_state = new_state counts = Counter ( new_state . values ()) opinion_one . append ( counts [1] / 400) exit_prob . append ( mean ( opinion_one )) plt . plot ( ps , exit_prob ) plt . xlabel ( 'p ') plt . ylabel ( ' exit probability ')

Exercise 7.18. For two opinions oi and oj not to affect each other their difference must exceed : |oi − oj | > . Let us start considering the boundaries of the range, near opinions zero and one. The centers of the outermost opinion clusters are expected to be at a distance from the extremes of the range, around position and 1 − , respectively. This is because all opinions within from the centers will be attracted towards them. For the same reason, all opinions within of the center of each of those clusters, toward the center, are expected to belong to that cluster. So we have that within a segment of size approximately 2 on either extreme of the opinion range, one opinion cluster will emerge. By working our way toward the center of the opinion range, and repeating the same argument, we conclude that there will be as many clusters as there are segments of size 2 within the opinion range, so 53

the expected number of clusters is approximately 1/2 .

Exercise 7.19. We can adapt the examples in the Chapter 7 tutorial for the initial state and state transition functions to the bounded-confidence model. We update the states asynchronously and in random order. We also need a function to check the stop condition: def initial_state ( G ): state = {} for node in G . nodes : state [ node ] = random . random () return state # asynchronous updates in random order def state_transition (G , current_state , epsilon , mu ): state = current_state . copy () shuffled_nodes = list ( G . nodes ()) random . shuffle ( shuffled_nodes ) for node in shuffled_nodes : neigh = random . choice ( list ( G . neighbors ( node ))) if abs ( state [ node ] - state [ neigh ]) < epsilon : oi = state [ node ] + mu * ( state [ neigh ] - state [ node ]) oj = state [ neigh ] + mu * ( state [ node ] - state [ neigh ]) state [ node ] = oi state [ neigh ] = oj return state def convergence ( old , new ): for n in old : if abs ( old [ n ] - new [ n ]) >= 0.01 * old [ n ]: return False return True

Now we can run the simulations. This solution does not use the Simulation class from the tutorial. We plot a histogram of the final opinions for each value of and µ: complete = nx . complete_graph (1000) fig = plt . figure ( figsize =(10 ,10)) epsilons = [0.125 , 0.25 , 0.5] mus = [0.1 , 0.3 , 0.5] i = 0 for eps in epsilons : for mu in mus : i += 1 old_state = initial_state ( complete ) while True : new_state = state_transition ( complete , old_state , eps , mu ) if convergence ( old_state , new_state ):

54

break old_state = new_state plt . subplot (3 , 3 , i ) plt . xlim (0 ,1) plt . hist ( new_state . values ()) plt . title ( ' epsilon = ' + str ( eps ) + ' , mu = ' + str ( mu )) plt . xlabel ( ' opinion ') plt . ylabel ( ' nodes ') plt . tight_layout () plt . show ()

The number of opinion clusters decreases as increases, according to the relationship discussed in the previous exercise. The value of µ does not affect the number of opinion clusters.

Exercise 7.20. Let us reuse the initial state, state transition, and convergence functions from the solution of the previous exercise. Let us encapsulate the bounded-confidence model in a function that runs the simulation and produces histograms for a given network and set of values: def plot_ b cm _ h is t o gr a m s (G , epsilon_values ): fig = plt . figure ( figsize =(15 ,3)) i = 0

55

for eps in epsilon_values : i += 1 old_state = initial_state ( G ) while True : new_state = state_transition (G , old_state , eps , 0.5) if convergence ( old_state , new_state ): break old_state = new_state plt . subplot (1 , len ( epsilon_values ) , i ) plt . xlim (0 ,1) plt . hist ( new_state . values ()) plt . title ( ' epsilon = ' + str ( eps )) plt . xlabel ( ' opinion ') plt . ylabel ( ' nodes ') plt . tight_layout () plt . show ()

From the previous exercise, we know that c must be between 0.25 and 0.5. We can explore values of in this range and use histograms as in the previous exercise to count the number of opinion clusters: RN = nx . gnp_random_graph (1000 , 0.1) plot_bcm_ h is t o gr a m s ( RN , [0.25 , 0.3 , 0.35 , 0.4 , 0.45 , 0.5])

From these histograms we see that c must be between 0.25 and 0.3 — let us further explore this range: plot_bcm_ h is t o gr a m s ( RN , [0.25 , 0.26 , 0.27 , 0.28 , 0.29 , 0.3])

We conclude that c ≈ 0.27 for the random network. Similarly for the small-world network, let us start from the same guess: SW = nx . w a t t s _ s t r o g a t z _ g r a p h (1000 , 4 , 0.01) plot_bcm_ h is t o gr a m s ( SW , [0.25 , 0.3 , 0.35 , 0.4 , 0.45 , 0.5])

56

We observe that the high clustering coefficient makes is harder for narrow clusters to form.

For between 0.45 and 0.5 there is a transition from three to one cluster: plot_bcm_ h is t o gr a m s ( SW , [0.45 , 0.46 , 0.47 , 0.48 , 0.49 , 0.5])

We conclude ≈ 0.46.

Exercise 7.21. We expect just two opinion communities, one for each opinion, of approximately equal size. Since nodes predominantly get connected with nodes of the same opinion, eventually there will only be links between nodes with the same opinion. If there are just two opinions, we expect the formation of two communities. The sizes are approximately the same because, since opinions are assigned at random among the nodes, there will be an approximately equal number of nodes of either opinion. Assuming the network is not too sparse, there will be enough links within each of the two communities so that each will be connected.

Exercise 7.22. For p close to one, we have the formation of as many communities as there are opinions, provided the network is not too sparse, like before. For p close to zero the network barely changes, and the majority dynamics will operate until it reaches a stable opinion configuration in each of the connected components of the network. However, the stable configuration might not be consensus, as it happens on a grid (Section 7.3.1). In fact, if the underlying network is a random graph, consensus is almost never reached.

Exercise 7.23. Here is a function that implements the greedy search algorithms: def greedy_search (G , source , target ): current = source steps = 0 while current != target : distance = {} for n in G . neighbors ( current ): distance [ n ] = nx . s h o r t e s t _ p a t h _ l e n g t h (G , n , target ) nearest = min ( distance , key = distance . get ) current = nearest

57

steps += 1 return steps

To better interpret the results, let us compare the number of steps taken by greedy search with the average shortest path length: ps = [0.001 , 0.01 , 0.1 , 1] for p in ps : SM = nx . w a t t s _ s t r o g a t z _ g r a p h (1000 , 4 , p ) APL = nx . a v e r a g e _ s h o r t e s t _ p a t h _ l e n g t h ( SM ) sum = 0 for _ in range (100): t , s = random . sample ( list ( SM . nodes ()) , 2) sum += greedy_search ( SM , s , t ) print ( 'p = ' , p , ': APL = ' , APL , ' , average greedy steps = ' , sum /100) # p = 0.001 : APL = 88.10 842042 042042 , average greedy steps = 92.87 # p = 0.01 : APL = 30 .1 74 67 26 72 67 26 74 , average greedy steps = 31.69 # p = 0.1 : APL = 9.02561161161161 , average greedy steps = 9.22 # p = 1 : APL = 5.35521921921922 , average greedy steps = 5.24

As the networks become more random the shortest paths become shorter, and greedy search is able to find paths whose length is very close to optimal.

Exercise 7.24. The topical distance in the figure is four.

58