Network Analysis Exercises in R: 20 Practice Problems with igraph

Explanation: graph_from_data_frame() is the workhorse constructor when your raw data is a tidy edge list, which is how networks are usually stored in databases or CSV exports. The first two columns become the edge endpoints; any extra columns become edge attributes automatically. Passing directed = FALSE produces an undirected graph (note the UN-- flag in the summary). For directed networks (followers, citations, transactions), set directed = TRUE.

Explanation: These four predicates are the first thing you check on any graph object: shape (n, m), orientation (directed yes/no), and whether the data is clean (no self-loops, no parallel edges). is_simple() returns FALSE if the graph has either loops or multi-edges, and the common fix is simplify(g, remove.multiple = TRUE, remove.loops = TRUE). Confirming simplicity early prevents subtle metric bugs: degree counts double-count multi-edges, and shortest-path algorithms treat self-loops as zero-cost detours.

Explanation: Vertex attributes are how you carry "real-world meaning" inside the graph object so that downstream filtering, coloring, and community comparison work without external joins. The pattern V(g)$attr <- value assigns; V(g)$attr reads. Indexing dept_map by V(g)$name is the safe alignment trick: it tolerates a different vertex order than the source data. Edge attributes follow the symmetric pattern with E(g)$weight <- ....

Explanation: Degree is the simplest and most interpretable centrality: the number of incident edges. Top-degree nodes are usually your "hub" candidates for seeding diffusion experiments, but degree alone is biased toward visibility, not structural importance, which is why we layer in betweenness and eigenvector centrality later. For directed graphs, pass mode = "in", "out", or "all" to distinguish follower count from following count.

Explanation: degree_distribution() returns probabilities indexed from degree 0 upward, which is convenient for fitting a power-law tail with fit_power_law() from igraph. The Barabasi-Albert model produces a heavy-tailed distribution because new nodes preferentially attach to high-degree existing nodes, a process that shows up empirically in citation networks, web graphs, and protein interactions. If the head of the distribution looks roughly geometric instead, suspect Erdos-Renyi sampling, not preferential attachment.

Explanation: Density is the ratio of observed edges to the maximum possible (n*(n-1)/2 for undirected simple graphs), useful for comparing graphs of different sizes. Global transitivity is the proportion of connected triples that are closed into triangles, a classic measure of "small-world" structure. Real social networks typically show transitivity of 0.1 to 0.6 versus near-zero for random Erdos-Renyi graphs at the same density. Pass type = "local" to get a per-vertex clustering coefficient instead.

Explanation: Betweenness counts the fraction of shortest paths through each vertex, so high-betweenness nodes act as bottlenecks ("brokers") whose removal would fragment the graph. In Zachary's karate club, vertices 1 (the instructor) and 34 (the president) score highest, which matches the historical split. For graphs above ~10,000 nodes the exact algorithm gets expensive; pass cutoff = k to estimate from paths of length <= k, or use estimate_betweenness().

Explanation: Closeness is the reciprocal of mean geodesic distance to every other vertex, so high-closeness nodes can reach the whole graph in few hops. Normalization (normalized = TRUE) scales by n-1 so values are comparable across graph sizes. Closeness is poorly defined on disconnected graphs because some pairs have infinite distance; in practice, compute it on the largest connected component (use components() and induced_subgraph()). Closeness and betweenness often disagree: a node can be close to many others without being a broker.

Explanation: Eigenvector centrality is recursive: your score is proportional to the sum of your neighbors' scores. Mathematically it is the leading eigenvector of the adjacency matrix. It often disagrees with raw degree because a node with three well-connected friends scores higher than a node with five isolated ones. PageRank is essentially eigenvector centrality with random-restart damping, which fixes pathologies on directed graphs with dangling nodes; reach for page_rank() when handling web-style directed data.

Explanation: PageRank treats edges as directional endorsements and uses a random-walk-with-restart formulation: with probability damping the walker follows an outgoing edge, otherwise jumps to a uniform random vertex. The restart fixes two failure modes that break vanilla eigenvector centrality on directed graphs: dangling sinks and disconnected strongly-connected components. P3 wins here because four other papers cite it and one of those citers (P4) is itself cited.

Explanation: shortest_paths() returns both vertex and edge sequences in a list; pull $vpath[[1]] for the vertex IDs and wrap in names() for the labels. The default algorithm is unweighted BFS, which gives geodesic distance in number of hops. For weighted edges (travel time, cost), set weights = E(g)$weight and igraph automatically switches to Dijkstra. When you only need the integer distance and not the path itself, distances(g, v = "Ada", to = "Finn") is much faster.

Explanation: distances() returns an n-by-n matrix in O(n*m) for unweighted graphs (Dijkstra on weighted), and diameter() is the maximum finite entry of that matrix. The karate graph's diameter of 5 means the most distant pair is reachable in five hops, which is why "six degrees of separation" sounds plausible: small-world graphs grow logarithmically in diameter. For very large graphs, mean_distance() is cheaper and more meaningful than the worst-case diameter.

Explanation: components() returns three pieces: membership (vertex -> component ID), csize (size of each component), and no (number of components). For directed graphs, pass mode = "weak" to ignore direction or "strong" to require bidirectional reachability. The largest weakly connected component is usually the "main" graph for analysis: extract it with induced_subgraph(g, V(g)[membership == which.max(csize)]) to drop noise islands before computing centrality.

Explanation: Louvain is the default "greedy modularity" community detector for large graphs because it scales near-linearly and almost always finds the best partition. The output is a communities object you can call membership(), length() (community count), and sizes() on. Modularity around 0.3 is "weak" community structure, 0.4+ is strong, and >0.7 is essentially block-diagonal. Louvain is non-deterministic (random tie-breaking), so set a seed for reproducible reports.

Explanation: sizes() is just table(membership(comm)) under the hood, but it returns a table object with a tidy print method. The community IDs are arbitrary labels assigned during the optimization run, so they have no inherent meaning across runs (random tie-breaking can swap labels). For longitudinal comparisons (week-over-week communities), match communities by overlap rather than by ID with compare(comm1, comm2, method = "nmi").

Explanation: Different algorithms optimize different objectives and have different scaling properties. Louvain optimizes modularity directly and scales to millions of edges. Edge betweenness (Girvan-Newman) iteratively removes the highest-betweenness edge and is O(n*m^2), so it is only viable below ~1000 nodes but produces interpretable hierarchical splits. Walktrap uses random-walk distance and finds tighter, more cohesive communities. On clean toy graphs they often agree; on noisy real-world data, comparing modularity (or NMI against ground truth) is the right way to choose.

Explanation: Separating the layout (layout_with_fr()) from the plot call is the standard idiom because force-directed layouts are stochastic; computing them once and passing the matrix in lets you produce identical figures across renders. vertex.color accepts any integer vector (one per vertex); pairing it with membership(comm) gives community-aware coloring "for free". Avoid putting raw degree into vertex.size without scaling; degrees of 1-2 produce dots smaller than the vertex label.

Explanation: induced_subgraph() keeps the listed vertices and all edges among them, preserving vertex and edge attributes. Combine it with components()$membership to slice out connected pieces, or with a boolean filter V(g)[degree > 5] to keep a "core" set. The alternative subgraph() is deprecated; use induced_subgraph() for vertex-based slicing and subgraph.edges() for edge-based slicing.

Explanation: make_ego_graph() returns a list because you can request multiple egos at once; if you pass a single node, just extract [[1]]. The order argument controls the radius: order = 1 is direct neighbors, order = 2 adds friends-of-friends. Ego networks are the building block for personal-influence studies and for breaking very large graphs into per-user sub-analyses that fit in memory. For just the vertex IDs without building the subgraph, use the lighter ego() or neighborhood().

Explanation: subgraph.edges() keeps only the listed edges and (with delete.vertices = TRUE) drops any vertices left isolated. Note the convenient E(g)[weight >= 5] syntax: igraph evaluates the expression inside the brackets against the edge attribute set, similar to dplyr::filter(). The UNW- flag in the summary confirms the graph is undirected, named, and weighted. After thresholding, always re-check components() because a sparsifying filter often splits the graph into pieces.