Agreement Functions for Distributed Computing Models

TL;DR

This paper introduces agreement functions to characterize the computational capabilities of various distributed computing models, providing a unified framework to understand task solvability under different adversaries.

Contribution

It presents a novel, simple characterization of distributed models using agreement functions, capturing the computability of a broad class of adversaries.

Findings

Agreement functions precisely characterize task computability.

The framework applies to a wide class of fair adversaries.

Includes models with superset-closed and symmetric adversaries.

Abstract

The paper proposes a surprisingly simple characterization of a large class of models of distributed computing, via an agreement function: for each set of processes, the function determines the best level of set consensus these processes can reach. We show that the task computability of a large class of fair adversaries that includes, in particular superset-closed and symmetric one, is precisely captured by agreement functions.

Equations

$$\forall P\subseteq \Pi ,\forall Q\subseteq P,setcon(\mathcal{A}{|}_{P,Q})=min(|Q|,setcon(\mathcal{A}{|}_P)).$$

$$setcon(\mathcal{A}{|}_{P,Q})\le \min (|Q|,setcon(\mathcal{A}{|}_P))$$

Full text

1 Introduction

In general, a model of distributed computing is a set of runs, i.e., all allowed interleavings of steps of concurrent processes. There are multiple ways to define these sets of runs in a tractable way.

A natural one is based on failure models that describe the assumptions on where and when failures might occur. By the conventional assumption of uniform failures, processes fail with equal and independent probabilities, giving rise to the classical model of $t$-resilience, where at most $t$ processes may fail in a given run. The extreme case of $t=n-1$, where $n$ is the number of processes in the system, corresponds to the wait-free model.

The notion of adversaries [6] generalizes uniform failure models by defining a set of process subsets, called live sets, and assuming that in every model run, the set of correct, i.e., taking infinitely many steps, processes must be a live set. In this paper, we consider adversarial read-write shared memory models, i.e., sets of runs in which processes communicate via reading and writing in the shared memory and live sets define which sets of processes can be correct.

A conventional way to capture the power of a model is to determine its task computability, i.e., the set of distributed tasks that can be solved in it. For example, consider the [math]-resilient adversary $\mathcal{A}_{0\textrm{-}\textit{res}}$ defined through a single live set $\{p_{1},\ldots,p_{n}\}$: the adversary says that no process is allowed to fail (by taking only finitely many steps). It is easy to see that the model is strong enough to solve consensus, and, thus, any task [14]. 111In the “universal” task of consensus, every process has a private input value, and is expected to produce an output value, so that (validity) every output is an input of some process, (agreement) no two processes produce different output values, and (termination) every process taking sufficiently many steps returns.

In this paper, we propose a surprisingly simple characterization of the task computability of a large class of adversarial models through agreement functions.

An agreement function $\alpha$ maps subsets of processes $\{p_{1},\ldots,p_{n}\}$ to positive integers in $\{0,1,\ldots,n\}$. For each subset $P$, $\alpha(P)$ determines, intuitively, the level of set consensus that processes in $P$ can reach when no other process is active, i.e., the smallest number of distinct input values they can decide on.

For example, the agreement function of the wait-free shared-memory model is $\alpha_{wf}:P\mapsto|P|$ and the $t$-resilient model, where at most $t$ processes may fail or not participate, has $\alpha_{t,\textit{res}}:\;P\mapsto\max(0,|P|-n+t+1)$.

The agreement function of an adversary $\mathcal{A}$ can be computed using the notion of set consensus power of an adversary introduced in [13]: $\alpha_{\mathcal{A}}(P)=\mathit{setcon}(\mathcal{A}|_{P})$. Here $\mathcal{A}|_{P}$ is the restriction of $\mathcal{A}$ to $P$, i.e., the adversary defined through the live sets of $\mathcal{A}$ that are subsets of $P$.

To each agreement function $\alpha$, corresponding to an existing model, we associate a particular model, the $\alpha$-model. The $\alpha$-model is defined as the set of runs satisfying the following property: the set $P$ of participating (taking at least one step) processes in a run is such that $\alpha(P)\geq 1$ and is such that at most $\alpha(P)-1$ processes take only finitely many steps in it. An algorithm solves a task in the $\alpha$-model if processes taking infinitely many steps produces an output.

We show that, for the class of fair adversaries, agreement functions “tell it all” about task computability: a task is solvable in a fair adversarial model with agreement function $\alpha$ if and only if it is solvable in the $\alpha$-model. Fair adversaries include notably the class of superset-closed [16, 19] and the class of symmetric [22] adversaries. Intuitively, superset-closed adversaries do not anticipate failures of processes: if $S\in\mathcal{A}$ and $S\subseteq S^{\prime}$, then $S^{\prime}\in\mathcal{A}$. Symmetric adversaries do not depend on processes identifiers: if $S\in\mathcal{A}$, then for every set of processes $S^{\prime}$ such that $|S^{\prime}|=|S|$, we have $S^{\prime}\in\mathcal{A}$.

A corollary of our result is a characterization of the $k$-concurrency model [9]. Here we use the fact that the $k$-concurrency model is equivalent, with respect to task solvability, to the $k$-obstruction-freedom [13], a symmetric adversary consisting of live sets of sizes from $1$ to $k$. Thus, the agreement function $\alpha_{k\textit{-conc}}:\;P\mapsto\min(|P|,k)$ captures the $k$-concurrent task computability. An alternative characterization of $k$-concurrency via a compact affine task was suggested in [11].

There are, however, models that are not captured by their agreement functions. We give an example of a non-fair adversary that solves strictly more tasks than its $\alpha$-model. Characterizing the class of models that can be captured through their agreement function is an intriguing open question.

The rest of the paper is organized as follows. Section 2 gives model definitions. In Section 3, we formally define the notion of an agreement function. In Section 4, we present an $\alpha$-adaptive set consensus algorithm, and in Section 5, we prove a few useful properties of $\alpha$-models. In Section 6, we present the class of fair adversary, show that superset-closed and symmetric adversaries are fair and that fair adversaries are captured by their agreement functions. In Section 7, we give examples of models that are not captured by agreement functions. Section 8 reviews related work, and Section 9 concludes the paper.

2 Preliminaries

Processes, runs, models. Let $\Pi$ be a system of $n$ asynchronous processes, $p_{1},\ldots,p_{n}$ that communicate via a shared atomic-snapshot memory [1]. The atomic-snapshot (AS) memory is represented as a vector of $n$ shared variables, where each process is associated with a distinct position in this vector, and exports two operations: update and snapshot. An update operation performed by $p_{i}$ replaces position $i$ with a new value and a snapshot operation returns the current state of the vector.

We assume that processes run the full-information protocol: the first value each process writes is its input value. A process then alternates between taking snapshots of the memory and writing back the result of its latest snapshot. A run is thus a sequence of process identifiers stipulating the order in which the processes take operations: each odd appearance of $i$ corresponds to an update and each even appearance corresponds to a snapshot. A model is a set of runs.

Failures and participation. A process that takes only finitely many steps of the full-information protocol in a given run is called faulty, otherwise it is called correct. A process that took at least one step in a given run is called participating in it. The set of participating processes in a given run is called its participating set. Note that, since every process writes its input value in its first step, the inputs of participating processes are eventually known to every process that takes sufficiently many steps.

Tasks. In this paper, we focus on distributed tasks [18]. A process invokes a task with an input value and the task returns an output value, so that the inputs and the outputs across the processes which invoked the task respect the task specification. Formally, a task is defined through a set $\mathcal{I}$ of input vectors (one input value for each process), a set $\mathcal{O}$ of output vectors (one output value for each process), and a total relation $\Delta:\mathcal{I}\mapsto 2^{\mathcal{O}}$ associating to each input vector a set of valid output vectors. An input $\bot$ denote a not participating process and an output value $\bot$ denote an undecided process. Check [15] for more details.

In the task of $k$-set consensus, input values are in a set of values $V$ ($|V|\geq k+1$), output values are in $V$, and for each input vector $I$ and output vector $O$, $(I,O)\in\Delta$ if the set of non-$\bot$ values in $O$ is a subset of values in $I$ of size at most $k$. The special case of $1$-set consensus is called consensus [7].

Solving a task. We say that an algorithm $A$ solves a task $T=(\mathcal{I},\mathcal{O},\Delta)$ in a model $M$ if $A$ ensures that (1) in every run in which processes start with an input vector $I\in\mathcal{I}$, all decided values form a vector $O\in\mathcal{O}$ such that $(I,O)\in\Delta$, and (2) if the run is in $M$, then every correct process decides.

This gives rise to the notion of task solvability, i.e., a task $T$ is solvable in a model $M$ if and only if there exists an algorithm $A$ which solves $T$ in $M$.

BGG simulation. The principal technical tool in this paper is a simulation technique that we call the BGG simulation, after Borowski, Gafni, Guerraoui, collecting ideas presented in [3, 8, 9, 10]. The technique allows a system of $n$ processes that communicate via read-write shared memory and $k$-set consensus objects to simulate a $k$-process system running an arbitrary read-write algorithm.

In particular, we can use this technique to run an extended BG simulation [8] on top of these $k$ simulated processes, which gives a simulation of an arbitrary $k$-concurrent algorithm. An important feature of the simulation is that it adapts to the number of currently active simulated processes $a$: if it goes below $k$ (after some simulated processes complete their computations), the number of used simulators also becomes $a$. We refer to [11] for a detailed description of this simulation algorithm.

3 Agreement functions

Definition 1 (Agreement function)

The agreement function of a model $M$ is a function $\alpha:2^{\Pi}\to\{0,\ldots,n\}$, such that for each $P\in 2^{\Pi}$, in the set of runs of $M$ in which no process in $\Pi\setminus P$ participates, iterative $\alpha(P)$-set consensus can be solved, but $(\alpha(P)-1)$-set consensus cannot. By convention, if $M$ contains no (infinite) runs with participating set $P$, then $\alpha(P)=0$.

Intuitively, for each $P$, we consider a model consisting of runs of $M$ in which only processes in $P$ participate and determine the best level of set consensus that can be reached in this model, with [math] corresponding to a model that consists of finite runs only.

Note the agreement function $\alpha$ of a model $M$ is monotonic: $P\subseteq P^{\prime}$ $\Rightarrow$ $\alpha(P)\leq\alpha(P^{\prime})\leq|P^{\prime}|$. Indeed, the set of runs of $M$ where the processes in $\Pi\setminus P$ do not take any step is a subset of the set of runs of $M$ where the processes in $\Pi\setminus P^{\prime}$ do not take any step. Moreover, $|P^{\prime}|$-set consensus is trivially solvable in any model by making processes return their own proposal directly. In this paper, we only consider monotonic functions $\alpha$.

Definition 2 ($\alpha$-model)

Given a monotonic agreement function $\alpha$, the $\alpha$-model is the set of runs in which, the participating set $P$ satisfies: (1) $\alpha(P)\geq 1$; and, (2) at most $\alpha(P)-1$ participating processes take only finitely many steps.

We say that a model is characterized by its agreement function $\alpha$ if and only if it solves the same set of task as the $\alpha$-model.

Definition 3 ($\alpha$-adaptive set consensus)

The $\alpha$-adaptive set consensus task is an agreement task satisfying the validity and termination properties of consensus and the $\alpha$-agreement property: if at some time $\tau$, $k$ distinct values have been returned, then the current participating set $P_{\tau}$ is such that $\alpha(P_{\tau})\geq k$.

4 Adaptive set consensus

We can easily show that any model with agreement function $\alpha$ can solve the $\alpha$-adaptive set consensus task, i.e., to achieve the best level of set consensus without this an priori knowledge of the set of processes that are allowed to participate.

Let $M$ be a model and let $\alpha$ be its agreement function. Recall that, by definition, assuming that subsets of $P$ participate, there exists an algorithm that solves $\alpha(P)$-set consensus, let $\alpha(P)$-$\mathit{agreement}$ be such an algorithm.

We describe now an $\alpha$-adaptive set consensus algorithm providing the “best” level of consensus available in every participating set, without prior knowledge of who may participate. The algorithm adaptively ensures that if the participating set is $P$, then at most $\alpha(P)$ distinct input values can be decided.

The algorithm is presented in Algorithm 1. The idea is the following: every process $p$ writes its input in shared memory (line 1), and then takes a snapshot to get the current set $P$ of participating processes (lines 1–1).

Then processes adopt a value “locked” by a process associated to the largest participation (lines 1–1). It uses this new value as proposal for a simulated agreement solving $\alpha(parts)$ (feasible as it is accessed only by processes in $parts$ and $\alpha$ only increases with participation). The decision value obtained is then “locked” in memory by writing the value together with the current participation estimation size, $|parts|$, to the shared memory (line 1). If after locking the value, the updated participating set $P$ (lines 1–1), has not changed (line 1), the process returns its current decision estimate, $v$ (line 1). Otherwise, if participation has changed, then the same construction is applied again and again until it has been executed with an observed stable participation (lines 1–1).

Theorem 4.1

In any run with a participating set $P$, Algorithm 1 satisfies the following properties:

• –

Termination:* All correct processes eventually decide.*

• –

$\alpha$-Agreement:* if at some time $\tau$, $k$ distinct values have been returned, then the current participating set $P_{\tau}$ is such that $\alpha(P_{\tau})\geq k$.*

• –

Validity:* Each decided value has been proposed by some process.*

Proof

Let us show that Algorithm 1 satisfies the following properties:

• –

Validity: Processes can only decide on their current estimated decision value $v$ (line 1). This value $v$ is first initialized to their own input proposal (line 1), and it can then only be replaced by adopting another process’s current, initialized, estimated decision value. Adaopting this value can either be done directly (line 1), or through an agreement protocol (line 1) satisfying the same validity property.

• –

Termination: Assume that a correct process never decides. Then it must be blocked executing the while loop indefinitely often (at lines 1–1). So the participation observed must have changed at each iteration (line 1). But, as participation can only increase, it must have been strictly increased infinitely often – a contradiction with the finiteness of the system size.

• –

$\alpha$-Agreement: We say that a process returns at level $t$ if it exited the while loop (line 1) with a last participation observed of size $t$. Let $l$ be the smallest level at which a process returns, and let $O_{l}$ the set of values ever written to $R$ at level $l$ , i.e., values $v$ such that $(v,l)$ ever appears in $R$. We shall show that for all $l^{\prime}>l$, $O_{l^{\prime}}\subseteq O_{l}$.

Indeed, let $q$ be the first process to write a value $(v^{\prime},l^{\prime})$ (in line 1), such that $l^{\prime}>l$, in $R$. Thus, the immediately preceding snapshot, taken before this write in lines 1 or 1, witnessed a participating set of size $l^{\prime}$. Hence, the snapshot of $q$ succeeds the last snapshot (of size $l<l^{\prime}$) taken by any process $p$ that returned at level $l$. But immediately before taking this last snapshot, every such process has written $(v,l)$ in R (line 1) for some $v\in O_{l}$. Therefore $q$ must see $(v,l)$ in its snapshot of size $l^{\prime}$ and, since, by assumption, the snapshot contains no values written at levels higher than $l$, $q$ must have adopted some value written at level $l$, i.e., $v^{\prime}\in O_{l}$. Inductively, we can derive that any subsequent process will have to adopt a value in $O_{l}$.

We have shown that every returned value must appear in $O_{l}$, where $l$ is the smallest level at which some process exits the while loop (line 1).

Participation can only grow due to snapshots inclusion property, thus there is a single participating set of size $l$, $P_{l}$, which can be observed in a given run. A value in $O_{l}$ has been adopted as the decision returned by the $\alpha(P_{l})$-agreement, that can return at most $\alpha(P_{l})$ values as it was only accessed by processes in $P_{l}$. Therefore the set of returned decisions, as included in $O_{l}$, is smaller or equal to $\alpha(P_{l})$. Last, it easy to see that for any process returning at a time $\tau$, the participation $P_{\tau}$ at time $\tau$ is such that $P_{l}\subseteq P_{\tau}$ and thus that $\alpha(P_{l})\leq\alpha(P_{\tau})$. Therefore, the number of distinct returned decisions returned at any time $\tau$ is smaller or equal to $\alpha(P_{\tau})$.

This adaptive agreement is simple but central for all our model simulations. All reductions are constructed with a common simulation structure. Processes write their input, then use their access to shared memory and their ability to solve this adaptive agreement to simulate an adaptive BGG simulation where the number of active BG simulators is equal at any time $\tau$ to at most $\alpha_{M}(P_{\tau})$, with $P_{\tau}$ the participating set at time $\tau$, with at least one of these BG simulators taking infinitely many steps.

5 Properties of the $\alpha$-model

We now relate task solvability in the $\alpha$-model and in $M$. More precisely, we show that (1) the agreement function of the $\alpha$-model is $\alpha$ and (2) any task $T$ solvable in the $\alpha$-model is also solvable in every model with agreement function $\alpha$.

Theorem 5.1

The agreement function of the $\alpha$-model is $\alpha$.

Proof

Take $P$ such that $\alpha(P)>1$ and consider the set of runs of the $\alpha$-model in which no process in $\Pi\setminus P$ participates and, thus, according to the monotonicity property, at most $\alpha(P)-1$ processes are faulty. To solve $\alpha(P)$-set consensus, we use the safe-agreement protocol [2], the crucial element of BG simulation. Safe agreement solves consensus if every process that participates in it takes enough steps. The failure of a process then may block the safe-agreement protocol. In our case as at most $\alpha(P)-1$ processes in $P$ can fail, so we can simply run $\alpha(P)$ safe agreement protocols: every process goes through the protocols one by one using its input as a proposed value, if the protocol blocks, it proceeds to the next one in the round-robin manner. The first protocol that returns gives the output value. Since at most $\alpha(P)-1$ processes are faulty, at least one safe agreement eventually terminates, and there are at most $\alpha(P)$ distinct outputs. To see that $(\alpha(P)-1)$ cannot be solved in this set of runs, recall that one cannot solve $(\alpha(P)-1)$-set consensus $(\alpha(P)-1)$-resiliently [2, 18, 21].

The following result is instrumental in our characterizations of fair adversaries:

Theorem 5.2

For any task $T$ solvable in an $\alpha$-model, $T$ is solvable in any read-write shared memory model which solves the $\alpha$-adaptive set consensus task.

Proof

Using $\alpha$-adaptive set consensus and read-write shared memory, we can run $BGG$-simulation so that, when the participating set is $P$, at most $\alpha(P)$ BG simulators are activated and at least one is live (i.e., takes part in infinitely many simulation steps). Moreover, we make a process provided with a (simulated) task output to stop proposing simulated steps to BGG simulation. Hence, the number of active simulators is also bounded by the number of participating processes without an output, with at least one live BG simulator if there is a correct process without a task output.

These BG simulators are used to simulate an execution of a protocol solving $T$ in the $\alpha$-model. And so, since any finite run can be extended to a valid run of the $\alpha$-model, the protocol can only provide valid outputs.

We make BG simulators execute the breadth-first simulation: every BG simulator executes an infinite loop consisting of (1) updating the estimated participating set $P$, then (2) try to execute a simulation step of every process in $P$, one by one.

Now assume that there exist $k\geq 1$ correct processes that are never provided with a task output. BGG simulation ensure that we eventually have at most $min(k,\alpha(P))$ active simulators, with at least one live among them. Let $s$ be such a live simulator. After every process in $P$ have taken their first steps, $s$ tries to simulate steps for every process of $P$ infinitely often. A process simulation step can be blocked forever only due to an active but not live BG simulator222 Note that the extended BG-simulation provides a mechanism which ensures that a simulation step is not blocked forever by a no longer active BG simulator., thus there are at most $min(k,\alpha(P))-1$ simulated processes in $P$ taking only finitely many steps.

As at most $\alpha(P)-1$ processes have a finite number of simulated steps, the simulated run is a valid run of the $\alpha$-model. Moreover, as at most $k-1$ processes have a finite number of simulated steps, there is one process never provided with a task output simulated as a correct process. But, a protocol solving a task eventually provides task outputs to every correct process — a contradiction.

Using Theorem 4.1 in combination with Theorem 5.2, we derive that:

Corollary 1

Let $M$ be any model, $\alpha_{M}$ be its agreement function, and $T$ be any task that is solvable in the $\alpha_{M}$-model. Then $M$ solves $T$.

6 Characterizing fair adversaries

An adversary $\mathcal{A}$ is a set of subsets of $\Pi$, called live sets, $\mathcal{A}\subseteq 2^{\Pi}$. An infinite run is $\mathcal{A}$-compliant if the set of processes that are correct in that run belongs to $\mathcal{A}$. An adversarial $\mathcal{A}$-model is thus defined as the set of $\mathcal{A}$-compliant runs.

An adversary is superset-closed [19] if each superset of a live set of $\mathcal{A}$ is also an element of $\mathcal{A}$, i.e., if $\forall S\in\mathcal{A}$, $\forall S^{\prime}\subseteq\Pi$, $S\subseteq S^{\prime}\implies S^{\prime}\in\mathcal{A}$. Superset-closed adversaries provide a non-uniform generalization of the classical $t$-resilient adversary consisting of sets of $n-t$ or more processes.

An adversary $\mathcal{A}$ is a symmetric adversary if it does not depend on process identifiers: $\forall S\in\mathcal{A}$, $\forall S^{\prime}\subseteq\Pi$, $|S^{\prime}|=|S|\implies S^{\prime}\in\mathcal{A}$. Symmetric adversaries provides another interesting generalization of the classical $t$-resilience condition and $k$-obstruction-free progress condition [9] which was previously formalized by Taubenfeld as its symmetric progress conditions [22].

6.1 Set consensus power

The notion of the set consensus power [12] was originally proposed to capture the power of adversaries in solving colorless tasks [3, 4], i.e., tasks that can be defined by relating sets of inputs and outputs, independently of process identifiers.

Definition 4

The set consensus power of $\mathcal{A}$, denoted by $\mathit{setcon}(\mathcal{A})$, is defined as follows:

• –

If $\mathcal{A}=\emptyset$, then $\mathit{setcon}(\mathcal{A})=0$

• –

Otherwise, $\mathit{setcon}(\mathcal{A})=\max_{S\in\mathcal{A}}\min_{a\in S}\mathit{setcon}(\mathcal{A}|_{S\setminus\{a\}})+1{}.$ 333$\mathcal{A}|_{P}$ is the adversary consisting of all live sets of $\mathcal{A}$ that are subsets of $P$.

Thus, for a non-empty adversary $\mathcal{A}$, $\mathit{setcon}(\mathcal{A})$ is determined as $\mathit{setcon}(\mathcal{A}|_{S\setminus\{a\}})+1$ where $S$ is an element of $\mathcal{A}$ and $a$ is a process in $S$ that “max-minimize” $\mathit{setcon}(\mathcal{A}|_{S\setminus\{a\}})$. Note that for $\mathcal{A}\neq\emptyset$, $\mathit{setcon}(\mathcal{A})\geq 1$.

It is shown in [12] that $\mathit{setcon}(\mathcal{A})$ is the smallest $k$ such that $\mathcal{A}$ can solve $k$-set consensus.

It was previously shown in [13] that for a superset-closed adversary $\mathcal{A}$, the set consensus power of $\mathcal{A}$ is equal to $\mathit{csize}(\mathcal{A})$, where $\mathit{csize}(\mathcal{A})$ denote the minimal hitting set size of $\mathcal{A}$, i.e., a minimal subset of $\Pi$ that intersects with each live set of $\mathcal{A}$. Therefore if $\mathcal{A}$ is superset-closed, then $\mathit{setcon}(\mathcal{A})=\mathit{csize}(\mathcal{A})$. For a symmetric adversary $\mathcal{A}$, it can be easily derived from the definition of $\mathit{setcon}$ that $\mathit{setcon}(\mathcal{A})=|\{k\in\{1,\dots,n\}:\exists S\in\mathcal{A},|S|=k\}|$.

Theorem 6.1

The agreement function of adversary $\mathcal{A}$ is $\alpha_{\mathcal{A}}(P)=\mathit{setcon}(\mathcal{A}|_{P})$.

Proof

An algorithm $A_{P}$ that solves $\alpha_{\mathcal{A}}(P)$-set consensus, assuming that the participating set is a subset of $P$, is a straightforward generalization of the result of [12]. It is shown in [12] that $\mathit{setcon}(\mathcal{A})$-set consensus can be solved in $\mathcal{A}$. But if we restrict the runs to assume that the processes in $\Pi\setminus P$ do not take a single step, then the set of possible live sets reduces to $\mathcal{A}|_{P}$. Thus using the agreement algorithm of [12] for the adversary $\mathcal{A}|_{P}$, we obtain a $\mathit{setcon}(\mathcal{A}|_{P})$-set consensus algorithm, or equivalently, an $\alpha_{\mathcal{A}}(P)$-set consensus algorithm.

It is immediate from Theorem 6.1 that $\mathcal{A}\subseteq\mathcal{A}^{\prime}$ implies $\mathit{setcon}(\mathcal{A})\leq\mathit{setcon}(\mathcal{A}^{\prime})$.

6.2 Fair adversaries

In this paper we propose a class of adversaries which encompasses both classical classes of super-set closed and symmetric adversaries. Informally, an adversary is fair if its set consensus power does not change if only a subset of the processes are participating in an agreement protocol.

More precisely, consider $\mathcal{A}$-compliant runs with participating set $P$ and assume that processes in $Q\subseteq P$ want to reach agreement among themselves: only these processes propose inputs and are expected to produce outputs. We can only guarantee outputs to processes in $Q$ when the set of correct processes include some process in $Q$, i.e., when the current live set intersect with $Q$. Thus, the best level of set consensus reachable by $Q$ is defined the set consensus power of adversary $\mathcal{A}|_{P,Q}=\{S\in\mathcal{A}|_{P},S\cap Q\neq\emptyset\}$, unless $|Q|<\mathit{setcon}(\mathcal{A}|_{P})$.

Definition 5

[Fair adversary] An adversary $\mathcal{A}$ is fair if and only if:

[TABLE]

Property 1

[TABLE]

Proof

For any $P\subseteq\Pi$ and $Q\subseteq P$, $\mathcal{A}|_{P,Q}=\{S\in\mathcal{A}|_{P},S\cap Q\neq\emptyset\}$ is a subset of $\mathcal{A}|_{P}$ and, thus, $\mathit{setcon}(\mathcal{A}|_{P,Q})\leq\mathit{setcon}(\mathcal{A}|_{P})$. Moreover, $\mathit{setcon}(\mathcal{A}|_{P,Q})\leq|Q|$, as $|Q|$-set consensus can be solved in $\{S\in\mathcal{A}|_{P},S\cap Q\neq\emptyset\}$ as follows: every process waits until some process in $Q$ writes its input and decides on it.

Theorem 6.2

Any superset-closed adversary is fair.

Proof

Suppose that there exists a superset-closed adversary $\mathcal{A}$ that is not fair, i.e., by Property 1, $\exists P\subseteq\Pi,\exists Q\subseteq P,\mathit{setcon}(\{S\in\mathcal{A}|_{P},S\cap Q\neq\emptyset\})<min(|Q|,\mathit{setcon}(\mathcal{A}|_{P}))$. Clearly $\mathcal{A}|_{P}$ and $\mathcal{A}|_{P,Q}$ are also superset-closed and, thus, $\mathit{setcon}(\mathcal{A}|_{P})=\mathit{csize}(\mathcal{A}|_{P})$ and $\mathit{setcon}(\mathcal{A}|_{P,Q})=\mathit{csize}(\mathcal{A}|_{P,Q})$.

Since $\mathit{setcon}(\mathcal{A}|_{P,Q})<|Q|$, a minimal hitting set $H^{\prime}$ of $\mathcal{A}|_{P,Q}$ is such that $|H^{\prime}|<|Q|$, and therefore there exists a process $q\in Q$, $q\not\in H^{\prime}$. Also, since $\mathit{setcon}(\mathcal{A}|_{P,Q})<\mathit{setcon}(\mathcal{A}|_{P})$, $H^{\prime}$ is not a hitting set of $\mathcal{A}|_{P}$. Thus, there exists $S\in\mathcal{A}|_{P}$ such that $S\cap H^{\prime}=\emptyset$. Hence, $(S\cup\{q\})\cap H^{\prime}=\emptyset$. Since $\mathcal{A}|_{P}$ is superset closed, we have $S\cup\{q\}\in\mathcal{A}|_{P}$ and, since $q\in Q$, $S\cup\{q\}\in\mathcal{A}|_{P,Q}$. But $(S\cup\{q\})\cap H^{\prime}=\emptyset$—a contradiction with $H^{\prime}$ being a hitting set of $\mathcal{A}|_{P,Q}$.

Theorem 6.3

Any symmetric adversary is fair.

Proof

The set consensus power of a generic adversary $\mathcal{A}$ is defined recursively through finding $S\in\mathcal{A}$ and $p\in S$ which max-minimize the set consensus power of $\mathcal{A}|_{S\setminus\{p\}}$. Let us recall that if $\mathcal{A}\subseteq\mathcal{A}^{\prime}$ then $\mathit{setcon}(\mathcal{A})\leq\mathit{setcon}(\mathcal{A}^{\prime})$. Therefore, $S$ can always be selected to be locally maximal, i.e., such that there is no live set in $S^{\prime}\in\mathcal{A}$ with $S\subsetneq S^{\prime}$.

Suppose by contradiction that $\mathcal{A}$ is symmetric but not fair, i.e., by Property 1, for some $P\subseteq\Pi$ and $Q\subseteq P$, $\mathit{setcon}(\mathcal{A}|_{P,Q})<min(|Q|,\mathit{setcon}(\mathcal{A}|_{P}))$. We show that if the property holds for $P$ and $Q$ such that $\mathcal{A}|_{P,Q}\neq\emptyset$ then it also holds for some $P^{\prime}\subsetneq P$ and $Q^{\prime}\subseteq Q$.

First, we observe that $|Q|>1$, otherwise $\mathit{setcon}(\mathcal{A}|_{P,Q})=0$ and, thus, we have $\mathcal{A}|_{P,Q}=\emptyset$.

Since $\mathcal{A}$ is symmetric, $\mathcal{A}|_{P}$ is also symmetric. Thus, for every $S\in\mathcal{A}|_{P}$ and $p\in S$ such that $\mathit{setcon}(\mathcal{A}|_{P})=1+\mathit{setcon}(\mathcal{A}|_{S\setminus\{p\}})$, any $S^{\prime}$ such that $|S^{\prime}|=|S|$ and for any $p^{\prime}\in S^{\prime}$, we also have $\mathit{setcon}(\mathcal{A}|_{P})=1+\mathit{setcon}(\mathcal{A}|_{S^{\prime}\setminus\{p^{\prime}\}})$. Since we can always choose $S$ to be a maximal set, we derive that the equality holds for every maximal set $S$ in $\mathcal{A}|_{P}$ and every $p\in S$.

Let us recall that, by the definition of $\mathit{setcon}$, there exists $L\in\mathcal{A}|_{P,Q}$ and $a\in L$ such that $\mathit{setcon}(\mathcal{A}|_{P,Q})=1+\mathit{setcon}((\mathcal{A}|_{P,Q})|_{L\setminus\{a\}})=\mathit{setcon}(\mathcal{A}|_{L,Q})$. Since $\mathcal{A}|_{P}$ is symmetric, for all $L^{\prime}$, $|L^{\prime}|=|L|$ and $L\cap Q\subseteq L^{\prime}\cap Q$, we have $\mathit{setcon}(\mathcal{A}|_{L^{\prime},Q})\geq\mathit{setcon}(\mathcal{A}|_{L,Q})$. Indeed, modulo a permutation of process identifiers, $\mathcal{A}|_{L^{\prime},Q}$ contains all the live sets of $\mathcal{A}|_{L,Q}$ plus live sets in $\mathcal{A}|_{L^{\prime}}$ that overlap with $(L^{\prime}\cap Q)\setminus(L\cap Q)$. Since $\mathit{setcon}(\mathcal{A}|_{L,Q})=\mathit{setcon}(\mathcal{A}|_{P,Q})$ and $L^{\prime}\in\mathcal{A}|_{P,Q}$, we have $\mathit{setcon}(\mathcal{A}|_{L^{\prime},Q})=\mathit{setcon}(\mathcal{A}|_{L,Q})$. Therefore, for any $a\in L^{\prime}$, $\mathit{setcon}(\mathcal{A}|_{L^{\prime}\setminus\{a\},Q})<\mathit{setcon}(\mathcal{A}|_{L^{\prime}\setminus\{a\}})$.

In particular, for $L^{\prime}$ with $L^{\prime}\cap Q\in\{L^{\prime},Q\}$, $\mathit{setcon}(\mathcal{A}|_{L^{\prime},Q})=\mathit{setcon}(\mathcal{A}|_{L,Q})$. Note that $L^{\prime}\nsubseteq Q$, otherwise, $\mathcal{A}|_{L^{\prime},Q}=\mathcal{A}|_{L^{\prime}}$ and, thus, $\mathit{setcon}(\mathcal{A}|_{L^{\prime},Q})=\mathit{setcon}(\mathcal{A}|_{L^{\prime}})=\mathit{setcon}(\mathcal{A}|_{P})$, contradicting our assumption.

Thus, let us assume that $Q\subsetneq L^{\prime}$. Note that $Q^{\prime}=Q\setminus\{a\}\subsetneq L^{\prime}\setminus\{a\}$, and since $|Q|\geq 2$, $Q^{\prime}\neq\emptyset$, we have $\mathit{setcon}(\mathcal{A}|_{P^{\prime},Q^{\prime}})<\mathit{setcon}(\mathcal{A}|_{P^{\prime}})$ for $P^{\prime}=L^{\prime}\setminus\{a\}$ and $Q^{\prime}\subseteq P^{\prime}$, $Q^{\prime}\neq\emptyset$. Furthermore, since $\mathit{setcon}(\mathcal{A}|_{P,Q})<|Q|$, we have $\mathit{setcon}(\mathcal{A}|_{P^{\prime},Q^{\prime}})<|Q^{\prime}|$.

By applying this argument inductively, we end up with a live set $P$ and $Q\subseteq P$ such that $\mathit{setcon}(\mathcal{A}|_{P})\geq 1$, $Q\neq\emptyset$ and $\mathit{setcon}(\mathcal{A}|_{P,Q})=0$. By the definition of $\mathit{setcon}$, $\mathcal{A}|_{P}\neq\emptyset$ and $\mathcal{A}|_{P,Q}=\emptyset$. But $\mathcal{A}|_{P}$ is symmetric and $Q\neq\emptyset$, so for every $S\in\mathcal{A}|_{P}$, there exists $S^{\prime}\in\mathcal{A}|_{P}$ such that $|S|=|S^{\prime}|$ and $S^{\prime}\cap Q\neq\emptyset$, i.e., $\mathcal{A}|_{P,Q}\neq\emptyset$—a contradiction.

Note that not all adversaries are fair. For example, the adversary $\mathcal{A}=\{\{p_{1}\},\{p_{2},p_{3}\},\{p_{1},p_{2},p_{3}\}\}$ is not fair. On the other hand, not all fair adversaries are either super-set closed or symmetric. For example, the adversary $\mathcal{A}=2^{\{p_{1},p_{2},p_{3}\}}\setminus\{p_{1},p_{2}\}$ is fair but is neither symmetric not super-set closed. Understanding what makes an adversary fair is an interesting challenge.

6.3 Task computability in fair adversarial models

In this section, we show that the task computability of a fair adversarial $\mathcal{A}$-model is fully grasped by its associated agreement function $\alpha_{\mathcal{A}}$.

Using BGG simulation, we show that the $\alpha_{\mathcal{A}}$-model can be used to solve any task $T$ solvable in the $\mathcal{A}$-model. In the simulation, up to $\alpha(P)$ BG simulators execute the given algorithm solving $T$, where $P$ is the participating set of the current run.

We adapt the currently simulated live set to include processes not yet provided with a task output, and ensure that the chosen live set is simulated sufficiently long until some active processes are provided with outputs of $T$. The simulation terminates as soon as all correct processes are provided with outputs.

The code for BG simulator $b_{i}\in\{b_{1},\dots,b_{\alpha_{\mathcal{A}}(\Pi)}\}$ is given in Algorithm 2. It consists of two parts: (1) selecting a live set to simulate (lines 2–2), and (2) simulating processes in the selected live set (lines 2–2).

Selecting a live set. This is the most involved part. The idea is to select a participating live set $L\subseteq P$ such that: (1) the set consensus power of $\mathcal{A}|_{L,A}=\{S\in\mathcal{A}|_{L},S\cap A\neq\emptyset\}$, with $A$ the set of participating processes not yet provided with a task output, is greater than or equal to the BG simulator identifier $i$; (2) $L$ is a subset of the live sets currently selected by live BG simulators with greater identifiers; (3) $L$ does not contain the processes currently simulated by live BG simulators with greater identifiers.

The live set selection in Algorithm 2 consists in two phases. First, BG simulators determine a selection window $W$, $W\subseteq P$, i.e., the largest set of processes which is a subset of the live sets selected by live BG simulators with greater identifiers, and which excludes the processes currently selected by live BG simulators with greater identifiers (lines 2–2). This is done iteratively on all BG simulators with greater identifiers, from the greatest to the lowest. At each iteration, if the targeted BG simulator $b_{k}$ appears live, the current window is restricted to the live set selected by $b_{k}$, but excluding the process selected by $b_{k}$. Determining if $b_{k}$ appears live is simply done by checking whether, with the current simulation status observed, the live set selected by $b_{k}$ is valid, i.e., satisfies conditions (1), (2) and (3) above.

The second phase (lines 2–2), consists in checking if the currently selected live set is valid (line 2). If not, the BG simulator tries to select a live set $L$ which belongs to the selection window $W$, and hence satisfies (2) and (3), but also such that the set consensus power of $\mathcal{A}_{L,A}$ is greater than $i$, the BG simulator identifier (line 2). If the simulator does not find such a live set, it simply selects any available live set (line 2).

Simulating a live set. The idea is that, if the selected live set does not change, the BG simulator simulates steps of every process in its selected live set infinitely often. Unlike conventional variations of BG simulations, a BG simulator here does not skip a blocked process simulation, instead it aborts and re-tries the same simulation step until it is successful.

Intuitively, this does not obstruct progress because, in case of a conflict, there are two live BG simulators blocked on the same simulation step, but the BG simulator with the smaller identifier will eventually change its selected live set and release the corresponding process.

Pseudocode. The protocol executed by processes in the $\alpha_{\mathcal{A}}$-model is the following: Processes first update their status in $P_{MEM}$ by replacing $\bot$ with their initial state. Then, processes participate in an $\alpha_{\mathcal{A}}$-adaptive BGG simulation (i.e., BGG simulation runs on top of an $\alpha_{\mathcal{A}}$-adaptive set consensus protocol), where BG simulators use Algorithm 2 to simulate an algorithm solving a given task $T$ in the adversarial $\mathcal{A}$-model. When a process $p$ observes that $P_{MEM}[p]$ has been set to $\top$ (“termination state”), it stops to propose simulation steps.

Proof of correctness. Let $P_{f}$ be the participating set of the $\alpha_{\mathcal{A}}$-model run, and let $A_{f}$ be the set of processes $p\in P_{f}$ such that $P_{MEM}[p]$ is never set to $\top$.

Lemma 1

There is a time after which variables $P$ and $A$ in Algorithm 2 become constant and equal to $A_{f}$ and $P_{f}$ for all live BG simulators.

Proof

Since $\Pi$ is finite, the set of processes $p$ such that $P_{MEM}[p]\neq\bot$ eventually corresponds to $P_{f}$ as the first step of $p$ is to set $P_{MEM}[p]$ to its initial state and $P_{MEM}[p]$ can only be updated to $\top$ afterwards. As after $P_{MEM}[p]$ is set to $\top$, it cannot be set to another value, eventually, the set of processes from $P_{f}$ such that $P_{MEM}[p]\neq\top$ is equal to $A_{f}$. Live BG simulators update $P$ and $A$ infinitely often, so eventually their values of $P$ and $A$ are equal to $P_{f}$ and $A_{f}$ respectively.

Lemma 2

If $A_{f}$ contains a correct process, then there is a correct BG simulator with an identifier smaller or equal to $min(|A_{f}|,\alpha_{\mathcal{A}}(P_{f}))$.

Proof

In our protocol, eventually only correct processes in $A_{f}$ are proposing BGG simulation steps. Thus eventually, at most $|A_{f}|$ distinct simulations steps are proposed. The $\alpha_{A}$-adaptive set consensus protocol used for BGG simulation ensures that at most $\alpha_{\mathcal{A}}(P_{f})$ distinct proposed values are decided. But as there is a time after which only processes in $A_{f}$ propose values, eventually, $min(|A_{f}|,\alpha_{\mathcal{A}}(P_{f}))$-set consensus is solved. Thus BGG simulation ensures that, when this is the case, there is a live BG simulator with an identifier smaller or equal to $min(|A_{f}|,\alpha_{\mathcal{A}}(P_{f}))$.

Suppose that $A_{f}$ contains a correct process, and let $b_{m}$ be the greatest live BG simulator such that $m\leq min(|A_{f}|,\alpha_{\mathcal{A}}(P_{f}))$ (by Lemma 2). Let $S_{i}(t)$ denote the value of $S_{cur}$ and let $p_{i}(t)$ denote the value of $p_{cur}$ at simulator $b_{i}$ at time $t$. Let also $\tau_{f}$ be the time after which every active but not live BG simulators have taken all their steps, and after which $A$ and $P$ have become constant and equal to $A_{f}$ and $P_{f}$ for every live BG simulator (by Lemma 1).

Lemma 3

For every live BG simulator $b_{s}$, with $s\leq min(|A_{f}|,\alpha_{\mathcal{A}}(P_{f}))$, eventually, $b_{s}$ cannot fail the test on line 2.

Proof

Consider a correct BG simulator $b_{s}$ starting a round after time $\tau_{f}$. Let $W_{s}$ be the value of $W$ at the end of line 2. Two cases may arise:

• If $W_{s}=P_{f}$, as $\mathcal{A}$ is fair, then $\mathit{setcon}(\mathcal{A}|_{W_{s},A_{f}})=\min(|A_{f}|,\mathit{setcon}(\mathcal{A}|_{P_{f}}))$. Thus, $\mathit{setcon}(\mathcal{A}|_{W_{s},A_{f}})\geq s$.

• Otherwise, $W_{s}$ is set on line 2 to some $S_{target}\setminus\{p_{target}\}$ at some iteration $l$, with $\mathit{setcon}(\mathcal{A}|_{S_{target},A_{f}})\geq l$ for $l>s$. We have $\mathit{setcon}(\mathcal{A}|_{W_{s},A_{f}})=\mathit{setcon}((\mathcal{A}|_{S_{target},A})|_{S_{target}\setminus\{p_{target}\}})$ which, by the definition of $\mathit{setcon}$, is greater or equal to $\mathit{setcon}(\mathcal{A}|_{S_{target},A})-1\geq l-1\geq s$, so we have $\mathit{setcon}(\mathcal{A}|_{W_{s},A_{f}})\geq s$.

By the definition of $\mathit{setcon}$, as $\mathit{setcon}(\mathcal{A}|_{W_{s},A_{f}})\geq s$, there exists $S\subseteq W_{s}$ such that $\mathit{setcon}(\mathcal{A}|_{S,A_{f}})\geq s$. So, eventually $b_{s}$ will always succeed the test on line 2.

Lemma 4

For every live BG simulator $b_{s}$, with $s\leq min(|A_{f}|,\alpha_{\mathcal{A}}(P_{f}))$, eventually, the value of $W$ computed at the end of iteration $m+1$ (at lines 2–2) is equal to some constant value $W_{m,f}$.

Proof

No BG simulator $b_{l}$, with $l>m$, executes lines 2–2 after time $\tau_{f}$. Therefore $R[l]$ is constant after time $\tau_{f}$, $\forall l>m$. As the computation of $W$, on lines 2–2, only depends on the value of $A$, $P$ and $R[l]$, for $\alpha_{\mathcal{A}}(\Pi)\geq l>m$, all constant after time $\tau_{f}$, then the value of $W$ computed at the end of line 2 for iteration $m+1$ is the same at every round initiated after time $\tau_{f}$ for any live BG simulator $b_{s}$, with $s\leq min(|A_{f}|,\alpha_{\mathcal{A}}(P_{f}))$.

Lemma 5

If $A_{f}$ contains a correct process, then the set of processes with an infinite number of simulated steps is a live set of $\mathcal{A}$ containing a process of $A_{f}$.

Proof

As $b_{m}$ is live, it proceeds to an infinite number of rounds. By Lemma 4, eventually $b_{m}$ computes the same window in every round. By Lemma 3, if $b_{m}$ does not have a valid live set selected, then it eventually selects a valid one for $W_{m,f}$. Thus, eventually $b_{m}$ never changes its selected live set. Let $S_{m,f}$ be this live set. Afterwards, in each round, $b_{m}$ tries to complete a simulation step of $p_{m}(t)$ and, if successfully completed, changes $p_{m}(t)$ in a round robin manner among $S_{m,f}$. Two cases may arise:

• If $p_{m}(t)$ never stabilizes, then the set of processes with an infinite number of simulated steps includes $S_{m,f}$. By Lemma 4, every other live BG simulator with a smaller identifier computes the same value of $W$ at the end of round $m+1$ (of the loop at lines 2–2). Thus, after the $S_{m,f}$ is selected by $b_{m}$, as $S_{m,f}$ is valid, every BG simulator will select a subset of $S_{m,f}$ for its window value in every round. Moreover, by Lemma 3, these BG simulators will always find valid live sets to select, and so they will eventually simulate only processes in $S_{m,f}$. Thus, the set of processes with infinitely many simulated steps is equal to $S_{m,f}$, a live set intersecting with $A_{f}$.

• Otherwise, $p_{m}(t)$ eventually stabilizes on some $p_{m,f}$. Therefore, $b_{m}$ attempts to complete a simulation step of $p_{m,f}$ infinitely often. Two sub-cases may arise:

• –

Either $|S_{m,f}|=1$ and, therefore, $b_{m}$ is the only one live BG simulator performing simulation steps, and thus, the set of processes with an infinite number of simulated steps is equal to $S_{m,f}$, a live set intersecting with $A_{f}$.

• –

Otherwise, by Lemma 4, every live BG simulator with a smaller identifier eventually selects a window, and thus a live set (Lemma 3), which is a subset of $S_{m,f}\setminus\{p_{m,f}\}$. Thus every live BG simulator with a smaller identifier eventually selects processes to simulate distinct from $p_{m,f}$ and, thus, cannot block $b_{m}$ infinitely often—a contradiction.

Lemma 6

If $\mathcal{A}$ is fair, then any task $T$ solvable in the $\mathcal{A}$-model is solvable in the $\alpha_{\mathcal{A}}$-model.

Proof

Let us assume that it is not the case: there exists a task $T$ and a fair adversary $\mathcal{A}$ such that $T$ is solvable in the adversarial $\mathcal{A}$-model but not in the $\alpha_{\mathcal{A}}$-model. As every finite run of the $\mathcal{A}$-model can be extended to and $\mathcal{A}$-compliant run, the simulated algorithm can only provide valid outputs to the simulated processes. Thus, it can only be the case that a correct process is not provided with a task output, i.e., belongs to $A_{f}$.

Therefore, by Lemma 5, the simulation provides an $\mathcal{A}$-compliant run, i.e., the set of processes with an infinite number of simulated steps is a live set. As the run is $\mathcal{A}$-compliant then each process $p$ with an infinite number of simulated steps is eventually provided with a task output and thus $p_{MEM}[p]$ is set to $\top$. Thus, they cannot belong to $A_{f}$ — a contradiction.

Combining Corollary 1 and Lemma 6 we obtain the following result:

Theorem 6.4

For any fair adversary $\mathcal{A}$, the adversarial $\mathcal{A}$-model and the $\alpha_{\mathcal{A}}$-model are equivalent regarding task solvability.

7 Agreement functions do not always tell it all

We observe that agreement functions are not able to characterize the task computability power of all models. In particular there are non-fair adversaries not captured by their agreement functions.

Consider for example the adversary $\mathcal{A}=\{\{p_{1}\},\{p_{2},p_{3}\},\{p_{1},p_{2},p_{3}\}\}$. It is easy to see that $\mathit{setcon}(\mathcal{A})=2$, but that $\mathit{setcon}(\mathcal{A}|_{\Pi,\{p_{2},p_{3}\}})=1$ which is strictly smaller than $\min(|\{p_{2},p_{3}\}|,\mathit{setcon}(\mathcal{A}))=2$. Therefore, $\mathcal{A}$ is non-fair.

Consider the task $Cons_{2,3}$ consisting in consensus among $p_{2}$ and $p_{3}$: every process in $\{p_{2},p_{3}\}$ proposes a value and every correct process in $\{p_{2},p_{3}\}$ decides a proposed value, so that $p_{2}$ and $p_{3}$ cannot decide different values. $Cons_{2,3}$ is solvable in the adversarial $\mathcal{A}$-model: every process in $\{p_{2},p_{3}\}$ simply waits until $p_{2}$ writes its proposed value and decides on it. Indeed, this protocol solves $Cons_{2,3}$ in the $\mathcal{A}$-model as if $p_{3}$ is correct, $p_{2}$ is also correct.

The agreement function of $\mathcal{A}$, $\alpha_{\mathcal{A}}$, is equal to [math] for $\{p_{2}\}$ or $\{p_{3}\}$, to $2$ for $\{p_{1},p_{2},p_{3}\}$, and to $1$ for all other values. It is easy to see that $\alpha_{\mathcal{A}}$ only differs from $\alpha_{1-res}$, the agreement function of the $1$-resilient adversary, for $\{p_{1}\}$ where $\alpha_{\mathcal{A}}(\{p_{1}\})=1>\alpha_{1-res}(\{p_{1}\})=0$. Therefore, $\forall P\subseteq\Pi,\alpha_{\mathcal{A}}(P)\geq\alpha_{1-res}(P)$, and thus any task solvable in the $\mathcal{A}$-model is solvable in the $1$-resilient model.

The impossibility of solving such a task $1$-resiliently can be directly derived from the characterization of task solvable $t$-resiliently from [8]. Indeed, let $p_{1}$ wait for some process to output in order to decide the same value. Processes $p_{2}$ and $p_{3}$ use the ability to solve consensus among themselves to output a unique value. As there are two correct processes in the system, $p_{2}$ or $p_{3}$ will eventually terminate and thus $p_{1}$ will not wait indefinitely. This gives a $3$-process $1$-resilient consensus algorithm—a contradiction[7, 20]. Thus, the $\mathcal{A}$-model is not equivalent with the $\alpha_{\mathcal{A}}$-model, even though they have the same agreement function.

8 Related work

Adversarial models were introduced by Delporte et al. in [6]. With respect to colorless tasks, Herlihy and Rajsbaum [17] characterized a class superset-closed [19] adversaries (closed under the superset operation) via their minimal core sizes. Still with respect to colorless tasks, Gafni and Kuznetsov [12] derived a characterization of general adversary using its consensus power function $\mathit{setcon}$. A side result of this present paper is an extension of the characterization in [12] to any (not necessarily colorless) tasks.

Taubenfeld introduced in [22] the notion of a symmetric progress conditions, which is equivalent to our symmetric adversaries.

The BG simulation establishes equivalence between $t$-resilience and wait-freedom with respect to task solvability [3, 4, 8]. Gafni and Guerraoui [10] showed that if a model allows for solving $k$-set consensus, then it can be used to simulate a $k$-concurrent system in which at most $k$ processes are concurrently invoking a task. In our simulation, we use the fact that a model $M$ associated to an agreement function $\alpha_{M}$ allows to solve an $\alpha$-adaptive set consensus, using the technique proposed in [5], which enables a composition of the ideas in [3, 4, 8] and [10]. Running BG simulation on top of a $k$-concurrent system, we are able to derive the equivalence between fair adversaries and their corresponding $\alpha$-models.

9 Concluding remarks

By Theorem 6.4, task computability of a fair adversary $\mathcal{A}$ is characterized by its agreement function $\alpha$: a task is solvable with $\mathcal{A}$ if and only if it is solvable in the $\alpha$-model. The result implies characterizations of superset-closed [16, 19] and symmetric [22] adversaries and, via the equivalence result established in [9], the model of $k$-concurrency.

As a corollary, for all models $M$ and $M^{\prime}$ characterized by their agreements functions, such that $\forall P\in\Pi,\alpha_{M^{\prime}}(P)\geq\alpha_{M}(P)$, we have that $M$ is stronger than $M^{\prime}$, i.e., the set of tasks solvable in $M$ contains the set of tasks solvable in $M^{\prime}$. In particular, if the two agreement functions are equal, then $M$ and $M^{\prime}$ solve exactly the same sets of tasks. Note that if a model $M$ is characterized by its agreement function $\alpha$, then it belongs to the weakest equivalence class among the models whose agreement function is $\alpha$.

An intriguing open question is therefore how to precisely determine the scope of the approach based on agreement functions and if it can be extended to capture larger classes of models.