The Unproven Law Hiding in a Cup of Coffee

In September 2011, theoretical computer scientist Scott Aaronson attended an FQXi conference on the nature of time—held aboard a cruise ship sailing from Bergen, Norway, to Copenhagen, Denmark. During Sean Carroll's opening talk, a slide appeared: three cups of coffee. The first was cleanly split into black and white, structurally simple. The second showed milk and coffee swirling into intricate tendrils—the most visually interesting. The third was a uniform grey, indistinguishable from nothing in particular. Entropy increased monotonically from left to right, but "interestingness" seemed to peak at the middle cup.

The slide became widely shared. Few knew that the middle cup wasn't simulated. Carroll later admitted in his blog's comment section that the mixing pattern was made by poking at it with a spoon. Left alone, real milk slowly diffuses into a uniform grey—monotonous, boring, no tendrils. Tendrils require stirring, and stirring is an external force. That detail matters: the universe we intuitively imagine as "getting complex, then simple" is itself being stirred by something.

Carroll's question was clean: the second law of thermodynamics says entropy only increases, so why does *complexity* appear to rise and then fall? The universe begins as a low-entropy particle soup and ends as a high-entropy particle soup, yet in between lie galaxies and brains. Is there a "first law of complexodynamics" explaining this hump-shaped curve?

Aaronson went home and wrote a blog post that performed careful surgery—not on an answer, but on the question itself.

First, fix the word "complex"

The problem sounds philosophical; Aaronson's treatment was purely technical: find a computable stand-in for "complexity."

The first candidate, Kolmogorov complexity (the length of the shortest program describing a string), fails directly: a string of perfectly random static has maximal Kolmogorov complexity, yet you wouldn't call static "complex" or "interesting"—it has no structure. This ruler measures incompressibility, but we want one that scores low for both simple and random things, and high only for that in-between category of "structured but not simple."

The second candidate is *sophistication*, which separates structure from randomness using a two-part code: find the shortest program describing a set S such that the target string x belongs to S and is a typical random element of it; the length of this "model" is the sophistication. The all-zeros string gets a trivial model and scores zero; a random string's model is "all strings of this length," also zero; only genuine structure costs bits to describe. The concept traces to Koppel and to Gács, Tromp, and Vitányi—the direction was right.

But for dynamical systems both rulers hit a wall. Aaronson pointed out: for a deterministic system, the state at time t can be described by three things—the initial state, the evolution rule, and the number t. The number t needs only log(t) bits. So no matter how long the system evolves, Kolmogorov complexity or sophistication can't outgrow a logarithm—whereas intuitively, complexity should swing polynomially with time. The root of the wall: descriptions can cheat, compressing an entire history into one formula plus a counter.

Aaronson's patch adds two locks. His "complextropy" is roughly defined as follows: the program describing set S must run in n·log(n) time—no lazy "initial state plus counter" programs that slow down as time passes—and the reconstruction side must finish within the deadline too. The "initial state + rule + t" description still exists, but its cost grows so fast with t that the time limit disqualifies it. With both locks on, the logarithmic wall disappears.

The conjecture can now be stated—the "first law" in the title: complextropy is near zero at the initial time, large at intermediate times, and returns to near zero once the system reaches equilibrium.

Aaronson's own words: "I don't yet know how to prove this conjecture." The post's contribution wasn't an answer—it was grinding the question into a shape that could be proved or disproved.

A comment-section argument that ran for a decade

Heavyweights arrived in the comments.

Charles Bennett (inventor of logical depth) entered at comment #110, proposing another candidate: logical depth—how long the shortest program generating an object must run. His intuition: the mid-mixing coffee tendrils are genuinely "deep," because any short program generating them must approximately simulate the whole mixing process; the equilibrium state can take shortcuts and be sampled directly, making it shallow.

Aaronson's skepticism was blunt: "I see no intuitive reason why depth should be large at intermediate times." His argument is worth unpacking: to generate an approximation of a tendril state, you only need to describe the boundaries between black and white regions (costing many bits—hence high sophistication), then sample pixels independently within each region (fast—hence low depth). A description can be "structurally expensive but temporally cheap." Depth and sophistication measure two different kinds of expensive.

The argument had no winner in 2011. Carroll contributed a coarse-graining idea at comments #6 and #7—blur the picture at the right scale, then measure Kolmogorov complexity. Luca Trevisan added an elegant generalization at #17: don't pick one scale—compute them all. Plot a three-dimensional "scale × time × complexity" figure, and the hump appears at intermediate scales and intermediate times. Scales too small show you entropy; scales too large collapse the coffee into a single cell with complexity identically zero.

Fourteen years later, the conjecture ran in an afternoon

In 2014, Aaronson and Carroll, together with Lauren Ouellette (then an MIT undergraduate—the student mentioned in the 2011 post), published a follow-up: simulating coffee mixing in a two-dimensional cellular automaton, defining "apparent complexity" as the Kolmogorov complexity of the coarse-grained approximate state (arXiv:1405.6903). Two results: for non-interacting particles, an analytic proof that complexity never grows; for interacting particles, numerical evidence that complexity peaks at a height on the order of the cup's horizontal size. Proving the interacting-particle hump analytically remains open.

The conjecture's core is directly reproducible with gzip—Kolmogorov complexity is uncomputable, but compressed file size is a crude upper bound, a standard stand-in in this field. A run: a 64×64 lattice, black on top and white on bottom, each step swapping a random adjacent black-white pixel pair until fully mixed, measured at nine time points across five coarse-graining scales.

The raw-pixel gzip curve shows no hump: rising monotonically from 39 bytes to 747 bytes, while the reference value for a random noise image is 744—a three-byte difference. Raw Kolmogorov complexity (even the gzip version) measures randomness, plain and simple; at full mixing it hits the noise ceiling. To see a hump, you must coarse-grain first.

At 4×4 blocks (a 16×16 image), the curve is textbook: starting at 27 bytes, rising to a 179-byte peak, then falling to 158 at equilibrium. Small-large-small—a clear hump. Better still, the scale dependence: at 2×4 blocks (too fine) the hump is barely visible; at 16×16 blocks (too coarse) the entire curve lies flat around 36 bytes. The hump lives only at intermediate scales—slicing Trevisan's predicted 3D figure gives exactly this. The peak occurs at about 30% of the mixing time, well before equilibrium.

One cup of coffee, one afternoon, a few gzip calls: all the phenomenology envisioned in the 2011 post. The entropy ruler only rises monotonically; the complexity ruler must first pick the right scale before the hump appears. The conjecture itself is still standing, waiting for a proof—Aaronson's problem now belongs to whoever comes next with a faster compressor and a bigger lattice.

---

*Sources: Scott Aaronson, "The First Law of Complexodynamics" (Shtetl-Optimized blog, 2011-09-23, with comments #6/#7 Carroll, #17 Trevisan, #110 Bennett); Aaronson, Carroll & Ouellette, "Quantifying the Rise and Fall of Complexity in Closed Systems: The Coffee Automaton" (arXiv:1405.6903, 2014). Experiments here: 64×64 lattice, random adjacent opposite-color pair-swap dynamics, gzip -9 compression, block-average coarse-graining; the random reference curve uses a same-size binary noise image.*