Network Coding Gaps for Completion Times of Multiple Unicasts

TL;DR

This paper investigates the potential benefits of network coding over routing for minimizing completion times in multiple unicast networks, establishing bounds on the coding gap that are polylogarithmic in the number of unicast sessions.

Contribution

It introduces new techniques to upper bound the network coding gap for makespan minimization in multiple unicasts, showing it is at most polylogarithmic in the number of sessions.

Findings

Network coding gap is at most polylogarithmic in the number of unicasts.

Existence of instances where the coding gap is polylogarithmic in the number of unicasts.

Results extend to average completion time and any  norm of completion times.

Abstract

We study network coding gaps for the problem of makespan minimization of multiple unicasts. In this problem distinct packets at different nodes in a network need to be delivered to a destination specific to each packet, as fast as possible. The network coding gap specifies how much coding packets together in a network can help compared to the more natural approach of routing. While makespan minimization using routing has been intensely studied for the multiple unicasts problem, no bounds on network coding gaps for this problem are known. We develop new techniques which allow us to upper bound the network coding gap for the makespan of $k$ unicasts, proving this gap is at most polylogarithmic in $k$. Complementing this result, we show there exist instances of $k$ unicasts for which this coding gap is polylogarithmic in $k$. Our results also hold for average completion time, and more generally any $\ell_p$ norm of completion times.

Equations

$$O\left(\log (k)\cdot \log \left(\sum _i{d}_i/\underset{i}{\min }{d}_i\right)\right).$$

$$\sum _{e\in E}{c}_e({\tilde{\ell }}_e-1)$$

$$\tilde{\ell }(p)$$

$$\underset{P\sim \mathcal{P}}{\mathrm{Pr}}[B(x,\gamma \Delta )⊈P]\le \beta \gamma .$$

$$(5/3{)}^{2^i}$$

$$\sum _{j^{\prime }\le j}\alpha \cdot 2^{j^{\prime }+1}$$

$$O\left(\log (k)\cdot \log \left(\sum _i{d}_i/\underset{i}{\min }{d}_i\right)\right).$$

$$L\ge \frac{w}{C(w)}\ge \frac{w}{w^{\prime }+T}=(r-o(1))\frac{w^{\prime }}{w^{\prime }+T}=r-o(1).$$

$$r^{\prime }\ge w/C^R(w)\ge (r-o(1))/\alpha =r/\alpha -o(1).$$

$${\int }_0^{d([k])}f(x)=\frac{d_1}{d_1}+\frac{d_2}{d_1+d_2}+\frac{d_3}{d_1+d_2+d_3}+\dots +\frac{d_k}{d([k])}.$$

$${\int }_0^{d([k])}f(x)$$

$$\le 1+{\int }_{d_1}^{d([k])}\frac{1}{x}dx=1+\ln \frac{d([k])}{d_1}.$$

$$\frac{k_{+}}{f_{+}}$$

$$\ge \frac{k_1}{f_1}\cdot \frac{1}{1+\frac{2m_1}{f_1}\frac{f_2}{k_2}}\ge \frac{k_1}{f_1}\cdot \frac{1}{1+\frac{2u_1}{r_2}}=r_1\cdot \frac{1}{1+\frac{2u_1}{r_2}}=r_{+}.$$

$$\frac{m_{+}}{f_{+}}$$

$$\le u_2\cdot \frac{1+a_2\frac{k_2}{2(m_1/f_1-1)}\frac{1}{m_2}}{1+\frac{f_1}{2m_1}\frac{k_2}{f_2}}\le u_2\cdot \frac{1+a_2\cdot \frac{1}{2}\cdot 1}{1+\frac{1}{2}\frac{r_2}{u_1}}=u_{+}.$$

$$\frac{m_{+}}{f_{+}}$$

$$\frac{k_{i+1,r}}{f_{i+1,r}}\ge r_{i+1,r}=r_{i,3r}\cdot \frac{1}{1+2u_{i,3r}/r_{i,u(i,3r)}}\ge 3r\cdot \frac{1}{1+2u_{i,3r}/u_{i,3r}}=3r\cdot \frac{1}{3}=r.$$

$$m_{i+1,r}$$

$$\log m_{i+1,r}$$

$$=O(2^i)+O(b_1{b}_2)\log (m_1{m}_2)+\log (m_1{m}_2)$$

$$=O(2^i)+O(5^{2^i})\log (m_1{m}_2)$$

$$=O(5^{2^i})\cdot \log (m_{i,3r}\cdot m_{i,u(i,3r)}).\text{qed}$$

$$\log u(i+1,r)$$

$$\le O(2^i)+\frac{1}{c}(c^2{)}^{2^i}\log u(i,3r)$$

$$\le O(2^i)+\frac{1}{c}(c^2{)}^{2^i}\frac{1}{c}{c}^{2^i}\log 3r$$

$$\le O(2^i)+\frac{1}{c^2}(c^2{)}^{2^{i+1}}\log 3r$$

$$\le \frac{1}{c}(c^2{)}^{2^{i+1}}\log r,$$

$$\log m_{i+1,r}$$

$$\le O(5^{2^{i+1}})\cdot \left(c^{2^i}\log 3r+c^{2^i}\log u(i,3r)\right)$$

$$\le O(5^{2^{i+1}})\cdot \left(c^{2^i}\log 3r+c^{2^i}{2}^{O(2^i)}\log 3r\right)$$

$$=c^{2^i}\cdot O(5^{2^{i+1}})\cdot 2^{O(2^i)}\log 3r$$

$$\le c^{2^i+1}\log r,$$

Full text

While makespan minimization using routing has been intensely studied for the multiple unicasts problem, no bounds on network coding gaps for this problem are known. We develop new techniques which allow us to upper bound the network coding gap for the makespan of $k$ unicasts, proving this gap is at most polylogarithmic in $k$. Complementing this result, we show there exist instances of $k$ unicasts for which this coding gap is polylogarithmic in $k$. Our results also hold for average completion time, and more generally any $\ell_{p}$ norm of completion times.

00footnotetext: Supported in part by NSF grants CCF-1618280, CCF-1814603, CCF-1527110, NSF CAREER award CCF-1750808, and a Sloan Research Fellowship, as well as a DFINITY scholarship.

1 Introduction

In this paper we study the natural mathematical abstraction of what is arguably the most common network communication problem: multiple unicasts. In this problem, distinct packets of different size are at different nodes in a network, and each packet needs to be delivered to a specific destination as fast as possible. That is, minimizing the makespan, or the time until all packets are delivered.

All known multiple-unicast solutions employ (fractional) routing (also known as store-and-forward protocols), i.e., network nodes potentially subdivide packets and route (sub-)packets to their destination via store and forward operations, while limited by edge capacities. The problem of makespan minimization of routing has been widely studied over the years. A long line of work [60, 55, 62, 10, 40, 13, 54, 58, 53, 8, 46, 45, 61], starting with the seminal work of Leighton, Maggs, and Rao [45], studies makespan minimization for routing along fixed paths. The study of makespan minimization for routing (with the freedom to pick paths along which to route) resulted in approximately-optimal routing, first for asymptotically-large packet sizes [10], and then for all packet sizes [62].

It seems obvious at first that routing packets, as though they were physical commodities, is the only way to solve network communication problems, such as multiple unicasts. Surprisingly, however, results discovered in the 2000s [5] suggest that information need not flow through a network like a physical commodity. For example, nodes might not just forward information, but instead send out XORs of received packets. Multiple such XORs or linear combinations can then be recombined at destinations to reconstruct any desired packets. An instructive example is to look at the XOR $C\oplus M$ of two $s$-bit packets, $C$ and $M$. While it is also $s$ bits long, one can use it to reconstruct either all $s$ bits of $C$ or all $s$ bits of $M$, as long as the other packet is given. Such network coding operations are tremendously useful for network communication problems, but they do not have a physical equivalent. Indeed, the $C\oplus M$ packet would correspond to some $s$ ounces of a magic “café latte” liquid with the property that one can extract either $s$ ounces of milk or $s$ ounces of coffee from it, as long as one has enough of the other liquid already. Over the last two decades, many results demonstrating gaps between the power of network coding and routing have been published (e.g., [5, 64, 31, 48, 65, 43, 6, 19, 24, 22, 15, 63, 26, 27, 38]). Attempts to build a comprehensive theory explaining what is or is not achievable by going beyond routing have given rise to an entire research area called network information theory.

The question asked in this paper is:

“How much faster than routing can network coding be for any multiple-unicast instance?”

In other words, what is the (multiplicative) network coding gap for makespan of multiple unicasts. Surprisingly, no general makespan coding gap bounds were known prior to this work. This is in spite of the vast amount of effort invested in understanding routing strategies for this problem, and ample evidence of the benefits of network coding.

This question was studied in depth for the special case of asymptotically-large packet sizes, otherwise known as throughput maximization (e.g., [48, 32, 41, 2, 37, 31, 66, 48, 65, 43, 6]). Here, the maximum throughput of a multiple-unicast instance can be defined as $\sup_{w\rightarrow\infty}w/C(w)$, where $C(w)$ is the makespan of the fastest protocol for the instance after increasing all packet sizes by a factor of $w$ (see Appendix A). In the throughput setting, no instances are known where coding offers any advantage over routing, and this is famously conjectured to be the case for all instances [48, 32]. This conjecture, if true, has been proven to have surprising connections to various lower bounds [3, 2, 21]. Moreover, by the work Afshani et al. [3], a throughput coding gap of $o(\log k)$ for all multiple-unicast instances with $k$ unicast pairs ($k$-unicast instances, for short) would imply explicit super-linear circuit lower bounds—a major breakthrough in complexity theory. Such a result is currently out of reach, as the best known upper bound on throughput coding gaps is $O(\log k)$, which follows easily from the same bound on multicommodity flow/sparsest cut gaps [9, 50].

In this work we prove makespan coding gaps for the general problem of arbitrary packet sizes. In particular, we show that this gap is at most $O(\log^{2}k)$ for any $k$-unicast instance (for the most interesting case of similar-sized packet sizes). We note that any coding gap upper bound for this more general setting immediately implies the same bound in the throughput setting (Appendix A), making our general bound only quadratically larger than the best known bound for the special case of throughput. Complementing our results, we prove that there exist $k$-unicast instances where the network coding gap is $\Omega(\log^{c}k)$ for some constant $c>0$.

To achieve our results we develop novel techniques that might be of independent interest. The need for such new tools is due to makespan minimization for general packet sizes needing to take both source-sink distances as well as congestion issues into account. This is in contrast with the throughput setting, where bounds must only account for congestion, since asymptotically-large packet sizes make distance considerations inconsequential. For our more general problem, we must therefore develop approaches that are both congestion- and distance-aware. One such approach is given by a new combinatorial object we introduce, dubbed the moving cut, which allows us to provide a universally optimal characterization of the coding makespan. That is, it allows us to obtain tight bounds (up to polylog terms) on the makespan of any given multiple-unicast instance. We note that moving cuts can be seen as generalization of prior approaches that were (implicitly) used to prove unconditional lower bounds in distributed computing on specially crafted networks [18, 56]; the fact they provide a characterization on all networks and instances is novel. This underlies our main result—a polylogarithmic upper bound on the makespan coding gap for any multiple-unicast instance.

1.1 Preliminaries

In this section we define the completion-time communication model. We defer the, slightly more general, information-theoretic formalization to Appendix B.

A multiple-unicast instance $\mathcal{M}=(G,\mathcal{S})$ is defined over a communication network, represented by an connected undirected graph $G=(V,E)$ with capacity $c_{e}\in\mathbb{Z}_{\geq 1}$ for each edge $e$. The $k\triangleq|\mathcal{S}|$ sessions of $\mathcal{M}$ are denoted by $\mathcal{S}=\{(s_{i},t_{i},q_{i})\}_{i=1}^{k}$. Each session consists of source node $s_{i}$, which wants to transmit a packet to the sink $t_{i}$, consisting of $q_{i}\in\mathbb{Z}_{\geq 1}$ sub-packets. Without loss of generality we assume that a uniform sub-packetization is used; i.e., all sub-packets have the same size (think of sub-packets as the underlying data type, e.g., field elements or bits). For brevity, we refer to an instance with $k$ sessions as a $k$-unicast instance.

A protocol for a multiple-unicast instance is conducted over finitely-many synchronous time steps. Initially, each source $s_{i}$ knows its packet, consisting of $d_{i}$ sub-packets. At any time step, the protocol instructs each node $v$ to send a different packet along each of its edges $e$. The packet contents are computed with some predetermined function of packets received in prior rounds by $v$ or originating at $v$. Network coding protocols are unrestricted protocols, allowing each node to send out any function of the packets it has received so far. On the other hand, routing protocols are a restricted, only allowing a node to forward sub-packets which it has received so far or that originate at this node.

We say a protocol for multiple-unicast instance has completion times $(T_{1},T_{2},\dots,T_{k})$ if for each $i\in[k]$, after $T_{i}$ time steps of the protocol the sink $t_{i}$ can determine the $d_{i}$-sized packet of its source $s_{i}$. The complexity of a protocol is determined by functions $\mathcal{C}:\mathbb{R}_{\geq 0}^{k}\to\mathbb{R}_{\geq 0}$ of its completion times. For example, a protocol with completion times $(T_{1},T_{2},\dots,T_{k})$ has makespan $\max_{i\in[k]}T_{i}$ and average completion time $(\sum_{i\in[k]}T_{i})/k$. Minimizing these measures is a special case of minimizing weighted $\ell_{p}$ norms of completion time, namely minimizing $(\sum_{i\in[k]}w_{i}\cdot T_{i}^{p})^{1/p}$ for some $\vec{w}\in\mathbb{R}^{k}$ and $p\in\mathbb{R}_{\geq 0}$.

Since coding protocols subsume routing ones, for any function $\mathcal{C}$ of completion times, and for any multiple-unicast instance, the fastest routing protocol is no faster than the fastest coding protocol. Completion-time coding gaps characterize how much faster the latter is.

Definition 1.1**.**

(Completion-time coding gaps) For any function $\mathcal{C}:\mathbb{R}_{\geq 0}^{k}\rightarrow\mathbb{R}_{\geq 0}$ of completion times, the network coding gap for $\mathcal{C}$ for a $k$-unicast instance $\mathcal{M}=(G,\mathcal{S})$ is the ratio of the smallest $\mathcal{C}$-value of any routing protocol for $\mathcal{M}$ and the smallest $\mathcal{C}$-value of any network coding protocol for $\mathcal{M}$.

We note that the multiple-unicast instance problem can be further generalized, so that each edge has both capacity and delay, corresponding to the amount of time needed to traverse the edge. This more general problem can be captured by replacing each edge $e$ with a path with unit delays of total length proportional to $e$’s delay. As we show, despite path length being crucially important in characterizing completion times for multiple-unicast instances, this transformation does not affect the worst-case coding gaps, which are independent of the network size (including after this transformation). We therefore consider only unit-time delays in this paper, without loss of generality.

1.2 Our Contributions

In this work we show that completion-time coding gaps of multiple unicasts are vastly different from their throughput counterparts, which are conjectured to be trivial (i.e., equal to one). For example, while the throughput coding gap is always one for instances with $k=2$ sessions [34], for makespan it is easy to derive instances with $k=2$ sessions and coding gap of $\nicefrac{{4}}{{3}}$ (based on the butterfly network). Having observed that makespan coding gaps can in fact be nontrivial, we proceed to study the potential asymptotic growth of such coding gaps as the network parameters grow. We show that the makespan coding gap of multiple unicasts with $k$ sessions and packet sizes $\{d_{i}\}_{i\in[k]}$ is polylogarithmic in the problem parameters, $k$ and $\sum_{i}d_{i}/\min_{i}d_{i}$, but independent of the network size, $n$. The positive part of this result is given by the following theorem.

Theorem 1.2**.**

The network coding gap for makespan of any $k$-unicast instance is at most

$O\left(\log(k)\cdot\log\left(\sum_{i}d_{i}/\min_{i}d_{i}\right)\right).$

For similarly-sized packets, this bound simplifies to $O(\log^{2}k)$. For different-sized packets, our proofs and ideas in [57] imply a coding gap of $O(\log k\cdot\log(nk))$. Moreover, our proofs are constructive, yielding for any $k$-unicast instance $\mathcal{M}$ a routing protocol which is at most $O(\log k\cdot\log(\sum_{i}d_{i}/\min_{i}d_{i}))$ and $O(\log k\cdot\log(nk))$ times slower than the fastest protocol (of any kind) for $\mathcal{M}$. We note that our upper bounds imply the same upper bounds for throughput (see Appendix A). Our bounds thus also nearly match the best coding gap of $O(\log k)$ known for this special case of makespan minimization.

On the other hand, we prove that a polylogarithmic gap as in 1.2 is inherent, by providing an infinite family of multiple-unicast instances with unit-sized packets ($d_{i}=1$ for all $i\in[k]$) exhibiting a polylogarithmic makespan coding gap.

Theorem 1.3**.**

There exists an absolute constant $c>0$ and an infinite family of $k$-unicast instances whose makespan coding gap is at least $\Omega(\log^{c}k).$

Building on our results for makespan we obtain similar results to Theorems 1.2 and 1.3 for average completion time and more generally for any weighted $\ell_{p}$ norm of completion times.

1.3 Techniques

Here we outline the challenges faced and key ideas needed to obtain our results, focusing on makespan.

1.3.1 Upper Bounding the Coding Gap

As we wish to bound the ratio between the best makespan of any routing protocol and any coding protocol, we need both upper and lower bounds for these best makespans. As it turns out, upper bounding the best makespan is somewhat easier. The major technical challenge, and our main contribution, is in deriving lower bounds on the optimal makespan of any given multiple-unicast instance. Most notably, we formalize a technique we refer to as the moving cut. Essentially the same technique was used to prove that distributed verification is hard on one particular graph that was designed specifically with this technique in mind [20, 18, 56]. Strikingly, we show that the moving cut technique gives an almost-tight characterization (up to polylog factors) of the coding makespan for every multiple-unicast instance (i.e., it gives universally optimal bounds).

We start by considering several prospective techniques to prove that no protocol can solve an instance in fewer than $T$ rounds, and build our way up to the moving cut. For any multiple-unicast instance, $\max_{i\in[k]}\textrm{dist}(s_{i},t_{i})$, the maximum distance between any source-sink pair, clearly lower bounds the coding makespan. However, this lower bound can be arbitrarily bad since it does not take edge congestion into account; for example, if all source-sink paths pass through one common edge. Similarly, any approach that looks at sparsest cuts in a graph is also bound to fail since it does not take the source-sink distances into account.

Attempting to interpolate between both bounds, one can try to extend this idea by noting that a graph that is “close” (in the sense of few deleted edges) to another graph with large source-sink distances must have large makespan for routing protocols. For simplicity, we focus on instances where all capacities and demands are one, i.e., $c_{e}=1$ for every edge $e$ and $d_{i}=1$ for all $i$, which we refer to as simple instances. The following simple lemma illustrates such an approach.

Lemma 1.4**.**

Let $\mathcal{M}=(G,\mathcal{S})$ be a simple $k$-unicast instance. Suppose that after deleting some edges $F\subseteq E$, any sink is at distance at least $T$ from its source; i.e., $\forall i\in[k]$ we have $\textrm{dist}_{G\setminus F}(s_{i},t_{i})\geq T$. Then any routing protocol for $\mathcal{M}$ has makespan at least $\min\left\{T,k/|F|\right\}$.

Proof.

For any sets of flow paths between all sinks and source, either (1) all source-sink flow paths contain at least one edge from $F$, incurring a congestion of $k/|F|$ on at least one of these $|F|$ edges, or (2) there is a path not containing any edge from $F$, hence having a hop-length of at least $T$. Either way, any routing protocol must take at least $\min\{T,k/|F|\}$ to route along these paths. ∎

Perhaps surprisingly, the above bound does not apply to general (i.e., coding) protocols. Consider the instance in Figure 1. There, removing the single edge $\{S,T\}$ increases the distance between any source-sink pair to $5$, implying any routing protocol’s makespan is at least $5$ on this instance. However, there exists a network coding protocol with makespan $3$: Each source $s_{i}$ sends its input to its neighbor $S$ and all sinks $t_{j}$ for $i\neq j$ along the direct 3-hop path $s_{i}---t_{j}$. Node $S$ computes the XOR of all inputs, passes this XOR to $T$ who, in turn, passes this XOR to all sinks $t_{j}$, allowing each sink $t_{j}$ to recover its source $s_{j}$’s packets by canceling all other terms in the XOR.

One can still recover a valid general (i.e., coding) lower bound by an appropriate strengthening of 1.4: one has to require that all sources be far from all sinks in the edge-deleted graph. This contrast serves as a good mental model for the differences between coding and routing protocols.

Lemma 1.5**.**

Let $\mathcal{M}=(G,\mathcal{S})$ be a simple $k$-unicast instance. Suppose that after deleting some edges $F\subseteq E$, any sink is at distance at least $T$ from any source; i.e., $\forall\boldsymbol{i},\boldsymbol{j}\in[k]$ we have $\textrm{dist}_{G\setminus F}(\boldsymbol{s_{i}},\boldsymbol{t_{j}})\geq T$. Then any (network coding) protocol for $\mathcal{M}$ has makespan at least $\min\left\{T,k/|F|\right\}$.

Proof.

We can assume all sources can share information among themselves for free (e.g., via a common controlling entity) since this makes the multiple-unicast instance strictly easier to solve; similarly, suppose that the sinks can also share information. Suppose that some coding protocol has makespan $T^{\prime}<T$. Then all information shared between the sources and the sinks has to pass through some edge in $F$ at some point during the protocol. However, these edges can pass a total of $|F|\cdot T^{\prime}$ packets of information, which has to be sufficient for the total of $k$ source packets. Therefore, $|F|\cdot T^{\prime}\geq k$, which can be rewritten as $T^{\prime}\geq k/|F|$. The makespan is therefore at least $T^{\prime}\geq\min\{T,k/|F|\}$. ∎

Unfortunately, 1.5 is not always tight and it is instructive to understand when this happens. One key example is the previously-mentioned instance studied in the influential distributed computing papers [56, 20, 18] (described in Figure 2), where congestion and dilation both play key roles. Informally, this network was constructed precisely to give an $\tilde{\Omega}(\sqrt{n})$ makespan lower bound (leading to the pervasive $\tilde{\Omega}(\sqrt{n}+D)$ lower bound for many global problems in distributed computing [18]). The intuitive way to explain the $\tilde{\Omega}(\sqrt{n})$ lower bound is to say that one either has to communicate along a path of length $\sqrt{n}$ or all information needs to shortcut significant distance over the tree, which forces all information to pass through near the top of the tree, implying congestion of $\tilde{\Omega}(\sqrt{n})$. 1.5, however, can at best certify a lower bound of $\tilde{\Omega}(n^{1/4})$ for this instance. That is, this lemma’s (coding) makespan lower bound can be polynomially far from the optimal coding protocol’s makespan.

A more sophisticated argument is needed to certify the $\tilde{\Omega}(\sqrt{n})$ lower bound for this specific instance. The aforementioned papers [20, 18, 56] prove their results by implicitly using the technique we formalize as our moving cut in the following definition and lemma (proven in Section 2.1).

Definition 1.6**.**

*(Moving cut)

Let $G=(V,E)$ be a communication network with capacities $c:E\rightarrow\mathbb{Z}_{\geq 1}$ and let $\{(s_{i},t_{i})\mid i\in[k]\}$ be source-sink pairs. A moving cut is an assignment $\ell:E\to\mathbb{Z}_{\geq 1}$ of positive integer lengths to edges of $G$. We say the moving cut has capacity $C$, if $\sum_{e\in E}c_{e}(\ell_{e}-1)=C$, and distance $T$, if all sinks and sources are at distance at least $T$ with respect to $\ell$; i.e., $\forall i,j\in[k]$ we have $d_{\ell}(s_{i},t_{j})\geq T$.*

Lemma 1.7**.**

Let $\mathcal{M}=(G,\mathcal{S})$ be a unicast instance which admits a moving cut $\ell$ of capacity strictly less than $\sum_{i\in[k]}d_{i}$ and distance $T$. Then any (coding) protocol for $\mathcal{M}$ has makespan at least $T$.

1.7 can be seen as a natural generalization of 1.5, which can be equivalently restated in the following way: “Suppose that after increasing each edge $e$’s length from one to $\ell_{e}\in\{\boldsymbol{1},\boldsymbol{T+1}\}$, we have that (1) $\sum_{e\in E}c_{e}(\ell_{e}-1)<\sum_{i=1}^{k}d_{i}$, and (2) $\textrm{dist}_{\ell}(s_{i},t_{j})\geq T$. Then any (coding) protocol $\mathcal{M}$ has makespan at least $T$”. Dropping the restriction on $\ell_{e}$ recovers 1.7.

Strikingly, the moving cut technique allows us not only to prove tight bounds (up to polylog factors) for the instance of Figure 2—it allows us to get such tight bounds for every multiple-unicast instance. In order to upper bound the makespan coding gap, we therefore relate such a moving cut with the optimal routing makespan, as follows.

To characterize the optimal routing makespan, we study hop-bounded multicommodity flow, which is an LP relaxation of routing protocols of makespan $T$. First, we show that a fractional LP solution of high value to this LP implies a routing with makespan $O(T)$. Conversely, if the optimal value of this LP is low, then by strong LP duality this LP’s dual has a low-valued solution, which we us to derive a moving cut and lower bound the coding makespan. Unfortunately, the dual LP only gives us bounds on (average) distance between source-sink pairs $(s_{i},t_{i})$, and not between all sources $s_{i}$ and sinks $t_{j}$ (including $j\neq i$), as needed for moving cuts. For this conversion to work, we prove a generalization of the main theorem of Arora, Rao and Vazirani [7] to general metrics, of possible independent interest. (See Section 2.3.) This allows us to show that a low-valued dual solution implies a moving cut certifying that no coding protocol has makespan less than $T/O(\log k\cdot\log(\sum_{i}d_{i}/\min_{i}d_{i}))$. As the above rules out low-valued optimal solutions to the LP for $T=T^{*}\cdot O(\log k\cdot\log(\sum_{i}d_{i}/\min_{i}d_{i}))$ with $T^{*}$ the optimal coding makespan, the LP must have high optimal value, implying a routing protocol with makespan $O(T)$, and thus our claimed upper bound on the makespan coding gap.

1.3.2 Lower Bounding the Coding Gap

To complement our polylogarithmic upper bound on the makespan gap, we construct a family of multiple-unicast instances $\mathcal{M}$ that exhibit a polylogarithmic makespan coding gap. We achieve this by amplifying the gap via graph products, a powerful technique that was also used in prior work to construct extremal throughput network coding examples [11, 51, 12]. Here we outline this approach, as well as the additional challenges faced when trying to use this approach for makespan.

We use a graph product introduced by Braverman et al. [12] (with some crucial modifications). Braverman et al. [12] use their graph product to prove a conditional throughput coding gap similar to the one of 1.3, conditioned on the (unknown) existence of a multiple-unicast instance ${I}$ with non-trivial throughput coding gap. The graph product of [12] takes instances ${I}_{1},{I}_{2}$ and intuitively replaces each edge of ${I}_{1}$ with a source-sink pair of a different copy of ${I}_{2}$. More precisely, multiple copies of ${I}_{1}$ and ${I}_{2}$ are created and interconnected. Edges of a copy of ${I}_{1}$ are replaced by the same session of different copies of ${I}_{2}$; similarly, sessions of a copy of ${I}_{2}$ replace the same edge in different copies of ${I}_{1}$. This product allows for coding protocols in ${I}_{1}$ and ${I}_{2}$ to compose in a straightforward way to form a fast coding protocol in the product instance. The challenge is in proving impossibility results for routing protocols, which requires more care in the definition of the product graph.

To address this challenge, copies of instances are interconnected along a high-girth bipartite graph to prevent unexpectedly short paths from forming after the interconnection. For example, to prove a throughput routing impossibility result, Braverman et al. [12] compute a dual of the multicommodity flow LP (analogous to our LP, but without any hop restriction) to certify a limit on the routing performance. In the throughput setting, a direct tensoring of dual LP solutions of ${I}_{1}$ and ${I}_{2}$ gives a satisfactory dual solution of the product instance. In more detail, a dual LP solution in ${I}$ assigns a positive length $\ell_{{I}}(e)$ to each edge in ${I}$; each edge of the product instance corresponds to two edges $e_{1}\in{I}_{1}$ and $e_{2}\in{I}_{2}$, and the direct tensoring $\ell_{+}((e_{1},e_{2}))=\ell_{{I}_{1}}(e_{1})\cdot\ell_{{I}_{2}}(e_{2})$ provides a feasible dual solution with an adequate objective value. To avoid creating edges in the product distance of zero $\ell_{+}$-length, they contract edges assigned length zero in the dual LP of either instance. Unfortunately for us, such contraction is out of the question when studying makespan gaps, as such contractions would shorten the hop length of paths, possibly creating short paths with no analogues in the original instance.

Worse yet, any approach that uses the dual of our $T$-hop-bounded LP is bound to fail in the makespan setting. To see why, suppose we are given two instances ${I}_{1},{I}_{2}$, both of which have routing makespan at least $T$ and expect that the product instance ${I}_{+}$ to have routing makespan at least $T^{2}$ by some construction of a feasible dual LP solution. Such a claim cannot be directly argued since a source-sink path in the product instance that traverses, say, $T-1$ different copies of ${I}_{2}$ along a path of hop-length $T+1$ in ${I}_{2}$ could carry an arbitrary large capacity! This is since the hop-bounded LP solution on ${I}_{2}$ only takes short paths, of hop-length at most $T$, into account. Since there is no direct way to compose the dual LP solutions, we are forced to use a different style of analysis from the one of [12], which in turn forces our construction to become considerably more complicated.

To bound the routing makespan in the product instance we rely on 1.4: We keep a list of edges $F$ along with each instance and ensure that (i) all source-sink distances in the $F$-deleted instance are large and that (ii) the ratio of the number of sessions $k$ to $|F|$ is large. We achieve property (i) by interconnecting along a high-girth graph and treating the replacements of edges in $F$ in a special way (hence deviating from the construction of [12]). Property (ii) is ensured by making the inner instance ${I}_{2}$ significantly larger than the outer instance ${I}_{1}$, thus requiring many copies of ${I}_{1}$ and resulting in a large number of sessions in the product graph. To allow for this asymmetric graph product, we need an infinite number of base cases with non-trivial makespan coding gap for our recursive constructions (rather than a single base instance, as in the work of Braverman et al. [12]). This infinite family is fortunately obtained by appropriately generalizing the instance of Figure 1.

The main challenge in our approach becomes controlling the size of the product instance. To achieve this, we affix to each instance a relatively complicated set of parameters (e.g., coding makespan, number of edges, number of sessions, etc.) and study how these parameters change upon applying the graph product. Choosing the right set of parameters is key—they allow us to properly quantify the size escalation. In particular, we show that the coding gap grows doubly-exponentially and the size of the instances grow triply-exponentially, yielding the desired polylogarithmic coding gap.

1.4 Related Work

This work ties in to many widely-studied questions. We outline some of the most relevant here.

Routing multiple unicasts.

Minimizing the makespan of multiple unicasts using routing has been widely studied. When packets must be routed along fixed paths, two immediate lower bounds on the makespan emerge: dilation, the maximum length of a path, and congestion, the maximum number of paths crossing any single edge. A seminal result of Leighton et al. [45] proves one can route along such fixed paths in $O(\mathrm{congestion}+\mathrm{dilation})$ rounds, making the result optimal up to constants. Follow ups include works improving the constants in the above bound [55, 61], computing such protocols [46], simplifying the original proof [60], routing in distributed models [58, 53], and so on. When one has the freedom to choose paths, Bertsimas and Gamarnik [10] gave near-optimal routing solutions for asymptotically-large packet sizes, later extended to all packet sizes by Srinivasan and Teo [62]. The power of routing for multiple unicasts is therefore by now well understood.

Network coding gains.

The utility of network coding became apparent after Ahlswede et al. [5] proved it can increase the (single multicast) throughput of a communication network. Following their seminal work, there emerged a vast literature displaying the advantages of network coding over routing for various measures of efficiency in numerous communication models, including for example energy usage in wireless networks [64, 24, 22], delay minimization in repeated single unicast[15, 63], and makespan in gossip protocols [19, 27, 26]. The throughput of a single multicast (i.e., one single node sending to some set of nodes), arguably the simplest non-trivial communication task, was also studied in great detail (e.g., [5, 47, 4, 33, 49, 35]). In particular, Agarwal and Charikar [4] showed that the throughput coding gap for a single multicast equals the integrality gap of natural min-weight Steiner tree relaxations, for which non-trivial bounds were known (see, e.g., [67, 29]). While the throughput coding gap for a single multicast is now fairly well understood, the case of multiple senders seems to be beyond the reach of current approaches.

Throughput gaps for multiple unicasts.

The routing throughput for multiple unicasts is captured by multicommodity max-flow, while the coding throughput is clearly upper bounded by the sparsest cut. Known multicommodity flow-cut gap bounds therefore imply the throughput coding gap for $k$ unicasts is at most $O(\log k)$ [50, 9], and less for special families of instances [59, 44, 17, 42, 14, 39, 16]. In 2004 Li and Li [48] and Harvey et al. [32] independently put forward the multiple-unicast conjecture, which asserts that the throughput coding gap is trivial (i.e., it is one). This conjecture was proven true for numerous classes of instances [34, 52, 37, 41, 2]. More interestingly, a positive resolution of this conjecture has been shown to imply unconditional lower bounds in external memory algorithm complexity [2, 21], computation in the cell-probe model [2], and (recently) an $\Omega(n\log n)$ circuit size lower bound for multiplication of $n$-bit integers [3] (matching an even more recent breakthrough algorithmic result for this fundamental problem [30]). Given this last implication, it is perhaps not surprising that despite attempts by many prominent researchers [37, 31, 66, 48, 65, 43, 6], the conjecture remains open and has established itself as a notoriously hard open problem. Indeed, even improving the $O(\log k)$ upper bound on throughput coding gaps seems challenging, and would imply unconditional super-linear circuit size lower bounds, by the work of Afshani et al. [3]. Improving our upper bound on makespan coding gaps to $o(\log k)$ would directly imply a similar improvement for throughput coding gaps, together with these far-reaching implications.

2 Upper Bounding the Coding Gap

In this section we prove 1.2, upper bounding the makespan network coding gap. Given a multiple-unicast instance $\mathcal{M}$ we thus want to upper bound its routing makespan and lower bound its coding makespan. To characterize these quantities we start with a natural hop-bounded multicommodity flow LP, ConcurrentFlowM$(T)$, which serves as a “relaxation” of routing protocols of makespan at most $T$. The LP, given in Figure 3, requires sending a flow of magnitude $z\cdot d_{i}$ between each source-sink pair $(s_{i},t_{i})$, with the additional constraints that (1) the combined congestion of any edge $e$ is at most $T\cdot c_{e}$ where $c_{e}$ is the capacity of the edge (as only $c_{e}$ packets can use this edge during any of the $T$ time steps of a routing protocol), and (2) the flow is composed of only short paths, of at most $T$ hops. Specifically, for each $i\in[k]$, we only route flow from $s_{i}$ to $t_{i}$ along paths in $\mathcal{P}_{i}(T)\triangleq\{p:s_{i}{\rightsquigarrow}t_{i}\mid|p|\leq T,\,p\text{ is simple}\}$, the set of simple paths of hop-length at most $T$ connecting $s_{i}$ and $t_{i}$ in $G$.

A routing protocol solving $\mathcal{M}$ in $T$ rounds yields a solution to ConcurrentFlowM($T$) of value $z=1$, almost by definition.111Such a protocol must send $d_{i}$ packets along paths of length at most $T$ between each sour-sink pair $(s_{i},t_{i})$, and it can send at most $c_{e}$ packets through each edge $e$ during any of the $T$ rounds, or at most $c_{e}\cdot T$ packets overall. A partial converse is also true; a feasible solution to ConcurrentFlowM($T$) of value at least $\Omega(1)$ implies a routing protocol for $\mathcal{M}$ in time $O(T)$. This can be proven using standard LP rounding [62] and $O(\textrm{congestion + dilation})$ path routing [45]. (See Appendix C.)

Proposition 2.1**.**

Let $z,\{f_{i}(p)\mid i\in[k],p\in\mathcal{P}_{i}(T)\}$ be a feasible solution for ConcurrentFlowM$(T)$. Then there exists an integral routing protocol with makespan $O(T/z)$.

Complementing the above, we show that a low optimal LP value for ConcurrentFlowM$(T)$ implies that no coding protocol can solve the instance in much less than $T$ time.

Lemma 2.2**.**

If the optimal value of ConcurrentFlowM$(T)$ is at most $z^{*}\leq 1/10$, then the coding makespan for $\mathcal{M}$ is at least $T/(C\cdot\log(k)\cdot\log\left(\sum_{i}d_{i}/\min_{i}d_{i}\right))$ for some constant $C>0$.

Before outlining our approach for proving 2.2, we show why this lemma together with 2.1 implies our claimed upper bound for the makespan network coding gap. See 1.2

Proof.

Fix a multiple-unicast instance $\mathcal{M}$. Let $T^{*}$ be the minimum makespan for any coding protocol for $\mathcal{M}$. Let $T=(C+1)\cdot T^{*}\cdot(\log(k)\cdot\log(\sum_{i}d_{i}/\min_{i}d_{i}))$ for $C$ as in 2.2. Then, the LP ConcurrentFlowM$(T)$ must have optimal value at least $z^{*}\geq 1/10$, else by 2.2 and our choice of $T$, any coding protocol has makespan at least $T/O(\log(k)\cdot\log(\sum_{i}d_{i}/\min_{i}d_{i}))>T^{*}$, contradicting the definition of $T^{*}$. But then, by 2.1, there exists a routing protocol with makespan $O(T/z^{*})=O(T^{*}\cdot\log(k)\cdot\log(\sum_{i}d_{i}/\min_{i}d_{i})$. The theorem follows. ∎

The remainder of the section is dedicated to proving 2.2. That is, proving that a low optimal value for the LP ConcurrentFlowM$(T)$ implies a lower bound on the makespan of any coding protocol for $\mathcal{M}$. To this end, we take a low-valued LP solution to the dual LP CutM$(T)$ (implied by strong LP duality) and use it to obtain an information-theoretic certificate of impossibility, which we refer to as a moving cut. Section 2.1 introduces a framework to prove such certificates of impossibility, which we show completely characterizes any instance’s makespan (up to polylog terms). We then explain how to transform a low-value dual LP solution to such a moving cut in Section 2.2. For this transformation, we prove a lemma reminiscent of Arora et al. [7, Theorem 1] for general metrics, in Section 2.3.

2.1 Moving Cuts: Characterizing Makespan

In this section we prove that moving cuts characterize the makespan of a multiple unicast instance. For ease of reference, we re-state the definition of moving cuts.

See 1.6

We start by proving 1.7, whereby moving cuts with small capacity and large distance imply makespan lower bounds.

See 1.7

Proof.

We will show via simulation that a protocol solving $\mathcal{M}$ in at most $T-1$ rounds would be able to compress $\sum_{i=1}^{k}d_{i}$ random bits to a strictly smaller number of bits, thereby leading to a contradiction. Our simulation proceeds as follows. We have two players, Alice and Bob, who control different subsets of nodes. In particular, if we denote by $A_{r}\triangleq\{v\in V\mid\min_{i}\textrm{dist}_{\ell}(s_{i},v)\leq r\}$ the set of nodes at distance at most $r$ from any source, then during any round $r\in\{0,1,\ldots,T-1\}$ all nodes in $A_{r}$ are “spectated” by Alice. By spectated we mean that Alice gets to see all of these nodes’ private inputs and received transmissions during the first $r$ rounds. Similarly, Bob, at time $r$, spectates $B_{r}\triangleq V\setminus A_{r}$. Consequently, if at round $r$ a node $u\in V$ spectated by Alice sends a packet to a node $v\in V$, then Bob will see the contents of that packet if and only if Bob spectates the node $v$ at round $r+1$. That is, this happens only if $u\in A_{r}$ and $v\in B_{r+1}=V\setminus A_{r+1}$. Put otherwise, Bob can receive a packet from Alice along edge $e$ during times $r\in[\min_{i}\textrm{dist}_{\ell}(s_{i},u),\min_{i}\textrm{dist}_{\ell}(s_{i},v)-1]$. Therefore, the number of rounds transfer can happen along edge $e$ is at most $\min_{i}\textrm{dist}_{\ell}(s_{i},v)-\min_{i}\textrm{dist}_{\ell}(s_{i},u)-1\leq\ell_{e}-1$. Hence, the maximum number of bits transferred from Alice to Bob via $e$ is $c_{e}(\ell_{e}-1)$. Summing up over all edges, we see that the maximum number of bits Bob can ever receive during the simulation is at most $\sum_{e\in E}c_{e}(\ell_{e}-1)<\sum_{i=1}^{k}d_{i}$. Now, suppose Alice has some $\sum_{i=1}^{k}d_{i}$ random bits. By simulating this protocol with each source $s_{i}$ having (a different) $d_{i}$ of these bits, we find that if all sinks receive their packet in $T$ rounds, then Bob (who spectates all $t_{j}$ at time $T-1$, as $\min_{i}\textrm{dist}_{\ell}(s_{i},t_{j})\geq T$ for all $j$) learns all $\sum_{i=1}^{k}d_{i}$ random bits while receiving less than $\sum_{i=1}^{k}d_{i}$ bits from Alice—a contradiction. ∎

1.7 suggests the following recipe for proving makespan lower bounds: Prove a lower bound on the makespan of some sub-instance ${\mathcal{M}}^{\prime}=(G,{\mathcal{S}}^{\prime})$ with $\mathcal{S}^{\prime}\subseteq\mathcal{S}$ induced by indices $I\subseteq[k]$ using 1.7. As any protocol solving $\mathcal{M}$ solves $\mathcal{M}^{\prime}$, a lower bound on the makespan of $\mathcal{M}^{\prime}$ implies a lower bound on the makespan of $\mathcal{M}$. So, to prove makespan lower bounds for $\mathcal{M}$, identify a moving cut for some sub-instance of $\mathcal{M}$. If this moving cut has capacity less than the sum of demands of the sub-instance and distance at least $T$, then the entire instance, $\mathcal{M}$, has makespan at least $T$.

By the above discussion, the worst distance of a (low capacity) moving cut over any sub-instance serves as a lower bound on the makespan of any instance. The following lemma, whose proof is deferred to the end of Section 2.2, asserts that in fact, the highest distance of a moving cut over any sub-instance is equal (up to polylog terms) to the best routing makespan of $\mathcal{M}$. Consequently, by 1.2, the strongest lower bound obtained using moving cuts is equal up to polylog terms to the optimal (coding) makespan for $\mathcal{M}$.

Lemma 2.3**.**

If a $k$-unicast instance $\mathcal{M}$ has no routing protocol with makespan $T$, then there exists a set of sessions $I\subseteq[k]$ with a moving cut of capacity strictly less than $\sum_{i\in I}d_{i}$ and distance at least $T/O(\log k\cdot(\sum_{i}d_{i}/\min_{i}d_{i}))$ with respect to the unicast sub-instance induced by $I$.

We now turn to leveraging moving cuts to prove makespan lower bounds. Specifically, 2.2.

2.2 From Dual Solution to Moving Cut

2.1 shows that high objective value for the primal LP, ConcurrentFlowM($T$) implies an upper bound on the routing time for the given instance. In this section we prove the “converse”, 2.2, whereby low objective value of the primal LP implies a lower bound on the coding time for the given instance.

Our approach will be to prove that a low objective value of the primal LP —implying a feasible dual LP solution of low value—yields a moving cut for some sub-instance. This, by 1.7, implies a lower bound on protocols for this sub-instance, and thus for the entire instance, from which we obtain 2.2. We turn to converting a low-valued dual LP solution to such a desired moving cut.

By definition, a low-value feasible solution to the dual LP, CutM$(T)$, assigns non-negative lengths $\ell:E\to\mathbb{R}_{\geq 0}$ such that (1) the $c$-weighted sum of $\ell$-lengths is small, i.e., $\sum_{e\in E}c_{e}\ell_{e}=\tilde{O}(1/T)$, as well as (2) if $h_{i}$ is the $\ell$-length of the $T$-hop-bounded $\ell$-shortest path between $s_{i}$ and $t_{i}$, then $\sum_{i\in[k]}d_{i}\cdot h_{i}\geq 1$. Property (1) implies that appropriately scaling the lengths $\ell$ yields a moving cut given by lengths $\tilde{\ell}$ of bounded capacity, $\sum_{e}c_{e}\tilde{\ell}_{e}$. For this moving cut to be effective to lower bound the makespan of some sub-instance using 1.7, the cut must have high distance w.r.t. this sub-instance. As a first step to this end, we use Property (2) to identify a subset of source-sink pairs $I\subseteq[k]$ with pairwise $\tilde{\ell}$-distance at least $\tilde{\Omega}(T)$. 2.4, proven in Appendix C using a “continuous” bucketing argument, does just this. The claim introduces a loss factor ${\alpha_{\mathrm{gap}}}$ that we use throughout this section.

Claim 2.4**.**

Given sequences $h_{1},\ldots,h_{k},d_{1},\ldots,d_{k}\in\mathbb{R}_{\geq 0}$ with $\sum_{i\in[k]}d_{i}\cdot h_{i}\geq 1$ there exists a non-empty subset $I\subseteq[k]$ with $\min_{i\in I}h_{i}\geq\frac{1}{{\alpha_{\mathrm{gap}}}\cdot\sum_{i\in I}d_{i}}$ for ${\alpha_{\mathrm{gap}}}\in\left[1,O\left(\log\frac{\sum_{i\in[k]}d_{i}}{\min_{i\in[k]}d_{i}}\right)\right]$.

Scaling up the $\ell$ lengths yields a sub-instance induced by pairs $I\subseteq[k]$ and moving cut with bounded capacity and with $\tilde{\ell}$-distance between every source and its sink of at least $\tilde{\Omega}(T)$, i.e., $d_{\tilde{\ell}}(s_{i},t_{i})\geq\tilde{\Omega}(T)$ for all $i\in I$. However, 1.7 requires $\tilde{\ell}$-distance $\tilde{\Omega}(T)$ between any source and sink, i.e., $d_{\tilde{\ell}}(s_{i},t_{j})\geq\tilde{\Omega}(T)$ for all $i,j\in I$. To find a subset of source-sink pairs with such distance guarantees, we rely on the following metric decomposition lemma, whose proof is deferred to Section 2.3.

Lemma 2.5**.**

Let $(X,d)$ be a metric space. Given $n$ pairs $\{(s_{i},t_{i})\}_{i\in[n]}$ of points in $X$ with at most $k$ distinct points in $\bigcup_{i}\{s_{i},t_{i}\}$ and pairwise distances at least $d(s_{i},t_{i})\geq T$, there exists a subset of indices $I\subseteq[n]$ of size $|I|\geq\frac{n}{9}$ such that $d(s_{i},t_{j})\geq\frac{T}{O(\log k)}$ for all $i,j\in I$. Moreover, such a set can be computed in polynomial time.

We are now ready to construct the moving cut.

Lemma 2.6**.**

If the optimal value of ConcurrentFlowM$(T)$ is at most $z^{*}\leq 1/10$, then there exists $\tilde{I}\subseteq[k]$ and a moving cut ${\tilde{\ell}}$ of capacity strictly less than $\sum_{i\in{\tilde{I}}}d_{i}$ and distance at least $T/O({\alpha_{\mathrm{gap}}}\log k)$ with respect to the unicast sub-instance induced by $\tilde{I}$ (i.e., $\tilde{\mathcal{M}}=(G,\tilde{\mathcal{S}})$ where $\tilde{\mathcal{S}}=\{(s_{i},t_{i},d_{i})\}_{i\in{\tilde{I}}}$).

Proof.

By strong duality, the dual LP CutM$(T)$ has a feasible solution $\{h_{i},\ell_{e}\mid i\in[k],e\in E\}$ to CutM$(T)$ with objective value $T\sum_{e\in E}c_{e}\ell_{e}=z^{*}$. Fix such a solution. Let $I\subseteq[k]$ be a subset of indices as guaranteed by 2.4. Define ${\tilde{\ell}}_{e}\triangleq 1+\lfloor\ell_{e}\cdot T\cdot\sum_{i\in I}d_{i}\rfloor$ for all $e\in E$ and note that ${\tilde{\ell}}_{e}\in\mathbb{Z}_{\geq 1}$. By definition of ${\tilde{\ell}}$ and $T\sum_{e}c_{e}\ell_{e}=z$, we get a bound on the capacity of ${\tilde{\ell}}$:

[TABLE]

We now show that $d_{{\tilde{\ell}}}(s_{i},t_{i})>T/{\alpha_{\mathrm{gap}}}$ for all $i\in I$. Consider any simple path $p$ between $s_{i}{\rightsquigarrow}t_{i}$. Denote by ${\tilde{\ell}}(p)$ and $\ell(p)$ the length with respect to ${\tilde{\ell}}$ and $\ell$, respectively. It is sufficient to show that ${\tilde{\ell}}(p)>T/{\alpha_{\mathrm{gap}}}$. If $p\not\in\mathcal{P}_{i}(T)$, i.e., the hop-length of $p$ (denoted by $|p|$) is more than $T$. Then ${\tilde{\ell}}(p)\geq|p|>T\geq T/{\alpha_{\mathrm{gap}}}$, since ${\tilde{\ell}}_{e}\geq 1\ \forall e\in E$. Conversely, if $p\in\mathcal{P}_{i}(T)$, then by our choice of $I$ as in 2.4 and the definition of $h_{i}$, we have that $\ell(p)\geq h_{i}\geq\frac{1}{{\alpha_{\mathrm{gap}}}\sum_{i\in I}d_{i}}$, hence

[TABLE]

Finally, we choose a subset ${\tilde{I}}\subseteq I$ s.t. $d_{{\tilde{\ell}}}(s_{i},t_{j})>T/O({\alpha_{\mathrm{gap}}}\log k)$ for all $i,j\in{\tilde{I}}$. By 2.5 applied to the graphic metric defined by ${\tilde{\ell}}$ and each pair $(s_{i},t_{i})$ repeated $d_{i}$ times, there exists a multiset of indices ${\tilde{I}}\subseteq I\subseteq[k]$ such that $d_{{\tilde{\ell}}}(s_{i},t_{j})\geq T/O({\alpha_{\mathrm{gap}}}\log k)$ for all $i,j\in{\tilde{I}}$ and such that $|{\tilde{I}}|\geq\sum_{i}d_{i}/9$. Therefore, taking each pair $(s_{i},t_{i})$ indexed by ${\tilde{I}}$ at least once, we find a subset of sessions ${\tilde{I}}\subseteq[k]$ such that $\sum_{i\in{\tilde{I}}}d_{i}\geq\frac{1}{9}\sum_{i\in[k]}d_{i}>\sum_{e}c_{e}\cdot({\tilde{\ell}}_{e}-1)$ and $d_{{\tilde{\ell}}}(s_{i},t_{j})\geq T/O({\alpha_{\mathrm{gap}}}\log k)$ for all $i,j\in{\tilde{I}}$. In other words, ${\tilde{\ell}}$ is a moving cut of capacity strictly less than $\sum_{i\in{\tilde{I}}}d_{i}$ and distance $T/O({\alpha_{\mathrm{gap}}}\log k)$ with respect to the sub-instance induced by ${\tilde{I}}$. ∎

Combining 2.6 with 1.7, we obtain this section’s main result, 2.2.

See 2.2

Remark 1.

We note that the $\log k$ term in 2.2’s bound is due to the $\log k$ term in the bound of 2.5. For many topologies, including genus-bounded and minor-free networks, this $\log k$ term can be replaced by a constant (see Section 2.3), implying smaller makespan gaps for such networks.

Remark 2.

2.3, which states that a lower bound on routing makespan implies the existence of a moving cut of high distance with respect to some sub-instance, follows by 2.6 and 2.1, as follows. By 2.1, $\mathcal{M}$ having no routing protocol with makespan $T$ implies that for some constant $c>0$, the LP ConcurrentFlowM($c\cdot T$) has objective value at most $1/10$. 2.6 then implies the existence of the moving cut claimed by 2.3.

2.3 From Pairwise to All-Pairs Distances

This section is dedicated to a discussion and proof of the following Lemma that seems potentially useful beyond the scope of this paper.

See 2.5

We note that the above lemma is similar to the main Theorem of Arora et al. [7]. Our result holds for general metrics with a factor of $O(\log k)$ in the distance loss, while their holds for $\ell_{2}^{2}$ metrics with a factor of $O(\sqrt{\log k})$. The results are incomparable and both are tight. (The tightness of 2.5 can be shown to be tight for graph metrics, for example in graph metrics of constant-degree expanders.)

To prove 2.5 we rely on padded decompositions [25]. To define these, we introduce some section-specific notation. Let $(X,\textrm{dist})$ be a metric space. Let the (weak) diameter of a set of points $U\subseteq X$ be denoted by ${\mathrm{diam}}(U)\triangleq\max_{x,y\in U}\textrm{dist}(x,y)$. We say a partition $P=\{X_{1},X_{2},\dots,X_{t}\}$ of $X$ is $\Delta$-bounded if ${\mathrm{diam}}(X_{i})\leq\Delta$ for all $i$. Next, for $U\subseteq X$ and a partition $P$ as above, we denote by $U\subseteq P$ the event that there exists a part $X_{i}\in P$ containing $U$ in its entirety; i.e., $U\subseteq X_{i}$. Let $B(x,\rho)\triangleq\{y\in X\mid\textrm{dist}(x,y)\leq\rho\}$ denote the ball of radius $\rho\geq 0$ around $x\in X$.

Definition 2.7**.**

Let $(X,\textrm{dist})$ be a metric space. We say that a distribution $\mathcal{P}$ over $\Delta$-bounded partitions of $X$ is $(\beta,\Delta)$-padded if, for some universal constant $\delta$, it holds that for every $x\in X$ and $0\leq\gamma\leq\delta$,

[TABLE]

In words, each part of the partition has diameter at most $\Delta$ and the probability of any point $x$ in the metric being at distance less than $\gamma\Delta$ from a different part than its own part is at most $\beta\gamma$. Such decompositions were presented, for example, by Gupta et al. [25].

Lemma 2.8** ([25]).**

Any metric $(X,\textrm{dist})$ on $k$ points admits a $(\beta,\Delta)$-padded decomposition, for any $\Delta>0$ and some $\beta=O(\log k)$. Such a decomposition can be computed in polynomial time.

We are now ready to prove 2.5.

Proof of 2.5.

First note that we can focus on the metric space induced by the $k$ distinct points. Let $\mathcal{P}$ be a $\Delta$-bounded $\beta$-padded decomposition with $\Delta=T-1$ and $\beta=O(\log k)$. We first note that for all $i\in[k]$, $s_{i}$ and $t_{i}$ are contained in different parts since the diameter of each part $X_{i}$ is at most $\Delta=T-1$ and $\textrm{dist}(s_{i},t_{i})\geq T$. Furthermore, letting $\gamma=\frac{1}{2\beta}$, we have that $\Pr[B(s_{i},\gamma\Delta)\subseteq P]\geq\frac{1}{2}$. Let $I^{\prime}\subseteq[n]$ be the subset of indices $i$ with $B(s_{i},\gamma\Delta)\subseteq P$. Then we have $\Pr[i\in I^{\prime}]\geq\frac{1}{2}$ for all $i\in[n]$.

Flip a fair and independent coin for each part in $P$. Let $U\subseteq X$ be the set of points in parts whose coin came out heads, and $V\subseteq X$ be the analogous set for tails. Then for each $i\in I^{\prime}$ we have that $\Pr[s_{i}\in U\text{ and }t_{i}\in V]=\frac{1}{4}$. Let $I\subseteq I^{\prime}$ be the subset of indices $i$ with $s_{i}\in U\text{ and }t_{i}\in V$, giving $\Pr[i\in I]=\Pr[i\in I^{\prime}]\cdot\Pr[i\in I\mid i\in I^{\prime}]=\frac{1}{2}\cdot\frac{1}{4}=\frac{1}{8}\ \forall i\in[n]$. We also have that $\textrm{dist}(s_{i},t_{j})>\rho=\frac{T-1}{2\beta}$ for all $i,j\in I$, since $B(s_{i},\rho)\subseteq U$ for all $i\in I\subseteq I^{\prime}$ and $\{t_{j}\}_{j\in I}\cap U=\emptyset$. Therefore, this random process yields a subset of indices $I\subseteq[n]$ such that $\textrm{dist}(s_{i},t_{j})>\frac{T-1}{2\beta}$ for all $i,j\in I$, of expected size at least $\mathbb{E}[|I|]\geq\sum_{i\in[n]}\Pr[i\in I]\geq\frac{n}{8}$. As $n-\mathbb{E}[|I|]$ is a non-negative random variable, Markov’s inequality implies that with constant probability $n-|I|\leq\frac{64}{63}\cdot(n-\mathbb{E}[|I|])\leq\frac{8n}{9}$. The lemma follows. ∎

Remark: The $O(\log k)$ term in 2.5’s bound is precisely the smallest possible $\beta$ for which $(\beta,\Delta)$-padded decompositions of the metric exist. For many graphic metrics, such as those of minor-excluded, bounded-genus, and bounded-doubling-dimension networks, padded decompositions with smaller $\beta$ exist [44, 25, 1]. This improves the bounds of 2.5 and thus 2.2 by $(\log k)/\beta$, implying the same improvement for our makespan coding gaps for such networks.

3 Polylogarithmic Coding Gap Instances

In this section we construct a family of multiple-unicast instances with polylogarithmic makespan coding gap. More precisely, we construct instances where the coding gap is at least $(5/3)^{2^{i}}$ and the size (both the number of edges and sessions) is bounded by $2^{2^{O(2^{i})}}$. Here we give a bird’s eye view of the construction and leave the details to subsequent subsections. We clarify that all big-O bounds like $f=O(g)$ mean there exists a universal constant $c>0$ s.t. $f\leq c\cdot g$ for all admissible values (in particular, there is no assumption on $f$ or $g$ being large enough).

We use the graph product of [12] as our main tool. Given two multiple-unicast instances ${I}_{1},{I}_{2}$ (called the outer and inner instance, resp.) we create a new instance ${I}_{+}$ where the coding gap is the product of the coding gaps of ${I}_{1}$ and ${I}_{2}$. The product is guided by a colored bipartite graph $B=(V_{1},V_{2},E)$ where each edge is labeled by $(\chi_{1},\chi_{2})=$ (edge in ${I}_{1}$, session in ${I}_{2}$). Precisely, we create $|V_{1}|$ copies of ${I}_{1}$, $|V_{2}|$ copies of ${I}_{2}$ and for each edge $(a,b)\in E(B)$ with label $(\chi_{1},\chi_{2})$ we replace the edge $\chi_{1}$ in the $a^{th}$ copy of ${I}_{1}$ with session $\chi_{2}$ in the $b^{th}$ copy of ${I}_{2}$.

To prove a lower bound on the coding gap, one needs to upper bound the coding makespan and lower bound the coding makespan. The former is easy: the coding protocols nicely compose. The latter, however, is more involved. Our main tool is 1.4, which necessitates (i) keeping track of cut edges $F$ along each instance ${I}$ such that all source-sink pairs of ${I}$ are well-separated after edges in $F$ are deleted, and (ii) keeping the ratio $r\triangleq\frac{k}{|F|}$, number of sessions to cut edges, high. We must ensure that the properties are conserved in the product instance ${I}_{+}$. For (i), i.e., to disallow any short paths from forming as an unexpected consequence of the graph product, we choose $B$ to have high girth. Also, we replace edges $F$ in the outer instances with paths rather than connecting them to a session in the inner instance. Issue (ii) is somewhat more algebraically involved but boils down to ensuring that the ratio of sessions to cut edges (i.e., $r$) in the inner instance is comparable to the size (i.e., number of edges) of the outer instance itself. Note that makes the size of the outer instance ${I}_{1}$ insignificant when compared to the size of the inner instance ${I}_{2}$.

We recursively define a family of instances by parametrizing them with a “level” $i\geq 0$ and a lower bound on the aforementioned ratio $r$, denoting them by $I(i,r)$. We start for $i=0$ with the $\nicefrac{{5}}{{3}}$ instance of Figure 1 where we can control the ratio the aforementioned ratio $r$ by changing the number of sessions $k$ (at the expense of increasing the size). Subsequently, an instance on level $i$ is defined as a product two of level $i-1$ instances with appropriately chosen parameters $r$. One can show that the coding makespan for a level $i$ instance is at most $5^{2^{i}}$ and routing makespan is at least $3^{2^{i}}$, hence giving a coding gap of $(5/3)^{2^{i}}$. Furthermore, we show that the size of $I(i,r)$ is upper bounded by $r^{2^{O(2^{i})}}$, giving us the full result.

Finally, we note an important optimization to our construction and specify in more detail how $I(i,r)$ is defined. Specifically, it is defined as the product of ${I}_{1}\triangleq I(i-1,3r)$ being the outer instance and ${I}_{2}\triangleq I(i-1,m_{1}/f_{1})$ being the inner instance, where $m_{1}$ and $f_{1}$ are the number of total and cut edges of ${I}_{1}$. This necessitates the introduction and tracking of another parameter $u\triangleq m/f$ to guide the construction. We remark that this might be necessary since if one uses a looser construction of ${I}_{2}\triangleq I(i-1,m_{1})$ the end result $I(i,r)$ would be of size $r^{2^{O(i\cdot 2^{i})}}$ and give a coding gap of $\exp\left(\frac{\log\log k}{\log\log\log k}\right)$, just shy of a polylogarithm.

3.1 Gap Instances and Their Parameters

In this section we formally define the set of instance parameters we will track when combining the instances.

A gap instance ${I}=(G,\mathcal{S},F)$ is a multiple-unicast instance $\mathcal{M}=(G,\mathcal{S})$ over a connected graph $G$, along with an associated set of cut edges $F\subseteq E(G)$. We only consider gap instances where the set of terminals is disjoint, i.e., $s_{i}\neq s_{j},s_{i}\neq t_{j},t_{i}\neq t_{j}$ for all $i\neq j$. Furthermore, edge capacities and demands are one; i.e., $c_{e}=1\ \forall e\in E(G)$, and $d_{i}=1\ \forall(s_{i},t_{i},d_{i})\in\mathcal{S}$. A gap instance ${I}=(G,\mathcal{S},F)$ has parameters $(a,b,f,k,m,r,u)$ when:

• •

$\mathcal{M}$ admits a network coding protocol with makespan at most $a$.

• •

Let $\textrm{dist}_{G\setminus F}(\cdot,\cdot)$ be the hop-distance in $G$ after removing all the cut edges $F$. Then for all terminals $i\in[k]$ we have that $\textrm{dist}_{G\setminus F}(s_{i},t_{i})\geq b$.

• •

The number of cut edges is $f=|F|$.

• •

The number of sessions is $k=|\mathcal{S}|$.

• •

The graph $G$ has at most $m$ edges; i.e., $|E(G)|\leq m$.

• •

$r$ is a lower bound on the ratio between number of sessions and cut edges; i.e., $k/f\geq r$.

• •

$u$ is an upper bound on the ratio between number of total edges and cut edges; i.e., $m/f\leq u$.

We note that the parameters of a gap instance immediately imply a lower bound on the optimal routing makespan via 1.4. Indeed, all packets transmitted in the first $b-1$ rounds must pass through $F$, and thus at most $f\cdot(b-1)$ packets can be sent between any source and its sink in the first $b-1$ rounds, implying that under any routing protocol, most sessions have completion time at least $b$.

Observation 3.1**.**

Let ${I}$ be a gap instance with parameters $(a,b,f,k,m,r,u)$ and $b\leq r$. Then the routing makespan for $(G,\mathcal{S})$ is at least $b$. Moreover, for any routing protocol of ${I}$, at least $k\cdot(1-\frac{b-1}{r})$ sessions have completion time at least $b$.

As an application of the above observation, we obtain another proof of the lower bound of the routing makespan for the family of instances of Figure 1. More generally, letting the cut edges be the singleton $F=\{(S,T)\}$, we obtain a family of gap instances with the following parameters.

Fact 3.2**.**

The family of gap instances of Figure 1 have parameters $(3,5,1,k,\theta(k^{2}),k,\theta(k^{2}))$ for $k\geq 5$.

The above family of gap instances will serve as our base gap instances in a recursive construction which we describe in the following section.

3.2 Graph Product of Two Gap Instances

In this section we present the graph product that combines two instances to obtain one a with higher coding gap.

Definition 3.3**.**

Colored bipartite graphs are families of bipartite graphs $\mathcal{B}({n_{1},n_{2},m,k,g})$. Graphs $B=(V_{1},V_{2},E)\in\mathcal{B}({n_{1},n_{2},m,k,g})$ are bipartite graphs with $|V_{1}|=n_{1}$ (resp. $|V_{2}|=n_{2}$) nodes on the left (resp., right), each of degree $m$ (resp., $k$), and these graphs have girth at least $g$. In addition, edges of $B$ are colored using two color functions, edge color $\chi_{1}:E(B)\rightarrow[m]$ and session color $\chi_{2}:E(B)\rightarrow[k]$, which satisfy the following.

• •

$\forall v\in V_{1}$, the edge colors of incident edges form a complete set $\{\chi_{1}(e)\mid e\ni v\}=[m]$.

• •

$\forall v\in V_{2}$, the session colors of incident edges form a complete set $\{\chi_{2}(e)\mid e\ni v\}=[k]$.

• •

$\forall v\in V_{1}$, the session colors of incident edges are unique $|\{\chi_{2}(e)\mid e\ni v\}|=1$.

• •

$\forall v\in V_{2}$, the edge colors of incident edges are unique, i.e, $|\{\chi_{1}(e)\mid e\ni v\}|=1$.

The size of the colored bipartite graphs will determine the size of the derived gap instance obtained by performing the product along a colored bipartite graph. The following gives a concrete bound on the size and, in turn, allows us to control the growth of the gap instances obtained this way.

Lemma 3.4** ([12]).**

$\forall r,m,g\geq 3$, there exists a colored bipartite graph $B\in\mathcal{B}(n_{1},n_{2},m,k,2g)$ with $n_{1},n_{2}\leq(9mk)^{g+3}$.

Performing the product along a colored bipartite graph.

Having defined colored bipartite graphs, we are now ready to define the graph product of ${I}_{1}$ and ${I}_{2}$ along $B$.

For $i\in\{1,2\}$ let ${I}_{i}=(G_{i},\mathcal{S}_{i},F_{i})$ be a gap instance with parameters $(a_{i},b_{i},f_{i},k_{i},m_{i},r_{i},u_{i})$ and let $B\in\mathcal{B}(n_{1},n_{2},2(m_{1}-f_{1}),k_{2},g)$ be a colored bipartite graph with girth $g\triangleq 2b_{1}b_{2}$. We call ${I}_{1}$ the outer instance and ${I}_{2}$ the inner instance. Denote the product gap instance ${I}_{+}\triangleq T({I}_{1},{I}_{2},B)$ by the following procedure:

• •

Replace each non-cut edge $e=\{u,v\}\in E(G_{1})\setminus F_{1}$ with two anti-parallel arcs \vec{e}=(u,v),\reflectbox{\vec{\reflectbox{$e$}}}=(v,u) and let $\vec{E}(G_{1})=\{\vec{e}_{1},\vec{e}_{2},\ldots,\vec{e}_{2(m_{1}-f_{1})}\}$ be the set of all such arcs.

• •

Construct $n_{1}$ copies of $(V(G_{1}),\vec{E}(G_{1}))$ and $n_{2}$ copies of $G_{2}$. Label the $i^{th}$ copy as $G_{1}^{(i)}$ and $G_{2}^{(i)}$.

• •

Every cut edge $e\in F_{1}$ and every $i\in[n_{1}]$ replace edge $e$ in $G_{1}^{(i)}$ by a path of length $a_{2}$ with the same endpoints. Let $f_{e}^{(i)}$ be an arbitrary edge on this replacement path.

• •

For every $(i,j)\in E(B)$ where $i\in[n_{1}],j\in[n_{2}]$ with edge color $\chi_{1}$ and session color $\chi_{2}$ do the following. Let $\vec{e}^{(i)}_{\chi_{1}}=(x,y)$ be the $\chi_{1}$th arc in $G_{1}^{(i)}$ and let $(s,t)$ be the $\chi_{2}$th terminal pair in $G_{2}^{(j)}$. Merge $x$ with $s$ and $y$ with $t$; delete $\vec{e}^{(i)}_{\chi_{1}}=(x,y)$ from $G_{1}^{(i)}$.

• •

For each session in the outer instance $(s_{i},t_{i},d_{i}=1)\in\mathcal{S}_{1}$ add a new session $(s_{i}^{(j)},t_{i}^{(j)},1)$ in $G_{1}^{(j)}$ for $j\in[n_{1}]$ to the product instance.

• •

The cut edges $F_{+}$ in the product instance ${I}_{+}$ consist of the the union of the following: (i) one arbitrary (for concreteness, first one) edge from all of the $a_{2}$-length paths that replaced cut edges in $G_{1}^{(i)}$, i.e., $\{f_{e}^{(i)}\mid e\in F_{1},i\in[n_{1}]\}$, and (ii) all cut edges in copies of $G_{2}$, i.e., $\{e^{(i)}\mid e\in F_{2},i\in[n_{2}]\}$.

We now give bounds on how the parameters change after combining two instances. First, we note that by composing network coding protocols for ${I}_{1}$ and ${I}_{2}$ in the natural way yields a network coding protocol whose makespan is at most the product of these protocols’ respective makespans.

Lemma 3.5**.**

(Coding makespan) The product instance ${I}_{+}$ admits a network coding protocol with makespan at most $a_{1}a_{2}$.

Less obviously, we show that if we choose a large enough girth $g$ for the colored bipartite graph, we have that the $b$ parameter of the obtained product graph is at least the product of the corresponding $b$ parameters of the inner and outer instances.

Lemma 3.6** (Routing makespan).**

Let ${I}_{+}=(G_{+},\mathcal{S}_{+},F_{+})$ be the product instance using a colored bipartite graph $B$ of girth $g\triangleq 2b_{1}b_{2}$ and let $\textrm{dist}_{G_{+}\setminus F_{+}}(\cdot,\cdot)$ be the hop-distance in $G_{+}$ with all the edges of $F_{+}$ deleted. We have that $\textrm{dist}_{G_{+}\setminus F_{+}}(s_{i},t_{i})\geq\min(b_{1}b_{2},\frac{g}{2})=b_{1}b_{2}$ for all $(s_{i},t_{i},d_{i})\in\mathcal{S}_{+}$.

Proof.

Let $p$ be a path in $G_{+}\setminus F_{+}$ between some terminals $s_{i}{\rightsquigarrow}t_{i}$ that has the smallest hop-length among all $(s_{i},t_{i},d_{i})\in\mathcal{S}_{+}$. We want to show that $|p|\geq\min(b_{1}b_{2},\frac{g}{2})$.

First, let $q$ be the path in the colored bipartite graph $B$ that corresponds to $p$. There are some technical issues with defining $q$ since merging vertices in the graph product has the consequence that some $v\in V(G_{+})$ belong to multiple nodes $V(B)$. To formally specify $q$, we use the following equivalent rephrasing of the graph product that will generate an “expanded instance” $G_{+}^{\prime}$. Instead of “merging” two vertices $u,v$ as in $G_{+}$, connect then with an edge $e$ of hop-length $h(e)=0$ and add $e$ to $G_{+}^{\prime}$. Edges from $G_{+}$ have hop-length $h(e)=1$ and are analogously added to $G_{+}^{\prime}$. The path $p$ can be equivalently specified as the path between $s_{i}{\rightsquigarrow}t_{i}$ in $G_{+}^{\prime}\setminus F_{+}$ that minimizes the distance $\textrm{dist}_{h}(s_{i},t_{i})$. Now, each vertex $V(G_{+}^{\prime})$ belongs to exactly one vertex $V(B)$, hence the path $q$ in $B$ corresponding to $p$ is well-defined. Note that $p$ is a closed path in $G_{+}$ and $q$ is a closed path in $B$.

Suppose that $q$ spans a non-degenerate cycle in $B$. Then $|p|\geq\frac{|q|}{2}\geq\frac{g}{2}$, where the last inequality $|q|\geq g$ is due to the girth of $G$. The first inequality $|p|\geq\frac{|q|}{2}$ is due to the fact that when $q$ enters a node $v\in V_{2}(B)$, a node representing an inner instance, the corresponding path $p$ had to traverse at least one inner instance edge before its exit since the set of terminals is disjoint and a path can enter/exit inner instances only in terminals.

Suppose now that $q$ does not span a cycle in $B$, therefore the set of edges in $q$ span a tree $\mathcal{T}$ in $B$ and $q$ is simply the (rotation of the unique) Eulerian cycle of that tree. Notation-wise, let $v\in V_{1}(B)$ be the node in the colored bipartite graph $B$ that contains the critical terminals $s_{i}$ and $t_{i}$ and suppose that $\mathcal{T}$ is rooted in $v$. If the depth of $\mathcal{T}$ is $1$ (i.e., consists only of $v\in V_{1}(B)$ and direct children $w_{1},\ldots,w_{t}\in V_{2}(B)$), then $p$ must correspond to a $s_{i}{\rightsquigarrow}t_{i}$ walk in $v$, where each (non-cut) edge traversal is achieved by a non-cut walk in the inner instance $w_{j}$ between a set of inner terminals. Note that every $s_{i}{\rightsquigarrow}t_{i}$ non-cut walk has hop-length at least $b_{1}$ and each non-cut walk in the inner instance has hop-length at least $b_{2}$, for a cumulative $b_{1}\cdot b_{2}$.

Finally, suppose that $\mathcal{T}$ has depth more than $1$, therefore there exists two $v,w\in V(\mathcal{T})$ and $v,w\in V_{1}(B)$. Since $\mathcal{T}$ is traversed via an Eulerian cycle, the path $p$ passes through two terminals of $(s_{j},t_{j},\cdot)\in\mathcal{S}_{+}$. Let $p^{\prime}$ be the natural part of $p$ going from $s_{j}{\rightsquigarrow}t_{j}$, e.g., obtained by clipping the path corresponding to the subtree of $q$ in $\mathcal{S}$. Furthermore, let $p^{\prime\prime}$ be the part of the $p$ connecting $v$ and $w$ and is disjoint from $p^{\prime\prime}$. From the last paragraph we know that $|p^{\prime\prime}|\geq 1$ since it passes through at least one $u\in V_{2}(B)$. Also, by minimality of $s_{i}{\rightsquigarrow}t_{i}$ we have that $\textrm{dist}_{h}(s_{j},t_{j})\geq\textrm{dist}_{h}(s_{i},t_{i})$. Now we have a contradiction since $\textrm{dist}_{h}(s_{i},t_{i})=|p|\geq|p^{\prime}|+|p^{\prime\prime}|\geq 1+\textrm{dist}_{h}(s_{j},t_{j})$. ∎

Combining Lemmas 3.5 and 3.6 together with some simple calculations (deferred to Appendix D), we find that the product instance is a gap instance with the following parameters.

Lemma 3.7**.**

For $i\in\{1,2\}$ let ${I}_{i}=(G_{i},\mathcal{S}_{i},F_{i})$ be a gap instance with parameters $(a_{i},b_{i},f_{i},k_{i},m_{i},r_{i},u_{i})$ with $\frac{m_{i}}{f_{i}}\geq 2$ and $a_{i}\geq 2$; let $B\in\mathcal{B}(n_{1},n_{2},2(m_{1}-f_{1}),k_{2},2b_{1}b_{2})$ be a colored bipartite graph. Then ${I}_{+}\triangleq T(G_{1},G_{2},B)$ is a gap instance with parameters $a_{+}\triangleq a_{1}a_{2}$, $b_{+}\triangleq b_{1}b_{2}$, $f_{+}\triangleq n_{1}f_{1}+n_{2}f_{2}$, $k_{+}\triangleq n_{1}k_{1}$, $m_{+}\triangleq a_{2}n_{1}f_{1}+n_{2}m_{2}$, $r_{+}\triangleq r_{1}\frac{1}{1+2u_{1}/r_{2}}$, $u_{+}\triangleq u_{2}\frac{1+a_{2}/2}{1+r_{2}/(2u_{1})}$. Moreover, $\frac{m_{+}}{f_{+}}\geq 2$ and $a_{+}\geq 2$.

3.3 Iterating the Graph Product

Having bounded the parameters obtained by combining two gap instances, we are now ready to define a recursive family of gap instances from which we obtain our polylogarithmic makespan network coding gap.

Definition 3.8**.**

We recursively define a collection of gap instances $({I}(i,r))_{i\geq 0,r\geq 5}$, and denote its parameters by $(a_{i,r},b_{i,r},f_{i,r},k_{i,r},m_{i,r},r_{i,r},u_{i,r})$. For the base case, we let ${I}(0,r)$ be the gap instance of 3.2 with parameters $(3,5,1,r,\theta(r^{2}),r,\theta(r^{2}))$. For $i+1>0$ we define ${I}(i+1,r)\triangleq T({I}_{1},{I}_{2})$. Here, ${I}_{1}\triangleq{I}(i,3r)$ and ${I}_{2}\triangleq{I}(i,u_{i,3r})$, with parameters $(a_{1},\ldots,u_{1})$ and $(a_{2},\ldots,u_{2})$, respectively.

In other words, ${I}_{1}$ is defined such that $r_{1}=3r_{+}$ and ${I}_{2}$ such that $r_{2}=u_{1}$. In Appendix D we study the growth of the parameters of our gap instance families. Two parameters that are easy to bound for this construction are the following.

Observation 3.9**.**

For any $i\geq 0$ and $r\geq 5$, we have $a_{i,r}=3^{2^{i}}$ and $b_{i,r}=5^{2^{i}}$.

A less immediate bound, whose proof is also deferred to Appendix D, is the following bound on the number of edges of the gap instances..

Lemma 3.10**.**

We have that $\log m_{i,r}\leq 2^{O(2^{i})}\log r$ for all $i\geq 0,r\geq 5$.

3.4 Lower Bounding the Coding Gap

We are now ready to prove this section’s main result – a polylog$(k)$ makespan coding gap. See 1.3

Proof.

For each $i\geq 0$ and $r\triangleq 5^{2^{i}}$, consider ${I}_{i,r}$ as defined above. By 3.9 this gap instance has coding makespan at most $a_{i,r}=3^{2^{i}}$. Moreover, also by 3.9, this instance has $b_{i,r}=5^{2^{i}}$, and so by 3.1 its routing makespan is at least $5^{2^{i}}$. Hence the makespan coding gap of ${I}_{i,r}$ is at least $(5/3)^{2^{i}}$. It remains to bound this gap in terms of $k\triangleq k_{i.r}$.

As the terminals of ${I}_{i,r}$ are disjoint, we have that $k$ is upper bounded by the number of nodes of ${I}_{i,r}$, which is in turn upper bounded by $m_{i,r}$, as ${I}_{i,r}$ is connected and not acyclic. That is, $k\leq m_{i,r}$. But by 3.10, we have that $\log m_{i,r}\leq 2^{O(2^{i})}\cdot\log r=2^{O(2^{i})}\cdot O(2^{i})\leq 2^{O(2^{i})}\leq 2^{c^{\prime}\cdot 2^{i}}$, for some universal constant $c^{\prime}>0$. Therefore, stated in terms of $k$, the makespan coding gap is at least

[TABLE]

where $c\triangleq\frac{\log 5/3}{c^{\prime}}>0$ is a universal constant, as claimed. ∎

4 Coding Gaps for Other Functions of Completion Times

In this section we extend our coding gap results to other time complexity measures besides the makespan. For our upper bounds, we show that our coding gaps for $\ell_{\infty}$ minimization of the completion times (makespan) implies similar bounds for a wide variety of functions, including all weighted $\ell_{p}$ norms; proving in a sense that $\ell_{\infty}$ is the “hardest” norm to bound. The following lemma underlies this connection.

Lemma 4.1**.**

Let $\alpha$ be an upper bound on the coding gap for completion times’ $\ell_{\infty}$ norm (makespan). Then, if multiple-unicast instance $\mathcal{M}$ admits a coding protocol with completion times $(T_{1},T_{2},\dots,T_{k})$, there exists a routing protocol for $\mathcal{M}$ with completion times placewise at most $(4\alpha\cdot T_{1},4\alpha\cdot T_{2},\dots,4\alpha\cdot T_{k})$.

Proof.

Let $\mathcal{M}$ be a multiple-unicast instance. Let $(T_{1},T_{2},\dots,T_{k})$ be the vector of completion times of some coding protocol. Without loss of generality, assume $T_{1}\leq T_{2}\leq\dots\leq T_{k}$. Next, for any $j\in\mathbb{Z}$, denote by $\mathcal{M}_{j}$ the sub-instance of $\mathcal{M}$ induced by the unicasts with completion time $T_{i}\in[2^{j},2^{j+1})$. Then, there exists a network coding protocol for each $\mathcal{M}_{j}$ with makespan at most $2^{j+1}$. Consequently, there exists a routing protocol for $\mathcal{M}_{j}$ with makespan at most $\alpha\cdot 2^{j+1}$. Scheduling these protocols in parallel, in order of increasing $j=0,1,2,\dots,$ we find that a unicast with completion time $T_{i}\in[2^{j},2^{j+1})$ in the optimal coding protocol has completion time in the obtained routing protocol which is at most

[TABLE]

Note that unlike our routing protocols for makespan minimization of 1.2, the proof here is non-constructive, as it assumes (approximate) knowledge of the completion times of each unicast in the optimal coding protocol. Nonetheless, this proof guarantees the existence of a protocol, which suffices for our needs. In particular, applying 4.1 to the coding protocol minimizing a given weighted $\ell_{p}$ norm, we immediately obtain the following.

Corollary 4.2**.**

Let $\alpha$ be an upper bound on the coding gap for completion times’ $\ell_{\infty}$ norm (makespan). Then the coding gap for any weighted $\ell_{p}$ norm of the completion times is at most $4\alpha$.

Plugging in our coding gap upper bound of 1.2, we therefore obtain a generalization of 1.2 to any weighted $\ell_{p}$ norm, as well as average completion time (which corresponds to $\ell_{1}$).

Theorem 4.3**.**

The network coding gap for any weighted $\ell_{p}$ norms of completion times is at most

[TABLE]

Note that similar bounds hold even more generally. In particular, for any sub-homogeneous function of degree $d$ (i.e., $f(c\cdot\vec{x})\leq c^{d}\cdot f(\vec{x})$, 4.1 implies a coding gap of at most $(4\alpha)^{d}$, where $\alpha$ is the best upper bound on the coding gap for makespan minimization.

Lower bounds.

As with makespan minimization, a polylogarithmic dependence in the problem parameters as in 4.3, as we prove below. Crucially, we rely on our makespan coding gap’s examples displaying the property that under coding nearly all unicast sessions’ completion time is at least polylogarithmically larger than under the best coding protocol.

Theorem 4.4**.**

There exists an absolute constant $c>0$ and an infinite family of $k$-unicast instances whose $\ell_{p}$-coding gap is at least $\Omega(\log^{c}k)$.

Proof.

We follow the proof of 1.3 and consider $I_{i,r}$, this time setting $r\triangleq(5^{2^{i}})^{2}=5^{2^{i+1}}$. This does not change the parameters $a_{i,r}=3^{2^{i}}$ and $b_{i,r}=5^{2^{i}}$, nor the bound $\alpha\triangleq(5/3)^{2^{i}}\geq\log^{c}k$ for some absolute constant $c>0$. This instance has a coding protocol with completion times $(a_{i,r},\ldots,a_{i,r})$, and so this coding protocol’s completion times’ $\ell_{p}$ value is $a_{i,r}$. On the other hand, by 3.1, at least $k\cdot(1-\frac{b_{i,r}}{r})\geq(1-o(1))\cdot k$ pairs have routing completion time at least $b_{i,r}$, where $o(1)$ tends to [math] as $i\to\infty$. Consequently, the $\ell_{p}$-value of any routing protocol’s completion times is at least $(1-o(1))\cdot b_{i,r}$. Since $b_{i,r}/a_{i,r}=\alpha\geq\log^{c}k$, we obtain the required coding gap. ∎

5 Conclusions and Open Questions

In this paper we study completion-time coding gaps; i.e., the ratio for a given multiple-unicast instance, of the fastest routing protocol’s completion time to the fastest coding protocol’s completion time. We provide a strong characterization of these gaps in the worst case, showing they can be polylogarithmic in the problem parameters, but no greater. The paper raises a few exciting questions and research directions.

Probably the most natural question is to close our upper and lower bounds. We show that the network coding gap is polylogarithmic, but what polylog? Another question, motivated by the super-constant speedups we prove coding can achieve over routing for this basic communication problem, is whether there exist efficient algorithms to compute the fastest coding protocol, mirroring results known for the fastest routing protocols for multiple unicasts [45, 46], and for the highest-throughput coding protocols for multicast [36]. Another natural question is extending this study of network coding gaps for completion times to other widely-studied communication problems, such as multiple multicasts.

Implications to other fields.

As discussed in Section 1 and Section 1.4, the conjectured non-existence of throughput coding gaps for multiple unicast has been used to prove (conditional) lower bounds in many seemingly-unrelated problems. It would be interesting to see whether our upper and lower bounds on the coding gap for multiple unicasts’ completion times can be used to prove unconditional lower bounds for other models of computation. We already have reason to believe as much; using techniques developed in this paper, combined with many other ideas, the authors have obtained the first non-trivial universal lower bounds in distributed computation. It would be interesting to see what other implications this work might have to other areas of Theory. Perhaps most exciting would be to investigate whether completion-time coding gaps imply new results in circuit complexity for depth-bounded circuits.

Acknowledgements

The authors would like to thank Mohsen Ghaffari for suggesting an improvement to 1.2 which resulted in a coding gap independent of $n$, Anupam Gupta for pointing out a simplification of 2.5 and the Lemma’s similarity to [7, Theorem 1], and Paritosh Garg for bringing [12] to our attention.

Appendix

Appendix A Completion Time vs. Throughput

In this section we argue why network coding upper bounds for makespan imply coding gaps for throughput maximization. We first introduce the standard definitions of the throughput maximization model [2, 12]. The differences between the throughput and completion-time model (see Section 1.1) are highlighted in blue.

Throughput maximization model. A multiple-unicast instance $\mathcal{M}=(G,\mathcal{S})$ is defined over a communication network, represented by an undirected graph $G=(V,E,c)$ with capacity $c_{e}\in\mathbb{Z}_{\geq 1}$ for each edge $e$. The $k\triangleq|\mathcal{S}|$ sessions of $\mathcal{M}$ are denoted by $\mathcal{S}=\{(s_{i},t_{i},d_{i})\}_{i=1}^{k}$. The (maximum) throughput of $\mathcal{M}$ is the supremum $r>0$ such that there exists a sufficiently large $b>0$ where the following problem has a correct protocol. Each session consists of source node $s_{i}$, which wants to transmit a packet to its sink $t_{i}$, consisting of {\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\lceil r\cdot b\cdot d_{i}\rceil} sub-packets (e.g., an element of an underlying field). A protocol for a multiple-unicast instance is conducted over finitely-many synchronous time steps. Initially, each source $s_{i}$ knows its packet, consisting of $d_{i}$ sub-packets. At any time step, the protocol instructs each node $v$ to send a different packet along each of its edges $e$. The packet contents are computed with some predetermined function of packets received in prior rounds by $v$ or originating at $v$. The total number of sub-packets sent through an edge $e$ over the duration of the entire protocol is at most $b\cdot c_{e}$. We differentiate the maximum throughput achievable by coding and routing protocols as $r^{C}$ and $r^{R}$, respectively. The throughput coding gap is the largest ratio $r^{C}/r^{R}$ that can be achieved for any instance.

Relating completion times and throughput. The throughput maximization intuitively corresponds to the makespan minimization of an instance with asymptotically-large packet sizes. More formally, we modify a multiple unicast instance $\mathcal{M}$ by increasing its demands by a factor of $w$ while keeping the capacities the same. This causes the makespan to increase. We argue that the slope of the increase with respect to $w$ is exactly the throughput of $\mathcal{M}$.

Definition A.1**.**

Given a multiple-unicast instance $\mathcal{M}$ we define $C^{C}(w)$ and $C^{R}(w)$ to be the makespan of the fastest coding and routing protocols when the all demands are multiplied by a common factor $w$.

Observation A.2**.**

Let $\mathcal{M}$ be a multiple-unicast instance. The maximum throughput $r$ corresponding to $\mathcal{M}$ is equal to $\sup_{w\to\infty}w/C(w)$ for both coding and routing. Formally, $r^{C}=\sup_{w\to\infty}w/C^{C}(w)$ and $r^{R}=\sup_{w\to\infty}w/C^{R}(w)$.

Proof.

We drop the R/C superscripts since the proof holds for both without modification. Let $L\triangleq\sup_{w\to\infty}w/C(w)$. We first argue that $L\geq r$, i.e., we can convert a throughput protocol to a makespan-bounded one. For simplicity, we will assume that $b=1$ ($b$ from the throughput definition); when this is not the case one needs to appropriately re-scale the sub-packets for the completion-time protocol.

Let $\mathcal{T}$ be a protocol of throughput at least $r-o(1)$ and let $T$ be the total number of rounds $\mathcal{T}$ uses (note that in the throughput setting $T$ has no impact on the quality of $\mathcal{T}$). Let $w\in\mathbb{Z}$ be a sufficiently large number. We use pipelining by scheduling $w^{\prime}\triangleq w/(r-o(1))$ independent copies of $\mathcal{T}$: the first one starting at time $1$, second at time $2$, …, last one at time $w^{\prime}$. Each copy operates on a separate set of sub-packets, with the pipelined protocol being able to transmit $(r-o(1))\cdot d_{i}\cdot w^{\prime}=d_{i}\cdot w$ sub-packets across the network (in line with A.1) in at most $w^{\prime}+T$ rounds. Note that $\mathcal{T}$ sends at most $c_{e}$ sub-packets over an edge $e$ over its entire execution, hence the pipelined version of $\mathcal{T}$ never sends more than $c_{e}$ sub-packets during any one round. In other words, we have that $C(w)\leq w^{\prime}+T$. Letting $w\to\infty$ (which implies $w^{\prime}\to\infty$), we have that

[TABLE]

We now argue the converse $r\geq L$, i.e., we can convert a completion-time protocol into a throughput protocol with the appropriate rate. The result essentially follows by definition. By assumption, for some sufficiently large $w>0$ there exists a protocol with makespan at most $C(w)\leq w/(L-o(1))$. The protocol sends a total of at most $C(w)c_{e}$ sub-packets over an edge $e$. Furthermore, by construction of $C(w)$, each source-sink pair successfully transmits $w\cdot d_{i}$ sub-packets. By noting that $w\cdot d_{i}=(L-o(1))C(w)d_{i}$, we conclude that by using $b\triangleq C(w)$ we get a protocol with rate $L-o(1)$. ∎

Corollary A.3**.**

Suppose that the makespan coding gap is at most $\alpha$ (over all instances). Then the throughput coding gap is at most $\alpha$.

Proof.

Consider some multiple unicast instance $\mathcal{M}$, with coding throughput $r$. By A.2, for sufficiently large $w$ there is a coding protocol $\mathcal{P}_{1}$ satisfying $w/C^{C}(w)\geq r-o(1)$, i.e., $C^{C}(w)\leq w/(r-o(1))$. By the makespan coding gap assumption, there exists a routing protocol $\mathcal{P}_{2}$ implying that $C^{R}(w)\leq\alpha\cdot w/(r-o(1))$. Furthermore, following the proof of A.2, protocol $\mathcal{P}_{2}$ implies a routing throughput of $r^{\prime}$ for the original instance $\mathcal{M}$, satisfying

[TABLE]

In other words, $r/r^{\prime}\geq\alpha+o(1)$ and we are done. ∎

Appendix B Network Coding Model for Completion Time

In this section we formalize the $k$-session unicast communication problem and the notion of completion time for it. We note that our model is not new—e.g., it is equivalent to the models of Chekuri et al. [15], Wang and Chen [63] that study delay in communication networks.

The input to a $k$-session unicast problem $(G,\mathcal{S})$ consists of a graph $G=(V,E,c)$, where edges have capacities $c:E\to\mathbb{R}_{\geq 0}$, and a set of $k$ sessions $\mathcal{S}=\{(s_{i},t_{i},d_{i})\}_{i=1}^{k}$. Each triplet $(s_{i},t_{i},d_{i})$ corresponds to the source $s_{i}\in V$, sink $t_{i}\in V$ and the demand $d_{i}\in\mathbb{R}_{\geq 0}$ of session $i$. The graph $G$ can be either directed or undirected, where in the latter case we model an undirected edge $e$ as two directed edges \vec{e},\reflectbox{\vec{\reflectbox{$e$}}} where both of them have equal capacity c(\vec{e})=c(\reflectbox{\vec{\reflectbox{$e$}}})=c_{e}.222Papers such as Adler et al. [2] often impose an alternative condition c(\vec{e})+c(\reflectbox{\vec{\reflectbox{$e$}}})=c(e), which would make our proofs slightly heavier on notation. However, their convention can only impact the results up to a factor of 2, which we typically ignore in this paper.

Each source $s_{i}$ is privy to an input message $m_{i}\in M_{i}$ generated by an arbitrary stochastic source with entropy at least $d_{i}$, hence the entropy of the random variable $m_{i}$ is $d_{i}$. The sources corresponding to different sessions are independent.

A $T$-round network coding computation consists of a set of $|E|\times T$ coding functions $\{f_{\vec{e},r}:M\to\Gamma\}_{\vec{e}\in E,1\leq r\leq T}$, where $\Gamma$ is some arbitrary alphabet and $M\triangleq\prod_{i}M_{i}$. These functions satisfy the following properties:

• •

The entropy of any coding function $f_{\vec{e},r}$ never exceeds the edge capacity $c(\vec{e})$, i.e., $H(f_{\vec{e},r})\leq c(\vec{e})$ for all $\vec{e}\in E,1\leq r\leq T$.

• •

For each directed edge $\vec{e}=(u,v)\in E$ and round $1\leq r\leq T$ the function $f_{\vec{e},r}$ is computable from communication history received strictly before round $r$ at node $u$. In other words, let the communication history $Y_{u,r}$ be defined as $\{m_{i}\mid i\in[k],s_{i}=u\}\cup\{f_{(x,y),r^{\prime}}\mid y=u\text{ and }r^{\prime}<r\}$, then $H(f_{(u,v),r}|Y_{u,r})=0$.

• •

The completion times of a network coding computation are $(T_{1},T_{2},\ldots,T_{k})\in\mathbb{Z}_{\geq 0}^{k}$ when the following holds. For every session $i$, the message $m_{i}$ of the session $(s_{i},t_{i},d_{i})$ must be computable from the sink $t_{i}$’s history after $T_{i}$ rounds are executed, i.e., $H(m_{i}|Y_{t_{i},T_{i}+1})=0$.

Remark: The above “bare-bones” formalization is sufficient for all of our results to hold. However, such a formalization can be unwieldy since a complete instance description would also need to specify a stochastic distribution corresponding to each source $s_{i}$. A standard way of avoiding this issue is to simply assume the sources generate a uniformly random binary string of length $d_{i}$ (forcing $d_{i}$ to be an integer). Without going into too much detail, we mention this assumption can be made without loss of generality if we allow for (1) an arbitrarily small decoding error $\varepsilon>0$, (2) slightly perturbing the edge capacities $c_{e}$ and source entropies $d_{i}$ by $\varepsilon$, and (3) scaling-up both $c_{e}$’s and $d_{i}$’s by a common constant $b>0$; this approach is standard in the literature (e.g., see [2, 12]).

Appendix C Deferred Proofs of Section 2

In this section we provide proofs deferred from Section 2, starting with the proof of 2.1, restated here for ease of reference.

See 2.1 To prove the above, we rely on the celebrated $O(\textrm{congestion + dilation})$ packet scheduling theorem of Leighton et al. [45]. In particular, we use the solution to ConcurrentFlowM$(T)$ to obtain a collection of short paths with bounded congestion (i.e., bounded maximum number of paths any given edge belongs to). We then route along these paths in time proportional to these paths’ maximum length and congestion. The issue is that the feasible LP solution provides fractional paths, hence requiring us to round the LP solution. Independent rounding would result in paths of length $T$ and congestion $T/z+O(\log n)$ (with high probability). To avoid this additive dependence on $n$, we rely on the following theorem of Srinivasan and Teo [62].

Lemma C.1** ([62], Theorem 2.4, paraphrased).**

Let $\mathcal{M}$ be a multiple-unicast instance and for each $i\in[k]$ let $\mathcal{D}_{i}$ be a distribution over $s_{i}{\rightsquigarrow}t_{i}$ paths of hop-length at most $L$. Suppose that the product distribution $\prod\mathcal{D}_{i}$ has expected congestion for each edge at most $L$. Then there exists a sample $\omega\in\prod\mathcal{D}_{i}$ (i.e., a choice of a from $\mathcal{D}_{i}$ between each $s_{i}{\rightsquigarrow}t_{i}$) with (maximum) congestion $O(L)$.

Using the above lemma to round the LP and using Leighton et al. [45] path routing to route along the obtained paths yields 2.1.

Proof of 2.1.

Consider an optimal solution to this ConcurrentFlowM($T$). Clearly, picking for each pair $(s_{i},t_{i})$ some $d_{i}$ paths in $P_{i}(T)$ with each $p\in\mathcal{P}_{i}(T)$ picked with probability $f_{i}(p)\cdot d_{i}/\sum_{p\in\mathcal{P}_{i}(T)}f_{i}(p)\leq f_{i}(p)/z$ yields an expected congestion at most $T\cdot c_{e}/z$ for each edge $e$. That is, thinking of $G$ as a multigraph with $c_{e}$ copies per edge, each such parallel edge has congestion $T/z$. On the other hand, each such path has length at most $T\leq T/z$ (since $z\leq 1$). Therefore, by C.1, there exist choices of paths for each pair of (maximum) congestion and hop-bound (i.e., dilation) at most $O(T/z)$. But then, using $O(\mbox{congestion + dilation)}$ routing [45] this implies an integral routing protocol with makespan $O(T/z)$, as claimed. ∎

Here we prove 2.4, restated here for ease of reference.

See 2.4

Proof.

Suppose (without loss of generality) that $h_{1}\geq h_{2}\geq\ldots h_{k}$ and assume for the sake of contradiction that none of the sets $[1],[2],\ldots,[k]$ satisfy the condition. In other words, if we let $d([j])\triangleq\sum_{i=1}^{j}d_{j}$, then $h_{i}<\frac{1}{\alpha}\cdot\frac{1}{d([i])}$ for all $i\in[k]$. Multiplying both sides by $d_{i}$ and summing them up, we get that $1\leq\sum_{i=1}^{k}d_{i}h_{i}<\frac{1}{\alpha}\sum_{i=1}^{k}\frac{d_{i}}{d([i])}$. Reordering terms, this implies $\sum_{i=1}^{k}\frac{d_{i}}{d([i])}>\alpha$.

Define $f(x)$ as $1/d_{1}$ on $[0,d_{1})$; $1/(d_{1}+d_{2})$ on $[d_{1},d_{1}+d_{2})$; …; $1/d([i])$ on $[d([i-1]),d([i]))$ for $i\in[k]$. Now we have

[TABLE]

However, since $f(x)\leq 1/x$

[TABLE]

Hence by setting $\alpha\triangleq 1+\ln\frac{d([k])}{d_{1}}$ we reach a contradiction and finish the proof. ∎

Appendix D Deferred Proofs of Section 3

Here we provide the deferred proofs of lemmas of Section 3, restated below for ease of reference.

See 3.5

Proof.

Suppose there exists a network coding protocol with makespan $t_{i}\leq a_{i}$ that solves $(G_{i},\mathcal{S}_{i})$ for $i\in\{1,2\}$. Functionally, each round in the outer instance $(G_{1},\mathcal{S}_{1})$ consists of transmitting $c_{e}$ bits of data from $u$ to $v$ for all arcs $(u,v)$ where $\{u,v\}\in E(G_{1})$. This is achieved by running the full $t_{2}$ rounds of the inner instance protocol over all copies of the instances which pushes $d_{i}$ bits from $s_{i}$ to $t_{i}$ for all $(s_{i},t_{i},d_{i})$ and all copies of the inner instance. The reason why such inner protocol pushes the information across each arc $(u,v)$ is because $u$ is merged with some $s_{i}$, $v$ is merged with $t_{i}$, and with $d_{i}=c_{e}$ for some $(s_{i},t_{i},d_{i})\in\mathcal{S}_{2}$ and some copy of the inner instance. In conclusion, by running $t_{1}$ outer rounds, each consisting of $t_{2}$ inner rounds, we get a $t_{1}t_{2}\leq a_{1}a_{2}$ round protocol for the product instance. ∎

See 3.7

Proof of 3.7.

First, the set of terminals in the product instance ${I}_{+}$ is disjoint, as distinct terminals of copies of the outer instance ${I}_{1}$ have their edges associated with distinct terminals source-sink pairs of the inner instance ${I}_{2}$. Consequently, no two terminals of the outer instance are associated with the same node of the same copy of an inner instance. The capacities and demands of ${I}_{+}$ are one by definition. We now turn to bounding the gap instance’s parameters.

Parameters $a_{+}$ and $b_{+}$ are directly argued by 3.5 and 3.6. Furthermore, $f_{+},k_{+},m_{+}$ are obtained by direct counting, as follows.

Recall that the cut edges of the outer instance get replaced with a path of length $a_{2}$. Since there are $n_{1}$ copies of outer instances, each having $f_{1}$ cut edges, this contributes $a_{2}n_{1}f_{1}$ edges to $m_{+}$. The non-cut edges of the outer instance get deleted and serve as a merging directive, hence they do not contribute to $m_{+}$. Finally, each edge of the inner instance gets copied into ${I}_{+}$, contributing $n_{2}m_{2}$ as there are $n_{2}$ copies of the inner instance.

For $r_{+}$ we need to show it is a lower bound on $k_{+}/f_{+}$. We note that $|E(B)|=n_{1}\cdot 2(m_{1}-f_{1})=n_{2}k_{2}$ and proceed by direct calculation:

[TABLE]

For $u_{+}$ we need to show it is an upper bound on $m_{+}/f_{+}$. Note that $k_{2}\leq m_{2}$ since the set of terminals is disjoint and the graph is connected.

[TABLE]

Here the last inequality relies on $m_{1}/f_{1}\geq 2$ and on $k_{2}\leq m_{2}$, which follows from the set of terminals being disjoint and the graph $G_{2}$ being connected.

For the final technical conditions, note that $a_{+}\geq 2$ is clear from $a_{+}=a_{1}a_{2}\geq 4\geq 2$. Finally, $\frac{m_{+}}{f_{+}}\geq 2$ follows from the following.

[TABLE]

D.1 Upper Bounding $m_{i,r}$

For readability, we sometimes write $u(i,r)$ instead of $u_{i,r}$ and similarly for $m(i,r)$. Also, we note that the technical conditions $a_{i,r}\geq 2$ and $\frac{m_{i,r}}{f_{i,r}}\geq 2$, which clearly hold for $i=0$, hold for all $i>0$, due to 3.7. Finally, we note that by 3.7, since $r_{2}=u_{1}$ and $a_{2}\geq 1$, we have that $u_{+}\geq u_{2}$ and so for all gap instances in the family we have $u_{i,r}\geq u_{i-1,u(i-1,3r)}\geq 5$.

Lemma D.1**.**

The parameter of ${I}(i,r)$ for any $i\geq 0,r\geq 5$ satisfy the following.

1. (i)

$\frac{k_{i,r}}{f_{i,r}}\geq r$, 2. (ii)

$u_{i+1,r}\leq 3^{2^{i}}\cdot u_{i,u(i,3r)}$* and* 3. (iii)

$\log m(i+1,r)\leq O(5^{2^{i+1}})\cdot\log(m_{i,3r}\cdot m_{i,u(i,3r)})$.

Proof.

Claim i follows from 3.7, as follows.

[TABLE]

We now prove claims ii and iii. Fix $i,r$ and define ${I}_{1}\triangleq{I}(i,3r)$ (with parameters $(a_{1},\ldots,u_{1})$) and ${I}_{2}\triangleq{I}(i,u_{i,r})$ (with parameters $(a_{2},\ldots,u_{2})$). We have $u(i+1,r)=u_{2}\frac{1+a_{2}/2}{1+r_{2}/(2u_{1})}\leq u_{2}\frac{1+a_{2}/2}{1+1/2}\leq u_{2}\cdot a_{2}$ (3.7), with $a_{2}=a_{i,u(i,3r)}=3^{2^{i}}$ and $u_{2}=u(i,u(i,3r))$ from the iterated tensoring process. Therefore, we conclude that $u(i+1,r)\leq 3^{2^{i}}\cdot u_{i,u(i,3r)}$, as claimed.

We now prove Claim iii. The corresponding colored bipartite graph $B\in\mathcal{B}(n_{1},n_{2},2(m_{1}-f_{1}),k_{2},2b_{1}b_{2})$ used to produce the product ${I}_{i,r}$ has $\max(n_{1},n_{2})\leq(2(m_{1}-f_{1})k_{2})^{O(b_{1}b_{2})}$, by 3.4. Therefore, as $k_{2}\leq m_{2}$, we have that $\max(n_{1},n_{2})\leq(m_{1}\cdot m_{2})^{O(b_{1}b_{2})}$. This implies the following recurrence for $m_{i,r}$.

[TABLE]

Taking out logs, we obtain the desired bound.

[TABLE]

Given D.1 we obtain the bound on $u_{i,r}$ in terms of $i$ and $r$.

Lemma D.2**.**

We have that $\log u_{i,r}\leq 2^{O(2^{i})}\log r$ for all $i\geq 0,r\geq 5$.

Proof.

By D.1, we have the recursion $u(i+1,r)\leq 3^{2^{i}}\cdot u(i,u(i,3r))$ with initial condition $u(0,r)=O(r^{2})$, by 3.2. Taking out logs, we obtain $\log u(i+1,r)\leq O(2^{i})+\log u(i,u(i,3r))$ and $\log u(0,r)=O(\log r)$. We prove via induction that $\log u(i,r)\leq\frac{1}{c}(c^{2})^{2^{i}}\cdot\log r$ for some sufficiently large $c>0$. In the base case $\log u(0,r)=O(\log r)\leq\frac{1}{c}(c^{2})\log r=c\log r$. For the inductive step we have:

[TABLE]

where the last inequality holds for $i\geq 1$ and $r\geq 5$ and a sufficiently large $c>0$. ∎

Plugging in the bound of D.2 and D.1 we can prove inductively the upper bound on the number of edges of ${I}_{i,r}$ in terms of $i$ and $r$ given by 3.10, restated here. See 3.10

Proof.

By D.1, we have the recursion $\log m(i+1,r)\leq O(5^{2^{i+1}})\cdot\log(m_{i,3r}\cdot m_{i,u(i,3r)})$ with initial condition $\log m(0,r)=O(\log r)$, by 3.2. We prove via induction that $\log m_{i,r}\leq c^{2^{i}}\log r$ for a sufficiently large universal constant $c>0$. In the base case $\log m_{0,r}\leq O(\log r)\leq c\log r=c^{2^{0}}\log r$. For the inductive step, using D.2 to bound $\log u(i,3r)$, we have:

[TABLE]

where the last inequality holds for $i\geq 1$ and $r\geq 5$ and a sufficiently large $c>0$. ∎