Incidence Structure and Graph Representation: How Linear Algebra Encodes Nodes, Edges, and Flow Balance

Last Updated July 2, 2026

Incidence structure and graph representation explain how networks can be encoded through the relationship between nodes and edges. Where an adjacency matrix records node-to-node connection, an incidence matrix records node-to-edge participation. This shift is powerful: it makes edges explicit, supports flow balance, conservation laws, graph orientation, node-edge constraints, Laplacian construction, network optimization, infrastructure modeling, and systems-level reasoning about how local connections produce global structure.

This article continues Part V of the Linear Algebra for Systems Modeling series by connecting nodes, edges, incidence matrices, oriented incidence, unsigned incidence, directed graphs, undirected graphs, edge lists, adjacency lists, node-edge matrices, graph Laplacians, flow conservation, cut structure, cycle structure, sparse representation, network data modeling, and responsible interpretation.

The central modeling question is not only “Which nodes are connected?” It is “How are relationships represented as edges, how do those edges attach to nodes, and what does the chosen graph representation make visible or invisible about structure, flow, dependence, and system behavior?”

An adjacency matrix asks whether one node connects to another. An incidence matrix asks which nodes participate in which edges. This may sound like a small difference, but it changes the mathematics. Incidence structure makes edges into first-class objects. It supports flow conservation, network constraints, node balances, cuts, cycles, graph Laplacians, transportation modeling, electrical networks, water systems, supply-chain pathways, ecological interactions, and optimization on networks.

Graph representation is therefore not merely a data-format choice. Edge lists, adjacency matrices, adjacency lists, incidence matrices, and sparse matrix formats each support different questions. Some make node-to-node connection easy. Some make edge-level auditing easier. Some scale well. Some preserve direction. Some support conservation laws. Some are easier to visualize. A responsible network model chooses representation according to the structure being studied.

Why Incidence Structure Matters

Incidence structure matters because many network questions concern not only which nodes are connected, but how edges attach to nodes. A road segment has two endpoints. A transmission line connects two substations. A pipe links two junctions. A citation points from one paper to another. A supply contract links a supplier and a buyer. A flow path connects origin and destination. An incidence matrix represents this node-edge relationship directly.

This representation is central when edges carry quantities. Traffic moves along roads. Electricity moves along lines. Water moves through pipes. Goods move through supply chains. Information moves through channels. Risk moves through exposure networks. An incidence matrix helps convert edge-level flows into node-level balances.

Incidence structure is especially valuable when a network model must audit edges, flows, constraints, and node-level balances.

Back to top ↑

Graphs as Nodes and Edges

A graph consists of nodes and edges. Nodes represent entities. Edges represent relationships. Formally, a graph is often written as:

An edge may be undirected, directed, weighted, labeled, temporal, spatial, or typed. The representation chosen depends on what the edge means.

Graph representation begins with these definitions. Linear algebra can analyze structure only after the modeled entities and relationships are made explicit.

Back to top ↑

Adjacency Versus Incidence

Adjacency and incidence matrices represent the same graph from different angles. An adjacency matrix is node-by-node. An incidence matrix is node-by-edge.

Adjacency emphasizes relationships among nodes. Incidence emphasizes how edges attach to nodes. Both are useful, but they answer different modeling questions.

Back to top ↑

Unsigned Incidence Matrices

An unsigned incidence matrix records whether a node participates in an edge. For a simple undirected graph:

Each ordinary undirected edge has two endpoint nodes, so each edge column often contains two nonzero entries. This representation is useful when the network is undirected and edge participation matters more than orientation.

Unsigned incidence is simple and interpretable, but it does not encode direction. For flows, conservation, and oriented systems, signed incidence is usually more useful.

Back to top ↑

Oriented Incidence Matrices

An oriented incidence matrix assigns signs to edge endpoints. A common convention is:

Some fields use the opposite sign convention. The important requirement is consistency. Once a convention is chosen, edge flows can be multiplied through the incidence matrix to compute node-level balances.

Oriented incidence matrices are central in flow networks, electrical circuits, transportation systems, conservation models, and graph Laplacian construction.

Back to top ↑

Directed Graphs and Direction Conventions

Direction conventions must be documented carefully. A directed edge can represent movement, influence, citation, dependency, command, risk exposure, payment, supply, or information transfer. The direction of the edge may mean “from source to target,” “from dependent to provider,” or “from provider to dependent,” depending on the domain.

Direction is not a visual arrow alone. It is a semantic claim about how relation, flow, dependence, or influence should be interpreted.

Back to top ↑

Edge Lists, Adjacency Lists, and Matrix Formats

Graphs can be stored in several formats. Each format supports different workflows.

There is no universally best graph representation. A serious workflow often keeps the edge list as an auditable source and generates adjacency or incidence matrices for specific computations.

Back to top ↑

Flow Balance and Node Conservation

Incidence matrices are especially useful for flow balance. Let \(\mathbf{f}\) be a vector of edge flows. Multiplying the incidence matrix by the edge-flow vector gives a node-balance vector:

Under the sign convention used here, positive entries of \(\mathbf{b}\) may represent net inflow and negative entries may represent net outflow. In other conventions, the sign interpretation reverses.

Flow balance is one reason incidence matrices are foundational in network optimization, electrical circuits, hydraulic systems, logistics, transportation, and infrastructure modeling.

Back to top ↑

Incidence Matrices and Graph Laplacians

Incidence matrices provide a direct path to graph Laplacians. For an oriented incidence matrix \(B\), the unweighted graph Laplacian can be written as:

For weighted graphs, with edge-weight matrix \(W\), the weighted Laplacian is:

The graph Laplacian appears in diffusion, consensus, electrical networks, spectral clustering, graph cuts, smoothing, vibration, random walks, and network robustness.

The Laplacian shows how incidence structure links local node-edge relationships to global network behavior.

Back to top ↑

Cuts, Cycles, and Structural Subspaces

Incidence matrices reveal structural subspaces of a graph. The column space of an incidence matrix is connected to node-balance patterns. The null space is connected to cycles and circulations.

This matters in systems where flow can circulate without external supply or demand, such as electrical loops, transport circulation, closed hydraulic systems, supply loops, and feedback pathways.

Incidence structure therefore connects graph topology to the linear algebra of subspaces.

Back to top ↑

Weighted Incidence Structure

In many systems, edges have weights. A road has capacity or travel time. A pipe has conductance or resistance. A power line has impedance. A supply link has volume or dependency. A financial edge has exposure. A communication link has bandwidth or frequency.

Weights can be incorporated through a diagonal edge-weight matrix:

Weighted incidence structure should never treat all weights as equivalent. Weight semantics determine the correct mathematics.

Back to top ↑

Sparse Representation and Computation

Incidence matrices are usually sparse. Each edge column touches only a small number of nodes. In a simple graph, each ordinary edge touches two nodes, so each column has only two nonzero entries. This makes incidence matrices well suited for sparse storage and scalable computation.

Large infrastructure, platform, citation, transaction, and supply-chain networks cannot usually be treated as dense matrices. Sparse representation is part of the modeling architecture.

Back to top ↑

Graph Representation Choices

Graph representation choices should follow the question being asked. A modeler should not choose adjacency, incidence, edge lists, or graph objects merely because one format is familiar. Each representation privileges different structure.

Responsible graph modeling often preserves multiple representations: an edge list for audit, a sparse matrix for computation, and metadata for interpretation.

Back to top ↑

Incidence Structure in Systems Modeling

Incidence structure is especially important when systems are defined by flows, constraints, boundaries, and conservation. It supports models of transportation, water, power, logistics, communications, ecological movement, financial exposure, supply chains, and engineered networks.

Incidence structure is strongest when edge-level relationships are meaningful, auditable, and central to system behavior.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Incidence structure connects graph representation, oriented incidence matrices, node-edge maps, flow conservation, graph Laplacians, cut spaces, cycle spaces, sparse matrices, network optimization, electrical network theory, discrete differential operators, and systems governance.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for incidence structure should document node lists, edge lists, source-target conventions, signed incidence matrices, unsigned incidence matrices, edge weights, flow vectors, node balances, Laplacians, rank diagnostics, sparsity, connected components, cut and cycle interpretation, data provenance, and representation warnings.

The companion repository treats incidence matrices as auditable graph 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 node-edge analysis.

For this article, the computational examples focus on constructing an oriented incidence matrix from an edge list, computing node balances from edge flows, deriving a graph Laplacian, reporting rank and sparsity, and preserving governance records for graph representation choices.

Back to top ↑

Python Workflow: Incidence Matrix Audit

The Python workflow below constructs an oriented incidence matrix from a small infrastructure-style edge list, computes node balances from edge flows, derives an unweighted Laplacian, and writes auditable outputs.

from __future__ import annotations

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


Matrix = list[list[float]]
Vector = list[float]


@dataclass(frozen=True)
class IncidenceStructureAudit:
    graph_name: str
    node_count: int
    edge_count: int
    directed_convention: str
    signed_incidence: bool
    nonzero_incidence_entries: int
    incidence_density: float
    max_absolute_node_balance: float
    laplacian_trace: float
    rank_estimate: int
    flow_conservation_warning: str
    representation_warning: str


def transpose(A: Matrix) -> Matrix:
    return [list(row) for row in zip(*A)]


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 matvec(A: Matrix, x: Vector) -> Vector:
    return [sum(A[i][j] * x[j] for j in range(len(x))) for i in range(len(A))]


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


def trace(A: Matrix) -> float:
    return sum(A[i][i] for i in range(min(len(A), len(A[0]))))


def rank_via_row_reduction(A: Matrix, tolerance: float = 1e-10) -> int:
    M = [row[:] for row in A]
    rows = len(M)
    cols = len(M[0]) if rows else 0
    rank = 0

    for col in range(cols):
        pivot = None
        for r in range(rank, rows):
            if abs(M[r][col]) > tolerance:
                pivot = r
                break
        if pivot is None:
            continue

        M[rank], M[pivot] = M[pivot], M[rank]
        pivot_value = M[rank][col]
        M[rank] = [value / pivot_value for value in M[rank]]

        for r in range(rows):
            if r != rank and abs(M[r][col]) > tolerance:
                factor = M[r][col]
                M[r] = [M[r][c] - factor * M[rank][c] for c in range(cols)]

        rank += 1
        if rank == rows:
            break

    return rank


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


def build_incidence(node_names: list[str], edges: list[tuple[str, str, float]]) -> Matrix:
    node_index = {node: i for i, node in enumerate(node_names)}
    B = [[0.0 for _ in edges] for _ in node_names]

    for edge_index, (source, target, _weight) in enumerate(edges):
        B[node_index[source]][edge_index] = -1.0
        B[node_index[target]][edge_index] = 1.0

    return B


def build_audit() -> tuple[IncidenceStructureAudit, list[str], list[str], Matrix, Matrix, Vector]:
    node_names = ["water", "power", "transport", "communications"]
    edges = [
        ("water", "power", 0.75),
        ("power", "transport", 0.60),
        ("power", "communications", 0.80),
        ("transport", "communications", 0.45),
        ("communications", "water", 0.30),
    ]
    edge_names = [f"e{i+1}_{source}_to_{target}" for i, (source, target, _weight) in enumerate(edges)]

    B = build_incidence(node_names, edges)
    flows = [12.0, 9.0, 5.0, 4.0, 3.0]
    balances = matvec(B, flows)
    L = matmul(B, transpose(B))

    nonzero = count_nonzero(B)
    density = nonzero / (len(B) * len(B[0]))

    audit = IncidenceStructureAudit(
        graph_name="synthetic_infrastructure_incidence_graph",
        node_count=len(node_names),
        edge_count=len(edges),
        directed_convention="B[v,e] = -1 at source/tail and +1 at target/head.",
        signed_incidence=True,
        nonzero_incidence_entries=nonzero,
        incidence_density=round(density, 12),
        max_absolute_node_balance=round(max(abs(value) for value in balances), 12),
        laplacian_trace=round(trace(L), 12),
        rank_estimate=rank_via_row_reduction(B),
        flow_conservation_warning=(
            "Node balances are computed from synthetic edge flows. "
            "Interpreting imbalance requires source, sink, storage, and boundary assumptions."
        ),
        representation_warning=(
            "Incidence structure depends on node definitions, edge definitions, sign convention, "
            "edge direction, weight semantics, data provenance, and conservation assumptions."
        ),
    )

    return audit, node_names, edge_names, B, L, balances


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, edge_names, B, L, balances = build_audit()
    row = asdict(audit)

    with (output_dir / "tables" / "incidence_structure_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" / "oriented_incidence_matrix.csv", node_names, edge_names, B)
    write_matrix_csv(output_dir / "tables" / "graph_laplacian_from_incidence.csv", node_names, node_names, L)

    with (output_dir / "tables" / "node_balance_from_edge_flows.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=["node", "balance"])
        writer.writeheader()
        for node, balance in zip(node_names, balances):
            writer.writerow({"node": node, "balance": round(balance, 8)})

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


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Incidence structure audit complete.")

This workflow keeps the edge list, signed incidence matrix, Laplacian, node balances, rank estimate, and representation warnings together.

Back to top ↑

R Workflow: Graph Representation Diagnostics

R can support incidence diagnostics by constructing a node-edge matrix from an edge list, computing node balances, deriving a Laplacian, and exporting audit records.

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

edges <- data.frame(
  source = c("water", "power", "power", "transport", "communications"),
  target = c("power", "transport", "communications", "communications", "water"),
  weight = c(0.75, 0.60, 0.80, 0.45, 0.30)
)

edge_names <- paste0(
  "e", seq_len(nrow(edges)), "_",
  edges$source, "_to_", edges$target
)

B <- matrix(0, nrow = length(node_names), ncol = nrow(edges))
rownames(B) <- node_names
colnames(B) <- edge_names

for (e in seq_len(nrow(edges))) {
  B[edges$source[e], e] <- -1
  B[edges$target[e], e] <- 1
}

flows <- c(12, 9, 5, 4, 3)
names(flows) <- edge_names

balances <- B %*% flows
L <- B %*% t(B)

audit_record <- data.frame(
  graph_name = "synthetic_infrastructure_incidence_graph",
  node_count = length(node_names),
  edge_count = nrow(edges),
  directed_convention = "B[v,e] = -1 at source/tail and +1 at target/head.",
  signed_incidence = TRUE,
  nonzero_incidence_entries = sum(B != 0),
  incidence_density = sum(B != 0) / (nrow(B) * ncol(B)),
  max_absolute_node_balance = max(abs(balances)),
  laplacian_trace = sum(diag(L)),
  rank_estimate = qr(B)$rank,
  representation_warning = paste(
    "Incidence structure depends on node definitions, edge definitions,",
    "sign convention, edge direction, weights, data provenance, and conservation assumptions."
  )
)

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

write.csv(audit_record, "outputs/tables/r_incidence_structure_audit.csv", row.names = FALSE)
write.csv(B, "outputs/tables/r_oriented_incidence_matrix.csv")
write.csv(L, "outputs/tables/r_graph_laplacian_from_incidence.csv")
write.csv(
  data.frame(node = node_names, balance = as.numeric(balances)),
  "outputs/tables/r_node_balance_from_edge_flows.csv",
  row.names = FALSE
)

print(audit_record)

This R workflow treats graph representation as a reproducible modeling step rather than a hidden conversion.

Back to top ↑

Haskell Workflow: Typed Incidence Records

Haskell can represent incidence diagnostics as typed records, keeping sign convention, rank estimate, conservation warning, and representation warning attached to the graph summary.

module Main where

data IncidenceStructureAudit = IncidenceStructureAudit
  { graphName :: String
  , nodeCount :: Int
  , edgeCount :: Int
  , directedConvention :: String
  , signedIncidence :: Bool
  , nonzeroIncidenceEntries :: Int
  , incidenceDensity :: Double
  , maxAbsoluteNodeBalance :: Double
  , laplacianTrace :: Double
  , rankEstimate :: Int
  , representationWarning :: String
  } deriving (Show)

buildAudit :: IncidenceStructureAudit
buildAudit =
  IncidenceStructureAudit
    "synthetic_infrastructure_incidence_graph"
    4
    5
    "B[v,e] = -1 at source/tail and +1 at target/head."
    True
    10
    0.5
    9.0
    10.0
    3
    "Incidence structure depends on node definitions, edge definitions, sign convention, edge direction, weight semantics, data provenance, and conservation assumptions."

main :: IO ()
main =
  print buildAudit

The typed record helps prevent edge-flow outputs from being separated from representation assumptions.

Back to top ↑

SQL Workflow: Incidence Representation Registry

SQL can document graph-representation assumptions when incidence matrices support infrastructure dashboards, network optimization, flow modeling, supply-chain analysis, ecological modeling, graph analytics, or institutional decision systems.

CREATE TABLE incidence_representation_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 incidence_representation_registry VALUES
(
  'node_definition',
  'Node definition',
  'Defines rows of the incidence matrix.',
  'Determines which entities can accumulate, supply, demand, receive, or send flow.',
  'Excluded nodes can distort balance and connectivity conclusions.'
);

INSERT INTO incidence_representation_registry VALUES
(
  'edge_definition',
  'Edge definition',
  'Defines columns of the incidence matrix.',
  'Determines which relationships or flow channels are represented.',
  'Different edge definitions produce different incidence structure.'
);

INSERT INTO incidence_representation_registry VALUES
(
  'sign_convention',
  'Sign convention',
  'Defines whether source nodes receive -1 or +1 entries.',
  'Determines how edge flows translate into node balances.',
  'Changing sign conventions reverses balance interpretation.'
);

INSERT INTO incidence_representation_registry VALUES
(
  'edge_direction',
  'Edge direction',
  'Defines source and target for each edge.',
  'Determines orientation of flow, influence, dependency, or relation.',
  'Direction must match domain meaning, not just visual layout.'
);

INSERT INTO incidence_representation_registry VALUES
(
  'edge_weight',
  'Edge weight',
  'Defines edge weight semantics.',
  'Determines whether weights represent capacity, conductance, resistance, cost, exposure, or probability.',
  'Weights may require transformation before entering Laplacian or flow equations.'
);

INSERT INTO incidence_representation_registry VALUES
(
  'flow_conservation',
  'Flow conservation',
  'Defines whether Bf = b represents conservation, imbalance, storage, supply, or demand.',
  'Determines interpretation of node balances.',
  'Conservation assumptions must be matched to physical or institutional reality.'
);

INSERT INTO incidence_representation_registry VALUES
(
  'laplacian_construction',
  'Laplian construction',
  'Defines how incidence structure is transformed into a graph Laplacian.',
  'Supports diffusion, cuts, smoothness, electrical analogy, and spectral analysis.',
  'Unweighted and weighted Laplacians encode different assumptions.'
);

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

This registry keeps incidence-matrix analysis tied to node definitions, edge definitions, sign conventions, edge directions, weights, conservation assumptions, and Laplacian construction.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports incidence-structure audits, oriented incidence matrices, edge-list conversion, node-balance computation, graph Laplacian construction, rank diagnostics, sparse representation, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Incidence structure is powerful because it makes edges explicit. It supports flow conservation, node balances, graph Laplacians, cut and cycle analysis, sparse computation, and auditable conversion from edge lists to matrices. Its limits arise because real systems contain ambiguous boundaries, uncertain edges, nonlinear constraints, temporal variation, hidden flows, measurement bias, multiple relation types, institutional context, and contested interpretations of what flow or connection means.

An incidence matrix is not neutral. Rows depend on node definitions. Columns depend on edge definitions. Signs depend on convention. Weights depend on domain semantics. Flow-balance equations depend on assumptions about conservation, accumulation, sources, sinks, and storage. A Laplacian built from incidence structure depends on whether the graph is weighted, directed, normalized, physical, probabilistic, or symbolic.

Responsible use requires documenting node boundaries, edge sources, direction conventions, sign conventions, weight meanings, flow units, conservation assumptions, sparse representation choices, data provenance, missingness, uncertainty, time period, and downstream use. Incidence matrices should make graph structure auditable, not hide modeling choices behind elegant algebra.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Network Adjacency Matrices
• Graph Theory Foundations for Systems Modeling
• PageRank and Network Influence Models
• Network Flow Modeling
• Infrastructure Network Models
• Flow, Connectivity, and System Vulnerability
• 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
• Stability Analysis with Eigenvalues
• Markov Chains and Transition Matrices
• Linear Dynamical Systems
• Control Systems Modeling
• 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/.
• 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/.
• 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 ↑