Multi-party communication complexity involves distributed computation of a function over inputs held by multiple distributed players. A key focus of distributed computing research, since the very beginning, has been to tolerate crash failures. It is thus natural to ask "If we want to compute a certain function in a fault-tolerant way, what will the communication complexity be?" This natural question, interestingly, has not been formally posed and thoroughly studied prior to this work. Whether

more »

... ult-tolerant communication complexity is interesting to study largely depends on how big a difference failures make. This paper proves that the impact of failures is significant, at least for the SUM aggregation function in general networks: As our central contribution, we prove that there exists (at least) an exponential gap between the non-fault-tolerant and fault-tolerant communication complexity of SUM. Our results also imply the optimality (within polylog factors) of some recent fault-tolerant protocols for computing SUM via duplicate-insensitive techniques, thereby answering an open question as well. Part of our results are obtained via a novel reduction from a new two-party problem UNIONSIZECP that we introduce. UNIONSIZECP comes with a novel cycle promise, which is the key enabler of our reduction. We further prove that this cycle promise and UNIONSIZECP likely play a fundamental role in reasoning about fault-tolerant communication complexity. * This article is the full Technical Report version of the PODC'12 paper with the same title. The first three authors of this article are alphabetically ordered. Fault tolerance in communication complexity and our exponential gap. involves distributed computation of a function over inputs held by multiple distributed players. A key focus of distributed computing research, since the very beginning, has been to tolerate failures. (Throughout this paper, failures refer to node crash failures unless otherwise mentioned.) It is thus natural to ask "If we want to compute a certain function in a fault-tolerant way, what will the communication complexity be?" For the question to be meaningful, we impose two restrictions before moving forward. First, we allow the computation to ignore/omit the inputs held by those players that have failed (i.e., crashed) or been disconnected. This means that the function needs to be well-defined over any subset of the inputs. Second, we will assume that there is one special root player that never fails and only this player needs to learn the final result. This allows us to focus on the communication complexity of the function instead of the difficulty of, for example, achieving fault-tolerant distributed consensus. This also nicely maps to our target scenarios later in wireless sensor networks and wireless ad-hoc networks, where the root corresponds to the base station. While the above question is natural, interestingly, it has not been formally posed and thoroughly studied -see later for our speculations on the possible reasons. Whether such fault-tolerant communication complexity is interesting to study, given the extensive research on "non-fault-tolerant" communication complexity, largely depends on how big a difference failures can make. This paper proves that the impact of failures is significant, at least for the SUM function 1 in networks with general topologies: As the central contribution of this work, we prove that there exists (at least) an exponential gap between the non-fault-tolerant (NFT) and fault-tolerant (FT) communication complexity of SUM. Here FT communication complexity is the smallest communication complexity among all fault-tolerant protocols that can tolerate an arbitrary number of failures, while NFT communication complexity corresponds to all protocols. To our knowledge, ours is the first such result on FT communication complexity. This exponential gap attests that FT communication complexity needs to be studied separately from NFT communication complexity. The SUM function. Consider a synchronous wireless network (e.g., a wireless sensor network or a wireless ad-hoc network) with N nodes and some arbitrary topology. Each node has a binary value, and the SUM function asks for the sum of all the values. Note that SUM can be easily reduced to and from some other interesting aggregation functions such as SELECTION. Communication complexity has significant practical relevance here since i) wireless communication usually consumes far more energy than local computation, and needs to be minimized for nodes operating on battery power or nodes relying on energy harvesting, and ii) the capacity of wireless networks does not scale well [18] . Existing results on SUM. In failure-free settings, by leveraging in-network processing, a trivial tree-aggregation protocol can compute SUM with zero-error while requiring each node to send O(log N ) bits. For (ǫ, δ)approximate results, it is possible to further reduce to O(log 1 ǫ + log log N ) bits per node for constant δ. In comparison, to tolerate arbitrary failures, we are not aware of any zero-error protocol for computing SUM that is better than trivially having every node flood its id together with its value and thus requiring each node to send O(N log N ) bits. For (ǫ, δ)-approximate results, researchers have proposed some protocols [5, 13, 25, 26, 31] where each node needs to send roughly O( 1 ǫ 2 ) bits for constant δ (after omitting logarithmic terms of 1 ǫ and N ). All these protocols conceptually map the value of each node to exponentially weighted positions in some bit vectors, and then estimate the sum from the bit vectors. Same as in one-pass distinct element counting algorithms in streaming databases [1, 16] , doing so makes the whole process duplicate-insensitive. In turn, this allows each node to push its value along multiple directions to guard against failures. Note however, that duplicate-insensitive techniques do not need to be one-pass, and furthermore tolerating failures does not have to use duplicate-insensitive techniques. For example, one could repeatedly invoke the tree-aggregation protocol until one happens to have a failure-free run. There is also a large body of work [3, 7, 11, 12, 20, 22 ,23] on computing SUM via gossip-based averaging (also called average consensus protocols). They all rely on the mass conservation property [23] , and thus are vulnerable to node failures. There have been a few efforts [15, 21] on making these protocols fault-tolerant. But they largely focus on correctness, without formal results on the protocol's communication complexity in the presence of failures. Despite all these efforts, no lower bounds on the FT communication complexity of SUM have ever been obtained, and thus it has been unknown whether the existing protocols can be improved. Our results. Our main results in this paper are the first lower bounds on the FT communication complexity (or FT lower bounds in short) of SUM, for public-coin randomized protocols with zero-error and with (ǫ, δ)-error. These FT lower bounds are (at least) exponentially larger than the corresponding upper bounds on the NFT communication complexity (or NFT upper bounds in short) of SUM, thus establishing an exponential gap. Private-coin protocols and deterministic protocols are also fully but implicitly covered, and our exponential gap still applies. Specifically, since there is a tradeoff between communication complexity and time complexity, Figure 1 summarizes our FT lower bounds when the time complexity of the SUM protocol is within b aggregation rounds (defined in Section 2), for b from 1 to ∞. For b ≤ N 0.25−c or 1 ǫ 0.5−c where c is any positive constant below 0.25, the NFT upper bounds are always at most logarithmic with respect to N or 1 ǫ , while the FT lower bounds are always polynomial. 2 For b > N 0.25−c or 1 ǫ 0.5−c , the NFT upper bounds drop to O(1), while the FT lower bounds are still at least logarithmic. Our results also imply that under small b values, the existing fault-tolerant SUM protocols (incurring O(N log N ) or O( 1 ǫ 2 ) bits [5, 13, 25, 26, 31] per node) are actually optimal within polylog factors. Our approach. Our FT lower bounds for b ≤ 2 − c are obtained via a simple but interesting reduction 2 Here for (ǫ, δ)-approximate results, we only considered terms containing ǫ. Even if we take the extra terms with N into account, our exponential gaps continue to exist as long as 1 ǫ c = Ω(log N ). 3 from a two-party communication complexity problem UNIONSIZE, where Alice and Bob intend to determine the size of the union of two sets. In the reduction, without knowing Bob's input, Alice can only simulate the SUM oracle protocol's execution in part of the network. Furthermore this part is continuously shrinking due to the spreading of such unknown information. Failures play a fundamental role in the reductionthey hinder the spreading of unknown information. The FT lower bounds under b ≤ N 0.25−c or 1 ǫ 0.5−c are much harder to obtain. There we introduce a new two-party problem called UNIONSIZECP, which is roughly UNIONSIZE extended with a novel cycle promise. Identifying this promise is a key contribution of this work, which enables the continuous injection of failures to further hinder the spreading of unknown information. We then prove a lower bound on UNIONSIZECP's communication complexity via information theoretic arguments [4] . This lower bound, coupled with our reduction, leads to FT lower bounds for SUM. We further prove a strong completeness result showing that UNIONSIZECP is complete among the set of all two-party problems that can be reduced to SUM in the FT setting via oblivious reductions (defined in Section 6). Namely, we prove that every problem in that set can be reduced to UNIONSIZECP. Our proof also implicitly derives the cycle promise, thus showing that it likely plays a fundamental role in reasoning about the FT communication complexity of many functions beyond SUM. Finally, our FT lower bounds under b > N 0.25−c or 1 ǫ 0.5−c are obtained by drawing a strong connection to an interesting probing game, and then by proving a lower bound on the probing game. Other related work. Despite the developments (e.g., [8, 10, 19, 28, 29] ) on different models for communication complexity, to the best of our knowledge, fault tolerance has never been considered. Among them, the closest setting to fault tolerance is perhaps unreliable channels [8, 28, 29 ] that either flip the bits adversarially or flip each bit iid. The specific techniques and insights there have limited applicability to our faulttolerant setting. Under the iid unreliable channel model, there have also been some information-theoretic lower bounds [2, 17] on the rates of distributed computations. We suspect that such a lack of prior work on fault tolerance is due to two reasons. First, one needs to define correctness in a meaningful way when failures are possible, since some of the inputs can be missing. For this work, recent applications in wireless sensor networks have shown us how to do so [5] . Second, communication complexity problems tend to be challenging to study, and taking failures into account only makes things harder. For this work, we rely on several quite recent results [9, 19]. Model and Definitions This section describes the system model and formal definitions used throughout this paper, except in Section 8. For clarity, we defer to Section 8 various relaxed/extended versions of the system model and definitions, under which our exponential gap results continue to hold. All "log" in this paper means log 2 . System model. We consider a wireless network with N nodes and an arbitrary undirected and connected graph G as the network topology. Each node has a unique id, and one of the N nodes is the root. We assume that the topology G (including the ids of each node in G) is known to all nodes. The system is synchronous and a protocol proceeds in synchronous rounds. In each round, a node (which has not failed) first performs some local computation, and then does either a send or receive operation (but not both). We also say that the node is in a sending state or a receiving state in that round, respectively. Our results are insensitive to whether collisions are possible, but to make everything concrete, we still adopt and stick to the following commonlyused collision model. By doing a send, a node (locally) broadcasts one message to all its neighbors in G. By doing a receive, the node receives the message sent by one of its neighbors j iff node j is the only sending node among all node i's neighbors. If multiple neighbors of i send in the same round, a collision occurs and node i does not receive anything. All our results hold regardless of whether node i can distinguish silence from collision. Failure model. The root never fails. Any other node in G may experience crash failures (but not byzantine 4 failure), and the total number of failures can be up to N − 1. See Section 8 for more discussion on the number of failures. To model worst-case behavior, we have an adversary determine which nodes fail at what time. The adversary can be adaptive to the behavior of the protocol (including the coin flips) so far, but it cannot predict future coin flip results. The SUM problem. Here each node i in G has a binary value w i , which is initially unknown to any other node. Let s 2 = N i=1 w i , and let s 1 be the sum of w j 's where by the end of the protocol's execution, node j has not failed or been disconnected from the root due to other nodes' failures. Following the same definitions from [5], a zero-error result of SUM is any s where s 1 ≤ s ≤ s 2 , and an (ǫ, δ)-approximate result of SUM is anyŝ such that for some zero-error result s, Pr[|ŝ − s| ≥ ǫs] ≤ δ. Time complexity of SUM protocols. We will consider only public-coin randomized protocols. By default, a "randomized protocol" in this paper is a public-coin randomized protocol. For a randomized SUM protocol and with respect to a topology G, we define the protocol's time complexity under G to be the number of rounds needed for the protocol to terminate, under the worst-case values of the nodes in G, the worst-case failures (for fault-tolerant cases), and the worst-case random coin flips in the protocol. The topology G has a large impact on time complexity, and we use the notion of aggregation rounds to isolate such impact. We will describe the time complexity in terms of aggregation rounds. This is analogous to describing it as a multiple of, for example, the diameter of G. In failure-free settings, an aggregation round in G consists of Λ(G) rounds, where Λ(G) is a function of the connected graph G. We will define Λ(G) precisely later in Section 3, which describes a simple deterministic tree-aggregation protocol and then defines Λ(G) as the number of rounds needed for that protocol to finish on G. When failures are possible, the network topology may change during execution. Let G be the set of all topologies that have ever appeared during the given execution. Note that a G ′ ∈ G may or may not be connected. For any such G ′ that is not connected, we define Λ(G ′ ) to be Λ(G ′′ ) where G ′′ is the connected component of G ′ that contains the root. To allow a fair comparison between NFT and FT communication complexity, we define an aggregation round in an execution with failures to be max G ′ ∈G Λ(G ′ ) rounds. This implies that an aggregation round for an FT protocol is either the same or longer than that for an NFT protocol, which makes our gap results stronger. 0 (SUM N , b) and R syn,ft ǫ,δ (SUM N , b). Communication complexity of two-party problems. Our proofs will also need to reason about the NFT communication complexity of some two-party problems. In such a problem Π, Alice and Bob each have an input X and Y respectively, and the goal is to compute the function Π(X, Y ). For all two-party problems in this paper, we only require Alice to learn the final result. We will often use n to denote the size of Π, as compared to N which describes the number of nodes in G. The communication complexity of a randomized protocol for computing Π is defined to be either the average-case or worst-case (over random coin flips) number of bits sent by Alice and Bob combined. In the classic setting without synchronous rounds [24] , similar as earlier, we define R 0 (Π) (R ǫ,δ (Π), respectively) to be the smallest average-case (worst-case, respectively) communication complexity across all randomized protocols that can generate a zero-error result ((ǫ, δ)-approximate result, respectively) for Π. We will also need to consider a second setting with synchronous rounds 3 , adapted from [19] . Here Alice and Bob proceed in synchronous rounds, where in each round Alice and Bob may simultaneously send a message to the other party. Alice, or Bob, or both may also choose not to send a message in a round. The time complexity of a randomized protocol for computing Π is defined to be the number of rounds needed for the protocol to terminate, over the worst-case input and the worst-case coin flips. We define R syn 0 (Π, t) (R