Network Adjacency Matrices: How Linear Algebra Encodes Connectivity and Relationships

Last Updated July 2, 2026

Network adjacency matrices turn relationships into linear algebra. A network can describe roads, power lines, citations, social ties, supply chains, communication links, ecological interactions, financial exposure, infrastructure dependence, or information flow. An adjacency matrix records which nodes are connected, how strongly they are connected, and sometimes in which direction those connections point.

This article opens Part V of the Linear Algebra for Systems Modeling series by connecting graph structure, matrices, networks, edges, weights, directionality, self-loops, sparsity, walks, paths, reachability, degree, centrality, diffusion, spectral structure, normalization, and responsible interpretation. It prepares the transition from dynamical systems to networked systems, where matrices organize connectivity, influence, flow, vulnerability, and interdependence.

The central modeling question is not only “Which nodes are connected?” It is “What does connection mean, how was it measured, what direction and weight does it carry, and what system behavior becomes visible or distorted when relationships are encoded as a matrix?”

An adjacency matrix is one of the most important bridges between graph theory and linear algebra. Each row and column corresponds to a node. Each entry records whether a connection exists, how strong it is, or how it is directed. This allows networks to be analyzed with matrix operations: multiplication counts walks, powers reveal reachability, row sums and column sums compute degrees, eigenvectors identify structural influence, sparse formats scale computation, and normalization prepares networks for diffusion, ranking, flow, and transition models.

Adjacency matrices are simple enough to teach and powerful enough to support serious systems analysis. They appear in transportation networks, power grids, water systems, communication infrastructure, citation networks, supply chains, ecological food webs, financial exposure networks, organizational dependency maps, recommendation systems, knowledge graphs, and platform dynamics. But the matrix is only as meaningful as the relationship definition behind each entry.

Why Network Adjacency Matrices Matter

Network adjacency matrices matter because many systems are defined by relationships rather than isolated variables. A city is not only a list of intersections; it is a network of roads. A power grid is not only a list of substations; it is a network of transmission lines. A supply chain is not only a list of firms; it is a network of dependencies. A knowledge system is not only a list of documents; it is a network of citations, references, concepts, and links.

Linear algebra turns these relationships into analyzable structure. Once a network is represented as a matrix, modelers can compute degrees, paths, walks, diffusion, connectivity, influence, clustering, centrality, spectral properties, vulnerability, and flow-related structure.

Adjacency matrices make relationship structure computationally visible, but they also force modelers to define what counts as a connection.

Back to top ↑

Nodes, Edges, and Matrix Entries

A network has nodes and edges. Nodes represent entities. Edges represent relationships among entities. An adjacency matrix \(A\) records those relationships:

In a weighted network, entries can take nonzero values other than one:

Adjacency matrices are compact, but they require clear node definitions, edge definitions, units, direction conventions, and data provenance.

Back to top ↑

Undirected Adjacency Matrices

In an undirected network, connections have no direction. If node \(i\) is connected to node \(j\), then node \(j\) is also connected to node \(i\). The adjacency matrix is symmetric:

For example, an undirected network of roads, friendship ties, co-authorships, physical proximity, or shared infrastructure may be represented with a symmetric adjacency matrix when direction is not meaningful or not measured.

Symmetry is a modeling claim. It should not be imposed merely because symmetric matrices are mathematically convenient.

Back to top ↑

Directed Adjacency Matrices

In a directed network, edges have orientation. A connection from node \(i\) to node \(j\) may not imply a connection from node \(j\) to node \(i\). Directed adjacency matrices are generally asymmetric:

Directed networks appear in citation systems, web links, supply chains, command structures, input-output systems, migration flows, financial exposures, disease transmission, influence networks, and platform recommendation systems.

Directed adjacency matrices require careful row-column conventions. A reversed convention can invert the interpretation of influence, dependence, exposure, and flow.

Back to top ↑

Weighted Adjacency Matrices

Weighted adjacency matrices assign a numeric value to each connection. The meaning of the weight depends on the domain:

Weights make networks more expressive, but they also introduce units, scaling, measurement uncertainty, and comparability problems. A weight can represent capacity in megawatts, travel time in minutes, shipment volume in tons, communication frequency, probability of transition, dollar exposure, ecological interaction strength, or trust score. These meanings should not be mixed casually.

Weighted networks are often more realistic than binary networks, but their interpretation depends on measurement discipline.

Back to top ↑

Self-Loops and Diagonal Entries

The diagonal entries of an adjacency matrix represent self-loops:

Many simple graph models set diagonal entries to zero. But self-loops can be meaningful in transition systems, retention models, self-citation networks, Markov chains, input-output systems, and models where a node retains part of its state over time.

Diagonal entries should be handled deliberately. They are not just technical details; they can change degree, diffusion, spectral structure, and long-run behavior.

Back to top ↑

Degree from Adjacency

Degree measures how connected a node is. In an undirected binary network, the degree of node \(i\) is the sum of its row:

In a directed network, row sums and column sums can measure different things:

Degree is simple, but its meaning depends on the direction and weight conventions of the adjacency matrix.

Back to top ↑

Matrix Powers, Walks, and Reachability

Matrix powers reveal indirect connections. For a binary adjacency matrix, entries of \(A^2\) count walks of length two, and entries of \(A^k\) count walks of length \(k\):

This is one of the most important reasons adjacency matrices matter. Matrix multiplication turns local links into indirect pathways. It reveals how influence, exposure, traffic, risk, infection, information, or dependency can move beyond immediate neighbors.

Walk counts are not always path counts. A walk can revisit nodes. This distinction matters in network vulnerability, influence modeling, routing, and flow analysis.

Back to top ↑

Sparse Network Representation

Most real networks are sparse: the number of actual edges is far smaller than the number of possible edges. A network with one million nodes would have a trillion possible directed matrix entries, but only a tiny fraction may be nonzero.

Storing such a network as a dense matrix is often impossible or wasteful. Sparse formats store only nonzero entries and their indices.

Sparse representation is not only an implementation detail. It determines whether network analysis can scale to real systems.

Back to top ↑

Normalization and Transition Structure

Adjacency matrices often need normalization before they can represent diffusion, random walks, influence, or transition probabilities. For example, a row-normalized matrix can convert outgoing weights into probabilities:

Normalization changes the meaning of the matrix. Raw adjacency may measure capacity, count, cost, strength, similarity, or exposure. A normalized matrix may measure probability, share, relative influence, or diffusion rule.

Normalization is a modeling step. It should be documented, especially when the transformed matrix is used for ranking, diffusion, prediction, or decision support.

Back to top ↑

Spectral Structure of Networks

The eigenvalues and eigenvectors of adjacency-related matrices reveal structural patterns in networks. Spectral methods can identify dominant influence, communities, bottlenecks, diffusion rates, ranking structure, expansion, and vulnerability.

Eigenvector centrality, PageRank, spectral clustering, diffusion analysis, and graph signal processing all depend on adjacency or adjacency-derived matrices.

Spectral network analysis is powerful, but it should never be detached from the meaning of nodes, edges, weights, and data collection.

Back to top ↑

Bipartite and Multilayer Networks

Not every network connects entities of the same type. Bipartite networks connect two different kinds of nodes, such as people and organizations, authors and papers, firms and products, species and habitats, or users and items.

A bipartite adjacency matrix can be rectangular:

Projection can convert bipartite structure into one-mode networks:

Projection can create artificial density and misleading similarity. Bipartite and multilayer structures should be preserved when their distinction matters.

Back to top ↑

Network Data and Modeling Judgment

Adjacency matrices look objective because they are arrays of numbers. But every entry reflects a data decision. What counts as a node? What counts as an edge? Is the network directed? Are weights reliable? Are missing edges truly absent or merely unobserved? Does the data capture current structure or a historical snapshot? Are some nodes overrepresented because they are easier to measure?

Network modeling requires data provenance, uncertainty review, sensitivity analysis, and interpretive humility.

Back to top ↑

Network Adjacency in Systems Modeling

Network adjacency matrices are useful whenever system behavior depends on connectivity. They can represent routes, dependencies, channels, exposure, influence, communication, transmission, collaboration, supply, demand, ecological interaction, and institutional connection.

The same matrix form can support different modeling tasks. A transportation adjacency matrix can support routing. A power-grid adjacency matrix can support vulnerability analysis. A citation adjacency matrix can support knowledge-flow analysis. A supply-chain adjacency matrix can support shock propagation. A digital-platform adjacency matrix can support recommendation or attention analysis. A public-health adjacency matrix can support contact-network modeling.

Adjacency matrices help model connectivity, but they do not explain the system alone. They are one structured representation within a larger modeling judgment.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Network adjacency matrices connect graph theory, matrix algebra, sparse computation, spectral analysis, Markov chains, graph Laplacians, random walks, diffusion, centrality, reachability, clustering, network flow, robustness, graph partitioning, and model governance.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for network adjacency matrices should document node lists, edge lists, matrix shape, direction convention, weight meaning, diagonal convention, row sums, column sums, degree distributions, symmetry checks, sparsity, connectedness, matrix powers, normalization, spectral diagnostics, data provenance, missing-edge assumptions, and interpretation warnings.

The companion repository treats adjacency matrices as auditable network representations. Python, R, Julia, SQL, Haskell, C, C++, Fortran, Rust, Go, notebooks, schemas, generated outputs, Canvas artifacts, advanced reports, and calculators each support a different layer of reproducible network-matrix analysis.

For this article, the computational examples focus on adjacency construction, directed and weighted diagnostics, degree measures, two-step walks, sparsity, normalization, and governance records for network representation choices.

Back to top ↑

Python Workflow: Adjacency Matrix Audit

The Python workflow below builds a small directed weighted infrastructure-style network, computes row and column degree measures, checks sparsity, computes two-step walks, constructs a row-normalized transition matrix, and writes auditable outputs.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
import csv
import json


Matrix = list[list[float]]


@dataclass(frozen=True)
class NetworkAdjacencyAudit:
    network_name: str
    node_count: int
    edge_count: int
    directed: bool
    weighted: bool
    diagonal_nonzero_count: int
    density: float
    max_out_weight: float
    max_in_weight: float
    two_step_walk_total: float
    row_normalized: bool
    direction_convention: str
    weight_meaning: str
    interpretation_warning: str


def matmul(A: Matrix, B: Matrix) -> Matrix:
    return [
        [sum(A[i][k] * B[k][j] for k in range(len(B))) for j in range(len(B[0]))]
        for i in range(len(A))
    ]


def row_sums(A: Matrix) -> list[float]:
    return [sum(row) for row in A]


def col_sums(A: Matrix) -> list[float]:
    return [sum(A[i][j] for i in range(len(A))) for j in range(len(A[0]))]


def count_nonzero(A: Matrix) -> int:
    return sum(1 for row in A for value in row if value != 0.0)


def diagonal_nonzero_count(A: Matrix) -> int:
    return sum(1 for i in range(min(len(A), len(A[0]))) if A[i][i] != 0.0)


def row_normalize(A: Matrix) -> Matrix:
    normalized = []
    for row in A:
        total = sum(row)
        if total == 0.0:
            normalized.append([0.0 for _ in row])
        else:
            normalized.append([value / total for value in row])
    return normalized


def write_matrix_csv(path: Path, node_names: list[str], A: Matrix) -> None:
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.writer(handle)
        writer.writerow(["node"] + node_names)
        for node, row in zip(node_names, A):
            writer.writerow([node] + [round(value, 8) for value in row])


def build_audit() -> tuple[NetworkAdjacencyAudit, list[str], Matrix, Matrix, Matrix]:
    node_names = ["water", "power", "transport", "communications", "health"]

    # Row-to-column convention:
    # A[i][j] records influence or dependency from node i to node j.
    A = [
        [0.00, 0.75, 0.20, 0.10, 0.30],
        [0.15, 0.00, 0.65, 0.80, 0.55],
        [0.10, 0.25, 0.00, 0.35, 0.40],
        [0.05, 0.45, 0.30, 0.00, 0.25],
        [0.20, 0.30, 0.35, 0.40, 0.00],
    ]

    edge_count = count_nonzero(A)
    n = len(A)
    density = edge_count / (n * n)
    out_weights = row_sums(A)
    in_weights = col_sums(A)
    A2 = matmul(A, A)
    P = row_normalize(A)

    audit = NetworkAdjacencyAudit(
        network_name="synthetic_infrastructure_dependency_network",
        node_count=n,
        edge_count=edge_count,
        directed=True,
        weighted=True,
        diagonal_nonzero_count=diagonal_nonzero_count(A),
        density=round(density, 12),
        max_out_weight=round(max(out_weights), 12),
        max_in_weight=round(max(in_weights), 12),
        two_step_walk_total=round(sum(sum(row) for row in A2), 12),
        row_normalized=True,
        direction_convention="A[i][j] means dependency or influence from row node i to column node j.",
        weight_meaning="Synthetic edge weights represent relative dependency strength, not physical capacity.",
        interpretation_warning=(
            "Adjacency conclusions depend on node boundaries, edge definitions, direction conventions, "
            "weight meaning, missing-edge assumptions, time variation, and data provenance."
        ),
    )

    return audit, node_names, A, A2, P


def write_outputs(output_dir: Path) -> None:
    (output_dir / "tables").mkdir(parents=True, exist_ok=True)
    (output_dir / "json").mkdir(parents=True, exist_ok=True)

    audit, node_names, A, A2, P = build_audit()
    row = asdict(audit)

    with (output_dir / "tables" / "network_adjacency_audit.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=list(row.keys()))
        writer.writeheader()
        writer.writerow(row)

    write_matrix_csv(output_dir / "tables" / "adjacency_matrix.csv", node_names, A)
    write_matrix_csv(output_dir / "tables" / "two_step_walk_matrix.csv", node_names, A2)
    write_matrix_csv(output_dir / "tables" / "row_normalized_transition_matrix.csv", node_names, P)

    (output_dir / "json" / "network_adjacency_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Network adjacency audit complete.")

This workflow keeps the adjacency matrix, two-step walk structure, normalized transition matrix, and interpretation warning together.

Back to top ↑

R Workflow: Network Matrix Diagnostics

R can support adjacency diagnostics by computing row sums, column sums, density, two-step walks, and normalized transition structure.

node_names <- c("water", "power", "transport", "communications", "health")

A <- matrix(
  c(
    0.00, 0.75, 0.20, 0.10, 0.30,
    0.15, 0.00, 0.65, 0.80, 0.55,
    0.10, 0.25, 0.00, 0.35, 0.40,
    0.05, 0.45, 0.30, 0.00, 0.25,
    0.20, 0.30, 0.35, 0.40, 0.00
  ),
  nrow = 5,
  byrow = TRUE
)

rownames(A) <- node_names
colnames(A) <- node_names

edge_count <- sum(A != 0)
node_count <- nrow(A)
density <- edge_count / (node_count * node_count)

out_weight <- rowSums(A)
in_weight <- colSums(A)
A2 <- A %*% A

row_normalize <- function(M) {
  totals <- rowSums(M)
  P <- M
  for (i in seq_len(nrow(M))) {
    if (totals[i] > 0) {
      P[i, ] <- M[i, ] / totals[i]
    } else {
      P[i, ] <- 0
    }
  }
  P
}

P <- row_normalize(A)

audit_record <- data.frame(
  network_name = "synthetic_infrastructure_dependency_network",
  node_count = node_count,
  edge_count = edge_count,
  directed = TRUE,
  weighted = TRUE,
  density = density,
  max_out_weight = max(out_weight),
  max_in_weight = max(in_weight),
  two_step_walk_total = sum(A2),
  row_normalized = TRUE,
  direction_convention = "A[i,j] means dependency or influence from row node i to column node j.",
  weight_meaning = "Synthetic edge weights represent relative dependency strength, not physical capacity.",
  interpretation_warning = paste(
    "Adjacency conclusions depend on node boundaries, edge definitions, direction conventions,",
    "weight meaning, missing-edge assumptions, time variation, and data provenance."
  )
)

dir.create("outputs/tables", recursive = TRUE, showWarnings = FALSE)

write.csv(audit_record, "outputs/tables/r_network_adjacency_audit.csv", row.names = FALSE)
write.csv(A, "outputs/tables/r_adjacency_matrix.csv")
write.csv(A2, "outputs/tables/r_two_step_walk_matrix.csv")
write.csv(P, "outputs/tables/r_row_normalized_transition_matrix.csv")

print(audit_record)

This R workflow treats adjacency structure as auditable data rather than an invisible preprocessing step.

Back to top ↑

Haskell Workflow: Typed Network Records

Haskell can represent network adjacency diagnostics as typed records, keeping the direction convention, weight meaning, and interpretation warning attached to the matrix summary.

module Main where

data NetworkAdjacencyAudit = NetworkAdjacencyAudit
  { networkName :: String
  , nodeCount :: Int
  , edgeCount :: Int
  , directed :: Bool
  , weighted :: Bool
  , density :: Double
  , maxOutWeight :: Double
  , maxInWeight :: Double
  , directionConvention :: String
  , weightMeaning :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: NetworkAdjacencyAudit
buildAudit =
  NetworkAdjacencyAudit
    "synthetic_infrastructure_dependency_network"
    5
    20
    True
    True
    0.8
    2.15
    1.95
    "A[i][j] means dependency or influence from row node i to column node j."
    "Synthetic edge weights represent relative dependency strength, not physical capacity."
    "Adjacency conclusions depend on node boundaries, edge definitions, direction conventions, weight meaning, missing-edge assumptions, time variation, and data provenance."

main :: IO ()
main =
  print buildAudit

The typed record helps prevent matrix outputs from being separated from modeling assumptions.

Back to top ↑

SQL Workflow: Network Adjacency Registry

SQL can document adjacency assumptions when network matrices support dashboards, risk models, infrastructure planning, graph analytics, supply-chain review, platform analysis, or institutional decision systems.

CREATE TABLE network_adjacency_assumption_registry (
    assumption_key TEXT PRIMARY KEY,
    assumption_name TEXT NOT NULL,
    mathematical_role TEXT NOT NULL,
    systems_modeling_role TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO network_adjacency_assumption_registry VALUES
(
  'node_definition',
  'Node definition',
  'Defines row and column entities in the adjacency matrix.',
  'Determines what the network can represent.',
  'Boundary choices can exclude important entities.'
);

INSERT INTO network_adjacency_assumption_registry VALUES
(
  'edge_definition',
  'Edge definition',
  'Defines what nonzero matrix entries mean.',
  'Determines what kind of relationship is modeled.',
  'Different edge definitions produce different networks.'
);

INSERT INTO network_adjacency_assumption_registry VALUES
(
  'direction_convention',
  'Direction convention',
  'Defines whether A[i,j] points from row to column or column to row.',
  'Determines interpretation of influence, exposure, dependency, and flow.',
  'Reversing direction can invert conclusions.'
);

INSERT INTO network_adjacency_assumption_registry VALUES
(
  'weight_meaning',
  'Weight meaning',
  'Defines the units or scale of edge weights.',
  'Determines whether weights represent capacity, cost, frequency, probability, exposure, or similarity.',
  'Weights with different meanings should not be compared casually.'
);

INSERT INTO network_adjacency_assumption_registry VALUES
(
  'diagonal_convention',
  'Diagonal convention',
  'Defines whether self-loops are included.',
  'Determines whether nodes can retain or refer to themselves.',
  'Diagonal entries can change degree, diffusion, and spectral structure.'
);

INSERT INTO network_adjacency_assumption_registry VALUES
(
  'normalization',
  'Normalization',
  'Defines transformations from raw adjacency to transition or diffusion matrices.',
  'Determines how edge weights are interpreted in downstream models.',
  'Normalization changes matrix meaning and must be documented.'
);

INSERT INTO network_adjacency_assumption_registry VALUES
(
  'data_provenance',
  'Data provenance',
  'Defines source and quality of node and edge data.',
  'Determines trustworthiness of network conclusions.',
  'Missing edges, false edges, stale data, and measurement bias can distort results.'
);

SELECT
    assumption_name,
    mathematical_role,
    systems_modeling_role,
    review_warning
FROM network_adjacency_assumption_registry
ORDER BY assumption_key;

This registry keeps adjacency-matrix analysis tied to node definitions, edge meanings, direction conventions, weight interpretation, diagonal treatment, normalization, and data provenance.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports network adjacency audits, directed and weighted matrix diagnostics, degree summaries, sparse representation, two-step walk analysis, row normalization, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Network adjacency matrices are powerful because they turn relationships into analyzable mathematical structure. They can reveal connectivity, indirect pathways, influence, exposure, degree, diffusion, sparsity, spectral patterns, and vulnerability. Their limits arise because real systems have ambiguous boundaries, hidden relationships, changing connections, uncertain weights, nonlinear interactions, institutional context, measurement bias, and feedback effects that may not be captured by a simple matrix.

An adjacency matrix can represent physical connection, functional dependence, communication, similarity, probability, exposure, citation, influence, or flow. These meanings are not interchangeable. A high-weight edge might mean capacity in one model, cost in another, risk in another, and similarity in another. A zero entry might mean no relationship, no observed relationship, no data, or an excluded relationship. Direction conventions can reverse interpretation. Normalization can transform raw weights into a different model entirely.

Responsible use requires documenting nodes, edges, weights, direction, diagonal treatment, sparsity, normalization, data sources, missingness, uncertainty, time period, update frequency, and downstream use. Network adjacency matrices should make relational structure transparent, not hide modeling choices behind dense arrays, graph visualizations, or centrality scores.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Matrices and the Organization of Multivariable Systems
• Matrix Arithmetic and the Logic of Combination
• Matrix Multiplication and Interaction Effects
• Linear Transformations and Model Behavior
• Eigenvalues, Eigenvectors, and System Modes
• Diagonalization and Decoupled System Behavior
• Stability Analysis with Eigenvalues
• Markov Chains and Transition Matrices
• Long-Run Behavior in State Transition Systems
• Linear Dynamical Systems
• Matrix Differential Equations
• Control Systems Modeling
• Incidence Structure and Graph Representation
• Graph Theory Foundations for Systems Modeling
• PageRank and Network Influence Models
• Network Flow Modeling
• Infrastructure Network Models
• Flow, Connectivity, and System Vulnerability
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• Barabási, A.-L. (2016) Network Science. Cambridge: Cambridge University Press. Available at: https://networksciencebook.com/.
• Bollobás, B. (1998) Modern Graph Theory. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-1-4612-0619-4.
• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. Cambridge: Cambridge University Press. Available at: https://vmls-book.stanford.edu/.
• Chung, F.R.K. (1997) Spectral Graph Theory. Providence, RI: American Mathematical Society. Available at: https://www.ams.org/books/cbms/092/.
• Diestel, R. (2024) Graph Theory. 6th edn. Berlin: Springer. Available at: https://diestel-graph-theory.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/.
• Godsil, C. and Royle, G. (2001) Algebraic Graph Theory. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-1-4613-0163-9.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://www.press.jhu.edu/books/title/10678/matrix-computations.
• Newman, M.E.J. (2018) Networks. 2nd edn. Oxford: Oxford University Press. Available at: https://global.oup.com/academic/product/networks-9780198805090.
• NetworkX Developers (n.d.) NetworkX Documentation. Available at: https://networkx.org/documentation/stable/.
• NumPy Developers (n.d.) NumPy Documentation. Available at: https://numpy.org/doc/stable/.
• SciPy Developers (n.d.) Sparse Arrays: scipy.sparse. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/sparse.html.
• West, D.B. (2001) Introduction to Graph Theory. 2nd edn. Upper Saddle River, NJ: Prentice Hall. Available at: https://faculty.math.illinois.edu/~west/igt/.

Back to top ↑

References

• Barabási, A.-L. (2016) Network Science. Cambridge: Cambridge University Press. Available at: https://networksciencebook.com/.
• Bollobás, B. (1998) Modern Graph Theory. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-1-4612-0619-4.
• Boyd, S. and Vandenberghe, L. (2018) Introduction to Applied Linear Algebra: Vectors, Matrices, and Least Squares. Cambridge: Cambridge University Press. Available at: https://vmls-book.stanford.edu/.
• Chung, F.R.K. (1997) Spectral Graph Theory. Providence, RI: American Mathematical Society. Available at: https://www.ams.org/books/cbms/092/.
• Diestel, R. (2024) Graph Theory. 6th edn. Berlin: Springer. Available at: https://diestel-graph-theory.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/.
• Godsil, C. and Royle, G. (2001) Algebraic Graph Theory. New York: Springer. Available at: https://link.springer.com/book/10.1007/978-1-4613-0163-9.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://www.press.jhu.edu/books/title/10678/matrix-computations.
• Newman, M.E.J. (2018) Networks. 2nd edn. Oxford: Oxford University Press. Available at: https://global.oup.com/academic/product/networks-9780198805090.
• NetworkX Developers (n.d.) NetworkX Documentation. Available at: https://networkx.org/documentation/stable/.
• NumPy Developers (n.d.) NumPy Documentation. Available at: https://numpy.org/doc/stable/.
• SciPy Developers (n.d.) Sparse Arrays: scipy.sparse. SciPy Documentation. Available at: https://docs.scipy.org/doc/scipy/reference/sparse.html.
• West, D.B. (2001) Introduction to Graph Theory. 2nd edn. Upper Saddle River, NJ: Prentice Hall. Available at: https://faculty.math.illinois.edu/~west/igt/.

Back to top ↑