Speedrunning is even more like computer science academia. Speedrunners optimize, they solve traveling salesperson problems, and they are perhaps the only part of civil society interested in computing lower bounds. What's more, is that speedrunning too has a sort of conference system.

This weekend I got to perform at Games Done Quick (GDQ), perhaps the world's biggest stage for playing videogames fast. It is every speedrunner's dream to be on that stage.

Just like an academic conference, you can submit your best work, and a program committee will decide which submissions will be included in the event. This year GDQ had its event in Europe, at Gamescom in Cologne Germany. Because of that proximity, I submitted a run together with my friend Chelsea. Our submission was a run of Hades II (Supergiant Games, 2025) in the Fresh File category. As an extra hurdle, we played this single player game with two players on one controller (2P1C). I press most of the buttons, Chelsea does everything else including movement and aiming.

I was more nervous about this submissions than any paper I ever submitted, but we got accepted! What's more, our run was being highlighted in the Gamescom promotional emails.

Unlike an academic conference, your performance at the event is the only part that counts. And unlike in practice, you only get 1 shot at it. After the notification came in early June, we had just 3 months to prepare. Chelsea and I live in different countries, so finding practice time was an undertaking. However we are an experienced duo, having 2P1C runs on the official leaderboards in 4 different categories^[1][2][3][4].

To give the best possible show, we prepared a host of things. We procured two mods for the game: one to respawn us in place if we died (its a difficult game but the show must go on), and a second one to rig the first crucial coin flip in our favor. Besides that, we strategized lots. Which boons do we want to see, and which ones should we exclude because of their added unpredictability and cognitive load? Which flashy strategies can we try to show off, and where do we need to prepare dedicated safe strategies instead? Hades II is a roguelike game, which means that randomness can make or break your day. We needed to have a plan for every eventuality.

Last week was Gamescom, with GDQ taking place friday through sunday. GDQ gave us runners free tickets for all three days. Chelsea and I would play on sunday, so we had two days to simply watch and experience the event. Gamescom itself, I did not care for. It is unbelievably crowded, not a good time. But attending GDQ in-person (instead of through the usual live stream) was a joy. When you're there in the audience, everything hits that much more. The clutch moves are that much more exciting. The funny bits are that much funnier. (And to be honest, seeing that the other runs didn't always go perfectly did a lot to soothe our nerves about our own run.)

Just like an academic conference, meeting the people in your community makes everything more fun.

On sunday it was our turn. After Donkey Kong Country and Skylar & Plux, before Silksong and OOT Blindfolded. The GDQ staff was amazing, they are a well-oiled operation handling all the complexities of audio, video, computers, German internet connections and livestreaming. After we were in place with all the setup, it was time to play. The game had it out for us, but Chelsea and I were able to put on a good show with the help of our commentator Dr Omega. Check out our show in the embed below or at this link.

I am super grateful to Chelsea for playing with me and being such a good friend, to GDQ for coming to Europe and for the opportunity to have a dream come true, and to Dr Omega for the stellar commentary.

[1]	Hades 1 Fresh File

[2]	Hades 1 Loyalty Card (Routed)

[3]	Hades 2 Fresh File (early access patch 3)

[4]	Hades 2 Fresh File (release version)

Web Search

Most people agree that Google is worse now than it was a decade ago. Some people blame SEO, some blame LLMs. I think Ed Zitron is right when he describes the degradation is intentional on Google's part: enshittification at work.

Still, search is now a fundamental part of how we interact with the web and we want something that works. One remedy I have heard is to use LLMs as a search engine. This is highly dubious practice in my view. Even the best models would sooner lie to your face than accurately describe the contents a simple web page.

My recommendation is a search engine called Kagi. It is truly great. As good as Google was back in the day I find that Kagi consistently yields high quality and authorative sources while returning a minimum of spam and AI slop. I started using this product already back in 2023 and I recommend it to everyone.

One feature worth pointing out: Kagi search is a paid product. I pay 5 dollars plus tax for up to 300 searches per month (which is more than enough). Because the user pays, the user is the customer. This is unlike Google, DuckDuckGo, or most other search engines, where the user is the product. You can feel the difference in how you are treated. Six dollars is a small price to pay for a functioning web.

Syndication

Second recommendation is an oldy but goldy: get yourself an RSS reader. It is astounding the number of people I talk to (young or old) who do not use one of these.

RSS is a web protocol thingy, and almost every website participates. You can load special RSS urls into a software called an RSS reader, and the software will put all the new updates from all your subscribed websites into a chronological feed.

RSS is an amazing technology. You can follow your favorite newspaper, get your daily xkcd comic, and follow the latest papers in your ArXiv categories all in the same software. Every time you find a cool website, you can easily subscribe. That way you slowly build your own personal chronological feed of cool things and stay up-to-date with all you care about.

There are a lot of good RSS readers out there, either local on your device or as a web app. I like Inoreader, they have a comfortable free tier. Do not worry about vendor lock-in: every RSS reader I know allows to export your list of feeds to a .ompl file which you can use to move to a different product.

I recommend you install a browser add-on to more easily find the RSS feed for a given webpage. On Firefox a good one is Want My RSS, which puts a little logo in the address bar when a feed is available. On Chrome I will not recommend anything, I don't like them because they are destroying their add-on ecosystem as we speak. But perhaps you can find something there too.

If you are a colleague in theoretical computer science, subscribe to theory.report to stay up-to-date with all the bloggers in the community. On arXiv they have separate feeds per category and subject class you can subscribe to. RSS is by far the easiest way to see all new papers coming out. If you are in optimization, note that Optimization Online also has a feed.

One thing I mentioned was that the standard Klee-Minty cube is stable under zero-preserving perturbations. Someone asked me for a proof. Since there is currently no written source for this lore, I will write a quick proof here.

Let's start with some traditional Klee-Minty cubes:

Assume the inequalities are ordered as shown: first we list both inequalities for \(j=2\) and then both inequalities for \(j=3\) and so on.

We shift the means slightly and then perturb all non-zero coefficients. This yields a linear program

Theorem. If \(\alpha,\beta,\gamma,\delta,\varepsilon,\eta \in [-0.05,0.05]^d\) then Bland's rule takes exponentially many pivot steps.

Proof. We go by induction. We prove that there are exactly \(2^d\) bases, and Bland's rule will visit all bases when it starts at the basis minimizing \(x_d\) and works to maximize \(x_d\). All basic feasible solutions \(x\) satisfy \(x \in [0,1]^d\). The Bland path is reversible: if we start at the basis maximizing \(x_d\) and we use Bland's rule to minimize \(x_d\) then the same bases are visited but in reverse order.

We can check the base case \(d=1\) easily. The starting basis consists of the constraint \(0.1 + \alpha_1 \leq (1+\gamma_1)x_1\) and the end basis consists of the constraint \((1+\delta_1)x_1 \leq 0.9 + \varepsilon_1\). The two basic feasible solutions \(\frac{0.1 + \alpha_1}{1+\gamma_1}\) and \(\frac{0.9+\varepsilon_1}{1+\delta_1}\) are easily verified to be in \([0,1]\).

When \(d \geq 2\), assume that the induction statement has been proven for \(d-1\). The starting basis for \(d\) consists of all lower-bounding constraints: \(0.1 + \alpha_1 \leq (1+\gamma_1)x_1\) and \(0.1 + \alpha_j + (0.2+\beta_j)x_{j-1}\leq(1+\gamma_j)x_j\) for all \(j \in \{2,\dots,d\}\).

Take the Bland path for \(d-1\), and append to every basis in it the constraint \(0.1 + \alpha_j + (0.2+\beta_j)x_{j-1} \leq (1+\gamma_j)x_j\). These bases are now bases for the KM-cube in \(d\) variables. The associated basic solutions are identical on coordinates \(1,\dots,d-1\) and have \(x_d = \frac{0.1 + \alpha_j + (0.2+\beta_j)x_{d-1}}{1+\gamma_j}\). The Bland path for \(d-1\) contains \(2^{d-1}\) bases and increases the value of \(x_{d-1}\) in every step. Since \(1+\gamma_d \in [0.95,1.05]\) and \(0.1 + \alpha_d \in [0.05,0.15]\) and \(0.2 + \beta_d \in [0.15,0.25]\) and \(x_{d-1} \in [0,1]\) we get \(x_d \in [0, 0.43]\).

When we consider the constraint \((1+\delta_d)x_d \leq (0.9+\varepsilon_d)-(0.2+\eta_d)x_{d-1}\), we see that the left-hand side is at most \(1.05 \cdot 0.43 \leq 0.46\) and the right-hand side is at least \(0.85-0.25 = 0.6\). That is all we needed to check in order to verify that the bases constructed so far are feasible.

Every step on our path so far is improving. Due to our chosen ordering of the inequalities, the constraint \(0.1 + \alpha_j + (0.2+\beta_j)x_{j-1} \leq (1+\gamma_j)x_j\) will not leave the basis until there is no other possible improving direction left. Hence our path so far is all part of the Bland path for our KM-cube in \(d\) variables.

At the end of our path so far, Bland's rule will pivot out the constraint \(0.1 + \alpha_j + (0.2+\beta_j)x_{j-1} \leq (1+\gamma_j)x_j\) and pivot in \((1+\delta_d)x_d \leq (0.9+\varepsilon_d)-(0.2+\eta_d)x_{d-1}\), since it is the only available improving move.

Now take again the Bland path for \(d-1\), but reverse its order and append to every basis in it the constraint \((1+\delta_d)x_d \leq (0.9+\varepsilon_d)-(0.2+\eta_d)x_{d-1}\). This yields \(2^{d-1}\) more bases for the \(d\)-variable KM-cube. Because we reversed the order, the Bland path is decreasing \(x_{d-1}\). Since \(0.2+\eta_d > 0\) and \(1+\delta_d > 0\), the path is thus increasing the value of \(x_d\). We have now constructed our full Bland path of \(2^d\) bases. It remains to show that these final \(2^{d-1}\) bases are feasible and in \([0,1]^d\). Note that \(1+\delta_d \in [0.95,1.05]\), \(0.9+\varepsilon_d \in [0.85,0.95]\) and \(0.2+\eta_d \in [0.15,0.25]\). Since \(x_{d-1} \in [0,1]\) we get \(x_d = \frac{0.9+\varepsilon_d - (0.2+\eta_d)x_{d-1}}{1+\delta_d} \in [0.57, 1]\). The only constraint that can lead to infeasiblity is \(0.1 + \alpha_j + (0.2+\beta_j)x_{j-1} \leq (1+\gamma_j)x_j\) but its left-hand side is at most \(0.4\) and its right-hand side is at least \(0.57\), hence the bases are all feasible. QED

Interpretation

This theorem directly shows us that Bland's rule has exponential complexity under both relative and zero-preserving smoothed analysis. When we rescale the inequalities by large numbers in the standard way, it follows directly that Dantzig's most-negative reduced cost rule has exponential complexity for relative smoothed analysis.

In my previous post I interpreted the above theorem by stating that zero-preserving smoothed analysis is a dead end. While I stand by that statement, I do want to give a second possible interpretation.

Namely, you can conclude that Bland's rule is just bad.^[1] More specifically: Bland's rule is purely combinatorial in nature. Perturbations are (stochastic) geometry. It is no wonder that Bland's pivoting decisions fail to benefit from perturbations. Dantzig's rule is also bad of course. In this case, specifically because it fails to be scale-invariant with respect to rescaling the inequalities. Dantzig thus similarly fails to be a geometrically-steered pivot rule.

When your pivot rule does incorporate the ambient geometry, you can do significantly better than zero-preserving smoothed analysis. In fact, in the by-the-book paper we bound the running time of a simplex method in a much weaker probabilistic model: only the right-hand side is perturbed.^[2] That is part of why we are so proud of the BTB paper: its both mathematically stronger and scientifically more robust than what we had before.

UPDATE 30/07/26

I did a bit more lit search after posting. Tuns out that Bland's rule was already mentioned to have exponential running time under zero-preserving smoothed analysis, as mentioned in Dan Spielman's lecture notes from 2002! A slightly different model was studied by Miranda Christ and Mihalis Yannakakis, who perturb the non-zero transition probabilities in an MDP. They find MDP's with \(n\) states for which adversarial zero-preserving perturbations of magnitude at most \(1/n\) take time \(2^{\sqrt{n}}\) to be solved when using a simplex method with Dantzig's pivot rule on the standard LP formulation.

[1]	Every practitioner will agree.

[2]	We use the semi-random shadow vertex pivot rule, which generally prefers steeper edges over shallower edges. Hence it incorporates the ambient geometry. The analysis also needs some additional minor assumptions to make the definitions make sense: RHS perturbations alone lack scale.

Theoretical computer science has given us many great pieces of theory, predominantly following the classic modeling paradigm called 'worst-case analysis'. Under this paradigm, we specify a single algorithm (or class of algorithms) with mathematical precision and rigor, along with the set of valid inputs. A worst-case analysis then attempts to find the worst-possible performance of the algorithm (in time, memory, or output solution quality). We describe that worst-case performance as a function of the size of the input, often counted as the number of bits or number of numbers. In some parts of computation, whether modern or undergrad curriculum, worst-case analysis is a useful paradigm for understanding your algorithm's performance.

Other parts of computation spit in the face of theory. Paging, SAT, graph coloring, linear programming, mixed-integer linear programming, clustering, traveling salesperson. Each of these works better, is solveable faster, or returns better quality solutions than what worst-case analysis would predict. SAT and MILP are NP-hard in theory. In practice they are easy.^[3] The simplex method for linear programming runs in exponential time under worst-case analysis. In practice its blazingly fast.^[4]

We need different approaches, new modeling strategies. And the problem is, mathematicians like us are poorly equipped to think critically about what we do. Nobody believes in average-case analysis. But also smoothed analysis is kinda bullshit,^[5] even if people still believe in it.^[6]

So let me describe you how I got radicalized against smoothed analysis, so that you too can stop falling for its cursed allure. These arguments mostly come from discussions with my PhD student Eleon Bach. They were published in this paper but here on the blog I can write with more zest.

Hypersparsity

Real-world linear program constraint matrices have a property called hypersparsity. For one, that means that the matrix is very sparse: 99.99% of matrix entries are zero (and thus not even stored in memory). Only 0.01% is non-zero. This is important for real-world codes: the simplex method is memory-bound, so if you destroy all zeroes then your running time blows up. The instances we study in smoothed analysis have no sparsity: with probability 1, all entries of the matrix are non-zero. This is bad.

The second part of hypersparsity is the structure of the non-zeroes: most non-zero matrix entries share a handful of values. Most entries are probably equal to 1, but even among the remaining entries there are only a limited number of unique values. This is a problem for smoothed analysis: almost surely, all entries have distinct values. This is bad.

Worst-case instances are sparse and stable

So smoothed instances do not look like real-world instances for sparsity reasons. This is unlike worst-case instances: the Klee-Minty cubes are hypersparse. Looking purely at the patterns in the constraint matrix, one would assume that KM-cubes are more like real-world instances than smoothed analysis instances are.

You may think "could we do smoothed analysis in a sparse way? We could only perturb the non-zero entries in the input data". This thought puts you in good company: Spielman and Teng propose the same thing. Too bad its a dead end. If you choose the parameters right, then the behavior of the KM-cube is stable under constant-magnitude zero-preserving perturbations. That is, the zero-preserving smoothed complexity of the simplex method (with the most-negative reduced cost pivot rule) is exponential.

Even imprecise numbers are precise

Next issue. Some linear programs do contain numbers that 'look inaccurate': numbers like 15.79081 or 43.15593. Maybe those numbers contain some type of independent Gaussian noise to make them look like that? I don't think so. If you allow yourself to change such 'ugly' numbers by as little as 0.01% then the previously-optimal solution will violate some constraints by as much as 50%. This holds for 13 out of 90 NETLIB instances, quite a large amount.^[7] Feel free to disagree with my interpretation, but I personally think that means that the 'ugly random-looking numbers' have important non-trivial relations between eachother. Hence they cannot be changed in isolation. This would violate a key assumption of smoothed analysis: that all random noise entries are independently distributed.

Singular matrices should stay singular

In a typical LP, not every maximal square submatrix is a basis. Some submatrices are singular. Singular submatrices are good: the simplex method will never pivot to them, so they don't cost any extra time. If you add small random Gaussian noise to your constraint matrix, then every submatrix will be basic. This is a disaster: what used to be a singular submatrix (good) is now a basic submatrix with high condition number (very bad).

If you read your favorite solver's user manual or talk to their helpdesk, you will learn this: please write your input data in maximum precision. Use integer numbers if you can, or 64-bit floats if you must. Do not use 32-bit floats, for they are too imprecise and that imprecision hurts solver performance. One reason that is given for this advice is what I say above: low precision may cause nominally singular submatrices to pass the threshold and become basic. A basis with high condition number will ruin your numerical stability and your simplex method performance along with it.

So: smoothed analysis says 'more noise (less precision) is good'. The user manual says 'more precision is good'. Smoothed analysis is wrong, the user manual is correct.

Philosophical incoherence

Final issue. In smoothed analysis, we assume that there is an idealized piece of input data which gets perturbed by random noise added after its formulation. What is this noise? Where does it come from? What does it model?

Some people suggest the noise as modeling floating-point inaccuracy, implicitly advocating for a value of \(\sigma = 2^{-53} \approx 10^{-16}\) as per IEEE 754. Other people speak of the noise as modeling measurement error, which would endorse a value of \(\sigma \approx 10^{-2}\). This disagreement is ridiculous. Imagine admitting this to a real scientist, like a physicist: "yeah we have a theoretical understanding, except we don't agree what our model models and our opinions about the central parameter's value differ by 14 order of magnitude." Not a good look.

Smoothed analysis is trash

So that's the deal, those are the arguments that radicalized me against smoothed analysis for LP. Its instances don't pass the most basic sanity checks, its conclusions seem to contradict the user manual ground truth, and the whole theory lacks a coherent philosophical grounding.

This all leaves a crucial question: how should one analyze an algorithm when worst-case analysis fails? At the workshop we had talks from different subfields, and people had different partial answers to this question. Some people went deeper into the theory, other people proposed to engage more with computational experiments in one form or another. Some people thought that a good analysis method would be broadly applicable, others were happy to exploit more problem-specific features. This is an exciting set of questions and a lively research field.

For the simplex method, by far the best current analysis framework is by-the-book analysis, our new baby (STOC '26). It is not perfect but it is a big step up from all that came before.

I am curious to see where all the workshop's topics and participants will go next. Although none of us has all the answers, we are all making progress.

[1]	For an overview of items falling under this umbrella, take a look at this book edited by Tim Roughgarden and use password 'BWCA_CUP' to open it.

[2]

I am not pulling any punches today. The literature doesn't capture people's feelings, and normally you can only observe those by attending an IRL event. However, events like this workshop, broadly scoped on BWCA in its entirety, happen only once every 12 years and only permit 25 attendees. As such, you probably don't often hear the spicier takes. This blog post collects a few more critical notes, some mine and some taken from others. Don't get discouraged by any of this criticism: it applies to everyone's work, including my own. I built my career on doing smoothed analysis of the simplex method, so mostly I am throwing in my own windows here. The point is to reflect critically, and sometimes that is easier when we don't mince our words. Anyway, see for yourself what you can get out of this blog post: use it to help develop your own sense of critical evaluation. Nobody trains us mathematicians how to do this, and we gotta learn somehow.

[3]

Crafting hard instances is not difficult. But somehow, we have reams and reams of practical real-world instances which are easy to solve. Electronics designs get verified bug-free by showing that huge boolean formulas are UNSAT. Swathes of global shipping and manufacturing get planned by solving MIPs. 10k variables is tiny for these solvers, but should be huge for any true believer in NP-hardness.

[4]

For the simplex method, crafting hard instances is difficult. What I mean by that is, crafting numerically unstable instances is easy and your solver will struggle with those. But instances without numerical problems, but which do exhibit super-polynomial running times on real physical IEEE 754 compliant computer hardware? Constructing those is an open research problem.

[5]

At least it is trash for the context of studying linear programming, as I will lay out in this blog post. For other algorithms and applications areas, these arguments may not apply. Maybe for your problem, smoothed analysis is fine. I invite you to consider this matter critically in the context of the algorithm you study.

[6]

People really did believe in this theory. Spielman and Teng's Gödel Prize citation claims that smoothed analysis "provides a new rigorous framework for explaining the practical success of algorithms". Those are big claims: not only is it rigorous (mathematically? scientifically? who knows), but it provides actual explanation!

[7]	These facts are taken from this book, although the authors give a very different interpretation of what these same facts mean.

Human computers of the Mathematical Tables Project, where the 1948 diet LP computation was performed.

Even after this demonstration, a number of real applications of LP were performed by hand. Lets look a bit of a timeline for electronic computers first. The first specialized simplex method for transportation problems^[3] was coded in 1950 for the SEAC. In 1952, Orchard-Hays got the first simplex code working on the IBM Card Programmed Calculator, and later on the more recognizeable IBM 701 machines. These early hardwares and softwares were very error-prone and needed a lot of highly-skilled babysitting, but Orchard-Hays' later codes were commercially useful.

Charnes, Cooper and Mellon famously presented the first work on LP in fossil fuel blending in 1951. They do not directly specify, but we can be fairly sure that their computation was done by hand. Although the LP had no workable structure that aided computation, it was fairly small problem: maybe 9 inputs, 6 outputs.

Dantzig writes in 1954^[4] that often, when studying a particular structure of LP, human hands with a specialized algorithm were faster than an electronic computer with a general LP code. For example, a transportation problem^[3] with a hundred combined rows (sources) and columns (sinks) can be 'handled nicely by clerks'. Dantzig writes that already in 1953, Heinz^[5] used LP to ship ketchup from 6 plants to 70 warehouses. We can be fairly sure that a small transportation problem like this was solved by hand. And this is presumably without the 1956 Ford-Fulkerson algorithm.

One other application of a transportation problem solved by hand is described in 1955^[5]. The RAND Corperation employed a large number of computers,^[6] as well as many researchers who had computations they wanted to see performed. In order to form a schedule that takes both priority and urgency into account, a transportation problem was formulated. Every week has a number of computer-hours available, every tasks needs a certain hours before it is completed. Dantzig gives an example where one has 18 projects and 10 weeks, resulting in a problem with 28 equations in 180 unknowns. He adds upper bounds of 40 hours on the individual edges to indicate that only one person can work on a project at a time.

This is perhaps the ultimate showcase that human computers remained important well into the mid-1950s: humans were solving an LPs, by hand, to decide in what order the different computing tasks should be solved (also by humans).

[1]

Date is from the NBS report. Note the involvement of famous matrix theorist Olga Taussky-Todd. I am not aware of any other document crediting her involvement with LP or computation. I asked David Alan Grier about this, he speculated that perhaps Taussky-Todd did not want to be credited: computation was seen as low-skilled (women's) work, and Taussky-Todd may not have felt comfortable being associated with that.

[2]	Correspondence from Dantzig to Von Neumann. The 5 computers were supervised for 4 hours per day by Jack Laderman. Note that only Laderman is credited by name, not the computers and not Taussky-Todd.

[3]	Given a bipartite graph, with supplies of a commodity available on the one side and demands on the other side, how to route the goods at minimal cost?

[5]	Recent Advances in Linear Programming, Dantzig, April 12th, 1955.

[6]	Dantzig writes "The RAND Corporation has extensive computing facilities that are in constant use by the research personnel." Despite how he phrases it, he is talking about human being here.

[4]	Status of Solution of Large-Scale Linear Programming Problems, Dantzig, November 30th, 1954.

1. collect your papers together for easy perusal

2. show who your advisor and advisees are (this helps editors know if you have a conflict of interest as a potential reviewer)

3. picture (people want to recognize you at events)

4. email address (so that your colleagues can reach you)

If you are a PhD student, and you have at least one paper online, then you should make your own website right now.

My first website was made using Academic Pages. It worked well enough, until one day in 2023 Jekyll started screaming and stopped compiling. Since then I have been writing html by hand. Starting today, I want to try something new. I rebuilt my website using Frankin. Its another static website generator, with easy support for LaTeX and code highlighting. I host my website through GitHub Pages, linked to my own domain name.

With the new Franklin tech, I want to start blogging. They say its good to practice your writing frequently. The first few posts will be information that I have tweeted before. Putting that into more a more archive-friendly and longer form format will be my first step towards making it into something useful.

At least, I think I will. Depends on how well this Github Pages deployment with the new tech will go lmaosob