PageRank and Network Influence Models: How Linear Algebra Ranks Directed Networks

Last Updated July 2, 2026

PageRank and network influence models explain how importance can emerge from directed relationships. In many systems, influence is not only a property of a single node. It depends on who points to whom, who depends on whom, who cites whom, who transfers attention, who receives flow, and how authority moves through a network.

This article continues Part V of the Linear Algebra for Systems Modeling series by connecting directed graphs, adjacency matrices, stochastic matrices, Markov chains, eigenvectors, stationary distributions, damping, teleportation, link structure, centrality, recursive influence, ranking, normalization, convergence, sparsity, sensitivity, and responsible interpretation.

The central modeling question is not only “Which node is most connected?” It is “What kind of influence is being modeled, how does influence move through directed links, and what assumptions are hidden inside the ranking rule?”

PageRank is one of the clearest examples of how linear algebra turns network structure into a ranking model. It begins with a directed graph. Links point from one node to another. Those links are normalized into a transition matrix. A random-walk process moves through the network. A damping factor prevents traps and ensures stable behavior. The long-run stationary distribution becomes a ranking score.

Although PageRank is historically associated with web search, the underlying idea is broader. It appears in citation analysis, knowledge networks, recommendation systems, institutional influence maps, supply-chain dependence, infrastructure exposure, academic literature, digital platforms, and any system where directed relations carry attention, endorsement, dependence, authority, or flow. But PageRank is not a universal measure of importance. It is a model of importance under specific assumptions about how influence moves.

Why PageRank Matters for Systems Modeling

PageRank matters because it shows how global influence can emerge from local directed relationships. A node may be important not because it has the most links, but because it is linked by other important nodes. Influence becomes recursive: a node receives importance from nodes that themselves receive importance.

This recursive structure is naturally expressed through linear algebra. Directed links become a matrix. Normalized columns or rows become transition probabilities. Repeated multiplication simulates movement through the network. Convergence produces a stable influence vector.

PageRank is therefore both a ranking method and a lesson in responsible matrix modeling.

Back to top ↑

Directed Networks and Influence

PageRank begins with a directed graph. A directed edge from node \(i\) to node \(j\) means that \(i\) points to \(j\), cites \(j\), links to \(j\), depends on \(j\), recommends \(j\), or transfers attention toward \(j\), depending on the model.

Directed structure is essential. In an undirected graph, connection is symmetric. In a directed influence model, source and target have different roles. A node can send many links, receive many links, or both.

Direction conventions must be explicit. Reversing edges can reverse the meaning of the ranking.

Back to top ↑

From Links to Transition Matrices

A directed adjacency matrix records links among nodes. But PageRank requires a transition matrix: a matrix whose entries describe probabilities of moving from one node to another.

For a column-stochastic convention, the transition matrix \(P\) satisfies:

If node \(j\) links to several outgoing targets, its rank is distributed across those outgoing links. A node linked by important nodes receives more rank than a node linked by structurally marginal nodes.

Normalization changes the meaning of the adjacency matrix. Raw links become probabilities or shares of attention.

Back to top ↑

Random-Walk Interpretation

PageRank is often explained through a random surfer. The surfer follows links with high probability, but sometimes jumps elsewhere. Over many steps, the fraction of time spent at each node becomes the PageRank score.

Without damping, the basic update is:

This is a Markov-chain model on a graph. The current state is a probability distribution over nodes. Multiplication by \(P\) moves that distribution through the network.

The random-walk interpretation is intuitive, but it is still a model. It assumes that influence behaves like movement through normalized links.

Back to top ↑

Stationary Distributions and Eigenvectors

The PageRank vector is a stationary distribution. It satisfies:

This is an eigenvector equation with eigenvalue one:

This connects PageRank to eigenvalues, eigenvectors, Markov chains, long-run behavior, and linear dynamical systems. The ranking is not merely counted; it is solved as a stable structure of repeated transition.

PageRank is therefore a network influence model built from eigenstructure.

Back to top ↑

Damping, Teleportation, and Rank Stability

Real directed networks can contain sinks, traps, disconnected components, and cycles. PageRank addresses these problems using damping and teleportation. The common PageRank update is:

The damping factor \(\alpha\) is often set near \(0.85\), though the right value depends on the modeling context. The teleportation vector may be uniform or personalized.

Damping is not a minor technical fix. It changes the meaning of influence by mixing network structure with an exogenous restart assumption.

Back to top ↑

Dangling Nodes and Sinks

A dangling node has no outgoing links. In a random-walk model, rank can become trapped unless dangling nodes are handled. Common approaches redistribute rank from dangling nodes uniformly or according to the teleportation vector.

Handling dangling nodes is a modeling decision. It affects rank distribution, especially in sparse or uneven networks.

Back to top ↑

PageRank Versus Degree Centrality

Degree centrality counts direct links. PageRank evaluates links recursively. A node linked by a few important nodes can rank higher than a node linked by many weakly connected nodes.

Degree is often easier to explain. PageRank is often more structurally expressive. Neither is automatically “correct.”

Back to top ↑

PageRank Versus Eigenvector Centrality

Eigenvector centrality and PageRank both use recursive importance. But PageRank adds stochastic normalization, damping, and teleportation, making it more stable on many directed networks.

PageRank can be understood as a stabilized, stochastic, directed-network influence model.

Back to top ↑

Personalized PageRank

Personalized PageRank changes the teleportation vector. Instead of jumping uniformly to all nodes, the process jumps more often to a chosen set of nodes, topics, users, institutions, or seed entities.

This is useful when influence is contextual. A node may be central to one topic, user, region, sector, or policy question but not central globally.

Personalization makes the ranking more specific, but it also introduces value choices about the restart distribution.

Back to top ↑

Topic-Sensitive and Weighted Influence

PageRank-style models can incorporate topics, edge weights, trust signals, capacities, costs, citations, time decay, or other relation strengths. In weighted PageRank, transition probabilities depend on edge weights rather than equal splitting among outgoing links.

Weighted influence models are more flexible, but they require stronger documentation of weight semantics.

Back to top ↑

Convergence and Power Iteration

PageRank is often computed by power iteration. Start with an initial rank vector, repeatedly apply the update rule, and stop when changes are small.

Ranking models should report convergence diagnostics, especially when rankings affect decisions.

Back to top ↑

Sparsity and Large-Scale Computation

Large directed networks are usually sparse. A web graph, citation graph, supply-chain graph, or platform graph may have many nodes but relatively few edges compared with all possible links. PageRank is therefore usually computed using sparse matrix operations rather than dense matrix multiplication.

Sparse computation is not merely an implementation optimization. It is what makes network ranking practical at systems scale.

Back to top ↑

Sensitivity, Manipulation, and Feedback

Network influence models can be sensitive to graph construction. Adding, removing, or reweighting links can change rankings. In adversarial or strategic settings, actors may attempt to manipulate links. In platform settings, rankings can feed back into attention, changing the future network.

PageRank-style models can become institutional ranking systems. That raises accountability questions beyond the mathematics.

Back to top ↑

Network Influence in Systems Modeling

PageRank-style models are useful wherever directed relationships distribute importance. They can identify influential documents, critical infrastructure dependencies, central suppliers, structurally prominent concepts, important transit hubs, authoritative sources, exposed financial institutions, or influential platform nodes.

In each domain, the key question is what the directed edge means. Influence is not generic; it is domain-specific.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. PageRank connects directed graph theory, stochastic matrices, Markov chains, eigenvectors, stationary distributions, damping, Perron-Frobenius theory, sparse matrix-vector multiplication, convergence analysis, perturbation sensitivity, and governance of ranking systems.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for PageRank and network influence models should document node lists, edge lists, direction conventions, adjacency matrices, transition matrices, stochastic convention, dangling-node handling, damping factor, teleportation vector, convergence tolerance, iteration counts, residuals, rank output, sensitivity tests, data provenance, and interpretation warnings.

The companion repository treats PageRank as an auditable network-influence model. 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 ranking analysis.

For this article, the computational examples focus on directed graph construction, transition-matrix normalization, dangling-node handling, damped PageRank iteration, convergence logging, rank comparison, and governance records for influence-model assumptions.

Back to top ↑

Python Workflow: PageRank Audit

The Python workflow below builds a small directed knowledge-and-infrastructure-style network, computes damped PageRank by power iteration, tracks convergence, 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 PageRankAudit:
    graph_name: str
    node_count: int
    edge_count: int
    damping_factor: float
    tolerance: float
    iterations: int
    converged: bool
    max_rank_node: str
    max_rank_score: float
    min_rank_node: str
    min_rank_score: float
    rank_sum: float
    dangling_node_count: int
    interpretation_warning: str


def build_graph() -> tuple[list[str], list[tuple[str, str]]]:
    nodes = ["water", "power", "transport", "communications", "health"]
    edges = [
        ("water", "power"),
        ("power", "transport"),
        ("power", "communications"),
        ("transport", "communications"),
        ("communications", "health"),
        ("health", "water"),
        ("transport", "water"),
        ("communications", "power"),
    ]
    return nodes, edges


def build_column_stochastic_matrix(nodes: list[str], edges: list[tuple[str, str]]) -> tuple[Matrix, int]:
    index = {node: i for i, node in enumerate(nodes)}
    n = len(nodes)
    adjacency = [[0.0 for _ in nodes] for _ in nodes]

    # Column-stochastic convention:
    # P[target][source] is the probability of moving from source to target.
    out_degree = {node: 0 for node in nodes}
    for source, target in edges:
        out_degree[source] += 1

    dangling_count = sum(1 for node in nodes if out_degree[node] == 0)

    for source, target in edges:
        adjacency[index[target]][index[source]] += 1.0 / out_degree[source]

    for node in nodes:
        if out_degree[node] == 0:
            source_index = index[node]
            for target_index in range(n):
                adjacency[target_index][source_index] = 1.0 / n

    return adjacency, dangling_count


def matvec(P: Matrix, r: Vector) -> Vector:
    return [sum(P[i][j] * r[j] for j in range(len(r))) for i in range(len(P))]


def l1_distance(a: Vector, b: Vector) -> float:
    return sum(abs(x - y) for x, y in zip(a, b))


def pagerank(
    P: Matrix,
    damping: float = 0.85,
    tolerance: float = 1e-10,
    max_iterations: int = 200,
) -> tuple[Vector, int, bool, list[dict[str, float]]]:
    n = len(P)
    r = [1.0 / n for _ in range(n)]
    teleport = [1.0 / n for _ in range(n)]
    log = []

    for iteration in range(1, max_iterations + 1):
        moved = matvec(P, r)
        next_r = [
            damping * moved[i] + (1.0 - damping) * teleport[i]
            for i in range(n)
        ]
        residual = l1_distance(next_r, r)
        log.append({"iteration": iteration, "l1_residual": residual})
        r = next_r

        if residual < tolerance:
            return r, iteration, True, log

    return r, max_iterations, False, log


def write_rank_table(path: Path, nodes: list[str], ranks: Vector) -> None:
    rows = sorted(
        [{"node": node, "rank": rank} for node, rank in zip(nodes, ranks)],
        key=lambda row: row["rank"],
        reverse=True,
    )
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=["node", "rank"])
        writer.writeheader()
        for row in rows:
            writer.writerow({"node": row["node"], "rank": round(row["rank"], 12)})


def write_convergence_log(path: Path, log: list[dict[str, float]]) -> None:
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=["iteration", "l1_residual"])
        writer.writeheader()
        for row in log:
            writer.writerow({
                "iteration": row["iteration"],
                "l1_residual": f"{row['l1_residual']:.12e}",
            })


def build_audit() -> tuple[PageRankAudit, list[str], list[tuple[str, str]], Vector, list[dict[str, float]]]:
    nodes, edges = build_graph()
    P, dangling_count = build_column_stochastic_matrix(nodes, edges)
    damping = 0.85
    tolerance = 1e-10
    ranks, iterations, converged, convergence_log = pagerank(P, damping=damping, tolerance=tolerance)

    rank_rows = list(zip(nodes, ranks))
    max_node, max_rank = max(rank_rows, key=lambda item: item[1])
    min_node, min_rank = min(rank_rows, key=lambda item: item[1])

    audit = PageRankAudit(
        graph_name="synthetic_directed_network_influence_model",
        node_count=len(nodes),
        edge_count=len(edges),
        damping_factor=damping,
        tolerance=tolerance,
        iterations=iterations,
        converged=converged,
        max_rank_node=max_node,
        max_rank_score=round(max_rank, 12),
        min_rank_node=min_node,
        min_rank_score=round(min_rank, 12),
        rank_sum=round(sum(ranks), 12),
        dangling_node_count=dangling_count,
        interpretation_warning=(
            "PageRank scores depend on node definitions, directed-edge meaning, transition normalization, "
            "dangling-node handling, damping factor, teleportation vector, convergence tolerance, graph boundary, "
            "and data provenance. Rank is a model-specific influence score, not automatic importance."
        ),
    )

    return audit, nodes, edges, ranks, convergence_log


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, nodes, edges, ranks, convergence_log = build_audit()
    row = asdict(audit)

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

    with (output_dir / "tables" / "directed_edge_list.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=["source", "target"])
        writer.writeheader()
        for source, target in edges:
            writer.writerow({"source": source, "target": target})

    write_rank_table(output_dir / "tables" / "pagerank_scores.csv", nodes, ranks)
    write_convergence_log(output_dir / "tables" / "pagerank_convergence_log.csv", convergence_log)

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


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

This workflow keeps the directed graph, transition convention, damping factor, convergence diagnostics, score table, and interpretation warning together.

Back to top ↑

R Workflow: Influence Ranking Diagnostics

R can support PageRank-style diagnostics by constructing a directed transition matrix, running damped iteration, and exporting ranks and convergence checks.

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

edges <- data.frame(
  source = c("water", "power", "power", "transport", "communications", "health", "transport", "communications"),
  target = c("power", "transport", "communications", "communications", "health", "water", "water", "power")
)

n <- length(nodes)
node_index <- setNames(seq_along(nodes), nodes)

out_degree <- setNames(rep(0, n), nodes)
for (i in seq_len(nrow(edges))) {
  out_degree[edges$source[i]] <- out_degree[edges$source[i]] + 1
}

P <- matrix(0, nrow = n, ncol = n)
rownames(P) <- nodes
colnames(P) <- nodes

for (i in seq_len(nrow(edges))) {
  source <- edges$source[i]
  target <- edges$target[i]
  P[node_index[target], node_index[source]] <- P[node_index[target], node_index[source]] + 1 / out_degree[source]
}

dangling_nodes <- names(out_degree[out_degree == 0])
if (length(dangling_nodes) > 0) {
  for (node in dangling_nodes) {
    P[, node_index[node]] <- 1 / n
  }
}

damping <- 0.85
tolerance <- 1e-10
max_iterations <- 200

rank_vector <- rep(1 / n, n)
teleport <- rep(1 / n, n)
convergence_log <- data.frame(iteration = integer(), l1_residual = numeric())

for (iteration in seq_len(max_iterations)) {
  next_rank <- damping * (P %*% rank_vector) + (1 - damping) * teleport
  residual <- sum(abs(next_rank - rank_vector))
  convergence_log <- rbind(
    convergence_log,
    data.frame(iteration = iteration, l1_residual = residual)
  )
  rank_vector <- as.numeric(next_rank)
  if (residual < tolerance) {
    break
  }
}

rank_table <- data.frame(node = nodes, rank = rank_vector)
rank_table <- rank_table[order(-rank_table$rank), ]

audit_record <- data.frame(
  graph_name = "synthetic_directed_network_influence_model",
  node_count = n,
  edge_count = nrow(edges),
  damping_factor = damping,
  tolerance = tolerance,
  iterations = nrow(convergence_log),
  converged = tail(convergence_log$l1_residual, 1) < tolerance,
  max_rank_node = rank_table$node[1],
  max_rank_score = rank_table$rank[1],
  min_rank_node = rank_table$node[nrow(rank_table)],
  min_rank_score = rank_table$rank[nrow(rank_table)],
  rank_sum = sum(rank_vector),
  dangling_node_count = length(dangling_nodes),
  interpretation_warning = paste(
    "PageRank scores depend on node definitions, directed-edge meaning,",
    "transition normalization, dangling-node handling, damping factor,",
    "teleportation vector, convergence tolerance, graph boundary, and data provenance."
  )
)

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

write.csv(audit_record, "outputs/tables/r_pagerank_audit.csv", row.names = FALSE)
write.csv(rank_table, "outputs/tables/r_pagerank_scores.csv", row.names = FALSE)
write.csv(convergence_log, "outputs/tables/r_pagerank_convergence_log.csv", row.names = FALSE)
write.csv(edges, "outputs/tables/r_directed_edge_list.csv", row.names = FALSE)

print(audit_record)

This R workflow keeps ranking output tied to convergence, damping, graph construction, and interpretive constraints.

Back to top ↑

Haskell Workflow: Typed Influence Records

Haskell can represent PageRank audit output as typed records, keeping ranking parameters and interpretation warnings attached to the results.

module Main where

data PageRankAudit = PageRankAudit
  { graphName :: String
  , nodeCount :: Int
  , edgeCount :: Int
  , dampingFactor :: Double
  , tolerance :: Double
  , iterations :: Int
  , converged :: Bool
  , maxRankNode :: String
  , maxRankScore :: Double
  , minRankNode :: String
  , minRankScore :: Double
  , rankSum :: Double
  , danglingNodeCount :: Int
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: PageRankAudit
buildAudit =
  PageRankAudit
    "synthetic_directed_network_influence_model"
    5
    8
    0.85
    1.0e-10
    42
    True
    "power"
    0.246
    "transport"
    0.144
    1.0
    0
    "PageRank scores depend on node definitions, directed-edge meaning, transition normalization, dangling-node handling, damping factor, teleportation vector, convergence tolerance, graph boundary, and data provenance."

main :: IO ()
main =
  print buildAudit

The typed record helps prevent rank scores from being separated from model assumptions.

Back to top ↑

SQL Workflow: Network Influence Registry

SQL can document ranking assumptions when PageRank-style models support search, recommendation, citation analysis, supply-chain review, infrastructure analysis, institutional dashboards, or platform governance.

CREATE TABLE network_influence_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_influence_registry VALUES
(
  'node_definition',
  'Node definition',
  'Defines the entities ranked by the PageRank vector.',
  'Determines what influence scores can mean.',
  'Changing node definitions can change the ranking.'
);

INSERT INTO network_influence_registry VALUES
(
  'directed_edge_meaning',
  'Directed edge meaning',
  'Defines what directed links represent.',
  'Determines whether rank means attention, authority, dependence, exposure, or flow.',
  'Reversing edge direction can reverse substantive interpretation.'
);

INSERT INTO network_influence_registry VALUES
(
  'transition_normalization',
  'Transition normalization',
  'Converts directed adjacency into a stochastic matrix.',
  'Determines how rank is distributed across outgoing links.',
  'Normalization changes raw link structure into probabilistic movement.'
);

INSERT INTO network_influence_registry VALUES
(
  'dangling_node_handling',
  'Dangling-node handling',
  'Defines redistribution for nodes with no outgoing links.',
  'Prevents rank from leaking or becoming trapped.',
  'Different redistribution rules can change scores.'
);

INSERT INTO network_influence_registry VALUES
(
  'damping_factor',
  'Damping factor',
  'Controls the balance between link-following and teleportation.',
  'Determines how strongly network structure governs rank.',
  'The damping value is a modeling assumption, not a neutral constant.'
);

INSERT INTO network_influence_registry VALUES
(
  'teleportation_vector',
  'Teleportation vector',
  'Defines restart distribution.',
  'Represents background attention, personalization, or topic sensitivity.',
  'Teleportation choices encode value and scope assumptions.'
);

INSERT INTO network_influence_registry VALUES
(
  'convergence_tolerance',
  'Convergence tolerance',
  'Defines stopping rule for power iteration.',
  'Determines numerical reliability of ranking output.',
  'Small score differences may not be meaningful without convergence review.'
);

INSERT INTO network_influence_registry VALUES
(
  'ranking_governance',
  'Ranking governance',
  'Defines how rank scores should be interpreted and used.',
  'Determines accountability for downstream decisions.',
  'Ranking models can create feedback, manipulation incentives, and concentration effects.'
);

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

This registry keeps PageRank analysis tied to directed-edge meaning, normalization, damping, teleportation, convergence, and governance.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports PageRank audits, directed edge lists, transition-matrix construction, dangling-node handling, damped power iteration, convergence diagnostics, influence-ranking outputs, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

PageRank is powerful because it turns directed network structure into a stable influence score. It captures recursive importance, directed attention, long-run rank flow, and the relationship between graph theory, Markov chains, and eigenvectors. Its limits arise because the score depends on modeling choices: node definitions, edge meanings, direction conventions, normalization, dangling-node treatment, damping, teleportation, convergence tolerance, graph boundary, data quality, and downstream use.

A high PageRank score does not automatically mean truth, merit, value, quality, reliability, legitimacy, safety, or moral importance. It means a node is structurally prominent under a particular directed influence model. In citation systems, that may reflect attention or disciplinary convention. In web systems, it may reflect link structure. In infrastructure, it may reflect dependency. In platforms, it may reflect feedback and visibility. In finance, it may reflect exposure. The meaning is domain-specific.

Responsible use requires documenting the network, testing sensitivity, reporting convergence, auditing manipulation, examining feedback loops, comparing alternative centrality measures, and explaining what the rank score does and does not mean. PageRank should clarify directed influence structure, not convert network position into unquestioned authority.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Network Adjacency Matrices
• Incidence Structure and Graph Representation
• Graph Theory Foundations for Systems Modeling
• Network Flow Modeling
• Infrastructure Network Models
• Flow, Connectivity, and System Vulnerability
• Markov Chains and Transition Matrices
• Long-Run Behavior in State Transition Systems
• Linear Dynamical Systems
• Eigenvalues, Eigenvectors, and System Modes
• Diagonalization and Decoupled System Behavior
• Stability Analysis with Eigenvalues
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling
• Algorithms & Computational Reasoning
• 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/.
• Brin, S. and Page, L. (1998) ‘The anatomy of a large-scale hypertextual Web search engine’, Computer Networks and ISDN Systems, 30(1–7), pp. 107–117. Available at: https://doi.org/10.1016/S0169-7552(98)00110-X.
• Boldi, P., Santini, M. and Vigna, S. (2005) ‘PageRank as a function of the damping factor’, Proceedings of the 14th International Conference on World Wide Web, pp. 557–566. Available at: https://doi.org/10.1145/1060745.1060827.
• 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/.
• 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/.
• Langville, A.N. and Meyer, C.D. (2012) Google’s PageRank and Beyond: The Science of Search Engine Rankings. Princeton, NJ: Princeton University Press. Available at: https://press.princeton.edu/books/paperback/9780691152660/googles-pagerank-and-beyond.
• 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.) PageRank. NetworkX Documentation. Available at: https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.link_analysis.pagerank_alg.pagerank.html.
• Page, L., Brin, S., Motwani, R. and Winograd, T. (1999) The PageRank Citation Ranking: Bringing Order to the Web. Stanford InfoLab. Available at: http://ilpubs.stanford.edu:8090/422/.
• Seneta, E. (2006) Non-negative Matrices and Markov Chains. Revised edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/0-387-32792-4.

Back to top ↑

References

• Barabási, A.-L. (2016) Network Science. Cambridge: Cambridge University Press. Available at: https://networksciencebook.com/.
• Boldi, P., Santini, M. and Vigna, S. (2005) ‘PageRank as a function of the damping factor’, Proceedings of the 14th International Conference on World Wide Web, pp. 557–566. Available at: https://doi.org/10.1145/1060745.1060827.
• 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/.
• Brin, S. and Page, L. (1998) ‘The anatomy of a large-scale hypertextual Web search engine’, Computer Networks and ISDN Systems, 30(1–7), pp. 107–117. Available at: https://doi.org/10.1016/S0169-7552(98)00110-X.
• 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/.
• Langville, A.N. and Meyer, C.D. (2012) Google’s PageRank and Beyond: The Science of Search Engine Rankings. Princeton, NJ: Princeton University Press. Available at: https://press.princeton.edu/books/paperback/9780691152660/googles-pagerank-and-beyond.
• 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.) PageRank. NetworkX Documentation. Available at: https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.link_analysis.pagerank_alg.pagerank.html.
• Page, L., Brin, S., Motwani, R. and Winograd, T. (1999) The PageRank Citation Ranking: Bringing Order to the Web. Stanford InfoLab. Available at: http://ilpubs.stanford.edu:8090/422/.
• Seneta, E. (2006) Non-negative Matrices and Markov Chains. Revised edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/0-387-32792-4.

Back to top ↑