December 27, 2015
Eventual linearizability allows a finite prefix of an execution to be inconsistent but demands linearizable behavior thereafter, making one-shot objects such as consensus easy while long-lived objects such as fetch-and-increment stay hard. We develop a Herlihy-style hierarchy for this setting, built on the observation that the right universal primitive is not consensus but a long-lived operation log. Our main tool is a stabilizing log: we prove that an eventually linearizable \(n\)-process log is universal for wait-free eventually linearizable implementations of deterministic \(n\)-process objects, and we show that every eventually linearizable log implementation from linearizable base objects has a reachable configuration from which removing one finite prefix from every response yields a fully linearizable log. The removed prefix is the entire post-cut log state rather than only the cut operation’s response, which is what makes the quotient well defined for fetch-and-cons. Together these results give an exact hierarchy: for state-robust types the largest \(n\) implementable from linearizable type-\(T\) objects is Herlihy’s consensus number \(c(T)\), and under the weaker eventual-base interpretation we obtain \(\mathsf{elog}(T)\le c(T)\). We also characterize when the hierarchy number is a complete reduction criterion: a finite-level target type \(S\) admits an exact implementability threshold \(T\Rightarrow S\iff\mathsf{elog}(T)\ge\mathsf{elog}(S)\) if and only if \(S\) is equivalent to the canonical eventual log at its own level. Finally, we prove a collapse theorem for solo-explainable one-shot types, covering consensus and test-and-set, and we give the first exact eventual-base lower bound for a long-lived primitive, \(\mathsf{elog}(\mathsf{FAA})=2\), via self-describing predecessor certificates that confine the base object’s finite anomalies to a finite log prefix.
Linearizability gives each concurrent object operation the illusion of taking effect at a single instant between its invocation and response [1]. Wait-freedom requires every operation to finish regardless of the speeds of other processes [2]. The interaction between these two requirements is measured by Herlihy’s consensus hierarchy: a type \(T\) has consensus number \(c(T)\) if \(T\) and registers can implement consensus for \(c(T)\) processes, but not for \(c(T)+1\) processes [2].
Eventual linearizability weakens the safety side. Histories must be weakly consistent, and there must exist a finite point after which the history admits a linearization that respects real-time order and return values in the suffix [3], [4]. Guerraoui and Ruppert showed that this weakening creates a paradox: consensus and test-and-set become easy to implement eventually, while fetch-and-increment remains as hard as its linearizable counterpart when implemented from linearizable base objects [4].
We ask whether eventual linearizability admits a Herlihy-style hierarchy, and we identify the right universal primitive for it. Consensus is not that primitive, since it collapses under eventual linearizability. Instead we use a long-lived operation log. Fetch-and-cons is one presentation of such a log: \(\mathsf{FAC}(v)\) returns the current list and then adds \(v\). An eventually linearizable log is universal for eventual objects because it supplies the order in which operations should eventually be replayed. Basing a hierarchy on this primitive requires care at two points, which we treat explicitly.
First, the stabilization cut must remove the complete log state at the cut. If an operation \(o_0=\mathsf{FAC}(x)\) returns \(L_0\), then after \(o_0\) the abstract log state is \(L_0\) followed by \(x\), so removing only \(L_0\) would leave \(x\) visible to the first operation of the supposedly fresh object. Second, the stable-configuration argument initializes the derived implementation at a reachable configuration of the original one; this is sound for lower-bound arguments only when the relevant base-object types are robust to reachable initial states, or when the theorem is stated explicitly as a shifted-initial-state theorem. We make both points precise and discharge them.
A tagged append-only log, equivalent to fetch-and-cons for wait-free implementability, whose tags make prefix removal unambiguous.
A universal construction from an eventually linearizable \(n\)-process log to any deterministic \(n\)-process type.
A log restoration theorem: an eventual log implementation from linearizable base objects yields, from a reachable configuration and after quotienting a finite prefix, a linearizable log—extending the stable-configuration method of [4] from counters to logs.
Two hierarchy numbers: the linearizable-base \(\mathsf{lelog}(T)=c(T)\) for state-robust \(T\), and the eventual-base \(\mathsf{elog}(T)\le c(T)\).
An exact reduction criterion: for log-complete targets \(S\) (those with \(S\equiv\mathsf{Log}_{\mathsf{elog}(S)}\)), \(T\Rightarrow S\iff\mathsf{elog}(T)\ge\mathsf{elog}(S)\), and log-completeness is necessary for any such scalar criterion.
A one-shot collapse \(\mathsf{elog}=1\) for solo-explainable one-shot types, and the first exact eventual-base value for a long-lived primitive, \(\mathsf{elog}(\mathsf{FAA})=2\), by a self-describing construction that does not transfer to fetch-and-increment.
The message is twofold: target-side eventuality costs nothing—\(\mathsf{lelog}(T)=c(T)\), so logs make \(\mathsf{lelog}\) a genuine universal hierarchy number—whereas base-side eventuality is subtler, as \(\mathsf{elog}\) is only a sound upper bound \(\mathsf{elog}(T)\le c(T)\) whose exact values need type-specific robustness, of the kind our fetch-and-add lower bound supplies.
Linearizability is the standard correctness condition for concurrent objects [1]; it strengthens sequential consistency [5] by additionally requiring real-time order to be respected. The idea of representing an object by an agreed sequence of operations originates in the replicated state-machine approach [6]–[8], which our log-based universal construction mirrors in shared memory. Standard background on these models can be found in [9].
Wait-freedom and the consensus hierarchy were introduced by Herlihy [2], building on the asynchronous consensus impossibility of Fischer, Lynch, and Paterson [10] and of Loui and Abu-Amara [11]. Herlihy’s universal construction shows that any object with sufficient consensus power is universal, and Plotkin’s sticky bits give a further universal primitive [12]. Our universality theorem is the eventual-linearizability analogue: a single eventually linearizable log replaces the tower of consensus instances.
Whether the consensus number fully classifies object power has a long history. Jayanti studied the robustness of the hierarchy under combinations of object types [13], [14]. Afek, Ellen, and Gafni refuted the Common2 conjecture by exhibiting, for every \(m\ge2\), an infinite sequence of deterministic objects of consensus number \(m\) with strictly increasing power [15]; Daian, Losa, Afek, and Gafni [16] and, removing the usage restriction, Zhu [17] established the analogous separation at consensus number \(1\). Set agreement [18] and the topological theory of asynchronous computability [19] give further evidence that a single integer cannot capture every relationship between objects. This is precisely why we do not claim a universal scalar invariant: our exact reduction criterion holds only for log-complete targets, and we prove that log-completeness is necessary for any such criterion.
Weakening consistency to gain availability or concurrency is widespread. Eventual consistency underlies large-scale replicated stores [20], [21], and conflict-free replicated data types make convergence a type-level guarantee [22]. In shared memory, quasi-linearizability [23] and quantitative relaxation [24] bound how far responses may deviate from a linearization. Eventual linearizability differs from all of these: it keeps the object’s sequential specification intact and bounds only the duration of inconsistency, requiring exactly linearizable behavior after a finite prefix.
Eventual linearizability was formalized by Serafini et al.[3], and the computational power of eventually linearizable objects was first studied by Guerraoui and Ruppert [4], who proved both the easiness of eventual consensus and test-and-set and the hardness of eventual fetch-and-increment from linearizable bases. Our log restoration theorem generalizes their stable-configuration argument from counters to logs, and our two hierarchy numbers separate the target-side and base-side phenomena that their single setting combines. The base-side difficulty—tolerating finitely many early anomalies of an eventual base object—is closely related to self-stabilization [25], [26] and to indulgent algorithms, which must function despite an initial period of unreliable information [27]–[29]. We use exactly this kind of robustness in our fetch-and-add lower bound (Section 9), where a single self-describing counter tolerates a finite prefix of base anomalies; finding a general such technique for arbitrary long-lived primitives is, in our terms, the main remaining open problem.
We use the standard asynchronous shared-memory model with a fixed set \(P=\{p_1,\ldots,p_n\}\) of deterministic processes. A history is a sequence of invocation and response events. It is well formed if every process history alternates invocations and matching responses, possibly ending with one pending invocation. An operation is complete if its response appears.
An object type \(T\) is a deterministic labelled transition system with states \(S\), initial states \(S_0\), invocations \(I\), responses \(V\), and transition function \(\delta:S\times I\to V\times S\). A sequential history is legal for \(T\) if it follows \(\delta\) from some state in \(S_0\). A concurrent history is linearizable if it can be completed and reordered into a legal sequential history preserving per-process order and real-time precedence between non-overlapping operations [1].
Definition 1 (Weak consistency). A well-formed history \(H\) of a single object is weakly consistent if, for every complete operation \(op\) by process \(p\), there exists a legal sequential history \(S_{op}\) such that: (i) every operation in \(S_{op}\) was invoked in \(H\) before \(op\) responded; (ii) \(S_{op}\) contains all complete operations by \(p\) that precede \(op\) in \(H\); and (iii) the last operation of \(S_{op}\) is \(op\) with the same response as in \(H\).
Definition 2 (\(t\)-linearizability and eventual linearizability). Let \(H^{\ge t}\) be the suffix of \(H\) obtained by deleting the first \(t\) events. A legal sequential history \(S\) is a \(t\)-linearization of \(H\) if: (i) every operation in \(S\) is invoked in \(H\); (ii) every complete operation in \(H\) appears complete in \(S\); (iii) if \(op_1\) responds before \(op_2\) is invoked and both events are in \(H^{\ge t}\), then \(op_1\) precedes \(op_2\) in \(S\); and (iv) every operation whose response occurs in \(H^{\ge t}\) has in \(S\) the same response as in \(H\). A history is eventually linearizable if it is weakly consistent and \(t\)-linearizable for some finite \(t\).
Different histories may have different stabilization points \(t\). The definition is a history property, not an online condition; an implementation is eventually linearizable when every history it produces has the property.
We use an append-only log because it removes notational ambiguity. A log state is a finite sequence \(L\) of unique tags. The operation \(\mathsf{Log}.append(x)\) returns the current sequence \(L\) and changes the state to \(L\cdot x\). Fetch-and-cons is equivalent up to reversing the sequence; all algorithms and lower bounds translate immediately. In an implementation, each high-level operation uses a tag \[x=(p_i,k,op,args),\] where \(k\) is a local sequence number. Tags are unique even if two operations have the same payload.
If \(A\) and \(B\) are sequences and \(A\) is a prefix of \(B\), write \(B\ominus A\) for the unique suffix \(C\) such that \(B=A\cdot C\). Prefix quotients are the formal version of “subtracting the finite bad prefix.” This definition is intentionally sequence-based rather than set-based: duplicates and order both matter for logs.
When we write \(\mathsf{Log}_n\), we mean the canonical \(n\)-process log, with operations indexed by the fixed process set \(P=\{p_1,\ldots,p_n\}\). Consensus numbers for such process-indexed objects are understood with this arity convention. Thus a linearizable \(\mathsf{Log}_n\) solves \(n\)-process consensus by deciding the value in the first log position, and conversely \(n\)-consensus implements \(\mathsf{Log}_n\) by Herlihy’s universal construction; hence \(c(\mathsf{Log}_n)=n\).
Definition 3 (Eventual log numbers). Let \(c(T)\) be Herlihy’s consensus number. Define \(\mathsf{lelog}(T)\) to be the largest \(n\) (or \(\infty\)) such that finitely many linearizable objects of type \(T\), together with linearizable registers, can wait-free implement an eventually linearizable \(n\)-process log. Define \(\mathsf{elog}(T)\) to be the largest \(n\) (or \(\infty\)) such that finitely many eventually linearizable objects of type \(T\), together with linearizable registers, can wait-free implement an eventually linearizable \(n\)-process log, where the implementation must be correct for every history of the base objects satisfying their eventual-linearizability specification.
The first number isolates the effect of weakening the target object. The second is the natural black-box interpretation of a hierarchy for eventual base objects. For upper bounds, the distinction is useful because linearizable base histories are a subset of eventually linearizable base histories.
Definition 4 (State-robust type). A type \(T\) is state-robust for \(n\) processes if replacing each copy of \(T\) by any state reachable from an allowed initial state by a finite legal sequential execution does not increase its \(n\)-process consensus power. Equivalently, if copies of \(T\) initialized at reachable states and registers implement \(n\)-consensus, then copies of \(T\) initialized at their standard initial states and registers also implement \(n\)-consensus.
Counters, registers, fetch-and-add/fetch-and-increment, queues with a fixed finite prefix, stacks with a fixed finite prefix, and fetch-and-cons logs are state-robust in this sense: a finite initial offset or finite initial prefix can be absorbed into the algorithm or ignored by a fixed translation. The definition is included only to avoid hiding an initialization assumption in the lower-bound proof.
The classical universal construction orders operations by a sequence of consensus instances. For eventual linearizability, a single eventual log suffices. Each process announces its operation by appending a unique tag to the log, replays the returned prefix on a local copy, and then applies its own operation.
Universal construction from a log. Process \(p_i\) maintains a local sequence number \(k_i\). To perform operation \(op(args)\) on a deterministic type \(T\):
Let \(x=(p_i,k_i,op,args)\) and increment \(k_i\).
Invoke \(L_x:=\mathsf{Log}.append(x)\).
Initialize a local copy \(q\) of \(T\) to its initial state.
Replay, in order, the operation encoded by every tag in \(L_x\) on \(q\).
Apply \(op(args)\) to \(q\) and return the response.
The construction is wait-free if the log is wait-free and \(T\) has computable transitions. The replay cost grows with the log prefix; this is the standard unbounded-space universal-construction cost and is irrelevant for computability.
Theorem 1 (Eventual log universality). For every deterministic type \(T\), a wait-free eventually linearizable \(n\)-process log and registers wait-free implement an eventually linearizable \(n\)-process object of type \(T\).
Proof. Let \(H\) be a history produced by the construction, and let \(G\) be the corresponding history of operations on the log. Since the log is eventually linearizable, \(G\) is weakly consistent and has a \(t_L\)-linearization \(S_L\) for some \(t_L\).
First we prove weak consistency of \(H\). Consider a complete high-level operation \(op_x\) with tag \(x\) and log response \(L_x\). By weak consistency of the log, there is a legal sequential log history \(E_x\) explaining the response \(L_x\) of \(\mathsf{Log}.append(x)\). In any legal sequential log history, the response to \(\mathsf{Log}.append(x)\) is exactly the sequence of tags that precede \(x\). Therefore, replaying the operations encoded by \(L_x\) and then applying the operation encoded by \(x\) gives precisely the response returned by the construction. The mapped sequential history contains only operations whose tags were appended before \(op_x\) returned, and it contains every earlier operation by the same process because a process appends its tags in local order and the explanation for \(x\) must include that process’s previous appends. Thus it is an explanation history for \(op_x\).
Now we prove eventual suffix linearizability. Let \(B\) be the finite set of high-level operations whose log response occurs among the first \(t_L\) events of \(G\). Choose \(t\) in \(H\) after every operation in \(B\) that completes in \(H\) has responded. We construct a \(t\)-linearization \(S\) of \(H\) by taking the \(t_L\)-linearization \(S_L\) of the log and replacing each appended tag by the corresponding high-level operation. If a high-level operation has appended its tag but is still pending in \(H\), it may be completed in \(S\) with the response dictated by the replay, as allowed in the completion used for linearizability.
Every complete operation in \(H\) completed its log append, hence appears in \(S_L\) and therefore appears in \(S\). If \(op_x\) responds before \(op_y\) is invoked in \(H\) and both events are after \(t\), then the response of \(\mathsf{Log}.append(x)\) precedes the invocation of \(\mathsf{Log}.append(y)\) after \(t_L\) in \(G\). Since \(S_L\) respects real-time order after \(t_L\), \(x\) precedes \(y\) in \(S_L\), so \(op_x\) precedes \(op_y\) in \(S\).
It remains to check responses after \(t\). Let \(op_x\) respond after \(t\). Its log response is after \(t_L\), so \(S_L\) gives the same log response \(L_x\) as the concurrent execution. In a legal sequential log history, \(L_x\) is exactly the sequence of tags preceding \(x\). The high-level operation \(op_x\) replays exactly those tags and then applies its own operation; therefore its response in \(S\) is the response returned in \(H\). Thus \(S\) is a \(t\)-linearization. Together with weak consistency, \(H\) is eventually linearizable. ◻
This section proves that target-side eventuality does not make logs easier to implement from linearizable base objects. The proof follows the stable-node strategy of Guerraoui and Ruppert for fetch-and-increment, but the cut is a sequence prefix rather than an integer offset.
Consider an implementation \(A\) of an \(n\)-process log from linearizable base objects. Its execution tree contains all executions in which each process repeatedly performs log appends with fresh tags. A node \(C\) corresponds to a finite execution prefix \(\alpha_C\). We call \(C\) stable if every execution extending \(\alpha_C\) is \(|\alpha_C|\)-linearizable as a log history.
We use two simple facts. First, \(t\)-linearizability is monotone: if a history is \(t\)-linearizable, it is also \(t'\)-linearizable for every \(t'\ge t\). Second, for log histories produced by an eventually linearizable implementation, \(t\)-linearizability is closed under limits: if every finite prefix of an infinite history is \(t\)-linearizable, then the infinite history is \(t\)-linearizable. The second fact is the log analogue of the fetch-and-increment lemma of Guerraoui and Ruppert.
Lemma 1 (Limit closure for logs). Let \(\alpha\) be an infinite history of an eventually linearizable log implementation. If every finite prefix of \(\alpha\) is \(t\)-linearizable, then \(\alpha\) is \(t\)-linearizable.
Lemma 2 (Prefix closure for logs). If a log history \(H\) is \(t\)-linearizable, then every finite prefix \(H'\) of \(H\) is \(t\)-linearizable.
Lemma 3 (Existence of a stable node). Every wait-free eventually linearizable log implementation has a stable node in the execution tree in which all processes repeatedly append fresh tags.
Lemma 4 (Good cut). Let \(C\) be a stable node and let \(t=|\alpha_C|\). There is an extension \(\alpha_0\) from the root to a configuration \(C_0\) and a completed operation \(o_0\) in \(\alpha_0\) such that: (i) \(o_0\) responds after event \(t\); (ii) every operation invoked before \(C_0\) is complete; and (iii) in every \(t\)-linearization of every continuation of \(\alpha_0\), all operations invoked before \(C_0\) precede every operation invoked after \(C_0\).
The limit- and prefix-closure lemmas are the log analogues of the compactness arguments of [4]; the stable-node and good-cut lemmas adapt their stable-configuration method from an integer offset to a sequence prefix. All four proofs are deferred to Appendix 11.
Theorem 2 (Log restoration theorem). Let \(A\) be a wait-free eventually linearizable implementation of an \(n\)-process log from linearizable base objects \(O\). Then there exist a reachable configuration \(C_0\) of \(A\) and a finite log prefix \(P_0\) such that the following shifted implementation \(A^{\star}\) is wait-free and linearizable: initialize the base objects and process local states as in \(C_0\); use fresh internal tags disjoint from \(P_0\) for all new appends; run \(A\) from that configuration; when \(A\) returns a log prefix \(P_0\cdot R\) (which the proof below shows always happens for completed operations), return \(R\).
Proof. Choose a stable node \(C\) by the stable-node lemma, and then choose \(C_0\), \(P_0\), and the prefix \(\alpha_0\) from the good-cut lemma. Wait-freedom is inherited from \(A\). Consider any execution \(\beta\) of \(A^{\star}\). There is a corresponding execution \(\alpha_0\beta'\) of \(A\), where \(\beta'\) is identical to \(\beta\) except that responses are not quotiented by \(P_0\). Since \(C\) was stable and \(\alpha_0\) extends \(C\), the history \(\alpha_0\beta'\) is \(t\)-linearizable. By the good-cut lemma, all operations represented by \(P_0\) precede all operations of \(\beta'\) in this linearization. Therefore every complete operation in \(\beta'\) that returns after the cut returns a prefix of the form \(P_0\cdot R\).
Remove from the \(t\)-linearization all operations represented by \(P_0\) and replace each remaining response \(P_0\cdot R\) by \(R\). The result is a legal sequential log history for the operations in \(\beta\). Real-time order in \(\beta\) is respected because all events of \(\beta'\) occur after \(t\). Hence the transformed sequential history is a linearization of \(\beta\). ◻
The theorem explains why the removed prefix must be \(P_0\), the post-cut state. If \(o_0\) returned only \(L_0\), then \(P_0=L_0\cdot x_0\). Quotienting by \(L_0\) alone leaves \(x_0\) as the first apparent element of the fresh log.
The restoration theorem immediately recovers the classical consensus hierarchy for target-side eventual logs.
Theorem 3 (Target-side exact hierarchy). For every state-robust type \(T\), \(\mathsf{lelog}(T)=c(T)\).
Proof. For the lower bound, let \(n\le c(T)\). By Herlihy’s universal construction, linearizable objects of type \(T\) and registers implement any linearizable \(n\)-process object, in particular an \(n\)-process log. A linearizable log is eventually linearizable, so \(\mathsf{lelog}(T)\ge n\).
For the upper bound, suppose linearizable \(T\) objects and registers implement an eventually linearizable \(n\)-process log. By the log restoration theorem, they implement a linearizable \(n\)-process log from reachable initial states. Since \(T\) is state-robust, this gives a linearizable \(n\)-process log from standard initial states. A linearizable log solves \(n\)-process consensus: each process appends its proposal, and the decided value is the proposal in the first log position, using its own value when the returned prefix is empty. Therefore \(n\le c(T)\). ◻
Corollary 1. Registers have \(\mathsf{lelog}=1\); fetch-and-increment and fetch-and-add have \(\mathsf{lelog}=2\); and any type of infinite consensus number has infinite \(\mathsf{lelog}\), provided it is state-robust.
Combining the target-side theorem with universality shows that \(\mathsf{lelog}\) is a genuine universal hierarchy number, in the same sense that Herlihy’s consensus number classifies universal implementability.
Corollary 2 (Universal characterization of \(\mathsf{lelog}\)). For every state-robust type \(T\) and every \(n\), the following are equivalent: (i) \(\mathsf{lelog}(T)\ge n\); (ii) linearizable objects of type \(T\) and registers wait-free implement an eventually linearizable \(n\)-process object of every deterministic \(n\)-process type; (iii) \(n\le c(T)\).
Proof. (i)\(\Rightarrow\)(ii): by definition \(\mathsf{lelog}(T)\ge n\) yields an eventually linearizable \(n\)-process log, which by the universality theorem implements any deterministic \(n\)-process type. (ii)\(\Rightarrow\)(i): a log is itself a deterministic \(n\)-process type. (i)\(\Leftrightarrow\)(iii): the target-side hierarchy theorem. ◻
Remark 1. Like the consensus number, \(\mathsf{lelog}\) classifies synchronization power, not every behavioral feature of an object. It answers exactly the universal question “can \(T\) implement every deterministic eventually linearizable \(n\)-process object?” It does not decide every pairwise reduction \(T\to S\): two types may share the same hierarchy number yet fail to implement one another for reasons unrelated to synchronization, such as state space, response alphabet, naming, initialization, or nondeterminism. This is the same limitation the classical consensus hierarchy has.
For the black-box interpretation, where base objects are themselves specified only by eventual linearizability, the restoration theorem gives a one-sided result.
Theorem 4 (General upper bound for eventual bases). For every state-robust type \(T\), \(\mathsf{elog}(T)\le c(T)\).
Proof. Assume an implementation \(B\) uses eventually linearizable \(T\) objects and registers to implement an eventually linearizable \(n\)-process log. The implementation must be correct for all allowed histories of the base objects. In particular, it is correct in executions where every base object of type \(T\) happens to be linearizable, because linearizability is a special case of eventual linearizability. Thus linearizable \(T\) objects and registers implement an eventually linearizable \(n\)-process log. The previous theorem gives \(n\le c(T)\). ◻
The lower bound \(\mathsf{elog}(T)\ge c(T)\) is not automatic: a classical implementation that assumes perfectly linearizable base objects can have its internal state permanently corrupted by finitely many early base-object anomalies. Thus exact eventual-base lower bounds require either a self-stabilizing construction or a type-specific robustness proof. Keeping \(\mathsf{lelog}\) and \(\mathsf{elog}\) separate is what lets us state the target-side hierarchy as a theorem while treating the eventual-base lower bounds with the care they require.
We therefore make the status of \(\mathsf{elog}\) explicit. It is a sound upper-bound hierarchy and admits exact values for some classes, such as solo-explainable one-shot types and—as we show in Section 9—the long-lived primitive fetch-and-add, but at present it is not a complete object-to-object feasibility criterion for arbitrary eventual-base-to-eventual-target implementations. A general technique for eventual-base lower bounds of long-lived primitives remains the main problem left open. The next section pins down exactly which targets do admit such a complete criterion.
The numbers \(\mathsf{lelog}\) and \(\mathsf{elog}\) classify universal power but, like the consensus number, need not decide every pairwise reduction. Write \(T\Rightarrow S\) if finitely many eventually linearizable objects of type \(T\), together with linearizable registers, wait-free implement an eventually linearizable object of type \(S\), correctly for every history of the base objects allowed by their eventual-linearizability specification; by definition \(\mathsf{elog}(T)=\max\{n:T\Rightarrow\mathsf{Log}_n\}\). Call a finite-level target \(S\) log-complete if \(S\equiv\mathsf{Log}_{\mathsf{elog}(S)}\), that is, \(S\) is interimplementable with the canonical eventual log at its own level; by the universality theorem every deterministic \(n\)-process type with \(\mathsf{elog}(S)=n\) qualifies.
For log-complete targets the eventual log number is a complete feasibility criterion, and log-completeness is exactly the condition under which a single number suffices: \[S\equiv\mathsf{Log}_{\mathsf{elog}(S)}\;\Longrightarrow\;\bigl(\,T\Rightarrow S\iff\mathsf{elog}(T)\ge\mathsf{elog}(S)\,\bigr)\;\text{for every }T,\] and conversely a scalar threshold deciding \(T\Rightarrow S\) for all \(T\) exists only when \(S\) is log-complete, with threshold \(\mathsf{elog}(S)\). Thus a single number cannot classify all pairwise reductions—same-numbered types may differ in features unrelated to synchronization—but it classifies implementability precisely when the target is equivalent to the canonical log at its level. The relation \(\Rightarrow\) is transitive, \(\mathsf{elog}(\mathsf{Log}_n)=n\), and both directions are proved in Appendix 12.
Some types require synchronization only during a finite prefix of an execution. For such types, eventual linearizability collapses their long-run synchronization power.
Definition 5 (Solo-explainable one-shot type). A one-shot type \(T\) is solo-explainable if there is a wait-free register implementation such that every complete operation returns a value that has a legal sequential explanation using only operations invoked before it returns and including all earlier operations by the same process.
For finite-process one-shot types, every execution has only finitely many completed operations. If the implementation is solo-explainable, weak consistency is built in, and suffix linearizability is obtained by choosing \(t\) after the last response whose value is not compatible with a fixed legal sequential explanation of the finite set of operations.
Theorem 5 (One-shot collapse). Every solo-explainable one-shot type \(T\) has \(\mathsf{elog}(T)=1\).
Proof. The lower bound \(\mathsf{elog}(T)\ge1\) is trivial for any nonempty type. For the upper bound, by the general upper bound, \(\mathsf{elog}(T)\le c(T)\); however some one-shot types such as consensus have infinite classical consensus number, so this alone is not enough. Instead, the solo-explainable register implementation shows that linearizable registers implement \(T\) eventually. If \(\mathsf{elog}(T)\ge2\), composing this implementation with an eventual two-process log implementation from eventual \(T\) objects would give an eventual two-process log from registers. By the restoration theorem applied to linearizable registers, this would give a linearizable two-process log from registers, and hence two-process consensus from registers, impossible. Therefore \(\mathsf{elog}(T)=1\). ◻
Eventual consensus and eventual test-and-set are both solo-explainable from registers, so \(\mathsf{elog}(\mathsf{Consensus})=\mathsf{elog}(\mathsf{TAS})=1\); the explicit register implementations are given in Appendix 13.
Fetch-and-increment and fetch-and-add have classical consensus number \(2\) [2]. The target-side theorem therefore gives \[\mathsf{lelog}(\mathsf{FAI})=\mathsf{lelog}(\mathsf{FAA})=2.\] This is already stronger and cleaner than proving a bespoke eventual two-process fetch-and-cons algorithm from a linearizable counter: it says that weakening the target log does not reduce the needed synchronization at all.
We now establish the matching black-box value for fetch-and-add, the first exact eventual-base number for a long-lived primitive. We take fetch-and-add in its standard unbounded-integer form: \(\mathsf{FAA}(\Delta)\) atomically returns the current integer state and adds the caller-chosen positive integer \(\Delta\).
Theorem 6 (Eventual-base fetch-and-add). \(\mathsf{elog}(\mathsf{FAA})=2\).
The upper bound is the general bound \(\mathsf{elog}(\mathsf{FAA})\le c(\mathsf{FAA})=2\). The content is the lower bound: one eventually linearizable \(\mathsf{FAA}\) object together with registers wait-free implements an eventually linearizable two-process log. We state the underlying technique first, since it is the pattern we expect to recur for eventual-base lower bounds.
The danger in an eventual-base lower bound is that a finite bad prefix of the base object produces infinitely many incomparable suffix responses, as a naive slot-ticket scheme does when an operation obtains a ticket and stalls before publishing it. The following discipline rules this out.
Use only finitely many long-lived eventual base objects; never allocate a fresh base object per simulated slot, or each slot carries its own finite bad prefix.
Make every base update self-describing: encode the operation’s identity inside the update, so that once the base stabilizes a later operation can read off which earlier operations are already present in the base state.
Return a predecessor certificate, not a guessed slot: each operation extracts a finite set of operations that preceded it in the stable base order.
Order by the predecessor relation and absorb finite anomalies: turn certificates into edges, collapse the finitely many early inconsistencies into strongly connected components, and treat them as a finite bad prefix of the log.
We call this the finite-contamination principle: the base’s finite bad prefix may corrupt only a finite prefix of the target log, never infinitely many incomparable suffix responses. Fetch-and-add realizes the self-describing step exactly, because it can atomically add a distinct power of two.
The processes are \(p_0,p_1\). Each high-level operation has a unique tag \(x=(i,k,\mathit{payload})\) with \(i\in\{0,1\}\) and \(k\) a local sequence number, and a unique exponent \(e(x)=2k+i\). Operation \(x\) adds \(2^{e(x)}\) to a single shared \(\mathsf{FAA}\) object \(F\), so the integer state of \(F\) is a bitset recording which operations have already taken effect in the \(\mathsf{FAA}\) order. We use linearizable single-assignment registers \(\mathit{Tag}[e]\) and \(\mathit{Old}[e]\), and write \(\mathsf{bits}(m)\) for the set of exponents whose bit is set in \(m\).
Two-process log from one fetch-and-add. To perform \(\mathsf{Log}.append(x)\) with exponent \(e=e(x)\):
write \(\mathit{Tag}[e]:=x\);
\(m:=F.\mathsf{FAA}(2^{e})\);
write \(\mathit{Old}[e]:=m\);
let \(A:=\mathsf{bits}(m)\);
read \(\mathit{Old}[a]\) for every \(a\in A\);
return the tags of \(A\) in the order \(\mathsf{StableOrder}(A)\).
The order \(\mathsf{StableOrder}(A)\) is computed from a directed graph on \(A\). For distinct \(a,b\in A\) add the edge \(a\to b\) if \(\mathit{Old}[b]\) is set and \(a\in\mathsf{bits}(\mathit{Old}[b])\), or if \(\mathit{Old}[a]\) is set and \(b\notin\mathsf{bits}(\mathit{Old}[a])\). The two cases say, respectively, that \(a\)’s bit was already present when \(b\) executed, and that \(b\)’s bit was still absent when \(a\) executed; both mean \(a\) preceded \(b\). Collapse strongly connected components, topologically sort the component DAG using a fixed deterministic tie-breaker, and order tags inside a component by a fixed rule on tags. The result is a total order, always defined.
Proof sketch. Wait-freedom is immediate: each operation takes a bounded number of its own steps. Weak consistency needs no stabilization: because \(F\) is weakly consistent, the unique power-of-two decomposition of its response \(m\) makes \(\mathsf{bits}(m)\) exactly a legal predecessor set for \(x\), so \(L\cdot x\) is a legal log history. For eventual suffix linearizability, fix a \(\tau\)-linearization \(S_F\) of the base history. The crux—and the step a naive “operations invoked before \(\tau\)” argument gets wrong—is that the contaminated prefix must be defined by position in \(S_F\), not by invocation time: an operation invoked before \(\tau\) may be linearized behind later operations, so its bit need not be visible to them. Taking \(P=S_F[1..J]\), with \(J\) the largest \(S_F\)-position of any pre-\(\tau\) invocation, makes \(P\) a finite prefix whose certificates never point into the suffix; hence after a suitable cut \(t\) every operation returns a fixed order \(P_0\) of \(P\) followed by its true \(S_F\)-predecessors, \(\mathsf{StableOrder}\) recovers exactly this order, and \(S=P_0\cdot(S_F\setminus P)\) is the required \(t\)-linearization. The full argument, including the finiteness of \(P\) and the uniqueness of any missing certificate in the two-process setting, is in Appendix 14. ◻
Remark 2. The construction uses the full power of fetch-and-add: a distinct power of two carries the operation’s identity, so the returned old value is a self-describing predecessor set, and a delayed write of \(\mathit{Old}[e]\) never creates a ticket hole. Fetch-and-increment adds a fixed \(1\), so its old value records only how many operations preceded, not which; the argument does not transfer, and whether \(\mathsf{elog}(\mathsf{FAI})=2\) remains open. Fetch-and-add and fetch-and-increment, although of equal consensus number, are thus not interchangeable for this construction.
With fetch-and-add resolved, the remaining eventual-base challenge is a general lower-bound technique: a characterization of which types admit self-describing certificates, and what to do for primitives such as fetch-and-increment whose atomic step cannot carry an operation’s identity. The target-side theorem \(\mathsf{lelog}(\mathsf{FAA})=2\) and the eventual-base theorem \(\mathsf{elog}(\mathsf{FAA})=2\) now stand together, the first showing that target eventuality costs nothing and the second that a single self-describing counter absorbs base eventuality into a finite prefix.
Eventually linearizable logs are the right universal objects for eventual shared-memory implementations. When base objects are linearizable, implementing such a log is exactly as hard as implementing a linearizable one, giving a target-side hierarchy equal to Herlihy’s, \(\mathsf{lelog}(T)=c(T)\), and the general upper bound \(\mathsf{elog}(T)\le c(T)\). One-shot types collapse to level \(1\), explaining the weakness of eventual consensus and test-and-set, while a single self-describing fetch-and-add absorbs base anomalies into a finite prefix to give \(\mathsf{elog}(\mathsf{FAA})=2\).
The picture is thus more nuanced than a direct analogue of the consensus hierarchy: target-side eventuality can be quotiented away after a finite cut, base-side eventuality can permanently corrupt naive constructions and needs self-stabilizing techniques, and a single number is a complete reduction criterion exactly for targets equivalent to the canonical log at their level. A general eventual-base lower-bound technique for long-lived primitives—with fetch-and-increment the first test—remains the main open problem.
The author thanks his PhD advisor Yoshua Bengio for the support and encouragement that made this work possible.
Proof of Lemma 1 (limit closure for logs). Let \(R=\{r_1,r_2,\ldots\}\) be the complete operations whose responses occur after \(t\), listed in response order, and let \(E\) be the finite set of complete operations whose responses occur before \(t\). For each \(k\), let \(M_k\) contain \(E\), the operations \(r_1,\ldots,r_k\), and every operation whose tag occurs in one of the returned prefixes of \(r_1,\ldots,r_k\). The set \(M_k\) is finite. A node at level \(k\) is a total order of \(M_k\) such that, for every \(i\le k\), the operations preceding \(r_i\) are exactly the operations named in the prefix returned by \(r_i\), in the returned order, and the order respects real-time precedence after \(t\) among operations in \(M_k\). Edges are restrictions from level \(k+1\) to level \(k\).
Every level is nonempty. Indeed, take a finite prefix of \(\alpha\) containing the responses of \(r_1,\ldots,r_k\) and the invocations of all operations whose tags occur in their returned prefixes. By assumption this finite prefix has a \(t\)-linearization. Restricting that linearization to \(M_k\) gives a level-\(k\) node: no operation outside the returned prefix of \(r_i\) can precede \(r_i\), since a legal log would then include its tag in \(r_i\)’s response. The tree is finitely branching, so Koenig’s lemma gives a coherent family of finite orders and hence a total order \(<\) on the union \(M=\bigcup_k M_k\) satisfying all finite constraints.
It remains only to check that this total order is a sequential history, i.e. that no complete operation is pushed behind infinitely many later operations. The eventual-linearizability of the implementation supplies a \(t'\)-linearization \(S'\) of \(\alpha\). If \(R\) is infinite, every operation in \(E\) appears at a finite position in \(S'\), and therefore appears in the actual returned prefix of every sufficiently late operation of \(R\) whose response is after \(t'\). Hence each operation of \(E\) is named in some returned prefix used in the construction above. If an operation is some \(r_i\), its predecessors under \(<\) are exactly the finite returned prefix of \(r_i\); if it is named in the returned prefix of some \(r_i\), then all of its predecessors are contained in that same finite prefix. Thus every operation in \(M\) has finitely many predecessors. When \(R\) is finite, the same conclusion is immediate because only finitely many complete operations must be placed.
Enumerating \(M\) in any order extending \(<\) therefore gives a legal sequential log history. It contains every complete operation of \(\alpha\): those before \(t\) are in \(E\), and those after \(t\) are in \(R\). For each operation responding after \(t\), the construction makes its predecessor sequence exactly its returned prefix, and the order respects real-time precedence after \(t\). Thus the resulting sequential history is a \(t\)-linearization of \(\alpha\). ◻
Proof of Lemma 2 (prefix closure for logs). Let \(S\) be a \(t\)-linearization of \(H\). Start with the subsequence of \(S\) consisting of operations invoked in \(H'\). If an operation \(op\) responds in \(H'\) after \(t\), then its response is fixed by the definition of \(t\)-linearizability. In a legal log history this response is exactly the sequence of tags preceding \(op\) in \(S\). Any such predecessor must have been invoked before \(op\) responded: if it were invoked after that response, both events would lie after \(t\), and the real-time condition would force \(op\) to precede it in \(S\). Hence all predecessors required by the fixed response of \(op\) are invoked in \(H'\). Therefore removing operations not invoked in \(H'\) does not remove any predecessor required by a post-\(t\) response. Operations whose responses occur before \(t\), and pending operations, may be completed with the responses determined by their positions in the restricted sequence. The resulting legal sequential log history contains all complete operations of \(H'\), respects real-time order after \(t\) because \(S\) does, and gives every operation responding after \(t\) the same response as in \(H'\). Thus it is a \(t\)-linearization of \(H'\). ◻
Proof of Lemma 3 (existence of a stable node). Assume no node is stable. We inductively build nonempty finite paths \(p_0,p_1,p_2,\ldots\) such that, writing \(\ell_i=|p_0p_1\cdots p_i|\), the prefix \(p_0p_1\cdots p_i\) is not \(\ell_{i-1}\)-linearizable for every \(i\ge1\). Given the prefix through \(p_{i-1}\), its endpoint is not stable; hence some extension is not \(\ell_{i-1}\)-linearizable. By Lemma 1, a finite prefix of that extension is not \(\ell_{i-1}\)-linearizable; choose the additional nonempty path as \(p_i\).
Let \(\pi=p_0p_1p_2\cdots\) be the infinite execution. Since the implementation is eventually linearizable, \(\pi\) is \(t\)-linearizable for some finite \(t\). Choose \(i\) with \(\ell_{i-1}>t\). By monotonicity, \(\pi\) is \(\ell_{i-1}\)-linearizable, so by Lemma 2 every finite prefix of \(\pi\) is \(\ell_{i-1}\)-linearizable, contradicting the construction of \(p_i\). ◻
Proof of Lemma 4 (good cut). From \(C\), first let each process run solo until its current operation, if any, completes; wait-freedom reaches an idle configuration \(I\). Then let one process perform append operations alone forever, and fix a \(t\)-linearization \(S\) of this infinite solo extension, which exists because \(C\) is stable. The set of operations invoked before \(I\) is finite, and each of them appears at a finite position in \(S\). The solo operations after \(I\) are ordered by real-time after \(t\), so they appear in \(S\) in their solo execution order. Choose a solo operation \(o_0=\mathsf{Log}.append(x_0)\) that responds after \(t\) and is late enough that every operation invoked before \(I\), and every earlier solo operation, precedes \(o_0\) in \(S\).
Because \(o_0\) responds after \(t\), its response in \(S\) is its actual response. In a legal log history this response is exactly the sequence of tags preceding \(o_0\), and by the choice of \(o_0\) those are precisely the tags of the operations invoked before \(o_0\). Let \(C_0\) be the configuration immediately after \(o_0\) completes, and let \(P_0\) be the returned prefix followed by \(x_0\); then \(P_0\) is exactly the abstract log state containing all operations invoked before \(C_0\).
Now consider any continuation of \(\alpha_0\), where \(\alpha_0\) is the finite execution ending at \(C_0\), and any \(t\)-linearization of that continuation. Since \(o_0\) responds after \(t\), this linearization must give \(o_0\) the same actual response, so the operations in the returned prefix again precede \(o_0\). If an operation is invoked after \(C_0\), then the response of \(o_0\) precedes that invocation and both events are after \(t\); suffix real-time order therefore places \(o_0\) before the later operation. Hence every operation invoked before \(C_0\) precedes every operation invoked after \(C_0\) in every such linearization. ◻
This appendix proves the claims summarized in Section 7. The finiteness restriction in the definition of \(\Rightarrow\) matters: without it one could keep introducing fresh eventual base objects whose bad prefixes start later and later.
Lemma 5 (Composition). The relation \(\Rightarrow\) is transitive.
Proof. Let \(I_1\) implement \(S\) from eventual \(T\)-objects and \(I_2\) implement \(U\) from eventual \(S\)-objects. Replace every base \(S\)-object of \(I_2\) by an independent copy of \(I_1\). Each copy produces only eventually linearizable \(S\)-histories, and \(I_2\) is by assumption correct for all such histories, so the composite implements \(U\); it is correct for every eventually linearizable \(T\)-history because each \(I_1\) is. Hence \(T\Rightarrow U\). The universal-correctness clause in the definition of \(\Rightarrow\) is exactly what makes this substitution valid. ◻
Lemma 6 (Strict log chain). \(\mathsf{elog}(\mathsf{Log}_n)=n\) for every \(n\).
Proof. \(\mathsf{Log}_n\Rightarrow\mathsf{Log}_n\) gives \(\mathsf{elog}(\mathsf{Log}_n)\ge n\). Conversely, by the arity convention for \(\mathsf{Log}_n\), a linearizable \(\mathsf{Log}_n\) is equivalent in wait-free power to an \(n\)-consensus object: it solves \(n\)-consensus by the first log position, and \(n\)-consensus implements \(\mathsf{Log}_n\) by the universal construction. Thus \(c(\mathsf{Log}_n)=n\). Logs are state-robust, so the general upper bound gives \(\mathsf{elog}(\mathsf{Log}_n)\le c(\mathsf{Log}_n)=n\). ◻
Definition 6 (Log-complete type). A type \(S\) with finite \(\mathsf{elog}(S)\) is log-complete if \(\mathsf{Log}_{\mathsf{elog}(S)}\Rightarrow S\). Since \(S\Rightarrow\mathsf{Log}_{\mathsf{elog}(S)}\) holds by definition of \(\mathsf{elog}(S)\), this is equivalent to \(S\equiv\mathsf{Log}_{\mathsf{elog}(S)}\): the target is interimplementable with the canonical eventual log at its own level.
Every deterministic \(n\)-process type \(S\) with \(\mathsf{elog}(S)=n\) is log-complete.
Proof. By the universality theorem, \(\mathsf{Log}_n\Rightarrow S\). As \(\mathsf{elog}(S)=n\), this is exactly \(\mathsf{Log}_{\mathsf{elog}(S)}\Rightarrow S\). ◻
Theorem 7 (Exact reduction criterion). If \(S\) is log-complete then, for every type \(T\), \[T\Rightarrow S \quad\Longleftrightarrow\quad \mathsf{elog}(T)\ge\mathsf{elog}(S).\] In particular this holds for every pair of log-complete types.
Proof. Let \(m=\mathsf{elog}(S)\); log-completeness gives \(\mathsf{Log}_m\Rightarrow S\). If \(T\Rightarrow S\), then since \(S\Rightarrow\mathsf{Log}_m\) by definition of \(\mathsf{elog}(S)=m\), Lemma 5 gives \(T\Rightarrow\mathsf{Log}_m\), whence \(\mathsf{elog}(T)\ge m\). Conversely, if \(\mathsf{elog}(T)\ge m\) then \(T\Rightarrow\mathsf{Log}_m\) by definition, and \(\mathsf{Log}_m\Rightarrow S\) by log-completeness, so Lemma 5 gives \(T\Rightarrow S\). ◻
Theorem 8 (Necessity of log-completeness). Fix a target \(S\). There is an integer \(m\) for which \(T\Rightarrow S \Leftrightarrow \mathsf{elog}(T)\ge m\) holds for every type \(T\) if and only if \(m=\mathsf{elog}(S)\) and \(S\) is log-complete.
Proof. If \(S\) is log-complete, the previous theorem supplies such an \(m=\mathsf{elog}(S)\). Conversely, suppose such an \(m\) exists. Applying the criterion to \(T=S\) (using \(S\Rightarrow S\)) gives \(\mathsf{elog}(S)\ge m\). Applying it to \(T=\mathsf{Log}_m\), where \(\mathsf{elog}(\mathsf{Log}_m)=m\) by Lemma 6, gives \(\mathsf{Log}_m\Rightarrow S\). Composing with \(S\Rightarrow\mathsf{Log}_{\mathsf{elog}(S)}\) yields \(\mathsf{Log}_m\Rightarrow\mathsf{Log}_{\mathsf{elog}(S)}\), so \(m=\mathsf{elog}(\mathsf{Log}_m)\ge\mathsf{elog}(S)\). Hence \(m=\mathsf{elog}(S)\), and \(\mathsf{Log}_m\Rightarrow S\) is precisely log-completeness. ◻
To apply the criterion to a candidate \(n\)-process target \(S\) it suffices to show three things: (i) \(S\Rightarrow\mathsf{Log}_n\), a lower bound on the power of \(S\); (ii) \(S\not\Rightarrow\mathsf{Log}_{n+1}\), a matching upper bound, for instance via \(\mathsf{elog}(S)\le c(S)\); and (iii) \(\mathsf{Log}_n\Rightarrow S\), which the universality theorem supplies automatically for deterministic targets. Then \(\mathsf{elog}(S)=n\), \(S\) is log-complete by Proposition [prop:arity], and \(T\Rightarrow S\iff\mathsf{elog}(T)\ge n\) for every source \(T\).
These are the explicit solo-explainable register implementations behind the one-shot collapse theorem.
Each process \(p_i\) has a single-writer register \(R_i\) initially \(\bot\). To propose \(v\), process \(p_i\) writes \(v\) to \(R_i\) if \(R_i=\bot\), scans all registers, and returns the lowest-index non-\(\bot\) value. Every returned value was proposed before the operation returned, giving weak consistency. Since only finitely many first writes occur, after a finite point all scans see the same set of proposals and return the same lowest-index value; the suffix is linearized after the operation that proposed that value. Thus eventual consensus is implementable from registers, so \(\mathsf{elog}(\mathsf{Consensus})=1\).
A single register \(R\) initially \(0\) suffices: read \(R\); if it is \(0\), write \(1\) and return \(\mathsf{win}\); otherwise return \(\mathsf{lose}\). At most finitely many concurrent operations can read \(0\) before the first write of \(1\). Choose \(t\) after all such winning responses. The suffix contains only losing responses and is linearized after one of the winning operations. Weak consistency is immediate: a winning operation is explained as first, and a losing operation is explained after an operation that wrote \(1\) before it returned. Hence \(\mathsf{elog}(\mathsf{TAS})=1\).
Proof of Theorem 6. Wait-freedom. Each operation performs one write to \(\mathit{Tag}[e]\), one \(\mathsf{FAA}\), one write to \(\mathit{Old}[e]\), a scan of the finite bitset \(\mathsf{bits}(m)\), finitely many register reads, and a finite graph computation, hence completes in finitely many of its own steps whenever the base \(\mathsf{FAA}\) is wait-free.
Weak consistency. Let \(x\) be a completed operation with exponent \(e\), \(\mathsf{FAA}\) response \(m\), and returned list \(L\). Because \(F\) is eventually linearizable it is weakly consistent, so \(m\) has a legal sequential \(\mathsf{FAA}\) explanation that uses only \(\mathsf{FAA}\) operations invoked before \(x\)’s response and includes all earlier \(\mathsf{FAA}\) operations of \(p_i\). Each operation adds a distinct power of two exactly once, so the integer \(m\) has a unique decomposition into such summands: \(\mathsf{bits}(m)\) is exactly the set of operations before \(x\) in that explanation. Every \(a\in\mathsf{bits}(m)\) wrote \(\mathit{Tag}[a]\) before invoking its \(\mathsf{FAA}\), hence was invoked before \(x\) responded, and the explanation contains all earlier completed operations of \(p_i\), so they lie in \(\mathsf{bits}(m)\). As \(L\) is a permutation of the tags of \(\mathsf{bits}(m)\), the sequential log history \(L\cdot x\) is legal and explains \(x\). Thus weak consistency holds for every completed operation, with no appeal to stabilization.
Eventual suffix linearizability. Let \(G\) be the history of operations on \(F\). Since \(F\) is eventually linearizable, \(G\) has a \(\tau\)-linearization \(S_F\) for some finite \(\tau\). For an operation \(a\) that appears in \(S_F\), write \(\operatorname{Pred}(a)=\{q:q<_{S_F}a\}\) for its set of predecessors in \(S_F\).
The contaminated prefix. Let \(D\) be the set of high-level operations whose \(\mathsf{FAA}\) operation appears in \(S_F\) and whose \(\mathsf{FAA}\) invocation occurs among the first \(\tau\) events of \(G\); it is finite. Pending \(\mathsf{FAA}\) operations invoked before \(\tau\) but omitted from \(S_F\) may appear in weak explanations of early responses, but they never appear in the exact post-\(\tau\) certificates considered below, so they need not be assigned a position in \(S_F\). The bad prefix must not be taken to be \(D\). Defining it by position in \(S_F\) rather than by invocation time is essential: an operation invoked before \(\tau\) may be linearized in \(S_F\) behind operations invoked later, so its bit need not appear in the certificate of every later operation. Set \[J=\max_{d\in D}\operatorname{pos}_{S_F}(d)\quad(\text{with }J=0\text{ if }D=\varnothing),\qquad P=S_F[1..J],\] the length-\(J\) prefix of \(S_F\). Then \(P\) is finite and \(D\subseteq P\). For instance, if \(S_F=[x,b,c,\dots]\) with \(D=\{b\}\), then \(J=2\) and \(P=\{x,b\}\): the operation \(x\) that fails to see \(b\) is itself absorbed into the prefix rather than required to see it.
Certificates do not point from \(P\) into the suffix. We claim that if \(p\in P\), \(\mathit{Old}[p]\) has been written, and \(q\) is an operation that appears in \(S_F\) outside \(P\), then \(q\notin\mathsf{bits}(\mathit{Old}[p])\). If the \(\mathsf{FAA}\) of \(p\) responds after \(\tau\), then by clause (iv) \(\mathsf{bits}(\mathit{Old}[p])=\operatorname{Pred}(p)\), and since \(P\) is a prefix of \(S_F\) containing \(p\), no operation outside \(P\) precedes \(p\). If the \(\mathsf{FAA}\) of \(p\) responds before \(\tau\), its value may be corrupted, but weak consistency still explains it by a legal \(\mathsf{FAA}\) history using only operations whose \(\mathsf{FAA}\) is invoked before that response, hence before \(\tau\); any such operation that also appears in \(S_F\) belongs to \(D\subseteq P\). Thus early pending operations omitted from \(S_F\) may occur in a corrupted old value, but no operation from the post-\(P\) suffix of \(S_F\) can.
The high-level cut. Because \(P\) is finite, there is a finite time \(T^{\ast}\) after every operation in \(P\) has been invoked and after every certificate \(\mathit{Old}[p]\) with \(p\in P\) has reached its final state: written to a fixed value, or permanently unset because \(p\) takes no further steps (a wait-free process that keeps stepping completes and writes its certificate, so an unwritten certificate means a halted process). Choose a high-level cut \(t\) after every operation invoked before \(T^{\ast}\) that ever completes has responded; only finitely many operations are invoked before \(T^{\ast}\), so \(t\) is finite. Operations responding before \(t\) are placed in the bad prefix.
Let \(x\) respond after \(t\). Then \(x\) completes and was invoked after \(T^{\ast}\), since otherwise it would have responded before \(t\). Hence \(x\notin P\supseteq D\), so the \(\mathsf{FAA}\) of \(x\) is invoked after \(\tau\), and every certificate \(\mathit{Old}[p]\) with \(p\in P\) that \(x\) reads in step 5 holds its final value. By clause (iv), \(\mathsf{bits}(\mathit{Old}[x])=\operatorname{Pred}(x)=P\cup Q_x\), where \(Q_x=\{q\notin P:q<_{S_F}x\}\). This is exactly the equality the invocation-based argument failed to deliver; with \(P\) defined by \(S_F\)-position it holds.
At the time \(x\) scans the registers in step 5, at most one operation in \(P\cup Q_x\) can have an unset \(\mathit{Old}\) register. Every operation of \(x\)’s own process that belongs to \(P\cup Q_x\) is an earlier high-level operation and has completed before \(x\) is invoked, so it has already written \(\mathit{Old}\). The other process has at most one pending high-level operation by well-formedness. Thus an unset certificate, if present, is unique.
Shape of \(\mathsf{StableOrder}(P\cup Q_x)\). We show \(\mathsf{StableOrder}(P\cup Q_x)=P_0\cdot Q_x^{S_F}\), where \(P_0\) is a fixed order of \(P\) and \(Q_x^{S_F}\) lists \(Q_x\) in \(S_F\) order.
\(P\) precedes \(Q_x\). Let \(p\in P\) and \(q\in Q_x\). If \(\mathit{Old}[q]\) is written then \(q\) is a post-\(\tau\) operation, so \(p\in\operatorname{Pred}(q)=\mathsf{bits}(\mathit{Old}[q])\) and the edge \(p\to q\) is present. If \(\mathit{Old}[q]\) is unset then the uniqueness observation implies that \(\mathit{Old}[p]\) is written; by the claim, \(q\notin\mathsf{bits}(\mathit{Old}[p])\), so again \(p\to q\). No reverse edge arises: if \(\mathit{Old}[p]\) is written then the claim gives \(q\notin\mathsf{bits}(\mathit{Old}[p])\), and if \(\mathit{Old}[q]\) is written then \(p\in\mathsf{bits}(\mathit{Old}[q])\). In particular there is an edge from every vertex of \(P\) to every vertex of \(Q_x\), and none back.
\(Q_x\) recovers \(S_F\). Let \(u,v\in Q_x\) with \(u<_{S_F}v\). If \(\mathit{Old}[v]\) is written then \(u\in\operatorname{Pred}(v)=\mathsf{bits}(\mathit{Old}[v])\), so \(u\to v\); if \(\mathit{Old}[v]\) is unset then the uniqueness observation implies that \(\mathit{Old}[u]\) is written, and \(v\notin\operatorname{Pred}(u)=\mathsf{bits}(\mathit{Old}[u])\), so again \(u\to v\). The reverse edge is impossible: when \(\mathit{Old}[u]\) is written, \(v\notin\operatorname{Pred}(u)\); when \(\mathit{Old}[v]\) is written, \(u\in\operatorname{Pred}(v)\). Thus the restriction to \(Q_x\) is the acyclic tournament given by \(S_F\).
\(P\) is fixed. After \(t\) the certificates of \(P\) are final, and the deterministic \(\mathsf{StableOrder}\) rule depends only on those final certificate states; hence the strongly-connected-component collapse and topological sort restricted to \(P\) yield a fixed permutation \(P_0\), independent of \(x\).
Since every cross edge runs from \(P\) to \(Q_x\), the component DAG places all of \(P_0\) before \(Q_x^{S_F}\), so \(\mathsf{StableOrder}(P\cup Q_x)=P_0\cdot Q_x^{S_F}\). Thus every operation responding after \(t\) returns \(P_0\) followed by its \(S_F\)-predecessors outside \(P\).
The linearization. Let \(S\) be \(P_0\) followed by the operations of \(S_F\) outside \(P\) in \(S_F\) order. By the previous paragraph \(S\) is a legal sequential log history giving every operation responding after \(t\) exactly its returned list. It respects real-time order after \(t\): if \(x\) responds before \(y\) is invoked and both events are after \(t\), then \(x,y\notin P\) and the \(\mathsf{FAA}\) of \(x\) responds before that of \(y\) is invoked, both after \(\tau\), so \(S_F\)—and hence \(S\)—orders \(x\) before \(y\). Therefore \(S\) is a \(t\)-linearization, and with weak consistency the implementation is eventually linearizable. ◻