The Algorithm That Tamed the Web: Understanding PageRank’s Mathematics and Legacy

In the mid-1990s, as the World Wide Web was exploding from a niche academic enclave into a global phenomenon, a critical problem emerged: how could anyone find anything useful among the hundreds of millions of pages? Early search engines like AltaVista, Lycos, and Excite relied largely on keyword matching and simple heuristics like word frequency. But this approach was quickly gamed by spam—pages stuffed with irrelevant keywords could rank high for popular queries, burying high-quality content. The web, it seemed, was becoming a noisy bazaar where the best information was often hidden deep in the search results.

The solution came in 1998 from two Stanford PhD students, Larry Page and Sergey Brin. They developed an algorithm that treated the web not as a collection of loosely connected documents, but as a vast, directed graph of hyperlinks. The core idea was both elegant and revolutionary: a page is important if important pages link to it. This recursive definition, known as PageRank, became the secret sauce behind Google’s rise from a university project to the world’s most influential technology company. But PageRank is more than just a historical curiosity or a footnote in the story of search engines. Its underlying mathematical framework—a blend of linear algebra, Markov chains, and graph theory—has become a foundational tool in virtually every domain that deals with networked data. From social network analysis and recommendation systems to biological networks and even the ranking of scientific papers, PageRank and its variants underpin a vast swath of modern computational thinking.

Understanding how PageRank works in detail, however, reveals nuances that are often glossed over in high-level descriptions. Most practitioners know that PageRank is about counting links with a damping factor, but the real power—and subtlety—lies in three key components: power iteration, the damping factor, and personalization. These are not just implementation details; they are the mathematical pillars that make PageRank both computationally tractable and practically useful. In this article, we will peel back the layers of PageRank, exploring its history, mathematics, engineering challenges, and remarkable reach far beyond search engines. By the end, you will understand why this algorithm remains one of the most influential ideas in computer science, and how you can apply its principles to your own networked data.

1. The Pre-PageRank Web: A Spam-Infested Frontier

To appreciate the brilliance of PageRank, we must first walk through the state of web search in the mid-1990s. The web was growing exponentially: from roughly 10,000 websites in 1994 to over 2 million by 1998. Early search engines like AltaVista (launched 1995) were marvels of engineering, indexing hundreds of millions of pages. But their ranking algorithms were simple. A page’s relevance to a query was typically determined by term frequency–inverse document frequency (TF–IDF) , a classic information retrieval technique. TF–IDF scores a document’s relevance to a query based on how often the query terms appear in the document, normalized by how common those terms are across the entire corpus.

The problem? TF–IDF is entirely content-based. If you stuff the word “Porsche” into your page 500 times, you will rank highly for a search on “Porsche,” regardless of whether your page actually contains useful information about cars. This led to an arms race: SEO spammers would generate “doorway pages” loaded with hundreds of repetitions of popular keywords, often hidden in white text on a white background. The result was a degraded user experience. Users would click on what appeared to be a top result, only to land on an ad-filled page with no real content.

Search engines tried to fight back with heuristics, such as penalizing pages with abnormally high keyword density or checking meta tags. But these were easily bypassed. The problem was fundamental: content alone could not distinguish quality from spam.

Meanwhile, a different idea was brewing. Academics studying the structure of scientific citations had long recognized that a paper’s influence could be measured by how many other papers cited it. But even better was a recursive measure: a paper is important if it is cited by other important papers. This is the foundation of citation analysis, pioneered by Garfield’s Science Citation Index in the 1960s. Brin and Page, who were both involved in Stanford’s digital library project, saw an analogy: hyperlinks on the web were like citations. A page that receives many links is likely valuable. But a page linked from a highly authoritative page (like Yahoo’s homepage or a university’s site) should count for more than a link from an obscure personal page.

The challenge was to formalize this intuition into a computable algorithm that could handle a graph with billions of nodes. The result was PageRank.

2. The Web as a Directed Graph

The first step in understanding PageRank is to view the web as a directed graph:

• Nodes = web pages (URLs)
• Directed edges = hyperlinks from one page to another (outgoing links from the source, incoming links to the target)

Let the total number of pages be $N$. For page $i$, let $L(i)$ be the number of outbound links from $i$. In a simple “link-counting” scheme, the rank $r(i)$ of page $i$ would be the number of inbound links (i.e., its indegree). But that is easily gamed: a spammer can create thousands of pages all linking to a target page, inflating its indegree.

PageRank improves on this by making the rank recursive. Intuitively, if a page with high rank (many authoritative pages link to it) links to another page, that link carries more weight. Brin and Page defined the PageRank $r(i)$ of page $i$ as:

$$ r(i) = \sum_{j \text{ links to } i} \frac{r(j)}{L(j)} $$

In words: the rank of a page is the sum of the ranks of all pages that link to it, but each contributing rank is divided by the number of outgoing links on the source page. This ensures that a page’s influence is shared among all the pages it links to—so a page with many outbound links spreads its rank thinly, while a page with few outbound links concentrates its endorsement.

But this equation alone has a flaw. It defines a circular definition: $r(i)$ depends on $r(j)$, and $r(j)$ depends on $r(k)$, and so on. To solve it, we need to treat the entire set of ranks as a vector of unknowns. For all $N$ pages simultaneously, we can write:

$$ \mathbf{r} = \mathbf{M} \cdot \mathbf{r} $$

where $\mathbf{M}$ is an $N \times N$ matrix defined as:

$$ M_{ij} = \begin{cases} \frac{1}{L(j)} & \text{if page } j \text{ links to page } i \ 0 & \text{otherwise} \end{cases} $$

This is an eigenvalue equation: $\mathbf{r}$ is an eigenvector of $\mathbf{M}$ with eigenvalue 1. In linear algebra, such an equation typically has a unique solution (up to scaling) if the matrix satisfies certain properties. But here we uncover the first major nuance: for many web graphs, $\mathbf{M}$ is not a “nice” matrix. It can have columns summing to zero (if a page has no outbound links, known as a “dangling node”), and it may not be stochastic (columns must sum to 1 for the eigenvector to have a probabilistic interpretation). Moreover, the web graph is not necessarily strongly connected—you cannot navigate from every page to every other page by following links. This means the eigenvector might not be unique, or might be zero for many pages.

Brin and Page solved these issues with two crucial modifications: the damping factor and teleportation.

3. The Random Surfer Model

To make the mathematics well-behaved and to capture user behavior, Brin and Page introduced the random surfer model. Imagine a user who starts at a random web page. At each step, with probability $d$ (the damping factor, typically 0.85), the user clicks a random link on the current page—choosing uniformly among its outbound links. With probability $1-d$, the user gets bored and “teleports” to a completely random page (or, in the original formulation, to a random page chosen uniformly from all pages). If the current page has no outbound links (a dangling node), the user always teleports.

From a Markov chain perspective, this defines a transition matrix $\mathbf{P}$:

$$ P_{ij} = \begin{cases} \frac{d}{L(j)} + \frac{1-d}{N} & \text{if page } j \text{ links to page } i \ \frac{1-d}{N} & \text{if page } j \text{ does not link to page } i \text{ (but has outgoing links)} \ \frac{1}{N} & \text{if page } j \text{ has no outgoing links (dangling node)} \end{cases} $$

For a page $j$ with outgoing links, the probability of going to $i$ is $d$ times the link probability plus the teleportation probability. For dangling nodes, we effectively treat them as teleporting with probability 1.

The matrix $\mathbf{P}$ is now a column-stochastic matrix: all columns sum to 1. It is also primitive (because the teleportation ensures that every page can reach every other page in one step with some positive probability), which implies that the Markov chain is irreducible and aperiodic. This guarantees that:

1. There is a unique stationary distribution $\boldsymbol{\pi}$ such that $\boldsymbol{\pi} = \mathbf{P} \boldsymbol{\pi}$.
2. The stationary distribution can be found by power iteration, which converges exponentially fast.
3. The stationary distribution is exactly the PageRank vector.

Thus, the PageRank of a page is the long-run probability that a random surfer lands on that page. This probabilistic interpretation is both intuitive and mathematically robust. A page with many high-quality inbound links will have a large probability of being visited.

4. Power Iteration: The Workhorse Algorithm

The direct eigenvector solution of $\boldsymbol{\pi} = \mathbf{P} \boldsymbol{\pi}$ would require solving a dense system of $N$ equations, which is impossible for $N$ in the billions. Instead, we use power iteration, an iterative method that only requires multiplying the current vector by the matrix $\mathbf{P}$ repeatedly.

The algorithm is deceptively simple:

1. Initialize the PageRank vector $\mathbf{r}^{(0)}$ to $[1/N, 1/N, \ldots, 1/N]$.
2. For each iteration $t$:
   • Compute $\mathbf{r}^{(t+1)} = \mathbf{P} \mathbf{r}^{(t)}$.
   • Optionally normalize to sum to 1.
3. Stop when $|\mathbf{r}^{(t+1)} - \mathbf{r}^{(t)}|_1 < \epsilon$ (e.g., $10^{-8}$).

Because $\mathbf{P}$ is a sparse matrix (most entries are zero, except for the teleportation term which is dense), we cannot form $\mathbf{P}$ explicitly. But we can compute the multiplication efficiently using the web graph structure. The update step can be written as:

For each page $i$:

$$ r_i^{(t+1)} = \frac{1-d}{N} + d \sum_{j: j \to i} \frac{r_j^{(t)}}{L(j)} $$

plus the handling of dangling nodes: for each dangling node $j$, its rank is redistributed to all pages via teleportation. An efficient implementation maintains an accumulator for the total rank mass of dangling nodes.

The elegance of power iteration is that it only requires the graph’s adjacency list (which pages link to which) and a few floating-point vectors. The convergence rate is governed by the second-largest eigenvalue of $\mathbf{P}$, which is bounded by $d$ in absolute value. With $d = 0.85$, the spectral gap is about $1 - d = 0.15$, so the error decreases by a factor of $d$ each iteration. Typically, 50–100 iterations suffice for convergence to a practical tolerance.

Example: A Tiny Web Graph

Consider a web of 4 pages:

• Page 1 links to Page 2 and Page 3.
• Page 2 links to Page 4.
• Page 3 links to Page 4.
• Page 4 links to Page 1.

No dangling nodes. Let $d = 0.85$, $N = 4$. Initialize $\mathbf{r}^{(0)} = [0.25, 0.25, 0.25, 0.25]$.

Iteration 1:

• $r_1 = (1-0.85)/4 + 0.85 * 0 = 0.0375$ (since no page links to 1? Wait, page 4 links to 1. We need to follow the formula correctly.)

Let’s recompute carefully using the full update:

For page i: $r_i^{(t+1)} = (1-d)/N + d * \sum_{j \in B_i} r_j^{(t)} / L(j)$, where $B_i$ are pages linking to i.

• $B_1 = {4}$, $L(4)=1$, so contribution = $r_4^{(0)} / 1 = 0.25$ → $r_1^{(1)} = 0.0375 + 0.85*0.25 = 0.0375 + 0.2125 = 0.25$.
• $B_2 = {1}$, $L(1)=2$, contribution = $0.25/2 = 0.125$ → $r_2^{(1)} = 0.0375 + 0.85*0.125 = 0.0375 + 0.10625 = 0.14375$.
• $B_3 = {1}$, same as above → $r_3^{(1)} = 0.14375$.
• $B_4 = {2,3}$, $L(2)=1$, $L(3)=1$, contributions = $0.25/1 + 0.25/1 = 0.5$ → $r_4^{(1)} = 0.0375 + 0.85*0.5 = 0.0375 + 0.425 = 0.4625$.

Sum = 0.25 + 0.14375 + 0.14375 + 0.4625 = 1.0.

After several iterations, the ranks converge. In this small example, the true PageRank (with d=0.85) is something like: Page 4 highest, Page 1 next, then Pages 2 and 3 equally. This matches intuition: Page 4 is the only page that receives links from two sources, and it gives its endorsement only to Page 1, making Page 1 strong as well.

5. The Damping Factor: Why It Exists and What It Does

The damping factor $d$ (typically 0.85) is often described as the probability that a user continues clicking links. But its real mathematical purpose is to ensure the Markov chain is ergodic—that is, every state can reach every other state. Without teleportation (i.e., $d=1$), the random surfer would be stuck in disconnected components or cycles. For example, consider a “spider trap”: a set of pages that link only to each other, with no links to the outside. With $d=1$, the surfer would never leave that trap, and the stationary distribution would assign zero probability to all pages outside the trap. The teleportation term breaks this by giving the surfer a chance to jump anywhere.

Moreover, the damping factor controls the trade-off between global importance and local context. A low $d$ (e.g., 0.5) makes teleportation more frequent, so PageRank becomes more uniform—all pages get a baseline rank from teleportation, and link structure matters less. A high $d$ (e.g., 0.99) makes the algorithm highly sensitive to link structure, but also slows convergence and amplifies the problem of spider traps.

Brin and Page chose $d = 0.85$ empirically because it gave good search results and reasonable convergence speed. The value 0.85 is now canonical, though in many applications it is tuned.

Effect on Convergence: The convergence rate of power iteration is proportional to $|\lambda_2|$, the second-largest eigenvalue. For the PageRank matrix, it can be shown that $|\lambda_2| \leq d$. So with $d=0.85$, each iteration reduces the error by at least a factor of 0.85. To achieve an error tolerance $\epsilon$, the number of iterations needed is roughly $\log(\epsilon) / \log(d)$. For $\epsilon = 10^{-8}$ and $d=0.85$, this is about $\log(10^{-8}) / \log(0.85) \approx (-18.42)/(-0.1625) \approx 113$ iterations. In practice, convergence is often faster due to the spectral gap being larger than $1-d$ for real web graphs.

6. Personalization: Making PageRank Topic-Sensitive

The standard PageRank computes a single global importance score for every page. But what if you want to bias the ranking toward a particular topic? For example, a user searching for “apple” might be interested in the fruit or the technology company. A generic PageRank would treat both types of pages equally.

This is where personalized PageRank (also called topic-sensitive PageRank) comes in. The key idea is to replace the uniform teleportation distribution with a personalization vector $\mathbf{v}$. Instead of teleporting to a random page uniformly, the surfer teleports to a page according to the distribution $\mathbf{v}$. For instance, $\mathbf{v}$ could be a vector that puts nonzero probability only on pages about “sports,” making the PageRank biased toward sports pages.

Mathematically, the transition matrix becomes:

$$ P_{ij} = \begin{cases} \frac{d}{L(j)} + (1-d) , v_i & \text{ if } j \text{ links to } i \ (1-d) , v_i & \text{ otherwise (including dangling nodes)} \end{cases} $$

The stationary distribution now solves:

$$ \boldsymbol{\pi} = d , \mathbf{H} \boldsymbol{\pi} + (1-d) , \mathbf{v} $$

where $\mathbf{H}$ is the hyperlink matrix ($H_{ij} = 1/L(j)$ if $j$ links to $i$, else 0). This is a linear system that can still be solved by power iteration.

Personalized PageRank has a wide range of applications:

• Search personalization: Google’s early versions allowed users to select a “context” (e.g., “computers” or “shopping”) that would bias results.
• Recommender systems: In social networks, you can compute a personalized PageRank from a user’s node to recommend new friends or content.
• Graph analysis: The Personalized PageRank (PPR) vector from a given seed node gives a measure of “proximity” or “influence” in a graph. It is used in graph algorithms like the PageRank-Nibble method for community detection.

Example: LDA and Topic-Sensitive PageRank

In the original paper by Haveliwala (2002), topic-sensitive PageRank was computed by precomputing 16 topic-specific PageRank vectors, one for each top-level category of the Open Directory Project (ODP). For a query, the user’s query would be classified into one of these topics, and the corresponding PageRank vector would be used to rank the results. This improved relevance significantly.

7. Dangling Nodes and Dead Ends

One of the practical headaches in implementing PageRank is dealing with dangling nodes—pages with no outgoing links. In the random surfer model, the surfer must teleport when hitting a dangling node. But to represent this in the matrix, we need to adjust the column for dangling nodes to be the uniform teleportation vector.

There are two common approaches:

1. Explicit dangling teleportation: During power iteration, maintain a variable dangling_sum = sum_{j: L(j)=0} r_j^{(t)}. When computing new ranks, we add dangling_sum * (1-d)/N to every page’s teleportation baseline, plus dangling_sum * d / N? Wait, careful.

Let’s derive the update equation including dangling nodes.

Let $D$ be the set of dangling nodes. For any page $i$, the rank update is:

$$ r_i^{(t+1)} = \frac{1-d}{N} + d \sum_{j \notin D, j \to i} \frac{r_j^{(t)}}{L(j)} + d \sum_{j \in D} r_j^{(t)} \cdot \frac{1}{N} $$

Because for a dangling node, the surfer teleports to a random page (including possibly itself) with probability 1. So the link structure contributes $d$ times the rank of dangling nodes, but that rank is distributed uniformly to all pages. So the last term is $d \cdot \frac{1}{N} \cdot \sum_{j \in D} r_j^{(t)}$.

Thus the full update is:

$$ r_i^{(t+1)} = \frac{1-d}{N} + d \cdot \frac{1}{N} \cdot \text{dangling_rank}^{(t)} + d \sum_{j \notin D, j \to i} \frac{r_j^{(t)}}{L(j)} $$

In many implementations, the term $\frac{1-d}{N} + d \cdot \frac{1}{N} \cdot \text{dangling_rank}^{(t)}$ is precomputed as a teleportation baseline $T^{(t)} = \frac{1-d}{N} + d \cdot \frac{\text{dangling_sum}^{(t)}}{N}$. Then we initialize all $r_i^{(t+1)}$ to $T^{(t)}$, iterate over non-dangling nodes to add contributions from their outgoing links.

2. Preprocessing: Remove dangling nodes iteratively (since they don’t contribute rank except through teleportation, their removal can be compensated). This reduces the graph size but complicates the final correction.

In practice, the explicit handling during power iteration is straightforward and efficient, especially when using frameworks like MapReduce or Spark.

8. Implementation in Code

Let’s implement PageRank for a small graph using Python and NetworkX to solidify understanding.

import networkx as nx
import numpy as np

def pagerank(graph, d=0.85, max_iter=100, tol=1e-8):
    N = graph.number_of_nodes()
    # Initialize rank vector
    rank = {node: 1.0 / N for node in graph.nodes}
    # Precompute out-degree
    out_deg = {node: graph.out_degree(node) for node in graph.nodes}

    for _ in range(max_iter):
        new_rank = {}
        # Teleportation baseline from dangling nodes
        dangling_rank_sum = sum(rank[node] for node, deg in out_deg.items() if deg == 0)
        teleport_base = (1 - d) / N + d * dangling_rank_sum / N

        # Initialize all nodes with teleport_base
        for node in graph.nodes:
            new_rank[node] = teleport_base

        # Distribute rank from non-dangling nodes
        for src in graph.nodes:
            if out_deg[src] > 0:
                contribution = d * rank[src] / out_deg[src]
                for tgt in graph.successors(src):
                    new_rank[tgt] += contribution

        # Check convergence
        diff = sum(abs(new_rank[node] - rank[node]) for node in graph.nodes)
        rank = new_rank
        if diff < tol:
            break

    return rank

# Example: tiny web
G = nx.DiGraph()
G.add_edges_from([(1,2), (1,3), (2,4), (3,4), (4,1)])
pr = pagerank(G)
for node, val in sorted(pr.items()):
    print(f"Page {node}: {val:.4f}")

Output (approximate):

Page 1: 0.2635
Page 2: 0.1337
Page 3: 0.1337
Page 4: 0.4691

Matches our earlier manual iteration.

For large-scale graphs, we would not use NetworkX; we would use sparse linear algebra libraries (e.g., scipy.sparse.linalg), or distribute computation with MapReduce. In MapReduce, each iteration involves a map phase that emits (target, source_rank/out_deg) and a reduce phase that sums contributions and adds teleportation.

9. Scalability: PageRank at Google’s Scale

When Google first launched, it indexed about 26 million pages. Today, the web has hundreds of billions of pages. Computing PageRank on such a scale requires careful distributed computing.

Blockwise PageRank: The adjacency matrix is partitioned across machines. Each iteration involves a shuffle of the current rank vector (distributed by page ID) and the graph structure. Modern implementations use Spark GraphX or TensorFlow for scalability.

Incremental PageRank: Recomputing PageRank from scratch each time pages are added or removed is expensive. Researchers have developed incremental algorithms that update the PageRank vector using perturbations, focusing only on the affected part of the graph. Google likely has proprietary methods to keep its index fresh.

Handling Link Spam: Even with PageRank, spammers tried to manipulate it by creating link farms—clusters of pages that mutually link to each other to boost their ranks. Google introduced TrustRank, which uses a seed set of trusted pages (e.g., high-authority .edu domains) and propagates trust through links, penalizing pages far from trusted seeds. Another variant, BadRank, detects spam via reverse propagation.

10. Beyond Search: PageRank in Modern Data Science

PageRank’s mathematical generality has made it a Swiss Army knife for network analysis. Here are some of the most impactful applications:

10.1 Social Network Analysis

• Twitter’s “Who to Follow”: Twitter used a variant of personalized PageRank to recommend users. Starting from the user’s existing network, they compute a PageRank biased toward their friends, and then suggest other users with high PageRank in that neighborhood.
• Influence measurement: In a social graph, a user’s PageRank measured on the follower graph (or retweet graph) is a proxy for their influence. Tools like Klout (original algorithm) used a PageRank-like score.

10.2 Citation Analysis and Academic Rankings

• Eigenfactor: This metric for ranking scientific journals is essentially a variant of PageRank applied to the net of journal citations. It replaces raw citation counts with a random walk measure of influence. The Article Influence Score is also derived from PageRank.
• Paper ranking: Algorithms like CiteRank use PageRank with temporal damping to give more weight to recent papers.

10.3 Sports Rankings

• NCAA March Madness: The PageRank College Basketball Ranking applies the algorithm to the directed graph of game outcomes (winning team links to losing team). Lower-ranked teams that beat high-ranked teams get a boost. This method often outperforms traditional win-loss ratios.
• Soccer: Similar approaches rank football teams by analyzing the network of match results across leagues.

10.4 Biological Networks

• Protein-protein interaction networks: Gene prioritization algorithms (e.g., Gaussian Random Walk) use a PageRank-like process to find novel disease genes starting from known ones.
• Metabolic networks: PageRank helps identify key enzymes or metabolites in regulatory pathways.

10.5 Recommendation Systems

• Item rank: In an e-commerce setting, build a graph where items are nodes and edges represent co-purchases or co-views. A personalized PageRank from a user’s purchased items can generate recommendations (Amazon probably uses something similar).
• Movie recommendations: The PageRank for Recommender Systems (which is essentially the same as the Alpha-Centrality measure) is used in some collaborative filtering pipelines.

10.6 Graph Neural Networks

Modern deep learning on graphs acknowledges PageRank’s role. The PageRank-GNN model incorporates a personalized PageRank matrix as a propagation operator, allowing information to spread beyond immediate neighbors. Graph Attention Networks use attention mechanisms that can be seen as learning the damping factor.

11. Limitations and Modern Alternatives

PageRank is not without its flaws. Some key criticisms:

• Content blindness: PageRank ignores the actual content of pages. Two pages with identical link structures but vastly different content would have the same rank. Google’s modern ranking uses hundreds of signals, including machine learning models (RankBrain, BERT, MUM).
• Manipulability: Link farms and reciprocal linking can still be exploited, though Google’s machine learning models detect many spam patterns.
• Staleness: Old but popular pages (like a slow-loading but well-linked site) retain high PageRank, while new, high-quality content may take time to gain links.
• Computational cost: Even with power iteration, it is expensive to compute on trillion-edge graphs. Alternatives like SALSA (Stochastic Approach for Link Structure Analysis) or HITS (Hyperlink-Induced Topic Search) offer lighter-weight options for certain tasks.

Modern search engines use a blend of semantic understanding, user behavior signals (click-through rates, dwell time), and link analysis. PageRank is one component among many, but it remains the conceptual starting point.

12. Conclusion: The Enduring Legacy of PageRank

PageRank transformed the web by solving a fundamental problem—ranking information in a chaotic, hyperlinked space. Its elegance lies in its simplicity: a few lines of math can capture the collective wisdom of the web’s link structure. But behind that simplicity lies a rich tapestry of linear algebra, probability, and graph theory that has proven astonishingly versatile.

Today, PageRank and its variants are deployed everywhere: from finding influential users on social media to ranking academic papers, from recommending movies to uncovering disease genes. The algorithm that once saved the web from spam now helps us navigate the vast networks of the digital age.

As you work with your own networked data—whether it’s a friend graph, a citation network, or a web of interconnected sensors—remember the lessons of PageRank. Think about the random surfer, the damping factor, and the power of recursion. Sometimes a simple idea, when executed with mathematical rigor, can change the world.

Further reading:

• Brin, S., & Page, L. (1998). The anatomy of a large-scale hypertextual web search engine.
• Haveliwala, T. (2002). Topic-sensitive PageRank.
• Gleich, D. F. (2015). PageRank beyond the Web. SIAM Review.
• Langville, A. N., & Meyer, C. D. (2006). Google’s PageRank and Beyond: The Science of Search Engine Rankings.