Radio Network Lower Bounds Made Easy

Radio Network Lower Bounds Made Easy

Calvin Newport
Georgetown University
cnewport@cs.georgetown.edu
Abstract

Theoreticians have studied distributed algorithms in the radio network model for close to three decades. A significant fraction of this work focuses on lower bounds for basic communication problems such as wake-up (symmetry breaking among an unknown set of nodes) and broadcast (message dissemination through an unknown network topology). In this paper, we introduce a new technique for proving this type of bound, based on reduction from a probabilistic hitting game, that simplifies and strengthens much of this existing work. In more detail, in this single paper we prove new expected time and high probability lower bounds for wake-up and global broadcast in single and multi-channel versions of the radio network model both with and without collision detection. In doing so, we are able to reproduce results that previously spanned a half-dozen papers published over a period of twenty-five years. In addition to simplifying these existing results, our technique, in many places, also improves the state of the art: of the eight bounds we prove, four strictly strengthen the best known previous result (in terms of time complexity and/or generality of the algorithm class for which it holds), and three provide the first known non-trivial bound for the case in question. The fact that the same technique can easily generate this diverse collection of lower bounds indicates a surprising unity underlying communication tasks in the radio network model—revealing that deep down, below the specifics of the problem definition and model assumptions, communication in this setting reduces to finding efficient strategies for a simple game.

1 Introduction

In this paper, we introduce a new technique for proving lower bounds for basic communication tasks in the radio network model. We use this technique to unify, simplify, and in many cases strengthen the best known lower bounds for two particularly important problems: wake-up and broadcast.

The Radio Network Model. The radio network model represents a wireless network as a graph , where the nodes in correspond to the wireless devices and the edges in specify links. Each node can broadcast messages to its neighbors in . If multiple neighbors of a given node broadcast during the same round, however, the messages are lost due to collision. This model was first introduced by Chlamtac and Kutten [4], who used it to study centralized algorithms. Soon after, Bar-Yehuda et al. [2, 3] introduced the model to the distributed algorithms community where variations have since been studied in a large number of subsequent papers; e.g., [1, 19, 17, 20, 13, 18, 6, 10, 11, 16, 9, 12, 8, 7, 15, 14].

Two of the most investigated problems in the radio network model are wake-up (basic symmetry breaking among an unknown set of participants in a single hop network) and broadcast (propagating a message from a source to all nodes in an unknown multihop network). Lower bounds for these problems are important because wake-up and/or broadcast reduce to most useful communication tasks in this setting, and therefore capture something fundamental about the cost of distributed computation over radio links.

Our Results. In this paper, we introduce a new technique (described below) for proving lower bounds for wake-up and broadcast in the radio network model. We use this technique to prove new expected time and high probability lower bounds for these two problems in the single and multiple channel versions of the radio network model both with and without collision detection. In doing so, we reproduce in this single paper a set of existing results that spanned a half-dozen papers [21, 19, 17, 13, 9, 7] published over a period of twenty-five years. Our technique simplifies these existing arguments and establishes a (perhaps) surprising unity among these diverse problems and model assumptions. Our technique also strengthens the state of the art. All but one of the results proved in this paper improve the best known existing result by increasing the time complexity and/or generalizing the class of algorithms for which the bound holds (many existing bounds for these problems hold only for uniform algorithms that require nodes to use a pre-determined sequence of independent broadcast probabilities; all of our lower bounds, by contrast, hold for all randomized algorithms). In several cases, we prove the first known bound for the considered assumptions.

The full set of our results with comparisons to existing work are described in Figure 1. Here we briefly mention three highlights (in the following, is the network size and the network diameter). In Section 6, we significantly simplify Willard’s seminal bound for expected time wake-up with collision detection [21]. In addition, whereas Willard’s result only holds for uniform algorithms, our new version holds for all algorithms. In Section 7, we prove the first tight bound for high probability wake-up with multiple channels and the first known expected time bound in this setting. And in Section 9, we prove that Kushilevitz and Mansour’s oft-cited lower bound for expected time broadcast [19] still holds even if we assume multiple channels and/or collision detection—opening an unexpected gap with the wake-up problem for which these assumptions improve the achievable time complexity.

Our Technique. Consider the following simple game which we call -hitting. A referee secretly selects a target set . The game proceeds in rounds. In each round, a player (represented by a randomized algorithm) generates a proposal . If , the player wins. Otherwise, it moves on to the next round. In Section 3, we leverage a useful combinatorial result due to Alon et al. [1] to prove that this game requires rounds to solve with high probability (w.r.t. ), and rounds in expectation. (Notice, you could propose the sets of a -selective family [5] to solve this problem deterministically, but this would require proposals in the worst-case.)

These lower bounds are important because in this paper we show that this basic hitting game reduces to solving wake-up and broadcast under all of the different combinations of model assumptions that we consider. In other words, whether or not you are solving wake-up or broadcast, assuming multiple channels or a single channel, and/or assuming collision detection or no collision detection, if you can solve the problem fast you can solve this hitting game fast. Our lower bounds on the hitting game, therefore, provide a fundamental speed-limit for basic communication tasks in the radio network model.

The trick in applying this method is identifying the proper reduction argument for the assumptions in question. Consider, for example, our reduction for wake-up with a single channel and no collision detection. Assume some algorithm solves wake-up with these assumptions in rounds, in expectation. As detailed in Section 5, we can use to define a player that solves the -hitting game in rounds with the same probability—allowing the relevant hitting game lower bound to apply. Our strategy for this case is to have the player simulate running on all nodes in a network of size . For each round of the simulation, it proposes the ids of the nodes that broadcast, then simulates all nodes receiving nothing. This is not necessarily a valid simulation of running on nodes: but it does not need to be. What we care about are the simulated nodes with ids in : the (unknown to the player) target set for this instance of the hitting game. The key observation is that in the target execution where only the nodes in are active, they will receive nothing until the first round where one node broadcasts alone—solving wake-up. In the player’s simulation, these same nodes are also receiving nothing (by the the player’s fixed receive rule) so they will behave the same way. This will lead to a round of the simulation where only one node from (and perhaps other nodes outside of ) broadcast. The player will propose these ids, winning the hitting game.

These reductions get more tricky as we add additional assumptions. Consider, for example, what happens when we now assume collision detection. Maintaining consistency between the nodes in in the player simulation and the target execution becomes more complicated, as the player must now correctly simulate a collision event whenever two or more nodes from broadcast—even though the player does not know . Adding multiple channels only further complicates this need for consistency. Each bound in this paper, therefore, is built around its own clever method for a hitting game player to correctly simulate a wake-up or broadcast algorithm in such a way that it wins the hitting game with the desired efficiency. These arguments are simple to understand and sometimes surprisingly elegant once identified, but can also be elusive before they are first pinned down.

Roadmap. A full description of our results and how they compare to existing results is provided in Figure 1. In addition, before we prove each bound in the sections that follow, we first discuss in more detail the relevant related work. In Section 2, we formalize our model and the two problems we study. In Section 3, we formalize and lower bound the hitting games at the core of our technique. In Section 4, we detail a general simulation strategy that we adopt in most of our wake-up bounds (by isolating this general strategy in its own section we reduce redundancy). Sections 5 to 8 contain our wake-up lower bounds, and Section 9 contains our broadcast lower bound. (We only need one section for broadcast as we prove that the same result holds for all assumptions considered in this paper.)

Existing Results (exp. high) This Paper (exp. high)
wake-up [17, 13] (*)
wake-up/cd [21] (*)
wake-up/mc (open) [9, 7] (*)
wake-up/cd/mc (open)
broadcast [19]
broadcast/cd/mc (open)
Figure 1: This table summarizes the expected time (exp.) and high probability (high) results for wake-up and broadcast in the existing literature as well as the new bounds proved in this paper. In these bounds, is the network size, the number of channels, and the network diameter. In the problem descriptions, “cd” indicates the collision detection assumption and “mc” indicates the multiple channels assumption. In the existing results we provide citation for the paper(s) from which the results derive and use “(open)” to indicate a previously open problem. In all cases, the new results in this paper simplify the existing results. We marked some of our results with “(*)” to indicate that the existing results assumed the restricted uniform class of algorithms. All our algorithms hold for all randomized algorithms, so any result marked by “(*)” is strictly stronger than the existing result. We do not separate expected time and high probability for the broadcast problems as the tight bounds are the same for both cases.

2 Model and Problems

In this paper we consider variants of the standard radio network model. This model represents a radio network with a connected undirected graph of diameter . The nodes in the graph represent the wireless devices and the edges in capture communication proximity. In more detail, executions in this model proceed in synchronous rounds. In each round, each node can choose to either transmit a message or receive. In a given round, a node can receive a message from a node , if and only if the following conditions hold: (1) is receiving and is transmitting; (2) is ’s neighbor in ; and (3) is the only neighbor of transmitting in this round. The first condition captures the half-duplex nature of the radio channel and the second condition captures message collisions. To achieve the strongest possible lower bounds, we assume nodes are provided unique ids from . In the following, we say an algorithm is uniform if (active) nodes use a predetermined sequence of independent broadcast probabilities to determine whether or not to broadcast in each round, up until they first receive a message.

In the collision detection variant of the radio network model, a receiving node can distinguish between silence (no neighbor is transmitting) and collision (two or more neighbors are transmitting) in a given round. In this paper, to achieve the strongest possible lower bounds, when studying single hop networks we also assume that a transmitter can distinguish between broadcasting alone and broadcasting simultaneously with one or more other nodes. In the multichannel variant of the radio network model, we use a parameter to indicate the number of orthogonal communication channels available to the nodes. When , we generalize the model to require each node to choose in each round a single channel on which to participate. The communication rules above apply separately to each channel. In other words, a node receives a message from on channel in a given round, if and only if in this round: (1) receives on and transmits on ; (2) is a neighbor of ; and (3) no other neighbor of transmits on .

We study both expected time and high probability results, where we define the latter to mean probability at least . We define the notation , for integers , to denote the range , and define , for integer , to denote .

Problems. The wake-up problem assumes a single hop network consisting of inactive nodes. At the beginning of the execution, an arbitrary subset of these nodes are activated by an adversary. Inactive nodes can only listen, while active nodes execute an arbitrary randomized algorithm. We assume that active nodes have no advance knowledge of the identities of the other active nodes. The problem is solved in the first round in which an active node broadcasts alone (therefore waking up the listening inactive nodes). When considering a model with collision detection, we still require that an active node broadcasts alone to solve the problem (e.g., to avoid triviality, we assume that the inactive nodes need to receive a message to wake-up, and that simply detecting a collision is not sufficient111Without this restriction, the problem is trivially solved by just having all active nodes broadcast in the first round.). When considering multichannel networks, we assume the inactive nodes are all listening on the same known default channel (say, channel ). To solve the problem, therefore, now requires that an active node broadcast alone on the default channel.

The broadcast problem assumes a connected multihop graph. At the beginning of the execution, a single source node is provided a message . The problem is solved once every node in the network has received . We assume nodes do not have any advance knowledge of the network topology. As is standard, we assume that nodes are inactive (can only listen) until they first receive . As in the wake-up problem, detecting a collision alone is not sufficient to activate an inactive node, and in multichannel networks, we assume inactive nodes all listen on the default channel.

3 The -Hitting Game

The -hitting game, defined for some integer , assumes a player that faces off against an referee. At the beginning of the game, the referee secretly selects a target set . The game then proceeds in rounds. In each round, the player generates a proposal . If , then the player wins the game. Otherwise, the player moves on to the next round learning no information other than the fact that its proposal failed. We formalize both entities as probabilistic automata and assume the player does not know the referee definition and the referee does not know the player’s random bits. Finally, we define the restricted -hitting game to be a variant of the game where the target set is always of size two.

A Useful Combinatorial Result. Before proving lower bounds for our hitting game we cite an existing combinatorial result that will aid our arguments. To simplify the presentation of this result, we first define some useful notation. Fix some integer . Consider two sets and . We say that hits if . Let an -family be a family of non-empty subsets of . The size of an -family , sometimes noted as , is the number of sets in . Fix two -families and . We say hits , if for every there exists an such that hits . Using this notation, we can now present the result:

Lemma 3.1 ([1, 15]).

There exists a constant , such that for any integer , these two results hold:

  1. There exists an -family , where , such that for every -family that hits , .

  2. There exists an -family , where , such that for every , hits at most a -fraction of the sets in .

The first result from this lemma was proved in a 1991 paper by Alon et al. [1]. It was established using the probabilistic method and was then used to prove a lower bound on centralized broadcast solutions in the radio network model. The second result is a straightforward consequence of the analysis used in [1], recently isolated and proved by Ghaffari et al. [15].

Lower Bounds for the -Hitting Game. We now prove lower bounds on our general and restricted -hitting games. These results, which concern probabilities, leverage Lemma 3.1, which concerns combinatorics, in an interesting way which depends on the size of and being polynomial in .

Theorem 3.2.

Fix some player that guarantees, for all , to solve the -hitting game in rounds, in expectation. It follows that .

Proof.

Fix any . Let and be the constant and -family provided by the second result of Lemma 3.1 applied to . The lemma tells us that for any , hits at most a -fraction of the sets in . It follows that for any -family , such that , hits less than half the sets in .

We now use these observations to prove our theorem. Let be a -hitting game player. Consider a referee that selects the target set by choosing a set from with uniform randomness. Let be the first proposals generated by in a given instance of the game. By our above observation, this sequence of proposals hits less than half the sets in . Because the target set was chosen from with randomness that was uniform and independent of the randomness used by to generate its proposals, it follows that the probability that hits the target is less than . To conclude, we note that must therefore be larger than , as required by the theorem. ∎

Theorem 3.3.

Fix some player that guarantees, for all , to solve the -hitting game in rounds with probability at least . It follows that .

Proof.

Fix any . Let be the -family provided by the first result of Lemma 3.1 applied to this value. Let . We know from the lemma that .

To achieve our bound, we will consider the behavior of a player in the -hitting game for . As in Theorem 3.2, we have our referee select its target set by choosing a set from with uniform randomness. (Notice, in this case, our referee is actually making things easier for the player by restricting its choices to only the values in even though the game is defined for the value set , which is larger. As we will show, this advantage does not help the player much.)

Let , for some constant , be the exact lower bound from the first result of Lemma 3.1. Let be the first proposals generated by in a given instance of the game. Lemma 3.1 tells us that there is at least one set that does not hit. Because the target set was chosen from with randomness that was uniform and independent of the randomness used by , it follows that the probability that misses the target is at least (recall that is the size of ). Inverting this probability, it follows that the probability that wins the game with the proposals represented by is less than or equal to . It follows that must be larger than and therefore must be of size at least . To conclude the proof, we note that , and therefore we can express in terms of as some polynomial in , for some positive constant . Substituting for in our above equation, it follows that , as required by the theorem. ∎

Theorem 3.4.

Fix some player that guarantees, for all , to solve the restricted -hitting game in rounds with probability at least . It follows that .

Proof.

Our proof strategy is to prove a variant of the first result of Lemma 3.1 that will allow us to reuse the proof argument of Theorem 3.3 to prove our needed result for the restricted case. To do so, fix any . Consider the -family that consists of the unique pairs in . Fix some -family of size . We now show the existence of some not hit by . To do so, we first define a function , where returns a binary string of length , where bit of is if and only if is in the set in , by some fixed ordering of these sets. Given our assumption that , it follows that the total number of unique binary strings of length can be upper bounded as .

The pigeonhole principle tells us that there exist , such that . It follows that the set is not hit by , as we just established that there is no that contains or , but not both. At this point, we have established the existence of a -family made up only of sets of size two () such that any -family that hits this family must be of size at least . We can consider this a variant of the first result of Lemma 3.1, and therefore achieve our bound by now applying the same proof argument as in Theorem 3.3 to this variant of the result. This argument provides that rounds are required to solve the restricted hitting game with probability at least , as required by the theorem. ∎

4 Simulation Strategy

Most of our bounds for the wake-up problem use a similar simulation strategy. To reduce redundancy, we define the basics of the strategy and its accompanying notation in its own section. In more detail, the wake-up simulation strategy, defined with respect to a wake-up algorithm , is a general strategy for a -hitting game player to generate proposals based on a local simulation of . The strategy works as follows. The player simulates running on all nodes in a -node network satisfying the same assumptions on collision detection and channels assumed by . For each simulated round, the player will generate one or more proposals for the hitting game. In more detail, at the beginning of a new simulated round, the player simulates the nodes running up until the point that they make a broadcast decision. At this point, the player applies a proposal rule that transforms these decisions into one or more proposals for the hitting game. The player then makes these proposals, one by one, in the game. If none of these proposals wins the hitting game, then the player most complete the current simulated round by using a receive rule to specify what each node receives; i.e., silence, a message, or a collision (if collision detection is assumed by ). In other words, a given application of the wake-up simulation strategy is defined by two things: a definition of the proposal rule and receive rule used by the player to generate proposals from the simulation, and specify receive behavior in the simulation, respectively.

To analyze a wake-up simulation strategy for a given instance of the -hitting game with target set , we define the target execution for this execution to be the execution that would result if was run in a network where only the nodes corresponding to were active and they used the same random bits as the player uses on their behalf in the simulation. We say an instance of the simulation strategy is consistent with its target execution through a given round, if the nodes corresponding to in the simulation behave the same (e.g., send and receive the same messages) as the corresponding nodes in the target execution through this round.

5 Lower Bounds for Wake-Up

We begin by proving tight lower bounds for both expected and high probability solutions to the wake-up problem in the most standard set of assumptions used with the radio network model: a single channel and no collision detection. As explained below, our bounds are tight and generalize the best know previous bounds, which hold only for uniform algorithms, to now apply to all randomized algorithms. (We note that a preliminary version of our high probability bound below appeared as an aside in our previous work on structuring multichannel radio networks [8]).

In terms of related work, the decay strategy introduced Bar-Yehuda et al. [3] solves the wake-up problem in this setting with high probability in rounds and in expectation in rounds. In 2002, Jurdzinski and Stachowiak [17] proved the necessity of rounds to solve wake-up with probability at least , which proves decay optimal within a factor. Four years later, Farach-Colton et al. [13] removed the factor by applying linear programming techniques. As mentioned, these existing bounds only apply to uniform algorithms in which nodes use a predetermined sequence of broadcast probabilities. (Section of [13] claims to extend their result to a slightly more general class of uniform algorithms in which a node can choose a uniform algorithm to run based on its unique id.)

Theorem 5.1.

Let be an algorithm that solves wake-up with high probability in rounds in the radio network model with a single channel and no collision detection. It follows that .

Proof.

Fix some wake-up algorithm that solves wake-up in rounds with high probability in a network with one channel and no collision detection. We start by defining a wake-up simulation strategy that uses (see Section 4). In particular, consider the proposal rule that has the player propose the id of every node that broadcasts in the current simulated round, and the receive rule that always has all nodes receive nothing.

Let be the -hitting game player that uses this simulation strategy. We argue that solves the -hitting game in rounds with high probability in . To see why, notice that for a given instance of the hitting game with target , is consistent with the target execution until the receive rule of the first round in which exactly one node in broadcasts. (In all previous rounds, correctly simulates the nodes in receiving nothing, as its receive rule has all nodes always receive nothing.) Assume solves wake-up in round in the target execution. It follows that is the first round in which a node in broadcasts alone in this execution. By our above assumption, is consistent with the target execution up to the application of the receive rule in . In particular, it is consistent when it applies the proposal rule for simulated round . By assumption, this proposal will include exactly one node from —winning the hitting game.

We assumed that solves wake-up in rounds with high probability in . Combined with our above argument, it follows that solves the -hitting game in rounds with high probability in . To complete our lower bound, we apply a contradiction argument. In particular, assume for contradiction that there exists a wake-up algorithm that solves wake-up in rounds, with high probability. The hitting game player defined above will therefore solve -hitting in rounds with high probability. This contradicts Theorem 3.3. ∎

Theorem 5.2.

Let be an algorithm that solves wake-up in rounds, in expectation, in the radio network model with a single channel and no collision detection. It follows that .

Proof Idea..

It is sufficient to apply the same argument as in Theorem 5.1. The only change is in the final contradiction argument, where we simply replace with , and now contradict Theorem 3.2. ∎

6 Lower Bounds for Wake-Up with Collision Detection

We prove tight lower bounds for expected and high probability bounds on the wake-up problem in the radio network model with collision detection. In terms of related work, a seminal paper by Willard [21] describes a wake-up algorithm (he called the problem “selection resolution,” but the definition in this setting is functionally identical) which solves the problem in rounds, in expectation. He also proved the result tight with an lower bound for uniform algorithms. As Willard himself admits, his lower bound proof is mathematically complex. Below, we significantly simplify this bound and generalize it to hold for all algorithms. From a high-probability perspective, many solutions exist in folklore for solving wake-up (and related problems) in rounds. Indeed, leveraging collision detection, wake-up can be solved deterministically in rounds (e.g., use the detector to allow the active nodes to move consistently through a binary search tree to identify the smallest active id). The necessity of rounds seems also to exist in folklore.

We begin with our high probability result. Our simulation strategy is more difficult to deploy here because the player must now somehow correctly simulate the collision detection among the nodes in the (unknown) target set . To overcome this difficulty, we apply our solution to networks in which only two nodes are activated and then achieve a contradiction with our lower bound on restricted hitting.

Theorem 6.1.

Let be an algorithm that solves wake-up with high probability in rounds in the radio network model with a single channel and collision detection. It follows that .

Proof.

Fix some wake-up algorithm that solves wake-up in rounds with high probability in a network with one channel and collision detection. We start by defining a wake-up simulation strategy that uses (see Section 4). In particular, consider the proposal rule that has the player propose the id of every node that broadcasts in the current simulated round, and a receive rule that has two cases: (1) if a given player broadcast in the current simulated round, it is simulated as detecting a collision; (2) if a given player did not broadcast in the current simulated round, it is simulated as receiving and detecting nothing.

Let be the restricted -hitting game player that uses this simulation strategy. We cannot argue that this player solves the general -hitting game, as the receive rule above is not likely to be consistent for many target sets. We instead argue that solves restricted -hitting in rounds with high probability in . In other words, our receive rule above, we will show, keeps the simulation consistent when the target only contains two nodes (as is the case in restricted hitting). In more detail, fix a given instance of the restricted -hitting game with some target set . We argue that is consistent with the target execution until it applies the receive rule in the first round in which a node in broadcasts alone (at which point, the player will have won the hitting game). In particular, there are three cases relevant to the receive behavior in a given round of the target execution for . The first case is that and are both silent. In this case, they would both receive and detect nothing in the target execution. By definition, they will both receive nothing in ’s simulation as well. The second case is that both and broadcast. In this case, they would both correctly detect a collision in the target execution. By definition, the same occurs in the simulation. The third case has exactly one of the two nodes broadcasting. In this case, the player wins the hitting game during the proposal rule of this simulated round, so we do not have to care about applying the receive rule in a way that maintains consistency.

We assumed that solves wake-up in rounds with high probability in . Clearly, this bound still holds even if we restrict our attention to networks with only two nodes activated. Combined with our above argument, therefore, it follows that solves the restricted -hitting game in rounds with high probability in . Assume for contradiction that . It would follow that solves the restricted hitting game in rounds with high probability. This contradicts Theorem 3.4. ∎

We now simplify and strengthen Willard’s bound of rounds for expected time wake up. At the core of our result is a pleasingly simple but surprisingly useful observation: if you can solve wake-up in rounds with collision detection, you can then use this strategy to solve the hitting game in rounds by simulating (carefully) all possible sequences of outcomes for the collision detector behavior in a round execution. Solving the problem in rounds (in expectation) with collision detection, therefore, yields a hitting game solution that requires only rounds (in expectation), contradicting Theorem 3.2—our lower bound on expected time solutions to the hitting game.

Theorem 6.2.

Let be an algorithm that solves wake-up in rounds, in expectation, in the radio network model with a single channel and collision detection. It follows that .

Proof.

Fix some algorithm that solves wake-up in rounds, in expectation, in this setting. We start by defining a player that simulates to solve -hitting in no more than rounds, in expectation. Our player will use a variant of the simulation strategy defined in Section 4 and used in the preceding proofs, and we will, therefore, adopt much of the terminology of this approach (with some minor modifications). In more detail, in this variant, will run a different fixed-length simulation of , starting from round , to generate each of its guesses in the hitting game. Most of these simulations will not be consistent with the relevant target execution. We will show, however, that in the case that the target execution solves wake-up, at least one such simulation is consistent and will therefore win the game.

In more detail, for a given , let be a full rooted binary tree of depth . We define a tree node labeling , such that for every non-root node , if is a left child of its parent and if is a right child (by some consistent orientation). Let be the depth function (i.e., is the depth of in the tree with ). Finally, let return the -bit binary string defined by the sequence of labels (by ) on the path that descends from the root to (including ). For example, if the path from the root to goes from the root to its right child , then from to its left child , .

Our player , when playing the -hitting game, generate one guess for each node in . Fix some such node . To generate a guess for , the player first executes a -round simulation of , running on all nodes in a -node network, using to specify collision detector behavior (in a manner described below). After it simulates these full rounds, it then simulates just enough of round to determine the simulated nodes’ broadcast decisions in this round. The player proposes the id of the nodes that choose to broadcast in this final partial round. (When generating a guess for the root node, the player simply proposes the nodes that broadcast in the first round.)

In more detail, for each round of the simulation for tree node , if the bit of is , the player simulates all nodes detecting silence, and if the bit is , it simulates all nodes detecting a collision. As a final technicality, let be the random bits provided to the player to resolve its random choices. We assume that for each simulated node , the players uses the same bits from for in each of its simulations. We do not, therefore, assume independence between different simulations.

Consider the target execution of for a given instance of the hitting game with target set and random bits . Assume that the target execution defined for these bits and target set solves wake-up in some round . Notice that in every round , there are only two possible behaviors: (1) no nodes broadcast (and all nodes therefore receive and detect nothing); and (2) two or more nodes broadcast (and all nodes therefore detect a collision). By definition, there exists a node in such that is a binary string of length , where for each bit position in the string, if no nodes broadcast in that round of the target execution, and if two or more nodes broadcast in that round of the target execution. It follows that the first rounds of the simulation associated with tree node are consistent with the target execution. Because exactly one node from broadcasts in round of the target execution, and the -simulation is consistent through round , then this same single node from will broadcast in the simulated beginning of round . The player’s proposal associated with will therefore win the hitting game.

Pulling together the pieces, by assumption, the target execution for a given and solves wake-up in rounds, in expectation. It follows that our player solves -hitting with the same probability. The number of guesses required to solve the problem in this case is bounded by the number of nodes in (as there is one guess per node), which is . We can now conclude with our standard style of contradiction argument. Assume for contradiction that there exists an algorithm that solves wake-up with a single channel and collision detection in rounds, in expectation. It follows that wins the -hitting game in rounds, in expectation. This contradicts Theorem 3.2. ∎

7 Lower Bounds for Wake-Up with Multiple Channels

In recent years, theoreticians have paid increasing attention to multichannel versions of the radio network model (e.g., [10, 11, 16, 9, 12, 8, 7]). These investigations are motivated by the reality that most network cards allow the device to choose its channel from among multiple available channels. From a theoretical perspective, the interesting question is how to leverage the parallelism inherent in multiple channels to improve time complexity for basic communication problems. Daum et al. [7], building on results from Dolev et al. [9], prove a lower bound of rounds for solving wake-up with high probability and uniform algorithms in a network with channels. A lower bound for expected-time solutions was left open. The best known upper bound solves the problem in rounds with high probability and in rounds in expectation [7].

In the theorems that follow, we prove new lower bounds that match the best known upper bounds. These bounds close the gap that exists with the best known previous results, establish the first non-trivial expected time bound, and strengthen the results to hold for all algorithms. We begin with the high probability result. In this bound, the term dominates when is small and the term dominates when is large. We handle these cases separately in their own lemmas—each using a different simulation strategy—then combine them to achieve our final theorem.

Lemma 7.1.

Let be an algorithm that solves wake-up with high probability in rounds in the radio network model with channels. It follows that for every , .

Proof.

Assume for contradiction that there exists a wake-up algorithm that solves wake-up with high probability in this setting in rounds for some . We start by defining a wake-up simulation strategy (see Section 4) that simulates in a network with channels. In particular, consider the proposal rule that generate proposals for each simulated round. In particular, for each channel , it proposes the ids of the simulated nodes (if any) that broadcast on in the simulated round. Assume the player uses the simple receive rule that has all simulated nodes receive nothing.

Let be the -hitting game player that deploys this simulation strategy for our fixed value of . We argue that solves -hitting in rounds with high probability. To do so, we first argue that for a given instance of the hitting game with some target set , the player is consistent with the target execution until it applies the receive rule in the first round in which there is a channel on which some node from broadcasts alone, as in all previous rounds and channels, there are either no broadcasters or two or more broadcasters from : both cases in which the receive rule behavior of receiving nothing is correct. (This event does not necessarily imply that the player’s simulation becomes inconsistent—for example, if a node from broadcasts by itself on some channel other than with no other nodes from present to receive, the simulation is still consistent—but it holds that before this event happens the simulation is definitely consistent.)

Next, assume solves wake-up in round of this target execution. This requires a node from to broadcast alone on channel in . It follows that in some round in this target execution some node from broadcasts alone on a channel for the first time. As argued above, our simulation strategy is consistent with the target execution through . Therefore, the simulation will make the same broadcast decisions for nodes in round as in the target execution. Let be the smallest channel with a single broadcaster from in of the target execution. When the player makes its proposal for this channel and this round, it will win the hitting game.

We assumed that solves wake-up in rounds with high probability in . Combined with our above argument, it follows that our player solves -hitting in rounds with high probability in . By our assumption, however, for our fixed value of , which implies . This contradicts Theorem 3.3. ∎

Lemma 7.2.

Let be an algorithm that solves wake-up with high probability in rounds in the radio network model with channels. It follows that for every , .

Proof.

Assume for contradiction that there exists a wake-up algorithm that solves wake-up with high probability in this setting in rounds for some . We start by defining a wake-up simulation strategy (see Section 4) that simulates in network with channels. In particular, consider the proposal rule that generates up to two proposals per simulated round: the first proposal includes the ids of every node (if any) that broadcast in this simulated round (regardless of their channel choice), while the second proposal includes only the ids of every node (if any) that broadcast on channel during this simulated round. Assume the player uses the simple receive rule that has all nodes always receive nothing.

Let be the -hitting game player that uses this simulation strategy. We cannot prove that this player generates a simulation consistent with the target execution for all possible target sets. For our purposes here, however, we only need prove that the game is consistent in the special case where the size of the target set is always of size two (clearly, an algorithm that works for all network sizes will work in the special case where the number of active nodes happens to be two). We will then derive our contradiction with the lower bound on the restricted hitting game, which is sufficiently strong to achieve our needed logarithmic result.

In more detail, fix an an instance of the restricted hitting game with some target set . We call a round of the target execution meaningful if at least one of the two following conditions holds: (1) exactly one node from broadcasts on channel ; (2) exactly one node from broadcasts. Notice, these are not equivalent conditions. If, for example, broadcasts on channel and on channel , we satisfy the first property but not the second. We first argue that the player is consistent with the target execution until the receive rule is applied in the first meaningful round. To do so, consider the different combinations of possible behavior for and in a non-meaningful round: if and are both silent in a given round of the target execution, they both receive nothing in the target execution and in the player’s simulation; if and both broadcast in the target execution, and it is not the case that exactly one of these two nodes broadcasts on channel , then both receive nothing and wake-up is not solved in the target execution as well as in the simulation.

Assume the target execution eventually generates a meaningful round. Call this round . The player wins the hitting game in round . This follows because we argued that the player is consistent with the target execution through . Therefore, it will simulate the same broadcast behavior in as in the target execution. Regardless of which case in the definition of meaningful applies in , one of the proposals for this round will win the game. Pulling together the pieces, we note that the algorithm solves wake-up (and therefore generates a meaningful round) in this setting in rounds, with high probability in , for our fixed . Therefore, our player solves restricted -hitting in no more than rounds, with high probability in . We assumed, however, that . It follows that our player solves the restricted hitting game in rounds with high probability in . This contradicts Theorem 3.4. ∎

Our main theorem follows directly from Lemma 7.1 and 7.2:

Theorem 7.3.

Let be an algorithm that solves wake-up with high probability in rounds in the radio network model with channels. It follows that for every , .

Moving on to the expected case, we prove the necessity of rounds using the same technique as in Lemma 7.1:

Theorem 7.4.

Let be an algorithm that solves wake-up in rounds, in expectation, in the radio network model with channels. It follows that for every , .

Proof Idea..

We can apply the same wake-up simulation strategy and analysis as in Lemma 7.1. In this case, we are simply replacing with , and now deriving our contradiction with Theorem 3.2. ∎

8 Lower Bound for Wake-Up With Collision Detection and Multiple
Channels

The final combination of model parameters to consider for wake-up is collision detection and multiple channels. No non-trivial upper or lower bounds are currently known for this case. We rectify this omission by proving below that rounds are necessary to solve this problem with high probability in this setting. Notice, this bound represents an interesting split with the preceding multichannel results (which assume no collision detection), as the speed-up is now logarithmic in instead of linear. On the other hand, the term in the previous case is replaced here with a faster term.

Collision detection, in other words, seems to be powerful enough on its own that adding extra channels does not yield much extra complexity gains. We do not consider an expected time result for this setting. This is because even without collision detection, the best known upper bound for multichannel networks [7] approaches time (which is trivially optimal) quickly as the number of channels increases.

Theorem 8.1.

Let be an algorithm that solves wake-up with high probability in rounds in the radio network model with channels and collision detection. It follows that for every , .

Proof.

Assume for contradiction that there exists a wake-up algorithm for this setting that solves the problem with high probability in , for some .

To achieve our final bound, we will handle both the and the term separately. We begin with the term. This term is non-trivial only when , so assume this holds for the following argument. Consider the restricted wake-up problem where the adversary guarantees to activate exactly two nodes. We can construct a new wake-up algorithm, , that simulates running in a multichannel network to solve restricted wake-up in a network with collision detection and only a single channel. We will then use to solve the hitting game in a manner that generates a contradiction.

In more detail, the two nodes, and , running in an instance of the restricted wake-up problem, will work together to simulate two nodes, and , running in a network with channels. To implement this simulation, keeps the simulated state of and keeps the state of . To maintain consistency, and use a group of rounds to simulate each round of and running .

At the beginning of each such group, and advance their simulation of just far enough to determine the channel choice and broadcast behavior of and , respectively. At this point, and must coordinate their simulation to ensure that they simulate the receive behavior of and in this round in a consistent manner. To do so, in the first round of this group, (resp. ) broadcasts if (resp. ) broadcasts in this simulated round. If exactly one node broadcasts, wake-up is solved and we are done. If neither node broadcasts, then both nodes receive and detect nothing (recall, we assume runs in a setting with a single channel and collision detection). The two nodes can, at this point, simulate and also receiving and detecting nothing, and skip ahead to the next simulated round and group. The interesting case is if both nodes broadcast. In this case, both nodes detect a collision in . To properly advance the simulation, and must decide whether or not and should also detect a collision—they should if and choose the same channel in this simulated round, but should not if and choose different channels in this simulated round.

Let be the channel chosen by and the channel chosen by in this simulated round. Let be the binary representation of , and the binary representation of . Notice, . To determine if and are equivalent, and spend one round checking each bit in and . In each such round , broadcasts if bit of is , and broadcasts if bit of is . If , then during one of these rounds exactly one node will broadcast, solving wake-up. If the nodes make it through all bits without solving wake-up, then it follows that . This knowledge allows and to conclude their current simulated round by simulating and both detecting a collision.

It is clear to see that and running on a single channel with collision detection correctly simulate and running on channels with collision detection. If solves restricted wake-up in rounds with high probability, then solves restricted wake-up in rounds, with high probability. Recall, however, that we assumed . It follows that . We now have an algorithm, , that solves restricted wake-up in a single channel with collision detection in rounds. We can therefore directly apply the simulation strategy argument from Lemma 7.2 to to prove the existence of a player that solves the restricted -hitting game in time, also with high probability. This contradicts Theorem 3.4.

We now consider the term of our lower bound. This term dominates our bound when is large (i.e., . To begin, as before, assume that some wake-up algorithm solves the problem in this setting in rounds for some . Also as before, we will confine our attention to restricted wake-up, and construct a single channel algorithm that has two nodes and simulate two nodes and running with channels. In the previous argument, the difficult case in this simulation is when and both broadcast. To simulate collision detection properly, and must decide whether or not and chose the same channel. To resolve this question, we can no longer directly apply the bit-by-bit approach used above, because if is large this would take too many rounds.

We must instead use the same type of simulation tree argument introduced in the proof of Theorem 6.2. In particular, for each round, there are a constant number of possible receive behaviors for and . We can consider a simulation tree that explores all possible such behaviors at the cost of exponentiating the runtime. If the path in the tree matching the correct receive behavior solves wake-up, then the simulation will eventually test this path after no more than guesses, where is the height. Because we assume solves the problem in rounds, the simulation strategy used by solves it in rounds. As before, we now have a solution to restricted wake-up that solves the problem in a single channel with collision detection in rounds. We obtain our contradiction with Theorem 3.4 in the same manner as with the first term. ∎

9 Lower Bound for Global Broadcast

We now turn our attention to proving a lower bound for global broadcast. The tight bound for this problem is rounds for a connected multihop network of size with diameter . The lower bound holds for expected time solutions and the matching upper bounds hold with high probability [3, 18, 6]. The term was established in [1], where it was shown to hold even for centralized algorithms, and the term was later proved by Kushilevitz and Mansour [19]. Below, we apply our new technique to reprove (and significantly simplify) the lower bound for expected time solutions to global broadcast. (We do not also reprove the term because this bound is proved using the same combinatorial result from [1] that provides the mathematical foundation for our technique. To reprove the result of [1] using [1] is needlessly circular.) Perhaps surprisingly, we show that this bound holds even if we allow multiple channels and collision detection, both of which are assumptions that break the original lower bound from [19]. Notice, this indicates a interesting split with the wake-up problem for which these assumptions improve the achievable time complexity.

Theorem 9.1.

Let be an algorithm that solves global broadcast in rounds, in expectation, in the radio network model with collision detection, channels, and a network topology with diameter . It follows that for every , .

Proof.

To account for the multihop nature of the problem, we introduce a natural generalization of the hitting games introduced in Section 3. In more detail, the -multi-hitting game, for , is a variation of -hitting game in which we run consecutive instances of the ()-hitting game, requiring the player to win instance before proceeding to instance . There are two technical points in this definition that aid the below argument: assume that the referee selects all targets at the beginning of the game, and assume that the referee reveals to the player the target for instance at the end of the round in which the player wins that instance.

It is straightforward to use the existing bounds from Section 3 to bound this generalization. Consider a particular instance of this game for a particular player . let , for , be the time required to win trial of the game, and let be the time required to win the full multi-set game. Let , for each relevant , be the expected time for to win trial , and be the expected time to win the full multi-set game. Imagine that we apply the referee target selection strategy from Theorem 3.2 (our lower bound on the expected time for -hitting) for each trial in the multi-set hitting game, using independent randomness to make each selection. For each , , it follows from Theorem 3.2 that regardless of ’s definition, . We can now lower bound by leveraging linearity of expectation:

Having bounded , we can proceed to our main argument. Fix some that solves global broadcast in rounds, in expectation, in networks of size with channels and diameter . Fix any valid values for and . We will now prove the existence of a network of diameter in which requires rounds to solve broadcast in expectation, even when provided channels and collision detection. To do so, we deploy a variant of the simulation strategy introduced in Section 4, that will be used by a multi-hitting game player to play the hitting game by simulating running in specific diameter network with channels and collision detection. In particular, our player simulates on a network consisting of layers, , where the first layers each include nodes, and the last layer includes at least node (if divides evenly, then we can add an extra node to the system to populate , without affecting the asymptotic bounds below; otherwise we add the leftover node(s) to this last layer). For the sake of construction, for each , assign unique labels from to the nodes in . Let be the target chosen by the referee for trial of the instance of the multi-hitting game being played by our player . In our construction, we connect and by including an edge from every node in with a label corresponding to a value in to every node in . Notice, the player simulating this network does not know these values in advance, and therefore does not know the full topology of the network on which it is simulating , but we will now show this does not matter as the simulation will remain consistent. Finally, the nodes within each layer are connected as a clique. (Notice that this graph satisfies the unit disk graph property—strengthening our bound even beyond what is stated in the above theorem to indicate it holds even if we restrict our attention to unit disk graphs: an easier setting than general graphs.)

The simulation begins with the player choosing some node in as the source. In each round of the simulation, let be the largest value of such that the nodes in are active (i.e., have the message). Let be the nodes in that broadcast in , if any. If , let be the nodes in that broadcast on the default channel where inactive nodes listen (i.e., channel ). The player uses as its proposal in this round of the mutli-hitting game. The key insight of this reduction is that the player only needs to simulate communication between and if exactly one node connecting to is in . When this occurs, the player will learn of this fact, because its corresponding guess in the hitting game will win this instance of the game (and once it wins instance for the first time, it learns , so it can, moving forward, successfully simulate all future communication between these two layers). The player knows the full topology of all smaller layers, so it can always correctly simulate the behavior of nodes broadcasting in these layers as well.

Collision detection and multiple channels break the original proof of [19] because their argument requires that nodes in the same layer receive silence in all rounds before they advance the message. If the active nodes in a layer had collision detection, for example, they could quickly achieve some communication using collisions, at which point the argument of [19] fails. Our argument can tolerate such intra-layer communication as it focuses only on the externally observable (i.e., broadcast) behavior of the layer.

We conclude by noting that the player using this strategy will win the multi-hitting game when the message arrives at . By assumption, this occurs in expected time of rounds By our above bound on , and the fact that corresponds to and to , it must follow that , as needed. ∎

Acknowledgments

The author acknowledges Mohsen Ghaffari for his many helpful conversations regarding the combinatorial results from [1, 15] that form the core of the hitting game lower bounds. The author also acknowledges Sebastian Daum and Fabian Kuhn who co-authored with myself the first paper to apply this general strategy to a classical radio network lower bound [8].

References

  • [1] N. Alon, A. Bar-Noy, N. Linial, and D. Peleg. A Lower Bound for Radio Broadcast. Journal of Computer and System Sciences, 43(2):290–298, 1991.
  • [2] R. Bar-Yehuda, O. Goldreigch, and A. Itai. On the Time-Complexity of Broadcast in Multi-Hop Radio Networks: An Exponential Gap between Determinism and Randomization. In Proceedings of the ACM Conference on Distributed Computing, 1987.
  • [3] R. Bar-Yehuda, O. Goldreigch, and A. Itai. On the Time-Complexity of Broadcast in Multi-Hop Radio Networks: An Exponential Gap between Determinism and Randomization. Journal of Computer and System Sciences, 45(1):104–126, 1992.
  • [4] I. Chlamtac and S. Kutten. On Broadcasting in Radio Networks–Problem Analysis and Protocol Design. IEEE Transactions on Communications, 33(12):1240–1246, 1985.
  • [5] A. E. F. Clementi, A. Monti, and R. Silvestri. Distributed Broadcast in Radio Networks of Unknown Topology. Theoretical Computer Science, 302(1-3), 2003.
  • [6] A. Czumaj and W. Rytter. Broadcasting algorithms in radio networks with unknown topology. Journal of Algorithms, 60:115–143, 2006.
  • [7] S. Daum, S. Gilbert, F. Kuhn, and C. Newport. Leader Election in Shared Spectrum Radio Networks. In Proceedings of the ACM Conference on Distributed Computing. ACM, 2012.
  • [8] S. Daum, F. Kuhn, and C. Newport. Efficient Symmetry Breaking in Multi-Channel Radio Networks. In Proceedings of the International Conference on Distributed Computing, 2012.
  • [9] S. Dolev, S. Gilbert, R. Guerraoui, F. Kuhn, and C. Newport. The Wireless Synchronization Problem. In Proceedings of the ACM Conference on Distributed Computing, 2009.
  • [10] S. Dolev, S. Gilbert, R. Guerraoui, and C. Newport. Gossiping in a Multi-Channel Radio Network. In Proceedings of the International Conference on Distributed Computing, 2007.
  • [11] S. Dolev, S. Gilbert, R. Guerraoui, and C. Newport. Secure Communication Over Radio Channels. In Proceedings of the ACM Conference on Distributed Computing, 2008.
  • [12] S. Dolev, S. Gilbert, M. Khabbazian, and C. Newport. Leveraging Channel Diversity to Gain Efficiency and Robustness for Wireless Broadcast. In Proceedings of the ACM Conference on Distributed Computing, 2011.
  • [13] M. Farach-Colton, R. J. Fernandes, and M. A. Mosteiro. Lower Bounds for Clear Transmissions in Radio Networks. In Proceedings of the Latin American Symposium on Theoretical Informatics, 2006.
  • [14] M. Ghaffari and B. Haeupler. Near Optimal Leader Election in Multi-Hop Radio Networks. 2013.
  • [15] M. Ghaffari, B. Haeupler, and M. Khabbazian. A Bound on the Throughput of Radio Networks. Pre-print, February 2013. ArXiv preprint arXiv:1302.0264.
  • [16] S. Gilbert, R. Guerraoui, D. Kowalski, and C. Newport. Interference-Resilient Information Exchange. In Proceedings of the IEEE International Conference on Computer Communications, 2009.
  • [17] T. Jurdzinski and G. Stachowiak. Probabilistic Algorithms for the Wakeup Problem in Single-Hop Radio Networks. In Proceedings of the International Symposium on Algorithms and Computation, 2002.
  • [18] D. Kowalski and A. Pelc. Broadcasting in Undirected Ad Hoc Radio Networks. Distributed Computing, 18(1):43–57, 2005.
  • [19] E. Kushilevitz and Y. Mansour. An (Dlog(N/D)) Lower Bound for Broadcast in Radio Networks. SIAM Journal on Computing, 27(3):702–712, 1998.
  • [20] T. Moscibroda and R. Wattenhofer. Maximal Independent Sets in Radio Networks. In Proceedings of the ACM Conference on Distributed Computing, 2005.
  • [21] D. Willard. Log-Logarithmic Selection Resolution Protocols in a Multiple Access Channel. SIAM Journal on Computing, 15(2):468–477, 1986.
Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
54882
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description