Adrià Garriga-Alonso

How to multiply polynomials in Θ(n log n) time

2026-10-13T22:41:12Z

The information in this post is taken from the sources listed in the Sources section at the end of it. If you don’t care about understanding the algorithm and need an implementation now, skip to the Implementation subsection.

Why?

Why would anyone want to multiply polynomials in $\Theta (n \log n)$ instead of the naive $\Theta(n^2)$ time? Sometimes happens. I did when I got confronted with the UVa Online Judge 12879 Golf Bot problem. I knew I needed a discrete convolution, but then I got stuck because $200 000^2$ is way too high and the only way to calculate it I knew was quadratic.

If you mean “Why would you write this post?”, well, talking about an algorithm I recently learned to solve a problem is proving to be an easy way to kick-start my blog.

Gathering building blocks

So how do we do it? We are going to have to talk a bit about the representation of polynomials in computer memory first. (Haha get it?)

Coefficient representation

As far as I know, there are two useful ways of doing that. The first, and most obvious, is to store the coefficients of every term in an array, vector, list, you name it. Let $A(x)$ be a polynomial of degree-bound $n$ :

A(x) = a_0 + a_1x + a_2x^2 + ... + a_{n-1}x^{n-1}

The “degree-bound $n$ ” is any $n$ strictly greater than the degree of the polynomial. We will always be talking about the smallest $n$ that fulfills this condition, that is, the degree plus one. The polynomial’s coefficients are $a_0, a_1, ..., a_{n-1}$ , and that’s what we store. For example, the polynomial:

3 + 2x^2 + 5x^3

Has the representation $3, 0, 2, 5$ . Notice there is no “ $x = x^1$ ” term, so the coefficient in position 1 is 0.

There is a straightforward way to evaluate the polynomial’s value for any $x_0$ in $\Theta(n)$ . We can elevate $x_0$ to the required value for each coefficient, multiply for every coefficient and add all that up. I like Horner’s rule though:

A(x_0) = a_0 + x_0(a_1 + x_0(... + x_0(a_n)))

Multiplying two polynomials of degree-bound $n$ and $m$ takes $\Theta(nm)$ time. One has to multiply every coefficient of one with every coefficient of the other. The resulting polynomial will be of degree-bound $m + n - 1$ . You’ve probably done this by hand countless times when trying to solve or simplify equations.

Point-value representation

To represent a polynomial $A(x)$ of degree-bound $n$ , we store $n-1$ point-value pairs:

(x_0, A(x_0)), (x_1, A(x_1)), \; ..., \; (x_n, A(x_n))

The algorithm to multiply polynomials in point-value representation is as follows. Let $A(x)$ and $B(x)$ be polynomials of degree-bound $n$ and $m$ respectively. They are both of degree-bound $n+m-1$ too. (Proof: $n+m-1 \geq n$ and $n+m-1 \geq m$ if $n, m \geq 1$ , which is the case with degree-bounds). Represent $A(x)$ and $B(x)$ as vectors of $n+m-1$ point-value pairs, with the same points. Then multiply the values of each corresponding point-value pair.

Intuitively, because the value at each point of the result is the multiplication of the values at each point of the two polynomials we are multiplying, that is exactly what we do!

Let us do an example. We multiply:

A(x) = 3x^2 + x

B(x) = -5x^3 + 2x^2 - x + 4

Their minimum degree-bounds are, respectively, $3$ and $4$ . Thus, we need $3+4-1=6$ point-value pairs for each:

$x_0$	$A(x_0)$	$B(x_0)$	$C(x_0) = A(x_0) \cdot B(x_0)$
0	$A(0) = 0$	$B(0) = 4$	$C(0) = 0$
1	$A(1) = 4$	$B(1) = 3$	$C(1) = 12$
2	$A(2) = 14$	$B(2) = -6$	$C(2) = -84$
3	$A(3) = 30$	$B(3) = -35$	$C(3) = -1050$
4	$A(4) = 52$	$B(4) = -96$	$C(4) = -4992$
5	$A(5) = 80$	$B(5) = -201$	$C(5) = -16080$

$C(x)$ on the right is the result of $A(x) \cdot B(x)$ , and its point-value representation is $(0, 0), (1, 12), (2, -84), (3, -1050), (4, -4992), (5, -16080)$ .

“That’s it!”, you may think. “Problem solved, and it’s $\Theta(n)$ !”. Not so fast.

To convert from coefficient to point-value representation we need to evaluate $A(x)$ at $n$ points. The time needed to do that with what we know, Horner’s rule, is of course $\Theta(n^2)$ .

Cutting time with FFT (Fast Fourier Transform)

FFT is a very important algorithm in signal analysis. It computes the DFT (Discrete Fourier Transform) of a signal in $\Theta(n \log n)$ time. The DFT maps the time domain to the frequency domain, that is; from a sequence of samples it extracts which frequencies are present and in which intensity. It is used, for example, to measure the pitch of an sound input, in applications such as Learn by Music Technology Group or one of those singing games.

But we are more interested in the mathematical definition of the DFT.

X_k = \sum_{n=0}^{N-1} x_n \cdot e^{-j2\pi k n / N}

Let’s break this definition down and rearrange it to understand why it is relevant to us. We also change the variables $A_k = X_k$ , $a = x$ , $i = n$ , to reflect the correspondences with the naming conventions we used for polynomials.

A_k = \sum_{i=0}^{N-1} a_i \cdot \left( e^{-j2\pi k/N} \right)^i

For each $k$ , the DFT is the sum of all the input coefficients $a_i$ multiplied by $\left(x_k\right)^i = \left( e^{-j2\pi k/N} \right)^i$ . By doing this, we are effectively evaluating the polynomial expressed by the coefficients $a_i$ in all the points $x_k$ .

We can calculate the coefficient representation from a point-value representation with points $\left(x_k\right)^i = \left( e^{-j2\pi k/N} \right)^i$ by using the inverse DFT. Turns out this is quite the simple reversal:

a_i = \frac{1}{N} \sum_{k=0}^{N-1} A_k \cdot \left( e^{j2\pi k/N} \right)^i

You can look up the proof elsewhere.

The Algorithm

The building blocks of our algorithm are complete.

Input: $A_v$ and $B_v$ , coefficient representation of polynomials $A(x)$ and $B(x)$ respectively.

Output: $C_v$ , coefficient representation of polynomial $C(x) = A(x) \cdot B(x)$ .

Let $\left| A_v \right|$ be the length of $A_v$ , that is, the lowest degree-bound of $A(x)$ . Let $\left| B_v \right|$ be the length of $B_v$ . Let $\left| C_v \right| = \left| A_v \right| + \left| B_v \right| - 1$ be the lowest degree-bound of the result $C_v$ .
Let $n = \min_i 2^i$ subject to $2^i \geq \left| C_v \right|$ . That is, the smallest power of two that is greater or equal than $\left| C_v \right|$ . To compute it: iterate from $i=0$ , increasing by $1$ every time, until $2^i \geq \left| C_v \right|$ .
Let $A_v$ be the vector representing $A(x)$ padded with zeroes so that its total length is $n$ . Let $B_v$ be the vector representing $B(x)$ padded with zeroes so that its total length is $n$ .
Let $A_v' = FFT(A_v)$ and $B_v' = FFT(B_v)$ .
Let $C_v' = A_v' \cdot B_v'$ , the dot product of $A_v'$ and $B_v'$ . That is, multiplying every element of $A_v'$ with the element in the same position $B_v'$ , and assigning that to the same position in $C_v'$ .
Let $C_v = FFT^{-1}(C_v')$ . $C_v$ is $C(x)$ in coefficient representation. Terminate.

Analysis

We show, as formally as I can, why this algorithm is $\Theta(n \log n)$ . You may skip this section if it’s obvious to you, or try and figuring out yourself before reading it.

is $\Theta(1)$ if we know the length of the inputs. It may be up to $O(n)$ if we have to measure them, for example by iterating until we find a sentinel at the end.
is $\Theta(\log n)$ . Proof: $n = 2^i$ , $i = \log n$ .
is $\Theta(n)$ . We have to add $\left( n - \left| A_v \right| \right) + \left( n - \left| B_v \right| \right)$ , which a linear function of $n$ .
is $\Theta (n \log n)$ , because the FFT is too.
is $\Theta(n)$ , because we iterate once for each elemnt of $C_v'$ .
is $\Theta (n \log n)$ . The inverse FFT is like a regular FFT, with then dividing every element by $N$ . Thus, it’s $\Theta(n \log n + n) = \Theta(n \log n)$

Thus, the whole algorithm is:

\Theta(n + \log n + n + n \log n + n + n \log n) = \Theta(n \log n)

Isn’t it easy to simplify expressions in asymptotic notation?

Implementation

If you are writing an application that needs an FFT of any form, I suggest using a library. Numerous smart people have spent their time making said library bug-free and performant, and you can greatly profit from their effort. I only know of one FFT library, the Fastest Fourier Transform in the West, but there are probably others that are just as fast, or bindings for this one to other languages.

However, if you must embed the routine in your program, for instance in a programming contest, you have to “implement it yourself”. The algorithm is not very complicated, but time spent debugging it is time wasted. I suggest copying Stanford University ACM Team’s Notebook. I endorse copying many things from there, actually. At the very least, their implementation is clear enough that you can base yours off of it.

Assuming we have included Stanford’s implementation earlier in the C++ file:

// Assume we have at most 2^18 = 262144 coefficients
const int MAX_LEN = 262144 * 2;

// For those of you who don't want to read the Stanford source:
// "cpx" represents a complex number.
// FFT(input, output, internal=1, size of input, direction)
// Direction is 1 for FFT, -1 for inverse FFT

cpx A[MAX_LEN], B[MAX_LEN], C[MAX_LEN];
int A_len, B_len, C_len;

/* set the appropriate coefficients in the inputs A and B's real-valued part,
 * and their length in A_len and B_len.
 */

// find the immediately greatest power of two
for(C_len = 1; !(C_len > A_len + B_len - 1); C_len *= 2);

// This is assumed in the 12879 Golf Bot problem
assert(C_len < MAX_LEN);

// pad A and B with zeroes
memset(A + A_len, 0, (C_len - A_len) * sizeof(cpx));
memset(B + B_len, 0, (C_len - B_len) * sizeof(cpx));

// fill C with A's point-value
FFT(A, C, 1, C_len, 1);

// fill A with B's point-value
FFT(B, A, 1, C_len, 1);

// Multiply the polynomials in point-value
for(int i=0; i<C_len; i++)
    A[i] = A[i] * C[i];

// Convert back to coefficient representation
FFT(C, A, 1, C_len, -1);
for(int i=0; i<C_len; i++)
    C[i].a /= C_len;

// now C[i].a (the real-valued parts) contain the result

Solving 12879 Golf Bot

To solve 12879 Golf Bot, what we need to do is: have a vector that is 1 at the distances which the golf bot can shoot and 0 at the distances which it cannot. We need to add that vector to a vector of zeroes itself starting from every 1 it itself has. This is the operation called discrete convolution, and it’s the equivalent of multiplying two polynomials in coefficient form. So you do that, but you don’t need to divide by C_len at the end, because we only need to know if a given position is $>0$ .

It’s a very quick explanation, but the problem isn’t the focus of this post :)

Final thoughts

Hope this post was enjoyable, easy to read, and useful.

Don’t use this in production over the simple naive quadratic algorithm if you do not handle big enough inputs. How big is big enough? Measure.

Sources

This pdf from Portland State University’s Algorithm Design and Analysis class. Contains more information about operations, properties and algorithms related to polynomials.

Wikipedia’s definition of the DFT and inverse DFT.

A Stack Exchange answer with an example of this algorithm. Helped me understand this a lot.

Contest writeup: Murcia qualifiers 2015

2026-10-13T22:41:12Z

This is a writeup of the problems my team solved in the Murcia contest, which we were participating in as preparation for SWERC. Those people are way better than us, but we will not give up!

The problems are given the UVa numbers that will soon appear.

12962 Average Reuse Distance

At first read this problem seems easier than it really is. But it’s not a hard problem, it’s actually a fairly straightforward simulation.

The Problem

Given a sequence of memory accesses to different addresses (represented by the characters 'a' to 'z'), give its Average Reuse Distance. The Reuse Distance of a memory access to address $x$ is the number of other addresses accessed since the last access of $x$ . First accesses to any given position do not count towards the average.

The solution

The core of this problem was keeping track of the different memory accesses since the last access of each address, and then counting them in an efficient way. We solved this by storing which addresses had been accessed as a bitmask. You can very easily reset the bitmask by setting it to 0, and count the number of ones in the bitmask with GCC and Clang’s __builtin_popcount.

The algorithm is the following:

Total sum = 0
For each character $c$ of input read:
If $c$ hasn’t been encountered before, mark it as encountered.
Otherwise, add the number of ones in the bitmask to the total sum and add 1 to the number to divide the sum by.
For all characters a-z, set their mask’s <this number>th bit to 1.
Reset $c$ ’s bitmask to 0

In the end, you output the mean from the sum you gathered, or NaN if the divider is 0.

Here is the code.

12963 Astragalus Nitidiflorus

We technically did not solve this problem within the contest, but came very close. The night after the contest, when sitting down to look at the problems again, we found what was wrong in 5 minutes.

The problem

You are given a grid with characters on it. You have to find the horizontal instances of the word “GARBANCILLOS” and the vertical instances of the word “ASTRAGALUS”. Whenever they intersect is a possible location, but each word instance can only be used once. Determine the number of locations.

The grid is at most 150x150.

The solution

You need to do two things here. First, find the strings’ locations and where they intersect. Then, compute the maximum matching of vertical and horizontal strings.

To find the strings’ location in $\Theta(n^2)$ , we used a rolling hash. The longest of the strings is 12 characters, $12 \cdot 5 = 60 < 64$ , so a hash with 5 bits per character can be used without collisions. We discard all the characters outside of the range from 'A' to 'Z', and give them the mask 0x1f.

First we look at the character matrix horizontally, and store the position of the found “GARBANCILLOS” in a sorted vector, one for each row. We also store its future index in the graph of intersecting strings in an std::map. Then we look at the character matrix vertically, and when we find a match we binary search for the possible horizontal matches in each row. If one is find, the edge is added to the maximum-matching matrix.

Finally, we output the maximum matching of the matrix we built.

Here is the code.

12965 Angry Bids

Nice pun.

The problem

You have some product’s producers, and some consumers. Each of them has an ideal price. The consumers will get angry if the price is higher than their ideal price. The producers will get angry if the price is lower than their ideal price. Find the price such that the number of angry people is minimal, and how many angry people there are.

The prices range from $0$ to $10^9$ . There are up to $10^4$ producers and $10^4$ consumers.

The solution

It’s amazing how many problems are solved this way. If we check every possible price in order (unfeasible), we will have more consumers progressively getting angry, and more producers progressively getting happy.

Thus, we assign producers the number 1, and consumers the number -1. We create pairs of <price, assigned number> for each of them, and sort those pairs. We increase the price of the consumers in the pairs by 1 because that is when the consumer will start being unhappy. We sort this sequence and then iterate over it, keeping a sum of all the assigned numbers we have found. The point where this sum is maximum is the optimal point.

Here is the code

12967 Spray Graphs

However, the name of the problem in the contest is “Spray Graphs”. And the page’s title is “Spary graphs”. Haha.

The problem

You are given the graph structure in the picture. In this picture, each “level” of the graph has an assigned letter. We can build more levels by branching every node in right angles as shown in the figure.

Spray graph of size 4. Problem by Facultad de Informática, Universidad de Murcia.

Given a number of levels, compute how many paths there are to get to any of the leaves. The levels range from 1 to 30.

The solution

Notice two things about this graph. First, it has four-way symmetry around the central node, so we can just compute the paths of a quarter of the graph and then multiply by 4, we can get the answer.

Radial symmetry in spray graphs

It is also very much like a grid, each node’s paths come only from the nodes to the left and up.

We can then build a grid with the number of paths for each node. The grid’s top row will be counting $1, 2, 3, ...$ since the nodes in the top row of the separated portions in the previous picture have that number of paths. The first column will be all $1$ s, since there is only one straight path down there. Then, we can compute each node’s number of paths as the paths coming from the left plus the paths coming from the top.

Here’s the grid for a size 5 graph:

1	2	3
1	$2+1=3$	$3+3=6$
1	$3+1=4$
1

Finally, just add up the leaves (the last diagonal), and multiply by 4. Bingo!

Embarbussaments

2026-10-13T22:41:12Z

Attention! For those of you who do not understand Catalan, there is an English translation below!

La meva germana i jo vam començar a fer la primera d’aquestes frases. No em semblen especialment difícils de dir, però això potser és perquè els he escrit jo. Vaig gaudir del procés i el resultat, i per això vaig escriure les altres tres. Aquí van! Prova de dir-les!

La mangosta Agustina i la llagosta Gustau, vaguistes, gasten en gustos a l’Agost.

Manca de xancles, xanques blanques i tanques de branques fan que tanquin encara la banca.

La rara barana que el pare i la mare preparen fa cara la vara on para la Sara i s’encara al sarau i gatzara.

Fa poc que moc el soc del lloc al foc i toco un roc. Jo sóc un cóc de mocs que xoca al boc.

Estan creades de forma que tenen una seqüència concreta de sons repetida moltes vegades. Excepte la primera, també alternen síl·labes tòniques i àtones, per donar ritme. Noteu també la diferència entre "o"s obertes [IPA ɔ] i tancades [o] en l’última.

Traduir aquesta entrada m’ha fet adonar-me que, sí, les llengües romàniques i l’anglès tenen gairebé la mateixa gramàtica. Que fort.

In English

Title: Tongue Twisters

My sister and I started composing the first of these sentences. They don’t seem hard to say to me, but that may be because I wrote them. I enjoyed the process and results, so I wrote the other three. Here they go! Try to read them out loud!

La mangosta Agustina i la llagosta Gustau, vaguistes, gasten en gustos a l’Agost. (Augustine (female) the mongoose and Gustaf the lobster, strikers, spend on pleasures during August.)

Manca de xancles, xanques blanques i tanques de branques fan que tanquin encara la banca. (Lack of flipflops, white stilts and fences made of branches make the bank still be closing.)

La rara barana que el pare i la mare preparen fa cara la vara on para la Sara i s’encara al sarau i gatzara. (The rare railing that father and mother prepare makes expensive the rod where Sara stops and turns to face the party and rejoicing.)

Fa poc que moc el soc del lloc al foc i toco un roc. Jo sóc un cóc de mocs que xoca al boc. (For a short time, I have been moving the stump from the place to the fire and touching a rock. I am a snot pie that shocks the buck.)

They are created to have a certain sequence of sounds repeated many times. Except for the first one, they also alternate stressed and unstressed syllables, to give rhythm. Note also the difference between open [IPA ɔ] and closed [o] "o"s in the last one.

Translating this post made me realize that yes, latin-derived languages and English have almost the same grammar. Damn.

An Alternative Population Ethics

2026-10-13T22:41:12Z

Let’s say we believe consequentialism and utilitarianism. Roughly, we hold that the morality of an action depends only on its consequences, and the consequences we care about are only changes in the amount of happiness in the world. We wish to increase the amount of happiness, as much as possible. We are rational, so every time we act we will choose the action that we expect to lead to the outcome with maximum happiness. (This is essentially what effective altruists try to do.)

Now, the world we live in has many human (and maybe nonhuman) individuals with moral weight. To make our life easier, let’s say we can quantify the happiness (also called welfare or utility) of an individual. That utility is a real number, positive if the individual’s life is worth living, zero if it is neutral, and negative if the individual is better off not existing. Let’s also assume we know, for each action, the happiness outcome of each individual.^[1]

If none of the actions change identity or number of the agents that exist, choosing is easy: the best action is that which maximises the sum^[2] of happiness.

Population axiologies

However, what if the actions can also change the number of individuals in the population? That happens in many cases: deciding whether to have a child personally, designing the structure of money incentives and tax changes to encourage/discourage children, giving away or selling contraception… For these cases, we need to be able to compare populations with a different number of individuals.

Thus we get to the problem of population axiology: give an “at least good as” complete, transitive ordering of all possible populations, solely based on people’s utility.

Borrowing notation from Arrhenius (2000). Let $A$ , $B$ , $C$ , $B \cup C$ , … be populations, or sets of individuals. We may indicate the population size: $A_n$ is a population of $n$ individuals: $a_1, a_2, \dots, a_n$ . The numerical representation of $a_i$ ’s welfare is given by the function $v(a_i)$ . Since it is transitive, we can safely represent the ordering with a “ $\geq$ ” symbol. The problem can then be written: for any two populations $A$ and $B$ , is $A_n \geq B_m$ or $A_n \leq B_m$ ?

Let’s take care of the case where $n \neq m$ . We could, again, just care about the sum of utility, so $A \geq B$ if and only if $\sum_{a_i \in A} v(a_i) \geq \sum_{b_i \in B} v(b_j)$ . But this opens us up to the Repugnant Conclusion (Parfit, 1984) (video explanation by Julia Galef): a population of $10^{100}$ people with welfare 1 each would be much better than a population of 10 billion with welfare $10^{80}$ each.

And this, to most people, is unpalatable. However, some philosophers think we should accept the Repugnant Conclusion. Tännsjö (2002) argues that when we picture a “life barely worth living” we picture precarious hygienic conditions, lack of food, and depending on the weather for your food crop. But actually it is our first-world materially comfortable lives that are barely worth living. Also, we do not care about the obvious goodness of the enormous increase in population because of our scope insensitivity bias.

Still, the Repugnant Conclusion created the problem of population axiology and led to the following findings.

Impossibility theorems

Many alternatives to summing utility have been proposed: counting average utility. Having each additional life have less weight, thus having any sum of bounded utilities converge. Having a “critical level” which marks a minimum for well-being that is above a life barely worth living. See introduction by Greaves (2016).

Arrhenius showed, in 2011, the impossibility of a satisfactory population ethics. After his already discouraging results in 2000, his findings challenged population ethics even as moral framework. Both papers present really compelling conditions that a population axiology ought to satisfy, represent them formally, and mathematically prove them impossible to hold in the same axiology. I will describe the conditions of the 2011 paper:

The ordering is complete (no two populations are incomparable) and transitive ( $A \geq B$ and $B \geq C$ implies $A \geq C$ ).
Given two populations of the same size and with all the individuals having the same welfare, the one with higher sum^[3] of welfare is not worse.
Let $A_n$ be a population of $n-1$ people with very high welfare and one person with welfare $w$ . Let $B_n$ be a population of $n-1$ people with very low positive welfare and one person with welfare $w+1$ . Then, for any population $X$ , there exists an $n$ sufficiently large such that $A \cup X \geq B \cup X$ . Roughly, if you change enough people from low positive to really high welfare in a population, that compensates for one individual with a slightly lower welfare.
Let $B_n$ be a population of $n$ individuals with welfare $w$ . Let $A_n$ be a population of an individual with welfare $w+1$ , and $n-1$ individuals with welfare $c$ , $c < w$ . Given a population $X$ with the welfare of everyone being between $c$ and $w$ , there exists a sufficiently large $n$ such that $B_n \cup X \geq A_n \cup X$ . Roughly, making a lot of people better off at the expense of very little of one person’s welfare, such that these people mentioned are all equally happy, does not make things worse.
There is at least one negative welfare level $w<0$ , such that adding any number of people with positive welfare $v>0$ is not worse than adding a person with welfare $w$ .
For any population $X$ , there exists a perfectly equal very-high-welfare population $A_n$ , and very-negative-welfare population $B_m$ , such that $X \cup A_n \geq X \cup B_m \cup C_l$ , for all, arbitrarily large, values of $l$ . Population $C$ is composed of very low positive lives. This means avoidance of a Repugnant Conclusion on steroids: not only is there a vast number of barely-worth-living lives, but there also exist many lives that are much worse than not existing.

Reiterating: it is impossible to have all these properties in the same population axiology.

Side-stepping the issue: dropping the “axiology” requirement

Notice that the desirable properties of the “population axiology” can be framed as transitions. This is a very similar form to (one of) the intended use(s) for them, namely, deciding which is the most moral of any two actions with known^[4] outcomes. Let’s take that strong hint, and re-frame the choice not as deciding between any two populations, but between any two populations starting from the status quo.

I propose ascribing moral weight only to individuals who currently exist. When taking a decision, choose the outcome that maximises the sum^[5] of the utility of the people who are alive at that moment. This way of looking at population ethics is unfortunately not an axiology. An axiology would allow us to output a single number measuring the utility of the whole population, and using that as a drop-in replacement for single-agent utility in all the game theory (and game practice, also called Artificial Intelligence, AI) that we know. Instead, our criterion is only useful when an agent is taking a decision based on a model of the world and on future outcomes of their current action.

We can illustrate this more easily within the somewhat more restricted framework of AI as online search (Russell and Norvig, 2009, Section 4.5). In the following figure, we show a decision tree. At each node we face a decision, with as many branches as possible courses of action we can take. We are currently in the bottom-most node, the root, at time instant $t=0$ . At each time step, the individuals in our population have a positive or negative experience. At $t=3$ we have the expected return^[6] ^[7] for each chain of actions. We depict surrounded in green the utility of the individuals who are alive when taking the decision, and in purple the utility of those who start existing later. The dotted green-purple line marks the moment where, in the possible future of each path, at least one new individual exists.

Illustration of our decision process for populations.

The decision process can be viewed as an adversarial search (Russell and Norvig, 2009, Section 5) process. In this game we have two players, represented as blue and green edges in the picture. Blue plays in states where at least one new individual has been born, that is, above the dotted line. Green plays below. Green plays at the root node, which means the agent that is deciding is Green. Green cares about maximising the return of the people that exist in $t=0$ , that is, the return we depict surrounded in green. Blue wants to maximise the utility of all the people, that is the sum of the numbers surrounded in green and purple. The edge that is highlighted in the relevant player’s colour is the edge the player would choose if he were to play from that edge’s parent node. Notice that, in the right-most outcome, Blue never plays, since nobody is born.

In our example, we choose the bubble with (13, -4), because it is the one with the highest Green-utility out of the options Blue leaves available.

This system behaves as if we decided to increase the utility of the existing people now, knowing that, when new people are born, we will care about them too. It resembles our current society’s treatment of babies: you can use contraception to prevent a baby’s existence all you want, but once you have a baby, if you mistreat it or kill it you shall face severe consequences. Barring contraception accidents, children exist because their parents thought they would be happier raising them.^[8]

Does this avoid the Repugnant Conclusion?

Yes. We start from a population of $n$ individuals with a level of well-being. The Repugnant Conclusion entails sacrificing these individuals utility to create many more individuals with low positive welfare, so at some point we have to allow a birth. If we do not have a choice over this it is useless to apply any moral theory. Thus we can decide, at some point in the middle, to bring into existence an individual, or not to. We know that, if we bring into existence that individual, we will be morally forced to decrease the others’ well-being for it. Thus, we decide for the good of the existing beings, and do not bring into existence the individual.^[9]

This can fail when the decider lacks sufficient foresight, and incorrectly predicts that the new individual will not decrease the others’ well-being. But that is not a problem of our decision criterion, rather, of our prediction mechanism. Consider the following situation of an agent maximising its utility:

Insufficient prediction power causes bad decision.

The agent chooses the right-most node, because it thinks it will lead to 14 return. But, one time-step later than the agent has looked, it gets very low reward, thus very low return. This should be alleviated in some way, but that is not in the scope of this post.

So when the prediction mechanism works as intended, and the world does not take such drastic turns, the decision criterion avoids the Repugnant Conclusion.

Does this fail in any other way?

Yes. The criterion as-is needs at least one amendment. Currently, an agent deciding by this criterion will not hesitate to create arbitrarily many lives with negative utility, to increase the utility of the people who are alive just a little. One may think the commitment to a life when it exists would fix that, but that is not the case. If Green can restrict its decisions in some way, it can take all the necessary decisions before anyone is born, and thus completely prevent Blue from playing. In a real world example, Green becomes president, passes laws mandating the construction of inhuman but cheap factory farms, laws preventing anyone from messing with those farms, and then removes itself out of office before any farm is in operation, for example by committing a crime. Thus Green will become very sad when the farms start working, but its own purpose at the moment of decision will be fulfilled, namely, maximum utility for the beings who were alive back then.

We could forbid the creation of any lives with negative welfare entirely. But that would outlaw really positive scenarios, such as one person working a shitty job and having nobody to talk to, in order for $10^{100}$ people to live lives with $10^{100}$ welfare. No, instead, we need to forbid bad trade-offs.^[10]

The solution is: when a purple life has negative welfare, it gets counted into the green utility. Thus, future net negative lives have the same weight as present net negative lives. This reflects the Asymmetry Intuition: we may be indifferent about making happy people, while we prefer making people happy, not making miserable people, and not making people miserable. (Benatar, 2008)

In practice, if we end up having an AI that needs to make this sort of decisions, I suspect this will lean towards just not creating any lives, and creating lives with negative welfare should be rare (what for? Humans are slow and inefficient at working, and they decrease utility when unhappy). If it’s an economist or politician, they can use this rule, but they wouldn’t do anything truly absurd; they are human.

Closing thoughts

Based on insights from AI and a few moral intuitions, I have created a decision criterion for a changing population, when considering possible futures. The criterion avoids the Repugnant Conclusion, behaves like a simple sum of utilities when population doesn’t change, mirrors our current accepted morals for treatment of nonexistent individuals, and doesn’t seem to have any glaring holes.

Of course, such holes may be found, if you do find one please comment, email me, or otherwise let me know.

References

(I recommend the Google Scholar Button browser add-on for comfortable fetching of papers, but I’ve included links for convenience here.)

[Blog] Armstrong, S. Integral versus differential ethics.

[PDF] Arrhenius, G., 2000, An Impossibility Theorem for Welfarist Axiologies. Economics and Philosophy, 16: 247–266.

[PDF] Arrhenius, G., 2011. The impossibility of a satisfactory population ethics. Descriptive and normative approaches to human behavior.

[Book] Benatar, D., 2008. Better never to have been: The harm of coming into existence. Page 32. Oxford University Press. Chicago

[PDF] Greaves, H., 2016. Population axiology.

[Book] Parfit, D., 1984. Reasons and persons. OUP Oxford.

[Book] Russell, S. and Norvig P., 2009. Artificial Intelligence: A Modern Approach. 3rd. Prentice Hall Press, Upper Saddle River, NJ, USA. ISBN: 0136042597, 9780136042594.

[PDF] Tännsjö, T., 2002. Why we ought to accept the repugnant conclusion. Utilitas, 14(3), pp.339-359.

I sometimes write “people” in this essay because it reads natural, but you may substitute for “individuals with moral weight” every time. Also, since we quantify utility as numeric, a moral weight can be really a numeric weight, to multiply that individual’s utility by. ↩︎
Or average, if you prefer, it makes no difference. Quick proof: Let $A$ be the set of possible actions, $U(i, a) : I \times A \mapsto \mathbb{R}$ is the function giving the utility, a real number, of individual $i$ when taking action $a$ . Given the set of individuals $I$ and actions $A$ , clearly $\forall a, a' \in A \, \sum_i U(i, a) \geq \sum_i U(i, a') \iff \frac{\sum_i U(i, a)}{|I|} \geq \frac{\sum_i U(i, a')}{|I|}$ since $|I|=|I|$ . ↩︎
Again, or average, see footnote 2. ↩︎
If you believe in expected value utility, you can extend that to population outcomes with probabilities. While I don’t know of any alternative to it, expected value utility has some problems, namely Pascal’s Mugging. ↩︎
See footnotes 2 and 3. Aren’t populations with the same number of individuals wonderful? ↩︎
This term is taken from the artificial intelligence literature, specifically from sequential decision processes, which is what are facing here. The idea is that, at each time step $i$ , the agent receives a numeric reward $r_i$ . The agent also has a discount rate $\gamma$ , $0 \leq \gamma \leq 1$ , which models how much the agent cares about receiving rewards sooner. The return at time $t$ , $R_t$ , is the sum of all discounted future rewards until then, that is: $R_t = r_0 + \gamma r_1 + \dots + \gamma^t r_t = \sum_{i=0}^t \gamma^i r_i$ . The path of actions that has the highest return at time $t$ , when the agent’s decisions end ( $t$ can be infinite too, if the decisions never end), is the path that the rational agent prefers. ↩︎
Why are we using returns and not utility over the whole lifetime now? We have gone down into the realm of making decisions while the population is changing, while individuals experience pain or pleasure and are born and die. It makes much more sense to think about populations and the pain or pleasure experienced during a time interval of each individual, rather than during their whole lifetime. This is the notion of returns, and thus our use of them, and why we will use the term somewhat interchangeably with “utility” around this passage. ↩︎
Be it because they enjoy the raising, because their child being happy makes them happy, or to make their own parents happy. But it all reflects back to the parents’ own projected well-being. ↩︎
This idea very much resembles that of Integral Ethics (Armstrong, 2014), which was inspiration for this post’s approach. ↩︎
Edit 20 November 2016: Thanks to /u/bayen for pointing out a problem with the previous rule. ↩︎

Remote development with Unison

2026-10-13T22:41:12Z

Use case

You have to run your program on a remote server. However your favourite editor with your favourite configuration isn’t available over SSH. Or its over-SSH mode is very slow (looking at you, TRAMP). Also, you’d like to work online sometimes.

Unison is like Dropbox but without an intermediary server.

Setting it up

First, you need to have two^[1] directories, one in your local machine and one in your remote machine, that will be synchronised. For example, /local/path/to/my/software in your local machine and /remote/path/software in your remote server. You must have SSH access to the server, which is for example at user@host.

Then you download and install Unison. Preferrably use your system’s package. You need two executables: unison and unison-fsmonitor. The second one is not always available with the unison package: it is not there, for example on Ubuntu or OS X. To install it:

Ubuntu: install the ocaml package to compile Unison from source. Then just run make. It might give an error, but with a little bit of luck you will have compiled the unison-fsmonitor executable before that. Copy it to your $PATH.
OS X: install UNOX

Now you have to set up a “profile” configuration file in your local machine. In $HOME/.unison/profile-name.prf, write something like:

root = /local/path/to/my/software
root = ssh://user@host//remote/path/software

ignore = Regex ^(.*/)*[^/]*\.[^/]*$
ignorenot = Regex ^(.*/)*[^/]*\.(py|txt|md|ipynb|bash|gitignore)$

This will synchronize all files ending in .py, .txt, .md… or having no “.” in their filename, between the two directories mentioned at the beginning. Read more about how the ignore and ignorenot rules work here and here.

Finally, in your local machine, run:

unison profile-name -repeat watch -times -logfile /var/log/unison.log

And the directories shall be synchronized.

Or more, but we will only set up two here. ↩︎

Policy gradients (part 1): what is it?

2026-10-13T22:41:12Z

I missed doing math. So I played with policy gradients, and I found a result that surprised me, but it turns out is equivalent to a generalized advantage estimator.

Policy gradients explainers are a perennial genre in machine learning, similar to ~~burrito~~ monad tutorials in the Haskell world. I’m excited to add my take to the literature.

Problem setting for RL

The policy gradients setting is as follows. You have a neural network that is acting in an environment. Every time-step it observes the current state and takes an action. Then the environment changes, and the neural network receives a corresponding reward. You want to optimize the trajectories coming out of this neural network so they get as much reward as possible. The neural network is a ‘policy’, which is a function of the current state that outputs a probability distribution over actions.

We’ll call the neural network weights θ, and the policy π_θ, which is a distribution over the next action a_{t+1} which depends on all the previous states x_{1:t}. In LLMs, the action is just a new token, so we’ll call it x_t just like the states. To optimize the trajectories, we want to take gradient steps in the direction of increasing reward.

The policy gradients theorem

The objective we want to maximize is the expectation over trajectories of length T (x_{1:T}), of the reward obtained in that trajectory. We express this objective as the gradient (∇_θ) of the expectation, as follows:

\text{Gradient of expected return} = \nabla_\theta \left(\mathbb{E}_{x_{1: T} \sim \pi_\theta} \left[ \sum_{t=1}^T r(x_{1:t}) \right] \right)

This is a weird gradient to take, because the value inside the expectation does not depend on our parameters θ by itself. Instead, it only acquires this dependency because we’re taking the average reward over trajectories, and we can change the distribution of trajectories by changing π_θ.

In other words, the objective only depends on θ through the expectation. We’d like to estimate the gradient by sampling trajectories, because computing the exact expectation is prohibitive. Usually we would remove the dependence on θ from the expectation distribution, using the reparameterization trick. We cannot do this because the distribution we’re sampling is discrete.^[1]

The policy gradients theorem rewrites the gradient of the expected sum of rewards, as an expectation over trajectories of things we can compute.

\text{Gradient of expected return} = \mathbb{E}_{x_{1: T} \sim \pi_\theta} \left[ \left(\sum_{t=1}^T r(x_{1:t}) \right) \nabla_\theta \log \pi_\theta(x_{1:T}) \right]

This is a much more convenient form, because we can just sample trajectories, compute the gradient of the states over the trajectory and the reward, and get an estimate of the gradient that we can follow.

The derivation uses two insights:

You can exchange gradient operators and expectations/integrals, most of the time.
By the chain rule, the gradient of log(f(x)) is 1/x * the gradient of f(x). Therefore the gradient of f(x) is f(x)*log(f(x)):

\nabla_x f(x) = f(x) \cdot \nabla_x \log \left( f(x) \right)

You might see the resemblance between this equation and the right-hand side of the previous one.

Deriving policy gradients

Now for the full derivation. We name the sum of rewards G(x[1:T]), for convenience, then the full derivation starts by expanding the expectation:

\nabla_\theta \mathbb{E}_{x_{1:T} \sim \pi_\theta} \left[ G(x_{1:T}) \right] = \nabla_\theta \int_{x_{1:T}} \pi_\theta\left( x_{1:T} \right) G(x_{1:T}) \textsf{d}x_{1:T}

then we exchange the integral and gradient operators

= \int_{x_{1:T}} \nabla_\theta \left( \pi_\theta\left( x_{1:T} \right) G(x_{1:T}) \right)\textsf{d}x_{1:T}

and use the identity above about grad(f)(x) = f(x) * grad(log f)(x):

= \int_{x_{1:T}} \pi_\theta(x_{1:T}) \nabla_\theta \log \pi_\theta\left( x_{1:T} \right) G(x_{1:T}) \textsf{d}x_{1:T}

and this is again an expectation over π_θ, so we can express it like that again. We get the identity back!

\nabla_\theta \mathbb{E}_{x_{1:T} \sim \pi_\theta} \left[ G(x_{1:T}) \right] = \mathbb{E}_{x_{1:T} \sim \pi_\theta} \left[ G(x_{1:T}) \nabla_\theta \log \pi_\theta\left( x_{1:T} \right) \right]

Then, in practice, we estimate this using samples from the policy. For each sample we compute G and the gradient of the log-probabilities of the actions actually taken, and average them.

Next time, we take a look at how to make this estimate have a lower variance.

Applying the reparameterization trick to discrete distributions can sort of be done using the Gumbel-Softmax trick. Now that I think of it, nobody has tried this for sparse autoencoders yet… ↩︎

Make your Statistics Sound with this One Cheap Trick

2026-10-13T22:41:12Z

If you don’t want to be fooled by randomness, and you don’t want to think too hard, you should be using the ✨bootstrap ✨.

Thank you for keeping our inferences sound, Black Swan Man. (credit: @black_swan_man on X)

Machine learning papers typically have bad statistical methods. The numbers don’t even have confidence ranges, or the plots don’t have error bars. For example, even though the NeurIPS 2025 checklist requires error bars, the first paper I clicked from the list of accepted papers has no error ranges in table 1. The field of ML makes progress despite bad statistics, because replication is so easy, so why bother?

I think it does matter, because replicating papers still has a cost, and giving accurate information to readers is important. Nevertheless, you can make a self-interested argument for using sound statistics: during hyperparameter/algorithm search. When getting a ML idea to work, you typically try lots of different variations. Often each variation just has 1-3 seeds. Being able to compare the error bars on each of these leads to better decisions about what to cut and what to keep.

Here’s how to use the bootstrap. If your measurement is summarized from N samples, you can pass the samples and the summary function directly to scipy.stats.bootstrap, and it will give you a 95% confidence interval for your measurement. You can use these as error bars. Hooray!

Under the hood, the bootstrap method samples many times with replacement from your dataset, and then computes the summary statistic for each sample. This gives you a distribution of likely values of your summary statistic. For example, suppose you have 100 samples and are computing the mean of your quantity. The bootstrap will sample 10,000 times a set of 100 samples with replacement, and compute its mean. You get a distribution of possible means.

How well does it work?

The Bootstrap is a consistent estimator of your confidence interval of interest. Concretely, as your number of observed samples N grows to infinity, the probability of the true value falling inside the 95% interval computed approaches 95%. (Of course, if we’re talking about means, the interval gets narrower and narrower with larger N too.)^[1] In fact, it can be shown that, for the bias-corrected method scipy uses, the error in probability between the requested interval coverage and the actual percentage of time it covers the true value decays as O(1/n).

For comparisons, computing ranks is better than values

For example, say you have 10 different variations of an algorithm, you want to compare them.

You could compute the per-datapoint accuracy to bootstrap, then compute the 95% confidence interval for the average accuracy, and check if these intervals overlap. This gives you a great idea of what the accuracy is. But in cases where the accuracy of the variations is close, it needs a lot of samples to tell you which one is better. The intervals will almost always overlap. (This is kind of conservative, strictly speaking hypothesis tests can do better.)

Alternatively, you can compute the ranking of each method on each data point. The average ranking for each algorithm is also a quantity for which the bootstrap can give confidence intervals! Because it doesn’t depend on how much better each algorithm is, and it takes into account that only one algorithm can be ‘the best’ at any particular data point, it often needs many fewer data points to conclude one algorithm is decisively better than another.

Bootstrap estimation thus gives us a very easy way to get error bars, and to make a 10-treatment version of the McNemar test.

Interestingly, the Bootstrap wikipedia page has a section on Gaussian process regression for bootstrapping data with temporal correlations, which cites a single article. I’m 85% sure that it was written by the author of that article. I’m pretty sure that is only correct if your measurements are Gaussian distributed. In fairness, if you’re measuring means of independent data points, they kind of are Gaussian. ↩︎

Circuit discovery through chain of thought using policy gradients

2026-10-13T22:41:12Z

Circuit discovery has been restricted to the single-forward-pass setting, because the algorithms to attribute changes in behavior to particular neurons / SAE features need gradients, and you can’t take a gradient through the sampled chain of thought. Or… can you?

It turns out taking gradients through random discrete actions is an essential part of reinforcement learning. We can estimate the gradients of an expectation over CoTs, with respect to the features, using the score function estimator. We can combine this with integrated gradients to produce a version of EAP-IG which works through the averages of chains of thought.

Background

Circuit discovery

The task we attempt to do is circuit discovery, defined by Conmy et al. Formally, for each subgraph $H$ of a computational DAG $G$ which represents a neural network, we want to find which subgraph $H$ is responsible for a behavior. We do this by defining a ‘task loss’, which compares the performance of the subgraph to the performance of the whole network. Let that loss be $D$ and then $x,x'$ be the clean and corrupted datapoints. The loss for a single pair of data points is:

$\mathcal{L}(x_i, x_i') = D(G(x_i), H(x_i, x_i'))$ .

the overall loss of a circuit $H$ is simply the average of this loss over all datapoints and corrupted datapoints $x_i,x_i'$ .

Partial edge inclusion: introducing z

To connect this to integrated gradients, we introduce variables $z$ , which control whether an edge is included in $H$ or not. The scalar $z_j$ controls whether the $j$ th edge (or node) is included in $H$ or not. That is, the value $v_j$ of the $j$ th edge is replaced by:

$v_j(x_i)\text{ under the subgraph } H_z := z_jv_j(x_i) + (1-z_j)v_j(x_i')$

If we set $z_j=0$ the edge is not included, i.e., it has the value it would get under the corrupted input. If we set $z_j=1$ , then the edge has the value it gets from running the comptuational graph $G$ forward.

Integrated Gradients for attribution

Our first ingredient can be any gradient-based method for circuit discovery. I’ve chosen to focus on EAP with Integrated Gradients because it’s still the circuit discovery algorithm with the best balance of simplicity and performance. You could make a CoT version of Attribution Patching as well.

To attribute behavioral loss to some configuration of edges (concrete value of $z$ ), we compute the gradient of the task loss with respect to $z$ , which determines whether we include an edge or not: $\nabla_z\mathcal{L}(x_i, x_i'; H_z)$ . In EAP-IG, we average this for z between 0 and 1, for all edges of the graph $G$ simultaneously. If we interpolate at $N$ points in between 0 and 1, the attribution for a single data point is:

$\text{Attrib}(x_i, x_i') = \sum_{n=0}^N \nabla_z \mathcal{L}(z; x_i, x_i')\Big|_{z = \frac{n}{N}}$

for loss defined using the task loss, the full graph and the graph corrupted by z: $\mathcal{L}(z; x_i, x_i') = D(G(x_i), H_z(x_i, x_i'))$ . Notice that we average over $z = \frac{n}{N}$ , so we take $z=1$ , $z=0$ , and $N-1$ intermediate points.

Policy gradients

Now for the second ingredient: policy gradients. Suppose I have a policy and some loss function $F(a_1, a_2, \dots, a_T)$ , which depends on trajectories of actions $a_1,a_2,\dots,a_T$ from the policy. The policy $\pi_\theta$ is parameterized by some parameters $\theta$ . The expected loss over trajectories is:

$\mathcal{L}(\theta) = \mathbb{E}_{a_{1:T} \sim \pi_\theta}\left[ F(a_{1:T})\right]$

We’d like to take gradients $\nabla_\theta \mathcal{L}(\theta)$ . These are tricky because the loss $F(\cdot)$ does not depend on $\theta$ directly. Instead, it depends on $\theta$ through the distribution over actions in the trajectory, which determines the expectation of $F(a_{1:T})$ .

The policy gradient theorem tells us that the gradient is the expected gradient of the log-probability of actions, weighed by how big $F(a_{1:T})$ is:

$\nabla_\theta \mathcal{L}(\theta)= \nabla_\theta \mathbb{E}_{a_{1:T} \sim \pi_\theta}\left[ F(a_{1:T})\right] = \mathbb{E}_{a_{1:T} \sim \pi_\theta}\left[ F(a_{1:T}) \sum_{t=1}^T \nabla_\theta \log \pi(a_t | a_{1:t-1}) \right] .$

Let’s take this formula as given. I explain it in these two posts, but one the keys to it is that we can swap integral and differential signs, and that $\nabla_\theta \pi_\theta = \pi_\theta \nabla_\theta \log \pi_\theta$ by the chain rule.

What do policy gradients give us?

It’s worth expanding on what policy gradients are for, and why they’re useful. Policy gradients give us the gradient of how the average outcome over many trajectories varies, when we vary the parameters $\theta$ . It’s not for a particular rollout, it’s for the whole distribution. As such, any gradients that we take include the effect of the CoT on the output.

The function $F$ can be a function of any number of steps in the trajectory. It can be just of the final step (if we’re looking at e.g. full CoTs and a single token answer). It can be of many steps at the end (if we’re considering a CoT + whether an answer matches the truth, as rated by some other model). It can be basically anything. That’s why it’s the workhorse of modern LLM RL: PPO, GRPO, etc. are all based on policy gradients.

The proposed method: integrated gradient policy gradient

So if we want to attribute behavior sampled through CoTs to parts of the network, we can just use both of these simultaneously.

We define a task loss $D$ that depends on the tokens until now, the output of the original model and the output of the new model. The behavior that we want to study (and find sub-circuits for) is thus the expectation when sampling from the corrupted subgraph:

$\mathcal{L}(z) = \mathbb{E}_{x_{1:T} \sim H_z}\left[ D(a_{1:T}, G(x_{1:T}), H(z; x_{1:T}, x_{1:T}' ) \right]$

We sample from $H_z$ autoregressively: we start with $x_1$ and corrupt it to find $x_1'$ , that lets us compute $H_z(x_1, x_1')$ and sample $x_2$ from it; then we corrupt $x_2$ to get $x_2'$ , etc. I’ve abbreviated this in the expression above as $x_{1:T} \sim H_z$ .

Now we see how we can use both elements.

Integrated gradients: to attribute the behavior through the CoT to components z of the model, we simply need to take $\nabla_z \mathcal{L}(z)$ interpolated at various points for $z$ between 0 and 1. That is, we want:

$\text{Attrib} = \sum_{n=0}^N \nabla_z \mathcal{L}(z)\Big|_{z = \frac{n}{N}}$

We’ve removed the dependence of Attrib on the data points $(x_i, x_i')$ because we’re sampling things from the model, presumably with some context. But we could average over some contexts, why not.

Policy gradients: The gradient $\nabla_z \mathcal{L}(z)$ is with respect to a probability distribution. To compute it, we need to use the policy gradient theorem:

$\nabla_z \mathcal{L}(z) = \mathbb{E}_{x_{1:T} \sim H_z}\left[ D\left(a_{1:T}, G(x_{1:T}), H(z; x_{1:T}, x_{1:T}' ) \right)\cdot \sum_{t=1}^T \nabla_z \log H_z(x_t \,|\, x_{1:t-1}) \right]$

To estimate this expectation, we sample a bunch of CoTs from $H_z$ and average their values of $D(x_{1:T}) \cdot \sum_t \nabla_z \log H_z(x_t | \dots)$ .

We can just plug this in into the previous equation, and there we have it: attribution to circuit components over chains of thought.

Discussion

This method is very flexible, because it’s just the old EAP-IG, except now we can also compute gradients over probability distributions. The $z$ can be assigned to neurons, attention heads, SAE components, anything.

They don’t even have to be constant across time. We can have separate components for the gradients at a particular time-step to study the effect of a component at that time step. The same is possible if the ‘time step’ moves depending on where a token falls, but I think you’re missing some of the effect in that case.

I haven’t implemented this. It’s tricky with open-source packages because you can’t just interpolate between the original and corrupted inputs in vLLM, and Huggingface only has quadratic sampling. To make it really efficient, it’s also nice to be able to compute the gradients w.r.t $z$ at every step using the same version of KV-cache attention that you computed.

I might fill this gap with open-source tooling myself, especially if I can get funding for a month to do it.

A dirge for unintelligent computers

2026-10-13T22:41:12Z

haven’t you heard? computers can talk now, and think in a human-like manner.
You can just ask the computer what you want it to do, in words, and it will more or less do it.
- programming was kind of words, but not really; it was its own thing.
- the grandest Rube Goldberg machine, constrained only by your imagination, skill, and time it takes you to lay it out.
the unintelligent computer is dead. Long live the unintelligent computer
compilers no longer ignore comments.
I loved unintelligent computers. They were their own weird thing, behaving in weird but exact ways
anything could be understood, and understanding would reward you with arcane powers
- the Arcane ways were rewarded
it used to reward persistence and understanding.
unintelligent computers were a medium for self-expression and art.
- the medium still exists, and the community around it is very much alive, but it will die
  - it is not invigorated by a profession’s injection of people, trying new and interesting things, time and effort and money anymore
- there’s now a distinction between the crafters (who still do it by hand) and the professionals

There’s no need to understand the machine deeply anymore. All these arcane facts about Python and type systems and automatic differentiation and libraries, are not needed anymore. When my Emacs is misbehaving, I used to M-x toggle-debug-on-error, inspect its internal functionality, learn a bit more about the editor and fix it myself. It was not useful knowledge, but it was joyful—a detailed machine, inspectable and modifiable as it runs! Now, I just hit SPC a a s and ask Claude to fix my problem. Things are nicer to use as a result, but I don’t deeply understand the problem anymore.

For coding, the need to inspect agent output is still there. The agents make mistakes: your intent is not clear and gets filled (sometimes in creative, sometimes in hair-pulling ways), and they write extremely verbose code that is difficult to then maintain. (I believe verbose code is more comfortable to agents because of their extremely fast reading speed and relatively shallow mind, whereas humans, recurrent creatures, prefer terse code and comments even at the cost of stacking the tower of abstraction a little higher.)

And yet… it’s for the best. Most people don’t know how to interact with these weird, maniacally rule-following machines. They have too many states for anyone to keep track of, and the people are not curious enough about the arcane to accumulate an understanding. Many other people understand the machines but dislike dealing with them, or have alienating CRUD-pushing enterprise jobs. Freed from the exacting rules, they will be spiritually richer, with temporarily lower wages.

Those who did not understand in the first place but want to use computers for things have their bindings cut, and are set free.

And yet… I am sad. My craft is dying. Young children will not fall in love with the stubborn computer, reshape their brain until they can pedantically follow chains of logical implication until they understand the outcome. They will not feel the pull to dive, over and over, into the belly of a machine made to be comprehensible by people, which has kept complexity at bay, but yet has so much that it is almost overwhelming. They will not dream of making such machines themselves, turning the design in their head over and over until it is functional and beautiful. The current children just ask the AI to make a program. In a few years you won’t even have to navigate app menus anymore, you will ask the AIs to do or track something for you and they will hunt through commands until it is done.

The same will happen to mathematical proof. The same thing happened to hunting and [bow shooting](lars andersen) and [driving stick](fds fdsa). I recognize that it is the same impulse leads ethnic minorities to prop up their culture by law, if they’re able; or deaf parents to desire that their child be deaf too, so the child can relate to the world in a similar way. People who have never experienced these things have no attachment to or desire for them. But it makes me sad nevertheless.