Byzantine BG Simulations for Message-Passing Systems

The BG-simulation is a powerful reduction algorithm designed for asynchronous read/write crash-prone systems, namely, it allows a set of $(t+1)$ asynchronous sequential processes to wait-free simulate (i.e., despite the crash of up to $t$ of them) an arbitrary number $n$ of processes under the assumption that at most $t$ of them crash. The BG simulation shows that, in read/write systems, the crucial parameter is not the number $n$ of processes, but the upper bound $t$ on the number of process crashes. The paper first focuses on BG-like simulations in the context of asynchronous message-passing systems. It incrementally presents two reductions. The first considers that processes may fail by crashing. Assuming $t<\min(n',n/2)$, it simulates a system of $n'$ processes where up to $t$ may crash, on top of a basic system of $n$ processes where up to $t$ may crash. The second simulation concerns the case where processes may commit Byzantine failures. Assuming $t<\min(n',n/3)$, it simulates a system of $n'$ processes where up to $t$ may be Byzantine, on top of a basic system of $n$ processes where up to $t$ may be Byzantine. It is important to notice that this algorithm is the first BG simulation algorithm that considers Byzantine process failures. These simulations, suited to asynchronous message-passing systems, are genuine in the sense that they do not rely on an intermediate stage simulating a read/write memory system. Moreover, they are built modularly. Each of the two new BG-like simulations relies on novel specific safe agreement objects. The one suited to message-passing Byzantine systems has noteworthy computability implications. It allows crash-tolerant algorithms, designed for asynchronous read/write systems, to be executed on top of asynchronous message-passing systems prone to Byzantine failures.