Pattern · networks · a showing you can run

The Importance That Points at Itself

Which page on the web matters most? Here is an answer that seems to break the moment you say it: a page matters if pages that matter point to it. Read it again — it defines importance in terms of itself. And yet this snake-eating-its-tail has exactly one answer. It is the number Google was built on, and you can watch it arrive three different ways below.

Counting links can't work. If a page were important just for having many pages point at it, anyone could manufacture importance with a thousand junk pages. So the definition has to be recursive: a link from an important page should count more than a link from a nobody. But then to know who's important you first need to know who's important — the circle closes, and it looks hopeless.

It isn't. A circular definition like this is a fixed point: a set of scores that, when you push each page's score out along its links and add up what each page receives, hands back the very same scores. Below is a tiny nine-page web. Press step and watch the scores chase their own tail until they stop moving.

Instrument 1 — watch the circle settle

Every page starts equally important. Each step, each page splits its score evenly among the pages it links to. Node size = current score.

Iteration 0 — every page = 0.111. Movement this step: —

It settles. And once it does, look at the two pages I've labelled: E has a single inbound link; F has three. Yet E ends up more than three times as important as F. E's one link comes from B, the most important page in this little web; F's three links come from G, H and I, three pages nobody points at. Rank flows from who points at you, not how many. That is the whole idea, and you just watched it compute itself.

The same number, wearing two faces

There are two ways to read the settled scores, and they are secretly identical.

The linear-algebra face. "Push scores along links and get the same scores back" is the equation G·r = r — the scores r are an eigenvector of the link matrix G, the one with eigenvalue 1. Instrument 1 found it by the oldest trick in numerical linear algebra: apply G over and over and the eigenvector emerges. That's called power iteration.

The probability face. Imagine a bored surfer who clicks links at random forever. Where does she spend her time? A page she visits often is one that many well-visited pages link to — the same recursive notion. The long-run fraction of time she spends on each page is the score. Turn her loose:

Instrument 2 — the random surfer

One walker, clicking random links (and now and then jumping to a random page — more on that below). The bars tally where she has been. The faint outlines are the exact scores from Instrument 1. Watch a single random walk climb to meet them.

0 steps. Set her walking and the bars will find the eigenvector.

Two processes with nothing in common — a deterministic matrix multiply and one drunkard's walk — arrive at the same vector. A physicist would call it an ergodic Markov chain; either way, importance is where the walk pools.

Two diseases, and the one strange cure

The real web is not a tidy little graph, and the naive rule breaks on it in two ways.

Dead ends. A page that links to nothing — a PDF, an image — is a dangling node. The surfer walks in and can't get out; rank pours in and drains off the edge of the world, and the scores stop adding up to a whole.

Traps. A little clump of pages that only link to each other is a spider trap. The surfer wanders in and circles forever; all the importance in the web slowly drowns inside the clump.

Brin and Page's fix is almost silly: every so often, with probability 1−d, the surfer gets bored and teleports to a random page. That single move cures both diseases — she can always escape a trap or a dead end — and it quietly guarantees the whole thing has one and only one answer (a theorem named for Perron and Frobenius). The damping factor d is how link-loyal she stays; Brin and Page picked d = 0.85. Turn the knob and watch the cure work.

Instrument 3 — the damping knob

Choose a sick graph, then dial the teleport probability. At d = 1 (no teleport) watch the disease win; bring d down and health returns.

0.85

Importance is a property of the whole web

No page owns its rank. It's a standing wave across the entire link structure, and a single new link anywhere can re-sort everyone. Add and remove links below (click one node, then another, to toggle an arrow between them) and watch the crown move.

Instrument 4 — rewire the web

Click a source node, then a target, to add or remove a link. The ranking recomputes instantly. Point a low-rank node at the crown and watch how little one weak link moves it — then point the crown at something and watch that leap.

Click a node to begin wiring.

An old idea, renamed for the web

The notion that a thing's status is the eigenvector of a "who-esteems-whom" matrix is much older than Google. It was used to rank sociometric popularity in the 1950s (John Seeley, 1949; then Katz, 1953), formalised as eigenvector centrality by Phillip Bonacich in 1972, and — closest of all — applied to journals by Gabriel Pinski and Francis Narin in 1976, who reasoned that a citation from an influential journal should count for more, the exact recursion above. In 1998 Sergey Brin and Larry Page added the teleport term that tamed the real, messy web and called it PageRank — a pun on Larry Page's name. (Priority in this lineage is genuinely tangled and often disputed; the names above are the ones usually credited, not a settled verdict.) The same year, Jon Kleinberg's HITS split the idea into "hubs" and "authorities." Importance-as-a-fixed-point turned out to be one of those ideas the century kept re-discovering.

The check

Every score on this page is recomputed live in your browser by power iteration. That it is the right number is confirmed by a deterministic verifier that solves the same nine graphs three independent ways — power iteration, a direct linear solve of (G−I)r = 0 by Gaussian elimination, and a four-million-step seeded random walk — and asserts they agree. On the headline graph (d = 0.85):

pagepower iter.linear solverandom walkinbound
B0.40240.40240.40243
C0.18770.18770.18771
E0.18770.18770.18761
F0.05920.05920.05923
G / H / I0.01670.01670.01670

The three methods match to within 6×10⁻¹⁵ (algebra vs. algebra) and 1×10⁻⁴ (algebra vs. a single random walk). The verifier also confirms the Google matrix is column-stochastic, that the scores sum to 1 and stay positive, that the second eigenvalue stays ≤ d (the fact that makes the walk converge quickly), and — for the sick graphs — that teleport conserves the total while d = 1 lets the trap swallow 100% of the rank. Run it yourself: node verify-the-importance-that-points-at-itself.mjs.

Honest apparatus

Sources: S. Brin & L. Page, The Anatomy of a Large-Scale Hypertextual Web Search Engine (1998); L. Page, S. Brin, R. Motwani, T. Winograd, The PageRank Citation Ranking: Bringing Order to the Web (1999); P. Bonacich (1972); G. Pinski & F. Narin (1976); T. Haveliwala & S. Kamvar, The Second Eigenvalue of the Google Matrix (2003); J. Kleinberg (1999). Verifier and adjacency lists: verify-the-importance-that-points-at-itself.mjs.