The Capacity of Smartphone Peer-to-Peer Networks

TL;DR

This paper analyzes the capacity limits of smartphone peer-to-peer networks across different communication demand structures, providing theoretical bounds, algorithms, and solutions for random networks and gossip protocols.

Contribution

It characterizes the optimal throughput for pairwise, broadcast, and all-to-all capacities in smartphone networks and introduces algorithms that asymptotically match these bounds.

Findings

Characterized optimal throughput for three capacity problems.

Developed algorithms matching theoretical capacity bounds.

Resolved an open question on one-shot gossip algorithms.

Abstract

We study three capacity problems in the mobile telephone model, a network abstraction that models the peer-to-peer communication capabilities implemented in most commodity smartphone operating systems. The capacity of a network expresses how much sustained throughput can be maintained for a set of communication demands, and is therefore a fundamental bound on the usefulness of a network. Because of this importance, wireless network capacity has been active area of research for the last two decades. The three capacity problems that we study differ in the structure of the communication demands. The first problem is pairwise capacity, where the demands are (source, destination) pairs. Pairwise capacity is one of the most classical definitions, as it was analyzed in the seminal paper of Gupta and Kumar on wireless network capacity. The second problem we study is broadcast capacity, in which a single source must deliver packets to all other nodes in the network. Finally, we turn our attention to all-to-all capacity, in which all nodes must deliver packets to all other nodes. In all three of these problems we characterize the optimal achievable throughput for any given network, and design algorithms which asymptotically match this performance. We also study these problems in networks generated randomly by a process introduced by Gupta and Kumar, and fully characterize their achievable throughput. Interestingly, the techniques that we develop for all-to-all capacity also allow us to design a one-shot gossip algorithm that runs within a polylogarithmic factor of optimal in every graph. This largely resolves an open question from previous work on the one-shot gossip problem in this model.

Equations

$$O((D+\sqrt{n})\text{polylog}(n)+n(d(G)+\log n))=\tilde{O}(d(G)\cdot n),$$

$$\left(\frac{de{l}_i(r)}{r}\right)\ge t,$$

$$f_i(v_{in},v_{out})$$

$$=f_i^a(v)+\sum _{u,(u_{out},v_{in})\in E_D}{f}_i(u_{out},v_{in}).$$

$$f_i(v_{in},v_{out})$$

$$=f_i^b(v)+\sum _{w,(v_{out},w_{in})\in E_D}{f}_i(v_{out},w_{in}).$$

$$2q(v)+\sum _i(a_i(v)+b_i(v))\le r_0,$$

$$f(v_{in},v_{out})=\frac{2}{r_0}(q(v)+\sum _i(a_i(v)+b_i(v)))=\frac{1}{r_0}(2q(v)+\sum _i(a_i(v)+b_i(v)))+t_{v}T\le 1+t_{v}T,$$

$$\frac{N\cdot v(f_i^{\prime })}{3N}\cdot (1-ϵ/4)=\frac{1}{3}v(f_i^{\prime })\cdot (1-ϵ/4).$$

$$T\ge \frac{1}{3}v(f^{\prime })(1-ϵ/4)\ge \frac{1}{3}v(f)(1-ϵ/4)\ge \frac{1}{3}{\tau }^{\ast }(1-ϵ).$$

$$k$$

$${\Pi }_{u\in V}(1-8a_b)$$

$$(1/4{)}^{8\alpha \log n}$$

$$\mathbf{E}(Z)\ge k/\sqrt{n}=\lfloor \frac{\sqrt{n}}{9\alpha \log n}\rfloor .$$

$$\exp \left(-\mathbf{E}(Z)/8\right)\le \exp \left(-\frac{\sqrt{n}}{72\alpha \log n}\right)$$

$$p_1{p}_2>a_b/2=\frac{\alpha \log n}{2n}.$$

$$(1-p_1{p}_2{)}^{n/2}$$

$$\mathrm{Pr}[X<(n/8)(1-r^2)]\le \mathrm{Pr}[X<\mu /2]\le \exp \left(\frac{-n(1-r^2)}{16}\right).$$

$$\mathrm{Pr}(Y_{i,j}\le (1/2)\mu )$$

$$\mathrm{Pr}(Y_{i,j}\ge 2\mu )\le \exp \left(\frac{-\mu }{3}\right)\le \exp \left(\frac{-{\beta }^2\alpha \log n}{36}\right),$$

$$T_i\ge \frac{i\cdot |C|}{|S|}=\frac{i(q|S|)}{|S|}=iq.$$

Full text

The Capacity of Smartphone Peer-to-Peer Networks

Michael Dinitz

  

Magnús M. Halldórsson

  

Calvin Newport

  

Alex Weaver

The three capacity problems that we study differ in the structure of the communication demands. The first problem is pairwise capacity, where the demands are (source, destination) pairs. Pairwise capacity is one of the most classical definitions, as it was analyzed in the seminal paper of Gupta and Kumar on wireless network capacity. The second problem we study is broadcast capacity, in which a single source must deliver packets to all other nodes in the network. Finally, we turn our attention to all-to-all capacity, in which all nodes must deliver packets to all other nodes. In all three of these problems we characterize the optimal achievable throughput for any given network, and design algorithms which asymptotically match this performance. We also study these problems in networks generated randomly by a process introduced by Gupta and Kumar, and fully characterize their achievable throughput.

Interestingly, the techniques that we develop for all-to-all capacity also allow us to design a one-shot gossip algorithm that runs within a polylogarithmic factor of optimal in every graph. This largely resolves an open question from previous work on the one-shot gossip problem in this model.

1 Introduction

In this paper, we study the classical capacity problem in the mobile telephone model: an abstraction that models the peer-to-peer communication capabilities implemented in most commodity smartphone operating systems. The capacity of a network expresses how much sustained throughput can be maintained for a set of communication demands. We focus on three variations of the problem: pairwise capacity, in which nodes are divided into pairwise packet flows, broadcast capacity, in which a single source delivers packets to the whole network, and all-to-all capacity, in which all nodes deliver packets to the whole network.

For each variation we prove limits on the achievable throughput and analyze algorithms that match (or nearly match) these bounds. We study these results in both arbitrary networks and random networks generated with the process introduced by Gupta and Kumar in their seminal paper on wireless network capacity [22]. Finally, we deploy our new techniques to largely resolve an open question from [29] regarding optimal one-shot gossip in the mobile telephone model. Below we summarize the problems we study and the results we prove, interleaving the relevant related work.

The Mobile Telephone Model.

The mobile telephone model (MTM), introduced by Ghaffari and Newport [17], modifies the well-studied telephone model of wired peer-to-peer networks (e.g., [12, 18, 4, 20, 11, 19]) to better capture the dynamics of standard smartphone peer-to-peer libraries. It is inspired, in particular, by the specific interfaces provided by Apple’s Multipeer Connectivity Framework [2].

In this model, the network is modeled as an undirected graph $G=(V,E)$, where the nodes in $V$ correspond to smartphones, and an edge $\{u,v\}\in E$ indicates the devices corresponding to $u$ and $v$ are close enough to enable a direct peer-to-peer radio link. Time proceeds in synchronous rounds. As in the original telephone model, in each round, each node can either attempt to initiate a connection (e.g., place a telephone call) with at most one of its neighbors, or wait to receive connection attempts. Unlike the original model, however, a waiting node can accept at most one incoming connection attempt. This difference is consequential, as many of the celebrated results of the original telephone model depend on the nodes’ ability to accept an unbounded number of incoming connections (see [17, 7] for more discussion).111This behavior is particularly evident in studying PUSH-PULL rumor spreading in the telephone model in a star network topology. This simple strategy performs well in this network due to the ability of the points of the star to simultaneously pull the rumor from the center. In the mobile telephone model, by contrast, any rumor spreading strategy would be fundamentally slower due to the necessity of the center to connect to the points one by one. This restriction is motivated by the reality that standard smartphone peer-to-peer libraries limit the number of concurrent connections per device to a small constant (e.g., for Multipeer this limit is $8$). Once connected, a pair of nodes can participate in a bounded amount of reliable communication (e.g., transfer a constant number of packets/rumors/tokens).

Finally, the mobile telephone model also allows each node to broadcast a small $O(\log{n})$-bit advertisement to its neighbors at the start of each round before the connection decisions are made. Most existing smartphone peer-to-peer libraries implement this scan-and-connect architecture. Notice, the mobile telephone model is harder than the original telephone model due to its connection restrictions, but also easier due to the presence of advertisements. The results is that the two settings are formally incomparable: each requires its own strategies for solving key problems.

In recent years, several standard one-shot peer-to-peer problems have been studied in the MTM, including rumor spreading [17], load balancing [8], leader election [29], and gossip [29, 30]. This paper is the first to study ongoing communication in this setting.

The Capacity Problem.

Capacity problems are parameterized with a network topology $G=(V,E)$, and a flow set $F$ made up of pairs of the form $(s,R)$ (each of which is a flow), where $s\in V$ indicates a source (sometimes called a sender), and $R\subset V$ indicates a set of destinations (receivers). For each flow $(s,R)\in F$, source $s$ is tasked with routing an infinite sequence of packets to destinations in $R$. The throughput achieved by a given destination for a particular flow is the average number of packets it receives from that flow per round in the limit, and the overall throughput is the smallest throughput over all the destinations in all flows (see Section 2.2 for formal definitions). We study three different capacity problems, each defined by the different constraints they place on the flow set $F$.

Results: Pairwise Capacity.

The pairwise capacity problem divides nodes into source and destination pairs in $F$, i.e., the given flows are between pairs of nodes rather than from a source to a general destination set. We begin with pairwise capacity as it was the primary focus of Gupta and Kumar’s seminal paper on the capacity of the protocol and physical wireless network models [22]. They argued that it provides a useful assessment of a network’s ability to handle concurrent communication.

We begin in Section 3.1 by tackling the following fundamental problem: given an arbitrary connected network topology graph $G=(V,E)$ and a flow set $F$ that divides the nodes in $V$ into sender and receiver pairs, is it possible to efficiently calculate a packet routing schedule that approximates the optimal achievable throughput? We answer this question in the affirmative by establishing a novel connection between pairwise capacity and the classical concurrent multi-commodity flow (MCF) problem. To do so, we first transform a given $G$ and $F$ into an instance of the MCF problem. We then apply an existing MCF approximation algorithm to generate a fractional flow that achieves a good approximation of the optimal flow in the network. Finally, we apply a novel rounding procedure to transform the fractional flow into a schedule. We prove that this resulting schedule provides a constant approximation of the optimal achievable throughput.

Inspired by Gupta and Kumar [22], in Section 3.2 we turn our attention to networks and flow pairings that are randomly generated using the process introduced in [22]. This process is parameterized with a network size $n\geq 2$ and communication radius $r>0$. It randomly places the $n$ nodes in a unit square and adds an edge between any pair of nodes within distance $r$. The source and destination pairs are also randomly generated.

For every given size $n$, we identify a connectivity threshold value $r_{c}(n)=\Theta(\sqrt{\log{n}/n})$, such that for any radius $r\leq r_{c}(n)$, with constant probability the network generated by the above process for $n$ and $r$ includes a source with no path to its destination—trivializing the optimal achievable throughput to [math]. We then prove that for every radius $r$ that is at least a sufficiently large constant factor larger than the threshold, there is a tight bound of $\Theta(r)$ on the optimal achievable throughput. These results fully characterize our algorithm from Section 3.1 in randomly generated networks.

Results: Broadcast Capacity.

Broadcast capacity is another natural communication problem in which a single source node is provided an infinite sequence of packets to deliver to all other nodes in the network. Solutions to this problem would be useful, for example, in a scenario where a large file is being distributed in a peer-to-peer network of smartphone users in a setting without infrastructure. In Section 4.1 we study the optimal achievable throughput for this problem in arbitrary connected graphs. To do so, we connect the scheduling of broadcast packets to existing results on graph toughness, a metric that captures a graph’s resilience to disconnection that was introduced by Chvátal [5] in the context of studying Hamiltonian paths.

In more detail, a graph $G$ has a $k$-tree if there exists a spanning tree of $G$ with maximum degree $k$. Let $d(G)$ be the smallest $k$ such that $G$ has a $k$-tree. This tree is also called a minimum degree spanning tree (MDST) of $G$. Building on a result of Win [35] that relates $k$-trees to toughness, we prove that for any given $G$ with $d(G)>3$, there exists a subset $S$ of nodes such that removing $S$ from $G$ partitions the graph into at least $(d(G)-2)|S|$ connected components.

As we formalize in Section 4.1, because each node in $S$ can connect to at most one component per round (due to the connection restrictions of the mobile telephone model), $\Omega(d(G))$ rounds are required to spread each packet to all components, implying that no schedule achieves throughput better than $O(1/d(G))$.

In Section 4.2, we prove this bound tight by exhibiting a matching algorithm. The algorithm begins by constructing a $k$-tree $T$ with $k\in\Theta(d(G))$ using existing techniques; e.g., [13, 9]. It then edge colors $T$ and uses the colors as the foundation for a TDMA schedule of length $\Theta(k)$ that allows nodes to simulate the more powerful CONGEST model in which each node can connect with every neighbor in a round. In the CONGEST model, a basic pipelined broadcast provides constant throughput. When combined with the simulation cost the achieved throughput is an asymptotically optimal $\Omega(1/d(G))$.

It is straightforward for a centralized algorithm to calculate this schedule in polynomial time, but in some cases a pre-computation of this type might be impractical, or require too high of a setup cost.222In the mobile telephone model, all nodes can learn the entire network topology in $O(n^{2})$ rounds and then run a centralized algorithm locally to determine their routing behavior. Though this setup cost is averaged out when calculating throughput in the limit, it might be desirable to minimize it in practice. With this in mind, we also provide a distributed version of this algorithm that converges to $\Omega(1/(d(G)+\log{n}))$ throughput in $\tilde{O}(D(T)d(G)+\sqrt{n})$ rounds, where $D(T)$ is the diameter of the spanning tree and $\tilde{O}$ hides polylog$(n)$ factors. The algorithm further converges to an optimal $\Omega(1/d(G))$ throughput after no more than $O(n^{2})$ total rounds—providing a trade-off between setup cost and eventual optimality.

Finally, in Section 4.3, we study the performance of our algorithm in networks generated randomly using the Gupta and Kumar process summarized above. We prove that for any communication radius sufficiently larger than the connectivity threshold, the network is likely to include an $O(1)$-tree, enabling our algorithms to converge to constant throughput. This result indicates that in evenly distributed network deployments the mobile telephone model is well-suited for high performance broadcast.

Results: All-to-All Capacity.

All-to-all capacity generalizes broadcast capacity such that now every node is provided an infinite sequence of packets it must deliver to the entire network. Solutions to this problem would be useful, for example, in a local multiplayer gaming scenario in which each player needs to keep track of the evolving status of all other players connected in a peer-to-peer network.

Clearly, $n$ separate instances of our broadcast algorithm from Section 4.2, one for each of the $n$ nodes as the broadcast source, can be interleaved with a round robin schedule to produce $\Omega(1/(n\cdot d(G)))$ throughput. In Section 5, we draw on the same graph theory connections as before to prove that this result is tight for all-to-all capacity. We then provide a less heavy-handed distributed algorithm for achieving this throughput. Instead of interleaving $n$ different broadcast instances, it executes distinct instances of all-to-all gossip, one for each packet number, using a flood-based strategy on a low degree spanning tree. Finally, we apply the random graph analysis from Section 4.3 to establish that for sufficiently large communication radius, with high probability, the randomly generated graph supports $\Omega(1/n)$-throughput, which is trivially optimal in the sense that a receiver can receive at most one new packet per round in our model.

New Results on One-Shot Gossip.

As we detail in Section 5.4, our results on all-to-all capacity imply new lower and upper bounds on one-shot gossip in the mobile telephone model. From the lower bound perspective, they imply that gossiping in graph $G$ in the mobile telephone model requires $\Omega(n\cdot d(G))$ rounds. From the upper bound perspective, when we carefully account for the costs of our routing algorithm applied to spreading only a single packet from each source, we solve the one-shot problem with high probability in the following number of rounds:

[TABLE]

where $D$ is the diameter of $G$. This algorithm is asymptotically optimal in any graph with $d(G)\in\Omega(\log{n})$ and $D\in O(n/\log^{x}{n})$ (where $x$ is the constant from the polylog in the MDST construction time), which describes a large family of graphs. For all other graphs the solution is at most a polylog factor slower than optimal. This is the first known gossip solution to be optimal, or within log factors of optimal, in all graphs, largely answering a challenge presented by [29].

Motivation.

Smartphone operating systems include increasingly robust support for opportunistic device-to-device communication through standards such as Apple’s Multipeer Connectivity Framework [2], Bluetooth LE [21], and WiFi Direct [3]. Though the original motivation for these links was to support information transfer among a small number of nearby phones, researchers are beginning to explore their potential to enable large-scale peer-to-peer networks. Recent work, for example, uses smartphone peer-to-peer networking to provide disaster response [33, 31, 25], circumvent censorship [14], extend internet access [1, 15], support local multiplayer gaming [28] and improve classroom interaction [23].

It remains largely an open question whether or not it will be possible to build large-scale network systems on top of smartphone peer-to-peer links. As originally argued by Gupta and Kumar [22], bounds for capacity problems can help resolve such questions for a given network model by establishing the limit to their ability to handle ongoing and concurrent communication. The results in this paper, as well as the novel technical tools developed to prove them, can therefore help resolve this critical question concerning this important emerging network setting.

2 Preliminaries

Here we define our model, the problem we study, and some useful mathematical tools and definitions.

2.1 Model

The mobile telephone model describes a smartphone peer-to-peer network topology as an undirected graph $G=(V,E)$. The nodes in $V$ correspond to the smartphone devices, and an edge $\{u,v\}\in E$ implies that the devices corresponding to $u$ and $v$ are within range to establish a direct peer-to-peer radio link. We use $n=|V|$ to indicate the network size.

Executions proceed in synchronous rounds labeled $1,2,...$, and we assume all nodes start during round $1$. At the beginning of each round, each node $u\in V$ selects an advertisement of size at most $O(\log{n})$ bits to broadcast to its neighbors $N(u)$ in $G$. After the advertisement broadcasts, each node $u$ can either send a connection invitation to at most one neighbor, or wait to receive invitations. A node receiving invitations can accept at most one, forming a reliable pairwise connection. It follows from these constraints that the set of connections in a given round forms a matching.

Once connected, a pair of nodes can perform a bounded amount of reliable communication. For the capacity problems studied in this paper, we assume that a pair of connected nodes can transfer at most one packet over the connection in a given round. We treat these packets as black boxes that can only be delivered in this manner (e.g., you cannot break a packet into pieces, or attempt to deliver it using advertisement bits).

We assume when running a distributed algorithm in this model that each computational process (also called a node) is provided a unique ID that can fit into its advertisement and an estimate of the network size. It is provided no other a priori information about the network topology, though any such node can easily learn its local neighborhood in a single round if all nodes advertise their ID.

2.2 Problem

In this paper we measure capacity as the achievable throughput for various combinations of packet flow and network types. We begin by providing a general definition of throughput that applies to all settings we study. This definition makes use of an object we call a flow set, which is a set $F=\{(s_{i},R_{i}):1\leq i\leq k\}$ (for some $k\geq 1$) where each $s_{i}\in V$ and $R_{i}\subseteq V$ (for node set $V$). For a given flow set $F$, each $(s_{i},R_{i})\in F$ describes a packet flow of type $i$; i.e., source $s_{i}$ is tasked with sending packets to all the destinations in set $R_{i}$. We refer to the packets from $s_{i}$ as $i$-packets.

A schedule for a given $G$ and $F$ describes a movement of packets through the flows defined by $F$. Formally, a schedule is an infinite sequence of directed matchings, $M_{1},M_{2},...$ on $G$, such that the edges in each $M_{t}$ are labelled by packets, where we define a packet as a pair $(i,j)$ with $i\in[|F|]$ and $j\in\mathbb{N}$ (i.e., $(i,j)$ is the $j$’th packet of type $i$). We require that the packet labels for a schedule satisfy the property that if edge $(u,v)$ in $M_{t}$ is labelled with packet $p=(i,j)$, then there is a path in $\bigcup_{l<t}M_{l}$ from $s_{i}$ to $u$ where all edges on the path are labelled with $p$. (It is easy to see by induction that this corresponds precisely to the intuitive notion of packets moving through a mobile telephone network). We say that a packet $p$ is received by a node $u$ in round $r$ if there is an edge $(v,u)\in M_{r}$ which is labelled $p$. A packet $(i,j)$ is delivered by round $r$ if every $x\in R_{i}$ receives it in some round $t$ with $t\leq r$.

Given a schedule $S$ for a graph $G$ and flow set $F$, we can define the throughput achieved by the slowest rate, indicated in packets per round, at which any of the flows in $F$ are satisfied in the limit. Formally:

Definition 2.1**.**

Fix a schedule $S$ defined with respect to network topology graph $G=(V,E)$ and flow set $F$. We say $S$ achieves throughput $t$ with respect to $G$ and $F$, if there exists a convergence round $r_{0}\geq 1$, such that for every $r\geq r_{0}$ and every packet type $i$:

[TABLE]

where $del_{i}(r)$ is the largest $j$ such that for every $l\leq j$, packet $(i,l)$ has been delivered by round $r$.

The above definition of throughput concerns performance in the limit, since $r_{0}$ can be arbitrarily large. In some cases, though, we might also be concerned with how quickly we achieve this limit. Our notion of convergence round allows us to quantify this, so we will provide bounds on the convergence round where relevant.

Many of the results in this paper concern algorithms that produce schedules. Our centralized algorithms take $G$ and $F$ as input and efficiently produce a compact description of an infinite schedule (i.e., an infinitely repeatable finite schedule). Our distributed algorithms assume a computational process running at each node in $G$, and for each $(s_{i},R_{i})\in F$, the source $s_{i}$ is provided an infinite sequence of packets to deliver to $R_{i}$. An execution of such a distributed algorithm might contain communication other than the flow packets provided as input; e.g., the algorithm might distributedly (in the mobile telephone model) compute a routing structure to coordinate efficient packet communication. However, a unique schedule can be extracted from each such execution by considering only communication corresponding to the flow packets. (It is here that we leverage the model assumption that the set of connections in a given round is a matching and each connection can send at most one flow packet per round.)

While our definition of throughput is for schedules and not algorithms, we will say that an algorithm achieves throughput $\alpha$ if it results in a schedule that achieves throughput $\alpha$.

In the sections that follow, we consider three different types of capacity: pairwise, broadcast, and all-to-all. Each capacity type can be formalized as a set of constraints on the allowable flow sets. For each capacity type we study achievable throughput with respect to both arbitrary and random network topology graphs. In the arbitrary case, the only constraints on the graph is that it is connected. For the random case, we must describe a process for randomly generating the graph. To do so, we use the approach introduced for this purpose by Gupta and Kumar [22]: randomly place nodes in a unit square, and then add an edge between all pairs within some fixed radius. Formally:

Definition 2.2**.**

For a given real value radius $r$, $0<r\leq 1$, and network size $n\geq 1$, the GK$(n,r)$ network generation process randomly generates a network topology $G=(V,E)$ as follows:

Let $V=\{u_{1},u_{2},...,u_{n}\}$. Place each of the $n$ nodes in $V$ uniformly at random in a unit square in the Euclidean plane. 2. 2.

Let $E=\{(u_{i},u_{j}):d(u_{i},u_{j})\leq r\}$, where $d$ is the Euclidean distance metric.

We will use the notation $G\sim GK(n,r)$ to denote that $G$ is a random graph generated by the $GK(n,r)$ process. When studying a specific definition of capacity with respect to a network randomly generated with the $GK$ process, it is necessary to specify how the flow set is generated. Because these details differ for each of the three capacity definitions, we defer their discussion to their relevant sections.

2.3 Mathematical Preliminaries

Probabilistic Preliminaries.

Several proofs will make use of the following Chernoff bound form:

Theorem 2.3**.**

Suppose $X_{1},...,X_{k}$ are independent random variables. Let $X=\sum_{i=1}^{k}X_{i}$ and $\mu=\mathbf{E}(X)$. Then,

• •

For $0<\delta<1$: $\Pr[X\leq(1-\delta)\mu)]\leq\exp{\left(\frac{-\delta^{2}\mu}{2}\right)}$

• •

For $\delta>0$: $\Pr[X\geq(1+\delta)\mu)]\leq\exp{\left(\frac{-\delta^{2}\mu}{2+\delta}\right)}$

Graph Theory Preliminaries.

We begin with some basic definitions. Fix some connected undirected graph $G=(V,E)$. We define $c(G)$ to be the number of components in $G$. In a slight abuse of notation, we define $G\setminus S$, for $S\subseteq V$, to be the graph defined when we remove from $G$ the nodes in $S$ and their adjacent edges. For a fixed integer $k>1$, we say $G$ has a $k$-tree if there exists a spanning tree in $G$ with maximum degree $k$. Finally, let $d(G)$ be the smallest $k$ such that $G$ has a $k$-tree. That is, $d(G)$ describes the maximum degree of the minimum degree spanning tree (MDST) in $G$.

Several of our capacity results build on a graph metric called toughness, introduced by Chvátal [5] in the context of studying Hamiltonian paths. It is defined as follows:

Definition 2.4**.**

An undirected graph $G=(V,E)$ has toughness $t(G)$ if $t(G)$ is the largest number $t$ such that for every $S\subseteq V$: if $c(G\setminus S)>1$, then $|S|\geq t\cdot c(G\setminus S)$.

Intuitively, to have toughness $t$ means that you need to remove $t$ nodes for every component you hope to create. Win [35] formalized this by establishing a link between toughness and $k$-trees:

Theorem 2.5** ([35]).**

For any $k\geq 3$, if $t(G)\geq\frac{1}{k-2}$, then $G$ has a $k$-tree.

Win’s theorem captures the intuition that a small toughness indicates a small number of strategic node removals can generate a large number of components. This in turn implies the existence of a spanning tree containing some high degree nodes (i.e., the nodes whose removal creates many components). We formalize this intuition with the following straightforward corollary of Win’s theorem:

Theorem 2.6**.**

Fix an undirected graph $G=(V,E)$ and degree $k\geq 3$. If $d(G)>k$, then there exists a non-empty subset of nodes $S\subset V$ such that $c(G\setminus S)>(k-2)\cdot|S|$.

Proof 2.7**.**

Since $d(G)>k$, the contrapositive of Thm. 2.5 implies that $t(G)<1/(k-2)$. By the definition of toughness, there exists an $S\subset V$ such that $|S|=t(G)\cdot c(G\setminus S)$. For this set, $c(G\setminus S)=|S|/t(G)>(k-2)|S|$.

3 Pairwise Capacity

In their seminal paper [22], Gupta and Kumar approached the question of network capacity by considering the maximum throughput achievable for a collection of disjoint pairwise flows, each consisting of a single source and destination. They studied achievable capacity in both arbitrary networks as well as random networks. In this section, we apply this approach to the mobile telephone model.

To do so, we formalize the pairwise capacity problem as the following constraint on the allowable flow sets (see Section 2.2): for every pair $(s_{i},R_{i})\in F$, it must be the case that $R_{i}=\{x\}$ (i.e., $|R|=1$), and neither $s$ nor $x$ shows up in any other pair in $F$.

3.1 Arbitrary Networks

We begin by designing algorithms that (approximate) the maximum achievable throughput in an arbitrary network. For now we will not focus on the convergence time, since our definition of capacity applies in the limit, so we describe the following as a centralized algorithm (the time required for each node to gather the full graph topology and run this algorithm locally to generate an optimal routing schedule is smoothed out over time). But as usual when considering centralized algorithms, we will care about the running time.

Formally, we define the Pairwise Capacity problem to be the optimization problem where we are given a graph $G=(V,E)$ and a pairwise flow set $F$, and are asked to output a description of an (infinite) schedule which maximizes the throughput. Our algorithm will in particular output a finite schedule which is infinitely repeated. Our approach is to establish a strong connection between multi-commodity flow and optimal schedules, and then apply existing flow solutions as a step toward generating a near optimal solution for the current network. In other words, we give an approximation algorithm for Pairwise Capacity via a reduction to a multi-commodity flow problem.

Theorem 3.1**.**

There is a (centralized) algorithm for Pairwise Capacity that achieves throughput which is a $(3/2+\epsilon)$-approximation of the optimal throughput, for any $\epsilon>0$. The convergence time is $n^{O(1)}{\epsilon^{-2}}$ and the running time is $n^{O(1)}{\epsilon^{-1}}$.

Multi-Commodity Flow.

In the maximum concurrent multi-commodity flow (MCMF) problem, we are given a triple $(D,M,cap)$, where $D=(V_{D},E_{D})$ is a digraph, $M$ is collection $M\subseteq V_{D}\times V_{D}$ of node-pairs (each representing a commodity), and $cap:E_{D}\rightarrow\mathbb{R}^{+}_{0}$ are flow capacities on the edges. Let $K=|M|$ be the number of commodities. The output is a collection $f=(f_{1},f_{2},\ldots,f_{K})$ of flows satisfying conservation and capacity constraints. Namely, for each flow $f_{i}$ and for each vertex $v\in G$ where $v\not\in\{s_{i},t_{i}\}$, the flow into a node equals the flow going out: $\sum_{e=(u,v)\in E_{D}}f_{i}(e)=\sum_{e^{\prime}=(v,w)\in E_{D}}f_{i}(e^{\prime})$. Also, the flow through each edge is upper bounded by its capacity: $f(e)=\sum_{i=1}^{K}f_{i}(e)\leq cap(e)$. Let $v(f_{i})=\sum_{w,e=(s_{i},w)\in E_{D}}f_{i}(e)$ be the value of flow $i$, or the total flow of commodity $i$ leaving its source. The value of the total flow $f$ is $v(f)=\min_{i=1}^{K}v(f_{i})$, and our goal is to maximize $v(f)$. We refer to $f$ as an MCMF flow and the constituent commodity flows as subflows.

The MCMF problem can be solved in polynomial-time by linear programming. There are also combinatorial approximation schemes known, and our version of the problem can be approximated within a $(1+\epsilon)$-factor in time $\tilde{O}((m+K)n/\epsilon^{2})$ [27].

We first show how to round an MCMF flow to use less precision while limiting the loss of value. We say that a MCMF flow is $\phi$-rounded if the flow of each commodity on each edge is an integer multiple of $1/\phi$: $\lfloor f_{i}(e)\cdot\phi\rfloor=f_{i}(e)\cdot\phi$, for all $i$, and all edges $e$. We show how to produce a rounded flow of nearly the same value.

Lemma 3.2**.**

Let $f$ be a MCMF flow and $\phi$ be a number. There is a rounding of $f$ to a $\phi$-rounded flow $f^{\prime}$ with value at least $v(f^{\prime})\geq v(f)(1-Km/\phi)$, and it can be generated in polynomial time.

Proof 3.3**.**

We focus on each subflow $f_{i}$. By standard techniques, each subflow $f_{i}$ can be decomposed into a collection of paths $P_{1},\ldots,P_{s}$ and values $\alpha_{1},\ldots,\alpha_{s}$, with $s\leq m=|E|$, such that $f_{i}(e)=\sum_{j,P_{j}\ni e}\alpha_{j}$ for each edge $e$. Let $\alpha^{\prime}_{j}=\lfloor\alpha_{j}\cdot\phi\rfloor/\phi$, for each $j$, and observe that $\alpha^{\prime}_{j}\geq\alpha_{j}-1/\phi$. We form the $\phi$-rounded flow $f^{\prime}$ by $f^{\prime}_{i}(e)=\sum_{j,P_{j}\ni e}\alpha^{\prime}_{j}$, for each edge $e$. It is easily verified that conservation and capacity constraints are satisfied. By the bound on $\alpha^{\prime}$, it follows that the value of the rounded flow is bounded from below by $v(f^{\prime}_{i})\geq v(f_{i})-s/\phi\geq v(f_{i})-m/\phi$. The value of each flow is trivially bounded from below by $v(f_{i})\geq 1/K$ (which is achieved by sending $1/K$ of each commodity flow along a single path). Thus, $v(f^{\prime}_{i})\geq(1-Km/\phi)v(f_{i})$.

We now turn to the reduction of Pairwise Capacity to MCMF. Given $G=(V,E)$ and $F$, along with a parameter $\tau$, we form the flow network ${\cal D}_{\tau}=(D,M,cap_{\tau})$ as follows. The undirected graph $G=(V,E)$ is turned into a digraph $D=(V_{D},E_{D})$ with two copies $v^{in},v^{out}$ of each vertex: $V_{D}=\{v^{in},v^{out}:v\in V\}$ and edges $E_{D}=\{(u^{out},v^{in}):uv\in E\}\cup\{(v^{in},v^{out}):v\in V\}$. The source/destination pairs carry over: $M=\{(s^{in},t^{out}):(s,\{t\})\in F\}$. Finally, capacities of edges in $E_{D}$ are $cap_{\tau}(u_{out},v_{in})=\infty$ and $cap_{\tau}(v_{in},v_{out})=1+t_{v}\cdot\tau/2$, where $t_{v}$ is the number of source/destination pairs in $F$ in which $v$ occurs. Observe that there is a one-to-one correspondence between simple paths in $G$ and in $D$ (modulo the in/out version of the start/end node).

Lemma 3.4**.**

The throughput of any schedule on $(G,F)$ is at most $\tau^{*}/2$, where $\tau^{*}$ is the largest value such that ${\cal D}_{\tau^{*}}$ has MCMF flow of value $\tau^{*}$.

Proof 3.5**.**

Let ${\cal A}$ be a mobile telephone schedule and let $T$ be its throughput. We want to show that ${\cal D}_{2T}$ has MCMF flow of value $2T$; this is sufficient to imply the lemma. We assume that packets flow along simple paths, and we achieve that by eliminating loops from paths, if necessary. By the throughput definition, there is a round $r_{0}=r^{{\cal A},T}$ such that for every round $r\geq r_{0}$ and every source/destination pair $i$, the number of $i$-packets delivered by round $r$ is at least $T\cdot r$. Let $X_{i}$ be the first $Tr_{0}$ $i$-packets delivered (necessarily by round $r_{0}$), for each type $i$, and let $X=\cup_{i}X_{i}$. For each edge $e=uv$ and pair $i$, let $q_{i}(u,v)$ be the number of packets in $X_{i}$ that passed through $e$, from $u$ to $v$. Also, for a vertex $v$, let $a_{i}(v)$ denote the number of $i$-packets originating at $v$, i.e., $a_{i}(v)=Tr_{0}$ if $v=s_{i}$ and $a_{i}(v)=0$ otherwise. Similarly, let $b_{i}(v)$ be the number of $i$-packets with $v$ as its destination. Finally, let $q_{i}(v)$ be the number of packets in $X_{i}$ that flow through $v$, but did not originate or terminate at $v$, and observe that $q_{i}(v)=\sum_{w,vw\in E}q_{i}(v,w)-a_{i}(v)=\sum_{u,uv\in E}q_{i}(u,v)-b_{i}(v)$.

Define the collection $f=(f_{1},f_{2},\ldots,f_{K})$ of functions where for each $i$, $f_{i}(u_{out},v_{in})=2q_{i}(u,v)/r_{0}$, for each edge $e=uv\in E$, and $f_{i}(v_{in},v_{out})=2(q_{i}(v)+a_{i}(v)+b_{i}(v))/r_{0}$, for each vertex in $V$. Observe that the flow $f_{i}(u_{out},v_{in})$ corresponds to twice the number of $i$-packets going from $u$ to $v$ (scaled by factor $1/r_{0}$). The flow $f_{i}(v_{in},v_{out})$ from $v_{in}$ to $v_{out}$ corresponds to the number of packets in $X_{i}$ coming into $v$ plus the number of those going out of $v$ (scaled by factor $1/r_{0}$), counting those that go through $v$ twice, but those originating or terminating at $v$ only once. We claim that $f$ is a valid MCMF flow in ${\cal D}_{2T}$ of value $2T$, which implies the lemma. Let $f_{i}^{a}(v)=2a_{i}(v)/r_{0}$ ($f_{i}^{b}(v)=2b_{i}(v)/r_{0}$) be the amount of type-$i$ flow originating (terminating) at $v$, respectively.

First, to verify flow conservation at nodes, consider a type $i$, and observe first that all packets in $X$ start at the source $s_{i}$ and end at the destination $t_{i}$.

[TABLE]

That is, the flow from each node $v_{in}$ equals the flow coming in plus the flow generated at the node (noting also that no flow terminates at the node). Similarly, the flow into $v_{out}$ equals the flow terminating at the node plus the node going out:

[TABLE]

Second, to verify capacity constraints, observe that if $q(v)=\sum_{i}q_{i}(v)$ is the number of packets that flow through node $v$, then

[TABLE]

since $v$ needs to handle flowing-through packets in two separate rounds and it can only process a single packet in a round. Thus, the flow through $(v_{in},v_{out})$ is bounded by

[TABLE]

satisfying the capacity constraints.

Finally, it follows directly from the definition of $f_{i}^{a}$ (or $f_{i}^{b}$) that the flow value is $2T$.

To prove Theorem 3.1 we need to introduce edge multicoloring.

Definition 3.6**.**

Given a graph $G=(V,E)$ and a color requirement $r(e)\in\mathbb{N}$ for each edge $e\in E$. An edge multicoloring of $(G,r)$ is a function $\pi:E\rightarrow 2^{\mathbb{N}}$ that satisfies the following: a) if $e_{1},e_{2}\in E$ are adjacent then $\pi(e_{1})\cap\pi(e_{2})=\emptyset$, and b) $|\pi(e)|\geq r(e)$, for each edge $e\in E$. The number of colors used is $|\cup_{e}\pi(e)|$, the size of the support for $\pi$.

We shall use the follow result on edge multicolorings.

Theorem 3.7** (Shannon [32]).**

Given a graph $G=(V,E)$ and a color requirement $r(e)\in\mathbb{N}$ for each edge $e\in E$, there is a polynomial-time algorithm that edge multicolors $(G,r)$ using at most $3\Delta_{r}(v)/2$ colors, where $\Delta_{r}(v)=\sum_{e\ni v}r(e)$.

We can now prove Theorem 3.1.

Proof 3.8** (Proof of Theorem 3.1).**

Let $(G,F)$ be a given Pairwise Capacity instance and let $\epsilon>0$. We perform binary search to find a value $\tau$ such that: a) An $1+\epsilon/4$-approximate MCMF algorithm produces flow $f$ of value at least $\tau(1-\epsilon/4)$ on ${\cal D}_{\tau}$, and b) The same does not hold for $\tau(1+\epsilon/4)$. The resulting flow $f=(f_{1},\ldots,f_{K})$ is then of value at least $\tau^{*}(1-\epsilon/4)/(1+\epsilon/4)\geq\tau^{*}(1-\epsilon/4)^{2}\geq\tau^{*}(1-2\epsilon/4)$. Recall that $K$ is the number of commodities, and so $K=|F|$.

Let $N=4\epsilon^{-1}Km$. We apply Lemma 3.2 to create from $f$ an $N$-rounded flow $f^{\prime}=(f^{\prime}_{1},\ldots,f^{\prime}_{K})$. By Lemma 3.2, this decreases the flow value by a factor of at most $1-Km/N=1-\epsilon/4$, i.e., $v(f^{\prime})\geq(1-\epsilon/4)v(f)\geq(1-3\epsilon/4)\tau^{*}$.

We then form an edge multicoloring instance on $G$ as follows. Each edge $e$ requires $r(e)$ colors, where $r(e)=\sum_{i}r_{i}(e)$ and $r_{i}(e)=f^{\prime}_{i}(e)\cdot N$. The weighted degree of each node $v$ is then $d_{r}(v)=\sum_{e\ni v}r(e)=N\sum_{e\ni v}f^{\prime}(e)\leq N\sum_{e\ni v}f(e)=\sum_{e=(v,u)\in E_{D}}f(e)+\sum_{e^{\prime}=(w,v)\in E_{D}}f(e)\leq 2N$, by node capacity constraints. We apply the algorithmic version of Shannon’s Theorem 3.7 to edge multicolor $(G,r)$ with at most $3N$ colors. This induces an initial schedule of length $3N$, which is then repeated as needed. Within each $3N$ rounds, $\sum_{v,e=(s_{i},v)}r_{i}(e)=N\cdot v(f^{\prime}_{i})$ $i$-packets depart from its source $s_{i}$.

Let $r_{0}=\frac{4n}{\epsilon}(3N)$. Consider the situation after round $r\geq r_{0}$. Observe that each packet is forwarded at least once during each $3N$ rounds, and thus it is delivered within $n(3N)$ rounds after it is transmitted from its source, since each path used is simple. Thus, the total number of type-$i$ packets that remain in the system in the end is at most a $\epsilon/4$-fraction of the delivered packets. Averaged over the $r$ rounds gives throughput of

[TABLE]

Hence, the throughput achieved is at least

[TABLE]

By Lemma 3.4, the throughput is then $3/2+\epsilon$-approximation of optimal.

The computation performed is dominated by the application of Shannon’s algorithm, which runs in time $O((\Delta_{r}+n)\hat{m})$, where $\hat{m}$ is the number of multiedges and $\Delta_{r}\leq 2N$ is the maximum weighted degree. Here, $\hat{m}=\sum_{e}q(e)=N\sum_{e}\sum_{i}f_{i}(e)\leq N\cdot m$. Hence, the number of computational steps is at most $O(mN^{2})=O(m^{3}K^{2}\epsilon^{-2})$. The convergence time is $r_{0}=\frac{4n}{\epsilon}(3N)=O(nmK\epsilon^{-2})$.

We note that the factor $3/2$ cannot be avoided in a reduction to flow. Consider the graph $G$ on six vertices $V=\{s_{i},t_{i}:i=0,1,2\}$ and edges $\{s_{i}t_{i^{\prime}},t_{i}t_{i^{\prime}}:i=0,1,2,i^{\prime}=i-1\bmod{3}\}$. The optimal throughput is $1/3$, with respect to $F=\{(s_{i},t_{i}):i=0,1,2\}$. This corresponds to the directed graph $D$ on nine nodes: $\{s_{i},t_{i}^{in},t_{i}^{out}:i=0,1,2\}$ and edges $\{(s_{i},t_{i^{\prime}}^{in}),(t_{i^{\prime}}^{out},t_{i}^{in}),(t_{i}^{in},t_{i}^{out}):i=0,1,2,i^{\prime}=i-1\bmod{3}\}$, and three subflows: $M=\{s_{i},t_{i}^{out}:i=0,1,2\}$. Then, ${\cal D}_{1}=(D,M,cap_{1})$, where $cap_{1}(t_{i}^{in},t_{i}^{out})=2$, has flow of value 1.

3.2 Random Networks

We now consider achievable throughput for the pairwise capacity problem in networks randomly generated with the $GK$ process defined in Section 2.2. Following the lead of the original Gupta and Kumar capacity paper [22], we assume the flow sets are also randomly generated with uniform randomness and contain all the nodes (i.e., every node shows up as a source or destination). A minor technical consequence of this definition is that it requires us to constrain our attention to even network sizes.

We begin in Section 3.2.1 by identifying a threshold value for the radius $r$ below which the randomly generated network is likely to be disconnected, trivializing the achievable throughput to [math]. In Sections 3.2.2 and 3.2.3, we then prove that for any radius value $r$ that is at least a sufficiently large constant factor greater than the threshold, with high probability in $n$, the optimal achievable throughput is in $\Theta(r)$.

3.2.1 Connectivity Threshold

When analyzing networks and flows generated by the $GK(n,r)$ network generation process, we must consider the radius parameter $r$. If $r$ is too small, then we expect a network in which some sources are disconnected from their corresponding destinations, making the best achievable throughput trivially [math]. Here we study a connectivity threshold value $r_{c}(n)=\sqrt{\frac{\alpha\log{n}}{n}}$, defined with respect to a network size $n$ and a constant fraction $\alpha$. We prove that for any $r\leq r_{c}(n)$, with probability at least $1/2$, given a network generated by $G(n,k)$ and a random pairwise flow set $F$, there exists at least one pair in $F$ that is disconnected.

Theorem 3.9**.**

There is some constant $\alpha>0$ so that for every sufficiently large even network size $n$ and radius $r\leq r_{c}(n)=\sqrt{\frac{\alpha\log{n}}{n}}$, if $G\sim GK(n,r)$ and $F$ is a random pairwise flow set, then with probability at least $1/2$ there exists $(s,\{x\})\in F$ such that $s$ is disconnected from $x$ in $G$.

At a high level, to prove this theorem we divide the unit square into a grid consisting of boxes of side length $r$, and then group these boxes into regions made up of $3\times 3$ collections of boxes. If a given region has a node $u$ in the center box, and all its other boxes are empty, then $u$ is disconnected from any node not in its own box. Our proof calculates that for a sufficiently small constant fraction $\alpha$ used in the definition of the connectivity threshold, with probability at least $1/2$, there will be a node $u$ such that $u$ is isolated as described above, and $u$ is part of a source/destination pair with another node $v$ located in a different box.

Given this setup, the main technical complexity in the proof is carefully navigating the various probabilistic dependencies. One place where this occurs is in proving the likelihood of empty regions. For sufficiently small $\alpha$ values, the expected number of non-empty regions is non-zero, but we cannot directly concentrate on this expectation due to the dependencies between emptiness events. These dependencies, however, are dispatched by leveraging the negative association between the indicator variables describing a region’s emptiness (e.g., if region $i$ is not empty, this increases the chance that region $j\neq i$ is empty). In particular, we will apply the following results concerning negative association derived in [6] based on the more general results of [10]:

Theorem 3.10** ([6, 10]).**

Consider an experiment in which weighted balls are thrown into $n$ bins according to some distribution. Fix some $a\geq 0$, and let $Y_{i}$ be the indicator random variable defined such that $Y_{i}=1$ iff there are no more than $a$ balls in bin $i$. The variables $Y_{1},Y_{2},...,Y_{n}$ are negatively associated, and therefore standard Chernoff bounds apply to their sum.

We can proceed to the main proof:

Proof 3.11** (Proof (of Theorem 3.9).).**

We consider the network generated with the threshold connectivity value $r=r_{c}(n)=\sqrt{\frac{\alpha\log{n}}{n}}$ defined in the theorem statement. Clearly if the network is disconnected for this radius it is also disconnected for smaller radii. We will show the theorem claim holds for $r_{c}(n)$ for sufficiently large $n$ and $\alpha=1/32$.

We begin by structuring the unit square into which nodes are randomly placed by the $GK$ process. First, we divide the unit square into a grid of square boxes of side length $r$ (ignore left over space). We then partition these boxes into regions made up of $3\times 3$ collections of boxes (ignore left over boxes). Finally, we label these regions $1,2,...,k$, where

[TABLE]

For each region $i$, let $c_{i}$ refer to the center box of the $3\times 3$ pattern of boxes that defines the region. We call the remaining $8$ boxes the boundary boxes for region $i$. We now calculate the probability that $GK(n,r_{c}(n))$ process places nodes such that boundary boxes of a given region $i$ are all empty.

By the definition of the $GK(n,r_{c}(n))$ process, the probability that a given node $u$ is placed in a given box is equal to the total area, $a_{b}$, of the box. Therefore, the probability $u$ is not placed in any of the $8$ boundary boxes of a given region is $1-8\cdot a_{b}$.

Pulling these pieces together with the fact that $a_{b}=r_{c}(n)^{2}=(\alpha\log{n})/n$, it follows that the probability that no node is placed in the boundary boxes of a given region $i$ is lower bounded as:

[TABLE]

where the second step follows from the well-known inequality that $(1-p)\geq(1/4)^{p}$ for any $p\leq 1/2$ (for sufficiently large $n$, it is clear that $p=8a_{b}\leq 1/2$). Because we assumed $\alpha=1/32$, we can further simplify:

[TABLE]

We now lower bound the probability that some region has empty boundary boxes. To do this, we first define the random indicator variables $Y_{1},Y_{2},...,Y_{k}$, where $Y_{i}=1$ iff the boundary boxes of region $i$ are empty. Let $Z=\sum Y_{i}$. We want to lower bound the probability that $Z>0$. By linearity of expectations,

[TABLE]

Because each node is equally likely to be placed in each region, we know from Theorem 3.10 (with $a=0$) that the variables $Y_{1},Y_{2},...,Y_{k}$, are negatively associated. Therefore the Chernoff bounds from Theorem 2.3 apply to $Z$. In particular, it follows that the probability that $Z\leq\mathbf{E}(Z)/2$ is upper bounded by:

[TABLE]

For our fixed $\alpha=1/32$, it follows that for sufficiently large $n$, two things are true: $\mathbf{E}(Z)\geq 2$ (and therefore $\mathbf{E}(Z)/2>0$), and this probability is upper bounded by $1/4$. Therefore, for sufficiently large $n$, the probability that there are no regions with empty boundary boxes is at most $1/4$.

Conditioned on the event that a given region $i$ has empty boundary boxes, we want to now bound the probability that there exists a source/destination pair $(u,\{v\})\in F$ such that $u$ is in $c_{i}$ and $v$ is not.

For a given $(u,\{v\})\in F$, this occurs with probability $p_{1}p_{2}$, where $p_{1}$ is the probability that $u$ is in $c_{i}$ and $p_{2}$ is the probability that $v$ is not in $c_{i}$. Given that $p_{1}=a_{b}$ (where $a_{b}$ is the area contained in a box) and $p_{2}$ is clearly greater than $1/2$, we crudely bound this product as

[TABLE]

So the probability that this splitting event fails to occur for all $n/2$ pairs in $F$ is upper bounded by

[TABLE]

As before, for our fixed $\alpha=1/32$, for sufficiently large $n$ this probability is upper bounded by $1/4$.

We have shown the following two bounds: (1) the probability that there are no regions with empty boundary boxes is at most $1/4$; and (2) the probability that given a region with empty boundary boxes, that there are no pairs split by the region, is also at most $1/4$. We can combine these events with a union bound to establish that the probability that at least one of these two events fails is less than $1/2$, satisfying the theorem statement.

3.2.2 Bound on Achievable Throughput

In the previous section, we identified a radius threshold $r_{c}(n)$ below which a randomly generated network is likely to disconnect a source and destination, reducing the achievable throughput to a trivial [math]. Here we study the properties of the networks generated with radius values on the other side of this threshold. In particular, we show that for any radius $r\geq r_{c}(n)$, with high probability, the randomly generated network and flow set will allow an optimal throughput bounded by $O(r)$. The intuition for this argument is that if nodes are evenly distributed in the unit square, a constant fraction of senders will have to deliver packets from one half of the square to the other, necessarily requiring many packets to flow through a small column in the center of the square, bounding the achievable throughput.

Theorem 3.12**.**

For every sufficiently large even network size $n$ and radius $r\geq r_{c}(n)$, given a network $G\sim GK(n,r)$ and a random pairwise flow set $F$, the throughput of every schedule (w.r.t. $G$ and $F$) is $O(r)$ with high probability.

To build up to this proof, we consider a series of helper lemmas. These results assume that we divide the unit square into three columns (regions of height 1) such that the center region has width $r$ and the two outer regions width $(1-r)/2$. We first show that, in expectation, there are many source/destination pairs such that all paths between the source and destination require a node in the center region to send a packet to a node in an outer region. Slightly more formally, we say that a source/destination pair $(s_{i},t_{i})$ requires a node in the center region if every path from $s_{i}$ to $t_{i}$ in $G$ contains at least one node from the center region.

For the lemmas that follow, since the theorem is trivially true for constant $r$, we assume without loss generality, that $r$ is relatively small (e.g., $r<1/2$).

Lemma 3.13**.**

For a particular source/destination pair $(s_{i},t_{i})$, the probability that $(s_{i},t_{i})$ requires a node from the center region is at least $\frac{1}{2}(1-r^{2})$.

Proof 3.14**.**

Note that $(s_{i},t_{i})$ requires a node in the center region if one of the following two disjoint events occur: $s_{i}$ and $t_{i}$ are in different outer regions, or $s_{i}$ is in the center region but $t_{i}$ is in an outer region. The first event is sufficient since the width of the center region means that there are no edges between the two outer regions, while the second event is sufficient since every $s_{i}-t_{i}$ path includes $s_{i}$.

The first event occurs with probability $2(((1-r)/2)^{2}=(1-r)^{2}/2$, and the second event occurs with probability $r(1-r)$. Thus the total probability that every $s_{i}-t_{i}$ path includes an outgoing edge from a node in the center region is at least $(1-r)^{2}/2+r(1-r)=\frac{1}{2}(1-r^{2})$.

Next we relate this probability to the number of such source/destination pairs.

Lemma 3.15**.**

With very high probability, the number of source/destination pairs in $F$ that require a node in the center region is at least $\Omega(n(1-r))$.

Proof 3.16**.**

For each source/destination pair $(s_{i},t_{i})$, let $X_{i}$ be an indicator random variable for the union of the two events analyzed in Lemma 3.13, such that $\mathbf{E}[X_{i}]\geq\frac{1}{2}(1-r^{2})$. Observe that, clearly, these events are independent and let $X=\sum_{i=1}^{n/2}X_{i}$ denote the total number of pairs where $X_{i}=1$. By linearity of expectations, we know that $\mathbf{E}[X]\geq(n/4)(1-r^{2})$. So the Chernoff bound from Theorem 2.3 implies that

[TABLE]

Therefore, with very high probability, the number of source/destination pairs that meet the conditions of Lemma 3.13 is $\Omega((n/8)(1-r^{2}))=\Omega(n(1-r^{2}))=\Omega(n(1-r))$ for $r<1/2$. Furthermore, since by Lemma 3.13 each of these source/destination pairs requires a node in the center region, the number of pairs as described by the lemma statement is also $\Omega(n(1-r))$.

Now that we have successfully lower bounded the number of source/destination pairs that require a node in the center region to send a packet to a node in an outer region, we need an estimate for how many nodes in the center region exist to send these packets at one time.

Lemma 3.17**.**

With high probability, there are $O(rn)$ nodes in the center region.

Proof 3.18**.**

Let $Y$ be a random variable denoting the number of vertices in the center region. Each node is put into the center region independently with probability $r$, and thus $\mathbf{E}[Y]=rn$. Since the placement of each node is independent, we can use the Chernoff bound from Theorem 2.3 to get that $\Pr[Y\geq 2rn]\leq\exp{(-rn/3)}$. Thus with very high probability, there are at most $2rn=O(rn)$ nodes in the center region.

We now have everything we need to upper bound the pairwise throughput.

Proof 3.19** (Proof (of Theorem 3.12).).**

From Lemma 3.15 we know that with high probability that there are $\Omega(n(1-r))$ source/destination pairs that require one of the $O(rn)$ nodes in the center region. Since each of these nodes can send at most one packet per round by the constraints of the mobile telephone model, by round $\Psi$ at most $O(\Psi\cdot rn)$ packets can be delivered. Therefore, on average for each source/destination pair $(s_{i},t_{i})$, the number of packets delivered by round $\Psi$ is $O(\Psi\cdot rn)/\Omega(n(1-r))=O(\Psi r)$. Thus in any schedule there must exist some $(s_{i},t_{i})$ so that at round $\Psi$, only $O(\Psi r)$ packets from $s_{i}$ have been delivered to $t_{i}$, and hence the throughput is only $O(r)$.

3.2.3 Tightness of the Throughput Bound

In Section 3.2.2, we proved an upper bound of $O(r)$ on the achievable throughput in a network generated by $GK(n,r)$, for $r\geq r_{c}(n)$, and random pairwise flows. Here we show this result is tight by showing how to produce a schedule that achieves throughput in $\Omega(r)$ with respect to a random $G$ and $F$. Formally:

Theorem 3.20**.**

There exists a constant $\beta>1$ such that, for any sufficiently large network size $n\geq 2$ and radius $r\geq\beta r_{c}(n)$, if $G\sim GK(n,r)$ and $F$ is a random pairwise flow set, then with high probability in $n$ there exists a schedule that achieves throughput in $\Omega(r)$ with respect to $G$ and $F$.

At a high level, our argument divides the unit square into box of side length $\approx r$. We prove that with high probability, both nodes and pairwise demands are evenly distributed among the boxes. This allows a schedule that efficiently moves many packets in parallel up and down columns to the row of their destination, and then moves these packets left and right along the rows to reach their destination. The time required for a given packet to make it to its destination is bounded by the column and row length of $\approx 1/r$, yielding an average throughput in $\Theta(r)$. The core technical complexity of this argument is the careful manner in which packets are moved onto and off a set of parallel paths while avoiding more than a small amount of congestion at any point in their routing.

Our approach is to isolate the probabilistic elements of the proof. To do so, we need some preliminary definitions to help structure our argument. We begin by fixing a canonical way of covering the unit square into which the $GK$ process places nodes with a grid.

Definition 3.21**.**

Fix some radius $r,0<r\leq 1$. An $r$-grid is a partition of the unit square into boxes of side length $\hat{r}$, where $\hat{r}$ is the largest value such that: (a) $\hat{r}\leq r$; (b) $k=1/\hat{r}$ is a whole number; and (c) the distance between any two locations in boxes that share a side is at most $r$ (i.e., $\hat{r}\leq r/\sqrt{5}$). We call $\hat{r}$ the grid radius and $k$ the grid size of the $r$-grid.

We next define some useful properties of node placements and flow set definitions with respect to this grid structure.

Definition 3.22**.**

Fix some even network size $n\geq 2$, and radius $r>0$. Let $G\sim GK(n,r)$, and let $F$ be a random pairwise flow set. Consider the $r$-grid with grid size $k$. For each $i,j\in[1,k]$, we define the following two random variables:

• •

$X_{i,j}$* is the number of nodes placed in the grid box in row $i$ and column $j$.*

• •

$Y_{i,j}$* is the number of pairs $(s_{\ell},\{t_{\ell}\})\in F$ where $s_{\ell}$ is placed in column $j$ and $t_{\ell}$ is placed in row $i$.*

We say $G$ and $F$ are good if $(1/4)\cdot n/k^{2}\leq X_{i,j},Y_{i,j}\leq 4\cdot n/k^{2}$.

Now we show that $G$ and $F$ are good with high probability as long as the radius is a sufficiently large constant factor larger than the connectivity threshold $r_{c}(n)$ (see Section 3.2.1).

Lemma 3.23**.**

There exists a constant $\beta>1$ such that, for any sufficiently large network size $n\geq 2$ and radius $r\geq\beta r_{c}(n)$, if $G\sim GK(n,r)$ and $F$ is a random pairwise flow set, then $G$ and $F$ are good with high probability in $n$.

Proof 3.24**.**

Suppose that we first pair up the nodes (each pair consisting of a source and a destination) and then randomly place the nodes in the unit square. Clearly this is equivalent to first running $GK$ and then choosing a random pairwise flow set, so we analyze this modified process here. To do so, first fix an $n$ and $r\geq\beta r_{c}(n)$ as specified in the lemma statement, where we will bound the specific constant $\beta$ we need later in this proof. Consider the $r$-grid with grid radius $\hat{r}$ and grid size $k$. Finally, fix a row $i$ and column $j$ from this grid.

We begin by bounding $Y_{i,j}$. Let $F$ be our predefined set of pairwise flows (i.e., pairs of sources and destinations). Label these pairs arbitrarily, $1,2,...,(n/2)$. We define $Y_{i,j}=\sum_{\ell=1}^{n/2}Z_{\ell}$, where $Z_{\ell}$ is the random indicator variable that equals $1$ iff the source for pair $\ell$ in $F$ is placed in grid column $j$ and the destination for pair $\ell$ is placed in grid row $i$.

Each grid row and column takes up a $1/k$ fraction of the union square. It follows that $\Pr(Z_{\ell}=1)=(1/k)^{2}$, and therefore, by linearity of expectation: $\mathbf{E}(Y_{i,j})=\sum_{\ell=1}^{n/2}\mathbf{E}(Z_{\ell})=n/(2k^{2})$. Because $Y_{i,j}$ is the sum of independent indicator random variables, we can apply our Chernoff forms from Theorem 2.3 to concentrate on this expectation. In particular, if we use parameters $\mu=\mathbf{E}(Y_{i,j})=n/(2k^{2})$ and $\delta=1/2$, and also apply the loose bound $\hat{r}\geq r/6$, we get the following from the lower bound form of Theorem 2.3:

[TABLE]

Similarly, if we instead set $\delta=1$, we get the following from the upper bound form:

[TABLE]

where the last step follows from adapting the lower bound derivation above to replace the $8$ with a $3$ in the initial step. For any constant $c\geq 1$, there is a sufficiently large constant value for $\beta$, defined independently of $n$, such that both these probabilities are less than $n^{-c}$ (e.g., $\beta\geq\sqrt{(96c)/\alpha}$). Call this value $\beta(c)$.

We now turn our attention to $X_{i,j}$. Our process for generating $G=(V,E)$ and $F$ places each node with uniform randomness in the unit square. With this in mind, for each $u\in V$, let $Z^{\prime}_{u}$ be the independent random indicator variable that equals $1$ iff node $u$ is placed in grid box $(i,j)$. We can then define $X_{i,j}=\sum_{u\in V}Z^{\prime}_{u}$. Because each grid box has area $1/k^{2}$, it follows that $\Pr(Z^{\prime}_{u}=1)=1/k^{2}$, and therefore, by linearity of expectation, $\mathbf{E}(X_{i,j})=n/k^{2}$. Because $\mathbf{E}(X_{i,j})=2\mathbf{E}(Y_{i.j})$, and $X_{i,j}$ is also the sum of independent random indicators, the same concentration bounds derived above for $Y_{i,j}$ still apply to $X_{i,j}$, albeit now more loosely than before (the slightly larger expectation intensifies the concentration).

To conclude the proof, assume our goal is to end up with a failure probability less than $n^{-c}$, for some constant $c\geq 1$. We show that $\beta(c+3)$ is a sufficiently large definition of constant $\beta$ to satisfy the lemma statement for this bound.

To do so, we first note that Definition 3.22 requires that every $X_{i,j}$ and $Y_{i,j}$ be within the range $[\mu/4,4\mu]$, for $\mu=n/k^{2}$. Applying our above bounds with constant $\beta(c+3)$, it follows that any given $X_{i,j}$ or $Y_{i,j}$ is within this range with probability at least $1-n^{-(c+3)}$. By a union bound, the probability this fails to hold for any $X$ is less than $1/n^{c+2}$, and the same holds for any $Y$. A final union bound provides that the probability either the $X$ or $Y$ condition fails is itself still less than $1/n^{c}$, as required.

Our final result of this section proves that if $G$ and $F$ are good, then there exists a schedule that achieves throughput in $\Omega(r)$. To do, we describe an algorithmic process for generating this schedule. This result is existential because the process makes use of the locations in the unit square used by $GK$ to generate $G$.

Lemma 3.25**.**

Let $G\sim GK(n,r)$ for some even network size $n\geq 2$ and radius $r>0$, and let $F$ be a random pairwise flow set. If $G$ and $F$ are good then there exists a schedule that achieves throughput in $\Omega(r)$ with respect to $G$ and $F$.

Proof 3.26**.**

Fix some $n$, $r$, $G=(V,E)$, and $F$ as specified by the lemma statement. Assume $G$ and $F$ are good. We now construct a schedule for $G$ and $F$ that makes use of the location that the $GK(n,r)$ process placed each node in the unit square.

In more detail, cover the unit square with an $r$-grid of grid radius $\hat{r}$ and grid size $k$. By the definition of good, each grid box $(i,j)$ (i.e., the box in row $i$ and column $j$ of the $r$-grid) contains at least $n_{low}=(1/4)n/k^{2}$ nodes and no more than $n_{high}=4n/k^{2}$ nodes. In each such $(i,j)$, choose $n_{low}$ nodes to be the core nodes for this box. Label them arbitrarily, $1,2,...,n_{low}$. Routing between adjacent boxes in our strategy will always take place on links between core nodes in these boxes with the same label.

We now describe a multi-phase process that routes one packet from each source to each destination in $O(k)$ rounds. This process can then be repeated for each new packet, waiting for the current packet to be completely delivered for all nodes before moving on to the next. This will result in an overall throughput in $\Omega(1/k)=\Omega(r)$. To simplify discussion, we will use the following notions of directionality: up means moving from larger to smaller row numbers, down means smaller to larger rows, left means larger to smaller columns, and right means smaller to larger columns.

The first phase is dedicated to routing packets up their current column in the grid to arrive at the destination row containing the packet’s destination. This phase only applies to packets that start below their destination row (i.e., in a larger number row). To do so, we first put aside $15$ rounds for non-core source nodes to send their packet to a core node in their grid box. We assign non-core nodes to core nodes evenly. Because there are $n_{low}$ core nodes, and at most $16n_{low}$ total nodes (leaving at most $15n_{low}$ non-core sources), this load balancing ensures that $15$ rounds are sufficient, and no core node has been assigned more then $16$ total packets (including its own).

We now route packets up the grid columns. To do so, the core node with label $\ell$ in grid box $(i,j)$ (for $i>1$) forms a link with the core node with label $\ell$ in $((i-1),j)$. This forms a pipeline of nodes of the same label in each column.333We assume here the variation of the mobile telephone model in which you can have one outgoing and one incoming link per round. If we instead assume the slightly more restrictive version where there is at most one total link then we can easily simulate the former model at the cost of a factor of $2$ more rounds. Notice that $16$ rounds is enough for the core nodes in a given grid box, to route all of their packets up to their corresponding core nodes in the grid box above. Therefore, $16k$ rounds is enough to ensure every packet that needs to move up to get to its destination row has successfully arrived at its destination row.

There is, however, a subtle complication that must be addressed. Assume we are unlucky and that many (say, a super-constant number of) packets in a given column have destination row $i$, and that they all happen to be assigned to core nodes with the same label $\ell$. When the up routing phase as described above completes, these packets will have all successfully arrived at row $i$, but they will only be known by core node $\ell$ in this box. Before we can successfully route them left or right in subsequent phases, we would then have to spend too much time spreading them out from core node $\ell$.

To avoid this complication, we add a balancing step to the up routing. As stated above, our routing takes place in groups of $16$ rounds, where in each such group, each box moves its current packets up to the box above. We now introduce a rebalancing procedure in between each of these groups. In more detail, fix any grid box $(i,j)$ and core node $\ell$. If node $\ell$ has received more than $16$ packets with destination row $i$, then $\ell$ will evenly distributed these extra packets among other core nodes in its grid box, one by one, until its count is back down to $16$.

We know this rebalancing is always possible as the definition of good provides that $Y_{i,j}\leq 16n_{low}$, so there is always room to rebalance packets to keep each of the $n_{low}$ core nodes count at $16$ or below. Because at most $16$ new packets can arrive at a given core node in each group of routing rounds, an additional $16$ rounds is always sufficient to complete this rebalancing.

Combined, it follows that $O(k)$ rounds are sufficient not only to complete the up routing, but to also ensure that packets are evenly distributed among core nodes at their destination row. We follow this up routing phase with a symmetric down routing phase, that routes packets that start above their destination row down to their destination row. This requires an additional $O(k)$ rounds. When these two phases are done, each packet is assigned to a core node in its destination row, and no core node is assigned more than a constant number of packets.

To complete the routing, we now turn our attention to moving packets across columns. We being by using the above procedure to move packets to the left. That is, this phase applies to packets that are in a column to the right of their destination column.

For this phase, we replace the rebalancing steps with delivery steps. In more detail, when a packet $p$ arrives at a core node in the grid box containing its destination, the core node will deliver it to its destination during the next delivery step. Because each core node can receive at most $16$ new packets per routing group, $16$ rounds is sufficient for the delivery step.

To conclude the routing, after routing packets right to left, we execute a final phase that moves packet left to right. The total time required to complete this routing of a single packet over all pairwise flows is the time required by the four routing phases. Because each phase requires $\Theta(k)$ rounds, the total time is $\Theta(k)$.

To conclude this section, we note that the correctness of Theorem 3.12 is a direct corollary of Lemmas 3.23 and 3.25.

4 Broadcast Capacity

The broadcast capacity problem assumes a designated source node has an infinite sequence of packets to spread to the entire network, implementing a one-to-all packet stream. Formally, this version of the capacity problem constrains the flow set to only contain a single pair of the form $\{s,V\setminus\{s\}\}$, for some source $s\in V$. As we will show, the achievable throughput for this problem in a given network graph $G$ is strongly related to $d(G)$, the maximum degree of the minimum degree spanning tree (MDST) for $G$ (see Section 2.3). We begin in Section 4.1 by proving that in an arbitrary graph $G$, the achievable throughput is at most $O(1/d(G))$. This result leverages the classical connection between graph toughness and spanning trees discussed and extended in Section 2.3. We then prove in Section 4.2 that this bound is nearly tight by describing a distributed algorithm that achieves throughput in $\Omega(1/d(G))$.

We conclude in Section 4.3 by proving that with high probability, our algorithm from Section 4.2 will achieve constant throughput in a network generated randomly by the $GK$ process. This indicates that the mobile telephone model is well-suited for this variation of the capacity problem.

4.1 A Bound on Achievable Throughput for Arbitrary Networks

We establish that the maximum degree of an MDST in $G$—that is, $d(G)$—bounds the achievable throughput, with larger values of $d(G)$ leading to lower throughput. The bound is primarily graph theoretic: arguing a fundamental limit on the rate at which packets can spread through a given topology.

The intuition for this result is the following. Let $T$ be an MDST in $G$ of degree $d(G)$. Theorem 2.6 tells us that there exists a set $S$ of bridge nodes such that removing $S$ partitions the graphs into a set $C$ of at least $(d(G)-2)\cdot|S|$ components. To spread a given token to all nodes requires that it spread to all components in $C$.

Because removing $S$ creates these partitions, this spreading must pass through nodes in $S$ to conclude. Because connections are pairwise, however, each bridge node can serve at most one component per round. Since $|C|\geq(d(G)-2)\cdot|S|$, it will thus require $\Omega(d(G))$ rounds to complete such a spread. Hence the latency of the information spreading is lower bounded by the maximum degree of the MDST. Moreover, this process does not benefit from pipelining: broadcasting $k$ packets will take $\Omega(k\cdot d(G))$ rounds. This argument is formalized in the next theorem.

Theorem 4.1**.**

Fix a connected network graph $G=(V,E)$ and broadcast flow set $F$ with source $s$. Then every schedule achieves throughput at most $O(1/d(G))$.

Proof 4.2**.**

Fix some $G=(V,E)$, $s\in V$, and ${\cal A}$, as specified by the theorem statement. If $d(G)\leq 4$ then the theorem is trivially true as all throughput values are in $O(1)$. Assume therefore that $d(G)>4$. This allows us to apply Theorem 2.6 for $k=d(G)-1$, which establishes that there exists a non-empty subset $S\subset V$ such that $c(G\setminus S)>q\cdot|S|$, for $q=k-2=d(G)-3>1$ (where, as defined in Section 2.3, $c(G\setminus S)$ is the number of connected components after removing nodes in $S$ from graph $G$).

Let $C$ be the set of components in $G\setminus S$ that do not include the source $s$. Fix a packet $t$ spread by $s$. We say $t$ arrives at $C_{i}\in C$ in round $r\geq 1$, if this is the first round in which a node in $C_{i}$ receives packet $t$. In this case, $t$ must have been previously received by some bridge node in $S$ that is adjacent to $C_{i}$. This holds because if $t$ can make it from $s$’s component to $C_{i}$ without passing through a node in $S$, then removing $S$ would not disconnect $C_{i}$.

Fix any packet count $i\geq 1$. Each packet requires $|C|=c(G\setminus S)-1\geq q|S|$ arrival events before it completes spreading. As we established above, each arrival event requires a given node in $S$ to receive the given packet. Because each node in $S$ can receive at most one packet per round, there are at most $|S|$ arrival events per round in the network.

Putting together these pieces, let $T_{i}$ be the number of rounds required to spread $i$ packets. We can lower bound this value as:

[TABLE]

It follows that for every schedule, and every $i$, at least $T_{i}$ rounds are required to spread $i$ packets—yielding a throughput upper bounded by $\frac{i}{T_{i}}\leq\frac{i}{i\cdot q}=1/q=1/(d(G)-3)$, which yields the theorem.

4.2 An Optimal Routing Algorithm for Arbitrary Networks

Here we describe a routing algorithm that achieves broadcast capacity throughput in $\Omega(1/d(G))$, when executed in a connected graph $G$. The high-level idea is to first construct an MDST $T$ in the graph $G$. We then edge color $T$ using $O(d(G))$ colors, and use this coloring to simulate the standard CONGEST model, parameterized so that a constant number of packets can fit within its bandwidth limit. We analyze a straightforward pipelining flooding algorithm for the CONGEST model that converges to constant throughput. When combined with our simulator, which requires $O(d(G))$ real rounds to simulate each CONGEST round, the result is a solution that achieves an average latency of $O(d(G))$ rounds per packet, providing the claimed $\Omega(1/d(G))$ throughput.

As in the pairwise setting, we can do this in a centralized fashion at the cost of a large convergence time (in particular, it takes up to $O(n^{2})$ rounds to gather the graph topology locally before we can run a centralized algorithm). In order to decrease the convergence time, we subsequently describe a distributed version of this strategy that still converges to an optimal $\Omega(1/d(G))$ throughput in $O(n^{2})$ rounds, but guarantees to converge to at least $\Omega\left(\frac{1}{d(G)+\log{n}}\right)$ throughput in $\tilde{O}(D(T)\cdot d(G)+\sqrt{n})$ rounds, where $D(T)\leq n$ is the diameter of a spanning tree $T$ built by the algorithm and $\tilde{O}(\cdot)$ suppresses polylog$(n)$ factors.

Edge Coloring in the Mobile Telephone Model.

We begin by formally defining an edge coloring:

Definition 4.3**.**

Fix an undirected graph $G=(V,E)$ and palette size $c\geq q$. A $c$-edge coloring of $G$ is a function $\pi:E\rightarrow c$ that satisfies the following: if $e_{1},e_{2}\in E$ are adjacent then $\pi(e_{1})\neq\pi(e_{2})$.

Let $\Delta$ be the maximum degree of $G$. Clearly, an edge coloring requires at least $\Delta$ colors. Vizing showed that this trivial bound is close to optimal by proving that every graph admits a $(\Delta+1)$-coloring [34].

Achieving a $(\Delta+1)$-coloring with a centralized algorithm is straightforward. Because we will also consider distributed broadcast algorithms, however, we must also discuss how to produce an efficient edge coloring in a distributed manner in the mobile telephone model.

One of the first distributed edge coloring algorithms is described in Luby’s seminal paper on the maximal independent set (MIS) problem [26]. He produces a $(2\Delta-1)$-edge coloring of a graph in $O(\log{n})$ rounds, with high probability, in the LOCAL model of distributed computing by performing a $(\Delta+1)$-vertex coloring of the line graph of $G$.

We cannot, however, directly run this (or related) distributed coloring strategies in the mobile telephone model as their efficient time complexities heavily leverage the property of the LOCAL model that allows unbounded message sizes.444In Luby’s vertex coloring subroutine, for example, each node is responsible for simulating $\Theta(\Delta)$ virtual nodes during an execution of an MIS algorithm. Each node must send an MIS message on behalf of each of its virtual nodes, requiring at least $\Omega(\Delta)$ bits. The message size grows larger when this strategy is applied to the line graph of the original graph. More recent solutions require, at the very least, that nodes frequently describe their current palette of used or unused colors, which also requires $\Omega(\Delta)$ bits. Our distributed broadcast capacity algorithm will need to execute the distributed coloring using the $O(\log{n})$-bit advertisement tags allowed by our model—a challenge that is equivalent to edge coloring in the broadcast-CONGEST setting with an $O(\log{n})$ bandwidth limit. Each broadcast message is therefore only large enough to describe a constant number of colors and/or nodes.

Notice that the small broadcast messages in our setting implies that a $\Omega(\Delta)$ bound is unavoidable, as these many rounds are required for even basic coloring activities like describing your current used/unused palette, or assigning a color to each neighbor. On the positive side, the necessity of a slower bound enables us to explore simpler solutions. In particular, we propose the strategy summarized in Figure 1, in which nodes repeatedly construct a maximal matching, coloring the edges in the current matching with a new color and then removing them from consideration for future matchings.

As we establish, this strategy always terminates in at most $2\Delta-1$ matchings (creating a palette of the same size), and the $O(\log{n})$-round maximal matching algorithm of Israeli and Itai [24] is easily adapted to work with the small advertisement tags in our model (it requires nodes to broadcast, at most, a constant number of identifiers per round). The result is a randomized $(2\Delta-1)$-edge coloring algorithm that works in $O(\Delta\log{n})$ rounds, with high probability.555The high probability in the maximal matching algorithm is on the time complexity. Formally, we run the maximal matching algorithm for a fixed duration of rounds. With low probability, these rounds are not enough for one of the maximal matchings to succeed, potentially resulting in an incomplete edge coloring. Our edge coloring strategy is therefore a Monte Carlo algorithm, which will simplify its later use as a subroutine in a larger distributed system. Formally:

Theorem 4.4**.**

The EdgeColor-MTM$(\Delta)$ algorithm produces a $(2\Delta-1)$-edge coloring in $O(\Delta\log{n})$ rounds, with high probability in $n$.

Proof 4.5**.**

It follows directly from the definition of the algorithm that no two adjacent edges are colored the same color, as this would require two adjacent edges to be included in the same matching. It is sufficient, therefore, to show that $2\Delta-1$ maximal matchings are sufficient to cover every edge in $E$.

To see why this is true, fix some edge $(u,v)$ in $G$. The only event that can prevent $(u,v)$ from being included in a given maximal matching is if at least one other edge adjacent to $u$ or $v$ is included in the matching. There are at most $2(\Delta-1)$ such other edges, so $(u,v)$ must be matched after at most $2(\Delta-1)+1=2\Delta-1$ matchings.

The high probability comes from the Israeli and Itai maximal matching algorithm, which always produces a maximal matching, but terminates in $O(\log{n})$ rounds with high probability. By a union bound, with high probability all $2\Delta-1=O(n)$ instances of the algorithm terminate in time.

A Tight Broadcast Capacity Algorithm.

In Figure 2, we describe our streaming broadcast strategy: we create an MDST, edge color it, and then use this edge coloring to simulate pipelined flooding. In a centralized setting, we use the best-known approximation for MDST [13], which gives a spanning tree $T$ with max degree $d(G)+1$. We also use the centralized edge-coloring strategy for $T$ that uses only $d+1$ colors (which is easy on trees).

In the distributed setting, we assume the MDST algorithm is a Las Vegas algorithm that terminates with a tree with a degree in $O(d(G))$ in $f(n)$ rounds, for some complexity function $f(n)$ that we discuss below, with high probability in $n$ (and with probability $1$ in the limit). We also use the edge coloring algorithm from above as a subroutine. As described earlier, EdgeColor-MTM is a Monte Carlo algorithm. With low probability it can fail to color all edges. The validity checking step of our streaming broadcast algorithm simply checks for failures with a convergecast on the tree. If no problems are reported, $s$ can broadcast a message telling the network to proceed.

Once the edges are colored with $c=2d-1$ colors (or $c=d+1$ colors for the centralized algorithm), we can easily simulate the CONGEST model using $c$ real rounds for each simulated round. To simulate one round of CONGEST, we just cycle through the the $c$ colors, allowing, for each color $i$, all edges colored $i$ to connect. By the definition of edge coloring, all edges with the same color form a matching, so in $c$ rounds we can simulate one round of CONGEST (where every node sends a message to all of its neighbors rather than just one).

The pipeline flood we run on this simulation is the simple strategy in which $s$ floods messages down the MDST tree, starting a new flood in each round. The result is a pipeline of floods in which nodes receive a new message in every round. Because each simulated round requires $c=\Theta(d)$ rounds, and $d$ is the maximum degree of an approximate MDST, the result is a throughput that converges to $\Omega(1/d(G))$, as needed. Formally:

Theorem 4.6**.**

When executed in a connected network topology $G=(V,E)$ of size $n=|V|$, with a broadcast capacity flow set with source $s\in V$, with high probability in $n$: the SB$(s)$ algorithm achieves a throughput in $\Omega(1/d(G))$ with respect to $G$ and $F$.

Proof 4.7**.**

With high probability in $n$, we successful construct an MDST with maximum degree in $O(d(G))$, and successfully color the edges with $O(d(G))$ colors. Once this initialization is complete, the claimed throughput is achieved once sufficient packet deliveries have passed to amortize the setup costs of the MDST, edge coloring, and pipeline initialization.

Convergence Time.

To understand the convergence round of $SB(s)$ (that is, how fast it converges to its claimed throughput), we must consider the three setup costs the algorithm pays before converging to its eventual throughput: (1) MDST setup; (2) edge coloring; (3) time required to fill the pipeline. Tackling these in reverse order, the third requires $D(T)$ CONGEST rounds (where $T$ is the MDST tree built by the algorithm), which works out to $O(D(T)\cdot d(G))$ real rounds, and (2) is $O(\Delta(T)\log{n})$ rounds with high probability by Theorem 4.4 (where $\Delta(T)$ is the maximum degree of $T$). We note that $d(G)=\tilde{\Theta}(\Delta(T))$, so the third cost dominates the second cost when ignoring log factors.

The cost of (1) depends on the algorithm deployed. The centralized MDST algorithm due to Fürer and Raghavachari [13], generates a tree with maximum degree $d(G)+1$ in a polynomial number of computational steps. In our distributed setting, this algorithm can be deployed by spending $O(n^{2})$ rounds to gather the entire network topology by flooding edge descriptions using the mobile telephone model advertisements (which can fit a constant number of edges per advertisement), and then have each node run the centralized algorithm locally.

In recent work, Dinitz et al. [9] present a distributed algorithm for the broadcast-CONGEST model (with bandwidth bound $O(\log{n})$), that constructs a tree with maximum degree $O(d(G)+\log{n})$ in $\tilde{O}(D+\sqrt{n})$ rounds, with high probability in $n$. We can directly run this algorithm in the mobile telephone model using the advertisements to implement the small broadcast messages from the broadcast-CONGEST model. This distributed solution is more efficient, but for networks with small $d(G)$ values, it does not enable optimal throughput.

As hinted earlier, we can balance these competing interests by combining the two algorithms. In particular, we can implement $SB(s)$ such that it begins by constructing a tree using the distributed algorithm from [9]. It can then, in the background, improve this tree down to degree $d(G)+1$ using the algorithm from [13], switching to the new tree once it is complete.

By combining these various costs, we converge to $\Omega(1/(d(G)+\log{n}))$ throughput in $\tilde{O}(D(T)\cdot d(G)+\sqrt{n})$ rounds, which then improves to $\Omega((1/d(G)))$ throughput within $O(n^{2})$ rounds.

4.3 Random Networks

The preceding broadcast capacity results hold for any connected network graph. Here we study the problem in networks randomly generated by the $GK$ process with a communication radius sufficiently larger than the threshold $r_{c}(n)$.

In more detail, we prove that for any radius that is a sufficiently large constant factor bigger than $r_{c}(n)$, with high probability in $n$, our $SB(s)$ routing algorithm from Section 4.2 will achieve constant throughput in a network generated by $GK(n,r)$—indicating that in a natural network topology, the mobile telephone model is well-suited for broadcast capacity. The proof of the below theorem leverages results from Section 3.2.3 to prove that the network likely has a constant degree MDST.

Theorem 4.8**.**

There exists a constant $\beta\geq 1$, such that for any significantly large network size $n>1$ and radius $r\geq\beta r_{c}(n)$, if $G\sim GK(n,r)$ then with high probability $SB(s)$ achieves constant throughput (for any $s$).

Proof 4.9**.**

By Lemma 3.23, there exists a constant $\beta$, such that for any sufficiently large network size $n$, and any radius $r\geq\beta\cdot r_{c}(n)$, the graph $G=(V,E)$ generated by the $GK(n,r)$ process is good (see Definition 3.22). Assume this holds. Consider the $r$-grid. By the definition of good and $r$-grid, each grid box is non-empty, and each node is within range of every node in grid boxes that share an edge with its own.

With this in mind, fix one core node in each grid box. To construct a spanning tree, first connect each chosen core node to the chosen core nodes in the (at most) four adjacent boxes. This creates an overlay with at least one node in every grid box. We then take an arbitrary spanning tree of this overlay. Finally, for each box, connect the other nodes into a line that includes the box’s chosen core node as its endpoint. The result is a spanning tree with maximum degree $5$. It follows that $d(G)\leq 5$. By Theorem 4.6, the $SB(s)$ algorithm will achieve throughput in $\Omega(1/(d(G))=\Theta(1)$ in this graph.

5 All-to-All Capacity

We now consider the all-to-all capacity problem, which assumes all nodes begin with an infinite sequence of packets to spread to all other nodes. Formally, this variation of the capacity problem considers only the following canonical flow set: $F_{all}=\{(s,V\setminus\{s\}):s\in V\}$.

In Section 4, we described and analyzed an algorithm that achieved a throughput in $\Omega(1/d(G))$ for delivering packets from a single source to the whole network. To solve all-to-all capacity, we could run $n$ instances of this algorithm: one for each source, rotating through the different instances in a round robin fashion. This approach provides a baseline throughput result of $\Omega(1/(n\cdot d(G)))$. The key questions are whether or not this bound is tight, and whether there are simpler or more natural strategies than deploying round robin interleaving of single-source broadcast.

In this section we answer both questions in the affirmative. We first prove that every schedule achieves a throughput in $O(1/(n\cdot d(G)))$, then describe and analyze a distributed algorithm that achieves optimal throughput by solving all-to-all gossip with a simple flood on a good spanning tree for each packet. This algorithm then becomes our basis for largely resolving an open question from [29] regarding one-shot gossip in the mobile telephone model.

5.1 A Bound on Achievable Throughput for Arbitrary Networks

In Section 4, we proved a tight connection between the achievable broadcast capacity and the degree of an MDST in the graph (i.e., $d(G)$ for graph $G$). Here we formalize the intuition that this connection also exists for the related problem of all-to-all capacity.

Theorem 5.1**.**

Fix a connected network graph $G=(V,E)$ of size $n=|V|$. Every schedule achieves throughput at most $O\left(\frac{1}{n\cdot d(G)}\right)$ with respect to $G$ and $F_{all}$.

Proof 5.2**.**

Fix some $G=(V,E)$ as specified by the theorem statement. Because a given node in our model can receive at most one packet per round, it is trivial to calculate that for every packet count $i$, it requires $\Omega(n\cdot i)$ rounds for all nodes to deliver their first $i$ packets to all other nodes. Therefore, if $d(G)$ is constant, the theorem is trivially true.

On the other hand, if $d(G)$ is a sufficiently large constant, we can apply the same argument from our proof of Theorem 4.1, which in turn leverages Theorem 2.6, to establish that $T_{k}=\frac{(d(G)-3)\cdot k}{2}$ rounds are required for $k$ packets to spread.

Focusing on this case, fix some packet count $i$. For all $n$ nodes to successfully spread $i$ distinct packets requires $k=n\cdot i$ total packets to spread in the network, requiring at least $T_{k}\in\Omega(d(G)\cdot n\cdot i)$ total rounds, yielding a throughput in $O(i/T_{k})=O(1/(d(G)\cdot n))$. Since this holds for all $i$, the theorem claim follows.

5.2 An Optimal Routing Algorithm for Arbitrary Networks

In Section 4.2, we described an algorithm that simulates the CONGEST model (with a bandwidth bound sufficient to fit a constant number of packets) in the mobile telephone model. The strategy first builds an approximate MDST and then edge colors the tree edges. This coloring is used to schedule the mobile telephone model connections needed to simulate on round of CONGEST. If the tree has maximum degree $d$, then the simulation requires $O(d)$ real rounds for each simulated CONGEST round.

To match the all-to-all capacity bound from Theorem 5.1, we deploy this same CONGEST simulation. This time, however, we run an all-to-all gossip algorithm on top of the simulation, and show that this algorithm spreads $k$ gossip messages to all nodes in $O(D+k)$ rounds in the CONGEST model in a network with diameter $D$. Combining this bound with the simulation overhead will yield a throughput result that asymptotically matches the bound from Theorem 5.1.

We begin below by describing and analyzing our CONGEST gossip algorithm, before analyzing how it combines with our simulator.

Broadcast Gossip in CONGEST.

Here we describe and analyze a simple strategy call broadcast gossip, that is designed for the CONGEST. The strategy works as follows. Every node maintains a FIFO message queue initialized to holds its initial gossip message (if it starts with such a message), and a list of sent messages initialized to be empty. At the beginning of each round, each node $v$ does the following. If its queue is non-empty, it dequeues a message, broadcasts it to all of its neighbors, and adds it to its sent messages list. For each message $m$ received by $v$ in this round, if $m$ is on $v$’s sent messages list, it discards it, otherwise it enqueues it to its message queue.

The time complexity of this strategy is well-known as folklore, and for some models, it has a concrete proof in the literature; e.g., [16]. For the sake of completeness, we clarify and generalize the result from [16]:

Theorem 5.3**.**

Consider the broadcast gossip algorithm used to spread $k\geq 1$ messages in connected network topology $G=(V,E)$ with diameter $D$. All messages spread to all nodes by the end of round $D+k$.

Proof 5.4**.**

We begin by defining two useful pieces of notation: for a given gossip message $m$, let $u_{m}$ be the node that starts with $m$, and for each $v\in V$, let $d_{m}(v)$ be the shortest path distance between $v$ and $u_{m}$. Fix a specific message $m$. We first study the spread of this message through the network using induction on the round number. In particular, consider the following inductive hypothesis:

For every $r\geq 1$: for every $v$ and $\ell$ such that $d_{m}(u)+\ell=r$, one of the following two properties must be true of $v$ after round $r$: (1) $v$ has sent $m$; (2) $v$ has sent at least $\ell$ distinct gossip messages. **

We begin with the base case ($r=1$). There are only two relevant combinations of $v$ and $\ell$ values for $r=1$. The first is when $d_{m}(v)=0$ and $\ell=1$. In this case, $v=u_{m}$ so we know $v$ starts with $m$ and therefore has a message to broadcast during round $1$, satisfying property (2) for $\ell=1$. The second case is when $d_{m}(v)=1$ and $\ell=0$. In this case, property (2) is vacuously true.

We continue with the inductive step ($r>1$). Fix any $v$ and $\ell$ such that $d_{m}(v)+\ell=r$. Let us consider what has happened by the end of round $r-1$. If $v$ has sent $m$ by the end of round $r-1$, then we are done. Moving forward, therefore, assume $v$ has not sent $m$ by the end of $r-1$.

Fix some $w$ that is one hop closer to $u_{m}$ than $v$. Notice that $r-1=d_{m}(v)+\ell-1=d_{m}(w)+\ell$. Therefore, by the inductive hypothesis, and our assumption that $v$ has not yet sent $m$, we know that after round $r-1$, node $v$ has broadcast at least $\ell-1$ messages and node $w$ has either broadcast $m$ or broadcast $\ell$ messages. Either way, $v$ has at least one new message to broadcast in $r$, meaning that by the end of this round it will have at least satisfied property (2) of the inductive hypothesis.

Stepping back, we can now pull together the pieces to prove the main theorem. The inductive claim above establishes that for each $v$, $v$ has sent $m$ by round $d_{m}(v)+k\leq D+k$. This follows because by the above hypothesis, by the end of round $d_{m}(v)+k$, $v$ has either sent $m$ or at least $k$ other messages. Given that there are only $k$ total messages, the latter property also implies it has sent $m$.

The inductive claim applies for every message $m$. Therefore, every node has sent (and therefore received) every message by round $D+k$, as claimed.

A Tight All-to-All Capacity Algorithm.

As with broadcast capacity, we build an approximate MDST, edge color it, and then use the colors to simulate CONGEST. For each packet count $i$, we use our simulation to run the broadcast gossip strategy analyzed above to gossip each node’s packet number $i$. If $\hat{d}$ is the maximum degree of the approximate MDST, and $\hat{D}$ is its diameter, then each instance of broadcast gossip requires $O(n+\hat{D})=O(n)$ simulated rounds, which in turn requires $O(n\cdot\hat{d})$ total rounds—providing throughput values that match the $O(1/(d(G)\cdot n))$ bound proved in Theorem 5.1. Formally:

Theorem 5.5**.**

When executed in a connected network topology $G=(V,E)$ of size $n=|V|$, with high probability in $n$: the SG algorithm achieves throughput in $\Omega\left(\frac{1}{d(G)\cdot n}\right)$ with respect to $G$ and $F_{all}$.

Proof 5.6**.**

Fix some $G=(V,E)$ as specified by the theorem. With high probability in $n$, we successfully setup a simulation of the CONGEST model in a tree with a maximum degree in $O(d(G))$. The SG algorithm solves all-to-all gossip for each packet, finishing the current packet before moving onto the next. By Theorem 5.3, each instance requires $O(D+n)=O(n)$ simulated rounds, which requires $O(n\cdot d(G))$ real rounds. For all packet counts, the throughput is therefore in $\Omega\left(\frac{1}{d(G)\cdot n}\right)$, as claimed.

When it comes to convergence time, the same arguments as in Section 4.2 apply. That is, we can use a hybrid of the approximate MDST algorithms from [9, 13] to efficiently achieve a throughput in $\Omega\left(\frac{1}{(d(G)+\log{n})\cdot n}\right)$ that then improves to $\Omega\left(\frac{1}{d(G)\cdot n}\right)$ rounds by $O(n^{2})$ rounds. (In this case, the definition of efficient is slightly improved as compared to broadcast capacity, as we solve all-to-all gossip from scratch for each packet, eliminating a relevant setup cost related to filling a pipeline.)

5.3 Random Networks

We now prove that as with broadcast capacity, randomly generated networks are likely to enable efficient packet spreading. In particular, we prove that for any sufficiently large network size $n$, and any sufficiently large radius $r$ compared to the connectivity threshold $r_{c}(n)$ (see Section 4.3), with high probability in $n$, our $SG$ algorithm will achieve a throughput in $\Omega(1/n)$ with respect a graph generated by the $GK(n,r)$ process and flow set $F_{all}$.

Notice, because a node can receive at most one new packet per round, $O(1/n)$ is a trivial bound on achievable throughput in every graph, so this shows that graphs from the $GK$ process are in some sense the easiest graphs. The below result follows directly from Theorem 5.5 and the argument used in the proof of Theorem 4.8 that establishes for a sufficiently large radius, the resulting graph is likely to have a constant degree spanning tree.

Theorem 5.7**.**

There exists a constant $\beta\geq 1$, such that for any significantly large network size $n>1$ and radius $r\geq\beta r_{c}(n)$, if $G\sim GK(n,r)$ then with high probability $SG$ achieves throughput in $\Omega(1/n)$ with respect to $G$ and $F_{all}$.

5.4 Implications for One-Shot Gossip

Existing results for one-shot gossip in the mobile telephone model are expressed with respect to the vertex expansion (denoted $\alpha$) of the graph topology [30, 29]. The best known results requires $O((n/\alpha)\text{polylog}(n))$ rounds, which is not tight in all graphs as vertex expansion does not necessarily characterize optimal gossip.666Consider, for example, a path of length $n$, which has $\alpha=2/n$. It is possible to pipeline $n$ messages through this network in $\Theta(n)$ rounds, which is much faster than $\tilde{O}(n/\alpha)=\tilde{O}(n^{2})$. A key open question from [29] is whether it is possible to produce a gossip algorithm that is optimal (or within log factors of optimal) in all network topology graphs. The techniques used in the above capacity bounds help us prove the following, which largely resolves this open question:

Theorem 5.8**.**

Fix a connected network topology $G=(V,E)$ with diameter $D$, size $n=|V|$, and MDST degree $d(G)$. Every solution to the one-shot gossip in $G$ requires $\Omega(d(G)\cdot n)$ rounds. There exists an algorithm solves the problem in $O((D+\sqrt{n})\text{\em polylog}(n)+n(d(G)+\log{n}))=\tilde{O}(d(G)\cdot n)$ rounds, with high probability in $n$.

Proof 5.9**.**

The lower bound of $\Omega(d(G)\cdot n)$ follows directly from the argument of Theorem 5.1. To derive the upper bound, we consider the $SG$ algorithm run with the distributed approximate MDST algorithm from [9]. After initialization, $SG$ solves one-shot gossip in $O((D+n)\cdot\hat{d})=O(n\cdot\hat{d})$ rounds, where $\hat{d}$ is the maximum degree of the tree used by the algorithm. Using the distributed algorithm from [9], this tree requires $\tilde{O}(D+\sqrt{n})$ rounds to construct and yields $\hat{d}\in O(d(G)+\log{n})$. The theorem claim follows directly.

Notice, the solution described in Theorem 5.8 is asymptotically optimal in any graph with $d(G)\in\Omega(\log{n})$ and $D\in O(n/\log^{x}{n})$ (where $x$ is the constant from the polylog in the MDST construction time), which describes a large family of graphs. Furthermore, for the subset of graphs with small MDST degrees and/or large degrees, the solution can be expressed as $\tilde{O}(d(G)\cdot n)$, which is at most a polylog factor slower than optimal.

This is the first known gossip solution to be optimal, or within log factors of optimal, in all graphs, largely answering the challenge presented by [29].