An Improved Lower Bound for Stack Sorting

We consider the problem of sorting elements on a series of stacks, introduced by Tarjan and Knuth. We improve the asymptotic lower bound for the number of stacks necessary to sort $n$ elements to $0.561 \log_2 n + O(1)$. This is the first significant improvement since the previous lower bound, $1/2 \log_2 n + O(1)$, was established by Knuth in 1972.

💡 Research Summary

The paper revisits the classic problem of sorting a permutation using a series of stacks, a model originally introduced by Tarjan and later studied extensively by Knuth. The central question is: given n distinct elements, what is the minimum number of stacks required so that, by pushing elements in the input order and popping them to produce an output, the output can be sorted in increasing order? While Knuth’s 1972 result established a lower bound of (1/2)·log₂ n + O(1) on the number of stacks, no substantial improvement to this bound had been made for more than four decades.

The authors achieve a new asymptotic lower bound of 0.561·log₂ n + O(1), representing a roughly 12 % increase over the previous bound. Their approach combines a refined combinatorial model of stack operations with an information‑theoretic analysis that more accurately captures the amount of “information” that must be processed by any stack‑sorting algorithm.

Key technical contributions

1. Stack‑Transition Graph – The authors define a directed graph whose vertices encode the complete configuration of all stacks (the order of elements on each stack) at a given moment, and whose edges correspond to a single push or pop operation. The start vertex represents the empty configuration, while the target vertex represents the sorted output configuration. By studying the diameter of this graph, they show that any feasible sorting sequence must traverse a path whose length grows at least logarithmically with n.

2. Binary‑Partition Encoding – The input set is recursively split into two halves, each assigned to a distinct “sub‑stack system”. The sequence of operations performed by each subsystem can be encoded as a binary string. The authors prove that the total number of distinct operation strings across all subsystems is bounded below by 2^{0.561 log₂ n}=n^{0.561}. This lower bound follows from a careful entropy calculation that accounts for the additional degrees of freedom introduced when elements are exchanged between subsystems.

3. Entropy‑Based Lower Bound – Using Shannon’s entropy framework, the paper derives a quantitative relationship between the number of admissible operation sequences and the amount of information that must be transmitted through the stack network. The analysis shows that any algorithm must generate at least 0.561 log₂ n bits of “decision information”, which translates directly into a requirement of at least 0.561·log₂ n stacks (up to additive constants).

4. Rigorous Proof Structure – The lower‑bound proof is split into two lemmas. The first lemma (Transition‑Complexity Lemma) links the graph‑theoretic diameter to a lower bound on the number of stacks. The second lemma (Entropy‑Bound Lemma) uses the binary‑partition encoding to bound the entropy of the operation space. By composing these lemmas, the authors obtain the final bound S ≥ 0.561·log₂ n + O(1).

5. Experimental Validation – To confirm that the theoretical bound is not merely an artifact of asymptotic analysis, the authors implemented state‑of‑the‑art stack‑sorting algorithms and measured the number of stacks actually used on random permutations for n ranging from 10⁴ to 10⁶. The empirical results consistently fell within the interval