Complexity of Multi-Value Byzantine Agreement

In this paper, we consider the problem of maximizing the throughput of Byzantine agreement, given that the sum capacity of all links in between nodes in the system is finite. We have proposed a highly efficient Byzantine agreement algorithm on values of length l>1 bits. This algorithm uses error detecting network codes to ensure that fault-free nodes will never disagree, and routing scheme that is adaptive to the result of error detection. Our algorithm has a bit complexity of n(n-1)l/(n-t), which leads to a linear cost (O(n)) per bit agreed upon, and overcomes the quadratic lower bound (Omega(n^2)) in the literature. Such linear per bit complexity has only been achieved in the literature by allowing a positive probability of error. Our algorithm achieves the linear per bit complexity while guaranteeing agreement is achieved correctly even in the worst case. We also conjecture that our algorithm can be used to achieve agreement throughput arbitrarily close to the agreement capacity of a network, when the sum capacity is given

An Optimal Self-Stabilizing Firing Squad

Consider a fully connected network where up to $t$ processes may crash, and all processes start in an arbitrary memory state. The self-stabilizing firing squad problem consists of eventually guaranteeing simultaneous response to an external input. This is modeled by requiring that the non-crashed processes "fire" simultaneously if some correct process received an external "GO" input, and that they only fire as a response to some process receiving such an input. This paper presents FireAlg, the first self-stabilizing firing squad algorithm. The FireAlg algorithm is optimal in two respects: (a) Once the algorithm is in a safe state, it fires in response to a GO input as fast as any other algorithm does, and (b) Starting from an arbitrary state, it converges to a safe state as fast as any other algorithm does.Comment: Shorter version to appear in SSS0

Relating Knowledge and Coordinated Action: The Knowledge of Preconditions Principle

The Knowledge of Preconditions principle (KoP) is proposed as a widely applicable connection between knowledge and action in multi-agent systems. Roughly speaking, it asserts that if some condition is a necessary condition for performing a given action A, then knowing that this condition holds is also a necessary condition for performing A. Since the specifications of tasks often involve necessary conditions for actions, the KoP principle shows that such specifications induce knowledge preconditions for the actions. Distributed protocols or multi-agent plans that satisfy the specifications must ensure that this knowledge be attained, and that it is detected by the agents as a condition for action. The knowledge of preconditions principle is formalised in the runs and systems framework, and is proven to hold in a wide class of settings. Well-known connections between knowledge and coordinated action are extended and shown to derive directly from the KoP principle: a "common knowledge of preconditions" principle is established showing that common knowledge is a necessary condition for performing simultaneous actions, and a "nested knowledge of preconditions" principle is proven, showing that coordinating actions to be performed in linear temporal order requires a corresponding form of nested knowledge.Comment: In Proceedings TARK 2015, arXiv:1606.0729

No Double Discount: Condition-based Simultaneity Yields Limited Gain

Assuming each process proposes a value, the consensus problem requires the non-faulty processes to agree on the same value that has to be a proposed value. Solutions to the consensus problem in synchronous systems are based on the round-based model, namely, the progress of the processes is according to synchronous rounds. Simultaneous consensus requires that the non-faulty processes decide not only on the same value, but decide during the very same round. It has been shown by Dwork and Moses that, in a synchronous system prone to t process crashes, the earliest round at which a common decision can be simultaneously obtained is (t+1)-D where D is a non-negative integer determined by the actual failure pattern F. The condition-based approach to solve consensus assumes that the input vector belongs to set C (a set of input vectors satisfying a property called legality). Interestingly, the conditions for synchronou s consensus define a hierarchy of sets of conditions. It has been shown that d+1 is a tight lower bound on the minimal number of rounds for synchronous condition-based consensus (where d characterizes the class of constions the algorithm is instantiated with). This paper considers the synchronous condition-based consensus problem with simultaneous decision. It first presents a simple algorithm that directs the processes to decide simultaneously at the end of the round RS(t,d,F)=min((t+1)-D, d+1) (i.e., RS(t,d,F)=(t+1)-max(D,delta) with delta=t-d). The paper then shows that RS(t,d,F)is a lower bound for the condition-based simultaneous consensus problem. It thus follows that the algorithm designed is optimal in each and every run, and not just in the worst case: For every choice of failure pattern by the adversary (and every input configuration), the algorithm reaches simultaneous as fast as any correct algorithm could do under the same conditions. This shows that, contrary to what could be hoped, when considering condition-based consensus with simultaneous decision, we can benefit from the best of both actual worlds (either the failure world when RS(t,d,F)=(t+1)-D, or the condition world when RS(t,d,F)=d+1), but we cannot benefit from the sum of savings offered by both. Only one discount applies

Revisiting Simultaneous Consensus with Crash Failures

This paper addresses the “consensus with simultaneous decision” problem in a synchronous system prone to t process crashes. This problem requires that all the processes that do not crash decide on the same value (consensus) and that all decisions are made during the very same round (simultaneity). So, there is a double agreement, one on the decided value (data agreement) and one on the decision round (time agreement). This problem was first defined by Dwork and Moses who analyzed it and solved it using an analysis of the evolution of states of knowledge in a system with crash failures. The current paper presents a simple algorithm that optimally solves simultaneous consensus. Optimality means in this case that the simultaneous decision is taken in each and every run as soon as any protocol decides, given the same failure pattern and initial value. The design principle of this algorithm is simplicity, a first-class criterion. A new optimality proof is given that is stated in purely combinatorial terms

Aspects Of Knowledge And Belief-Based Programming

It has long been recognized that many distributed problems can be analyzed in terms of how agents act based on what they know about the system they are in. To make this intuition formal, Fagin, Halpern, Moses, and Vardi [25, 26] proposed a theory of programs for multi-agent systems in which preconditions of actions are formulas in a logic of knowledge. Knowledge-based programs have been successfully applied to a number of fundamental problems. This dissertation aims at further investigating the role of knowledge-based programs in the study of distributed systems. We focus ?rst on a general problem in distributed settings: given a function f whose value depends on the whole network N , the goal is for every agent to eventually compute the value f (N ). We call this problem global function computation. We give a necessary and suf?cient condition for the problem to be solvable and provide a knowledge-based program that solves the global function computation problem whenever possible. The program guarantees a certain level of optimality by having agents send messages only when they believe it is necessary to do so, and allows for systems in which agents are anonymous. Second, we consider the synthesis of knowledge-based programs. In general, to produce a program guaranteed to satisfy a given speci?cation, one can try to synthesize it from a formal proof that a computation satisfying that speci?cation exists. We build on a technique proposed by Bickford and Constable [11, 12] for extracting message automata from speci?cations of multi-agent systems to show how knowledge-based message automata can be synthesized using a proof development system such as Nuprl [19]. Third, we consider the problem of ensuring secrecy in a multi-agent system by disallowing unwanted ?ows of information. We discuss knowledge-based formulations of information-?ow properties, with a focus on the basic security predicates in the Modular Assembly Kit proposed by Mantel [62]

Continuous consensus via common knowledge

This paper introduces the continuous consensus problem, in which a core M[k] of information is continuously maintained at all correct sites of the system. All local copies of the core must be identical at all times k, and every interesting event should eventually enter the core. The continuous consensus problem is studied in synchronous systems with crash and omission failures, assuming an upper bound of t on the number of failures in any given run of the system. A simple protocol for continuous consensus, called ConCon, is presented. This protocol is knowledge-based: The actions processes take depend explicitly on their knowledge, as well as on their knowledge of what other processes know about failures and about events that occurred in the system. A close connection between continuous consensus and knowledge is established by showing that in every continuous consensus protocol, the information in the core at any given time must be common knowledge. Based on the characterization of common knowledge by Moses and Tuttle, it is shown that ConCon is an optimum protocol for continuous consensus, maintaining the most up-to-date core possible at all times: For every pattern of failures and external inputs and each point in time, the core provided by ConCon contains the cores of all correct protocols for continuous consensus. Indeed, th