Simpler Optimal Sorting from a Directed Acyclic Graph

Fredman proposed in 1976 the following algorithmic problem: Given are a ground set $X$, some partial order $P$ over $X$, and some comparison oracle $O_L$ that specifies a linear order $L$ over $X$ that extends $P$. A query to $O_L$ has as input distinct $x, x’ \in X$ and outputs whether $x <_L x’$ or vice versa. If we denote by $e(P)$ the number of linear extensions of $P$, then $\log e(P)$ is a worst-case lower bound on the number of queries needed to output the sorted order of $X$. Fredman did not specify in what form the partial order is given. Haeupler, Hladík, Iacono, Rozhon, Tarjan, and Tětek (‘24) propose to assume as input a directed acyclic graph, $G$, with $m$ edges and $n=|X|$ vertices. Denote by $P_G$ the partial order induced by $G$. Algorithmic performance is measured in running time and the number of queries used, where they use $Θ(m + n + \log e(P_G))$ time and $Θ(\log e(P_G))$ queries to output $X$ in its sorted order. Their algorithm is worst-case optimal in terms of running time and queries, both. Their algorithm combines topological sorting with heapsort. Their analysis relies upon sophisticated counting arguments using entropy, recursively defined sets defined over the run of their algorithm, and vertices in the graph that they identify as bottlenecks for sorting. In this paper, we do away with sophistication. We show that when the input is a directed acyclic graph then the problem admits a simple solution using $Θ(m + n + \log e(P_G))$ time and $Θ(\log e(P_G))$ queries. Especially our proofs are much simpler as we avoid the usage of advanced charging arguments and data structures, and instead rely upon two brief observations.

💡 Research Summary

The paper revisits the classic “sorting under partial information” problem introduced by Fredman in 1976, focusing on the case where the partial order is given explicitly as a directed acyclic graph (DAG). The goal is to output the ground set X in the true linear order L, using as few oracle comparisons (to an oracle O_L that tells the relative order of any two elements) and as little running time as possible. Information‑theoretically, any algorithm must make at least log e(P) comparisons, where e(P) is the number of linear extensions of the underlying partial order P. Recent work by Haeupler et al. (2024) achieved the optimal bound Θ(m + n + log e(P_G)) time and Θ(log e(P_G)) queries by combining topological sorting with a heap‑based approach, but their analysis relies on sophisticated entropy arguments, recursive set constructions, and the identification of “bottleneck” vertices.

The authors of this paper propose a dramatically simpler algorithm that attains exactly the same asymptotic bounds without any heavy machinery. The algorithm proceeds in four conceptual steps:

1. Extract a longest directed path π from the input DAG G. This can be done in linear time O(n + m) using standard DP on DAGs. The path π already respects the partial order and contains n − k vertices, leaving k vertices outside the path.

2. Initialize the residual graph H = G \ π, compute in‑degrees for all vertices in H, and collect the current sources (vertices of in‑degree zero) in a set S. This also costs O(n + m).

3. Iteratively insert sources: While S is non‑empty, pick an arbitrary source x_i from S. For each in‑neighbor u of x_i in the original graph G, use a constant‑time “CompAre” operation to find the in‑neighbor p_i that appears farthest along π. If x_i has no in‑neighbors, a dummy vertex preceding the head of π is used. Then a finger‑search (Search) operation queries the oracle O_L to locate the farthest vertex q_i on π that precedes x_i in the true order; this costs O(1 + log d_i) time and queries, where d_i is the distance between p_i and q_i on π. Finally, a finger‑insert (FingerInsert) places x_i immediately after q_i in the dynamic list representing π. The removal of x_i from H and the update of in‑degrees for its out‑neighbors are performed in O(d⁎(x_i)) total time, ensuring that each edge of G is examined only once, for an overall O(m) cost.

4. Output the final order by traversing the dynamic list (or the underlying level‑linked (2‑4)‑tree) in linear time.

The total running time is therefore O(n + m + k + ∑_{i=1}^k log d_i). The crucial technical contribution is the proof that ∑ log d_i = O(log e(P_G)). To establish this, the authors construct a set of open intervals R_i on the integer line: for vertices already on the original longest path the interval is a unit interval surrounding their position; for each inserted vertex x_i the interval spans from the position of its predecessor p_i on π to its own position. Lemma 2 shows that if there is a directed path from x_i to x_j in G, then the corresponding intervals are disjoint and ordered. Consequently, the collection R defines an “interval order” P_R that is a sub‑order of P_G, implying e(P_R) ≤ e(P_G). Lemma 3 (adapted from prior work) states that for any family of open intervals with unit size, the sum of logarithms of interval lengths is bounded by O(log e(P_R)). Since each interval length |R_i| is at least d_i, we obtain ∑ log d_i = O(log e(P_R)) ⊆ O(log e(P_G)). Together with Lemma 1, which guarantees k ≤ log e(P_G), the overall query count becomes O(k + ∑ log d_i) = O(log e(P_G)).

All data structures used—level‑linked (2‑4)‑trees for the dynamic list and a simple dynamic list ordering structure for constant‑time adjacency comparisons—require linear space. The algorithm therefore matches the optimal bounds of the prior state of the art while being conceptually straightforward: extract a longest path, repeatedly remove sources, and insert them via finger‑search. No heap, no entropy‑based charging scheme, and no intricate bottleneck analysis are needed.

In summary, the paper demonstrates that for DAG‑based partial orders, optimal sorting can be achieved with a clean, easy‑to‑implement algorithm whose correctness follows from two elementary observations and a concise combinatorial argument about interval orders. This simplification not only clarifies the underlying theory but also makes practical implementation more accessible, potentially influencing future work on partial‑order sorting and related problems.