Scalable and Secure Computation Among Strangers: Resource-Competitive Byzantine Protocols

TL;DR

This paper introduces resource-competitive Byzantine protocols that ensure honest nodes' communication cost is proportional to adversarial nodes, enabling scalable and secure agreement in permissionless systems with unknown participants.

Contribution

It presents the first resource-competitive Byzantine agreement, leader, and committee election algorithms with provable bounds and resilience to a high fraction of Byzantine nodes.

Findings

Expected communication cost is O((T+n) log n) bits.

Algorithm achieves latency of O(polylog(n)).

Resilient to nearly 25% Byzantine nodes.

Abstract

Motivated, in part, by the rise of permissionless systems such as Bitcoin where arbitrary nodes (whose identities are not known apriori) can join and leave at will, we extend established research in scalable Byzantine agreement to a more practical model where each node (initially) does not know the identity of other nodes. A node can send to new destinations only by sending to random (or arbitrary) nodes, or responding (if it chooses) to messages received from those destinations. We assume a synchronous and fully-connected network, with a full-information, but static Byzantine adversary. A general drawback of existing Byzantine protocols is that the communication cost incurred by the honest nodes may not be proportional to those incurred by the Byzantine nodes; in fact, they can be significantly higher. Our goal is to design Byzantine protocols for fundamental problems which are {\em resource competitive}, i.e., the number of bits sent by honest nodes is not much more than those sent by Byzantine nodes. We describe a randomized scalable algorithm to solve Byzantine agreement, leader election, and committee election in this model. Our algorithm sends an expected $O((T+n)\log n)$ bits and has latency $O(polylog(n))$, where $n$ is the number of nodes, and $T$ is the minimum of $n^2$ and the number of bits sent by adversarially controlled nodes. The algorithm is resilient to $(1/4-\epsilon)n$ Byzantine nodes for any fixed $\epsilon > 0$, and succeeds with high probability. Our work can be considered as a first application of resource-competitive analysis to fundamental Byzantine problems. To complement our algorithm we also show lower bounds for resource-competitive Byzantine agreement. We prove that, in general, one cannot hope to design Byzantine protocols that have communication cost that is significantly smaller than the cost of the Byzantine adversary.

Figures

Equations

$$E(X)$$

$$(1-ϵ)(\delta -(t/n))n$$

$$(n)\left(\frac{4ϵpn}{(1-ϵ)(\delta -t/n)n}\right)$$

$$E(X)=d|R^{\prime }|\cdot \frac{f_{g}s}{n^k}=\frac{d{f}_g{s}^2}{n^{k}l{n}^{3}n}=Cs{f}_{g}l{n}^{3}n.$$

$$Pr(X\le (1-1/\ln n)E(X))$$

$$Pr(\xi )$$

$$\frac{\delta T}{(1-ϵ)n}<\frac{T}{ϵn}$$

$$\delta T/((1-ϵ)n)\le ϵn$$

$$\Rightarrow$$

$$E[X]=\sum _{v}E[X_v]=(1/n)\sum _v{n}_v\le 2M_{\mathcal{A}}/n\in o(n^{\alpha /2}).$$

$$\mathrm{Pr}(X\ge 12E[X])\le \mathrm{Pr}(X\ge 12\log n)\le 2^{-2\log n}\le 1/n^2.$$

Full text

We describe a randomized scalable algorithm to solve Byzantine agreement, leader election, and committee election in this model. Our algorithm sends an expected $O((T+n)\log n)$ bits and has latency $O(\operatorname{polylog}(n))$, where $n$ is the number of nodes, and $T$ is the minimum of $n^{2}$ and the number of bits sent by adversarially controlled nodes. The algorithm is resilient to $(1/4-\epsilon)n$ Byzantine nodes for any fixed $\epsilon>0$, and succeeds with high probability111I.e., with probability at least $(1-1/n^{c})$ for some constant $c>0$.. Our work can be considered as a first application of resource-competitive analysis to fundamental Byzantine problems.

To complement our algorithm we also show lower bounds for resource-competitive Byzantine agreement. We prove that, in general, one cannot hope to design Byzantine protocols that have communication cost that is significantly smaller than the cost of the Byzantine adversary.

Keywords: Byzantine protocol, Byzantine agreement, Leader election, Committee election, Resource-competitive protocol, Randomized protocol

1 Introduction

What happens when you don’t know your neighbors? Anonymity is critical in many modern networks including cryptocurrency [10, 22], anonymous communication [24, 56], and wireless [37, 41, 57, 54]. In anonymous networks, nodes are generally known only by self-generated identifiers222Such as the public key for a digital signature.; and communication primitives may be limited to: sending a message to all nodes, sending a message to a random (or arbitrary) node, and responding to a message sent directly. Unfortunately, all algorithms to coordinate such networks in the presence of malicious faults seem either to require all-to-all communication, or make cryptographic assumptions.

The open nature of permissionless systems such as Bitcoin allow many nodes to enter the network with little or no admission control. A major challenge in such systems is dealing with malicious (also called Byzantine) nodes, which can try to foil the protocols executed by honest (good) nodes. Byzantine-resistant protocols are at the heart of secure and robust networks that can tolerate malicious nodes, such as P2P networks. Consider the real-world example of Bitcoin — a decentralized P2P-based digital currency [10]. A crucial aspect of Bitcoin is a computational mechanism that allows fault-tolerant agreement on a set of ordered transactions. Agreement in Bitcoin is achieved via a computationally-expensive operation, called mining.

The problem of achieving agreement under Byzantine faults, Byzantine agreement, is a fundamental and long-studied problem in distributed computing [49, 6, 43]. In the Byzantine agreement problem, all good nodes start with an input bit, and we must ensure two conditions: (1) All good nodes output the same input bit (consensus condition) and (2) the common bit should be the input bit of some good node (validity condition). This must be done despite the presence of a constant fraction of Byzantine nodes that can deviate arbitrarily from the protocol executed by the good nodes. Byzantine agreement is a “keystone” problem in distributed computing, in that it provides a critical building block for creating attack-resistant distributed systems. Its importance can be seen from widespread and continued application in many domains: sensor networks [53], grid computing [5], peer-to-peer networks [52] and cloud computing [58]. However, despite intensive research, there has still not been a practical solution to the Byzantine agreement problem for large networks. A main reason for this is the large message complexity of currently known protocols, as has been suggested by many systems papers [2, 4, 16, 44, 59]. The best known protocols have quadratic message complexity, i.e., $\Theta(n^{2})$, where $n$ is the number of nodes in the network.

King and Saia [33] described the first Byzantine agreement algorithm in synchronous complete networks that breaks the quadratic message barrier under the assumption that nodes a priori know the identities of all their neighbors. This assumption is called the $KT_{1}$ model [50], where it is assumed that each node has knowledge of the identities of its neighbors333Just the identities of the neighbors, not any other information such as the internal states of the neighbors is assumed. a priori. This is in contrast to the $KT_{0}$ model [50], another standard model where nodes do not know the identity of the neighbors. In the $KT_{1}$ model, [33] presented an algorithm where each processor sends only $\tilde{O}(\sqrt{n})$ messages, and thus the total message complexity is bounded by $\tilde{O}(n^{1.5})$. This was later improved by Braud-Santoni et al. [13] to $O(n\text{ polylog}(n))$ total message complexity, however, this protocol might require some node to send $O(n)$ messages.

The $KT_{0}$ model seems more applicable to modern, permissionless networks. While we can convert algorithms for $KT_{1}$ to $KT_{0}$ by including an initial step where each node communicates with all its neighbors to obtain their identities, this incurs a $\Theta(n^{2})$ message cost. Hence a fundamental question is: Can we design Byzantine protocols that require sub-quadratic messages in the $KT_{0}$ setting?

In this paper, we take a step toward addressing the above question. Our focus is on the fundamental problems of Byzantine agreement, leader election and committee election. Our main result is an algorithm to solve these problems while sending a number of bits that is $O((T+n)\log n)$, where $T$ is the minimum of $n^{2}$ and the number of bits sent by adversarially controlled (Byzantine) nodes, and $n$ is the network size. This kind of result where algorithmic cost is measured with respect to adversarial cost, is an example of resource-competitive analysis [9, 28]. To the best of our knowledge, our result is the first of its kind that introduces resource-competitive analysis to the study of Byzantine agreement and related problems. In particular, our result shows that Byzantine protocols can be designed that compete well with the resources (messages) expended by the Byzantine nodes; if they send less messages then the protocol also sends less. An alternate way to interpret our result is that Byzantine nodes have to incur significant message complexity (up to quadratic in $n$) in order to make the honest nodes to have large message complexity. We note that prior work on Byzantine protocols all incurred quadratic message complexity (in the $KT_{0}$ setting) regardless of the behavior of the Byzantine nodes. Our protocol is efficient, lightweight, and fast (has low latency) and can be used as a building block for designing secure and scalable systems.

1.1 Model

We consider a network of $n$ nodes: $t$ are bad and controlled by the adversary, and the remainder are good and follow our algorithm; we assume $t\leq(1/4-\epsilon_{0})n$ for some constant $\epsilon_{0}>0$.

We consider a synchronous, fully-connected network in the $KT_{0}$ model [48, 50]. In particular, we assume that a node has ports to every other node in the network, but learns the identity of each node reachable through a port only by receiving a communication from that node. Thus a node sends to a new destination only by selecting a port, or by responding to messages received. The $n$ nodes are assumed to have distinct ID’s which lie in $[1,n^{k}]$ for $k$ is a (large) constant.444This means that an ID can be represented using $O(\log n)$ bits, which can be sent in a message. We assume the CONGEST model, i.e., only $O(\log n)$-sized messages are used in our algorithm. Our adversary is full-information in that it knows the states of all nodes at any time, is assumed to be computationally unbounded, and is also rushing in the sense that it can read messages sent by good nodes before sending out its own messages. However, the adversary is static, so that it must decide which nodes are bad prior to the start of the algorithm. We assume that Byzantine nodes cannot fake their own identities, however they can forward fake messages on behalf of other nodes.

1.2 Our Contributions

We solve three classic problems in this model. In Byzantine agreement, all good nodes must output the same bit, which is the input bit of some good node. In leader election, all good nodes must agree on a leader, and this leader must be good with constant probability. In committee election, all nodes must agree on a subset of $O(\log n)$ nodes where the fraction of bad nodes in the subset is within a small $\epsilon$ fraction of the overall fraction of bad nodes.

Our main result is as follows.

Theorem 1.1**.**

There exists a randomized algorithm that solves Byzantine agreement, leader election and committee election in the above model. This algorithm sends an expected $O((T+n)\log n)$ messages, and has latency $O(\operatorname{polylog}(n))$, where $T$ is the minimum of $n^{2}$ and the number of bits sent by the bad nodes. It is resilient to $t\leq(1/4-\epsilon_{0})n$ Byzantine faults for any fixed $\epsilon_{0}>0$, and succeeds with probability $1-1/n^{c}$ for any constant $c$.

We note that our $O(\operatorname{polylog}(n))$ latency bound holds even in the CONGEST model, where each message is $O(\log n)$ bits. The algorithm KT0-ByzantineAgreement described in Section 2 achieves the result in Theorem 1.1, and the proof of this theorem is in Section 3.

To complement the above result we also show lower bounds for resource-competitive Byzantine agreement (see Section 5). We prove that, in general, one cannot hope to design Byzantine protocols that have communication cost that is significantly smaller than the cost of the Byzantine adversary, i.e., the no. of messages send by bad nodes. We first show a lower bound for deterministic BA protocols which is essentially tight with respect to the upper bound of our resource-competitive randomized algorithm (see Section 5.1). We show that if $T=O(n^{2})$ is the budget on the message bits of the Byzantine nodes, then for any deterministic protocol, the total number of messages sent by the good nodes is $\Omega(T)$ (see Theorem 5.1). The deterministic lower bound holds even in the $KT_{1}$ model. We then show a somewhat weaker lower bound on the resource competitiveness of randomized BA protocols (see Section 5.2). The argument for the randomized case is more involved compared to the deterministic case, as the algorithm’s (future) random choices are unknown to the Byzantine adversary. We show that if $T=n^{1+\alpha}$ for some $\alpha\in(0,1]$ is the budget of the Byzantine nodes, then for any (randomized) BA algorithm in the $KT_{0}$ setting, the total expected number of messages sent by good nodes, is at least $\Omega(n^{1+\frac{\alpha}{2}})$ (see Theorem 5.2). Another significance of this lower bound result is that it separates the message complexity of Byzantine agreement between $KT_{0}$ and $KT_{1}$ models in the randomized setting.

1.3 Techniques and other results

We focus first on Byzantine agreement, our solutions to leader and committee election use similar techniques. Our algorithm depends on solutions to two new problems: Implicit Agreement and Promise Agreement. In the Implicit Agreement problem, success means that strictly greater than a $t/n$ fraction of good nodes decide on the same (correct) bit and the remaining good nodes do not decide; and failure means that no good nodes decide. Next, the Promise Agreement problem assumes there has first been either success or failure in Implicit Agreement. In the case of success, Promise Agreement ensures all nodes decide on the same value and terminate; in the case of failure, no nodes decide.

KT0-ByzantineAgreement runs in epochs. In each epoch, we (1) run an algorithm for Implicit Agreement; (2) run an algorithm for Promise Agreement; and (3) terminate in the case of success, or increase computational effort in the case of failure.

The computational effort for Implicit Agreement is tuned by increasing the number of active nodes. In particular, during a run of Implicit Agreement, the active nodes first attempt to solve Byzantine agreement among themselves, and then to communicate the output to all other nodes in the network. Our Implicit Agreement algorithm ensures that, unless the bad nodes send a number of messages that is $n$ times the number of active nodes, then Implicit Agreement will succeed. Next, we solve Promise Agreement. This ensures that if Implicit Agreement succeeded, then all nodes will decide on the same value and terminate; and if Implicit Agreement failed, then no nodes decide. In the latter case, all nodes proceed to the next epoch, where the number of active nodes doubles in expectation.

LargeCoreBA. There are several technical challenges in the implementation of this main idea. The first is to enable Byzantine agreement among the active nodes when the bad nodes do not send out too many messages. We say that a node $x$ has a view of node $y$ if $x$ knows $y$’s ID and the port to $y$. With a fair amount of technical work, we show that it is possible to modify an algorithm by King et al. [34] to ensure agreement even among nodes whose views only “mostly” overlap, provided that the range of all IDs is only polynomially large. We call this modified algorithm LargeCoreBA, and summarize its properties in Lemma 1 below; we believe the result may be of independent interest. The technical approach we used to prove Lemma 1 is (1) a counting argument to show there are not too many bad nodes in the views of key participants; and (2) the use of a sampler graph to ensure that these bad participants are well spread over the committees, as used in [34] (see Section 4.1).

Lemma 1**.**

Let $G$ be a set of good nodes which wish to come to agreement. For each $x\in G$, let $S_{x}$ be the set of nodes in the view of $x$. Let $B$ be the set of bad nodes in $\bigcup_{x\in G}S_{x}$. Assume $G\subseteq\bigcap_{x}S_{x}$; $|B|\leq(1-\epsilon)|G|/2$ for some fixed constant $\epsilon>0$; and all nodes have distinct ID’s in $[1,n^{k}]$. Then there is an algorithm LargeCoreBA which computes almost everywhere agreement with high probability among $(1-1/\log n)$ fraction of nodes in $G$ in time and communication per node which is polylogarithmic in $|G|+|B|$. In one more round, if each good node broadcasts to all other nodes, and then each node takes the majority, all nodes will come to agreement using $|G|(|G|+|B|)$ total messages, and latency polylogarithmic in $|G|+|B|$.

Implicit Agreement. Our solution to Implicit Agreement is given in Steps 1 to 6 of our main algorithm in Section 2.1. There are two key technical problems that must be addressed.

First, how do we ensure that each active node $x$ maintains a set $S_{x}$ so that the conditions of Lemma 1 are matched? Also, in order to achieve a good competitive ratio, we need the conditions of Lemma 1 to hold unless the adversary sends $\Omega(nA)$ messages, where $A$ is the number of active nodes. If each active node $x$ naively adds to $S_{x}$ all nodes $y$ that it receives an initial message from, then the adversary can add $A$ Byzantine nodes to each $S_{x}$ while sending only $A^{2}$ messages. Thus, we must enlist the aid of non-active nodes to establish the $S_{x}$ sets. Initially, each active node sends its ID to all nodes. Call a good node light if it has received a number of IDs approximately equal to $A$. Then the light nodes convey information about their $S_{x}$ sets to the nodes in $S_{x}$. They can not send out all the IDs in $S_{x}$, since that would be too many bits. Instead, they just send out a single random ID, and a node $y$ adds an ID to $S_{y}$ if it was received from “enough” (i.e. $\Theta(nA)$) nodes that claim to be light.

Unfortunately, an adversary can still cause problems by making the size of the union of the bad nodes in each $S_{x}$ large, so that $|B|$ is large in Lemma 1, even when the advesary does not send out too many messages. To solve this problem, we use a “validation” step, whereby each active node, for each ID in $S_{x}$, queries $\Theta(\log n)$ random nodes about whether they have the ID in their $S_{x}$ sets, and filters out the ID unless enough of these queries are answered affirmatively. Based on information obtained during this process (Step 1 through Step 3c in Section 2.1), the active nodes determine if the number of light nodes is sufficient for favorable success in this epoch.

This brings us to the second problem. How can the active nodes agree on one of two options for this epoch: (1) conditions are favorable for agreement; or (2) conditions are not favorable? We can make use of LargeCoreBA in coming to agreement on an option. However, this is still challenging given that, under certain conditions, some active nodes may run LargeCoreBA, while other active nodes may not even have a small enough $S_{x}$ set to run it. To address this issue requires careful decisions about whether a node will run LargeCoreBA, what its input will be, and whether or not it will trust the output, all based on the node’s estimate of the number of light nodes (See Step 4, Section 2.1 for details). In particular, nodes will sometimes run LargeCoreBA, because other nodes are relying on them to do so, even when they plan to ignore the output. If active nodes decide conditions are favorable via the first call to LargeCoreBA (Step 4), they will all run it again (Step 5) to decide on a bit. Lemma 4 in Section 3 shows that no matter what the number of light nodes, these two steps ensure all active nodes come to agreement on the same decision.

Finally, in Step 6, active nodes send their decision to all other nodes. Nodes that have small $S_{x}$ sets take the majority of the messages received in this step, whereas other nodes default to a decision to wait for the next epoch. We can thereby guarantee the post-condition for Implicit Agreement: either (1) a strictly greater than $t/n$ fraction of good nodes decide, or (2) no good nodes decide. We obtain this result even when the adversary floods some good nodes but not others.

Promise Agreement. A final technical challenge is to determine whether or not we need to run another epoch. After solving Implicit Agreement, either (1) strictly greater than a $t/n$ fraction of the good nodes have decided on the same correct bit; or (2) no good nodes have decided. We must then ensure that all good nodes decide either to terminate or to run another epoch. To do this, we run an algorithm, PromiseAgreement that solves the Promise Agreement problem (see Section 4.2). The solution simply has each node sample a logarithmic number of other nodes, and take a majority vote. It does not increase the overall asymptotic number of messages sent, but some non-active nodes can be forced by the adversary to respond to $O(n)$ requests. If the outcome of PromiseAgreement is not agreement then all nodes proceed to the next epoch, where the number of active nodes doubles in expectation. In this way, we can guarantee that that KT0-ByzantineAgreement succeeds within $\log(n)$ expected epochs.

1.4 Related Work

$KT_{0}$ and $KT_{1}$ Communication Model.

$KT_{0}$ and $KT_{1}$ models are two well-studied standard models in distributed computing (e.g., see [30, 48, 50]). It turns out that message complexity of a distributed algorithm depends crucially (as explained below) on the initial knowledge of the nodes.555It is not hard to see that one can run the algorithms in the $KT_{1}$ model after one round of communication between neighbors, (which is all-to-all communication in a complete network). For example, consider the situation where there are no Byzantine nodes. It is known that $\Omega(n)$ expected messages are needed for explicit leader election666For explicit leader election, where all nodes should know the identity of the elected leader. in a complete (fully-connected network) in the $KT_{0}$ model (see e.g., [7, 40]), whereas in the $KT_{1}$ it takes no communication at all (since all nodes know each other’s IDs, the minimum one can be selected). Similarly it has been shown for implicit leader election and implicit agreement777In implicit leader election, only the leader node should know that it is the leader. In implicit agreement, it is enough if a non-empty subset of nodes agree. that $\Omega(\sqrt{n})$ expected messages is a lower bound in the $KT_{0}$ model [7]. It is known that for various fundamental problems such as broadcast, spanning tree construction, minimum spanning tree construction there is a significant gap in the message complexity between the two models. For example, for all the above problems in an arbitrary graph with $m$ edges, it is known that $\Omega(m)$ is a message lower bound in the $KT_{0}$ model which holds even for randomized (Monte Carlo) algorithms. However, in the $KT_{1}$ model, this lower bound can be breached: all these problems can be solved using randomized algorithms in $\tilde{O}(n)$ messages [39]. For the complete network case, it is known that minimum spanning tree construction needs $\Omega(n^{2})$ messages in the $KT_{0}$ model, while it can be accomplished in $\tilde{O}(n)$ messages in the $KT_{1}$ model. The recent work of Gmyr and Pandurangan [30] gives several new algorithms in the $KT_{1}$ model and shows many other separations between the two models.

Resource-Competitive Analysis.

This paper introduces resource-competitive analysis [9, 28] to the study of Byzantine agreement. In resource-competitive analysis, the computational cost of the attacker, $T$, is incorporated as a parameter in performance analysis. That is, the cost of executing an algorithm over a network of $n$ nodes is measured not only as a function of $n$, but also as a function of $T$.

Resource competitive analysis has been applied to designing algorithms for: jamming-resistant wireless communication [27, 29, 36]; attack-resistance on multiple access channels [8], tolerating adversarial channel noise [3, 19, 20], and efficiently distributing bridges for anonymity networks such as TOR [60]. See [9, 28] for detailed surveys.

Related notions comparing the resources of good and bad nodes have been considered earlier, see e.g., the work of [25], that shows how to achieve fairness in secure computation (either both good and bad parties obtain the result of the computation or nobody does) in the dishonest majority setting with a constant competitive ratio in terms of computational costs/number of steps.

Other related works include [12] that focus on scalability of secure protocols and show how to achieve sublinear communication.

Byzantine Agreement and Election.

Byzantine agreement enables participants in a distributed network to reach agreement on a decision, even in the presence of a malicious minority. Thus, it is a fundamental building block for many applications including: cryptocurrencies [11, 23, 26, 31]; trustworthy computing [14, 15, 16, 17, 18, 38, 55]; peer-to-peer networks [1, 47]; and databases [46, 51, 61].

In 2006, King, Saia, Sanwalani, and Vee  [34] gave a (randomized) algorithm to solve Byzantine agreement, leader election and committee election problems in a model differing from the one in this paper only in the assumption of $KT_{1}$ communication. This was the first algorithm to use only $\tilde{O}(1)$ bits of communication per node, and $\tilde{O}(1)$ time to bring almost all processors to agreement. This result can also be achieved in a particular sparse network [35]. This initial work produced agreement among all but $o(n)$ nodes. Further work extended this result to achieve everywhere agreement, while using a number of bits that is $\tilde{O}(n^{3/2})$ (load-balanced) [32]; and $\tilde{O}(n)$ (not load-balanced) [13]. All of these algorithms required each node to play a particular role as determined by its unique ID in $[1,n]$, and to send to specific neighbors. In other words, these algorithms critically rely on the $KT_{1}$ model. These bounds hold even if the bad nodes send any number of bits. Establishing Byzantine agreement via the use of committees is a common approach; for examples, see [26, 34, 42].

Paper Organization.

Section 2 contains KT0-ByzantineAgreement. Section 2.2 formally defines Promise Agreement. Section 3 analyzes the correctness and cost of KT0-ByzantineAgreement and proves Theorem 1.1. In Section 4.1 we prove Lemma 1. In Section 4.2, we describe an algorithm to solve Promise Agreement. In Section 5, we prove lower bounds. Finally, we conclude in Section 6.

2 KT0-ByzantineAgreement

Here, we describe the main algorithm for resource-competitive Byzantine agreement. It calls LargeCoreBA and an algorithm PromiseAgreement that solves Promise Agreement. A node $x$ calls LargeCoreBA with a set of possible participants $S_{x}$, which may include nodes which do not themselves participate.

The algorithm below runs correctly with probability $1-1/n^{c}$ for any constant $c$, when constant $C$ below is chosen to be sufficiently large, depending on $c$. We let $\epsilon$ be a small constant such that $0<\epsilon<\epsilon_{0}^{2}$. We set $\textit{max}_{a}=(1+\epsilon)p(n-t)$ and $\textit{min}_{a}=(1-\epsilon)p(n-t)$ so that w.h.p. the number of active nodes lies in this range.

We call a good node active if it sets its state to active in Step 2. We call a good node light if the number of IDs received by it from alleged active nodes in Step 2 is less than $\textit{max}_{a}+\epsilon pn$. We use bounds $Low=n-2t-\epsilon n$ and $High=Low+t$ to describe the number of light and purported light nodes. For $p>1/C\log n$, if there are at least $Low-t$ light nodes and each sends a random ID from their list of nodes that reported being active in Step 2, then w.h.p., at least $\beta=\frac{(1-\epsilon)(Low-t)}{\textit{max}_{a}+\epsilon pn}$ copies of all their common IDs, in particular, the IDs of all active nodes, will be received by every active node. Finally, an element in an active node $x$’s set $S_{x}$ is validated when $x$ queries a random set of $C\log n$ nodes and $\delta C\log n$ nodes respond yes. $\delta=\frac{(1-\epsilon)(Low-t)}{n}$ is chosen so that w.h.p., every ID in active will be validated but not many ID’s of nodes which are bad.

2.1 Pseudocode for KT0-ByzantineAgreement

Initialize: Every node $x$ sets $p\leftarrow(C\log n)/n$. Each node $x$ sets $\textit{ready-out}_{x}\leftarrow 0,\textit{ready-in}_{x}\leftarrow 0$, and sets its state to $\lnot\emph{active}$ and $\lnot\emph{light}$. 2. 2.

Nodes become active and notify others: With probability $p$, $x$ sets its state to active and sends its ID to all nodes. Every node $x$ sets $S_{x}$ to the set of IDs received. A node sets its state to light if $|S_{x}|\leq\textit{max}_{a}+\epsilon pn$. 3. 3.

Active** nodes learn of other active nodes:**

1. (a)

Every light node $x$ randomly selects an ID in $S_{x}$ and sends it to the nodes in $S_{x}$. 2. (b)

Every active node $x$ sets $n_{x}$ to be the number of nodes which send to $x$ in Step 3a. If $n_{x}\geq Low-t$ then $x$ resets $S_{x}$ to be the set of IDs which were received from at least $\beta$ nodes. For each $ID$ in $S_{x}$, $x$ sends the query $<ID?>$ to a random set of $C\log n$ nodes. 3. (c)

Every light node $x$ answers a query $<ID?>$ if ID is in $S_{x}$ and the query is sent by a node in $S_{x}$. An ID in $S_{x}$ is considered validated if $x$ received at least $\delta C\log n$ responses to the query for ID. Each active node $x$ that sent queries removes from $S_{x}$ all IDs which are not validated. 4. 4.

Can we proceed? Each active node $x$ with $n_{x}\geq Low-t$ runs LargeCoreBA with the other nodes in $S_{x}$. The input bit to LargeCoreBA, $\textit{ready-in}_{x}\leftarrow 1$ iff $n_{x}\geq High$. If $n_{x}\geq Low$ then $\textit{ready-out}_{x}\leftarrow$ output of LargeCoreBA. 5. 5.

Compute Byzantine Agreement Each active node $x$ with $\textit{ready-out}_{x}=1$ runs LargeCoreBA with nodes in $S_{x}$, with input bit, $\textit{value}_{x}$, set to the node’s initial input bit.

Node $x$ then sets $\textit{value}_{x}$ to the output of this LargeCoreBA. 6. 6.

Take Majority: Each active node, $x$, sends ($\textit{ready-out}_{x}$, $\textit{value}_{x}$) to all nodes. Then, each node $x$ with $n_{x}\geq Low-t$ sets $\textit{ready-out}_{x}$ to the majority ready-out bit received from nodes in $S_{x}$. If this bit is $1$, then $\textit{value}_{x}$ is set to the majority value bit received from nodes in $S_{x}$. 7. 7.

Promise Agreement: Each node $x$ runs PromiseAgreement with the tuple $(\textit{ready-out}_{x},\textit{value}_{x})$, and resets the tuple based on the outcome.

1. (a)

If $\textit{ready-out}_{x}=1$, then node $x$ terminates and outputs value $\textit{value}_{x}$; 2. (b)

Else if $p<1/(C\log n)$, $p$ doubles and $x$ repeats from Step 2. 3. (c)

Else {$pn\geq n/(C\log n)$} every node sends to all its neighbors to determine their IDs and all nodes execute LargeCoreBA to compute Byzantine agreement.

2.2 Promise Agreement

Here we define a variant of the almost-everywhere to everywhere Byzantine agreement problem, which we call Promise Agreement. In Section 4.2, we describe an algorithm, PromiseAgreement, to solve this problem.

Definition 1**.**

An algorithm is said to solve the Promise Agreement problem if it has the following properties.

If (i) there is at least a $t/n+2\epsilon$ fraction of good nodes with tuple $(\textit{ready-out},\textit{value})=(1,v)$, for the same bit $v$; and (ii) all remaining good nodes have ready-out value of [math], then all nodes terminate with tuple $(\textit{ready-out},\textit{value})=(1,v)$. 2. 2.

If all good nodes have $\textit{ready-out}=0$, then all nodes terminate with $\textit{ready-out}=0$.

3 Analysis of KT0-ByzantineAgreement

3.1 Correctness

We call one run of all the steps in the KT0-ByzantineAgreement algorithm an epoch. We assume $t\leq(1/4-\epsilon_{0})n$ for and fixed $\epsilon_{0}>0$. We also assume that $p<1/(C\log n)$ except in Step 7c.

Lemma 2**.**

The following events occur w.h.p. in $n$.

The number of active nodes is between $\textit{min}_{a}$ and $\textit{max}_{a}$. 2. 2.

If there are at least $Low-t$ light nodes, then all active nodes receive at least $\beta$ copies of the ID of every active node in Step 3a. 3. 3.

If there are at least $Low-t$ light nodes, then all active nodes will consider all IDs of active nodes validated after Step 3c. 4. 4.

If an ID is contained in the $S_{x}$ sets of at most $(1-\epsilon)(\delta-t/n)n$ light nodes in Step 3b, then that ID will not be validated.

Proof.

For each of these items there is a random variable $X$ which is the number of successful independent trials. In each case, we will show that $E[X]\geq C^{\prime}\log n$ for some constant $C^{\prime}$. Then, Chernoff bounds imply that $Pr(|X-E[X]|\geq\lambda E[X])\leq n^{-c}$, for any fixed $\lambda<1$, and any fixed $c$, for $C^{\prime}$ sufficiently large [45].

1. Let $X$ be the number of active nodes. Each node of at least $n-t$ good nodes is active with probability $p$. Since $t<n/4$ and $p\geq(C\log n)/n$, then $E[X]\geq(C/2)\log n\geq C^{\prime}\log n$, where $C$ in Step 1 is chosen sufficiently large.

2. Fix an active ID. That ID is sent out from a particular light node with probability at least $1/(\textit{max}_{a}+\epsilon pn)$. Let $X$ be the total number of copies sent of that ID. Then the expected number of copies sent out is at least $(Low-t)/(\textit{max}_{a}+\epsilon pn)\geq C^{\prime}\log n$, for any fixed C’, where constant C in Step 3b is chosen sufficiently large. Hence, by Chernoff bounds, w.h.p., at least $(1-\epsilon)E[X]=\beta$ copies of the fixed active ID are received by each active node. Finally, a union bound over at most $n$ possible active IDs that could be sent out establishes the result.

3. Fix an active node $v$ and an ID $u$, such that $v$ queries about $u$ in Step 3b. Let $X$ be the number of light nodes queried by $v$ about ID $u$ in this step. Then $E[X]=((Low-t)/n)C\log n\geq C^{\prime}\log n$, for any fixed $C^{\prime}$ for $C$ in Step 3b chosen sufficiently large. Thus, by Chernoff bounds, w.h.p., at least $(1-\epsilon)E[X]=\delta C\log n$ nodes will answer queries for the ID $u$, and so node $v$ will consider $u$ validated. Finally, taking union bounds over all choices for $v$ and $u$ shows that, w.h.p., all active nodes will be considered validated by all active nodes.

4. Fix an active node $v$ and an ID $u$, such that $v$ queries about $u$ in Step 3b. Assume there are exactly $(1-\epsilon)(\delta-t/n)n$ light nodes that contain the ID $u$ in their $S_{x}$ sets. Having fewer such nodes only decreases the probability that node $u$ is validated. Let $X$ be the number of light nodes queried by $v$ that answer the query for ID $u$. Then

[TABLE]

where the last step holds for any $C^{\prime}$ for $C$ chosen sufficiently large, provided that $t/n<1/4$. Thus, by Chernoff bounds, by setting $\lambda=(1-\epsilon/2)(1-\epsilon)-1$, we get that $Pr(X\geq(1-\epsilon/2)(\delta-t/n)C\log n)\leq n^{-c}$, for any fixed $c$, for $C$ sufficiently large. Let $Y$ be the number of bad nodes that are queried by $v$ about ID $u$. Again by Chernoff bounds, $Pr(Y\geq(1+\epsilon/2)(t/n)C\log n)\leq n^{-c^{\prime}}$ for any fixed $c^{\prime}$ for $C$ chosen sufficiently large. Putting these two facts together shows that the number of nodes in the sample that may answer $v$’s query about ID $u$ is, w.h.p., less than $\delta$.

A union bound over all nodes $v$ and IDs $u$ completes the proof.∎

For a fixed epoch, let CORE be the set of active nodes that run LargeCoreBA in Step 4. We show that the nodes participating in LargeCoreBA have the desired properties to successfully complete it when there are at least $Low-t$ light nodes. (See Lemma 1.)

From Lemma 2, we can observe the following.

Lemma 3**.**

If there are at least $Low-t$ light nodes then w.h.p., we have the following

Every active node is in the CORE, and therefore $|\textit{CORE}|\geq\textit{min}_{a}$. 2. 2.

For all $x\in\textit{CORE}$, $\textit{CORE}\subseteq S_{x}$ after Step 3c. 3. 3.

Let $B$ be the bad nodes in $\bigcup_{x\in\textit{CORE}}S_{x}$. At the conclusion of Step 3, if there are at least $Low-t$ light nodes, $|B|\leq\epsilon^{\prime}pn$ for any $\epsilon^{\prime}>0$, and $\frac{|B|}{|CORE|}\leq 1/2-\epsilon^{\prime\prime}$ for any $\epsilon^{\prime\prime}>0$.

Proof.

1. Follows from the way $n_{x}$ is set in Step 3b, and also from Lemma 2(1).

2. Follows from Lemma 2(2) and Lemma 2(3).

3. We note that no bad ID will be present in an $S_{x}$ unless it is validated, and by Lemma 2(4) w.h.p., this requires at least

[TABLE]

light nodes which contain this ID in their $S_{x}$ sets. A light node contains no more than $\textit{max}_{a}(1+\epsilon)$ IDs, of which at least $\textit{min}_{a}$ number are active.

Since $\textit{max}_{a}(1+\epsilon)-\textit{min}_{a}<4\epsilon pn$, there can be at most $4\epsilon pn$ IDs of bad nodes contained in $S_{x}$ for each light node $x$. As there are no more than $n$ light nodes, Lemma 2 implies that the total number of bad nodes which are validated is less than

[TABLE]

Where the last line follows for any $\epsilon^{\prime}$, provided that $\epsilon$ is sufficiently small, and $t<(1/4-\sqrt{\epsilon})n$; and the second to last line follows since $\epsilon$ was chosen such that $\epsilon_{0}\geq\sqrt{\epsilon}$. Thus the total number of bad nodes in $\bigcup_{x\in\textit{CORE}}S_{x}$ is less than $\epsilon^{\prime}pn$.

Since CORE contains at least $\textit{min}_{a}=(1-\epsilon)p(n-t)$ good nodes, $|\textit{CORE}|\geq(1-\epsilon)p(n-t)$, and hence $\frac{|B|}{|CORE|}<1/2-\epsilon$. ∎

Lemma 3 and Lemma 1 imply that LargeCoreBA can be successfully run when there are at least $Low-t$ light nodes. The following lemma follows from this fact and from Lemma 2. Figure 1 illustrates part of this lemma.

Lemma 4**.**

Let $L$ be the number of light nodes in an epoch of KT0-ByzantineAgreement. Then w.h.p.,

If $High\leq L$,

1. All active nodes have $\textit{ready-in}=1$, they run LargeCoreBA and decide on $\textit{ready-out}=1$ when run in Step 4; and

2. All active nodes $y$ run LargeCoreBA in Step 5 and set their $value$ bit to the input bit $value_{x}$ of some active node $x$.

If $Low\leq L<High$,

1. All active nodes successfully run LargeCoreBA but they may start with differing values for ready-out in Step 4.

2. If the output is a 1, all active nodes $y$ set $\textit{ready-out}=1$ and they will successfully run LargeCoreBA in Step 5 and set $value_{y}$ to the input $value_{x}$ for some active node $x$.

3. If the output is a 0, all active nodes set $\textit{ready-out}=0$.

If $Low-t\leq L<Low$, all active nodes will successfully run LargeCoreBA in Step 4, though some nodes will disregard the output. All active nodes will start with $\textit{ready-in}=0$ and all active nodes will have $\textit{ready-out}=0$. 4. 4.

If $L<Low-t$, some active nodes may run a possibly flawed LargeCoreBA in Step 4, though all active nodes will disregard the output. All active nodes will start with $\textit{ready-in}=0$ and end with $\textit{ready-out}=0$.

Proof.

If $L\geq Low-t$, then $n_{x}\geq Low-t$ for all nodes $x$, thus in Step 4, all active nodes have $\textit{ready-in}=0$, disregard the output of LargeCoreBA, and set $\textit{ready-out}=0$.

By Lemmas 3 and 1, when $L\geq Low-t$, LargeCoreBA will run successfully. If $L<Low$, then all active nodes $x$ have $n_{x}<High=Low+t$, so in Step 4, all active nodes $x$ have $\textit{ready-in}_{x}=0$. Thus, by the consistency property of LargeCoreBA, all active nodes $x$ have $\textit{ready-out}_{x}=0$.

If $L<High$, then all active nodes running LargeCoreBA in Step 4 may start with different ready-in values, but by the correctness of LargeCoreBA, they will all end with the same ready-out value. If the ready-out vale is $1$, in Step 5, LargeCoreBA will run correctly and they will all set their $value$ bit to the input bit, $value_{x}$ of some active node $x$.

If $L\geq High$, then any active node $x$ has $n_{x}\geq High$, and so has $\textit{ready-in}_{x}=1$. Thus, after Step 4, by the validity of LargeCoreBA, all active nodes will have $\textit{ready-out}=1$. Thus, they will all run LargeCoreBA in Step 5 and will all set their value bit to the input value bit of some active node. ∎

Lemma 5**.**

At the end of each epoch, w.h.p., all nodes either terminate and output the same value or they all go to the next epoch.

Proof.

By Lemma 4, if any active node $x$ sets $\textit{ready-out}=1$ after Step 5, all active nodes will set their tuple $(\textit{ready-out},\textit{value})$ to the value $(1,v)$, and $v$ will be the input bit of some node in CORE. Moreover, there must be at least $Low$ light nodes. Since every light node $y$ has at least $min_{a}$ IDs of active nodes in $S_{y}$, and $|S_{y}|\leq max_{a}+\epsilon n$, in Step 6, the majority of the messages received from nodes with IDs in $S_{y}$ will be $(1,v)$ and $y$ will set $\textit{ready-out}=1$ and $\textit{value}_{y}=v$. Since $Low=n-2t+\epsilon\geq t+2\epsilon$, all good nodes will come to agreement on $(1,v)$ in Step 7, when the Promise Agreement problem is solved correctly (by Lemma 9 in Section 4.2).

On the other hand, if any active node $x$ sets their value $\textit{ready-out}_{x}$ to 0, then we must be in Case 2, 3 or 4 of Lemma 4. In these cases, all active nodes have $\textit{ready-out}=0$, at the end of Step 5. Thus, all light nodes set $\textit{ready-out}=0$ since it is the majority value received in Step 6, and all nodes which are not light do not change their initial ready-out value from 0. Therefore, all nodes agree on $\textit{ready-out}=0$. With $\textit{ready-out}=0$, all nodes execute Steps 7b or 7c, depending on the value of $p$. ∎

3.2 Resource Costs

Lemma 6**.**

In any epoch, w.h.p., the algorithm sends $O((pn)^{2}\log n+pn^{2}+n\log n+T_{e})$ messages, where $T_{e}$ is the minimum of $n^{2}$ and the number of messages sent by bad nodes in that epoch. Moreover, in any epoch, the algorithm takes time polylogarithmic in $n$.

Proof.

There are $O(pn)$ active nodes which send to all nodes and each light node sends one message to $O(pn)$ nodes, for a total of $O(pn^{2})$ messages. When $S_{x}$ is reset, it is reset to be no larger than $n/\beta=O(np)$. To validate its $S_{x}$, each active node sends $O(\log n)$ messages for each element in $S_{x}$. There are $O(pn)$ active nodes, each with $|S_{x}|=O(n/\beta)=O(pn)$. Hence, issuing queries requires $O((pn)^{2}\log n)$ messages by good nodes. There are at most $T_{e}$ queries sent by bad nodes, so responding to queries requires $O(T_{e}+(pn)^{2}\log n)$ messages.

Computing LargeCoreBA in Steps 4 and 5, requires $O((pn)^{2})$ messages by Lemma 1. Then in Step 6, all active nodes send to all nodes for $O(pn^{2})$ messages. Finally, in Step 7, all nodes send $O(n\log n)$ messages to solve PromiseAgreement, as shown in Lemma 9. Thus, the total number of messages sent in the epoch is $O((pn)^{2}\log n+pn^{2}+n\log n+T_{e})$.

The time to perform all steps in an epoch is dominated by the cost of performing LargeCoreBA which is polylogarithmic. ∎

Lemma 7**.**

The algorithm terminates in a decision in a given epoch, unless the adversary sends $\Omega(pn^{2})$ messages.

Proof.

There are at least $High$ light nodes unless the adversary causes bad nodes to send more than $pn\epsilon$ messages to $n\epsilon$ nodes, for a total of $\Omega(pn^{2})$ messages. If there are at least $High$ light nodes in an epoch, then by Lemma 4 the algorithm terminates with a decision. ∎

Note that $O((pn)^{2}\log n+pn^{2})=O(pn^{2})$ except when $p>1/\log n$, in which case our algorithm runs LargeCoreBA on all the nodes, by messaging all $n$ of their neighbors, for a total cost of $O(n^{2})$. This is the bottleneck in the algorithm which causes it to be $O(\log n)$-competitive instead of $O(1)$-competitive.

Let $T$ be the minimum of $n^{2}$ and the total number of messages sent by the adversary, and $n$ be the number of nodes in the network. We can now prove Theorem 1.1.

3.3 Proof of Theorem 1.1

Proof.

By Lemma 7, the algorithm will terminate in an epoch, unless the adversary sends $cpn^{2}$ messages in that epoch, for some constant $c$. In epoch $i$, $p=(2^{i-1}\log n)/n$. If we do not terminate in epoch $i$, then $T\geq c2^{i-1}n\log n$. In epoch $i$, by Lemma 6, the total number of messages sent is $O((pn)^{2}\log n+pn^{2}+n\log n+T_{e})$.

We first consider the case where it’s always true that $p\leq 1/\log n$, and note that $O((pn)^{2}\log n+pn^{2})=O(pn^{2})$. Thus, the message cost in epoch $i$ is $O(n2^{i}\log n+T_{i})$, where $T_{i}$ is the number of messages sent by the adversary in epoch $i$. The $T_{i}$ terms clearly sum to $O(T)$. If $\ell$ is the last epoch, then $O(\sum_{i=1}^{\ell}2^{i}n\log n)=O(2^{\ell}n\log n)=O(T+n\log n)$. Thus the total number of messages sent in this case is $O(T+n\log n)$.

We next consider the case where $p>1/\log n$. In this case, our algorithm runs LargeCoreBA on all the nodes, by messaging all $n$ of their neighbors, for a total cost of $O(n^{2})$. The value of $T$ in this case is $\Omega(n^{2}/\log n)$, so our total message cost is $O(T\log n)$.

Since epoch $i$ has latency polylogarithmic in $n$ (by Lemma 1), and there are at most $\log n$ epochs, the total latency is $O(\operatorname{polylog}(n))$. Additionally, we note that when the algorithm terminates, by Lemma 7, all good nodes come to agreement on an input bit of some node in CORE.

Finally we note that we can also solve the leader election and committee election problems. To do this, the active nodes use Feige’s leader election algorithm to elect a committee in one step, or a leader in $\log^{*}n$ steps among the $CORE_{x}$ sets for every active node $x$. This is done instead of selecting an agreement value as in the KSSV algorithm. ∎

4 Additional Algorithms

4.1 LargeCoreBA

Here we prove Lemma  1. We do this by adapting the algorithm from [34]. In that paper, all nodes have a view of all of other nodes and nodes are numbered $[1,n]$.

The main idea of our adaptation is to show that for any $s$, $\log^{10}n\leq s\leq n$, there exists a deterministic assignment of IDs in $[1,n^{k}]$ to a set of $s/\ln n$ committees, so that for every subset of size $s$ IDs, a $1-1/\ln^{2}n$ fraction of committees are (1) “sufficiently large”; and (2) contain a nearly representative fraction of both good and bad nodes.

The algorithm in [34] is built upon a family of bipartite graphs with expansion-like properties. The existence of such graphs are proved using the probabilistic method (see Section 3 of [34]). We need the same properties here, but for a possibly much smaller subset of $s\leq n$ identities, which come from a much larger name space ($[1,n^{k}]$). We show that we can start with identities in the range $[1,n^{k}]$, of which $s$ are active and generate a set of committees which have the required properties with respect to the active nodes, as is needed in each layer of the “election graph” in [34], Corollary 3.2.

The following lemma achieves the needed result for the “static” network in that paper. We note that, in our algorithm, each node in epoch $i$ knows that the number of active nodes lies in the range $(1\pm\epsilon)2^{i}\log n$ for a fixed constant $\epsilon$, $0<\epsilon<1$.

Lemma 8**.**

Let $k,c,f_{g},f_{b}$ be any positive constants, where $c,k\geq 1$, and $(1-\epsilon)\leq f_{g}+f_{b}\leq(1+\epsilon)$. Let $i$ be an integer such that $1\leq i\leq\lg n/\lg\lg n$, and $s=(1+\epsilon)2^{i}\log n$. Further, let $L=[n^{k}]$, and $R=[s/\ln n]$ and $L_{g},L_{b}\subseteq L$ be any disjoint subsets where $|L_{g}|\geq f_{g}s$ and $|L_{b}|\leq f_{b}s$. Also for any bipartite graph over nodes $(L,R)$, let $\Gamma(r)$ denote the neighbors of node $r\in R$.

Then there exists a bipartite graph $(L,R)$, where each node in $R$ has degree $d\geq(C\ln^{6}n)(n^{k}/s)$, $C=4kc/(1-\epsilon)$, such that for all but a $1/\ln^{2}n$ fraction of nodes $r\in R$, all the following hold, with probability $1-3/n^{c}$:

Let $X_{s}=|\Gamma(r)\cap(L_{g}\cup L_{b})|$. Then $X_{s}\in(1\pm 1/\ln n)(f_{g}+f_{b})C\ln^{6}n$. 2. 2.

Let $X_{b}=|\Gamma(r)\cap L_{b}|$. Then $X_{b}\leq(1+1/\ln n)f_{b}C\ln^{6}n$. 3. 3.

Let $X_{g}=|\Gamma(r)\cap L_{g}|$. Then $X_{g}\geq(1-1/\ln n)(1-1/\ln n)f_{g}C\ln^{6}n$.

Proof.

Consider a bipartite multigraph with sides $L$ and $R$ where each node in $R$ has $d=(C\ln^{6}n)(n^{k}/s)$ neighbors chosen uniformly at random with replacement from $L$. Fix disjoint sets $L_{g},L_{b}\subseteq L$ where $|L_{g}|=f_{g}s$ and $|L_{b}|=f_{b}s$; and fix $R^{\prime}\subseteq R$, $|R^{\prime}|=s/\ln^{3}n\leq|R|/\ln^{2}n$.

Let $X$ be the number of edges from nodes in $R^{\prime}$ to $L_{g}$. Then

[TABLE]

By Chernoff bounds, for any positive $\lambda$, we have $Pr(|X-E(X)|\geq\lambda)\leq 2e^{-\frac{\lambda^{2}}{2E(X)}}$. Setting $\lambda=(1/\ln n)E(X)$, we get

[TABLE]

Let $\xi_{L_{g},R^{\prime}}$ be the event that for all nodes in $R^{\prime}$, condition (3) above fails. Let $\xi=\cup_{L_{g},R^{\prime}}\xi_{L_{g},R^{\prime}}$, for all $L_{g}$, $R^{\prime}$ of appropriate size. Then by a union bound,

[TABLE]

The last line in the above holds for $C>4kc/(1-\epsilon)$. Thus, with high probability, a random bipartite graph satisfies condition (3) for all sets $R^{\prime}$ and $L_{g}$. A similar analysis shows the same results for conditions (1) and (2). Putting these three facts together, the probability that a random graph fails any one of these properties is no more than $3/n^{c}$. In particular, such a graph exists. ∎

If we regard each node in $R$ as a committee whose members are the set of neighbor nodes contained in $L_{g}\cup L_{B}$, and if $|L_{g}|>(1+\epsilon)(2/3)s$ and $|L_{b}|\leq(1-\epsilon)s/3$, the nodes in $L_{g}$ which are mapped to the same committee can successfully run a linear time deterministic Byzantine agreement algorithm by Dolev et al. [21], even if they do not know the exact number and names of all the bad nodes participating, since the total number of bad nodes in any good node’s view mapped to the same committee is less than one third of the good nodes mapped to the committee. Each good node may fail to send a message to some bad node, or may fail to hear from some bad node, but a Byzantine agreement algorithm is resilient to a bad node which fails to send a message. Thus, the algorithm from [34] will work correctly with high probability. Moreover, this LargeCoreBA algorithm has latency that is polylogarithmic in the number of participants (active ndoes), and requires each active node to send only a polylogarithmic number of bits.

Note that the algorithm from [34] is almost everywhere, i.e., all but $1/\log n$ fraction of good nodes come to agreement. If we follow the last step with a step in which all active nodes send to each other, each can take the majority, so that all active good nodes come to the same correct decision, for a total number of messages $\leq(1+\epsilon)2^{2i}\log^{2}n$ messages in phase $i$.

4.2 PromiseAgreement

We now present a simple algorithm to solve the Promise Agreement problem, defined in Section 2.2.

PromiseAgreement

Each node $y$ sends a request to a random set of $c\log n$ nodes. 2. 2.

Each node $x$, upon receiving a request from a node $y$, responds to the request by reporting $(\textit{ready-out}_{x},\textit{value}_{x})$. 3. 3.

If greater than a $t/n+\epsilon$ fraction of nodes sampled by $x$ respond with $\textit{ready-out}=1$, then $x$ sets $\textit{ready-out}\leftarrow 1$ and sets $\textit{value}_{x}$ to the majority of the value bits sent by sampled nodes. Else $\textit{ready-out}_{x}\leftarrow 0$.

Lemma 9**.**

PromiseAgreement solves the Promise Agreement problem (Definition 1), with $O(1)$ latency, and sending $O(T^{\prime}+n\log n)$ bits, where $T^{\prime}$ is the minimum of $n^{2}$ and the number of messages sent by the adversary during this algorithm.

Proof.

Assume there are at least a $t/n+2\epsilon$ fraction of good nodes with $(\textit{ready-out},\textit{value})=(1,v)$ for the same bit $v$, and all remaining good nodes have ready-out values of [math]. By Chernoff and union bounds, every good node then has greater than a $t/n+\epsilon$ fraction of good nodes with ready-out values of $1$, and less than a $t/n+\epsilon$ fraction of bad nodes in their sample. Hence, all good nodes will terminate with tuple values of $(\textit{ready-out},\textit{value})=(1,v)$.

Assume that all good nodes have ready-out values of [math]. Then by Chernoff and union bounds, each sample has less than a $t/n+\epsilon$ fraction of bad nodes. Hence, all good nodes will terminate with ready-out values of [math].

The number of bits sent is just the number of queries sent which is $O(T^{\prime}+n\log n)$. ∎

5 Lower Bounds for Resource-Competitive Byzantine Agreement

We now study the lower bounds for resource-competitive Byzantine agreement (BA). We first show a tight lower bound on the resource competitiveness of deterministic BA protocols. Then we show a lower bound on the resource competitiveness of randomized BA protocols.

5.1 Deterministic Lower Bound

As per our model (cf. Section 1.1) we assume a complete $n$-node network with ${\epsilon}n$ Byzantine nodes and $(1-{\epsilon})n$ good nodes (i.e., non-Byzantine) for some small constant ${\epsilon}$. We assume the $KT_{0}$ model. The Byzantine nodes are controlled by a non-adaptive rushing adversary. It is assumed that Byzantine nodes cannot fake their own identities.

In the above setting, the goal is to show a lower bound on the message bits spent by the good nodes in any deterministic algorithm solving Byzantine everywhere agreement. The lower bound also holds in the $KT_{1}$ model, in which a node knows the ID of its neighbors.

The output of the algorithm, i.e., the agreed value depends on the ID, input distribution of the nodes and the information exchanged among the nodes during the execution of the algorithm. More precisely, the output of a node $u$ (with id $ID_{u}$) is a function $f_{u}(ID_{u},\,b_{u},\,X_{u})\rightarrow\{0,1\}$, where the argument $b_{u}$ is the input bit of $u$ and $X_{u}$ is the set of received message bits during the execution of the algorithm. Let us call this information $(ID_{u},\,b_{u},\,X_{u})$ as “transcript” of $u$. The algorithm is deterministic and known to the adversary which controls the Byzantine nodes. Further, the algorithm should work for any input distribution (i.e., the $0-1$ value distribution). Given an input distribution over the nodes, the complete execution of the algorithm is known to the adversary. Based on the execution, the adversary selects Byzantine nodes (in the beginning) in such a way that the algorithm fails to achieve agreement everywhere unless it spends enough messages. In fact, we prove the following result.

Theorem 5.1**.**

Suppose the budget of messages of the Byzantine nodes is $T\leq cn^{2}$ bits, for some constant $c$. Then any deterministic algorithm, which solves Byzantine everywhere agreement, incurs an expected $\Omega(\min\{T,\,n^{2}\})$ bits of messages.

Proof.

Let there be a deterministic algorithm $\mathcal{A}$ that solves the Byzantine agreement everywhere and incurs only $o(T)$ messages. We show a contradiction that the agreement is wrong in the sense that there exists two nodes with two different output value for some input distribution. Consider an arbitrary input distribution $\mathcal{I}$ over $n$ nodes. Since the total messages send by the good nodes is $o(T)$, there must exist a node, say, $u$ that exchanges (sends and receives) less than $\delta T/((1-{\epsilon})n)$ message bits in total for some small constant $\delta<1$ (the actual value of $\delta$ to be fixed later); otherwise the sum of the messages of all the good nodes would be $\Omega(T)$ (in fact, $u$ is the node which spends minimum number of messages throughout the execution of $\mathcal{A}$). Let $S_{u}$ be the set of nodes which exchange messages with $u$ throughout the execution of $\mathcal{A}$ on the given input $\mathcal{I}$. Note that, given $\mathcal{A}$ and $\mathcal{I}$, $u$ and $S_{u}$ are fixed and known to the adversary in the beginning. Further, for different input $\mathcal{I}$, the pair ($u$, $S_{u}$) might be different. The adversary then selects all the nodes in $S_{u}$ as Byzantine nodes before the execution starts. Thus the transcript of $u$ is fully controlled by the Byzantine nodes as $X_{u}$ is determined by the nodes in $S_{u}$. The transcript of $u$ is the total history of messages between $u$ and the rest of the nodes. Clearly, the decision of $u$ depends on the choice of $u$’s input value (0 or 1), $u$’s ID and its transcript (which might also include the IDs of the nodes that it communicated with). Also, in a valid protocol, every node (with every distinct ID and input value) will have a distinct transcript for deciding 0 or 1, respectively. Essentially, the adversary can decide a transcript for $u$ (depending on its input value and ID) such that the output value of $u$ would be different than the output value of all other good nodes (assuming all other good nodes execute the algorithm without any influence from the Byzantine nodes). This will give a contradiction to the everywhere agreement.

We now show that there are enough Byzantine nodes and each Byzantine node has sufficient budget to select all the nodes in $S_{u}$ as the Byzantine nodes (in the beginning). As explained above, the size of $S_{u}$ could be at most $\delta T/((1-{\epsilon})n)$. Clearly $S_{u}\neq\emptyset$ (otherwise, it won’t be a valid protocol). In other words, $1\leq|S_{u}|\leq\lceil\delta T/((1-{\epsilon})n)\rceil$. Now consider the following cases.

Case 1: $|S_{u}|=1$. That is $u$ exchanges at most $\delta T/((1-{\epsilon})n)$ messages with a single node, say $w$, throughout the execution of $\mathcal{A}$. If $w$ is selected to be a Byzantine node, it must have a budget of at least $\delta T/((1-{\epsilon})n)$ bits to be sent to $u$. Since the number of Byzantine nodes is ${\epsilon}n$ and their total budget is $T$, each Byzantine node can send (up to) $T/{\epsilon}n$ messages on average, i.e., the average budget of each Byzantine node can be (up to) $T/{\epsilon}n$. We need,

[TABLE]

which is satisfied for $\delta<(1-{\epsilon})/{\epsilon}$. Note that the remaining Byzantine nodes (i.e., which are not in $S_{u}$) may behave as the good nodes and response to the good nodes by following the algorithm $\mathcal{A}$. They are chosen from the nodes who spend lesser messages than the other nodes throughout the execution of $\mathcal{A}$. Thus the remaining Byzantine nodes is not spending more messages than the good nodes.

Case 2: $|S_{u}|=\lceil\delta T/((1-{\epsilon})n)\rceil$. Then ${\epsilon}n$ Byzantine nodes are sufficient to select all the nodes in $S_{u}$ in the beginning since (by assumption) $T\leq cn^{2}$ where the constant $c=(1-{\epsilon}){\epsilon}/\delta$ is determined as:

[TABLE]

Further, all the Byzantine nodes in $S_{u}$ have enough budget to communicate with $u$.

Case 3: $1<|S_{u}|<\lceil\delta T/((1-{\epsilon})n)\rceil$. This follows from Case 1 and Case 2. Case 1 says that a single Byzantine node has sufficient budget to communicate with $u$. Thus all the nodes in $S_{u}$ have enough budget to communicate with $u$. Also Case 2 says there are sufficient number of Byzantine nodes to select all the nodes in $S_{u}$ as Byzantine nodes.

Thus we claim that, given any input distribution there is a good node $u$ whose output (i.e., agreed value) is completely controlled by the adversary as the adversary controls the transcript of $u$. Now we argue that the algorithm $\mathcal{A}$ fails to achieve agreement everywhere for at least one of the following four input distributions:- $\mathcal{I}_{1}:$ all the nodes get value $1$, $\mathcal{I}_{2}:$ all the nodes get value [math], $\mathcal{I}_{3}:$ $u$ gets $1$ and rest get [math], and $\mathcal{I}_{4}:$ $u$ gets [math] and rest get $1$. Suppose the output of the algorithm $\mathcal{A}$ is constant, say all the nodes always output $1$, then the agreement is invalid for the input distribution $\mathcal{I}_{2}$. (Similarly invalid for $\mathcal{I}_{1}$ if output is always [math]). If the output is non-constant, i.e., the output depends on the input, IDs and the execution, then we show that there exists two good nodes (one is $u$ and any one from the remaining good nodes) that agree on two different bits for one of the input distributions $\mathcal{I}_{3}$ and $\mathcal{I}_{4}$. Based on the input value of $u$ (which is $1$ for $\mathcal{I}_{3}$, and [math] for $\mathcal{I}_{4}$) and its ID, the adversary decides the transcript of $u$ in such a way that $u$’s output bit will be opposite to the rest of the good nodes’ output bit. This contradicts that $\mathcal{A}$ solves the Byzantine agreement everywhere. Thus the number of message bits sent by the good nodes is $\Omega(T)$. ∎

The above argument holds even if the IDs are known to the neighbors (i.e., $KT_{1}$ model). The good nodes, in particular the node $u$, can never determine the Byzantine nodes, since the adversary selects the Byzantine nodes in the beginning and $u$ can have interactions with the Byzantine nodes only.

5.2 Randomized Lower Bound

Let us first consider a complete network with $n$ nodes $V$ in the anonymous setting, i.e., nodes do not have any identifiers. This can be extended to the non-anonymous $KT_{0}$ setting, where nodes have unique identities. Each node $v$ has $n-1$ ports through which it connects to the $n-1$ other nodes. Thus, if a node sends a message through a port $p\in[n-1]$ to another node $v$, then any message $u$ receives through $p$ is guaranteed to be from $v$. As before, among the $n$ nodes, a small fraction $\epsilon n$ (assumed to be integral) for a fixed $\epsilon>0$ are Byzantine and denoted $V^{b}$; let $V^{g}=V\setminus V^{b}$. Nodes can individually generate uniform and independent random bits as needed, but we do not assume the availability of common coins.

Our goal is to show a lower bound on the message complexity for Byzantine Agreement in the above setting (everywhere and with success probability 1) assuming that the adversary has full information and is a rushing adversary. Let us recall the definition of the message complexity.

Definition 2**.**

For a given BA algorithm $\mathcal{A}$, the message complexity $M_{\mathcal{A}}$ (or just $M$ when clear from context) is defined as the maximum expected number of the sum of the bits sent by good nodes. The maximum is taken over all possible adversarial strategies (i.e., choice of IDs, port assignments, input bits, and the behaviour of the Byzantine nodes) and the expectation is over the random bits used by the nodes.

Overview of our approach.

We show that if bad nodes can send $\Omega(n^{1+\alpha})$ messages, then the good nodes must send at least $\Omega(n^{1+\alpha/2})$ messages, for any $\alpha\in(0,1]$. If we assume not (for the sake of contradiction), then, good nodes can reach agreement while only sending $o(n^{\alpha/2})$ messages on average. Under this situation, when any good node $u$ sends a message to any other good node $v$, the bad nodes can bombard $v$ with $n^{\alpha/2}$ messages intended for denial of service (DoS). Node $v$ will be unable to distinguish between the legitimate message from $u$ and these DoS messages from bad nodes. As a result, $v$ will have to respond, on average, to $\Omega(n^{\alpha/2})$ messages from bad nodes first. This is more number of messages than what a good node $v$ can afford on average. Thus, several good nodes will not be able to establish two-way contact with any other good node, which we then exploit to show the impossibility via an indistinguishability argument.

Theorem 5.2**.**

Consider any BA algorithm $\mathcal{A}$ that guarantees that good nodes reach a valid agreement in the anonymous $KT_{0}$ setting as long as the number of messages sent by Byzantine nodes is at most $B=n^{1+\alpha}$ for some $\alpha\in(0,1]$. Then, the message complexity $M_{\mathcal{A}}$, i.e., the expected number of messages sent by good nodes, is at least $\Omega(n^{1+\frac{\alpha}{2}})$.

Proof.

Suppose for the sake of contradiction that there is a BA algorithm $\mathcal{A}$ for which $M_{\mathcal{A}}\in o(n^{1+\frac{\alpha}{2}})$ despite an adversarial budget of $B$. A quick upshot is that the average number of messages sent by good nodes is $o(n^{\frac{\alpha}{2}})$.

Our argument to show contradiction is structured as follows. We condition our entire argument on the total number of messages sent by good nodes to be bounded by at most $2M_{\mathcal{A}}\in o(n^{1+\frac{\alpha}{2}})$, which occurs with probability at least 1/2 by Markov’s Inequality. We first observe in Lemma 10 that good nodes receive messages from at most $o(n^{\alpha/2})$ different other good nodes. Exploiting this, we then give three adversarial scenarios. In all these scenarios, the Byzantine adversary employs a strategy in which half the Byzantine nodes use a denial-of-service style attack to suppress responses from good nodes. Under this adversarial strategy, we show in Lemma 11 that most good nodes are unable to establish two-way communication with any other good node. The remaining half of the Byzantine nodes exploit this situation to make it difficult for good nodes to distinguish between different scenarios that require different agreement values.

We begin with the following lemma that holds due to an elementary counting argument.

Lemma 10**.**

Recall the condition that at most $2M_{\mathcal{A}}\in o(n^{1+\frac{\alpha}{2}})$ messages are sent by good nodes. Under this condition, with high probability, each good node receives messages from at most $O(M_{\mathcal{A}}/n+\log n)$ different good nodes.

Proof.

Fix a good node $u$. Let $X_{v}$ be an indicator random variable taking the value 1 if good node $v$ sent a message to $u$. Notice that $E[X_{v}]=n_{v}/n$, where $n_{v}$ is the number of different nodes to which $v$ sent messages. The number of different good nodes from which $u$ received messages is given by $X=\sum_{v\in V^{g}}X_{v}$ and these $X_{v}$’s are independent owing to the fact that the ports at each node are independently permuted randomly. By linearity of expectation,

[TABLE]

Thus, we can apply Chernoff bounds to show that $\Pr(X\geq 12M_{\mathcal{A}}/n)\leq 2^{-2M_{\mathcal{A}}/n}$. If $M_{\mathcal{A}}\geq n\log n$, $\Pr(X\geq 12M_{\mathcal{A}}/n)\leq 1/n^{2}$ and applying the union bound over all $u\in V^{g}$, we get the required result. On the other hand, if $M_{\mathcal{A}}<n\log n$, then, $E[X_{v}]<\frac{\log n}{n}$ and $E[X]<\log n$, but we can still apply Chernoff bounds and get

[TABLE]

Again, we get the desired bound when we apply the union bound over all $u$. The claim follows when we combine the two Chernoff bounds. ∎

We now wish to show a certain adversarial strategy under which, with non-zero probability, at least one node will violate agreement. The Byzantine adversary’s strategy is as follows.

Port assignments.

The nodes are interconnected randomly in the sense that each node has port numbers 1 through $n-1$ through which it connects to the $n-1$ other nodes and the adversary connects a random permutation of the nodes to the $n-1$ ports. The permutations used for each of the nodes are (mutually) independent. Of course, the adversary will be aware of the port assignments.

Input bits.

Recall that there are $(1-\epsilon)n$ honest nodes $V^{g}$. The Byzantine adversary chooses one of the following three different scenarios.

Scenario 0:

All good nodes are assigned 0.

Scenario 1:

All good nodes are assigned 1.

Scenario 2:

Exactly half of them $V_{0}^{g}$ (chosen uniformly at random) are assigned an input bit 0 and the rest of them $V_{1}^{g}$ are assigned 1.

Denial of Service (DoS) Attackers.

Out of the $\epsilon n$ Byzantine nodes, the adversary designates $\epsilon n/2$ nodes as DoS attackers (denoted $D$). These DoS attackers behave in a specific manner towards nodes in $V^{g}$. We now describe this behavior of the DoS attackers for a fixed node $v\in V^{g}$. Whenever a node $u\not\in D$ sends a message $m$ to any good node $v$, the Byzantine adversary can observe this immediately and rushes in with $n^{\frac{\alpha}{2}}$ replicas of the (same message) $m$ from $n^{\frac{\alpha}{2}}$ DoS attackers denoted $D_{u\to v}$; the same $D_{u\to v}$ is used every time $u$ sends a message to $v$. However, for any pair $u\not\in{D\cup\{v\}}$ and $u^{\prime}\not\in{D\cup\{v\}}$, $u\neq u^{\prime}$, the adversary seeks to ensure that $D_{u\to v}\cap D_{u^{\prime}\to v}=\emptyset$. The adversary can ensure this pairwise disjointness as long as the number of nodes that send messages to $v$ is at most $o(n^{\frac{\alpha}{2}})$. This condition is in fact satisfied with sufficient probability (cf. Lemma 10) as long as the Byzantine adversary ensures that the number of nodes in $V^{b}\setminus D$ that contact $v$ is at most $o(n^{\frac{\alpha}{2}})$. Thus, from $v$’s perspective, to establish two-way contact with some good node $u$, it must intuitively respond to $\Omega(n^{\frac{\alpha}{2}})$ messages (on expectation), which is asymptotically more than its average budget.

Byzantine nodes that are not DoS attackers.

The strategy of nodes in $V^{b}\setminus D$ will be discussed later. We reiterate that the strategy must ensure that no good node is contacted by more than $o(n^{\frac{\alpha}{2}})$ nodes from $V^{b}\setminus D$.

A message $m$ from a node $v$ to a node $u$ is called a response if it is the first message from $v$ to $u$ and $u$ had sent a message to $v$ no later than $m$. Under this definition, note that two messages, one from $u$ to $v$ and the other from $v$ to $u$, sent in the same round will be considered responses to each other when no message transpired between them at any earlier point in time. This is however a rare event that we can safely ignore. Furthermore, a response from $v$ to $u$ is called a good response if both $v\in V^{g}$ and $u\in V^{g}$.

Lemma 11**.**

The total number of good responses sent by nodes in $V^{g}$ is $o(n)$ with probability at least $1-o(1)$.

Proof.

To aid in this proof, we first prove a claim about a simplified problem that we call the good apples problem (GAP). In this problem, we have $\bar{c}$ containers, $\bar{c}\geq c$ but $\bar{c}\in\text{poly}(c)$, and each container has $k$ apples (where $k\in\Omega(c^{\epsilon})$ for some $\epsilon>0$), but exactly one apple is good in each container and the rest are bad. We are allowed to pick a total of $cA(k)$ apples, where $A(k)\in o(k)$ but $A(k)\in\Omega(k^{\varepsilon})$ for some $\varepsilon>0$. Each pick can be from an arbitrarily chosen bin, but the apple that is picked must be chosen uniformly at random (UAR) and without replacement from the apples remaining in the chosen container. The goal is to pick as many good apples as possible. As a preliminary observation, notice that it doesn’t help to pick from a container after we have already picked the good apple from it. We now show that there is no strategy that guarantees picking $\Omega(c)$ good apples with any reasonable probability.

Claim 5.3**.**

The probability that the number of good apples picked exceeds $\alpha c$ for any fixed $\alpha>0$ is $o(1)$ regardless of the strategy used.

Proof Sketch.

We argue that the optimal strategy to solve GAP is to greedily pick from a single (arbitrarily chosen) container until we get the good apple in it and then moving to next container (chosen arbitrarily) and repeating. The intuition behind this strategy is that, once we have invested in a container $i$ with at least one pick (while all others are unpicked), a pick from $i$ is more likely to get the good apple than a pick from any other container.

Now under the optimal strategy, we can let $X_{i}$ be the indicator random variable that is 1 if the number of picks from container $i$ was at least $k/2$ given that the good apple in $i$ was picked. Clearly, $\Pr(X_{i}=1)\geq 1/2$. Moreover, given the budget of $cA(k)$ on the number of picks allowed, $\sum_{i}X_{i}\leq\frac{2cA(k)}{k}$. Let $G$ denote the total number of good apples that were picked. Notice that $G$ is dominated by $G^{*}$, the negative binomial distribution where $p=1/2$ and we are required to see $\frac{2cA(k)}{k}$ successes. Clearly, the probability that $G^{*}$ exceeds $\frac{12cA(k)}{k}$ can be viewed as the probability that the binomial random variable $B(\frac{12cA(k)}{k},1/2)$ is no more than $\frac{2cA(k)}{k}$, which is $o(1)$ by Chernoff bound. ∎

We now return to proving that the number of responses is $o(n)$ with probability at least $1-o(1)$. We can model the problem as a GAP. Each time a node $u\in V\setminus D$ sends a message to $v\in V^{g}$, recall that nodes in $D_{u\to v}$ send the exact same message. These messages sent by $D_{u\to v}\cup\{u\}$ can be viewed as a container with exactly one good message (i.e., the one sent by $u$) that $v$ needs to respond to. Since the total budget of messages that good nodes can send is $o(n^{1+\alpha/2})$, the total number of such “containers” can be at most $\bar{c}=o(n^{1+\alpha/2})$ and each container has $k=n^{\alpha/2}+1$ apples (corresponding to the DoS messages and the good message). Since the total message complexity $2M_{\mathcal{A}}$ is at most $o(n^{1+\alpha/2})=n\times o(n^{\alpha/2})$, we get the GAP instance by setting $c=n$ and $A(k)=o(n^{\alpha/2})$. From Claim 5.3, we know that the number of good apples picked is $o(c)$ with probability at least $1-o(1)$, which translates to the claim that the number of good responses is $o(n)$ with probability at least $1-o(1)$. ∎

The upshot is that a randomly chosen node $v\in V^{g}$ will not send any good response with probability at least a constant both under Scenario 0 and Scenario 1. Thus, this node (with constant probability) will have only managed to establish one-way communication with other good nodes. Let $I(v)\in V^{g}$ denote the set of good nodes that sent messages to $v$. By Lemma 10, $|I(v)|\in o(n^{\alpha/2})$. Since $\mathcal{A}$ guarantees BA everywhere, $v$ will be able to correctly decide on 0 (resp., 1) for Scenario 0 (resp., Scenario 1).

Let $\mathcal{A}(v,b)$ denote the strategy used by the nodes in $I(v)$ under Scenario $b$ for $b\in\{0,1\}$. For our lower bounding purpose, we can assume that all decisions by $\mathcal{A}(v,b)$ are made by a single coordinator within $I(v)$. The coordinator executing $\mathcal{A}(v)$ decides the content and timing of the messages sent by nodes in $I(v)$ to $v$. We assume that the coordinator is aware of $I(v)$ from the beginning. We even assume that it is aware of all messages sent by $v$. We are justified in making these assumptions because they only strengthen the algorithm. This strategy $\mathcal{A}(v,b)$ always ensures that $v$ correctly decides on $b$ under Scenario $b$, $b\in\{0,1\}$. In particular, it is resilient to all counter strategies by the Byzantine adversary.

Notice however that $\mathcal{A}(v,b)$ can be executed by $V^{b}\setminus D$ as well because these strategies only entail the Byzantine adversary playing the role of coordinator, choosing $o(n^{\alpha/2})$ Byzantine nodes and using them to send appropriate messages to $v$ at appropriate times. Of course, the Byzantine nodes are also aware of all messages sent by $v$.

Now, in order to complete the indistinguishability argument, we let the Byzantine adversary pick two nodes $v_{0}$ and $v_{1}$ uniformly at random under Scenario 2 and interact with them in such a way that they decide contradicting values. We condition on $v_{0}$ and $v_{1}$ starting with input values 0 and 1, respectively, which is anyway guaranteed to occur with probability 1/4 under Scenario 2. Moreover, the two nodes will not send any good response with constant probability. The Byzantine adversary then uses nodes in $V^{b}\setminus D$ to execute $\mathcal{A}(v_{0},0)$ and $\mathcal{A}(v_{1},1)$ towards $v_{0}$ and $v_{1}$, respectively. Specifically, the Byzantine adversary picks the $o(n^{\alpha/2})$ nodes from $V^{b}\setminus D$ to execute $\mathcal{A}(v_{0},0)$ (resp., $\mathcal{A}(v_{1},1)$) and – upon observing messages sent and received by $v_{0}$ and $v_{1}$ in each round – coordinates the chosen nodes to rush in with responses just as $\mathcal{A}(v,0)$ (resp., $A(v,1)$) would towards $v$ under Scenario [math] (resp., Scenario $1$). Since $v$ decided correctly under both Scenarios 0 and 1, the two nodes must decide on [math] and $1$, respectively, because their executions in Scenario 2 is indistinguishable from their respective executions in in Scenarios 0 and 1. Thus, with some constant probability, they reach contradicting decision values under Scenario 2. ∎

Extension to non-anonymous setting

We finally point out how to extend easily the above result to the non-anonymous setting, where honest nodes have unique identifiers; however, Byzantine nodes can fake their identifiers.888We note that this extension does not apply to setting where the Byzantine nodes are a bit weaker, i.e., they cannot fake their identities. This can be done by an easy reduction to the anonymous setting. Suppose in the non-anonymous setting there is a protocol that violates the lower bound shown in the anonymous setting. At the beginning of the protocol in the anonymous setting, honest nodes choose a random ID between $[1,n^{3}]$; it is easy to see that they are all unique with high probability. They then execute the protocol of the non-anonymous setting.

6 Conclusion

We have described an efficient randomized resource-competitive algorithm to solve Byzantine agreement, Leader election and Committee election, in the $KT_{0}$, synchronous communication model, with a static and full-information adversary. Our algorithm is efficient in the sense that message cost and latency grow slowly with the number of messages sent by the adversary. In particular, our algorithm uses $O((T+n)\log n)$ bits of communication, and has latency $O(\operatorname{polylog}(n))$, where $T$ is the minimum of $n^{2}$ and the number of bits sent by the nodes controlled by the adversary. Further, it succeeds with high probability. We also show lower bounds on resource-competitive Byzantine agreement algorithms. Our lower bounds show that in general, it is not possible to do significantly better than our algorithm with respect to the number of bits sent by Byzantine nodes. A key open problem is to close the gap between upper and lower bounds for randomized protocols across all budget values.