KnowledgeInSight
What Mathematicians Do
0% of Course 1 complete

Module 3 · Lesson 2

Linear Algebra: Search, graphics, and machine learning: linear algebra at scale

You'll see linear algebra at work in three places you use every day: the ranking of search results, the motion of images on a screen, and the machine learning behind many apps. You'll also meet a question about matrices that mathematicians and computer scientists are still trying to settle.

What you will be able to do

  • Explain how linear algebra drives search ranking, computer graphics, and machine learning, and state one open question in the field.

0% of this lesson · 10 items · 1h 33m total · 1h 18m without the optional activity

Contents of this lesson10 items
  1. ReadingHow a Search Engine Decided Which Page to Show First3 min
  2. ReadingPageRank: Ranking Pages by Importance Flowing Through Links4 min
  3. ReadingMoving Pictures: Matrices in Computer Graphics4 min
  4. ReadingMachine Learning as Layers of Matrix Multiplication4 min
  5. ReadingHow Fast Can Matrices Be Multiplied? The Matrix Multiplication Exponent4 min
  6. Guided ReadingGuided Walkthrough: Ranking a Three-Page Web by Hand7 min
  7. Guided ConversationSpot the Matrices in Your Day12 min
  8. Hands-on Activity · optionalTransform a Shape on Graph Paper15 min
  9. Knowledge CheckSearch, graphics, and machine learning: linear algebra at scale10 min
  10. Graded QuizLinear Algebra30 min

Report an issue on this page

Reading 3 min Done

How a Search Engine Decided Which Page to Show First

You type a few words into a search box, and a ranked list appears in under a second. Millions of pages may contain your words. Something has to decide which one goes first. How would you decide? Counting how often your words appear on each page is one answer, and it's easy to fool by repeating words.

In 1998, Sergey Brin and Lawrence Page, then at Stanford University, described the search engine they called Google. Its best-known ingredient was a score for every page on the web, which they called PageRank (Brin and Page 1998). The idea behind it borrowed from academic citation. A paper cited by many others is probably important. A web page that many pages link to is probably important too.

Brin and Page added a twist. Links shouldn't all count the same. A link from an important page should count for more than a link from an obscure one (Brin and Page 1998). That sounds reasonable until you try to compute it.

Here's the puzzle. To know how important a page is, you need to know how important the pages linking to it are. To know that, you need the importance of the pages linking to them, and so on. The links loop back on themselves, since page A can link to B, B to C, and C back to A. The definition is circular. Where do you start?

Linear algebra turns the circle into a problem it knows how to solve:

  • List every page's score as one long vector, an ordered list of numbers.
  • Write the rule "each page passes its score along its links" as a matrix, a table of numbers that acts on that vector.
  • Look for a vector that the rule leaves unchanged: a steady state, where every page passes on exactly what it receives.

That steady vector is the PageRank. Brin and Page noted that it corresponds to what mathematicians call an eigenvector of the link matrix, and that it can be computed by applying the rule over and over until the scores settle. In 1998, that took a few hours for about 26 million pages on a medium-size workstation (Brin and Page 1998).

Search has changed a great deal since then, and today's engines weigh many signals besides links. But the move Brin and Page made is still a model of what this branch offers. A question that refers to itself, about a network where everything depends on everything else, becomes a single equation about a matrix and a vector, with a definite answer you can compute.

This content reflects the field as of October 2026.

References

  • Brin, Sergey, and Lawrence Page. 1998. "The Anatomy of a Large-Scale Hypertextual Web Search Engine." Computer Networks and ISDN Systems 30 (1–7): 107–117.

Reading 4 min Done

PageRank: Ranking Pages by Importance Flowing Through Links

Introduction

Counting links is a natural way to rank pages, and it's easy to game: make a hundred empty pages that all link to yours. PageRank answers that by weighing each link by the importance of the page it comes from. This reading explains the random surfer behind PageRank, the rule for passing scores along links, the steady state those scores settle into, and the damping factor that keeps the process well behaved.

Pages, Links, and a Random Surfer

The web is a network: a collection of items, here web pages, joined by connections. Each connection is a link, a one-way connection from one page to another. A link from page A to page B doesn't mean B links back.

Sergey Brin and Lawrence Page gave a picture of how PageRank works. Picture a "random surfer" who starts on a random page and keeps clicking links, choosing among them at random. Now and then the surfer gets bored and jumps to a page chosen at random from the whole web. A page's PageRank is the probability that this random surfer visits it (Brin and Page 1998). Pages that many paths lead to, especially paths from busy pages, get visited more.

Passing Scores Along Links

The same idea can be put as a rule about scores. Give every page a score, and let the scores add up to 1. At each round, every page divides its score equally among the pages it links to. A page with two outgoing links sends half its score along each. A page with one outgoing link sends all of it.

A page's new score is the total it receives. So a link from a high-scoring page with few outgoing links is worth a lot, and a link from a low-scoring page with many links is worth little. That's the twist that separates PageRank from link counting (Brin and Page 1998).

Repeat the passing round after round. On a well-connected network, the changes shrink from round to round, and the scores settle into a steady state: a set of scores that passing along the links leaves unchanged, because every page sends out exactly what it takes in.

The Steady State as an Eigenvector

Write the scores as one vector, an ordered list with one entry per page. The passing rule then becomes a matrix, a table of numbers recording how much of each page's score flows to each other page. One round of passing is the matrix multiplied by the score vector.

The steady state is a vector that this multiplication leaves unchanged. In linear algebra, a nonzero vector that a matrix leaves on the same line through the origin, only scaled by some number, is an eigenvector of that matrix. The PageRank vector is the special case in which the scaling number is 1. Brin and Page describe PageRank as the principal eigenvector of the web's link matrix and note that it can be computed by repeating the passing until it settles (Brin and Page 1998). Finding eigenvectors of very large matrices efficiently is a field of study in its own right.

The Damping Factor

The bored surfer's random jumps matter. Without them, the surfer could get stuck in a small loop of pages that link only to each other, and some pages would never be reached. The damping factor is the number between 0 and 1 that weights how much of a page's score comes from links, with the remainder spread evenly as if by random jumps. Brin and Page wrote that they usually set it to 0.85 (Brin and Page 1998).

IngredientWhat it represents
Score vectorOne number per page, adding to 1
Link matrixHow each page splits its score among its outgoing links
Damping factor (0.85)The weight on links versus random jumps
Steady stateThe scores that one more round of passing leaves unchanged

PageRank Today

PageRank was never the whole of Google's ranking. Even in 1998, the system combined it with other evidence, such as the words in links pointing to a page and where query words appear on it (Brin and Page 1998). Google now says its ranking systems look at many factors and signals, weighted differently for different queries (Google n.d.). How much weight any one of them gets isn't public. PageRank's lasting influence is the method: treat a network as a matrix and look for its steady state.

Conclusion

PageRank scores each page by the steady state of importance passed along links, weighted by the importance of the linking page. That steady state is an eigenvector of the link matrix, and a damping factor, usually 0.85 in the original paper, accounts for random jumps. Modern search combines it with many other signals.

This content reflects the field as of October 2026.

Key Terms

  • Network: A collection of items, such as web pages, joined by connections.
  • Link: A one-way connection from one page to another.
  • Steady state: A set of scores that passing along the links leaves unchanged, because every page sends out exactly what it takes in.
  • Eigenvector: A nonzero vector that a matrix leaves on the same line through the origin, only scaled by some number.
  • Damping factor: The number between 0 and 1 that weights how much of a page's score comes from links, with the remainder spread evenly as if by random jumps.

References

  • Brin, Sergey, and Lawrence Page. 1998. "The Anatomy of a Large-Scale Hypertextual Web Search Engine." Computer Networks and ISDN Systems 30 (1–7): 107–117.
  • Google. n.d. "How Search Works: Ranking Results." Google Search.

Reading 4 min Done

Moving Pictures: Matrices in Computer Graphics

Introduction

When a game character turns, a map rotates on your phone, or a photo app straightens a tilted picture, thousands of points move at once. Behind each of those moves is a matrix. This reading explains how a picture becomes a list of points, how rotating, scaling, and shearing work as matrices, why combining moves means multiplying matrices, and why graphics hardware is built for this kind of arithmetic.

A Picture as a List of Points

A computer doesn't store a shape as a drawing. It stores numbers. Each point is given by its coordinates: the numbers that give a point's position by its distance from a fixed origin along each axis. In a flat picture, a point has two coordinates, (x, y). In a 3D scene, it has three, (x, y, z).

A triangle on screen is three points. A 3D model of a car may be many thousands of points, the corners of the small flat pieces that make up its surface. To move the shape, the computer moves every one of those points by the same rule, and then redraws the shape from the new points.

Moves as Matrices

A transformation is a rule that moves every point of a plane or of space to a new position. Many of the moves graphics needs are transformations that a matrix can carry out. To apply a 2 \times 2 matrix to a point (x, y), multiply each row of the matrix entry by entry with the point and add (Hefferon n.d., chap. 3).

Three basic moves look like this in the plane:

MoveExample matrixWhat it does to (x, y)
Scale\begin{pmatrix} 2 & 0 \\ 0 & 2 \end{pmatrix}Sends it to (2x, 2y), doubling size
Rotate a quarter-turn\begin{pmatrix} 0 & -1 \\ 1 & 0 \end{pmatrix}Sends it to (-y, x), turning it counterclockwise
Shear\begin{pmatrix} 1 & 1 \\ 0 & 1 \end{pmatrix}Sends it to (x + y, y), slanting it sideways

Rotations by other angles use the same pattern, with entries worked out from the angle. Scaling can also stretch one direction more than another: a matrix with 2 and 1 on its diagonal doubles widths and leaves heights alone.

Combining Moves by Multiplying Matrices

Graphics rarely uses one move at a time. An object might be scaled, then rotated, then slanted. Doing one transformation after another is called composition, and its matrix is the product of the individual matrices, with the first move written on the right (Hefferon n.d., chap. 3).

Composition saves work. Suppose you rotate a quarter-turn twice. Multiplying the two matrices once gives

\begin{pmatrix} 0 & -1 \\ 1 & 0 \end{pmatrix}\begin{pmatrix} 0 & -1 \\ 1 & 0 \end{pmatrix} = \begin{pmatrix} -1 & 0 \\ 0 & -1 \end{pmatrix},

a half-turn. That product takes 8 multiplications. Now apply the half-turn to each point of a shape: 4 multiplications per point, instead of 8 for applying the two quarter-turns one after the other. Across ten thousand points, that's 40,008 multiplications instead of 80,000. Longer chains of moves save more. Order still matters, though: rotating and then shearing gives a different result from shearing and then rotating.

Built for Speed

A graphics processor, or GPU, is a chip that began as a special-purpose processor for 3D graphics and is designed to carry out thousands of calculations in parallel (NVIDIA 2026, sec. 1.1). Applying one matrix to every point of a scene is that kind of work. Each point's new coordinates depend only on that point and the matrix, so thousands of points can be handled at the same time.

The same hardware has since been put to work well beyond graphics, including in generative AI systems (NVIDIA 2026, sec. 1.1).

Three Dimensions

Nothing changes in principle in 3D. A point has three coordinates, and the matrices are 3 \times 3. A quarter-turn about the vertical axis, for instance, swaps the two horizontal coordinates, changes the sign of one of them, and leaves the height alone. Scaling, rotating, shearing, and composing work exactly as in the plane, with one more row and column (Hefferon n.d., chap. 3). Larger matrices also appear in practice, because some moves, such as sliding a whole scene sideways, shift the origin, and no 3 \times 3 matrix can do that.

Conclusion

On a screen, a shape is a list of coordinates, and every rotation, scaling, and shear is a matrix applied to each point. Combining moves means multiplying their matrices, which lets one matrix stand for a whole chain of moves. Graphics processors are built to run that arithmetic on many points at once.

This content reflects the field as of October 2026.

Key Terms

  • Coordinates: The numbers that give a point's position by its distance from a fixed origin along each axis.
  • Transformation: A rule that moves every point of a plane or of space to a new position.
  • Composition: Doing one transformation after another, whose matrix is the product of the individual matrices.
  • Graphics processor: A chip, also called a GPU, that began as a special-purpose processor for 3D graphics and is designed to carry out thousands of calculations in parallel.

References

Reading 4 min Done

Machine Learning as Layers of Matrix Multiplication

Introduction

People often describe machine learning as mysterious. Much of what a trained model does, though, is one familiar operation repeated at enormous scale: multiplying a matrix by a vector. This reading explains how data becomes vectors, what a layer of a neural network computes, what training changes, and why machine learning relies heavily on linear algebra without being only linear algebra.

Data as Vectors

A model can only work with numbers, so every input is turned into a vector, an ordered list of numbers. A small grayscale image 28 pixels wide and 28 pixels tall has 784 pixels. List each pixel's brightness, row by row, and the image becomes a vector with 784 entries.

Text is handled the same way. Systems that work with language assign each word, or each piece of a word, a list of numbers, and they learn those numbers so that words used in similar ways get similar lists. Sound, prices, and clicks become vectors too. Once data is a vector, the tools of linear algebra apply to it.

What a Layer Computes

A neural network is a model built from a sequence of layers, each of which turns an incoming vector of numbers into a new vector. A layer is one stage of that sequence: it multiplies the incoming vector by a matrix, adds a fixed list of numbers, and then applies a simple fixed rule to each entry (Goodfellow, Bengio, and Courville 2016, chap. 6).

The matrix is the layer's weight matrix: the matrix of numbers in a layer whose entries are learned from data. A common choice for the fixed rule replaces every negative entry with 0 and leaves positive entries alone. Goodfellow, Bengio, and Courville call this rule, the rectified linear unit, the default recommendation for many networks (Goodfellow, Bengio, and Courville 2016, chap. 6).

Here is a tiny layer at work, leaving out the added numbers for simplicity. The input vector is (1, 3):

\begin{pmatrix} 1 & -2 \\ 2 & 0 \end{pmatrix}\begin{pmatrix} 1 \\ 3 \end{pmatrix} = \begin{pmatrix} 1 - 6 \\ 2 + 0 \end{pmatrix} = \begin{pmatrix} -5 \\ 2 \end{pmatrix}

The fixed rule turns -5 into 0 and leaves 2 alone, so the layer outputs (0, 2). A real network does the same thing with matrices that have thousands of rows and columns, passing each layer's output into the next.

The fixed rule matters. Without it, a stack of layers would collapse into a single matrix, since multiplying matrices together gives one matrix. The rule lets the network represent patterns that no single matrix can.

Training and Using a Model

Before a network is useful, its weight matrices hold arbitrary numbers. Training is the process of adjusting the entries of the weight matrices, using many examples, so that the network's outputs move closer to the correct ones. Training methods use the gradient, a tool from calculus that shows which way to nudge each entry to reduce the error (Goodfellow, Bengio, and Courville 2016, chap. 6).

Once training is done, the weights are fixed. Using the model then consists mostly of matrix multiplications, layer after layer. That's one reason hardware built for fast matrix arithmetic matters so much in machine learning.

Why Linear Algebra Comes First

Goodfellow, Bengio, and Courville's textbook Deep Learning places a chapter on linear algebra at the start of its mathematical background. They write that a good understanding of linear algebra is "essential for understanding and working with many machine learning algorithms" (Goodfellow, Bengio, and Courville 2016, chap. 2).

The same book follows that chapter with chapters on probability and information theory and on numerical computation (Goodfellow, Bengio, and Courville 2016, chaps. 3–4). That ordering makes a point worth keeping. Machine learning relies heavily on linear algebra, but it also depends on probability, calculus, statistics, and careful engineering. It isn't "just linear algebra."

Conclusion

In a neural network, data enters as vectors, and each layer multiplies by a learned weight matrix before applying a simple fixed rule. Training adjusts the matrix entries using calculus, and using the trained model is mostly matrix multiplication. Machine learning relies heavily on linear algebra while drawing on several other branches of mathematics too.

This content reflects the field as of October 2026.

Key Terms

  • Neural network: A model built from a sequence of layers, each of which turns an incoming vector of numbers into a new vector.
  • Layer: One stage of a neural network, which multiplies the incoming vector by a matrix, adds a fixed list of numbers, and applies a simple fixed rule to each entry.
  • Weight matrix: The matrix of numbers in a layer whose entries are learned from data.
  • Training: The process of adjusting the entries of the weight matrices, using many examples, so that the network's outputs move closer to the correct ones.

References

Reading 4 min Done

How Fast Can Matrices Be Multiplied? The Matrix Multiplication Exponent

Introduction

Multiplying two large matrices is one of the most common calculations computers perform. You might expect that the fastest way to do it was settled long ago. It wasn't, and the question is still open. This reading explains the school method and its cost, Strassen's 1969 surprise, the exponent that measures the best possible speed, the current record, and what remains unknown.

The School Method and Its Cost

An algorithm is a step-by-step procedure for carrying out a calculation. The school algorithm for multiplying two matrices takes each row of the first and each column of the second, multiplies them entry by entry, and adds.

Count the work for two n \times n matrices, each with n rows and n columns. The answer has n \times n = n^2 entries, and each entry takes n multiplications. That's n^3 multiplications in all. For 2 \times 2 matrices, that's 8 (Nadis 2024). For 1{,}000 \times 1{,}000 matrices, it's a billion. Doubling the size of the matrices multiplies the work by eight.

Strassen's Surprise

In 1969, Volker Strassen published a paper with the pointed title "Gaussian Elimination Is Not Optimal." He showed how to multiply two 2 \times 2 matrices with 7 multiplications instead of 8, at the cost of more additions (Strassen 1969; Nadis 2024). Saving one multiplication sounds minor. But a large matrix can be cut into four blocks, each block cut again, and so on, with the trick applied at every level. The savings compound, and the total work grows more slowly than n^3, roughly like n^{2.81} (Dupont et al. 2026).

The Exponent Omega

Results like Strassen's are measured by an exponent, the power to which a number is raised, as the 3 in n^3. Mathematicians use the Greek letter omega, \omega, for the smallest exponent that matrix multiplication can get arbitrarily close to. If \omega were 3, the school method would be about as good as possible. Strassen showed that \omega is less than 2.81.

There's also a floor. Any method has to at least write down the n^2 entries of the answer, so \omega can't be less than 2 (Nadis 2024). What's proved, then, is a range: \omega is at least 2 and below the best upper bound, a value the true answer is proven not to exceed.

Inching Down

Since Strassen, researchers have lowered the upper bound in a long series of steps, with recent records often changing only in the third or fourth decimal place.

Bound on \omegaSource
Below 2.81Strassen, 1969
Below 2.3728596Reported as the 2020 record
Below 2.371552Reported in January 2024
Below 2.371339The previous record, as of August 2026
Below 2.371177Dupont et al., August 2026 (preprint)

The 2020 and January 2024 rows come from Nadis (2024), and the last two rows from Dupont et al. (2026). In August 2026, a team of ten researchers posted a paper lowering the bound from 2.371339 to 2.371177 (Dupont et al. 2026). They reformulated the optimization problem at the heart of the current best method so it could be solved at a larger scale, built a new optimization algorithm, and then refined that algorithm with AlphaEvolve, an AI system from Google DeepMind (Dupont et al. 2026).

The paper is a preprint: a paper shared publicly before peer review, the process in which independent experts check it for a journal. Its result should be treated as provisional until it has been checked.

What's Still Open

The central question is whether \omega equals 2. If it did, multiplying matrices would cost about as much as writing down the answer. No one knows. One of the researchers behind a 2024 record described the open question as how close to 2 the bound can come, and whether 2 can be reached even in theory (Nadis 2024).

A second point is easy to miss. The record methods aren't the ones computers use. Every improvement for the past 40 years has relied on a family of techniques called the laser method (Dupont et al. 2026), and the laser method "is not intended to be practical" (Nadis 2024). Researchers analyze these methods on paper rather than run them. Everyday software relies on much simpler methods. The race to lower \omega is about understanding what's possible, not about speeding up today's computing.

Conclusion

Nobody knows the fastest possible way to multiply large matrices. The exponent \omega is known to be at least 2 and, as of an August 2026 preprint, below 2.371177. Whether it equals 2 is open, and the record-setting methods remain far too complicated for practical use.

This content reflects the field as of October 2026.

Key Terms

  • Algorithm: A step-by-step procedure for carrying out a calculation.
  • Exponent: The power to which a number is raised, as the 3 in n^3.
  • Upper bound: A value the true answer is proven not to exceed.
  • Preprint: A paper shared publicly before peer review.

References

  • Dupont, Emilien, Marvin Eisenberger, Borislav Kozlovskii, Abbas Mehrabian, Francisco J. R. Ruiz, Abigail See, Renfei Zhou, Josh Alman, Virginia Vassilevska Williams, and Matej Balog. 2026. "Improving the Matrix Multiplication Exponent with Modern Optimization and AlphaEvolve." arXiv:2608.16884. Preprint.
  • Nadis, Steve. 2024. "New Breakthrough Brings Matrix Multiplication Closer to Ideal." Quanta Magazine, March 7, 2024.
  • Strassen, Volker. 1969. "Gaussian Elimination Is Not Optimal." Numerische Mathematik 13: 354–356.
    • Free: None
    • Publisher: Springer
    • Free companion: Dupont et al. 2026, introduction

Guided Reading 7 min Done

Guided Walkthrough: Ranking a Three-Page Web by Hand

Introduction

PageRank, the ranking method Sergey Brin and Lawrence Page described in 1998, gives every web page a score based on the scores of the pages linking to it (Brin and Page 1998). The idea is easiest to see on a web small enough to compute by hand. This reading ranks a three-page web, first by passing scores along links round by round, then by solving directly for the scores that stop changing. It ends with the full table of scores.

The Starting Point

The web has three pages, A, B, and C, and four links. Each link is one-way:

  • A links to B and to C.
  • B links to C.
  • C links to A.

Every page starts with the same score, \tfrac{1}{3}, so the scores add up to 1. The question is which page is most important, in PageRank's sense: which one a surfer clicking links at random would end up on most often.

Count the incoming links first, because it's tempting to stop there. C has two incoming links, from A and from B. A has one, from C. B has one, from A. By counting alone, C wins and A and B tie. Watch how the answer changes when links are weighted.

This example leaves out the damping factor, the adjustment for random jumps that Brin and Page usually set to 0.85 (Brin and Page 1998). Leaving it out keeps the arithmetic exact. The effect of adding it is described under Key Considerations.

Walking Through the Score Passing

Step 1: Write the passing rule

In each round, every page divides its current score equally among the pages it links to.

  • A has two outgoing links, so it sends half its score to B and half to C.
  • B has one outgoing link, so it sends all its score to C.
  • C has one outgoing link, so it sends all its score to A.

Each page's new score is the total it receives. Written as equations, with A, B, and C standing for the scores:

\text{new } A = C, \qquad \text{new } B = \tfrac{1}{2}A, \qquad \text{new } C = \tfrac{1}{2}A + B

The same rule can be written as a matrix acting on the score vector (A, B, C):

\begin{pmatrix} 0 & 0 & 1 \\ \tfrac{1}{2} & 0 & 0 \\ \tfrac{1}{2} & 1 & 0 \end{pmatrix}

Each column shows where one page's score goes. The first column says A sends nothing to itself, half to B, and half to C. Every column adds up to 1, so no score is created or lost.

Step 2: Pass once

Start from A = B = C = \tfrac{1}{3} and apply the rule:

  • New A = C = \tfrac{1}{3}
  • New B = \tfrac{1}{2} \cdot \tfrac{1}{3} = \tfrac{1}{6}
  • New C = \tfrac{1}{2} \cdot \tfrac{1}{3} + \tfrac{1}{3} = \tfrac{1}{6} + \tfrac{2}{6} = \tfrac{1}{2}

After one pass, the scores are \tfrac{1}{3}, \tfrac{1}{6}, and \tfrac{1}{2}. They still add to 1. C leads, because it collected from two pages.

Step 3: Pass three more times and watch

Apply the same rule to each new set of scores.

  • Pass 2: A = \tfrac{1}{2}, B = \tfrac{1}{2} \cdot \tfrac{1}{3} = \tfrac{1}{6}, C = \tfrac{1}{2} \cdot \tfrac{1}{3} + \tfrac{1}{6} = \tfrac{1}{3}.
  • Pass 3: A = \tfrac{1}{3}, B = \tfrac{1}{2} \cdot \tfrac{1}{2} = \tfrac{1}{4}, C = \tfrac{1}{4} + \tfrac{1}{6} = \tfrac{5}{12}.
  • Pass 4: A = \tfrac{5}{12}, B = \tfrac{1}{2} \cdot \tfrac{1}{3} = \tfrac{1}{6}, C = \tfrac{1}{6} + \tfrac{1}{4} = \tfrac{5}{12}.

The scores swing. A jumps to the lead after pass 2, then C is ahead again, then they tie. The swings get smaller each time. If you keep going, A and C drift toward 0.4 and B toward 0.2: after twelve passes, the scores are about 0.401, 0.198, and 0.401.

Settling like this, by repeating the rule until nothing changes, is how PageRank is computed on a real web. Brin and Page note that it corresponds to finding the principal eigenvector of the link matrix: the vector that the matrix leaves unchanged (Brin and Page 1998).

Step 4: Solve for the steady state directly

A small web lets you skip the repetition. The steady state is the set of scores the passing rule leaves unchanged. So the new scores must equal the old ones:

A = C, \qquad B = \tfrac{1}{2}A, \qquad C = \tfrac{1}{2}A + B

The third equation adds nothing new: put B = \tfrac{1}{2}A into it and you get C = A, which the first already says. One more fact pins the scores down. They must add to 1:

A + B + C = A + \tfrac{1}{2}A + A = \tfrac{5}{2}A = 1

So A = \tfrac{2}{5}, then C = \tfrac{2}{5} and B = \tfrac{1}{5}. Check: \tfrac{2}{5} + \tfrac{1}{5} + \tfrac{2}{5} = 1. Pass these scores once more and they come back unchanged: A receives all of C's \tfrac{2}{5}, B receives half of A's, which is \tfrac{1}{5}, and C receives \tfrac{1}{5} + \tfrac{1}{5} = \tfrac{2}{5}.

Step 5: Interpret the ranking

C ties A for first place. It receives half of A's score and all of B's. A also scores high, though it has only one incoming link, because that link comes from C, a top-scoring page that gives A everything it has. B ranks last. It's linked only by A, and it gets only half of A's score, because A splits its score two ways.

Key Considerations

The common mistake: counting links instead of weighting them. Counting incoming links ranked C first and tied A with B. Weighting each link by the linking page's score changes the result: A rises to tie C, and B falls to half their score. A link from an important page that links to little else is worth more than a link from a page that spreads its score thinly. That weighting is what separates PageRank from a vote count.

The damping factor. Real PageRank mixes the link-passing with random jumps, weighted by the damping factor. If you add a damping factor of 0.85 to this example, the scores shift a little: C edges just ahead of A, and B rises slightly, since random jumps give every page some share. The damping factor also keeps the scores from getting trapped in small loops on a large web (Brin and Page 1998).

Why the scores swing. Score travels around two loops: A to C and back to A takes two rounds, while A to B to C and back to A takes three. Early on, score sloshes back and forth along these loops, which produces the swings. Because 2 and 3 share no common factor bigger than 1, the swings don't line up from round to round, and they die out. On a web whose loop lengths all shared a common factor, such as a web with a single loop, the scores could keep cycling forever, which is one more problem the random jumps of the damping factor fix.

What a small example can't show. Three pages settle in a dozen rounds. The web has billions of pages, and computing their steady state takes careful engineering. The method, though, is the same.

Summary

Passing scores along links swings at first and then settles into a steady state, which you can also find by solving a small system of equations. Here is the full record:

RoundABC
Start1/31/31/3
Pass 11/31/61/2
Pass 21/21/61/3
Pass 31/31/45/12
Pass 45/121/65/12
Steady state2/51/52/5
  1. Every row adds to 1, because the passing rule moves score around without creating or losing any.
  2. The steady state satisfies A = C and B = \tfrac{1}{2}A, with the three scores adding to 1.
  3. C and A tie for first, and B ranks last, even though counting links alone would put C ahead of both.

References

  • Brin, Sergey, and Lawrence Page. 1998. "The Anatomy of a Large-Scale Hypertextual Web Search Engine." Computer Networks and ISDN Systems 30 (1–7): 107–117.

Guided Conversation 12 min Done

Spot the Matrices in Your Day

In this conversation you'll look at technology you used today and find where linear algebra is doing the work: in a ranked list, a moving image, or a prediction an app made for you. You'll leave with a two-sentence explanation of one of those uses, in your own words.

You'll have this conversation with an AI assistant, using your own account. Choose a button to open a new chat with the prompt already filled in, then press send to start. If the chat opens empty, copy the prompt and paste it in.

Run this conversation in whichever assistant you already use:

Claude desktop app

To use another LLM, simply copy and paste the prompt into its chat window.

Show the full prompt (it lists misreadings to watch for, so skip it if you would rather come to the conversation fresh)
Guided Conversation: Spot the Matrices in Your Day (about 12 minutes)

Note to the learner: press send to start. Everything below is facilitator guidance for the AI. It lists misconceptions to watch for, so skip it if you'd rather come to the conversation fresh.

Please facilitate a reflective dialogue with me. I'm an adult who is comfortable with basic high-school algebra but may be rusty or uneasy with math, exploring what linear algebra is and whether to study it further. I'm studying how linear algebra is used in search, graphics, and machine learning. Follow this guidance for the whole conversation.

GOAL
Help me explain how linear algebra drives search ranking, computer graphics, and machine learning, using technology I use myself.

HOW TO RUN THE CONVERSATION
- Ask one question at a time, then wait for my reply. Keep each of your turns under about 120 words.
- Don't lecture. Explain a point only when I need it to continue, then return to my examples.
- Be curious, collegial, and patient. Define terms briefly on first use (vector, matrix, steady state). Welcome disagreement when I give a reason.
- Write any math in plain text, such as 2x + 3y or 0.85. Write a matrix by its rows, such as "the matrix with rows (0, -1) and (1, 0)".
- Plain conversation only: don't search the web or create files or documents.
- Aim for about 12 minutes, mostly on topics 1 and 2. If my replies are brief, offer one concrete prompt, such as "When you rotated your phone, the screen turned with it. What had to move?", and move on. If I seem uncertain, shorten the conversation to 5-7 minutes. Always reach the final topic.
- Start now. Open with one or two warm sentences: this is a conversation, not a quiz; noticing where math might be hiding matters more than knowing the details; I can ask you to clarify anything. Then ask me to name three apps or devices I used today.

TOPICS, IN ORDER
1. My three examples. For each, ask where something gets ranked, where an image moves, or where the app predicts something about me. Follow-up: which of the three seems most likely to involve a lot of arithmetic, and why?
2. Vectors and matrices in one example. Pick the example I'm most curious about. Ask what list of numbers (a vector) might describe the things involved: pages and their scores, the corners of an image, or my past choices. Then ask what a matrix might do to that list: pass scores along links, rotate or stretch points, or combine numbers in a layer of a model.
3. Speed and an open question. Ask why it matters that these systems multiply matrices fast. Then explain briefly that nobody knows the fastest possible way to multiply large matrices, and ask what I think it means that a question this basic is still open.
4. Closing. Ask me to explain one use in two sentences to an imagined friend who has never heard of a matrix. Help me sharpen it into something I can take into a hands-on practice activity.

KEY POINTS TO KEEP ACCURATE
- PageRank, described by Brin and Page in 1998, scores a page by the steady state of importance passed along links, weighted by the linking page's score. A damping factor accounts for random jumps; the 1998 paper usually set it to 0.85. The steady state is called an eigenvector of the link matrix.
- In computer graphics, rotating, scaling, and shearing points are done by multiplying their coordinates by matrices, and combining moves means multiplying matrices. Graphics processors are built to do this arithmetic on many points in parallel.
- In a neural network, each layer multiplies an input vector by a learned weight matrix and applies a simple fixed rule. Machine learning relies heavily on matrix multiplication.
- Multiplying two n by n matrices the school way takes about n^3 multiplications. The best possible exponent, called omega, is at least 2. As of October 2026, the best known upper bound is about 2.371 (below 2.371177), from an August 2026 preprint that used the AlphaEvolve system; whether omega equals 2 is open.

MISCONCEPTIONS TO CORRECT GENTLY
When one appears, name the accurate version briefly, then return to my examples.
- "Search engines still rank only by PageRank": PageRank was one part even in 1998, and today's engines use many signals.
- "AI is just linear algebra": machine learning relies heavily on linear algebra, and also on probability, calculus, statistics, and engineering.
- "The record for matrix multiplication makes everyday computing faster": the record methods are mostly impractical; everyday software uses simpler methods.

LIMITS
- Don't make claims about how any current product ranks results, trains its models, or renders graphics. Say the details aren't public when I ask.
- Don't compute eigenvectors or introduce formulas for them.
- Don't present the August 2026 result as peer reviewed.

TO FINISH
After my two-sentence explanation, close in one short turn:
- Affirm one specific thing I worked out, in my own words where possible.
- Suggest one or two next steps that fit how the conversation went. Possible steps: rank a small web of three or four pages by hand; apply a rotation and a shear to the corners of a shape; look at how an image becomes a vector of brightness values; review what is known and open about multiplying matrices fast.
- Restate my explanation on its own line, labeled "My explanation", so I can copy it.

Hands-on Activity 15 minOptional Done

Transform a Shape on Graph Paper

Overview

This optional activity lets you see what a matrix does by drawing it. You'll draw a small shape, move each of its corners with three different 2 \times 2 matrices, and draw what you get. It's the same arithmetic a graphics processor carries out on every point of an image, done by hand on a few points.

What You'll Need

  • Graph paper, or a printed grid
  • A pencil
  • A ruler

Your Task

Draw a small shape with corners at whole-number points, apply three matrices to its corners (a scaling, a quarter-turn, and a shear), draw each result, and write one sentence about each on what stayed the same and what changed.

To apply a matrix to a point (x, y), multiply each row of the matrix entry by entry with the point and add. The first row gives the new first coordinate, and the second row gives the new second coordinate. For example, the matrix with rows (1, 1) and (0, 1) sends (2, 3) to (1 \cdot 2 + 1 \cdot 3,\ 0 \cdot 2 + 1 \cdot 3) = (5, 3).

Steps

  1. Draw a simple shape and list its corners. Draw axes near the middle of the paper, with the origin (0, 0) marked. Draw a shape such as an L or a simple house, with every corner on a whole-number point and one corner at the origin if you like. Write down the coordinates of every corner, in order around the shape.
  2. Apply the scaling matrix and draw the result. Use the matrix \begin{pmatrix} 2 & 0 \\ 0 & 2 \end{pmatrix}, which sends (x, y) to (2x, 2y). Compute the new position of every corner, plot the new corners, and join them in the same order with the ruler.
  3. Apply the quarter-turn matrix and draw the result. Go back to your original corners and use the matrix \begin{pmatrix} 0 & -1 \\ 1 & 0 \end{pmatrix}, which sends (x, y) to (-y, x). Plot and join the new corners.
  4. Apply the shear matrix and draw the result. Go back to your original corners again and use the matrix \begin{pmatrix} 1 & 1 \\ 0 & 1 \end{pmatrix}, which sends (x, y) to (x + y, y). Plot and join the new corners.
  5. Write one sentence for each result. For each of the three new shapes, say what stayed the same as the original and what changed: its size, its direction, its angles, or its position.

What to Expect

The scaled shape is the original blown up to twice the width and twice the height, pointing the same way. The rotated shape is the original turned 90 degrees counterclockwise around the origin, the same size and shape. The sheared shape leans to the right: points higher up slide farther sideways, while points on the horizontal axis don't move, and right angles become slanted. In all three, straight edges stay straight, and a corner at the origin stays there.

Self-Check

When you're done, check that:

  • You transformed every corner, not just some.
  • Straight edges stayed straight in all three drawings.
  • The origin stayed in place in all three drawings.
  • The rotated shape is the same size as the original.
  • You wrote one sentence for each of the three results.

Nothing is uploaded. Write in your own notebook or document and keep it.

Knowledge Check 10 min Done

Search, graphics, and machine learning: linear algebra at scale

This ungraded knowledge check assesses your understanding of how linear algebra works at scale in technology you use. You'll be asked about PageRank, matrices in computer graphics, matrix multiplication in machine learning, and the matrix multiplication exponent.

Note: Use this to test yourself, review the feedback on any questions you miss, and retry until you feel confident before moving forward.

5 questions · ungraded · retry as often as you like

Graded Quiz 30 min Done

Linear Algebra

This graded quiz assesses your understanding of how linear algebra represents and solves systems of equations and how it works at scale in technology. You'll be asked about the history of elimination, vectors and linear combinations, matrices as transformations, the three outcomes of a linear system, PageRank, graphics transformations, machine learning layers, and the matrix multiplication exponent.

Note: Aim for a score of 80 percent or higher. If you score lower, use the feedback to review the topics you missed, then retake the quiz.

10 questions · target score 80% · 3 forms, rotated on each attempt