Layered List Labeling

TL;DR

This paper resolves a long-standing tension in list-labeling by presenting a black-box composition framework that combines three distinct list-labeling guarantees into a single algorithm with favorable worst-case, adaptive, and expected bounds. The core construction, the embedding $F \triangleleft R$, pairs a fast emulator with a reliable shell through a hierarchical buffer mechanism, using an $F$-emulator and an $R$-shell with checkpointed rebuilds to preserve sortedness while bounding costs via lightly-amortized guarantees. The authors prove two main results, Theorems twocomp and threecomp, showing that sequential and nested compositions preserve the desired properties, and they extend the framework to yield concrete consequences such as improved bounds for hammer-insert workloads and learning-augmented list-labeling with predictions. The work provides a general, reusable technique for reconciling worst-case latency, adaptive behavior, and high throughput in dynamic data structures, with potential practical impact on databases and order-maintenance systems relying on packed-memory arrays. $O(\log^2 n)$ remains a reference baseline, but the framework demonstrates that one can achieve the best of three worlds by compositional design rather than by pushing a single method to extremes.

Abstract

The list-labeling problem is one of the most basic and well-studied algorithmic primitives in data structures, with an extensive literature spanning upper bounds, lower bounds, and data management applications. The classical algorithm for this problem, dating back to 1981, has amortized cost $O(\log^2 n)$. Subsequent work has led to improvements in three directions: \emph{low-latency} (worst-case) bounds; \emph{high-throughput} (expected) bounds; and (adaptive) bounds for \emph{important workloads}. Perhaps surprisingly, these three directions of research have remained almost entirely disjoint -- this is because, so far, the techniques that allow for progress in one direction have forced worsening bounds in the others. Thus there would appear to be a tension between worst-case, adaptive, and expected bounds. List labeling has been proposed for use in databases at least as early as PODS'99, but a database needs good throughput, response time, and needs to adapt to common workloads (e.g., bulk loads), and no current list-labeling algorithm achieve good bounds for all three. We show that this tension is not fundamental. In fact, with the help of new data-structural techniques, one can actually \emph{combine} any three list-labeling solutions in order to cherry-pick the best worst-case, adaptive, and expected bounds from each of them.

Figures (4)

• Figure 1: An example array $\mathcal{A}$. The first image shows the data structure from the view of the embedding $F \triangleleft R$. There are 17 $F$-emulator slots, shaded blue, of which 12 are occupied by real elements. There are 4 ($R$-shell) buffer slots, shaded green, of which 2 are occupied by real elements. Finally, there are 4 $R$-shell empty slots, shaded white. The second image shows the data structure from the view of the $F$-emulator (i.e., the array $\mathcal{A}_F$), which only sees the blue slots. The third image shows the view of the $R$-shell, which is aware of all slots in the array, but sees all $F$-emulator slots (occupied and free) and buffer slots (occupied and free) as occupied by elements.
• Figure 2: An example move in the $F$-emulator of element $x$ to a ($F$-emulator) neighboring free slot $s$. Here $a=8$ buffer slot elements sit in between $x$ and the $F$-free slot in $F \triangleleft R$, with $a_1=6$ containing real buffered elements. The remaining $a_2=2$ contain dummy elements. Solid lines represent moves of slots in $F \triangleleft R$, while the dashed line represents the move of the element $x$ in the $F$-emulator. From the view of the $F$-emulator, all that has happened is that $x$ moved into slot $s$; and from the view of the $R$-emulator, nothing has happened.
• Figure 3: A example of the intervals $I_1, I_2, \ldots, I_k$ (where $k = 2$) used by a rebuild beginning at time $t_0$. The states of $\widetilde{F}(t_0)$ (i.e., the slots in $\mathcal{A}_F$) and $F(t_0)$ (i.e., the simulated copy of $F$) are each shown, and the intervals $I_1$ and $I_2$ are the constructed based on which elements need to move in order to get from one state to the other. The elements that need to move ($a, b, c, d, i, j, k, \ell$) form the set $Q$, and $I_1$ and $I_2$ are defined to be the maximal sub-intervals out of those that contain just elements of $Q$ and that are non-empty.
• Figure 4: An example of rebuilding the interval $I_1$, in Figure \ref{['fig:rebuild_intervals']}, by first moving the elements in the interval to be left-aligned, and then to their correct positions within $\mathcal{A}_F$. Each step shows only the state of $I_1$, which in turn is a sub-interval of $\mathcal{A}_F$, so slots not in $\mathcal{A}_F$ (i.e., slots colored green and white in Figure \ref{['fig:slot_types']}) are not shown (this means that deadweight moves are also not shown). Starting at the state of the interval in $\widetilde{F}(t_0)$, the rebuild first moves the elements in the interval one-by-one to be left-aligned in the interval. The rebuild then moves the elements one-by-one to their target positions within the array $\mathcal{A}_F$ (i.e., their positions in $F(t_0)$, which is also $C(t)$ for every time $t$ within the rebuild time window). Note that Rightward-move step 3 is an incorporation step, moving an element that was formerly in an R-shell buffer slot (so not formerly in $\mathcal{A}_F$) into a slot within $\mathcal{A}_F$. Also note that the final rightward-step (which would be Rightward move step 4) is a no-op, since $a$ is already in its correct position within array $\mathcal{A}_f$ and does not need to be moved.

Theorems & Definitions (14)

• Definition 1
• Theorem 1
• Theorem 1
• Lemma 2
• Lemma 3
• Lemma 4
• Lemma 5
• Lemma 6
• Lemma 7
• Lemma 8