Noisy Beeping Networks
aa r X i v : . [ c s . D S ] S e p Noisy Beeping Networks
Yagel Ashkenazi ∗ Ran Gelles † Amir Leshem ‡ Abstract
We introduce noisy beeping networks, where nodes have limited communication capabilities,namely, they can only emit energy or sense the channel for energy. Furthermore, imperfectionsmay cause devices to malfunction with some fixed probability when sensing the channel, whichamounts to deducing a noisy received transmission. Such noisy networks have implications forultra-lightweight sensor networks and biological systems.We show how to compute tasks in a noise-resilient manner over noisy beeping networks ofarbitrary structure. In particular, we transform any algorithm that assumes a noiseless beepingnetwork (of size n ) into a noise-resilient version while incurring a multiplicative overhead ofonly O (log n ) in its round complexity, with high probability. We show that our coding is optimalfor some tasks, such as node-coloring of a clique.We further show how to simulate a large family of algorithms designed for distributed net-works in the CONGEST( B ) model over a noisy beeping network. The simulation succeeds withhigh probability and incurs an asymptotic multiplicative overhead of O ( B · ∆ · min( n, ∆ )) inthe round complexity, where ∆ is the maximal degree of the network. The overhead is tight forcertain graphs, e.g., a clique. Further, this simulation implies a constant overhead coding forconstant-degree networks. The beeping communication model [CK10] abstracts a network of lightweight wireless devices withhighly limited communication. The network consists of nodes in an arbitrary topology, whereneighbouring nodes can communicate with each other. Nodes are assumed to be able either to sendsome energy (‘beep’) or to sense an incoming transmission (‘listen’), but they cannot do both at thesame time. Furthermore, a node set to listen cannot tell how many neighbouring nodes are beepingsimultaneously—all the node can sense is the existence of energy, a single ‘beep’. Such networkshave interesting relations to biological systems, such as the fly’s nervous system [AAB +
11] and antcolonies, where ants emit pheromones as a means of communication [FHB + collision —where more than a single node is beeping at a giventime. Collision detection can be attributed to listening nodes, beeping nodes, or both. Beeping-with-collision-detection means that if a node is set to beep, it can tell whether or not one or more ∗ Faculty of Engineering, Bar-Ilan University, . Supported in part by the Israel ScienceFoundation (ISF) through grant No. 1078/17. † Faculty of Engineering, Bar-Ilan University, [email protected] . Supported in part by the Israel ScienceFoundation (ISF) through grant No. 1078/17. ‡ Faculty of Engineering, Bar-IlanUniversity, [email protected] . Supported in part by the Israel ScienceFoundation (ISF) through grant No. 1644/18.
1f its neighbours also beeped at that same round. Listening-with-collision-detection means thata node set to listen can distinguish the following events: no neighbours beep; a single neighbourbeeps; multiple neighbours beep. These models are denoted B cd L , BL cd , and B cd L cd , respectively,where the standard beeping model without any collision detection is denoted BL .In the recent decade, beeping networks have gained some interest. Previous work (e.g., [AAB + +
13, GH13, JSX16, BBDK18, DBB18, CD19b, CMRZ19]) considered all the above four vari-ants and developed various algorithms that solve specific tasks, such as nodes coloring, leader elect-ing, or finding a Maximal Independent Set (MIS).In this work we focus on a novel variant of the beeping model we call the noisy beeping model.This setting is parametrized by a noise parameter ε ∈ (0 , / BL ε . In thissetting we assume that nodes are imperfect devices: sometimes they err in sensing the carrier anddeciding whether or not a beep was transmitted. Specifically, if a node is set to listen and none ofits neighbours beep—the node still has a probability of ε to (falsely) hear a beep. Additionally, ifone or more of its neighbours beep, the node will hear nothing with probability ε . Beeping nodesbehave the same as they do in the standard BL model.The presence of noise invalidates almost all existing algorithms. As a simple example considerthe case where nodes’ goal is to form an MIS of the network’s graph (see Section 5.2 for moredetails). One way to find an MIS is the following technique: nodes randomly pick a number (sayof size Θ(log n ) bits, where n is the number of nodes in the network) and check who has the largestnumber; this party would join the MIS. Towards this goal, each node can “beep” its chosen number:the node looks at the binary representation of the number and for the next i = 1 to Θ(log n ) roundsit beeps if the i -th bit of its number is ‘1’, or otherwise it listens. A node that is set to listen andhears a beep learns that it has a neighbour with a higher number. If the node does not learn abouta neighbour with a higher number, it joins the MIS and beeps to signal this event; this node andits neighbours (who hear this beep) then quit. Repeating the above enough times would yield anMIS. It is easy to verify that a noisy beep may falsify the computation by causing two neighbouringnodes to believe they have the highest number in their neighbourhood, or by causing a node andits entire neighbourhood to quit without any of them ever joining the MIS.Before describing our results, let us discuss the noise model in more details. In the literatureof network and interactive coding (e.g. [Gal88, RS94, GKS08, GMS14, JKL15, HS16, ABE + communication channels are noisy.That is, each channel may add noise with some probability ε . We argue that this kind of noisemakes little sense in wireless networks and is too strong for arbitrary beeping networks. Indeed,consider the case of a star network, where a center node is connected to n other nodes. If weallow channel noise, then the center will constantly hear beeps: even when all the n nodes in itsneighbourhood are set to listen, the center will hear a beep with probability 1 − ε n . Moreover, thisprobability increases as more devices are present, even if they are all silent . This makes little sensein the case of wireless networks since the noise probability should not depend on the number ofdevices, unless we assume devices are faulty and falsely transmit energy with probability ε (this isalso known as sender’s noise ).Our noise model assumes receiver’s noise . That is, the receiving device is faulty, and sometimesit fails to detect energy or sometimes it detects energy even though no other node has beeped.This aligns with the fact that beeping networks commonly consist of very cheap, ultra-lightweightdevices, where the receiver is merely a simple carrier sensing device. Receiver’s noise makes sensealso in biological systems such as ant colonies, where wind or other environmental disruption may2isposition pheromones so that a nearby ant does not “hear” them, while a different ant locatedfarther away does “hear” them. We show how to perform any task that takes R rounds assuming a noiseless beeping network on a noisy beeping network, with a multiplicative overhead of O (log n + log R ) in the round complexity( n is the number of nodes) with high probability, i.e., with a polynomially small failure probability.We further argue that this overhead is tight for short protocols ( R = poly( n )) as there is a taskthat has a lower bound of Ω(log n ), compared to the noiseless task. Theorem 1.1 (main, informal) . Given any network of n nodes in arbitrary topology and given anyprotocol π of length R rounds in the beeping model (with or without collision detection), π can besimulated in a noisy beeping network (without collision detection) in R · O (log n + log R ) roundswith probability at least − − Ω(log n +log R ) . The simulation result of Theorem 1.1 leads to exciting outcomes. In particular, it gives fastalgorithms for computing coloring, MIS, and leader election over noisy beeping networks (SeeSection 5 for full details). In particular, we show how to perform coloring in O (∆ log n + log n )rounds. This follows by emulating a B cd L coloring protocol by [CMRZ19]. Surprisingly, a lowerbound of Ω( n log n ) for coloring a clique of size n in the BL model is given by [CDT17]. Thisimplies that our noise-resilient simulation is tight in this case since the BL ε model is weaker thanthe BL model.Note that our simulation allows us to take protocols in the stronger B cd L cd model and makethem noise-resilient (thus obtaining upper bounds for various tasks). On the other hand, lowerbounds for the weaker BL model carry on to the BL ε model. In the case of coloring, this disparityin the model leads to tight results. Unfortunately, for other tasks such as MIS or leader election,there is still a gap between lower and upper bounds in the noisy model (similar gaps also exist inthe noiseless beeping setting). We elaborate on this in Section 5.Our main technique is a noise-resilient collision detection method which reduces the BL ε modelto the stronger B cd L cd model. That is, by executing this method, nodes can tell with high proba-bility whether none, one, or more than one of their neighobouring nodes has beeped. The cost ofeach instance of the collision detection procedure is O (log n ) rounds, and it works with high prob-ability despite noise. This allows us to simulate any protocol designed for the B cd L cd model (orany other weaker variant) over the noisy BL ε network with high probability. For short protocols,where R = poly( n ), this suffices to show that all rounds succeed with high probability via a unionbound. However, for longer protocols, there will still be errors every poly( n ) rounds, which we canavoid with high probability by increasing the overhead of the collision detection to O (log R ).The idea behind the collision detection is very simple. Assume we wish to simulate a singleround of B cd L cd model. Consider one specific neighbourhood and call all the parties that wish tobeep in this round active ; denote the parties that listen as passive . The parties pick a randomcodeword from a code C of length Θ(log n ) that has both good distance and constant weight . Withhigh probability all the nodes in the given neighbourhood pick a unique codeword from C . Next,each active party beeps its codeword: for the next i = 1 to Θ(log n ) rounds, it beeps if and only ifthe i -th bit of its codeword is 1. See Figure 1 for a demonstration.The three cases can be distinguished due to the constant weight code. If no party is active, thenno party beeps (the “all zero” word is transmitted). If a single party beeps, then a single codeword3 v ∨ E w A demonstration of the collision detection scenario. Nodes u and v are active, and w is passive.Each of the active parties picks a random codeword from a code of weight 4, and beeps it. The channelsuperimposes the beeps. The weight of the superimposed received transmission indicate whether there wereno active parties, one active party, or whether a collision has happened. Noise may flip some of the bits acertain party hears (in this example, the 6th bit was flipped by the noise for some receiver). is beeped, and its expected weight matches the weight of the code. In the case where multipleparties beep, the expected weight of the transmission is much higher (this stems from the distanceof the code C ). Each party, active or passive, counts the number of beeps and decides between thethree cases accordingly. The noise causes each party to hear a noisy version of the transmission,however, the expected number of beeps is determined only by the above three cases. Then, ouranalysis shows that the probability that the noise corrupts enough beeps to yield a wrong outcome,is polynomially small in n , given the right choice of code parameters.Regarding lower bounds, it is not too difficult to see that collision detection over noisy networksrequires Ω(log n ) rounds to succeed with high probability. The noise has a polynomial probabilityto corrupt O (log n ) slots, which means it can invalidate any protocol of that length. Therefore, ourcollision detection protocol is optimal. Theorem 1.2 (collision detection, informal) . The task of Collision Detection over noisy beepingnetworks ( BL ε ) with polynomially small failure probability requires Θ(log n ) rounds. Our last result considers the message-passing model, i.e., the CONGEST model with messagesof size B bits. We show that any fully-utilized protocol π in the CONGEST( B ) model can besimulated over the noisy beeping network BL ε with high probability, with a multiplicative overheadof O ( B · ∆ · min( n, ∆ )) in the round complexity. Note that for networks with constant degree thisimplies a constant overhead.The simulation operates in two steps, similar to an approach by [BBDK18, ABLP89]. In thefirst step the parties perform a 2-hop coloring. After this step, every node is assigned with a “color”(a number) so that no two nodes of distance at most two share the same color. In the second stepthe coloring is used to obtain Time-Division Multiple Access (TDMA). That is, assume roundsare also colored in a sequential cyclic manner and let nodes speak only in rounds associated withtheir color. Since we use a 2-hop coloring, it is guaranteed that only a single node beeps in everyneighbourhood, so no collisions occur. When a node has the exclusive right of speak, it transmitsmessages to all its neighbours at once. This TDMA blows the number of rounds by the numberof colors times the maximal degree in the network; note that in a 2-hop coloring, the number ofcolors is bounded by min(∆ , n ). Fully-utilized protocols are ones in which in every round every party sends a message to each one of its neighbours.
4n top of the TDMA we employ a coding technique for interactive coding over noisy networksdeveloped by Rajagopalan and Schulman [RS94, ABE + π even though some of the messages arrive corrupted. This coding requires a bound on theper-message noise probability being at most O (∆ − ), which naively implies an additional blowupof O (log ∆) in order to reduce the noise to that level. We avert this blowup by taking advantageof the broadcast nature of the beeping model. Each node can concatenate the messages directedto all its neighbours into a single message (of length O ( B ∆)) that will be encoded against errors.The node beeps this single message, and all its neighbours will hear and decode it simultaneously.This method reduces the per-message noise level to 2 − Ω(∆) with only a constant overhead.The following theorem summarizes the last result.
Theorem 1.3 (Simulating message-passing protocols, informal) . Given a 2-hop coloring with c col-ors, any fully-utilized protocol π in the CONGEST(B) model can be simulated with high probabilityin the noisy beeping model BL ε incurring a multiplicative overhead of O ( B · c · ∆) in its round com-plexity. In [BBDK18], Beauquier et al. show how to simulate a CONGEST(B) protocols over BL net-works with O ( B · c ) overhead. Hence our simulation (Theorem 1.3) improves the result of [BBDK18]for some networks, in addition to being noise-resilient.Finally, we show that our simulation is tight in the case of a clique. We show a specific taskthat can be computed in k rounds in the CONGEST(1) model, but takes Ω( kn ) rounds in the BL (or BL ε ) model. Note that our simulation’s overhead for a clique is exactly Θ( n ). The beeping model was introduced by Cornejo and Kuhn [CK10], and followed by plenty workstargeting specific tasks in the four variants of the beeping model (with and without collision de-tection), for both single-hop (clique) and multi-hop networks. Among these are algorithms forfinding an MIS [AAB +
11, AAB +
13, JSX16, HL16, BBDK18, CMRZ19], (node) coloring of thenetwork [CK10, JSX16, CDT17, CMRZ19], leader-election [GH13, FSW14, DBB18, CD19b], self-stabilization and synchronization [GM15], and broadcasting a message [CD19a]. Simulating beep-ing algorithms with collision-detection ( B cd L cd , B cd L , and BL cd ) over beeping networks withoutcollision-detection BL was shown by [CMRZ19]; the simulation incurs an O (log n ) factor.In a very recent work, Efremeko, Kol, and Saxena [EKS19] consider lower bounds on single-hop, noisy beeping channel. In contrast to our work, their noise model is one where the (single)channel may convert a beep to silence and vice-versa, yet this affects all the listening parties. Theyshow that a multiplicative overhead of Ω(log n ) is necessary for coding beeping protocols againstthe above noise in the single-hop setting.Closely related to beeping networks are Radio Networks [CK85], where wireless devices cancommunicate with their neighbours by sending messages of some fixed size, however, if a collisionoccurs (more than a single sender at a given round), no message is delivered. While this modelseems very similar to the beeping model, there are significant differences that stem from the fact thatcollisions in the beeping model superimpose while in the radio-network model they destructivelyinterfere.As an example, consider the case of broadcasting a message. This task can be done in O ( D ) inthe BL model (with D being the diameter of the network), by employing “beep waves” [CD19a].5n the other hand, in the radio networks model there are graphs with diameter D = 2 that requireΩ(log n ) to broadcast a message [ABLP91]; this was later extended to a lower bound of Ω( D log nD )for a large family of networks. Similar to the case of beeping, there are variants with and withoutcollision detection. Bar-Yehuda, Goldreich, and Itai [BGI91] showed how to simulate single-hopradio network with collision detection over a multi-hop network without collision detection with O (( D + log nδ ) log ∆) overhead (1 − δ is the success probability). This simulation lead to an almostoptimal broadcast with O ( D log n + log n ). Later, Czumaj and Rytter [CR06], as well as Kowalskiand Pelc [KP05], obtained optimal broadcast algorithm with O ( D log nD + log n ) rounds.The case of noisy radio networks was introduced by Censor-Hillel et al. [CHHZ17]. They providea noise-resilient broadcast algorithm with O ( log n − ε ( D + log nδ )) that succeeds with probability 1 − δ over a radio network where each transmission may be corrupted with probability ε . Further, Censor-Hillel et al. [CHHZ18] show how to simulate radio network protocols over noisy radio networks withhigh probability, with overhead poly(log ∆ , log log n ) for non-adaptive protocols, and O (∆ log ∆)for any protocol.Another closely related field is interactive coding [Gel17], where computations are performedover noisy networks (of various kinds) in the message-passing model, and the purpose is to performthe computation in a noise-resilient manner with small overhead. Many works consider the caseof computation over noisy networks, giving coding schemes assuming random noise [RS94, GMS14,ABE + Standard Notations.
For an integer n ∈ N we denote by [ n ] the set { , . . . , n } . We use standardBachmann-Landau notations, e.g. O (log n ) and Ω(log n ), to denote the asymptotic behavior of afunction as n → ∞ . We sometimes write O ε ( · ) to remind the reader that the term may dependon ε (e.g., when ε is constant). All logarithms are taken to base 2. The Beeping Communication Model.
Throughout this work we assume a network describedby a graph G = ( V, E ) with n = | V | nodes and m = | E | edges. Each node u ∈ V is a partythat participates in the computation. Edges in E represent pairs of neighbours that can hear eachother. For a given node v , the set N v = { u | ( u, v ) ∈ E } is called the neighbourhood of v . The maximal degree of the network, ∆ = max v ∈ V |N v | , is the largest neighbourhood in the network.The diameter D of the network is the maximal length of the shortest path between any two nodes.For any n ∈ N , we denote with K n the clique of size n (also known as a single hop network of n parties; otherwise, this is a multi hop network).We will assume that the size of the network, n , is known to all nodes, however the topology ofthe network is unknown. Moreover, the nodes are assumed to be identical, that is, they run thesame algorithm and have no distinguishing identifier. However, we assume each node has its ownrandomness tape, hence, nodes actions might differ due to their different randomness.Communication over the network is performed in (synchronous) slots where at each slot eachparty may either send a pulse ( beep ) or listen . If some party v beeps at a given slot, then any ofits neighbours u ∈ N v hears a beep in that slot if u is set to listen . At the same slot v is unaware ifany of its neighbours beeped or not. Parties that are set to listen in a given slot either hear a beep denoting at least one of their neighbours beeped in that slot, or they hear silence , denoting that6one of their neighbours beeped . We stress that in the beeping model, a party cannot distinguishthe event where a single neighbour beeps from the event where multiple neighbours beep. Noisy Beeping Model.
In the noisy beeping model, BL ε , the communication goes as definedin the above paragraph, however, random noise might alter the event of hearing a beep to a silence,and vice versa. In particular, for any party v set to listen at a given slot, if the expected outcomeof the node (in the standard beeping model) in this specific slot is out ∈ { beep, silence } , then withprobability ε its outcome in the noisy model will be the other possible outcome. We assume thatthe noise crossover probability is in the range ε ∈ (0 , /
2) and assume that the noise is independentbetween different nodes and across different time-slots of the same node.
Protocols.
Nodes run a protocol —a distributed algorithm that aims to solve some distributedtask (e.g., to color the network, or to elect a leader). The protocol dictates to each node whento beep or listen, and what output to give, as a function of the current time slot, all previouscommunication, and the node’s input and randomness.All the protocols discussed in this work are randomized Monte-Carlo protocols, where thecomputation succeeds with high probability , that is, with probability at least 1 − o ( n − ). The time the protocol π takes, denoted by | π | , is its round complexity —the maximum number of slots untilthe protocol terminates (with high probability). We note that, in contrast to the above notion,some works define | π | as the expected computation times, which significantly affects the lower andupper bounds they obtain.Finally, we say that a protocol Π (in some given communication and noise model) simulates π (possibly defined over a different model), if after the completion of Π, each node outputs thetranscript it would have seen when running π assuming noiseless channels. The overhead of thesimulation (in rounds), is the ratio between the round complexity of Π and the round complexity of π .We will (usually implicitly) focus mainly on the asymptotic overhead of coding schemes that convert(any) π to a noise-resilient simulating protocol Π. The overhead of a coding scheme is the limsup ofthe above ratio for a sequence of { Π i } i simulating a sequence { π i } i as | π i | tends to infinity with i . Error Correcting Codes. A code is a mapping C : Σ rn → Σ n . We call r ∈ (0 ,
1) the rate of thecode and n ∈ N the block length of the code. The elements in the image of C are called codewords .With a slight abuse of notation, we use C to denote also the set of codewords.A binary code is one with Σ = { , } . We say that C has relative distance δ ∈ [0 , x, y ∈ C it holds that ∆( x, y ) ≥ δn , where ∆( · , · ) is the Hamming distancefunction. The weight of a codeword x ∈ C , denoted ω ( x ), is the number of non-zero indices in x ,i.e., its hamming distance from the all-zero word.It is well known that binary codes with constant rate and relative distance exist. Such codes canbe obtained, for example, by concatenating Reed-Solomon codes [RS60] with binary linear Gilbert-Varshamov codes [Gil52, Var57]. Lemma 2.1.
For every ρ ∈ (0 , there exist δ ∈ (0 , such that the following holds for sufficientlylarge n . There exists a binary linear code C : { , } rn → { , } n with rate r ≥ ρ and relativedistance δ . Furthermore, there exist polynomial-time (in n ) encoding and decoding algorithms for C ,where the decoding succeeds as long as at most n · δ/ bits of the codewords are corrupted. Collision Detection in the Noisy Beeping Model
The collision-detection task is defined as follows. Each party is either active or passive . At the endof the scheme each party needs to output whether (i) all the nodes in its neighbourhood (includingitself) are passive (ii) there exists exactly a single active node, or (iii) more than one node is active.In this section we develop a collision-detection algorithm for beeping networks, which succeedswith high probability even in the presence of noise, i.e., in the BL ε model. The basic idea is verysimple: we use a (binary) constant-weight code C where every codeword has the same numberof 1’s. Parties beep the binary representation of codewords from C (this means they beep for each1 of the codeword). Since the code is of constant weight, if exactly a single party is active, then thenumber of times it beeps is exactly the code’s weight. If the number of beeps heard is substantiallylarger than that, we can infer that more than a single party was active. If on the contrary thenumber of beeps is substantially smaller, then we infer that no party was active. Note that noisemay add or remove beeps, and cause the parties to infer a wrong outcome. However, this eventoccurs with a polynomially small probability due to our choice of parameters.In particular, we use a balanced binary code C of length n c . A balanced binary code is onewhere the Hamming weight of any codeword is n c /
2. The code C will have a constant relativedistance δ and a constant rate r . To be concrete, we can construct C by taking any binary codewith a constant relative distance and rate (Lemma 2.1) and concatenate it with a balanced code ofsize 2, e.g., 0 →
01 and 1 →
10. This concatenation makes the code balanced while preserving itsdistance. The rate decreases by a constant factor of 2.In any given instance of the collision-detection protocol, every party that wishes to beep is“active”. Any other node is “passive”. Each active node uniformly picks a codeword c ∈ C and forthe next i = 1 , , . . . , n c rounds it beeps if c i = 1, or keeps silent otherwise.As mentioned above, if no party is active, then no node beeps during the n c rounds. Any beepthat is heard by some node in this case must be associated with noise. In particular, the numberof expected beeps each node hears is εn . If there is only a single active node, each node hears n c / c , c . Since ∆( c , c ) > δn c , at least n c / δ/ n c beeps aresent, which means that at least n c (1 / δ/ − εδ ) beeps are heard by each node in expectation(including its own beeps).By choosing a large enough δ with respect to the noise probability ε , we are able to distinguishthese three cases apart. The following technical lemma lower bounds the number of beeps in a caseof a collision. That is, if two (or more) adjacent nodes try to beep different codewords c , c ∈ C ,then in at least n c / δn c / Claim 3.1.
Let C be a balanced binary code with length n c and relative distance δ . For any twodistinct codewords c , c ∈ C , the Hamming weight of c ∨ c (i.e., the bit-wise OR) is at least n c (1 + δ ) / .Proof. In a balanced code ω ( c ) = ω ( c ) = n c /
2. Consider d = c ⊕ c . It is supported on at least δn indices, which we denote I . let c ∈ { c , c } be the codeword that has minimal weight on thesupport I , and denote by c I the codeword c restricted to the indices in I . Since c and c differ oneach index in I and c is the one with minimal weight on I , we get that, ω ( c I ) ≤ | I | /
2. Thus, theweight of c ∨ c is at least the weight of c plus the zeros in c I , where the other codeword is 1. ω ( c ∨ c ) ≥ n c / | I | − | I | / ≥ n c / δn c / . Algorithm 1
Collision detection over a noisy beeping model, BL ε Assume a balanced binary code C of length n c , relative distance δ < / r (which may dependon ε ). procedure CollisionDetection (active/passive) if passive then listen for n c rounds else if active then pick a codeword c ∈ C uniformly at random. for round j ∈ { , . . . , n c } do If c j = 0, listen . If c j = 1, beep . end for end if Let χ be the number of beeps sent and heard during the above n c rounds if χ < n c then return Silence else if χ < αn c then ⊲ α is a constant to be set below return SingleSender else return
Collision end if end procedure
We now formally analyze the correctness of the above collision-detection procedure in Algo-rithm 1. Namely, we prove that except with polynomially small probability, any node outputswhether zero, one, or more than one of his neighbours were active.
Theorem 3.2.
Assume a clique of size n , where all nodes perform the CollisionDetection procedure. Further assume that n c = Ω(log n ) , δ > ε , and r = Θ(1) . Then the following threeclaims hold, except with probability exp δ,ε ( − n c ) = exp δ,ε ( − log n ) = n − Ω(1) .
1. If the number of active parties is two or more, then all parties output
Collision .2. If none of the parties is active, then all parties output
Silence .3. If the number of active parties is exactly one, then all parties output
SingleSender .Proof.
We prove the above three claims in turn.
Claim 1.
Assume parties u, w are active. Except with probability 1 / rn c = 2 − Ω(log n ) , the partieschoose different codewords from C . Using Claim 3.1 we know that, out of the n c rounds, in at least n (1 + δ ) / n c /
2. We set α = (1 + δ/ / αn c is the average of these two expectations, servedas the threshold of beeps that distinguishes the two.9hen, the probability that a given party hears less than αn c beeps when two or more nodesare active, is less than the probability to have at least ( δ/ n c noisy slots. The probability to havethat many noisy slots, is bounded by e − D ( δ k ε ) n c < e − ( δ/ − ε )22 ε n c = e − Ω δ,ε (log n ) , following Chernoff’s inequality (Lemma A.1), assuming ε < δ/
4, and noting that for x > y it holdsthat D ( x k y ) ≥ ( x − y ) x . The above is polynomially small. Hence, via a union bound on all the partic-ipating nodes, except with a polynomially-small probability, all the parties output Collision . Notethat the constant in the Ω( · ) in the exponent can be made arbitrary large by increasing the lengthof the code n c by a constant factor. Claim 2.
Since none of the parties is active, no party beeps during the protocol. Then, theprobability that a given node hears more than n c / e − D ( k ε ) n c ≤ e − (1 / − ε )22 ε n c = e − Ω ε (log n ) . Then, via a union bound, the probability that all parties output
Silence is at least 1 − n − Ω(1) . Claim 3.
Since there is a single active node, there are exactly n c / n c / n c / · (1 − ε ) + n c / · ε = n c / . A party will output
Collision if due to the noise it hears more than αn c = n c / δ/ n c / e − D ( α k / n c ≤ e − δ/ n c = e − Ω δ (log n ) . As above, by a union bound, no party outputs
Collision except with a polynomially small probability.Finally, note that a party outputs
Silence in this scenario only if the total amount of beeps ithears is below n c /
4. This requires the number of errors to be at least n c / > ( δ/ n c , hence, thisprobability is strictly smaller than the probability computed above for erring on Collision .We note that the scheme works for every neighborhood in which all parties participate inAlgorithm 1. As an immediate corollary, for any network G with an arbitrary topology, if all nodesperform Algorithm 1, then each node output Silence , SingleSender , or
Collision , according to thenumber of active nodes in its own neighbourhood , including itself.Next we claim that no collision detection over K n in BL ε succeeds with high probability in o (log n ) rounds. Lemma 3.3.
Performing Collision Detection over K n with high probability in the BL ε model takes Ω(log n ) rounds.Proof. Let t be the length of the collision detection protocol and consider a specific party u and therounds in which u listens. Note that the pattern u hears in these rounds determines its output, andthat there always exist two different patterns that cause u to output different outcomes, whether u is active or passive. 10ecall that, for any given slot, the noise “flips” what u hears with probability ε . It follows thatthe noise can cause u to output the wrong outcome with probability at least ε t . Requiring u tosucceed with high probability implies ε t < n − c for some constant c >
1, hence, t = Ω(log n ).An immediate corollary of the above lemma is that detecting collisions in arbitrary graphs in BL ε takes Ω(log n ) rounds to succeed with high probability.We note that a similar lower bound of Ω(log n ) rounds for collision detection holds also inthe BL model for arbitrary graphs of size n , e.g., for n/ + BL ε model. Note, however, that in the BL model detecting collisions over K n seems easy as the number of active parties increases, while forthe noisy BL ε it remains difficult even if all parties are active.Theorem 3.2 and Lemma 3.3 lead to the following. Corollary 3.4.
Solving the Collision Detection problem on n nodes with high probability in thenoisy beeping BL ε model has a round complexity of Θ(log n ) . Given the above collision detection scheme of Algorithm 1, one can simulate any beeping protocolthat assumes that nodes can distinguish silence from a single beep and from multiple beeps (i.e.,the B cd L cd model) over a noisy beeping network that does not provide any inherent collisiondetection, BL ε . Similarly, we can simulate any of the weaker beeping models (i.e., BL , B cd L , BL cd ) over the noisy beeping model BL ε . Our simulation succeeds except with polynomially smallprobability in nR and has a multiplicative overhead of O (log n + log R ) in the number of rounds,where R is the number of rounds in the protocol to be simulated. Theorem 4.1.
Any protocol π that takes R = | π | rounds in the B cd L cd model can be simulated inthe noisy beeping network (without collision detection) BL ε model. The simulation incurs a roundoverhead of O (log n + log R ) and succeeds with probability at least − − Ω(log n +log R ) .The same holds even if π is defined in either the B cd L , BL cd , or the BL models.Proof. The claim follows by simulating each round of the original protocol π by performing the CollisionDetection procedure (Algorithm 1). For a given simulated round, any party that wants tobeep in π is set active in CollisionDetection , or otherwise it is passive. The output of each round iswhether 0, 1, or > B cd L cd model. The output in the weaker beeping models can trivially be deducedfrom the same information.Every round of π is simulated successfully with probability 2 − Ω( n c ) and the entire R -roundcomputation succeeds except with probability bounded by R − Ω( n c ) . By setting n c = Θ(log R +log n ) we guarantee that the simulation succeeds except with polynomially small probability in n and R .The above implies that our simulation is essentially tight. When | π | = n O (1) , our overhead is O (log n ), which is tight for certain tasks, such as coloring (see Section 5.2 below), or the collision-detection task which is trivial in the B cd L cd model, and takes Θ(log n ) in BL ε (Corollary 3.4). Thequestion whether the simulation is tight also for long protocols | π | > n ω (1) remains as an openquestion. 11 emark 1. Note that the above method requires the parties to know in advance the length of theprotocol R (or a reasonable bound on it). If we assume that the parties do not know R , we can stillsimulate any protocol via interactive coding tools as presented in Section 6. This leads to overheadof O (log n ) + poly(∆) , which may be superior to the above overhead of O (log R ) in the asymptoticcase where R → ∞ . The simulation procedure of Section 4 allows us to obtain noise-resilient protocols in the beepingmodel for various tasks such as coloring, MIS, and leader election. These are obtained by simulat-ing a (standard) beeping-model protocol for the required task. One main advantage is that we cansimulate a protocol that was designed for the B cd L cd model—these usually feature reduced com-plexity due to the stronger model assumption of (inherent) collision detection. In many situations,simulating the B cd L cd protocol rather than a BL protocol yields a noise-resilient protocol with re-duced complexity.As a demonstrating example, consider the task of coloring (see below for definition). It isknown that O (∆) rounds suffice to color a network whose maximal degree is ∆ assuming (beeping)collision detection ( B cd L ), while O (∆ log n ) rounds are required if no collision detection is assumed.Our noise-resilient simulation can make use of the more efficient O (∆)-round B cd L -protocol asits noiseless underlying algorithm and shave a log n factor off the overall round complexity. Thischoice allows us achieving tight bounds for the task of coloring over the noisy beeping model.Unfortunately, the same approach doesn’t lead to tight bounds for other tasks.In the next subsection we consider the tasks of coloring, MIS, and leader election, and discussnoise-resilient protocols for these tasks. We also give information about best known lower boundsfor these tasks in the noiseless model, since it carries over to the noisy setting. In Table 1 wesummarize the protocols implied by our simulation process for the noisy-beeping model. Task BL ε Upper Bound BL ε Lower Bound
Collision Detection O (log n ) Ω(log n ) this paper,[AAB + O (∆ log n + log n ) Ω(∆ log n ) [CDT17]MIS O (log n ) Ω(log n ) [MRSZ11]Leader Election O ( D log n + log n ) Ω( D + log n ) [GH13] Table 1:
Summary of the results for the noisy-beeping model BL ε . Upper bounds hold with high probability.In the communication network, D is the diameter; ∆ is its maximal degree; n is the number of nodes. The task of coloring a graph consists of assigning each node v ∈ V with a color c ( v ) ∈ K such thatno two neighbouring nodes are assigned with the same color, i.e., ∀ ( u, v ) ∈ E, c ( v ) = c ( u ). Theset K represents the possible colors and its size is larger than the maximal degree of the graph;it is usually assumed that K = O (∆). Certain algorithms allow a larger number of colors, e.g.,12 = O (∆ + log n ), an assumption that potentially makes the round complexity smaller. Protocolsare allowed to use randomness and are required to succeed with high probability.The current state of the art in coloring protocols for the beeping model is as follows. For the B cd L model, Casteigts et al. [CMRZ19] provide a randomized algorithm with Θ(∆ + log n ) roundsand K = O (∆ + log n ) colors. If the number of colors K ≥ ∆ is known to all parties, an algorithmwith round complexity O ( K log n ) is known. In the BL model, Conejo and Kuhn. [CK10] show aprotocol with O (∆ log n ) rounds assuming knowledge of K = O (∆). Note the log n gap betweenthe BL model and B cd L model.Simulating the protocol of [CMRZ19] using Theorem 4.1 yields the following. Theorem 5.1.
There exists an efficient randomized coloring protocol in the noisy beeping modelin O (∆ log n + log n ) rounds that succeeds with high probability. The protocol employs K = O (∆ +log n ) colors and assumes the parties only know a bound on the size of the network n . A lower bound for coloring in the BL model is given by Chlebus et al. [CDT17] arguing thatany randomized coloring algorithm over G = K n requires Ω( n log n ) rounds. This lower boundcarries on to the noisy setting, and proves that our noise-resilient coloring simulation is optimal. A Maximal Independent Set (MIS) is a set of nodes I ⊆ V such that (a) no two nodes in I areneighbours, and (b) any node v ∈ V is either in I or a neighbour of some node in I . Findingan MIS is one of the fundamental tasks in distributed computing as this set “governs” the entirenetwork: every node is an immediate neighbour of some member of the MIS, while there is onlylittle redundancy in the sense that no two govern nodes are connected to each other.Algorithms for finding MIS in the beeping model started with the work of Afek et al. [AAB + O (log n ) rounds in the B cd L . The current state of the art is an algorithm with roundcomplexity of O (log n ) in the B cd L model by Jeavons et al. [JSX16] (constants later improvedby [CMRZ19]).Simulating the protocol of [CMRZ19] using Theorem 4.1 yields the following. Theorem 5.2.
There exists an efficient randomized protocol solving the MIS problem in the noisybeeping model in O (log n ) rounds and with high probability of success. As for a lower bound for the MIS task, M´etivier et al. [MRSZ11] observed that the work ofKothapalli et al. on distributed coloring [KSOS06] implies a Ω(log n ) lower bound on the complexityof finding MIS in the beeping model, through the reduction of Wattenhofer [Wat07]. Many distributed tasks begin at some designated node, a leader , whose role is to initiate or coordi-nates the progress of the required distributed task. The task of electing a leader assumes that thenodes begin with some identifier (possibly chosen at random by the node itself). At the end of theprotocol all nodes must output the same identifier of a node, elected to be the leader. This taskbasically amounts to breaking symmetry among all participant.The state of the art is a leader election algorithm in the BL beeping model by Dufoulon, Burmanand Beauquier [DBB18] which has a round complexity of O ( D + log n ) where D is the diameter ofthe network. Simulating this protocol gives 13 heorem 5.3. There exists an efficient randomized leader election protocol in the noisy beepingmodel that takes O ( D log n + log n ) rounds and succeeds with high probability. A lower bound of Ω( D + log n ) rounds for electing a leader follows from [NO02, GLS12], seealso [GH13]. BL ε networks In this section we show how to simulate a protocol designed for message-passing networks (in theCONGEST model) over noisy beeping networks. Our simulation succeeds with high probabilityand incurs a communication overhead that tends to O (∆ · min(∆ , n )) as the message-passingprotocol’s length grows to infinity. This implies a constant communication overhead for a largefamily of network topologies.Furthermore, we show that this simulation is essentially tight. That is, we show that over aclique, some tasks necessitate an overhead of Ω( n ), which matches the simulation’s upper bound. The message-passing CONGEST model.
The CONGEST( B ) model assumes a network ab-stracted as the undirected graph G = ( V, E ) with n = | V | nodes, where each ( u, v ) ∈ E is a bi-directional communication channel. Communication works in synchronized rounds where in ev-ery round, a message of B bits is potentially communicated over every channel. Commonly, B = O (log n ).A protocol in this model determines for each node v , which message it needs to send to each of itsneighbours u in every round. The message is denoted M vu and it holds that | M vu | = B . Messagesto different neighbours (in any given round) may be different. However, we will assume that inevery round exactly 2 | E | messages are being communicated in the networks; such protocols aresometimes called fully utilized . Recall that | π | denotes the number of rounds the protocol π takes.Similar to the beeping model, we assume that nodes do not have unique identifiers also in theCONGEST model. Instead, each node has a list of ports to which it can send messages, whereeach port is connected to a single neighbour. In particular, port numbers may be arbitrary and nobinding between port numbers and nodes identities may be assumed. We now show how to simulate a CONGEST(B) protocol over the noisy beeping BL ε model.The simulation idea is as follows (cf. [BBDK18, ABLP89]). We first employ a 2-hop coloringover the network. Next, each node associates the identities of its neighbours (i.e., their portnumber) with their color. The 2-hop coloring allows us to avoid collisions through time-division,allowing exactly a single “color” to beep at any given time. Every round of π can be simulated by O ( c · ∆ · B ) rounds in BL ε , where c is the maximal number of colors. Finally, we employ a multipartyinteractive coding by Rajagopalan and Schulman [RS94] (see also [ABE + Theorem 6.1 ([RS94]) . Any fully-utilized R -round protocol π in the message-passing model overany network G communicating bits can efficiently be transformed into a fully-utilized noise-resilientprotocol Π in the message-passing model that simulates π . The protocol Π communicates messagesof constant size, takes O ( R ) rounds, and succeeds with probability − n (2(∆ + 1) p ) Ω( R ) given thatany message is correctly received with probability − p . BL ε is formally described in Algorithm 2. This schemealready assumes the nodes posses a 2-hop coloring with c colors. Also note that the parties inAlgorithm 2 are assumed to know the maximal degree ∆ of G . This information (or a reasonablebound of it) can be derived from c .We note that obtaining a 2-hop coloring in BL ε can be done in O (∆ log n + log n ) roundswith c = O (∆ + log n ) colors, or in O (∆ log n ) rounds with c = ∆ + 1 colors, assuming ∆is known; both via a B cd L cd scheme by [CMRZ19] and Theorem 4.1. We assume that any suchcoloring is done once at a pre-processing phase and thus it has no effect on the overhead of theoverall simulation as | π | → ∞ . Algorithm 2
Simulation of CONGEST(B) over BL ε for node u Input: a 2-hop coloring with maximal color c ; A protocol π in CONGEST(B); ∆ the maximal degreeof the communication network G . Let C : { , } k C → { , } n C be a code with k C = Θ(∆), n C = Θ(∆), and a constant relative distance. Let π be a simulation of π in CONGEST(1). Namely, split each transmission of π into (exactly) B transmissions of π , where nodes in π communicate bits . Let Π be the encoded protocol of π given by Theorem 6.1 with message alphabet Σ where | Σ | = O (1). Set k C ≥ ∆ log | Σ | . Preprocessing Step: Node u “collects” its colorset —the colors of all its neighbours N u . Without noise This can bedone in c rounds, where each node beeps in the slot assigned with its color. Via Theorem 4.1,this can be done in a noise-resilient manner in O ( c log n ) rounds. Every node u learns the colorset of every v ∈ N u . Without noise this can be done in c rounds:we give each color c slots; each node beeps 1 for every color in [ c ] that appears in its colorset.Via Theorem 4.1, this can be done in a noise-resilient manner in O ( c log n ) rounds. Let C u be the colorset of u . Fix an (arbitrary) mapping between u neighbours’ port number andtheir color. repeat for i ∈ [ c ] in a round-robin manner do if self color is i then let ¯ M = M u,j ◦ · · · ◦ M u,j t for { j , ..., j t } = C u , be the concate-nation of the t ≤ ∆ messages M uj that u needs to send to itsneighbours in Π (pad with zeros so that | ¯ M | = ∆ | Σ | ). Orderthe M uj in ¯ M by an increasing color number, j < j < · · · Theorem 6.2. Given a 2-hop coloring with c colors and for any ε < / , any fully-utilized proto-col π in the CONGEST(B) model can be simulated with high probability in the noisy beeping model BL ε incurring a multiplicative overhead of O ( B · c · ∆) in its round complexity.Proof. We argue that Algorithm 2 satisfies the theorem’s statement.Let us begin with analyzing the round complexity of Algorithm 2 on the input π . The prepro-cessing step takes O ( c log n ) rounds, however it happens only once and does not affect the multi-plicative blowup of the simulation. The bit-version protocol, π , takes | π | = B | π | rounds and com-municates bits. Via Theorem 6.1, we know that Π takes O ( | π | ) = O ( B | π | ) rounds and uses sym-bols of constant size. The repeat loop of Algorithm 2 occurs | Π | times, where each iteration consistsof c transmissions of codewords from C . Transmitting a single codeword from C takes n c = O (∆)rounds of the simulation. Putting it all together, the statement holds.We now move on to the correctness analysis. First, note that in this analysis, we identify colorswith port numbers, i.e., a message sent to port i in π is sent to the (neighbour) node with color i in the simulation. Note that the coloring need not be contiguous nor surjective, but we assumeall nodes know their and their neighbours’ colorsets (recall that a colorset of a node u is set ofthe colors of its neighbours N u ). The preprocessing step satisfies this assumption. The mappingbetween ports and colors may be arbitrary, but this has no effect on the correctness of π , since portnumbers are arbitrary to begin with. Lemma 6.3. Every iteration of the simulation’s repeat-loop simulates a single round of Π withmessage-error probability − Ω(∆) .Proof. The coding of Theorem 6.1 produces a fully-utilize protocol in which in each round, everyparty sends one message to each of its neighbours. Hence, a simulation of a single round of Πrequires delivering a single message from u to v for any pair of neighbours ( u, v ) ∈ E . Note thattwo messages are delivered on each edge—one in each direction.The simulation of a single round takes c epochs, where in each epoch a node with a matchingcolor sends a single message ¯ M that encodes its messages to all its neighbours. Furthermore, the2-hop coloring grantees that no two nodes in the neighbourhood of any node u have the same color.Hence, every node u hears only a single sender at every given epoch, and no collisions occur. Thus,the node u gets the message ¯ M from v ∈ N u with color i during the i -th epoch of the cycle, whileno other nodes in u ’s neighbourhood beep during that same epoch. Node u can parse ¯ M andobtain the specific message M vu that v addressed to u since u knows its own color, and it knowsthe colorset of v . With this information u can infer the position of M vu in ¯ M .Nonetheless, noise may alter the communicated symbols. Encoding each message ¯ M with theerror-correcting code C that has a constant relative distance guarantees that each such message isdecoded correctly, except with probability at most 2 − Θ( n C ) = 2 − Θ(∆) .By a repetitive activation of Lemma 6.3 we get that all the | Π | rounds of Π are simulated in BL ε without any collisions, and that the message-error probability is at most 2 − Θ(∆) . Theorem 6.1then gives that π (and hence, π ) is correctly simulated, except with probability n (cid:16) − Θ(∆) (cid:17) Ω( | π | ) = 2 − Ω( B ∆ ·| π | )+log n . emark 2. We mention that the simulation of Algorithm 2 can be made efficient. To this end,one needs to employ an efficient version of the Rajagopalan-Schulman coding assuming stochasticnoise, such as the one described in [GMS14] or as described in [ABE + Here we argue that our simulation of message-passing protocols is optimal for certain graphs. To-wards this end we focus on simulating some protocol π defined as a CONGEST(1) over a clique ofsize n , K n . The lower bound stems from information properties, namely, the bit-complexity of asingle round of π . Claim 6.4. The bit communication-complexity of a fully-utilized CONGEST(1) protocol over K n is | E | = n ( n − bits. The proof is trivial: in a fully-utilized protocol in the CONGEST(1) model, 2 | E | messages of asingle bit each are sent at every round by definition.Now consider a beeping protocol over K n in the BL model. Every round can be used to transferat most a single bit (to all the parties). To see this consider the input of the i -th party, X i ∈ { , } ,and the superimposed signal transmitted by the channel to all parties Y = X ∨ · · · ∨ X n . Thereare two options: if X · · · X n = 0 n then Y = 0, and if X · · · X n = 0 n then Y = 1. This implies thatthe channel can transfer only a single bit at a time—wether or not all the parties had the input 0. Claim 6.5. Consider a single-hop beeping channel without collision-detection, BL . The capacityof the channel is at most 1 bit.Proof. Let X , . . . , X n ∈ { , } be the inputs of the parties (beep or do not beep) and let Y ∈ { , } be the signal all the parties hear. Clearly,max p ( ~X ) I ( ~X ; Y ) ≤ H ( Y ) ≤ , where H ( X ) is the entropy of X , and I ( X ; Y ) is the mutual information between X and Y , see,e.g., [CT06].Next, we want to claim that a simulation for arbitrary message-passing protocols cannot dobetter than simulating each round of the protocol in Ω( n ) rounds of the beeping network. To thisend we define the following task, that exchanges (independent) information between all parties. Definition 1. The k - message-exchange task is defined as follows: Input: party i is given k setsof n messages, M to M k , where M = M i, , . . . , M i,n , etc. Assume that each M ti,j ∈ { , } isuniformly distributed, independently of all other messages. Output: party i needs to output the k vectors ˜ M to ˜ M k , where ˜ M = M ,i , M ,i , . . . , M n,i , etc. Note that the k -message-exchange task can be solved by a trivial protocol ˜ π in CONGEST(1),where party i simply sends the messages M ti,j to party j in round t . Hence, | ˜ π | = k rounds.We now claim that any beeping protocol for the k -message-exchange will take Ω( kn ) rounds.Thus, simulating ˜ π by our simulation procedure of Theorem 6.2, yields an optimal BL / BL ε protocolfor the k -message-exchange task. This means that the simulation overhead in cliques is tight.17 heorem 6.6. For any k > , solving the k -message-exchange task over K n assuming BL networkrequires Θ( kn ) rounds.Proof. Each one of the n parties is required to learn k ( n − 1) bits from its neighbours, and all thesebits are independent of each other and of the inputs of the party who needs to learn them, hence,the information they contain is kn ( n − 1) bits altogether (even when conditioned on the party’sinput). Note that all this information must be communicated over the channel to the party thatneeds it. Since K n has effectively only a single beeping channel (single-hop), and since the beepingchannel communicates at most a single bit per round (Claim 6.5), we get that kn ( n − 1) roundsare necessary to communicate this information, and the lower bound follows.As for the upper bound, consider Theorem 6.2 and recall that a 2-hop coloring can be done withmin( n, ∆ ) colors. Indeed, if we give every node a different color, we get a 2-hop coloring of K n employing c = n colors. The theorem then suggests that ˜ π can be simulated with high probabilitywith a multiplicative overhead of O ( c ∆) = O ( n ). Since | ˜ π | = k , the upper bound follows.Note that the above lower bound is stated in the BL model and the upper bound in the BL ε model, thus the statement holds for both the BL and the BL ε models. References [AAB + 13] Y. Afek, N. Alon, Z. Bar-Joseph, A. Cornejo, B. Haeupler, and F. Kuhn. Beeping a maximalindependent set. Distributed Computing , 26(4):195–208, 2013.[AAB + 11] Y. Afek, N. Alon, O. Barad, E. Hornstein, N. Barkai, and Z. Bar-Joseph. A biological solutionto a fundamental distributed computing problem. Science , 331(6014):183–185, 2011.[ADHS19] A. Aggarwal, V. Dani, T. P. Hayes, and J. Saia. Multiparty interactive communication with pri-vate channels. Proceedings of the 2019 ACM Symposium on Principles of Distributed Computing ,PODC ’19, pp. 147–149, ACM, New York, NY, USA, 2019. ISBN 978-1-4503-6217-7.[ABLP89] N. Alon, A. Bar-Noy, N. Linial, and D. Peleg. On the complexity of radio communication. Proceedings of the Twenty-first Annual ACM Symposium on Theory of Computing , STOC ’89,pp. 274–285, 1989.[ABLP91] N. Alon, A. Bar-Noy, N. Linial, and D. Peleg. A lower bound for radio broadcast. Journal ofComputer and System Sciences , 43(2):290–298, 1991.[ABE + 16] N. Alon, M. Braverman, K. Efremenko, R. Gelles, and B. Haeupler. Reliable communicationover highly connected noisy networks. Proceedings of the 2016 ACM Symposium on Principlesof Distributed Computing , PODC ’16, pp. 165–173, 2016.[BGI91] R. Bar-Yehuda, O. Goldreich, and A. Itai. Efficient emulation of single-hop radio network withcollision detection on multi-hop radio network with no collision detection. Distributed Computing ,5(2):67–71, 1991.[BBDK18] J. Beauquier, J. Burman, F. Dufoulon, and S. Kutten. Fast beeping protocols for deterministicMIS and (∆ + 1)-coloring in sparse graphs. IEEE INFOCOM 2018 - IEEE Conference onComputer Communications , pp. 1754–1762, 2018.[BEGH17] M. Braverman, K. Efremenko, R. Gelles, and B. Haeupler. Constant-rate coding for multipartyinteractive communication is impossible. J. ACM , 65(1):4:1–4:41, 2017.[CMRZ19] A. Casteigts, Y. M´etivier, J. Robson, and A. Zemmari. Design patterns in beeping algorithms:Examples, emulation, and analysis. Information and Computation , 264:32 – 51, 2019. CGH18] K. Censor-Hillel, R. Gelles, and B. Haeupler. Making asynchronous distributed computationsrobust to channel noise. A. R. Karlin, ed., , Leibniz International Proceedings in Informatics (LIPIcs) , vol. 94, pp.50:1–50:20, 2018.[CHHZ17] K. Censor-Hillel, B. Haeupler, D. E. Hershkowitz, and G. Zuzic. Broadcasting in noisy radionetworks. Proceedings of the ACM Symposium on Principles of Distributed Computing , PODC’17, pp. 33–42, ACM, New York, NY, USA, 2017.[CHHZ18] K. Censor-Hillel, B. Haeupler, D. E. Hershkowitz, and G. Zuzic. Erasure correction for noisyradio networks. CoRR , abs/1805.04165, 2018.[CK85] I. Chlamtac and S. Kutten. On broadcasting in radio networks - problem analysis and protocoldesign. IEEE Transactions on Communications , 33(12):1240–1246, 1985.[CDT17] B. S. Chlebus, G. De Marco, and M. Talo. Naming a channel with beeps. Fundamenta Infor-maticae , 153(3):199–219, 2017.[CK10] A. Cornejo and F. Kuhn. Deploying wireless networks with beeps. N. A. Lynch and A. A.Shvartsman, eds., International Symposium on Distributed Computing (DISC 2010) , pp. 148–162, 2010.[CT06] T. M. Cover and J. A. Thomas. Elements of Information Theory (2nd edition) . John Wiley &Sons, 2006.[CD19a] A. Czumaj and P. Davies. Communicating with beeps. Journal of Parallel and DistributedComputing , 130:98–109, 2019.[CD19b] A. Czumaj and P. Davies. Leader election in multi-hop radio networks. Theoretical ComputerScience , 2019.[CR06] A. Czumaj and W. Rytter. Broadcasting algorithms in radio networks with unknown topology. Journal of Algorithms , 60(2):115–143, 2006.[DBB18] F. Dufoulon, J. Burman, and J. Beauquier. Beeping a deterministic time-optimal leader election.U. Schmid and J. Widder, eds., , Leibniz International Proceedings in Informatics (LIPIcs) , vol. 121, pp. 20:1–20:17, SchlossDagstuhl–Leibniz-Zentrum fuer Informatik, Dagstuhl, Germany, 2018.[EKS18] K. Efremenko, G. Kol, and R. Saxena. Interactive coding over the noisy broadcast channel. Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2018 ,pp. 507–520, 2018.[EKS19] K. Efremenko, G. Kol, and R. Saxena. Noisy beeps. Electronic Colloquium on ComputationalComplexity (ECCC) , 2019. TR19-111.[FHB + 16] E. Fonio, Y. Heyman, L. Boczkowski, A. Gelblum, A. Kosowski, A. Korman, and O. Feinerman.A locally-blazed ant trail achieves efficient collective navigation despite limited information. eLife ,5:e20185, 2016.[FSW14] K.-T. F¨orster, J. Seidel, and R. Wattenhofer. Deterministic leader election in multi-hop beepingnetworks. F. Kuhn, ed., International Symposium on Distributed Computing (DISC 2014) , pp.212–226, 2014.[Gal88] R. Gallager. Finding parity in a simple broadcast network. Information Theory, IEEE Transac-tions on , 34(2):176–180, 1988.[Gel17] R. Gelles. Coding for interactive communication: A survey. Foundations and Trends R (cid:13) inTheoretical Computer Science , 13(1–2):1–157, 2017. GK19] R. Gelles and Y. T. Kalai. Constant-rate interactive coding is impossible, even in constant-degreenetworks. IEEE Transactions on Information Theory , 65(6):3812–3829, 2019.[GKR19] R. Gelles, Y. T. Kalai, and G. Ramnarayan. Efficient multiparty interactive coding for inser-tions, deletions, and substitutions. Proceedings of the 2019 ACM Symposium on Principles ofDistributed Computing , PODC ’19, pp. 137–146, 2019.[GMS14] R. Gelles, A. Moitra, and A. Sahai. Efficient coding for interactive communication. InformationTheory, IEEE Transactions on , 60(3):1899–1913, 2014.[GH13] M. Ghaffari and B. Haeupler. Near optimal leader election in multi-hop radio networks. Proceed-ings of the Twenty-fourth Annual ACM-SIAM Symposium on Discrete Algorithms , SODA ’13,pp. 748–766, Society for Industrial and Applied Mathematics, Philadelphia, PA, USA, 2013.[GLS12] M. Ghaffari, N. Lynch, and S. Sastry. Leader election using loneliness detection. DistributedComputing , 25(6):427–450, 2012.[Gil52] E. N. Gilbert. A comparision of signalling alphabets. Bell System Technical Journal , 31:504–522,1952.[GKS08] N. Goyal, G. Kindler, and M. Saks. Lower bounds for the noisy broadcast problem. SIAMJournal on Computing , 37(6):1806–1841, 2008.[GM15] R. Guerraoui and A. Maurer. Byzantine fireflies. Y. Moses, ed., Distributed Computing , pp. 47–59, Springer Berlin Heidelberg, Berlin, Heidelberg, 2015.[HL16] S. Holzer and N. Lynch. Brief announcement: beeping a maximal independent set fast. , 2016.[HS16] W. M. Hoza and L. J. Schulman. The adversarial noise threshold for distributed protocols. Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms , pp.240–258, 2016.[JKL15] A. Jain, Y. T. Kalai, and A. Lewko. Interactive coding for multiparty protocols. Proceedings ofthe 6th Conference on Innovations in Theoretical Computer Science, ITCS ’15 , pp. 1–10, 2015.[JSX16] P. Jeavons, A. Scott, and L. Xu. Feedback from nature: simple randomised distributed algorithmsfor maximal independent set selection and greedy colouring. Distributed Computing , 29(5):377–393, 2016.[KSOS06] K. Kothapalli, C. Scheideler, M. Onus, and C. Schindelhauer. Distributed coloring in ˜ O ( √ log n )bit rounds. Proceedings of the 20th International Conference on Parallel and Distributed Pro-cessing , IPDPS’06, pp. 44–44, 2006.[KP05] D. R. Kowalski and A. Pelc. Broadcasting in undirected ad hoc radio networks. DistributedComputing , 18(1):43–57, 2005.[MRSZ11] Y. M´etivier, J. M. Robson, N. Saheb-Djahromi, and A. Zemmari. An optimal bit complexityrandomized distributed MIS algorithm. Distributed Computing , 23(5):331–340, 2011.[NO02] K. Nakano and S. Olariu. Uniform leader election protocols for radio networks. IEEE Transac-tions on Parallel and Distributed Systems , 13(5):516–526, 2002.[RS94] S. Rajagopalan and L. Schulman. A coding theorem for distributed computation. STOC ’94:Proceedings of the twenty-sixth annual ACM symposium on Theory of computing , pp. 790–799,1994.[RS60] I. S. Reed and G. Solomon. Polynomial codes over certain finite fields. SIAM Journal of theSociety for Industrial and Applied Mathematics , 8(2):300–304, 1960. Var57] R. R. Varshamov. Estimate of the number of signals in error correcting codes. Doklady AkadamiiNauk , 117:739–741, 1957.[Wat07] R. Wattenhofer. http://dcg.ethz.ch/lectures/fs08/distcomp/lecture/chapter4.pdf ,2007. A Appendix Lemma A.1 (Chernoff) . Let X , . . . , X n be independent identically distributed random variables on { , } with expectation E [ X i ] = µ . Then, for every δ > , Pr "X i X i > (1 + δ ) nµ < (cid:18) e δ (1 + δ ) (1+ δ ) (cid:19) nµ , Pr "X i X i < (1 − δ ) nµ < (cid:18) e − δ (1 − δ ) (1 − δ ) (cid:19) nµ . The additive form is given by, Pr "X i X i > nµ + nδ < e − D ( µ + δ k µ ) n , with D ( x k y ) = x ln xy + (1 − x ) ln (cid:16) − x − y (cid:17) ..