Recently added

What's new

Essays arrive in groups rather than one at a time. The most recent group is below in full, and every earlier one after it, newest first.

Essays arrive in groups rather than one at a time, and a group usually opens up a subject not covered before. Between one group and the next nothing changes, so a reader who has seen the most recent group has seen everything.

27 September 2026

13 essays on randomised, and the guarantee that changes kind, the matrix that is a graph, regularisation, and the answer that is chosen, two errors, and whose fault they are, sparsity, and what elimination costs, where the flop count stopped predicting the time, least squares, and the road not to take, orthogonality, measured, exact arithmetic, and what it costs instead, neither sparse nor dense, the arithmetic underneath, structure, and the solver that cannot see it and elimination, and the swap

Randomised, and the guarantee that changes kind

A fade made of drops

A one-nonzero sketch's median error fell by about forty per cent for every factor of ten in how far a coherent matrix had been mixed toward an incoherent one, and nothing explained the rate. Followed one draw at a time, no draw fades at that rate. Each holds its coherent error — as large as the singular value of the direction its hash lost — and then drops, within one to three decades of mixing, never faster than one decade of error per decade of mixing. The median's steady slope is where the drops happen to fall. Change the spectrum and they fall elsewhere: at a decay of 0.9 there is no slope, only a cliff.

6 figures The matrix that is a graph

A finer invariant that hears less

The Laplacian spectrum fixes a graph's number of spanning trees and not the group those trees form, so the Smith normal form of the grounded Laplacian is a strictly finer integer invariant — and on the six-vertex pair the spectrum cannot separate, it does: ℤ₁₂ against ℤ₂ ⊕ ℤ₆. Over all 1,022 Laplacian-cospectral pairs of connected graphs on eight vertices it separates 435. The adjacency polynomial, a second spectrum rather than a finer one, separates all of them.

6 figures Regularisation, and the answer that is chosen

A third penalty on a flat floor

Two penalties at once were worth three per cent at most, and the explanation offered was that one penalty already does the work — which predicts that a third buys less still and that the best choice sits on a face of the parameter cube. The third buys a median of exactly nothing on all five signals and 0.66% on its best draw. But on twelve draws of forty the best triple does use all three, and on every one of them the nearest point with a penalty switched off is within that same 0.66%. The minimum is not on a face; it is on a floor so flat that where it lands is noise. Choosing the right single penalty is worth a factor of two.

6 figures Two errors, and whose fault they are

Balanced is not symmetric

The Sylvester–Kac matrix is made of small integers, so a double holds it exactly, and its eigenvalues are the integers from −(n − 1) to n − 1 in steps of two. Every digit an eigensolver loses on it is therefore the solver's own, and it loses them at exactly the rate first-order perturbation theory predicts: the median error is half the prediction across 1,568 eigenvalues. Balancing, the preprocessing libraries apply for this kind of matrix, divides every condition number by about sixty and leaves their growth untouched, and at order 112 the unbalanced solver returns eighteen complex eigenvalues for a spectrum of integers.

6 figures Sparsity, and what elimination costs

Pieces ordered blind

One level of nested dissection followed by minimum degree lengthened the factorisation's critical path, and the blame moved from the separator to the halves: minimum degree's path through a 12 × 24 half was longer than through the whole 24 × 24 grid. A 12 × 24 grid on its own has a path of 12,913, a third of the square's. What made the half expensive is that it was ordered as if the separator were not there. Count the separator's vertices in every degree and number them last, and the depth-one path falls from 53,508 to 41,050 — minimum degree's own — while the pieces' own arithmetic does not change at all. At depth two the same ordering beats full dissection.

5 figures Where the flop count stopped predicting the time

The circle between two eigenvalues

A contour count's error is not approximately governed by the nearest eigenvalue; it is exactly one closed-form term per eigenvalue, and summing those terms reproduces the quadrature to a millionth at 1,720 radius and point pairs. Three things follow. The rate is the ratio of the two moduli the circle sits between, not a distance, so two circles 0.2 from their nearest eigenvalue converge three times apart. Ten digits cost about 21 points divided by log₁₀ of that ratio, 71 points with twelve eigenvalues inside and 3,476 with six. And the best circle is not halfway: at the geometric mean of two eigenvalues on one ray their two terms are equal and opposite, and ten digits cost 27 points where the midpoint needs 84.

6 figures Least squares, and the road not to take

The degree that is safe to overshoot

The rules that choose a Tikhonov parameter miss by factors of millions on one draw in twenty. Transplanted to the degree of a polynomial fit, in a basis orthonormal on the data, the same rules never cost more than 2.7 times the best degree's error in three hundred draws. The reason is the shape of the valley they search: six degrees too few costs from 44 to 16,000 times the best error, forty degrees too many costs about twice it. The one rule with a tail, the discrepancy principle, has its threshold half a standard deviation above the residual it is waiting for.

6 figures Orthogonality, measured

The factor nobody forms

A blocked Householder factorisation's orthogonal factor, multiplied out, departs from orthogonality half as far in blocks of sixteen as one reflector at a time, and that was read as blocking buying a factor of two. Libraries do not multiply it out. Applied to vectors through its stored blocks — which is how every caller uses it — the same factor departs by 3.1 to 4.0·10⁻¹⁵ at every block size from one to sixty-four, and stops growing after about twenty reflectors instead of adding them up. The factor of two was the price of forming the product, and a factor that is never formed never pays it.

5 figures Exact arithmetic, and what it costs instead

The field decides it, usually

A matrix whose rank depends on the field it is read over was built, the first time, from its invariant factors outward, because random integer matrices never seemed to show the effect. Random 0/1 matrices show it at almost every size that is not tiny. At twenty rows, 99.8% of them are invertible over the rationals, 29% modulo two, 56% modulo three — and 71% of the ones the rationals call invertible are singular modulo two. Modulo two they obey, corank by corank, the law for uniformly random matrices over that field; modulo three and five, which their entries cannot fill, they converge to that field's law anyway.

6 figures Neither sparse nor dense

The smaller cluster sets the rank

An oscillatory kernel block between two equal clusters needs a rank that grows without limit as they grow. Make the clusters unequal at the same separation ratio and the rank stops following the larger one: a target an eighth long against a source of four needs 8 columns where the square block of side four needs 33, and a target a third long against a source 130 wavelengths long needs 11. What decides the rank is the product of the two lengths over their distance — the Fresnel number, the count optics gives for the waves two apertures can exchange.

5 figures The arithmetic underneath

The well on the far side of the band

Gradual underflow was said to buy a predicate and not an answer, because a quantity that has decayed into the subnormal range is already lost. A quantity that passes through the band on its way somewhere else is not. The stationary distribution of a two-well chain, computed in half precision across a barrier whose top is two to the minus sixteen of the near well, keeps its far well's probability of 0.2454 to three digits with subnormals and returns exactly zero without them. The normwise backward error calls both answers exact.

6 figures Structure, and the solver that cannot see it

Where one step stops being enough

One step of iterative refinement took the squared Laplacian's circulant-wrap solve to elimination's accuracy at every size, and the account was that each step multiplies the error by the wrap's condition number times the rounding, so one step suffices while that product is small. Raised to higher powers, the band tests the account and half of it holds: each step does contract by about κ(wrap)·u. The other half fails. The fifth power at sixteen points needs three steps with κ(wrap)·u near 10⁻⁶, where the third power at 128 points needs one with thirty times more, because the first solve starts up to a thousand times further from the answer than κ(wrap)·u says.

5 figures Elimination, and the swap

Where the multipliers go

Bunch–Kaufman bounds the growth in D and not the entries of L, and the warning attached to that is that everything which later uses the factors inherits the size of L. On a matrix built to make those entries 1.2 over ε, they reach 1.2·10¹⁰ while the solve's backward error stays at 1.6·10⁻¹⁶, |L||D||Lᵀ| stays at 6.7 times ‖A‖, and a step of refinement changes nothing. The large multipliers are where the rule has put the matrix's ill-conditioning. A direction of negative curvature read from those factors finds 7·10⁻¹⁶ of the curvature that is there; the bounded rule's finds 13%.

6 figures

Before that

Everything published earlier, newest first. Titles only — the cards are on the full listing.

26 September 2026

13 essays on reduction, and what a model is for, randomised, and the guarantee that changes kind, methods that were designed apart, elimination, and the swap, the matrix a constraint makes, sparsity, and what elimination costs, where the flop count stopped predicting the time, regularisation, and the answer that is chosen, exact arithmetic, and what it costs instead, when the index is a tuple, orthogonality, measured, structure, and the solver that cannot see it and when the problem arrives again

A mode that rings is counted twice — reduction, and what a model is for
A spread measured on probes it does not average — randomised, and the guarantee that changes kind
A tail from Tikhonov and a corner from truncation — methods that were designed apart
A trigger finer than the growth — elimination, and the swap
An augmentation read in the smallest eigenvalue — the matrix a constraint makes
An order fixed before the numbers — sparsity, and what elimination costs
Leaves cut to the edge on purpose — where the flop count stopped predicting the time
More samples take the floor and leave the dip — regularisation, and the answer that is chosen
The digits between the two searches — exact arithmetic, and what it costs instead
The rank that stops being typical — when the index is a tuple
The residual the appended block cannot remove — orthogonality, measured
The staircase a separable kernel builds — structure, and the solver that cannot see it
The step the two rows owe — when the problem arrives again

25 September 2026

18 essays on when the problem arrives again, where the flop count stopped predicting the time, when the index is a tuple, orthogonality, measured, elimination, and the swap, structure, and the solver that cannot see it, sparsity, and what elimination costs, randomised, and the guarantee that changes kind, regularisation, and the answer that is chosen, methods that were designed apart, exact arithmetic, and what it costs instead, least squares, and the road not to take, the matrix a constraint makes, reduction, and what a model is for, neither sparse nor dense and two errors, and whose fault they are

A floor with a cliff at one — when the problem arrives again
A near-tie is a factor of four — where the flop count stopped predicting the time
A still error is not a settled one — when the index is a tuple
Eight blocks and sixty-four reflections — orthogonality, measured
One step ahead is one step short — elimination, and the swap
One step past the zero — structure, and the solver that cannot see it
The halves were the price — sparsity, and what elimination costs
The leverage that did not move — randomised, and the guarantee that changes kind
The minimum on the right — regularisation, and the answer that is chosen
The overshoot was the lead — methods that were designed apart
The pivot is in every product — exact arithmetic, and what it costs instead
The residual the solution cannot hold — least squares, and the road not to take
The residual turns before the error doubles — the matrix a constraint makes
The smaller cell downstream — reduction, and what a model is for
A fit wins where the steps were few — when the problem arrives again
A multiplier is a force — least squares, and the road not to take
A quarter of the leaf — neither sparse nor dense
Two columns see what one walk cannot — two errors, and whose fault they are

24 September 2026

19 essays on methods that were designed apart, regularisation, and the answer that is chosen, structure, and the solver that cannot see it, when the index is a tuple, exact arithmetic, and what it costs instead, the matrix a constraint makes, elimination, and the swap, when the problem arrives again, reduction, and what a model is for, where the flop count stopped predicting the time, randomised, and the guarantee that changes kind, least squares, and the road not to take and orthogonality, measured

A count that marks the edge and not the pace — methods that were designed apart
A corner the penalty can afford — regularisation, and the answer that is chosen
The correction lost to its own two-by-two solve — structure, and the solver that cannot see it
The rank a sweep can vouch for — when the index is a tuple
The room a relation has to stand out — exact arithmetic, and what it costs instead
The shift had an edge, and the approximation moved it — methods that were designed apart
A fit that has an answer and cannot stop — when the index is a tuple
A loop that asks the null space why — the matrix a constraint makes
A threshold that holds the growth still — elimination, and the swap
A zero no twist can step around — structure, and the solver that cannot see it
One arc, and what each filter pays to be on it — methods that were designed apart
The answer the last window left — when the problem arrives again
The data count their dimensions, not the step's — regularisation, and the answer that is chosen
The inner product the mesh already computed — reduction, and what a model is for
The leaf that sits on the edge — where the flop count stopped predicting the time
The miss a normal table already priced — randomised, and the guarantee that changes kind
The weight the factor met first — least squares, and the road not to take
Two precisions guard the other edge — exact arithmetic, and what it costs instead
What the appended block inherits — orthogonality, measured

21 September 2026

6 essays on neither sparse nor dense, sparsity, and what elimination costs and least squares, and the road not to take

A second objective that is the first one doubled — neither sparse nor dense
How few columns the search needs — sparsity, and what elimination costs
The factor a sparse code keeps anyway — least squares, and the road not to take
A geometry setting that is a second accuracy — neither sparse nor dense
The freedom a symmetric factorisation does not have — sparsity, and what elimination costs
A prediction that arrives a decade late — neither sparse nor dense

18 September 2026

18 essays on structure, and the solver that cannot see it, where the flop count stopped predicting the time, when the problem arrives again, orthogonality, measured, reduction, and what a model is for, elimination, and the swap, sparsity, and what elimination costs, regularisation, and the answer that is chosen, randomised, and the guarantee that changes kind and the matrix a constraint makes

The circulant the problem did not contain — structure, and the solver that cannot see it
A beam ranked on what remains — where the flop count stopped predicting the time
A straight path has nothing for a parabola to fit — when the problem arrives again
Five precise points are five points — orthogonality, measured
Half the conditions and a certificate — reduction, and what a model is for
Noise the growth amplifies — elimination, and the swap
The column that was never fixed — sparsity, and what elimination costs
The grid on which the discretisation stops mattering — regularisation, and the answer that is chosen
The rank a certificate charges — randomised, and the guarantee that changes kind
The shift that stops at the first right count — the matrix a constraint makes
Two near-zeros cost less than one — structure, and the solver that cannot see it
A certificate written in coordinates — reduction, and what a model is for
A constraint the count stops seeing — the matrix a constraint makes
A margin the factorisation records — elimination, and the swap
A mirror decided in the thin directions — orthogonality, measured
A sketch that finds the columns it can see — randomised, and the guarantee that changes kind
The degree the history chooses — when the problem arrives again
Widen the beam where the ranking is right — where the flop count stopped predicting the time

16 September 2026

20 essays on when the problem arrives again, regularisation, and the answer that is chosen, orthogonality, measured, methods that were designed apart, randomised, and the guarantee that changes kind, sparsity, and what elimination costs, the matrix a constraint makes, elimination, and the swap, exact arithmetic, and what it costs instead and neither sparse nor dense

A guess worth two per cent — when the problem arrives again
A rule that has to be told how good its answer will be — regularisation, and the answer that is chosen
One number that has to be right — orthogonality, measured
The rule that is wrong in the right direction — methods that were designed apart
The split nobody is in a position to choose — randomised, and the guarantee that changes kind
Two minima that are one minimum — sparsity, and what elimination costs
Two repairs for one symptom — the matrix a constraint makes
Which of the choices is doing the work — elimination, and the swap
A bound on every intermediate at once — exact arithmetic, and what it costs instead
A rule that reads only its own probes — randomised, and the guarantee that changes kind
A second penalty is not a second parameter — regularisation, and the answer that is chosen
A test with no tolerance in it — the matrix a constraint makes
A triangle where the scalar was — orthogonality, measured
One line that buys a quarter of the run — when the problem arrives again
The depth that is worse than both ends — sparsity, and what elimination costs
The order the greedy rule cannot choose — elimination, and the swap
The parameter neither knob is — methods that were designed apart
The partition that does not move — neither sparse nor dense
Three orders and one last entry — exact arithmetic, and what it costs instead
Two knobs on one number — neither sparse nor dense

14 September 2026

14 essays on exact arithmetic, and what it costs instead, when the problem arrives again, where the flop count stopped predicting the time, least squares, and the road not to take and when the index is a tuple

A relation among digits that were not there — exact arithmetic, and what it costs instead
A warm start is degree zero — when the problem arrives again
A ceiling is not a target — where the flop count stopped predicting the time
Rounding a coordinate in the wrong basis — exact arithmetic, and what it costs instead
The order a batch arrives in — when the problem arrives again
Feasible and wrong — least squares, and the road not to take
One term too many — when the index is a tuple
The knob and the rounding — exact arithmetic, and what it costs instead
The plan that was right at rank four — where the flop count stopped predicting the time
The condition number that does not know — least squares, and the road not to take
The repair that costs exactly itself — when the index is a tuple
The search that got worse as it widened — where the flop count stopped predicting the time
The reference was a method — least squares, and the road not to take
The test that is a deadline — when the index is a tuple

13 September 2026

15 essays on regularisation, and the answer that is chosen, the matrix a constraint makes, methods that were designed apart, elimination, and the swap, sparsity, and what elimination costs, least squares, and the road not to take, orthogonality, measured and where the flop count stopped predicting the time

A better discretisation is a weaker filter — regularisation, and the answer that is chosen
A shift that certifies a saddle — the matrix a constraint makes
A stopping rule that follows the run it is given — methods that were designed apart
A worst case is as fragile as its margin — elimination, and the swap
An ordering that buys processors, not time — sparsity, and what elimination costs
One minus a leverage is a subtraction — least squares, and the road not to take
Spread resistances make the loops easy — orthogonality, measured
The block size a recursion still has — where the flop count stopped predicting the time
The growth a boundary-value problem supplies — elimination, and the swap
The least fill there is — sparsity, and what elimination costs
The perturbation that does the work — the matrix a constraint makes
The tree the resistances choose — orthogonality, measured
Two observations that hide each other — least squares, and the road not to take
What a cheap preconditioner has to leave alone — methods that were designed apart
Where the grid hands over to λ — regularisation, and the answer that is chosen

11 September 2026

20 essays on regularisation, and the answer that is chosen, the matrix a constraint makes, methods that were designed apart, orthogonality, measured, least squares, and the road not to take, elimination, and the swap, where the flop count stopped predicting the time and when the problem arrives again

A second blur, narrower than the first — regularisation, and the answer that is chosen
Noise that spares the answer and fools the rules — regularisation, and the answer that is chosen
A minimum the Hessian cannot see — the matrix a constraint makes
One draw in twenty — regularisation, and the answer that is chosen
A preconditioner that arrives past the answer — methods that were designed apart
A rotation that comes back mirrored — orthogonality, measured
One eigenvalue and two steps — the matrix a constraint makes
The corner reads the norm it is drawn in — regularisation, and the answer that is chosen
A stable block is not a stable basis — orthogonality, measured
A step that is not a unit of work — methods that were designed apart
The active set before the digits — the matrix a constraint makes
The grid was the first filter — regularisation, and the answer that is chosen
A basis built from the points — least squares, and the road not to take
A pivot that searches one row and one column — elimination, and the swap
The method that cannot use a smooth answer — methods that were designed apart
The recursion that was never told the memory — where the flop count stopped predicting the time
The repair the drift did not need — when the problem arrives again
The right-hand side as one more column — orthogonality, measured
Thirty-two coefficients instead of a noise level — regularisation, and the answer that is chosen
Where the augmentation puts the cost — the matrix a constraint makes

7 September 2026

50 essays on orthogonality, measured, methods that were designed apart, least squares, and the road not to take, elimination, and the swap, when the problem arrives again, when the index is a tuple, neither sparse nor dense, structure, and the solver that cannot see it, sparsity, and what elimination costs, reduction, and what a model is for, randomised, and the guarantee that changes kind, the arithmetic underneath, the eigenvalue problem that is not linear, two errors, and whose fault they are, the answer that depends on the machine, eigenvalues, singular values, rank and iterating, instead of factorising

A test with no answer in it — orthogonality, measured
An expiry date the noise does not move — methods that were designed apart
Influence is decided before the data — least squares, and the road not to take
The gap refinement can close — elimination, and the swap
The penalty for keeping it is a ratio — when the problem arrives again
The two numbers a caller has — least squares, and the road not to take
A compression of 10¹⁴ that still does not fit — when the index is a tuple
A knob calibrated in residuals — neither sparse nor dense
A speedup with a ceiling of its own — structure, and the solver that cannot see it
The cliff behind the count — sparsity, and what elimination costs
A condition number that is not the model's — reduction, and what a model is for
A rate that belongs to the matrix — randomised, and the guarantee that changes kind
Five indices are cheaper than two — when the index is a tuple
Four orders of conditioning, and four steps — structure, and the solver that cannot see it
The count that is not the budget — neither sparse nor dense
Bracketing an error nobody can measure — reduction, and what a model is for
The digit that costs more than the tensor — when the index is a tuple
The elimination the matrix does not need — structure, and the solver that cannot see it
The knob that moved two things — neither sparse nor dense
What a single draw cannot report — randomised, and the guarantee that changes kind
A bit buys an octave — the arithmetic underneath
The definition asks for more of what defeats it — reduction, and what a model is for
The number that cannot rank them — structure, and the solver that cannot see it
The offset that moved the slope — neither sparse nor dense
The state that is removed is not a mode — reduction, and what a model is for
A class a longer chain takes away — the eigenvalue problem that is not linear
A tolerance is priced by the problem — two errors, and whose fault they are
An estimate that does not move — the eigenvalue problem that is not linear
One mass removed, and one eigenvalue gone — the eigenvalue problem that is not linear
The tail a sample never reaches — two errors, and whose fault they are
Nine steps of pessimism — the arithmetic underneath
The licence is not the boundary — the answer that depends on the machine
The number that moves when the problem does — the eigenvalue problem that is not linear
The reading that never moves — the answer that depends on the machine
Where a contour's budget should go — the eigenvalue problem that is not linear
A good curve and a bad verdict — eigenvalues, singular values, rank
A threshold the matrix does not set — eigenvalues, singular values, rank
A different equation on every grid — iterating, instead of factorising
The error the method already knows — eigenvalues, singular values, rank
A parameter that is also a price — iterating, instead of factorising
The largest gap is inside the null space — eigenvalues, singular values, rank
A run that is over at step five — iterating, instead of factorising
The same budget, spent five ways — eigenvalues, singular values, rank
A smoother that stops being one — iterating, instead of factorising
How much direction there was to lose — iterating, instead of factorising
The switch does not know which side is better — iterating, instead of factorising
A proof that does not ask how large the matrix is — iterating, instead of factorising
A walk needs a length — iterating, instead of factorising
The answer that arrives when the space runs out — iterating, instead of factorising
The certificate that arrives soonest is worth least — iterating, instead of factorising

1 September 2026

12 essays on exact arithmetic, and what it costs instead and the matrix that is a graph

An answer with no error in it — exact arithmetic, and what it costs instead
Every intermediate is a minor — exact arithmetic, and what it costs instead
The answer is longer than the question — exact arithmetic, and what it costs instead
How many primes the answer needs — exact arithmetic, and what it costs instead
A prime that divides the answer — exact arithmetic, and what it costs instead
A fraction recovered from one remainder — exact arithmetic, and what it costs instead
The rank depends on the ring — exact arithmetic, and what it costs instead
What a determinant does not determine — exact arithmetic, and what it costs instead
A basis that describes its lattice badly — exact arithmetic, and what it costs instead
An exact answer to a measured problem — exact arithmetic, and what it costs instead
A Laplacian that is not symmetric — the matrix that is a graph
A conductance the arcs do not measure — the matrix that is a graph

31 August 2026

20 essays on the matrix that is a graph, reduction, and what a model is for and the eigenvalue problem that is not linear

A matrix with no numbers in it — the matrix that is a graph
Two Laplacians of one graph — the matrix that is a graph
The vertex nobody solves for — the matrix that is a graph
The vector that has to be rounded — the matrix that is a graph
A bound with a square root in it — the matrix that is a graph
A partition decided in the last digit — the matrix that is a graph
A ranking that is an eigenvector — the matrix that is a graph
The rate is the second eigenvalue — the matrix that is a graph
A chain with no stationary vector — the matrix that is a graph
A model with no matrices behind it — reduction, and what a model is for
An eigenvector that must not change sign — the matrix that is a graph
A ranking whose order is not determined — the matrix that is a graph
A distance computed by a solve — the matrix that is a graph
A graph with a tenth of the edges — the matrix that is a graph
Eliminating a vertex is a graph operation — the matrix that is a graph
The points the algorithm chose — the eigenvalue problem that is not linear
A perturbation that moves every coefficient — the eigenvalue problem that is not linear
A preconditioner that is a tree — the matrix that is a graph
A count that comes out of a determinant — the matrix that is a graph
The spectrum is not the graph — the matrix that is a graph

30 August 2026

20 essays on the answer that depends on the machine, reduction, and what a model is for and two errors, and whose fault they are

The same program, twice — the answer that depends on the machine
A bound every answer satisfies — the answer that depends on the machine
Where the disagreement comes from — the answer that depends on the machine
The vector that hides it — the answer that depends on the machine
The sum that cannot be wrong — the answer that depends on the machine
What determinism costs — the answer that depends on the machine
Accuracy and agreement are different properties — the answer that depends on the machine
One multiply the compiler removed — the answer that depends on the machine
A matrix that is definite on one machine — the answer that depends on the machine
A model that cannot be run — reduction, and what a model is for
A square that evaluates negative — the answer that depends on the machine
A stopping test is a race — the answer that depends on the machine
The tolerance that buys no agreement — the answer that depends on the machine
A rank that depends on the thread count — the answer that depends on the machine
The length that changes the kernel — the answer that depends on the machine
What a regression test can ask for — the answer that depends on the machine
An inner product with no fixed sign — the answer that depends on the machine
The fifth author — two errors, and whose fault they are
The variation that comes with a seed — the answer that depends on the machine
Two machines, one certificate — the answer that depends on the machine

29 August 2026

15 essays on reduction, and what a model is for, the eigenvalue problem that is not linear and two errors, and whose fault they are

A model that is a rational function — reduction, and what a model is for
The bound that is known in advance — reduction, and what a model is for
The product nobody had to form — reduction, and what a model is for
Exact at the points that were named — reduction, and what a model is for
A basis that is the same subspace and not the same thing — reduction, and what a model is for
Interpolating at the model’s own poles — reduction, and what a model is for
Why a Gramian can be truncated at all — reduction, and what a model is for
The problem the solver was actually given — the eigenvalue problem that is not linear
Where to put the poles of a rational function — reduction, and what a model is for
An error committed before the arithmetic — the eigenvalue problem that is not linear
Two approximants and one matrix size — the eigenvalue problem that is not linear
The eigenvalues that are answers to nothing — the eigenvalue problem that is not linear
A ceiling with a knob on it — the eigenvalue problem that is not linear
The conditioning that rises with the ceiling — the eigenvalue problem that is not linear
Three errors and one number — two errors, and whose fault they are

28 August 2026

13 essays on the eigenvalue problem that is not linear, structure, and the solver that cannot see it, where the flop count stopped predicting the time, randomised, and the guarantee that changes kind, two errors, and whose fault they are, the arithmetic underneath and iterating, instead of factorising

A matrix that depends on its own eigenvalue — the eigenvalue problem that is not linear
A backward-stable answer to a problem nobody asked — the eigenvalue problem that is not linear
The scaling that buys ten orders — the eigenvalue problem that is not linear
Six routes to one spectrum — the eigenvalue problem that is not linear
Every eigenvalue real, and a test that says so — the eigenvalue problem that is not linear
A spectrum that comes in reciprocal pairs — the eigenvalue problem that is not linear
A problem with infinitely many eigenvalues — the eigenvalue problem that is not linear
A perturbation that keeps the symmetry — structure, and the solver that cannot see it
The last digit is the cheapest — where the flop count stopped predicting the time
Counting what is inside a circle — randomised, and the guarantee that changes kind
The roots are not the coefficients — two errors, and whose fault they are
The units that overflow before the answer does — the arithmetic underneath
A Krylov space for a problem that is not linear — iterating, instead of factorising

27 August 2026

13 essays on the matrix a constraint makes, orthogonality, measured, least squares, and the road not to take, when the problem arrives again, sparsity, and what elimination costs, randomised, and the guarantee that changes kind, two errors, and whose fault they are and eigenvalues, singular values, rank

The zero that is not a missing entry — the matrix a constraint makes
Two ways to remove a constraint — the matrix a constraint makes
Three eigenvalues, and two are the golden ratio — the matrix a constraint makes
A preconditioner that need not know the constraint — the matrix a constraint makes
A condition number sent to infinity — the matrix a constraint makes
The basis nobody chose on purpose — orthogonality, measured
The regularisation that legalises every order — the matrix a constraint makes
A constraint is a weight at infinity — least squares, and the road not to take
What survives one step of the barrier — when the problem arrives again
An ordering that does not wait for the numbers — sparsity, and what elimination costs
The half of a problem a sketch may touch — randomised, and the guarantee that changes kind
Two condition numbers of one matrix — two errors, and whose fault they are
An eigenvalue count that cannot be slightly wrong — eigenvalues, singular values, rank

25 August 2026

13 essays on when the index is a tuple, randomised, and the guarantee that changes kind, where the flop count stopped predicting the time, two errors, and whose fault they are and iterating, instead of factorising

An index that is a pair — when the index is a tuple
A solve that is d decompositions — when the index is a tuple
A nearest point that is not there — when the index is a tuple
A rank that is not a property of the tensor — when the index is a tuple
A decomposition made only of SVDs — when the index is a tuple
The orthogonality that cannot be diagonal — when the index is a tuple
The format that does not notice the dimension — when the index is a tuple
An iteration that walks out of the set — when the index is a tuple
Sketching what is never unfolded — randomised, and the guarantee that changes kind
The order the products are taken in — where the flop count stopped predicting the time
A factorisation that is unique for once — when the index is a tuple
A tensor that cannot be decomposed — two errors, and whose fault they are
An iterate that must be made smaller — iterating, instead of factorising

23 August 2026

13 essays on neither sparse nor dense, randomised, and the guarantee that changes kind, where the flop count stopped predicting the time, sparsity, and what elimination costs and two errors, and whose fault they are

A block nobody can call sparse — neither sparse nor dense
A rank that is a number of digits — neither sparse nor dense
The size the rank does not notice — neither sparse nor dense
The kernel with nothing to compress — neither sparse nor dense
Which pairs are allowed to be small — neither sparse nor dense
The test that costs what it saves — neither sparse nor dense
Built from products alone — randomised, and the guarantee that changes kind
The same matrix, numbered twice — neither sparse nor dense
Where the format starts paying — where the flop count stopped predicting the time
The accuracy worth paying for — neither sparse nor dense
The fill that is not independent — sparsity, and what elimination costs
The rounding that was not the problem — neither sparse nor dense
An accuracy that is a backward error — two errors, and whose fault they are

22 August 2026

12 essays on when the problem arrives again, randomised, and the guarantee that changes kind, sparsity, and what elimination costs, the arithmetic underneath and iterating, instead of factorising

The problem that arrives again — when the problem arrives again
The accuracy that is thrown away — when the problem arrives again
A tolerance that reads its own residual — when the problem arrives again
A factorisation kept past its date — when the problem arrives again
Where the drift lands — when the problem arrives again
The sketch that is spent — randomised, and the guarantee that changes kind
What a rebuild is worth — when the problem arrives again
Stable once, and three thousand times — when the problem arrives again
The order that was right last time — sparsity, and what elimination costs
Three walks and one bound — the arithmetic underneath
The residual the method reports — iterating, instead of factorising
The number that is re-derived — iterating, instead of factorising

21 August 2026

12 essays on structure, and the solver that cannot see it, two errors, and whose fault they are, eigenvalues, singular values, rank and iterating, instead of factorising

A nearby problem of the wrong kind — structure, and the solver that cannot see it
The condition number of the model — structure, and the solver that cannot see it
The zero you are allowed to write — two errors, and whose fault they are
Deciding that a zero has arrived — two errors, and whose fault they are
Two matrices and one problem — eigenvalues, singular values, rank
An eigenvalue with no value — eigenvalues, singular values, rank
A problem with no answer — eigenvalues, singular values, rank
The zero that means it is finished — iterating, instead of factorising
Small compared to what — eigenvalues, singular values, rank
The same zero, and nothing was found — iterating, instead of factorising
Accurate is not a property of a method — eigenvalues, singular values, rank
The division that cannot be done — iterating, instead of factorising

20 August 2026

12 essays on orthogonality, measured, least squares, and the road not to take, structure, and the solver that cannot see it, elimination, and the swap, two errors, and whose fault they are, eigenvalues, singular values, rank and iterating, instead of factorising

The nearest orthogonal matrix — orthogonality, measured
A correction cheaper than the problem — least squares, and the road not to take
An iteration that only multiplies — orthogonality, measured
An equation whose unknown is a matrix — structure, and the solver that cannot see it
The observation that cannot be removed — least squares, and the road not to take
A rule that is correct and unusable — elimination, and the swap
The inverse that is never formed — elimination, and the swap
The number that decides nothing — two errors, and whose fault they are
A function of a matrix is not a function of its entries — eigenvalues, singular values, rank
The series that has to be squared back — eigenvalues, singular values, rank
The vector was what was wanted — eigenvalues, singular values, rank
An operator with no entries — iterating, instead of factorising

19 August 2026

12 essays on randomised, and the guarantee that changes kind, elimination, and the swap, least squares, and the road not to take, two errors, and whose fault they are and eigenvalues, singular values, rank

Counting what cannot be looked at — randomised, and the guarantee that changes kind
The pivot that reads the units — elimination, and the swap
When the matrix is wrong too — least squares, and the road not to take
A factorisation with nothing to pivot for — elimination, and the swap
The sketch that is not the answer — randomised, and the guarantee that changes kind
The units the matrix is measured in — two errors, and whose fault they are
A condition number scaling cannot move — two errors, and whose fault they are
When symmetry is not enough — elimination, and the swap
An estimate that can be fooled — two errors, and whose fault they are
The cheap rank and what it cannot see — eigenvalues, singular values, rank
The eigenvalues that are not there — eigenvalues, singular values, rank
A spectral radius that grows first — eigenvalues, singular values, rank

17 August 2026

12 essays on regularisation, and the answer that is chosen, where the flop count stopped predicting the time, methods that were designed apart, eigenvalues, singular values, rank, iterating, instead of factorising and the arithmetic underneath

The basis decides what a filter is — regularisation, and the answer that is chosen
Doing it twice — where the flop count stopped predicting the time
The step that stops mattering — methods that were designed apart
A parameter chosen on a smaller problem — methods that were designed apart
Memory bought with messages — where the flop count stopped predicting the time
Keeping the vectors, and losing the bound — eigenvalues, singular values, rank
How wide the block should be — eigenvalues, singular values, rank
The formula that was already optimal — iterating, instead of factorising
Where the box is cut — the arithmetic underneath
One sequence and two recurrences — iterating, instead of factorising
Exact along one axis — iterating, instead of factorising
The direction the diffusion does not go — iterating, instead of factorising

15 August 2026

12 essays on methods that were designed apart, structure, and the solver that cannot see it, where the flop count stopped predicting the time, eigenvalues, singular values, rank, the arithmetic underneath and iterating, instead of factorising

A parameter that counts steps — methods that were designed apart
Four knobs and one floor — methods that were designed apart
The part of a solver that may be rounded — methods that were designed apart
An answer that changes with the seed — methods that were designed apart
The circulant that cannot be indefinite — structure, and the solver that cannot see it
The message and the word — where the flop count stopped predicting the time
Two dimensions, and the cluster that thins — structure, and the solver that cannot see it
Restarting is a filter — eigenvalues, singular values, rank
An eigenvalue one vector cannot see — eigenvalues, singular values, rank
Proving the answer is in the box — the arithmetic underneath
The diffusion that makes the answer exact — iterating, instead of factorising
Aggregating what the matrix calls strong — iterating, instead of factorising

14 August 2026

12 essays on structure, and the solver that cannot see it, where the flop count stopped predicting the time, regularisation, and the answer that is chosen, the arithmetic underneath, iterating, instead of factorising and eigenvalues, singular values, rank

The matrix that is one row — structure, and the solver that cannot see it
The same arithmetic at a different price — where the flop count stopped predicting the time
When the answer is a choice — regularisation, and the answer that is chosen
A block size is a property of the machine — where the flop count stopped predicting the time
A limit the matrix never reaches — structure, and the solver that cannot see it
Where the answer stops being in the data — regularisation, and the answer that is chosen
A preconditioner that changes sign — structure, and the solver that cannot see it
A reduction that changes the order — where the flop count stopped predicting the time
Choosing without knowing — regularisation, and the answer that is chosen
A bound that is proved — the arithmetic underneath
The stencil that is not symmetric — iterating, instead of factorising
An eigenvalue that arrives twice — eigenvalues, singular values, rank

12 August 2026

12 essays on the arithmetic underneath, iterating, instead of factorising and eigenvalues, singular values, rank

Eight bits, and a format that breaks the rules — the arithmetic underneath
The coarse problem is a different problem — iterating, instead of factorising
The gap decides the eigenvector — eigenvalues, singular values, rank
A direction the smoother cannot see — iterating, instead of factorising
The direction the error leans — the arithmetic underneath
The plane survives what its vectors do not — eigenvalues, singular values, rank
A coin flip that fixes the average — the arithmetic underneath
Smoothing a whole line at once — iterating, instead of factorising
Coarsening in one direction only — iterating, instead of factorising
One exponent for thirty-two numbers — the arithmetic underneath
The coarse grid the matrix chooses — iterating, instead of factorising
A hierarchy with no grid behind it — iterating, instead of factorising

10 August 2026

12 essays on sparsity, and what elimination costs, iterating, instead of factorising, eigenvalues, singular values, rank and the arithmetic underneath

Structure and stability stop being separable — sparsity, and what elimination costs
A threshold between fill and growth — sparsity, and what elimination costs
The error smoothing cannot reach — iterating, instead of factorising
The form a real matrix can reach — eigenvalues, singular values, rank
The other half of a format — the arithmetic underneath
What the symbolic phase can only bound — sparsity, and what elimination costs
A norm that overflows before it is a norm — the arithmetic underneath
The same problem on a coarser grid — iterating, instead of factorising
Two shifts that are never formed — eigenvalues, singular values, rank
A condition number for one eigenvalue — eigenvalues, singular values, rank
A rate that does not notice the size — iterating, instead of factorising
The numbers below the smallest one — the arithmetic underneath

6–8 August 2026

34 essays on randomised, and the guarantee that changes kind, elimination, and the swap, orthogonality, measured, eigenvalues, singular values, rank, two errors, and whose fault they are, sparsity, and what elimination costs, least squares, and the road not to take, iterating, instead of factorising and the arithmetic underneath

A bound that holds with probability — randomised, and the guarantee that changes kind
Elimination is a sequence of choices — elimination, and the swap
Orthogonal is a number — orthogonality, measured
Symmetry is worth more than precision — eigenvalues, singular values, rank
The exact answer to a nearby problem — two errors, and whose fault they are
The factor is not sparse — sparsity, and what elimination costs
The projection and the right angle — least squares, and the road not to take
The rate the condition number predicts — iterating, instead of factorising
What a float can hold — the arithmetic underneath
A small residual is not a small error — two errors, and whose fault they are
An orthogonalisation nobody calls one — iterating, instead of factorising
Cancellation takes the answer, not a digit — the arithmetic underneath
Rank is a decision — eigenvalues, singular values, rank
The dimension does not appear — randomised, and the guarantee that changes kind
The order decides the memory — sparsity, and what elimination costs
The road that squares the problem — least squares, and the road not to take
The swap that is not optional — elimination, and the swap
Two Gram–Schmidts — orthogonality, measured
A reflection cannot stop being one — orthogonality, measured
Changing the condition number on purpose — iterating, instead of factorising
Randomisation does not create structure — randomised, and the guarantee that changes kind
The best approximation there is — eigenvalues, singular values, rank
The bound that is never attained — elimination, and the swap
The condition number is an amplifier — two errors, and whose fault they are
The order they are added in — the arithmetic underneath
The valley with no bottom — least squares, and the road not to take
Two ends of the same arrow — sparsity, and what elimination costs
An answer that is known — two errors, and whose fault they are
Buying the accuracy back — the arithmetic underneath
The algorithm the libraries actually run — eigenvalues, singular values, rank
The spectrum that predicts nothing — iterating, instead of factorising
A rate that is known in advance — iterating, instead of factorising
The form that makes it affordable — eigenvalues, singular values, rank
Where the hardware went — the arithmetic underneath

Every essay, by subject · by subject · by thread · search