Algorithms on CS Theorems

Work Stealing and Fair Scheduling

Fri, 17 Dec 2027 12:00:00 +0100

Symptom

You parallelize a recursive algorithm. Quicksort, or a tree traversal, or a divide-and-conquer numeric kernel. You have 16 cores and a central task queue, and you measure a speedup of 3.

Resolution and CDCL

Fri, 10 Dec 2027 12:00:00 +0100

Symptom

SAT is NP-complete (T027). It is the NP-complete problem, the one everything else reduces to. The textbook conclusion is that you should avoid it.

Meanwhile: a hardware verification team routinely discharges instances with two million variables and ten million clauses in under a minute. Package managers solve dependency resolution with SAT. Every bounded model checker (T049) is a SAT solver with a front end. The planning community abandoned custom search for SAT encodings and got faster.

Register Allocation Is Graph Coloring

Fri, 03 Dec 2027 12:00:00 +0100

Symptom

You write a function with forty local variables. The x86-64 machine it runs on has sixteen general-purpose registers, two of which are effectively spoken for.

Something must decide which values live in registers and which live in memory. Get it right and the function runs at register speed. Get it wrong and every operation costs a load and a store, and on a modern machine an L1 hit is around 4 cycles against roughly 1 for a register, with an L2 miss costing 12 to 20 and a trip to DRAM 200 or more.

The Exponential Time Hypothesis and Fine-Grained Complexity

Fri, 16 Jul 2027 12:00:00 +0100

Symptom

You have a string algorithm. Edit distance between two sequences, the classic dynamic program, $O(n^2)$ time. It has been in production for years.

Now the inputs are genome-scale. At $n = 10^5$ characters, $n^2 = 10^{10}$ operations, about 10 seconds at a billion ops per second. At $n = 10^6$ it is $10^{12}$ operations, about 1000 seconds — seventeen minutes for one pair of strings. You need to do a million pairs.

Parameterized Complexity (FPT and W[1])

Fri, 21 May 2027 12:00:00 +0100

Symptom

Your problem is NP-hard, and yet it keeps being easy.

You are computing a minimum vertex cover to select monitoring points in a network. Twelve thousand nodes. NP-hard, per T028, so you brace for the worst — and the answer comes back in under a second, every time. The cover is small, around thirty nodes, because the network is sparse and the interesting nodes are few.

Approximation Algorithms and Ratios

Fri, 14 May 2027 12:00:00 +0100

Symptom

You have accepted that the problem is NP-hard. Now what?

The literature offers a wall of results with numbers attached: 2-approximation, $\ln n$-approximation, PTAS, FPTAS, 0.878. Nobody explains what these numbers buy you, how they are proved, or how they connect to the heuristic you already wrote. Meanwhile your greedy heuristic is running in production and you have no idea whether it is within 5% or a factor of 50 of optimal, because you cannot compute the optimum to compare against — that was the whole problem.

Streaming Lower Bounds and Sketching

Fri, 30 Apr 2027 12:00:00 +0100

Symptom

Product wants the daily unique-visitor count. You have a firehose of events.

The obvious implementation is a set. Add each visitor ID, report the size. At a billion distinct IDs, eight bytes each, that is 8 GB before any hash table overhead, and in practice a HashSet will cost you two to three times that. Per day. Per dimension you want to slice by. Multiply by country, by platform, by campaign, and the memory bill is absurd for a number nobody looks at past two significant figures.

Universal Hashing

Fri, 23 Apr 2027 12:00:00 +0100

Symptom

Your service went down under a hash collision attack.

Somebody noticed your web framework put POST parameters into a hash table, found thousands of distinct keys colliding under its hash function, and posted a form with 20,000 of them. Every insert walked a chain. Quadratic behaviour, one CPU pinned per request, service dead. This actually happened, across PHP, Python, Ruby, Java and .NET in 2011, and again against Rust’s default HashMap before it switched to SipHash.

Karp's 21 Problems

Fri, 26 Mar 2027 12:00:00 +0100

Symptom

Three weeks into a project, you are still trying to write an exact algorithm.

The problem is yours and it looks specific: assign delivery vans to routes such that every stop is covered, no van exceeds its capacity, and the total distance is minimized. Nothing in the literature matches it exactly. So you keep going — better data structures, smarter pruning, a cleverer greedy pass with a repair step — and each version works on your test set and falls over on production data.

Huffman Coding Is Optimal

Fri, 19 Feb 2027 12:00:00 +0100

Symptom

You are compressing a log file. The symbols are wildly skewed: INFO is 90% of the lines, WARN is 9%, ERROR and FATAL split the rest. Fixed-width two-bit codes give you exactly 2 bits per symbol, and entropy (T018) says the floor is about 0.53 bits. There is a factor of four sitting there.

Concentration Bounds (Chernoff/Hoeffding)

Fri, 18 Dec 2026 12:00:00 +0100

Symptom

Your service handles four billion requests a month and you want the error rate. Computing it exactly means a job over four billion log lines. Someone suggests sampling ten thousand of them.

Amortized Analysis and the Potential Method

Fri, 11 Dec 2026 12:00:00 +0100

Symptom

You have a dynamic array. push writes one element and bumps a counter, which is clearly $O(1)$ — except when the array is full, in which case it allocates a new buffer of twice the size, copies every element across, and frees the old one. That is $O(n)$.

Adversary Arguments

Fri, 04 Dec 2026 12:00:00 +0100

Symptom

You need the largest and second-largest element of an array. The obvious way is two passes: $n-1$ comparisons for the max, then $n-2$ for the max of the rest. That is $2n - 3$.

Linearity of Expectation

Fri, 27 Nov 2026 12:00:00 +0100

Symptom

You are analyzing a hash table. You want the expected number of buckets that end up empty. The bucket occupancies are all tangled together — one key landing in bucket 3 makes every other bucket slightly less likely to be chosen — and the dependencies look like they will make the sum intractable.

The Omega(n log n) Comparison-Sort Bound

Fri, 20 Nov 2026 12:00:00 +0100

Symptom

Every general-purpose sort in every standard library is $O(n \log n)$. Timsort, introsort, pdqsort, merge sort, heapsort. Decades of work by extremely motivated people, an enormous amount of money riding on it, and they all land on the same exponent.

The Pigeonhole Principle

Fri, 28 Aug 2026 12:00:00 +0200

Symptom

You are asked to build a cache key. You have a 64-bit hash, and someone on the team says: “collisions are basically impossible, there are eighteen quintillion values.”

Or: your service assigns short IDs to uploads, six characters of base-36, and you are wondering when you need to worry.