Network Models: Analyzing Connectivity in Complex Systems

Last Updated June 6, 2026

Network models represent complex systems as structured patterns of interconnected components whose behavior depends not only on the properties of individual elements, but also on the architecture of their relationships. In a network model, system elements are represented as nodes, while relationships, flows, dependencies, exposures, or interactions are represented as edges. This formal structure allows analysts to examine how connectivity shapes diffusion, coordination, resilience, vulnerability, contagion, and systemic risk.

Network modeling is essential because many complex systems are relational before they are merely additive. A financial institution matters not only because of its balance sheet, but because of its obligations to other institutions. A species matters not only because of its population size, but because of its role in a food web. A city, server, bridge, port, hospital, supplier, influencer, or power substation matters not only as an isolated component, but because of the paths, dependencies, and flows that pass through it.

Network models therefore make interdependence analyzable. They allow systems modelers to ask which nodes are structurally important, where bottlenecks form, how shocks propagate, how communities cluster, how redundancy supports resilience, how hubs concentrate risk, and how the same disturbance behaves differently under different network architectures.

This article explains network models as a major paradigm within systems modeling. It covers graph structure, nodes and edges, centrality, topology, diffusion, contagion, cascading failure, resilience, multilayer systems, temporal networks, calibration, validation, software tools, sustainability applications, mathematical foundations, professional workflows, Python and R examples, strengths, limitations, and responsible interpretation.

What Are Network Models?

Network models are formal representations of systems composed of connected elements. The elements are called nodes or vertices. The relationships among them are called edges, links, or ties. The resulting structure is a graph.

Nodes may represent people, firms, species, cities, servers, power substations, hospitals, banks, suppliers, documents, technologies, ports, airports, agencies, or ecological habitats. Edges may represent friendship, trade, communication, transportation, influence, flow, dependency, exposure, predation, shared infrastructure, financial obligation, or institutional coordination.

The central idea is that relationships matter. Two systems with the same number of components can behave very differently if their connections differ. A decentralized network may contain local failures. A hub-and-spoke network may be efficient but vulnerable to hub disruption. A modular network may slow contagion across communities. A dense network may support redundancy while also accelerating the spread of risk.

Network models are useful because they transform relational structure into something measurable, testable, and open to simulation. They help analysts move from the vague claim that “everything is connected” to precise questions about which connections matter, how strongly, through which paths, under what assumptions, and with what consequences.

Back to top ↑

Why Network Models Matter

Network models matter because many system behaviors are generated by connectivity. A shock may remain local in one network and become systemic in another. An innovation may spread quickly through a small-world network but stall in a fragmented one. A disease may move rapidly through highly connected contact structures. A failure in a critical infrastructure node may cascade through interdependent systems.

Traditional models often focus on variables and quantities. Network models focus on relationships. This makes them indispensable when the structure of connection is itself a driver of behavior. They are especially valuable when the system contains interdependence, bottlenecks, hubs, community structure, dependency chains, overlapping networks, or pathways of propagation.

Network modeling helps answer questions such as:

• Which nodes are most structurally important?
• Which connections carry the most flow, influence, or risk?
• How fast can information, disease, failure, or innovation spread?
• Where are bottlenecks, bridges, or single points of failure?
• How does modularity affect resilience?
• How does targeted removal differ from random failure?
• How does network structure shape inequality, access, or concentration?
• Which interventions change system behavior by changing connectivity?

The value of network models is not only descriptive. They allow analysts to test structural scenarios: adding redundancy, removing dependencies, strengthening bridges, decentralizing hubs, isolating contagion pathways, or improving access for peripheral nodes.

Back to top ↑

Nodes, Edges, and System Boundaries

Every network model begins with boundary decisions. What counts as a node? What counts as an edge? Which relationships are included? Which are excluded? Is the network observed directly, inferred from data, or constructed from domain assumptions?

These decisions determine what the model can explain. A transportation network may represent intersections as nodes and roads as edges. A logistics network may represent warehouses, ports, suppliers, and retailers as nodes, with shipment routes as edges. A disease contact network may represent people as nodes and close contacts as edges. A financial network may represent institutions as nodes and exposures as weighted directed edges.

Boundary choices are not merely technical. They can change conclusions. If informal care relationships are excluded from a public-health network, the model may underestimate community resilience. If hidden supplier dependencies are excluded from a supply-chain model, the model may miss systemic vulnerability. If ecological interactions are simplified too aggressively, the model may misrepresent species dependence or collapse risk.

Good network modeling begins with explicit boundary documentation. A network diagram may look objective, but it always reflects modeling choices about what relationships matter.

Back to top ↑

Directed, Weighted, and Multilayer Networks

Networks can be represented in different forms depending on the system being modeled. In an undirected network, relationships are symmetrical. If node A is connected to node B, node B is also connected to node A. Friendship networks, road networks, or ecological co-occurrence networks may sometimes be modeled this way.

In a directed network, relationships have orientation. A supplier ships to a manufacturer. A lender has exposure to a borrower. A hyperlink points from one page to another. A predator consumes prey. Direction matters because it changes reachability, influence, flow, and vulnerability.

In a weighted network, edges carry values. These may represent distance, cost, volume, frequency, probability, exposure, capacity, intensity, or strength. A weighted edge can distinguish a minor relationship from a major dependency.

Many real systems are multilayer networks. The same nodes may participate in different relationship layers. Cities may be connected by air travel, trade, digital communication, migration, and political coordination. Firms may be connected through ownership, supply chains, shared labor markets, and financial exposure. People may be connected through households, workplaces, schools, transportation, and online networks.

Choosing the wrong network form can distort the analysis. A financial exposure network modeled as undirected may miss who is exposed to whom. A supply chain modeled as unweighted may fail to distinguish critical dependencies from minor ones. A static contact network may miss the timing of exposure.

Back to top ↑

Key Network Properties

Network properties describe the structure of connectivity. They help analysts compare networks, diagnose vulnerability, identify influential nodes, and understand how flow or contagion may move.

Some properties describe individual nodes. Degree measures how many connections a node has. Centrality measures a node’s structural importance. Some properties describe the whole network. Density measures how many possible ties are present. Clustering measures the tendency of nodes to form tightly connected groups. Modularity measures the extent to which a network is organized into communities.

These properties are not merely descriptive. They help explain behavior. Dense networks may spread signals quickly. Modular networks may contain contagion. High-degree hubs may support efficiency while concentrating risk. Long path lengths may reduce diffusion speed but increase separation. Clustering may support trust locally while creating echo chambers or barriers between groups.

Back to top ↑

Centrality and Structural Importance

Centrality measures identify nodes that are important because of their position in the network. Different centrality measures capture different forms of importance, so they should not be treated as interchangeable.

Degree centrality identifies nodes with many direct connections. Betweenness centrality identifies nodes that lie on many shortest paths and may act as bridges or bottlenecks. Closeness centrality identifies nodes that are near many others. Eigenvector centrality identifies nodes connected to other influential nodes. PageRank-style centrality is useful in directed networks where incoming links from important nodes raise importance.

Centrality is powerful but easy to misuse. A node with high degree may not be a bridge. A node with high betweenness may not have many direct connections. A node with high eigenvector centrality may be influential in one layer but irrelevant in another. Analysts should choose centrality measures based on the system process being modeled.

Back to top ↑

Network Topologies

Topology refers to the overall pattern of connections in a network. Different topologies produce different behaviors under diffusion, failure, intervention, and stress.

Random networks distribute edges relatively evenly. Scale-free networks contain hubs with many connections and many nodes with few connections. Small-world networks combine local clustering with short path lengths across the system. Modular networks contain communities connected by bridging ties. Hierarchical networks organize connectivity through levels of authority, dependency, or control.

Topology matters because system performance and vulnerability are often structural. The same number of nodes and edges can produce different systemic risk depending on how those edges are arranged.

Back to top ↑

Diffusion, Contagion, and Cascades

Network models are especially valuable for analyzing how things move through systems. These may include diseases, information, innovations, rumors, failures, financial distress, electricity, goods, trust, norms, influence, or ecological effects.

Diffusion refers broadly to spread across connections. Contagion often refers to transmission of a state, such as infection, panic, default, or adoption. Cascading failure occurs when failure in one part of the network triggers failure elsewhere. The network structure determines which paths are available, which nodes are exposed, and how quickly propagation occurs.

Network contagion can be simple or complex. In simple contagion, one exposure may be enough to transmit a state with some probability. Infectious disease transmission is often modeled this way. In complex contagion, adoption or behavior change may require reinforcement from multiple neighbors. Technology adoption, social norms, political mobilization, and institutional change often involve threshold-like dynamics.

Network modeling helps reveal whether a system is vulnerable to rapid spread, slow diffusion, local containment, or sudden systemic cascade.

Back to top ↑

Network Resilience and Fragility

Network resilience concerns whether a network can continue functioning under disruption. Fragility concerns how easily the network loses connectivity, capacity, coordination, or function.

A network may be resilient in one sense and fragile in another. A dense network may contain many alternate paths, supporting redundancy. But that same density may accelerate contagion. A modular network may contain shocks within communities, but it may also reduce cross-system coordination. A hub-based network may be efficient in normal times, but highly vulnerable to targeted hub failure.

Resilience analysis often examines what happens when nodes or edges are removed. Random removal simulates ordinary failure, attrition, or localized disruption. Targeted removal simulates attack, strategic disruption, climate exposure at critical sites, or failure of high-centrality components. Analysts then measure fragmentation, largest connected component size, path length, flow loss, service loss, or recovery time.

Network resilience is not always maximized by adding more connections. Sometimes resilience requires modularity, isolation, decoupling, redundancy, diversity, or protection of key bridges. Network models make these design tradeoffs visible.

Back to top ↑

Temporal and Adaptive Networks

Many networks are not static. Edges appear, disappear, strengthen, weaken, reverse direction, or change meaning over time. A contact network changes by hour and day. A trade network changes by season and market condition. A supply chain adapts after disruption. A social network changes as people form and abandon relationships. An ecological network shifts with habitat, climate, migration, and disturbance.

Temporal networks matter because timing changes exposure. A disease cannot transmit along a contact that did not exist at the relevant time. A supply route may be available in one season and unavailable in another. A financial exposure may be harmless under normal liquidity and dangerous under stress. A static network may exaggerate or underestimate connectivity if time is ignored.

Adaptive networks go further. In adaptive networks, nodes change edges in response to system behavior. Firms diversify suppliers after disruption. People avoid contacts during an epidemic. Platforms recommend new connections. Species migrate. Institutions coordinate under crisis. These adaptations can either reduce risk or create new forms of instability.

Temporal and adaptive networks connect network modeling directly to complex adaptive systems. They show that connectivity is often an evolving system state, not a fixed background condition.

Back to top ↑

Integration with Other Modeling Approaches

Network models often become more powerful when integrated with other systems modeling approaches. Network structure can define who interacts with whom in an agent-based model. It can define dependency pathways in a system dynamics model. It can define service routes in a discrete-event simulation. It can define spatial exposure in geospatial modeling. It can define intersectoral linkages in integrated assessment models.

Hybrid approaches are increasingly important because real systems often contain multiple types of structure at once. A public-health model may combine a contact network, individual agents, disease progression states, hospital capacity stocks, and policy scenarios. An infrastructure model may combine network topology, asset degradation, repair queues, storm exposure, and recovery dynamics. A supply-chain model may combine network dependency, inventory stocks, firm behavior, and transport delays.

Network models therefore function both as a standalone paradigm and as a structural layer inside larger modeling architectures.

Back to top ↑

Calibration, Validation, and Credibility

Network models require careful calibration and validation because network structure is often uncertain. Edges may be missing, inferred, outdated, confidential, or measured imperfectly. Weights may be estimated from proxies. Direction may be ambiguous. The relevant time window may be unclear. Hidden dependencies may matter most during crisis but remain invisible during normal operation.

Calibration may involve estimating edge weights, transmission probabilities, flow capacities, threshold values, disruption probabilities, or recovery rates. Validation may involve comparing model outputs with observed diffusion patterns, known bottlenecks, historical cascades, expert knowledge, or independent network data.

Validation should test both structure and behavior. A network may have plausible metrics but still omit critical relationships. A model may reproduce a cascade but for the wrong structural reason. A network diagram may be visually compelling but analytically weak if edges are poorly defined.

A professional network model should make data provenance, edge definitions, uncertainty, and limitations visible. The credibility of the model depends on the credibility of the relational data and the interpretation of network structure.

Back to top ↑

Software Tools for Network Modeling

Network modeling can be done in specialized software, programming libraries, databases, and visualization tools. The right tool depends on model purpose, data scale, reproducibility requirements, visualization needs, and whether the model is exploratory, analytical, operational, or research-oriented.

Python libraries such as NetworkX are widely used for graph analysis and teaching workflows. igraph supports network analysis in R, Python, and C. Gephi is often used for visual exploration. Graph databases such as Neo4j support relationship-oriented data storage and queries. Larger network simulations may require specialized performance-oriented implementations in C++, Rust, Julia, or distributed systems.

Software choice should follow the modeling question. A visual exploration of a small social network, a national infrastructure resilience model, and a high-performance contagion simulation have different tool requirements.

Back to top ↑

Applications Across Complex Systems

Across these applications, the core lesson is the same: system behavior depends on the architecture of relationships.

Back to top ↑

Applications in Sustainability and Policy

Network models are especially important for sustainability and policy because contemporary risks often move through interconnected systems. Climate hazards disrupt infrastructure networks. Energy transitions depend on grids, supply chains, finance, permitting, and institutional coordination. Ecosystem resilience depends on species interactions and habitat connectivity. Public-health outcomes depend on contact networks, care networks, trust networks, and mobility networks.

Policy effectiveness often depends on network position. An intervention at a peripheral node may have limited system impact. An intervention at a bridge may connect underserved communities. Protection of a high-centrality infrastructure asset may reduce systemic risk. Diversification of supply networks may reduce fragility. Strengthening weak ties may improve information diffusion.

Network modeling supports policy by revealing where relationships create leverage, fragility, dependence, inequality, or resilience.

Back to top ↑

Mathematical Lens: Adjacency, Centrality, Diffusion, and Cascades

A network can be represented by an adjacency matrix \(A\), where each entry \(a_{ij}\) indicates the relationship from node \(i\) to node \(j\).

The degree of node \(i\) in an undirected unweighted network is:

Eigenvector centrality assigns higher importance to nodes connected to other important nodes:

The graph Laplacian is commonly defined as:

A simple diffusion process over a network can be written as:

A threshold cascade rule can be written as:

These mathematical tools are what make network models more than visual diagrams. They turn connectivity into measurable structure and allow analysts to simulate diffusion, robustness, cascade risk, and intervention effects.

Back to top ↑

Back to top ↑

Strengths and Limitations

Network models are powerful because they make relational structure explicit. They can reveal bottlenecks, hidden dependencies, hubs, bridges, communities, fragmentation, contagion pathways, and structural inequality. They can test how interventions change system behavior by altering connectivity.

At the same time, network models have limitations. They may rely on incomplete relational data. They may treat relationships as static when they are dynamic. They may overemphasize structure while underrepresenting behavior, feedback, institutions, or adaptation. They may produce visually persuasive diagrams that are not analytically valid.

The strongest network models are not necessarily the most visually complex. They are the ones whose nodes, edges, weights, dynamics, and interpretation match the system question.

Back to top ↑

Python Workflow: Centrality, Robustness, and Contagion

The Python workflow below uses only the standard library. It builds a synthetic network, computes degree and betweenness-style bridge diagnostics, simulates simple contagion, and compares random node removal with targeted high-degree removal.

# network_models_workflow.py
# Dependency-light network modeling workflow:
# centrality, components, robustness, and contagion.
#
# Suggested repository placement:
# articles/network-models/python/network_models_workflow.py

from __future__ import annotations

from collections import deque
from pathlib import Path
import csv
import random


ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows to write: {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def build_synthetic_network(seed: int = 60606) -> dict[int, set[int]]:
    rng = random.Random(seed)
    n = 48
    graph = {node: set() for node in range(n)}

    # Three dense communities.
    communities = [range(0, 16), range(16, 32), range(32, 48)]

    for community in communities:
        nodes = list(community)
        for i in nodes:
            for j in nodes:
                if i < j and rng.random() < 0.18:
                    graph[i].add(j)
                    graph[j].add(i)

    # Add bridges between communities.
    bridges = [(3, 19), (7, 25), (21, 35), (29, 42), (12, 37)]
    for a, b in bridges:
        graph[a].add(b)
        graph[b].add(a)

    # Add a few hub-like connectors.
    for hub in [2, 18, 34]:
        for node in range(n):
            if node != hub and rng.random() < 0.08:
                graph[hub].add(node)
                graph[node].add(hub)

    return graph


def edge_count(graph: dict[int, set[int]]) -> int:
    return sum(len(neighbors) for neighbors in graph.values()) // 2


def degree_rows(graph: dict[int, set[int]]) -> list[dict[str, object]]:
    return [
        {
            "node": node,
            "degree": len(neighbors),
            "degree_centrality": round(len(neighbors) / max(1, len(graph) - 1), 6),
        }
        for node, neighbors in sorted(graph.items())
    ]


def shortest_paths_from(graph: dict[int, set[int]], source: int) -> dict[int, int]:
    distances = {source: 0}
    queue = deque([source])

    while queue:
        current = queue.popleft()
        for neighbor in graph[current]:
            if neighbor not in distances:
                distances[neighbor] = distances[current] + 1
                queue.append(neighbor)

    return distances


def connected_components(graph: dict[int, set[int]]) -> list[set[int]]:
    seen: set[int] = set()
    components: list[set[int]] = []

    for node in graph:
        if node in seen:
            continue

        component = set()
        queue = deque([node])
        seen.add(node)

        while queue:
            current = queue.popleft()
            component.add(current)

            for neighbor in graph[current]:
                if neighbor not in seen:
                    seen.add(neighbor)
                    queue.append(neighbor)

        components.append(component)

    return components


def graph_summary(graph: dict[int, set[int]], scenario: str) -> dict[str, object]:
    n = len(graph)
    m = edge_count(graph)
    possible_edges = n * (n - 1) / 2
    degrees = [len(neighbors) for neighbors in graph.values()]
    components = connected_components(graph)

    path_lengths = []
    for node in graph:
        distances = shortest_paths_from(graph, node)
        path_lengths.extend(distance for target, distance in distances.items() if target != node)

    return {
        "scenario": scenario,
        "nodes": n,
        "edges": m,
        "density": round(m / possible_edges, 6),
        "average_degree": round(sum(degrees) / n, 6),
        "maximum_degree": max(degrees),
        "component_count": len(components),
        "largest_component_size": max(len(component) for component in components),
        "average_path_length_reachable": round(sum(path_lengths) / len(path_lengths), 6) if path_lengths else 0,
    }


def remove_nodes(graph: dict[int, set[int]], nodes_to_remove: set[int]) -> dict[int, set[int]]:
    revised = {
        node: {neighbor for neighbor in neighbors if neighbor not in nodes_to_remove}
        for node, neighbors in graph.items()
        if node not in nodes_to_remove
    }
    return revised


def robustness_experiment(graph: dict[int, set[int]], seed: int = 70707) -> list[dict[str, object]]:
    rng = random.Random(seed)
    nodes = list(graph.keys())
    degree_ranked = sorted(nodes, key=lambda node: len(graph[node]), reverse=True)

    rows: list[dict[str, object]] = []

    for fraction in [0.0, 0.05, 0.10, 0.15, 0.20, 0.25]:
        k = int(round(len(nodes) * fraction))

        random_removed = set(rng.sample(nodes, k)) if k > 0 else set()
        targeted_removed = set(degree_ranked[:k])

        for strategy, removed in [
            ("random_removal", random_removed),
            ("targeted_high_degree_removal", targeted_removed),
        ]:
            revised = remove_nodes(graph, removed)
            components = connected_components(revised) if revised else []
            largest = max((len(component) for component in components), default=0)

            rows.append({
                "strategy": strategy,
                "removal_fraction": fraction,
                "nodes_removed": k,
                "remaining_nodes": len(revised),
                "component_count": len(components),
                "largest_component_size": largest,
                "largest_component_share": round(largest / max(1, len(revised)), 6),
            })

    return rows


def contagion_simulation(graph: dict[int, set[int]], seed_node: int = 2, probability: float = 0.18, steps: int = 24, seed: int = 80808) -> list[dict[str, object]]:
    rng = random.Random(seed)
    infected = {seed_node}
    rows: list[dict[str, object]] = []

    for step in range(steps + 1):
        rows.append({
            "step": step,
            "infected_count": len(infected),
            "infected_share": round(len(infected) / len(graph), 6),
        })

        newly_infected = set(infected)

        for node in infected:
            for neighbor in graph[node]:
                if neighbor not in infected and rng.random() < probability:
                    newly_infected.add(neighbor)

        infected = newly_infected

    return rows


def main() -> None:
    graph = build_synthetic_network()

    write_csv(TABLES / "python_network_node_degree.csv", degree_rows(graph))
    write_csv(TABLES / "python_network_summary.csv", [graph_summary(graph, "baseline_network")])
    write_csv(TABLES / "python_network_robustness.csv", robustness_experiment(graph))
    write_csv(TABLES / "python_network_contagion.csv", contagion_simulation(graph))

    print("Network modeling workflow complete.")
    print(TABLES / "python_network_summary.csv")


if __name__ == "__main__":
    main()

This workflow demonstrates a core network-modeling principle: the same nodes behave differently depending on connectivity. Degree structure affects vulnerability. Component structure affects resilience. Network paths shape contagion. Targeted removal can fragment a system more severely than random removal.

Back to top ↑

R Workflow: Network Metrics and Fragmentation Diagnostics

The R workflow below uses base R. It constructs a synthetic adjacency matrix, computes degree, density, reachable path lengths, components, and fragmentation under random and targeted node removal.

# network_models_diagnostics.R
# Base R workflow:
# network metrics, components, robustness, and fragmentation diagnostics.
#
# Suggested repository placement:
# articles/network-models/r/network_models_diagnostics.R

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- normalizePath(getwd(), mustWork = TRUE)
}

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")

dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

set.seed(60606)

n <- 48
A <- matrix(0, nrow = n, ncol = n)

communities <- list(1:16, 17:32, 33:48)

for (community in communities) {
  for (i in community) {
    for (j in community) {
      if (i < j && runif(1) < 0.18) {
        A[i, j] <- 1
        A[j, i] <- 1
      }
    }
  }
}

bridges <- matrix(c(
  3, 19,
  7, 25,
  21, 35,
  29, 42,
  12, 37
), ncol = 2, byrow = TRUE)

for (b in seq_len(nrow(bridges))) {
  i <- bridges[b, 1]
  j <- bridges[b, 2]
  A[i, j] <- 1
  A[j, i] <- 1
}

for (hub in c(2, 18, 34)) {
  for (node in seq_len(n)) {
    if (node != hub && runif(1) < 0.08) {
      A[hub, node] <- 1
      A[node, hub] <- 1
    }
  }
}

degree <- rowSums(A)
density <- sum(A) / (n * (n - 1))

bfs_distances <- function(A, source) {
  n <- nrow(A)
  distances <- rep(Inf, n)
  distances[source] <- 0
  queue <- c(source)

  while (length(queue) > 0) {
    current <- queue[1]
    queue <- queue[-1]

    neighbors <- which(A[current, ] == 1)

    for (neighbor in neighbors) {
      if (is.infinite(distances[neighbor])) {
        distances[neighbor] <- distances[current] + 1
        queue <- c(queue, neighbor)
      }
    }
  }

  distances
}

component_labels <- function(A) {
  n <- nrow(A)
  labels <- rep(0, n)
  component_id <- 0

  for (node in seq_len(n)) {
    if (labels[node] == 0) {
      component_id <- component_id + 1
      queue <- c(node)
      labels[node] <- component_id

      while (length(queue) > 0) {
        current <- queue[1]
        queue <- queue[-1]

        neighbors <- which(A[current, ] == 1)

        for (neighbor in neighbors) {
          if (labels[neighbor] == 0) {
            labels[neighbor] <- component_id
            queue <- c(queue, neighbor)
          }
        }
      }
    }
  }

  labels
}

all_distances <- c()

for (source in seq_len(n)) {
  distances <- bfs_distances(A, source)
  all_distances <- c(all_distances, distances[is.finite(distances) & distances > 0])
}

labels <- component_labels(A)
component_sizes <- table(labels)

node_metrics <- data.frame(
  node = seq_len(n),
  degree = degree,
  degree_centrality = degree / (n - 1),
  component = labels
)

summary_metrics <- data.frame(
  scenario = "baseline_network",
  nodes = n,
  edges = sum(A) / 2,
  density = density,
  average_degree = mean(degree),
  maximum_degree = max(degree),
  component_count = length(component_sizes),
  largest_component_size = max(component_sizes),
  average_path_length_reachable = mean(all_distances)
)

remove_nodes <- function(A, nodes_to_remove) {
  if (length(nodes_to_remove) == 0) {
    return(A)
  }

  keep <- setdiff(seq_len(nrow(A)), nodes_to_remove)
  A[keep, keep, drop = FALSE]
}

robustness_rows <- data.frame()
degree_ranked <- order(degree, decreasing = TRUE)

for (fraction in c(0, 0.05, 0.10, 0.15, 0.20, 0.25)) {
  k <- round(n * fraction)

  random_removed <- if (k > 0) sample(seq_len(n), k) else integer(0)
  targeted_removed <- if (k > 0) degree_ranked[seq_len(k)] else integer(0)

  for (strategy in c("random_removal", "targeted_high_degree_removal")) {
    removed <- if (strategy == "random_removal") random_removed else targeted_removed
    revised <- remove_nodes(A, removed)

    if (nrow(revised) > 0) {
      revised_labels <- component_labels(revised)
      revised_sizes <- table(revised_labels)
      largest <- max(revised_sizes)
      component_count <- length(revised_sizes)
    } else {
      largest <- 0
      component_count <- 0
    }

    robustness_rows <- rbind(robustness_rows, data.frame(
      strategy = strategy,
      removal_fraction = fraction,
      nodes_removed = k,
      remaining_nodes = nrow(revised),
      component_count = component_count,
      largest_component_size = largest,
      largest_component_share = largest / max(1, nrow(revised))
    ))
  }
}

write.csv(node_metrics, file.path(tables_dir, "r_network_node_metrics.csv"), row.names = FALSE)
write.csv(summary_metrics, file.path(tables_dir, "r_network_summary.csv"), row.names = FALSE)
write.csv(robustness_rows, file.path(tables_dir, "r_network_robustness.csv"), row.names = FALSE)

png(file.path(figures_dir, "r_network_degree_distribution.png"), width = 1000, height = 700)
hist(
  degree,
  breaks = seq(-0.5, max(degree) + 0.5, by = 1),
  main = "Synthetic Network Degree Distribution",
  xlab = "Degree",
  ylab = "Node Count"
)
grid()
dev.off()

png(file.path(figures_dir, "r_network_robustness.png"), width = 1000, height = 700)
plot(
  robustness_rows$removal_fraction[robustness_rows$strategy == "random_removal"],
  robustness_rows$largest_component_share[robustness_rows$strategy == "random_removal"],
  type = "b",
  ylim = c(0, 1),
  xlab = "Removal Fraction",
  ylab = "Largest Component Share",
  main = "Network Robustness Under Node Removal"
)
lines(
  robustness_rows$removal_fraction[robustness_rows$strategy == "targeted_high_degree_removal"],
  robustness_rows$largest_component_share[robustness_rows$strategy == "targeted_high_degree_removal"],
  type = "b",
  lty = 2
)
legend(
  "bottomleft",
  legend = c("Random removal", "Targeted high-degree removal"),
  lty = c(1, 2),
  pch = c(1, 1),
  bty = "n"
)
grid()
dev.off()

print(summary_metrics)
cat("R network modeling diagnostics complete.\n")

This R workflow shows how network analysis can move from structure to diagnostics. It computes baseline metrics, identifies components, and compares fragmentation under random and targeted removal.

Back to top ↑

GitHub Repository

Back to top ↑

Ethics and Responsible Use

Network models can reveal hidden structure, but they can also expose sensitive relationships. Social networks, contact networks, financial networks, supply-chain networks, and institutional networks may contain confidential, personal, strategic, or politically sensitive information. Responsible network modeling requires careful attention to privacy, data governance, inference risk, uncertainty, and stakeholder impact.

Network models also shape power. A centrality ranking can affect surveillance priorities, investment decisions, regulatory attention, policing, infrastructure protection, or organizational restructuring. If the network data are incomplete or biased, those decisions may reinforce inequality or misdirect resources.

A responsible network model should make relationships more understandable without exposing people, communities, institutions, or infrastructures to unnecessary harm.

Back to top ↑

Common Pitfalls

Network modeling can fail when visual appeal substitutes for analytical discipline. A network diagram may look sophisticated while relying on weak edge definitions, missing data, arbitrary thresholds, or misleading layouts.

Good network modeling requires clear definitions, careful data work, appropriate metrics, and disciplined interpretation.

Back to top ↑

Conclusion

Network models are among the most important tools in systems modeling because they make interdependence analyzable. By representing systems as nodes and edges, they reveal how connectivity shapes diffusion, concentration, vulnerability, resilience, coordination, access, and systemic risk.

Network models are especially valuable when system behavior depends on relationships rather than isolated components. Financial contagion, infrastructure fragility, ecological dependence, social influence, supply-chain disruption, public-health transmission, and digital-system vulnerability are all network phenomena. Their behavior cannot be fully understood without examining pathways, hubs, bridges, clusters, dependencies, and flows.

Used well, network modeling transforms relational complexity into structured analysis. It helps identify critical nodes, evaluate redundancy, test disruption scenarios, simulate contagion, compare topologies, and design more resilient systems. But it also requires caution. Network results depend on boundary choices, edge definitions, data quality, model assumptions, and responsible interpretation.

A network model is not just a picture of connections. It is a formal argument about how relationships shape system behavior.

Back to top ↑

Related Articles

• What Is Systems Modeling?
• Systems Thinking vs Systems Modeling
• Why Complex Systems Require Models
• The History of Systems Modeling
• Core Principles of Systems Modeling
• System Dynamics Modeling
• Agent-Based Modeling
• Discrete Event Simulation
• Hybrid Modeling Approaches
• Cascading Failure and Contagion

Further Reading

• Barabási, A.-L. (2016) Network Science. Available at: https://networksciencebook.com/.
• Easley, D. and Kleinberg, J. (2010) Networks, Crowds, and Markets: Reasoning About a Highly Connected World. Cambridge: Cambridge University Press. Available at: https://www.cs.cornell.edu/home/kleinber/networks-book/.
• Newman, M. (2018) Networks, 2nd edn. Oxford: Oxford University Press. Available at: https://academic.oup.com/book/27884.
• Watts, D.J. (2003) Six Degrees: The Science of a Connected Age. New York: W.W. Norton. Available at: https://wwnorton.com/books/9780393325423.
• Network Science Institute at Northeastern University. Home. Available at: https://www.networkscienceinstitute.org/.
• Santa Fe Institute. What is Complex Systems Science? Available at: https://www.santafe.edu/what-is-complex-systems-science.
• NetworkX. NetworkX Documentation. Available at: https://networkx.org/documentation/stable/.
• igraph. The igraph Software Package for Complex Network Research. Available at: https://igraph.org/.
• Gephi. The Open Graph Viz Platform. Available at: https://gephi.org/.
• Borgatti, S.P., Everett, M.G. and Johnson, J.C. (2018) Analyzing Social Networks, 2nd edn. Thousand Oaks, CA: SAGE Publications.
• Jackson, M.O. (2010) Social and Economic Networks. Princeton: Princeton University Press.
• Newman, M.E.J. (2010) Networks: An Introduction. Oxford: Oxford University Press.

Back to top ↑

References

• Barabási, A.-L. (2016) Network Science. Cambridge: Cambridge University Press. Available at: https://networksciencebook.com/.
• Barabási, A.-L. and Albert, R. (1999) ‘Emergence of scaling in random networks’, Science, 286(5439), pp. 509–512. Available at: https://doi.org/10.1126/science.286.5439.509.
• Borgatti, S.P., Everett, M.G. and Johnson, J.C. (2018) Analyzing Social Networks, 2nd edn. Thousand Oaks, CA: SAGE Publications.
• Easley, D. and Kleinberg, J. (2010) Networks, Crowds, and Markets: Reasoning About a Highly Connected World. Cambridge: Cambridge University Press. Available at: https://www.cs.cornell.edu/home/kleinber/networks-book/.
• Gephi. (n.d.) The Open Graph Viz Platform. Available at: https://gephi.org/.
• igraph. (n.d.) The igraph Software Package for Complex Network Research. Available at: https://igraph.org/.
• Jackson, M.O. (2010) Social and Economic Networks. Princeton: Princeton University Press.
• Network Science Institute at Northeastern University. (n.d.) Home. Available at: https://www.networkscienceinstitute.org/.
• NetworkX. (n.d.) NetworkX Documentation. Available at: https://networkx.org/documentation/stable/.
• Newman, M.E.J. (2003) ‘The structure and function of complex networks’, SIAM Review, 45(2), pp. 167–256. Available at: https://doi.org/10.1137/S003614450342480.
• Newman, M.E.J. (2010) Networks: An Introduction. Oxford: Oxford University Press.
• Newman, M. (2018) Networks, 2nd edn. Oxford: Oxford University Press. Available at: https://academic.oup.com/book/27884.
• Santa Fe Institute. (n.d.) What is Complex Systems Science? Available at: https://www.santafe.edu/what-is-complex-systems-science.
• Watts, D.J. (2003) Six Degrees: The Science of a Connected Age. New York: W.W. Norton. Available at: https://wwnorton.com/books/9780393325423.
• Watts, D.J. and Strogatz, S.H. (1998) ‘Collective dynamics of “small-world” networks’, Nature, 393, pp. 440–442. Available at: https://www.nature.com/articles/30918.

Back to top ↑